diff options
| author |   Marcelo Tosatti <mtosatti@redhat.com> | 2012-05-15 18:33:21 -0300 |
|---|---|---|
| committer | Marcelo Tosatti <mtosatti@redhat.com> | 2012-05-15 18:33:21 -0300 |
| commit | a1fce560c0e5f287ed65d2aaadb3e59578aaa983 (patch) | |
| tree | 1e6826248db1b67a82b2d1f41aace6931bb36201 | |
| parent | e54f008ef8f968cfc2f3ecab78491d180fa31efc (diff) | |
| parent | 8877b5ab9b56c42eb629860f3e8a4ea6d675b5fb (diff) | |
Merge branch 'upstream-merge'qemu-kvm-1.1-rc2
* upstream-merge: (137 commits)
Update version to 1.1.0-rc2
tcg/ppc64: Fix CONFIG_TCG_PASS_AREG0
tcg/ppc64: Don't hardcode register numbers for qemu_ld/st
qdev: fix -device foo,?
qemu-img: Fix segmentation fault
qcow2: Don't ignore failure to clear autoclear flags
coroutine: Fix setup of sigaltstack coroutines
qapi: QMP input visitor, handle floats parsed as ints
usb-host: handle guest-issued clear halt
qxl: set size of PCI IO BAR correctly (16) for revision 2
qemu-doc: Use QEMU instead of qemu for product name
qemu-doc: Fix executable name in examples
qemu-doc: Add missing parameter in description of -D option
configure: Use QEMU instead of Qemu
fix some common typos
qemu-timer: Fix wrong error message
mips_fulong2e: Don't register "cpu" VMState twice
pc: Add back PCI.rombar compat property
qdev: Fix adding of ptr properties
qdev: Use object_property_print() in info qtree
...
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
113 files changed, 6097 insertions, 5077 deletions
@@ -447,7 +447,7 @@ version 0.5.0: - multi-target build - fixed: no error code in hardware interrupts - fixed: pop ss, mov ss, x and sti disable hardware irqs for the next insn - - correct single stepping thru string operations + - correct single stepping through string operations - preliminary SPARC target support (Thomas M. Ogrisegg) - tun-fd option (Rusty Russell) - automatic IDE geometry detection @@ -281,11 +281,18 @@ ifdef CONFIG_VIRTFS $(INSTALL_DIR) "$(DESTDIR)$(mandir)/man1" $(INSTALL_DATA) fsdev/virtfs-proxy-helper.1 "$(DESTDIR)$(mandir)/man1" endif -install-sysconfig: + +install-datadir: + $(INSTALL_DIR) "$(DESTDIR)$(qemu_datadir)" + +install-confdir: $(INSTALL_DIR) "$(DESTDIR)$(qemu_confdir)" + +install-sysconfig: install-datadir install-confdir $(INSTALL_DATA) $(SRC_PATH)/sysconfigs/target/target-x86_64.conf "$(DESTDIR)$(qemu_confdir)" + $(INSTALL_DATA) $(SRC_PATH)/sysconfigs/target/cpus-x86_64.conf "$(DESTDIR)$(qemu_datadir)" -install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig +install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig install-datadir $(INSTALL_DIR) "$(DESTDIR)$(bindir)" ifneq ($(TOOLS),) $(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)" @@ -295,7 +302,6 @@ ifneq ($(HELPERS-y),) $(INSTALL_PROG) $(STRIP_OPT) $(HELPERS-y) "$(DESTDIR)$(libexecdir)" endif ifneq ($(BLOBS),) - $(INSTALL_DIR) "$(DESTDIR)$(qemu_datadir)" set -e; for x in $(BLOBS); do \ $(INSTALL_DATA) $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(qemu_datadir)"; \ done @@ -1 +1 @@ -1.0.90 +1.0.92 diff --git a/arch_init.c b/arch_init.c index 9a35aeea3..988adcae0 100644 --- a/arch_init.c +++ b/arch_init.c @@ -54,7 +54,6 @@ int graphic_height = 600; int graphic_depth = 15; #endif -const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf"; #if defined(TARGET_ALPHA) #define QEMU_ARCH QEMU_ARCH_ALPHA @@ -112,6 +111,37 @@ const uint32_t arch_type = QEMU_ARCH; #define ALL_EQ(v1, v2) ((v1) == (v2)) #endif + +static struct defconfig_file { + const char *filename; + /* Indicates it is an user config file (disabled by -no-user-config) */ + bool userconfig; +} default_config_files[] = { + { CONFIG_QEMU_DATADIR "/cpus-" TARGET_ARCH ".conf", false }, + { CONFIG_QEMU_CONFDIR "/qemu.conf", true }, + { CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", true }, + { NULL }, /* end of list */ +}; + + +int qemu_read_default_config_files(bool userconfig) +{ + int ret; + struct defconfig_file *f; + + for (f = default_config_files; f->filename; f++) { + if (!userconfig && f->userconfig) { + continue; + } + ret = qemu_read_config_file(f->filename); + if (ret < 0 && ret != -ENOENT) { + return ret; + } + } + + return 0; +} + static int is_dup_page(uint8_t *page) { VECTYPE *p = (VECTYPE *)page; diff --git a/arch_init.h b/arch_init.h index 828256cc4..c7cb94a93 100644 --- a/arch_init.h +++ b/arch_init.h @@ -1,8 +1,6 @@ #ifndef QEMU_ARCH_INIT_H #define QEMU_ARCH_INIT_H -extern const char arch_config_name[]; - enum { QEMU_ARCH_ALL = -1, QEMU_ARCH_ALPHA = 1, diff --git a/arm-semi.c b/arm-semi.c index 8debd19e3..88ca9bb1b 100644 --- a/arm-semi.c +++ b/arm-semi.c @@ -37,26 +37,26 @@ #include "hw/arm-misc.h" #endif -#define SYS_OPEN 0x01 -#define SYS_CLOSE 0x02 -#define SYS_WRITEC 0x03 -#define SYS_WRITE0 0x04 -#define SYS_WRITE 0x05 -#define SYS_READ 0x06 -#define SYS_READC 0x07 -#define SYS_ISTTY 0x09 -#define SYS_SEEK 0x0a -#define SYS_FLEN 0x0c -#define SYS_TMPNAM 0x0d -#define SYS_REMOVE 0x0e -#define SYS_RENAME 0x0f -#define SYS_CLOCK 0x10 -#define SYS_TIME 0x11 -#define SYS_SYSTEM 0x12 -#define SYS_ERRNO 0x13 -#define SYS_GET_CMDLINE 0x15 -#define SYS_HEAPINFO 0x16 -#define SYS_EXIT 0x18 +#define TARGET_SYS_OPEN 0x01 +#define TARGET_SYS_CLOSE 0x02 +#define TARGET_SYS_WRITEC 0x03 +#define TARGET_SYS_WRITE0 0x04 +#define TARGET_SYS_WRITE 0x05 +#define TARGET_SYS_READ 0x06 +#define TARGET_SYS_READC 0x07 +#define TARGET_SYS_ISTTY 0x09 +#define TARGET_SYS_SEEK 0x0a +#define TARGET_SYS_FLEN 0x0c +#define TARGET_SYS_TMPNAM 0x0d +#define TARGET_SYS_REMOVE 0x0e +#define TARGET_SYS_RENAME 0x0f +#define TARGET_SYS_CLOCK 0x10 +#define TARGET_SYS_TIME 0x11 +#define TARGET_SYS_SYSTEM 0x12 +#define TARGET_SYS_ERRNO 0x13 +#define TARGET_SYS_GET_CMDLINE 0x15 +#define TARGET_SYS_HEAPINFO 0x16 +#define TARGET_SYS_EXIT 0x18 #ifndef O_BINARY #define O_BINARY 0 @@ -138,11 +138,11 @@ static void arm_semi_cb(CPUARMState *env, target_ulong ret, target_ulong err) } else { /* Fixup syscalls that use nonstardard return conventions. */ switch (env->regs[0]) { - case SYS_WRITE: - case SYS_READ: + case TARGET_SYS_WRITE: + case TARGET_SYS_READ: env->regs[0] = arm_semi_syscall_len - ret; break; - case SYS_SEEK: + case TARGET_SYS_SEEK: env->regs[0] = 0; break; default: @@ -190,7 +190,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) nr = env->regs[0]; args = env->regs[1]; switch (nr) { - case SYS_OPEN: + case TARGET_SYS_OPEN: if (!(s = lock_user_string(ARG(0)))) /* FIXME - should this error code be -TARGET_EFAULT ? */ return (uint32_t)-1; @@ -211,14 +211,14 @@ uint32_t do_arm_semihosting(CPUARMState *env) } unlock_user(s, ARG(0), 0); return ret; - case SYS_CLOSE: + case TARGET_SYS_CLOSE: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0)); return env->regs[0]; } else { return set_swi_errno(ts, close(ARG(0))); } - case SYS_WRITEC: + case TARGET_SYS_WRITEC: { char c; @@ -233,7 +233,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) return write(STDERR_FILENO, &c, 1); } } - case SYS_WRITE0: + case TARGET_SYS_WRITE0: if (!(s = lock_user_string(args))) /* FIXME - should this error code be -TARGET_EFAULT ? */ return (uint32_t)-1; @@ -246,7 +246,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) } unlock_user(s, args, 0); return ret; - case SYS_WRITE: + case TARGET_SYS_WRITE: len = ARG(2); if (use_gdb_syscalls()) { arm_semi_syscall_len = len; @@ -262,7 +262,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) return -1; return len - ret; } - case SYS_READ: + case TARGET_SYS_READ: len = ARG(2); if (use_gdb_syscalls()) { arm_semi_syscall_len = len; @@ -280,17 +280,17 @@ uint32_t do_arm_semihosting(CPUARMState *env) return -1; return len - ret; } - case SYS_READC: + case TARGET_SYS_READC: /* XXX: Read from debug cosole. Not implemented. */ return 0; - case SYS_ISTTY: + case TARGET_SYS_ISTTY: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0)); return env->regs[0]; } else { return isatty(ARG(0)); } - case SYS_SEEK: + case TARGET_SYS_SEEK: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1)); return env->regs[0]; @@ -300,7 +300,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) return -1; return 0; } - case SYS_FLEN: + case TARGET_SYS_FLEN: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x", ARG(0), env->regs[13]-64); @@ -312,10 +312,10 @@ uint32_t do_arm_semihosting(CPUARMState *env) return -1; return buf.st_size; } - case SYS_TMPNAM: + case TARGET_SYS_TMPNAM: /* XXX: Not implemented. */ return -1; - case SYS_REMOVE: + case TARGET_SYS_REMOVE: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1)+1); ret = env->regs[0]; @@ -327,7 +327,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) unlock_user(s, ARG(0), 0); } return ret; - case SYS_RENAME: + case TARGET_SYS_RENAME: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "rename,%s,%s", ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1); @@ -347,11 +347,11 @@ uint32_t do_arm_semihosting(CPUARMState *env) unlock_user(s, ARG(0), 0); return ret; } - case SYS_CLOCK: + case TARGET_SYS_CLOCK: return clock() / (CLOCKS_PER_SEC / 100); - case SYS_TIME: + case TARGET_SYS_TIME: return set_swi_errno(ts, time(NULL)); - case SYS_SYSTEM: + case TARGET_SYS_SYSTEM: if (use_gdb_syscalls()) { gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1)+1); return env->regs[0]; @@ -363,13 +363,13 @@ uint32_t do_arm_semihosting(CPUARMState *env) unlock_user(s, ARG(0), 0); return ret; } - case SYS_ERRNO: + case TARGET_SYS_ERRNO: #ifdef CONFIG_USER_ONLY return ts->swi_errno; #else return syscall_err; #endif - case SYS_GET_CMDLINE: + case TARGET_SYS_GET_CMDLINE: { /* Build a command-line from the original argv. * @@ -452,7 +452,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) return status; } - case SYS_HEAPINFO: + case TARGET_SYS_HEAPINFO: { uint32_t *ptr; uint32_t limit; @@ -498,7 +498,7 @@ uint32_t do_arm_semihosting(CPUARMState *env) #endif return 0; } - case SYS_EXIT: + case TARGET_SYS_EXIT: gdb_exit(env, 0); exit(0); default: @@ -198,33 +198,31 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs, /* check if the path starts with "<protocol>:" */ static int path_has_protocol(const char *path) { + const char *p; + #ifdef _WIN32 if (is_windows_drive(path) || is_windows_drive_prefix(path)) { return 0; } + p = path + strcspn(path, ":/\\"); +#else + p = path + strcspn(path, ":/"); #endif - return strchr(path, ':') != NULL; + return *p == ':'; } int path_is_absolute(const char *path) { - const char *p; #ifdef _WIN32 /* specific case for names like: "\\.\d:" */ - if (*path == '/' || *path == '\\') + if (is_windows_drive(path) || is_windows_drive_prefix(path)) { return 1; -#endif - p = strchr(path, ':'); - if (p) - p++; - else - p = path; -#ifdef _WIN32 - return (*p == '/' || *p == '\\'); + } + return (*path == '/' || *path == '\\'); #else - return (*p == '/'); + return (*path == '/'); #endif } @@ -272,6 +270,15 @@ void path_combine(char *dest, int dest_size, } } +void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz) +{ + if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) { + pstrcpy(dest, sz, bs->backing_file); + } else { + path_combine(dest, sz, bs->filename, bs->backing_file); + } +} + void bdrv_register(BlockDriver *bdrv) { /* Block drivers without coroutine functions need emulation */ @@ -341,13 +348,53 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name) return drv && bdrv_is_whitelisted(drv) ? drv : NULL; } +typedef struct CreateCo { + BlockDriver *drv; + char *filename; + QEMUOptionParameter *options; + int ret; +} CreateCo; + +static void coroutine_fn bdrv_create_co_entry(void *opaque) +{ + CreateCo *cco = opaque; + assert(cco->drv); + + cco->ret = cco->drv->bdrv_create(cco->filename, cco->options); +} + int bdrv_create(BlockDriver *drv, const char* filename, QEMUOptionParameter *options) { - if (!drv->bdrv_create) + int ret; + + Coroutine *co; + CreateCo cco = { + .drv = drv, + .filename = g_strdup(filename), + .options = options, + .ret = NOT_DONE, + }; + + if (!drv->bdrv_create) { return -ENOTSUP; + } + + if (qemu_in_coroutine()) { + /* Fast-path if already in coroutine context */ + bdrv_create_co_entry(&cco); + } else { + co = qemu_coroutine_create(bdrv_create_co_entry); + qemu_coroutine_enter(co, &cco); + while (cco.ret == NOT_DONE) { + qemu_aio_wait(); + } + } - return drv->bdrv_create(filename, options); + ret = cco.ret; + g_free(cco.filename); + + return ret; } int bdrv_create_file(const char* filename, QEMUOptionParameter *options) @@ -572,16 +619,11 @@ static int bdrv_open_common(BlockDriverState *bs, const char *filename, int ret, open_flags; assert(drv != NULL); + assert(bs->file == NULL); trace_bdrv_open_common(bs, filename, flags, drv->format_name); - bs->file = NULL; - bs->total_sectors = 0; - bs->encrypted = 0; - bs->valid_key = 0; - bs->sg = 0; bs->open_flags = flags; - bs->growable = 0; bs->buffer_alignment = 512; assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */ @@ -590,7 +632,6 @@ static int bdrv_open_common(BlockDriverState *bs, const char *filename, } pstrcpy(bs->filename, sizeof(bs->filename), filename); - bs->backing_file[0] = '\0'; if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) { return -ENOTSUP; @@ -764,14 +805,8 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags, BlockDriver *back_drv = NULL; bs->backing_hd = bdrv_new(""); - - if (path_has_protocol(bs->backing_file)) { - pstrcpy(backing_filename, sizeof(backing_filename), - bs->backing_file); - } else { - path_combine(backing_filename, sizeof(backing_filename), - filename, bs->backing_file); - } + bdrv_get_full_backing_filename(bs, backing_filename, + sizeof(backing_filename)); if (bs->backing_format[0] != '\0') { back_drv = bdrv_find_format(bs->backing_format); @@ -838,9 +873,17 @@ void bdrv_close(BlockDriverState *bs) bs->opaque = NULL; bs->drv = NULL; bs->copy_on_read = 0; + bs->backing_file[0] = '\0'; + bs->backing_format[0] = '\0'; + bs->total_sectors = 0; + bs->encrypted = 0; + bs->valid_key = 0; + bs->sg = 0; + bs->growable = 0; if (bs->file != NULL) { - bdrv_close(bs->file); + bdrv_delete(bs->file); + bs->file = NULL; } bdrv_dev_change_media_cb(bs, false); @@ -866,12 +909,31 @@ void bdrv_close_all(void) * * This function does not flush data to disk, use bdrv_flush_all() for that * after calling this function. + * + * Note that completion of an asynchronous I/O operation can trigger any + * number of other I/O operations on other devices---for example a coroutine + * can be arbitrarily complex and a constant flow of I/O can come until the + * coroutine is complete. Because of this, it is not possible to have a + * function to drain a single device's I/O queue. */ void bdrv_drain_all(void) { BlockDriverState *bs; + bool busy; - qemu_aio_flush(); + do { + busy = qemu_aio_wait(); + + /* FIXME: We do not have timer support here, so this is effectively + * a busy wait. + */ + QTAILQ_FOREACH(bs, &bdrv_states, list) { + if (!qemu_co_queue_empty(&bs->throttled_reqs)) { + qemu_co_queue_restart_all(&bs->throttled_reqs); + busy = true; + } + } + } while (busy); /* If requests are still pending there is a bug somewhere */ QTAILQ_FOREACH(bs, &bdrv_states, list) { @@ -890,6 +952,13 @@ void bdrv_make_anon(BlockDriverState *bs) bs->device_name[0] = '\0'; } +static void bdrv_rebind(BlockDriverState *bs) +{ + if (bs->drv && bs->drv->bdrv_rebind) { + bs->drv->bdrv_rebind(bs); + } +} + /* * Add new bs contents at the top of an image chain while the chain is * live, while keeping required fields on the top layer. @@ -911,6 +980,7 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) tmp = *bs_new; /* there are some fields that need to stay on the top layer: */ + tmp.open_flags = bs_top->open_flags; /* dev info */ tmp.dev_ops = bs_top->dev_ops; @@ -978,6 +1048,9 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) bs_new->slice_time = 0; bs_new->slice_start = 0; bs_new->slice_end = 0; + + bdrv_rebind(bs_new); + bdrv_rebind(bs_top); } void bdrv_delete(BlockDriverState *bs) @@ -990,9 +1063,6 @@ void bdrv_delete(BlockDriverState *bs) bdrv_make_anon(bs); bdrv_close(bs); - if (bs->file != NULL) { - bdrv_delete(bs->file); - } assert(bs != bs_snapshots); g_free(bs); @@ -1400,12 +1470,24 @@ int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file, const char *backing_fmt) { BlockDriver *drv = bs->drv; + int ret; + + /* Backing file format doesn't make sense without a backing file */ + if (backing_fmt && !backing_file) { + return -EINVAL; + } if (drv->bdrv_change_backing_file != NULL) { - return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); + ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); } else { - return -ENOTSUP; + ret = -ENOTSUP; + } + + if (ret == 0) { + pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); + pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); } + return ret; } static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, @@ -1513,6 +1595,8 @@ int bdrv_read(BlockDriverState *bs, int64_t sector_num, return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false); } +#define BITS_PER_LONG (sizeof(unsigned long) * 8) + static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int dirty) { @@ -1523,8 +1607,8 @@ static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num, end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK; for (; start <= end; start++) { - idx = start / (sizeof(unsigned long) * 8); - bit = start % (sizeof(unsigned long) * 8); + idx = start / BITS_PER_LONG; + bit = start % BITS_PER_LONG; val = bs->dirty_bitmap[idx]; if (dirty) { if (!(val & (1UL << bit))) { @@ -3829,10 +3913,10 @@ void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable) if (enable) { if (!bs->dirty_bitmap) { bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) + - BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; - bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; + BDRV_SECTORS_PER_DIRTY_CHUNK * BITS_PER_LONG - 1; + bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * BITS_PER_LONG; - bs->dirty_bitmap = g_malloc0(bitmap_size); + bs->dirty_bitmap = g_new0(unsigned long, bitmap_size); } } else { if (bs->dirty_bitmap) { @@ -4032,10 +4116,15 @@ int bdrv_img_create(const char *filename, const char *fmt, if (backing_file && backing_file->value.s) { uint64_t size; char buf[32]; + int back_flags; + + /* backing files always opened read-only */ + back_flags = + flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); bs = bdrv_new(""); - ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv); + ret = bdrv_open(bs, backing_file->value.s, back_flags, backing_drv); if (ret < 0) { error_report("Could not open '%s'", backing_file->value.s); goto out; @@ -4099,6 +4188,7 @@ void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, job->bs = bs; job->cb = cb; job->opaque = opaque; + job->busy = true; bs->job = job; /* Only set speed when necessary to avoid NotSupported error */ @@ -4148,6 +4238,9 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) void block_job_cancel(BlockJob *job) { job->cancelled = true; + if (job->co && !job->busy) { + qemu_coroutine_enter(job->co, NULL); + } } bool block_job_is_cancelled(BlockJob *job) @@ -4155,13 +4248,52 @@ bool block_job_is_cancelled(BlockJob *job) return job->cancelled; } -void block_job_cancel_sync(BlockJob *job) +struct BlockCancelData { + BlockJob *job; + BlockDriverCompletionFunc *cb; + void *opaque; + bool cancelled; + int ret; +}; + +static void block_job_cancel_cb(void *opaque, int ret) +{ + struct BlockCancelData *data = opaque; + + data->cancelled = block_job_is_cancelled(data->job); + data->ret = ret; + data->cb(data->opaque, ret); +} + +int block_job_cancel_sync(BlockJob *job) { + struct BlockCancelData data; BlockDriverState *bs = job->bs; assert(bs->job == job); + + /* Set up our own callback to store the result and chain to + * the original callback. + */ + data.job = job; + data.cb = job->cb; + data.opaque = job->opaque; + data.ret = -EINPROGRESS; + job->cb = block_job_cancel_cb; + job->opaque = &data; block_job_cancel(job); - while (bs->job != NULL && bs->job->busy) { + while (data.ret == -EINPROGRESS) { qemu_aio_wait(); } + return (data.cancelled && data.ret == 0) ? -ECANCELED : data.ret; +} + +void block_job_sleep_ns(BlockJob *job, QEMUClock *clock, int64_t ns) +{ + /* Check cancellation *before* setting busy = false, too! */ + if (!block_job_is_cancelled(job)) { + job->busy = false; + co_sleep_ns(clock, ns); + job->busy = true; + } } @@ -303,6 +303,8 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi); const char *bdrv_get_encrypted_filename(BlockDriverState *bs); void bdrv_get_backing_filename(BlockDriverState *bs, char *filename, int filename_size); +void bdrv_get_full_backing_filename(BlockDriverState *bs, + char *dest, size_t sz); int bdrv_can_snapshot(BlockDriverState *bs); int bdrv_is_snapshot(BlockDriverState *bs); BlockDriverState *bdrv_snapshots(void); diff --git a/block/iscsi.c b/block/iscsi.c index 5222726d0..d37c4ee17 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -383,6 +383,65 @@ iscsi_aio_flush(BlockDriverState *bs, return &acb->common; } +static void +iscsi_unmap_cb(struct iscsi_context *iscsi, int status, + void *command_data, void *opaque) +{ + IscsiAIOCB *acb = opaque; + + if (acb->canceled != 0) { + qemu_aio_release(acb); + scsi_free_scsi_task(acb->task); + acb->task = NULL; + return; + } + + acb->status = 0; + if (status < 0) { + error_report("Failed to unmap data on iSCSI lun. %s", + iscsi_get_error(iscsi)); + acb->status = -EIO; + } + + iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb); + scsi_free_scsi_task(acb->task); + acb->task = NULL; +} + +static BlockDriverAIOCB * +iscsi_aio_discard(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque) +{ + IscsiLun *iscsilun = bs->opaque; + struct iscsi_context *iscsi = iscsilun->iscsi; + IscsiAIOCB *acb; + struct unmap_list list[1]; + + acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); + + acb->iscsilun = iscsilun; + acb->canceled = 0; + + list[0].lba = sector_qemu2lun(sector_num, iscsilun); + list[0].num = nb_sectors * BDRV_SECTOR_SIZE / iscsilun->block_size; + + acb->task = iscsi_unmap_task(iscsi, 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)); + qemu_aio_release(acb); + return NULL; + } + + iscsi_set_events(iscsilun); + + return &acb->common; +} + static int64_t iscsi_getlength(BlockDriverState *bs) { @@ -396,11 +455,11 @@ iscsi_getlength(BlockDriverState *bs) } static void -iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status, +iscsi_readcapacity16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { struct IscsiTask *itask = opaque; - struct scsi_readcapacity10 *rc10; + struct scsi_readcapacity16 *rc16; struct scsi_task *task = command_data; if (status != 0) { @@ -412,26 +471,25 @@ iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status, return; } - rc10 = scsi_datain_unmarshall(task); - if (rc10 == NULL) { - error_report("iSCSI: Failed to unmarshall readcapacity10 data."); + rc16 = scsi_datain_unmarshall(task); + if (rc16 == NULL) { + error_report("iSCSI: Failed to unmarshall readcapacity16 data."); itask->status = 1; itask->complete = 1; scsi_free_scsi_task(task); return; } - itask->iscsilun->block_size = rc10->block_size; - itask->iscsilun->num_blocks = rc10->lba; - itask->bs->total_sectors = (uint64_t)rc10->lba * - rc10->block_size / BDRV_SECTOR_SIZE ; + itask->iscsilun->block_size = rc16->block_length; + itask->iscsilun->num_blocks = rc16->returned_lba + 1; + itask->bs->total_sectors = itask->iscsilun->num_blocks * + itask->iscsilun->block_size / BDRV_SECTOR_SIZE ; itask->status = 0; itask->complete = 1; scsi_free_scsi_task(task); } - static void iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) @@ -445,10 +503,10 @@ iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data, return; } - task = iscsi_readcapacity10_task(iscsi, itask->iscsilun->lun, 0, 0, - iscsi_readcapacity10_cb, opaque); + task = iscsi_readcapacity16_task(iscsi, itask->iscsilun->lun, + iscsi_readcapacity16_cb, opaque); if (task == NULL) { - error_report("iSCSI: failed to send readcapacity command."); + error_report("iSCSI: failed to send readcapacity16 command."); itask->status = 1; itask->complete = 1; return; @@ -700,6 +758,8 @@ static BlockDriver bdrv_iscsi = { .bdrv_aio_readv = iscsi_aio_readv, .bdrv_aio_writev = iscsi_aio_writev, .bdrv_aio_flush = iscsi_aio_flush, + + .bdrv_aio_discard = iscsi_aio_discard, }; static void iscsi_block_init(void) diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c index 353889d41..10c22fe12 100644 --- a/block/qcow2-cluster.c +++ b/block/qcow2-cluster.c @@ -883,15 +883,19 @@ again: assert(keep_clusters <= nb_clusters); nb_clusters -= keep_clusters; } else { + keep_clusters = 0; + cluster_offset = 0; + } + + if (nb_clusters > 0) { /* For the moment, overwrite compressed clusters one by one */ - if (cluster_offset & QCOW_OFLAG_COMPRESSED) { + uint64_t entry = be64_to_cpu(l2_table[l2_index + keep_clusters]); + if (entry & QCOW_OFLAG_COMPRESSED) { nb_clusters = 1; } else { - nb_clusters = count_cow_clusters(s, nb_clusters, l2_table, l2_index); + nb_clusters = count_cow_clusters(s, nb_clusters, l2_table, + l2_index + keep_clusters); } - - keep_clusters = 0; - cluster_offset = 0; } cluster_offset &= L2E_OFFSET_MASK; diff --git a/block/qcow2.c b/block/qcow2.c index 8c60a6f06..655799c6a 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -300,7 +300,10 @@ static int qcow2_open(BlockDriverState *bs, int flags) if (!bs->read_only && s->autoclear_features != 0) { s->autoclear_features = 0; - qcow2_update_header(bs); + ret = qcow2_update_header(bs); + if (ret < 0) { + goto fail; + } } /* Check support for various header values */ @@ -1011,11 +1014,6 @@ fail: static int qcow2_change_backing_file(BlockDriverState *bs, const char *backing_file, const char *backing_fmt) { - /* Backing file format doesn't make sense without a backing file */ - if (backing_fmt && !backing_file) { - return -EINVAL; - } - pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); @@ -1192,7 +1190,10 @@ static int qcow2_create2(const char *filename, int64_t total_size, /* And if we're supposed to preallocate metadata, do that now */ if (prealloc) { + BDRVQcowState *s = bs->opaque; + qemu_co_mutex_lock(&s->lock); ret = preallocate(bs); + qemu_co_mutex_unlock(&s->lock); if (ret < 0) { goto out; } diff --git a/block/qed.c b/block/qed.c index 366cde7ad..30a31f907 100644 --- a/block/qed.c +++ b/block/qed.c @@ -367,6 +367,12 @@ static void qed_cancel_need_check_timer(BDRVQEDState *s) qemu_del_timer(s->need_check_timer); } +static void bdrv_qed_rebind(BlockDriverState *bs) +{ + BDRVQEDState *s = bs->opaque; + s->bs = bs; +} + static int bdrv_qed_open(BlockDriverState *bs, int flags) { BDRVQEDState *s = bs->opaque; @@ -1550,6 +1556,7 @@ static BlockDriver bdrv_qed = { .create_options = qed_create_options, .bdrv_probe = bdrv_qed_probe, + .bdrv_rebind = bdrv_qed_rebind, .bdrv_open = bdrv_qed_open, .bdrv_close = bdrv_qed_close, .bdrv_create = bdrv_qed_create, diff --git a/block/sheepdog.c b/block/sheepdog.c index 0ed6b193c..e01d37168 100644 --- a/block/sheepdog.c +++ b/block/sheepdog.c @@ -1678,6 +1678,14 @@ static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs) return ret; } + if (rsp->result == SD_RES_INVALID_PARMS) { + dprintf("disable write cache since the server doesn't support it\n"); + + s->cache_enabled = 0; + closesocket(s->flush_fd); + return 0; + } + if (rsp->result != SD_RES_SUCCESS) { error_report("%s", sd_strerror(rsp->result)); return -EIO; diff --git a/block/stream.c b/block/stream.c index 6724af276..8e5832273 100644 --- a/block/stream.c +++ b/block/stream.c @@ -33,19 +33,19 @@ typedef struct { static int64_t ratelimit_calculate_delay(RateLimit *limit, uint64_t n) { - int64_t delay_ns = 0; int64_t now = qemu_get_clock_ns(rt_clock); if (limit->next_slice_time < now) { limit->next_slice_time = now + SLICE_TIME; limit->dispatched = 0; } - if (limit->dispatched + n > limit->slice_quota) { - delay_ns = limit->next_slice_time - now; - } else { + if (limit->dispatched == 0 || limit->dispatched + n <= limit->slice_quota) { limit->dispatched += n; + return 0; + } else { + limit->dispatched = n; + return limit->next_slice_time - now; } - return delay_ns; } static void ratelimit_set_speed(RateLimit *limit, uint64_t speed) @@ -96,17 +96,6 @@ static void close_unused_images(BlockDriverState *top, BlockDriverState *base, bdrv_delete(unused); } top->backing_hd = base; - - pstrcpy(top->backing_file, sizeof(top->backing_file), ""); - pstrcpy(top->backing_format, sizeof(top->backing_format), ""); - if (base_id) { - pstrcpy(top->backing_file, sizeof(top->backing_file), base_id); - if (base->drv) { - pstrcpy(top->backing_format, sizeof(top->backing_format), - base->drv->format_name); - } - } - } /* @@ -141,14 +130,9 @@ static int coroutine_fn is_allocated_base(BlockDriverState *top, */ intermediate = top->backing_hd; - while (intermediate) { + while (intermediate != base) { int pnum_inter; - /* reached base */ - if (intermediate == base) { - *pnum = n; - return 1; - } ret = bdrv_co_is_allocated(intermediate, sector_num, nb_sectors, &pnum_inter); if (ret < 0) { @@ -171,6 +155,7 @@ static int coroutine_fn is_allocated_base(BlockDriverState *top, intermediate = intermediate->backing_hd; } + *pnum = n; return 1; } @@ -181,7 +166,7 @@ static void coroutine_fn stream_run(void *opaque) BlockDriverState *base = s->base; int64_t sector_num, end; int ret = 0; - int n; + int n = 0; void *buf; s->common.len = bdrv_getlength(bs); @@ -203,30 +188,25 @@ static void coroutine_fn stream_run(void *opaque) } for (sector_num = 0; sector_num < end; sector_num += n) { -retry: + uint64_t delay_ns = 0; + +wait: + /* Note that even when no rate limit is applied we need to yield + * with no pending I/O here so that qemu_aio_flush() returns. + */ + block_job_sleep_ns(&s->common, rt_clock, delay_ns); if (block_job_is_cancelled(&s->common)) { break; } - s->common.busy = true; - if (base) { - ret = is_allocated_base(bs, base, sector_num, - STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); - } else { - ret = bdrv_co_is_allocated(bs, sector_num, - STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, - &n); - } + ret = is_allocated_base(bs, base, sector_num, + STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); trace_stream_one_iteration(s, sector_num, n, ret); if (ret == 0) { if (s->common.speed) { - uint64_t delay_ns = ratelimit_calculate_delay(&s->limit, n); + delay_ns = ratelimit_calculate_delay(&s->limit, n); if (delay_ns > 0) { - s->common.busy = false; - co_sleep_ns(rt_clock, delay_ns); - - /* Recheck cancellation and that sectors are unallocated */ - goto retry; + goto wait; } } ret = stream_populate(bs, sector_num, n, buf); @@ -238,12 +218,6 @@ retry: /* Publish progress */ s->common.offset += n * BDRV_SECTOR_SIZE; - - /* Note that even when no rate limit is applied we need to yield - * with no pending I/O here so that qemu_aio_flush() returns. - */ - s->common.busy = false; - co_sleep_ns(rt_clock, 0); } if (!base) { @@ -251,11 +225,14 @@ retry: } if (!block_job_is_cancelled(&s->common) && sector_num == end && ret == 0) { - const char *base_id = NULL; + const char *base_id = NULL, *base_fmt = NULL; if (base) { base_id = s->backing_file_id; + if (base->drv) { + base_fmt = base->drv->format_name; + } } - ret = bdrv_change_backing_file(bs, base_id, NULL); + ret = bdrv_change_backing_file(bs, base_id, base_fmt); close_unused_images(bs, base, base_id); } @@ -286,7 +263,6 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base, void *opaque, Error **errp) { StreamBlockJob *s; - Coroutine *co; s = block_job_create(&stream_job_type, bs, speed, cb, opaque, errp); if (!s) { @@ -298,7 +274,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base, pstrcpy(s->backing_file_id, sizeof(s->backing_file_id), base_id); } - co = qemu_coroutine_create(stream_run); - trace_stream_start(bs, base, s, co, opaque); - qemu_coroutine_enter(co, s); + s->common.co = qemu_coroutine_create(stream_run); + trace_stream_start(bs, base, s, s->common.co, opaque); + qemu_coroutine_enter(s->common.co, s); } diff --git a/block/vvfat.c b/block/vvfat.c index 9ef21ddfc..2dc9d5088 100644 --- a/block/vvfat.c +++ b/block/vvfat.c @@ -982,6 +982,12 @@ static BDRVVVFATState *vvv = NULL; static int enable_write_target(BDRVVVFATState *s); static int is_consistent(BDRVVVFATState *s); +static void vvfat_rebind(BlockDriverState *bs) +{ + BDRVVVFATState *s = bs->opaque; + s->bs = bs; +} + static int vvfat_open(BlockDriverState *bs, const char* dirname, int flags) { BDRVVVFATState *s = bs->opaque; @@ -2855,6 +2861,7 @@ static BlockDriver bdrv_vvfat = { .format_name = "vvfat", .instance_size = sizeof(BDRVVVFATState), .bdrv_file_open = vvfat_open, + .bdrv_rebind = vvfat_rebind, .bdrv_read = vvfat_co_read, .bdrv_write = vvfat_co_write, .bdrv_close = vvfat_close, diff --git a/block_int.h b/block_int.h index 086832aab..b80e66db6 100644 --- a/block_int.h +++ b/block_int.h @@ -95,20 +95,23 @@ struct BlockJob { BlockDriverState *bs; /** + * The coroutine that executes the job. If not NULL, it is + * reentered when busy is false and the job is cancelled. + */ + Coroutine *co; + + /** * Set to true if the job should cancel itself. The flag must * always be tested just before toggling the busy flag from false - * to true. After a job has detected that the cancelled flag is - * true, it should not anymore issue any I/O operation to the - * block device. + * to true. After a job has been cancelled, it should only yield + * if #qemu_aio_wait will ("sooner or later") reenter the coroutine. */ bool cancelled; /** * Set to false by the job while it is in a quiescent state, where - * no I/O is pending and cancellation can be processed without - * issuing new I/O. The busy flag must be set to false when the - * job goes to sleep on any condition that is not detected by - * #qemu_aio_wait, such as a timer. + * no I/O is pending and the job has yielded on any condition + * that is not detected by #qemu_aio_wait, such as a timer. */ bool busy; @@ -140,6 +143,7 @@ struct BlockDriver { int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors); void (*bdrv_close)(BlockDriverState *bs); + void (*bdrv_rebind)(BlockDriverState *bs); int (*bdrv_create)(const char *filename, QEMUOptionParameter *options); int (*bdrv_set_key)(BlockDriverState *bs, const char *key); int (*bdrv_make_empty)(BlockDriverState *bs); @@ -363,6 +367,17 @@ void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, void *opaque, Error **errp); /** + * block_job_sleep_ns: + * @job: The job that calls the function. + * @clock: The clock to sleep on. + * @ns: How many nanoseconds to stop for. + * + * Put the job to sleep (assuming that it wasn't canceled) for @ns + * nanoseconds. Canceling the job will interrupt the wait immediately. + */ +void block_job_sleep_ns(BlockJob *job, QEMUClock *clock, int64_t ns); + +/** * block_job_complete: * @job: The job being completed. * @ret: The status code. @@ -409,8 +424,11 @@ bool block_job_is_cancelled(BlockJob *job); * immediately after #block_job_cancel_sync. Users of block jobs * will usually protect the BlockDriverState objects with a reference * count, should this be a concern. + * + * Returns the return value from the job if the job actually completed + * during the call, or -ECANCELED if it was canceled. */ -void block_job_cancel_sync(BlockJob *job); +int block_job_cancel_sync(BlockJob *job); /** * stream_start: diff --git a/blockdev.c b/blockdev.c index ab8825884..0d20460f0 100644 --- a/blockdev.c +++ b/blockdev.c @@ -762,14 +762,17 @@ void qmp_transaction(BlockdevActionList *dev_list, Error **errp) goto delete_and_fail; } + if (!bdrv_is_inserted(states->old_bs)) { + error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); + goto delete_and_fail; + } + if (bdrv_in_use(states->old_bs)) { error_set(errp, QERR_DEVICE_IN_USE, device); goto delete_and_fail; } - if (!bdrv_is_read_only(states->old_bs) && - bdrv_is_inserted(states->old_bs)) { - + if (!bdrv_is_read_only(states->old_bs)) { if (bdrv_flush(states->old_bs)) { error_set(errp, QERR_IO_ERROR); goto delete_and_fail; @@ -418,31 +418,37 @@ cvtstr( char *str, size_t size) { - const char *fmt; - int precise; - - precise = ((double)value * 1000 == (double)(int)value * 1000); + char *trim; + const char *suffix; if (value >= EXABYTES(1)) { - fmt = precise ? "%.f EiB" : "%.3f EiB"; - snprintf(str, size, fmt, TO_EXABYTES(value)); + suffix = " EiB"; + snprintf(str, size - 4, "%.3f", TO_EXABYTES(value)); } else if (value >= PETABYTES(1)) { - fmt = precise ? "%.f PiB" : "%.3f PiB"; - snprintf(str, size, fmt, TO_PETABYTES(value)); + suffix = " PiB"; + snprintf(str, size - 4, "%.3f", TO_PETABYTES(value)); } else if (value >= TERABYTES(1)) { - fmt = precise ? "%.f TiB" : "%.3f TiB"; - snprintf(str, size, fmt, TO_TERABYTES(value)); + suffix = " TiB"; + snprintf(str, size - 4, "%.3f", TO_TERABYTES(value)); } else if (value >= GIGABYTES(1)) { - fmt = precise ? "%.f GiB" : "%.3f GiB"; - snprintf(str, size, fmt, TO_GIGABYTES(value)); + suffix = " GiB"; + snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value)); } else if (value >= MEGABYTES(1)) { - fmt = precise ? "%.f MiB" : "%.3f MiB"; - snprintf(str, size, fmt, TO_MEGABYTES(value)); + suffix = " MiB"; + snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value)); } else if (value >= KILOBYTES(1)) { - fmt = precise ? "%.f KiB" : "%.3f KiB"; - snprintf(str, size, fmt, TO_KILOBYTES(value)); + suffix = " KiB"; + snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value)); + } else { + suffix = " bytes"; + snprintf(str, size - 6, "%f", value); + } + + trim = strstr(str, ".000"); + if (trim) { + strcpy(trim, suffix); } else { - snprintf(str, size, "%f bytes", value); + strcat(str, suffix); } } @@ -1021,7 +1021,7 @@ echo " --datadir=PATH install firmware in PATH$confsuffix" echo " --docdir=PATH install documentation in PATH$confsuffix" echo " --bindir=PATH install binaries in PATH" echo " --sysconfdir=PATH install config in PATH$confsuffix" -echo " --with-confsuffix=SUFFIX suffix for Qemu data inside datadir and sysconfdir [$confsuffix]" +echo " --with-confsuffix=SUFFIX suffix for QEMU data inside datadir and sysconfdir [$confsuffix]" echo " --enable-debug-tcg enable TCG debugging" echo " --disable-debug-tcg disable TCG debugging (default)" echo " --enable-debug enable common debug build options" @@ -2563,10 +2563,13 @@ fi ########################################## # Do we have libiscsi +# We check for iscsi_unmap_sync() to make sure we have a +# recent enough version of libiscsi. if test "$libiscsi" != "no" ; then cat > $TMPC << EOF +#include <stdio.h> #include <iscsi/iscsi.h> -int main(void) { iscsi_create_context(""); return 0; } +int main(void) { iscsi_unmap_sync(NULL,0,0,0,NULL,0); return 0; } EOF if compile_prog "-Werror" "-liscsi" ; then libiscsi="yes" @@ -2609,6 +2612,7 @@ EOF spice_cflags=$($pkg_config --cflags spice-protocol spice-server 2>/dev/null) spice_libs=$($pkg_config --libs spice-protocol spice-server 2>/dev/null) if $pkg_config --atleast-version=0.8.2 spice-server >/dev/null 2>&1 && \ + $pkg_config --atleast-version=0.8.1 spice-protocol > /dev/null 2>&1 && \ compile_prog "$spice_cflags" "$spice_libs" ; then spice="yes" libs_softmmu="$libs_softmmu $spice_libs" @@ -2908,14 +2912,15 @@ tools= if test "$softmmu" = yes ; then tools="qemu-img\$(EXESUF) qemu-io\$(EXESUF) $tools" if test "$virtfs" != no ; then - if test "$cap" = yes && test "$linux" = yes && test "$attr" = yes ; then - virtfs=yes - tools="$tools fsdev/virtfs-proxy-helper\$(EXESUF)" - else - if test "$virtfs" = yes; then - feature_not_found "virtfs" - fi + if test "$cap" = yes && test "$linux" = yes && test "$attr" = yes ; then + virtfs=yes + tools="$tools fsdev/virtfs-proxy-helper\$(EXESUF)" + else + if test "$virtfs" = yes; then + feature_not_found "virtfs" fi + virtfs=no + fi fi if [ "$linux" = "yes" -o "$bsd" = "yes" -o "$solaris" = "yes" ] ; then tools="qemu-nbd\$(EXESUF) $tools" diff --git a/coroutine-sigaltstack.c b/coroutine-sigaltstack.c index 7ff2d3379..861e87805 100644 --- a/coroutine-sigaltstack.c +++ b/coroutine-sigaltstack.c @@ -226,7 +226,7 @@ static Coroutine *coroutine_new(void) * called. */ coTS->tr_called = 0; - kill(getpid(), SIGUSR2); + pthread_kill(pthread_self(), SIGUSR2); sigfillset(&sigs); sigdelset(&sigs, SIGUSR2); while (!coTS->tr_called) { @@ -257,7 +257,7 @@ static Coroutine *coroutine_new(void) /* * Now enter the trampoline again, but this time not as a signal * handler. Instead we jump into it directly. The functionally - * redundant ping-pong pointer arithmentic is neccessary to avoid + * redundant ping-pong pointer arithmetic is necessary to avoid * type-conversion warnings related to the `volatile' qualifier and * the fact that `jmp_buf' usually is an array type. */ @@ -272,10 +272,10 @@ void tlb_set_page(CPUArchState *env, target_ulong vaddr, } else { addend = 0; } - iotlb = memory_region_section_get_iotlb(env, section, vaddr, paddr, prot, - &address); code_address = address; + iotlb = memory_region_section_get_iotlb(env, section, vaddr, paddr, prot, + &address); index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1); env->iotlb[mmu_idx][index] = iotlb - vaddr; @@ -51,7 +51,7 @@ perror_memory (int status, bfd_vma memaddr, struct disassemble_info *info) "Address 0x%" PRIx64 " is out of bounds.\n", memaddr); } -/* This could be in a separate file, to save miniscule amounts of space +/* This could be in a separate file, to save minuscule amounts of space in statically linked executables. */ /* Just print the address is hex. This is included for completeness even @@ -350,6 +350,8 @@ void hmp_info_spice(Monitor *mon) } monitor_printf(mon, " auth: %s\n", info->auth); monitor_printf(mon, " compiled: %s\n", info->compiled_version); + monitor_printf(mon, " mouse-mode: %s\n", + SpiceQueryMouseMode_lookup[info->mouse_mode]); if (!info->has_channels || info->channels == NULL) { monitor_printf(mon, "Channels: none\n"); @@ -847,7 +849,7 @@ void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict) { Error *error = NULL; const char *device = qdict_get_str(qdict, "device"); - int64_t value = qdict_get_int(qdict, "value"); + int64_t value = qdict_get_int(qdict, "speed"); qmp_block_job_set_speed(device, value, &error); @@ -54,6 +54,8 @@ enum { AC97_6Ch_Vol_C_LFE_Mute = 0x36, AC97_6Ch_Vol_L_R_Surround_Mute = 0x38, AC97_Vendor_Reserved = 0x58, + AC97_Sigmatel_Analog = 0x6c, /* We emulate a Sigmatel codec */ + AC97_Sigmatel_Dac2Invert = 0x6e, /* We emulate a Sigmatel codec */ AC97_Vendor_ID1 = 0x7c, AC97_Vendor_ID2 = 0x7e }; @@ -342,7 +344,7 @@ static uint16_t mixer_load (AC97LinkState *s, uint32_t i) uint16_t val = 0xffff; if (i + 2 > sizeof (s->mixer_data)) { - dolog ("mixer_store: index %d out of bounds %zd\n", + dolog ("mixer_load: index %d out of bounds %zd\n", i, sizeof (s->mixer_data)); } else { @@ -456,8 +458,7 @@ static void update_combined_volume_out (AC97LinkState *s) get_volume (mixer_load (s, AC97_Master_Volume_Mute), 0x3f, 1, &mute, &lvol, &rvol); - /* FIXME: should be 1f according to spec */ - get_volume (mixer_load (s, AC97_PCM_Out_Volume_Mute), 0x3f, 1, + get_volume (mixer_load (s, AC97_PCM_Out_Volume_Mute), 0x1f, 1, &pmute, &plvol, &prvol); mute = mute | pmute; @@ -480,11 +481,22 @@ static void update_volume_in (AC97LinkState *s) static void set_volume (AC97LinkState *s, int index, uint32_t val) { - mixer_store (s, index, val); - if (index == AC97_Master_Volume_Mute || index == AC97_PCM_Out_Volume_Mute) { + switch (index) { + case AC97_Master_Volume_Mute: + val &= 0xbf3f; + mixer_store (s, index, val); + update_combined_volume_out (s); + break; + case AC97_PCM_Out_Volume_Mute: + val &= 0x9f1f; + mixer_store (s, index, val); update_combined_volume_out (s); - } else if (index == AC97_Record_Gain_Mute) { + break; + case AC97_Record_Gain_Mute: + val &= 0x8f0f; + mixer_store (s, index, val); update_volume_in (s); + break; } } @@ -503,14 +515,17 @@ static void mixer_reset (AC97LinkState *s) memset (s->mixer_data, 0, sizeof (s->mixer_data)); memset (active, 0, sizeof (active)); mixer_store (s, AC97_Reset , 0x0000); /* 6940 */ - mixer_store (s, AC97_Master_Volume_Mono_Mute , 0x8000); + mixer_store (s, AC97_Headphone_Volume_Mute , 0x0000); + mixer_store (s, AC97_Master_Volume_Mono_Mute , 0x0000); + mixer_store (s, AC97_Master_Tone_RL, 0x0000); mixer_store (s, AC97_PC_BEEP_Volume_Mute , 0x0000); - - mixer_store (s, AC97_Phone_Volume_Mute , 0x8008); - mixer_store (s, AC97_Mic_Volume_Mute , 0x8008); - mixer_store (s, AC97_CD_Volume_Mute , 0x8808); - mixer_store (s, AC97_Aux_Volume_Mute , 0x8808); - mixer_store (s, AC97_Record_Gain_Mic_Mute , 0x8000); + mixer_store (s, AC97_Phone_Volume_Mute , 0x0000); + mixer_store (s, AC97_Mic_Volume_Mute , 0x0000); + mixer_store (s, AC97_Line_In_Volume_Mute , 0x0000); + mixer_store (s, AC97_CD_Volume_Mute , 0x0000); + mixer_store (s, AC97_Video_Volume_Mute , 0x0000); + mixer_store (s, AC97_Aux_Volume_Mute , 0x0000); + mixer_store (s, AC97_Record_Gain_Mic_Mute , 0x0000); mixer_store (s, AC97_General_Purpose , 0x0000); mixer_store (s, AC97_3D_Control , 0x0000); mixer_store (s, AC97_Powerdown_Ctrl_Stat , 0x000f); @@ -532,7 +547,7 @@ static void mixer_reset (AC97LinkState *s) record_select (s, 0); set_volume (s, AC97_Master_Volume_Mute, 0x8000); set_volume (s, AC97_PCM_Out_Volume_Mute, 0x8808); - set_volume (s, AC97_Line_In_Volume_Mute, 0x8808); + set_volume (s, AC97_Record_Gain_Mute, 0x8808); reset_voices (s, active); } @@ -588,14 +603,13 @@ static void nam_writew (void *opaque, uint32_t addr, uint32_t val) mixer_reset (s); break; case AC97_Powerdown_Ctrl_Stat: - val &= ~0xf; + val &= ~0x800f; val |= mixer_load (s, index) & 0xf; mixer_store (s, index, val); break; case AC97_PCM_Out_Volume_Mute: case AC97_Master_Volume_Mute: case AC97_Record_Gain_Mute: - case AC97_Line_In_Volume_Mute: set_volume (s, index, val); break; case AC97_Record_Select: @@ -657,6 +671,23 @@ static void nam_writew (void *opaque, uint32_t addr, uint32_t val) val); } break; + case AC97_Headphone_Volume_Mute: + case AC97_Master_Volume_Mono_Mute: + case AC97_Master_Tone_RL: + case AC97_PC_BEEP_Volume_Mute: + case AC97_Phone_Volume_Mute: + case AC97_Mic_Volume_Mute: + case AC97_Line_In_Volume_Mute: + case AC97_CD_Volume_Mute: + case AC97_Video_Volume_Mute: + case AC97_Aux_Volume_Mute: + case AC97_Record_Gain_Mic_Mute: + case AC97_General_Purpose: + case AC97_3D_Control: + case AC97_Sigmatel_Analog: + case AC97_Sigmatel_Dac2Invert: + /* None of the features in these regs are emulated, so they are RO */ + break; default: dolog ("U nam writew %#x <- %#x\n", addr, val); mixer_store (s, index, val); @@ -1158,8 +1189,8 @@ static int ac97_post_load (void *opaque, int version_id) mixer_load (s, AC97_Master_Volume_Mute)); set_volume (s, AC97_PCM_Out_Volume_Mute, mixer_load (s, AC97_PCM_Out_Volume_Mute)); - set_volume (s, AC97_Line_In_Volume_Mute, - mixer_load (s, AC97_Line_In_Volume_Mute)); + set_volume (s, AC97_Record_Gain_Mute, + mixer_load (s, AC97_Record_Gain_Mute)); active[PI_INDEX] = !!(s->bm_regs[PI_INDEX].cr & CR_RPBM); active[PO_INDEX] = !!(s->bm_regs[PO_INDEX].cr & CR_RPBM); diff --git a/hw/apb_pci.c b/hw/apb_pci.c index 7e28808ec..c28411a46 100644 --- a/hw/apb_pci.c +++ b/hw/apb_pci.c @@ -85,6 +85,8 @@ typedef struct APBState { unsigned int nr_resets; } APBState; +static void pci_apb_set_irq(void *opaque, int irq_num, int level); + static void apb_config_writel (void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size) { @@ -113,6 +115,16 @@ static void apb_config_writel (void *opaque, target_phys_addr_t addr, s->obio_irq_map[(addr & 0xff) >> 3] |= val & ~PBM_PCI_IMR_MASK; } break; + case 0x1400 ... 0x143f: /* PCI interrupt clear */ + if (addr & 4) { + pci_apb_set_irq(s, (addr & 0x3f) >> 3, 0); + } + break; + case 0x1800 ... 0x1860: /* OBIO interrupt clear */ + if (addr & 4) { + pci_apb_set_irq(s, 0x20 | ((addr & 0xff) >> 3), 0); + } + break; case 0x2000 ... 0x202f: /* PCI control */ s->pci_control[(addr & 0x3f) >> 2] = val; break; @@ -404,6 +416,9 @@ static void pci_pbm_reset(DeviceState *d) for (i = 0; i < 8; i++) { s->pci_irq_map[i] &= PBM_PCI_IMR_MASK; } + for (i = 0; i < 32; i++) { + s->obio_irq_map[i] &= PBM_PCI_IMR_MASK; + } if (s->nr_resets++ == 0) { /* Power on reset */ @@ -426,6 +441,9 @@ static int pci_pbm_init_device(SysBusDevice *dev) for (i = 0; i < 8; i++) { s->pci_irq_map[i] = (0x1f << 6) | (i << 2); } + for (i = 0; i < 32; i++) { + s->obio_irq_map[i] = ((0x1f << 6) | 0x20) + i; + } s->pbm_irqs = qemu_allocate_irqs(pci_apb_set_irq, s, MAX_IVEC); /* apb_config */ @@ -705,6 +705,15 @@ static void fdctrl_raise_irq(FDCtrl *fdctrl, uint8_t status0) qemu_set_irq(fdctrl->irq, 1); fdctrl->sra |= FD_SRA_INTPEND; } + if (status0 & FD_SR0_SEEK) { + FDrive *cur_drv; + /* A seek clears the disk change line (if a disk is inserted) */ + cur_drv = get_cur_drv(fdctrl); + if (cur_drv->max_track) { + cur_drv->media_changed = 0; + } + } + fdctrl->reset_sensei = 0; fdctrl->status0 = status0; FLOPPY_DPRINTF("Set interrupt status to 0x%02x\n", fdctrl->status0); @@ -936,23 +945,7 @@ static void fdctrl_write_ccr(FDCtrl *fdctrl, uint32_t value) static int fdctrl_media_changed(FDrive *drv) { - int ret; - - if (!drv->bs) - return 0; - if (drv->media_changed) { - drv->media_changed = 0; - ret = 1; - } else { - ret = bdrv_media_changed(drv->bs); - if (ret < 0) { - ret = 0; /* we don't know, assume no */ - } - } - if (ret) { - fd_revalidate(drv); - } - return ret; + return drv->media_changed; } /* Digital input register : 0x07 (read-only) */ @@ -1856,6 +1849,7 @@ static void fdctrl_change_cb(void *opaque, bool load) FDrive *drive = opaque; drive->media_changed = 1; + fd_revalidate(drive); } static const BlockDevOps fdctrl_block_ops = { @@ -1886,7 +1880,6 @@ static int fdctrl_connect_drives(FDCtrl *fdctrl) fd_init(drive); fd_revalidate(drive); if (drive->bs) { - drive->media_changed = 1; bdrv_set_dev_ops(drive->bs, &fdctrl_block_ops, drive); } } diff --git a/hw/mips_fulong2e.c b/hw/mips_fulong2e.c index 37dc711e0..1a8df1042 100644 --- a/hw/mips_fulong2e.c +++ b/hw/mips_fulong2e.c @@ -284,7 +284,6 @@ static void mips_fulong2e_init(ram_addr_t ram_size, const char *boot_device, exit(1); } - register_savevm(NULL, "cpu", 0, 3, cpu_save, cpu_load, env); qemu_register_reset(main_cpu_reset, env); /* fulong 2e has 256M ram. */ diff --git a/hw/pc_piix.c b/hw/pc_piix.c index 402194e85..c3fb74ea2 100644 --- a/hw/pc_piix.c +++ b/hw/pc_piix.c @@ -530,6 +530,10 @@ static QEMUMachine pc_machine_v0_12 = { .driver = "virtio-blk-pci",\ .property = "vectors",\ .value = stringify(0),\ + },{\ + .driver = "PCI",\ + .property = "rombar",\ + .value = stringify(0),\ } static QEMUMachine pc_machine_v0_11 = { diff --git a/hw/pc_sysfw.c b/hw/pc_sysfw.c index fafdf9b1c..f0d7c21b5 100644 --- a/hw/pc_sysfw.c +++ b/hw/pc_sysfw.c @@ -85,6 +85,9 @@ static void pc_fw_add_pflash_drv(void) filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); opts = drive_add(IF_PFLASH, -1, filename, "readonly=on"); + + g_free(filename); + if (opts == NULL) { return; } diff --git a/hw/qdev-monitor.c b/hw/qdev-monitor.c index dc4e4e1b8..eed781d2f 100644 --- a/hw/qdev-monitor.c +++ b/hw/qdev-monitor.c @@ -158,7 +158,7 @@ int qdev_device_help(QemuOpts *opts) * for removal. This conditional should be removed along with * it. */ - if (!prop->info->parse) { + if (!prop->info->set) { continue; /* no way to set it, don't show */ } error_printf("%s.%s=%s\n", driver, prop->name, @@ -166,7 +166,7 @@ int qdev_device_help(QemuOpts *opts) } if (info->bus_info) { for (prop = info->bus_info->props; prop && prop->name; prop++) { - if (!prop->info->parse) { + if (!prop->info->set) { continue; /* no way to set it, don't show */ } error_printf("%s.%s=%s\n", driver, prop->name, @@ -493,7 +493,7 @@ static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props, if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) { value = object_property_get_str(OBJECT(dev), legacy_name, &err); } else { - value = object_property_get_str(OBJECT(dev), props->name, &err); + value = object_property_print(OBJECT(dev), props->name, &err); } g_free(legacy_name); diff --git a/hw/qdev-properties.c b/hw/qdev-properties.c index 98dd06aeb..c5545dcd3 100644 --- a/hw/qdev-properties.c +++ b/hw/qdev-properties.c @@ -834,6 +834,7 @@ static void set_pci_devfn(Object *obj, Visitor *v, void *opaque, visit_type_str(v, &str, name, &local_err); if (local_err) { + error_free(local_err); return set_int32(obj, v, opaque, name, errp); } @@ -576,9 +576,12 @@ void qdev_property_add_legacy(DeviceState *dev, Property *prop, { gchar *name, *type; - if (!prop->info->print && !prop->info->parse) { + /* Register pointer properties as legacy properties */ + if (!prop->info->print && !prop->info->parse && + (prop->info->set || prop->info->get)) { return; } + name = g_strdup_printf("legacy-%s", prop->name); type = g_strdup_printf("legacy<%s>", prop->info->legacy_name ?: prop->info->name); diff --git a/hw/qxl-logger.c b/hw/qxl-logger.c index 367aad19f..fe2878c83 100644 --- a/hw/qxl-logger.c +++ b/hw/qxl-logger.c @@ -100,12 +100,15 @@ static const char *qxl_v2n(const char *n[], size_t l, int v) } #define qxl_name(_list, _value) qxl_v2n(_list, ARRAY_SIZE(_list), _value) -static void qxl_log_image(PCIQXLDevice *qxl, QXLPHYSICAL addr, int group_id) +static int qxl_log_image(PCIQXLDevice *qxl, QXLPHYSICAL addr, int group_id) { QXLImage *image; QXLImageDescriptor *desc; image = qxl_phys2virt(qxl, addr, group_id); + if (!image) { + return 1; + } desc = &image->descriptor; fprintf(stderr, " (id %" PRIx64 " type %d flags %d width %d height %d", desc->id, desc->type, desc->flags, desc->width, desc->height); @@ -120,6 +123,7 @@ static void qxl_log_image(PCIQXLDevice *qxl, QXLPHYSICAL addr, int group_id) break; } fprintf(stderr, ")"); + return 0; } static void qxl_log_rect(QXLRect *rect) @@ -130,17 +134,24 @@ static void qxl_log_rect(QXLRect *rect) rect->left, rect->top); } -static void qxl_log_cmd_draw_copy(PCIQXLDevice *qxl, QXLCopy *copy, int group_id) +static int qxl_log_cmd_draw_copy(PCIQXLDevice *qxl, QXLCopy *copy, + int group_id) { + int ret; + fprintf(stderr, " src %" PRIx64, copy->src_bitmap); - qxl_log_image(qxl, copy->src_bitmap, group_id); + ret = qxl_log_image(qxl, copy->src_bitmap, group_id); + if (ret != 0) { + return ret; + } fprintf(stderr, " area"); qxl_log_rect(©->src_area); fprintf(stderr, " rop %d", copy->rop_descriptor); + return 0; } -static void qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw, int group_id) +static int qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw, int group_id) { fprintf(stderr, ": surface_id %d type %s effect %s", draw->surface_id, @@ -148,13 +159,14 @@ static void qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw, int group_id) qxl_name(qxl_draw_effect, draw->effect)); switch (draw->type) { case QXL_DRAW_COPY: - qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id); + return qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id); break; } + return 0; } -static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw, - int group_id) +static int qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw, + int group_id) { fprintf(stderr, ": type %s effect %s", qxl_name(qxl_draw_type, draw->type), @@ -166,9 +178,10 @@ static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw, } switch (draw->type) { case QXL_DRAW_COPY: - qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id); + return qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id); break; } + return 0; } static void qxl_log_cmd_surface(PCIQXLDevice *qxl, QXLSurfaceCmd *cmd) @@ -189,7 +202,7 @@ static void qxl_log_cmd_surface(PCIQXLDevice *qxl, QXLSurfaceCmd *cmd) } } -void qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id) +int qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id) { QXLCursor *cursor; @@ -203,6 +216,9 @@ void qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id) cmd->u.set.visible ? "yes" : "no", cmd->u.set.shape); cursor = qxl_phys2virt(qxl, cmd->u.set.shape, group_id); + if (!cursor) { + return 1; + } fprintf(stderr, " type %s size %dx%d hot-spot +%d+%d" " unique 0x%" PRIx64 " data-size %d", qxl_name(spice_cursor_type, cursor->header.type), @@ -214,15 +230,17 @@ void qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id) fprintf(stderr, " +%d+%d", cmd->u.position.x, cmd->u.position.y); break; } + return 0; } -void qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext) +int qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext) { bool compat = ext->flags & QXL_COMMAND_FLAG_COMPAT; void *data; + int ret; if (!qxl->cmdlog) { - return; + return 0; } fprintf(stderr, "%" PRId64 " qxl-%d/%s:", qemu_get_clock_ns(vm_clock), qxl->id, ring); @@ -231,12 +249,18 @@ void qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext) compat ? "(compat)" : ""); data = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id); + if (!data) { + return 1; + } switch (ext->cmd.type) { case QXL_CMD_DRAW: if (!compat) { - qxl_log_cmd_draw(qxl, data, ext->group_id); + ret = qxl_log_cmd_draw(qxl, data, ext->group_id); } else { - qxl_log_cmd_draw_compat(qxl, data, ext->group_id); + ret = qxl_log_cmd_draw_compat(qxl, data, ext->group_id); + } + if (ret) { + return ret; } break; case QXL_CMD_SURFACE: @@ -247,4 +271,5 @@ void qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext) break; } fprintf(stderr, "\n"); + return 0; } diff --git a/hw/qxl-render.c b/hw/qxl-render.c index f7f1bfda0..e2e3fe2d3 100644 --- a/hw/qxl-render.c +++ b/hw/qxl-render.c @@ -228,14 +228,18 @@ fail: /* called from spice server thread context only */ -void qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext) +int qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext) { QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id); QXLCursor *cursor; QEMUCursor *c; + if (!cmd) { + return 1; + } + if (!qxl->ssd.ds->mouse_set || !qxl->ssd.ds->cursor_define) { - return; + return 0; } if (qxl->debug > 1 && cmd->type != QXL_CURSOR_MOVE) { @@ -246,9 +250,12 @@ void qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext) switch (cmd->type) { case QXL_CURSOR_SET: cursor = qxl_phys2virt(qxl, cmd->u.set.shape, ext->group_id); + if (!cursor) { + return 1; + } if (cursor->chunk.data_size != cursor->data_size) { fprintf(stderr, "%s: multiple chunks\n", __FUNCTION__); - return; + return 1; } c = qxl_cursor(qxl, cursor); if (c == NULL) { @@ -270,4 +277,5 @@ void qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext) qemu_mutex_unlock(&qxl->ssd.lock); break; } + return 0; } @@ -27,28 +27,42 @@ #include "qxl.h" +/* + * NOTE: SPICE_RING_PROD_ITEM accesses memory on the pci bar and as + * such can be changed by the guest, so to avoid a guest trigerrable + * abort we just set qxl_guest_bug and set the return to NULL. Still + * it may happen as a result of emulator bug as well. + */ #undef SPICE_RING_PROD_ITEM -#define SPICE_RING_PROD_ITEM(r, ret) { \ +#define SPICE_RING_PROD_ITEM(qxl, r, ret) { \ typeof(r) start = r; \ typeof(r) end = r + 1; \ uint32_t prod = (r)->prod & SPICE_RING_INDEX_MASK(r); \ typeof(&(r)->items[prod]) m_item = &(r)->items[prod]; \ if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \ - abort(); \ + qxl_guest_bug(qxl, "SPICE_RING_PROD_ITEM indices mismatch " \ + "! %p <= %p < %p", (uint8_t *)start, \ + (uint8_t *)m_item, (uint8_t *)end); \ + ret = NULL; \ + } else { \ + ret = &m_item->el; \ } \ - ret = &m_item->el; \ } #undef SPICE_RING_CONS_ITEM -#define SPICE_RING_CONS_ITEM(r, ret) { \ +#define SPICE_RING_CONS_ITEM(qxl, r, ret) { \ typeof(r) start = r; \ typeof(r) end = r + 1; \ uint32_t cons = (r)->cons & SPICE_RING_INDEX_MASK(r); \ typeof(&(r)->items[cons]) m_item = &(r)->items[cons]; \ if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \ - abort(); \ + qxl_guest_bug(qxl, "SPICE_RING_CONS_ITEM indices mismatch " \ + "! %p <= %p < %p", (uint8_t *)start, \ + (uint8_t *)m_item, (uint8_t *)end); \ + ret = NULL; \ + } else { \ + ret = &m_item->el; \ } \ - ret = &m_item->el; \ } #undef ALIGN @@ -343,7 +357,8 @@ static void init_qxl_ram(PCIQXLDevice *d) SPICE_RING_INIT(&d->ram->cmd_ring); SPICE_RING_INIT(&d->ram->cursor_ring); SPICE_RING_INIT(&d->ram->release_ring); - SPICE_RING_PROD_ITEM(&d->ram->release_ring, item); + SPICE_RING_PROD_ITEM(d, &d->ram->release_ring, item); + assert(item); *item = 0; qxl_ring_set_dirty(d); } @@ -383,14 +398,22 @@ static void qxl_ring_set_dirty(PCIQXLDevice *qxl) * keep track of some command state, for savevm/loadvm. * called from spice server thread context only */ -static void qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) +static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) { switch (le32_to_cpu(ext->cmd.type)) { case QXL_CMD_SURFACE: { QXLSurfaceCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id); + + if (!cmd) { + return 1; + } uint32_t id = le32_to_cpu(cmd->surface_id); - PANIC_ON(id >= NUM_SURFACES); + + if (id >= NUM_SURFACES) { + qxl_guest_bug(qxl, "QXL_CMD_SURFACE id %d >= %d", id, NUM_SURFACES); + return 1; + } qemu_mutex_lock(&qxl->track_lock); if (cmd->type == QXL_SURFACE_CMD_CREATE) { qxl->guest_surfaces.cmds[id] = ext->cmd.data; @@ -408,6 +431,10 @@ static void qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) case QXL_CMD_CURSOR: { QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id); + + if (!cmd) { + return 1; + } if (cmd->type == QXL_CURSOR_SET) { qemu_mutex_lock(&qxl->track_lock); qxl->guest_cursor = ext->cmd.data; @@ -416,6 +443,7 @@ static void qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) break; } } + return 0; } /* spice display interface callbacks */ @@ -546,8 +574,10 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext) if (SPICE_RING_IS_EMPTY(ring)) { return false; } - trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->mode)); - SPICE_RING_CONS_ITEM(ring, cmd); + SPICE_RING_CONS_ITEM(qxl, ring, cmd); + if (!cmd) { + return false; + } ext->cmd = *cmd; ext->group_id = MEMSLOT_GROUP_GUEST; ext->flags = qxl->cmdflags; @@ -559,6 +589,7 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext) qxl->guest_primary.commands++; qxl_track_command(qxl, ext); qxl_log_command(qxl, "cmd", ext); + trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->mode)); return true; default: return false; @@ -617,7 +648,10 @@ static inline void qxl_push_free_res(PCIQXLDevice *d, int flush) if (notify) { qxl_send_events(d, QXL_INTERRUPT_DISPLAY); } - SPICE_RING_PROD_ITEM(ring, item); + SPICE_RING_PROD_ITEM(d, ring, item); + if (!item) { + return; + } *item = 0; d->num_free_res = 0; d->last_release = NULL; @@ -643,7 +677,10 @@ static void interface_release_resource(QXLInstance *sin, * pci bar 0, $command.release_info */ ring = &qxl->ram->release_ring; - SPICE_RING_PROD_ITEM(ring, item); + SPICE_RING_PROD_ITEM(qxl, ring, item); + if (!item) { + return; + } if (*item == 0) { /* stick head into the ring */ id = ext.info->id; @@ -682,7 +719,10 @@ static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt * if (SPICE_RING_IS_EMPTY(ring)) { return false; } - SPICE_RING_CONS_ITEM(ring, cmd); + SPICE_RING_CONS_ITEM(qxl, ring, cmd); + if (!cmd) { + return false; + } ext->cmd = *cmd; ext->group_id = MEMSLOT_GROUP_GUEST; ext->flags = qxl->cmdflags; @@ -728,8 +768,13 @@ static int interface_req_cursor_notification(QXLInstance *sin) /* called from spice server thread context */ static void interface_notify_update(QXLInstance *sin, uint32_t update_id) { - fprintf(stderr, "%s: abort()\n", __FUNCTION__); - abort(); + /* + * Called by spice-server as a result of a QXL_CMD_UPDATE which is not in + * use by xf86-video-qxl and is defined out in the qxl windows driver. + * Probably was at some earlier version that is prior to git start (2009), + * and is still guest trigerrable. + */ + fprintf(stderr, "%s: deprecated\n", __func__); } /* called from spice server thread context only */ @@ -764,8 +809,8 @@ static void interface_async_complete_io(PCIQXLDevice *qxl, QXLCookie *cookie) } if (cookie && current_async != cookie->io) { fprintf(stderr, - "qxl: %s: error: current_async = %d != %" PRId64 " = cookie->io\n", - __func__, current_async, cookie->io); + "qxl: %s: error: current_async = %d != %" + PRId64 " = cookie->io\n", __func__, current_async, cookie->io); } switch (current_async) { case QXL_IO_MEMSLOT_ADD_ASYNC: @@ -993,8 +1038,8 @@ static const MemoryRegionPortio qxl_vga_portio_list[] = { PORTIO_END_OF_LIST(), }; -static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, - qxl_async_io async) +static int qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, + qxl_async_io async) { static const int regions[] = { QXL_RAM_RANGE_INDEX, @@ -1015,8 +1060,16 @@ static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, trace_qxl_memslot_add_guest(d->id, slot_id, guest_start, guest_end); - PANIC_ON(slot_id >= NUM_MEMSLOTS); - PANIC_ON(guest_start > guest_end); + if (slot_id >= NUM_MEMSLOTS) { + qxl_guest_bug(d, "%s: slot_id >= NUM_MEMSLOTS %d >= %d", __func__, + slot_id, NUM_MEMSLOTS); + return 1; + } + if (guest_start > guest_end) { + qxl_guest_bug(d, "%s: guest_start > guest_end 0x%" PRIx64 + " > 0x%" PRIx64, __func__, guest_start, guest_end); + return 1; + } for (i = 0; i < ARRAY_SIZE(regions); i++) { pci_region = regions[i]; @@ -1037,7 +1090,10 @@ static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, /* passed */ break; } - PANIC_ON(i == ARRAY_SIZE(regions)); /* finished loop without match */ + if (i == ARRAY_SIZE(regions)) { + qxl_guest_bug(d, "%s: finished loop without match", __func__); + return 1; + } switch (pci_region) { case QXL_RAM_RANGE_INDEX: @@ -1049,7 +1105,8 @@ static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, break; default: /* should not happen */ - abort(); + qxl_guest_bug(d, "%s: pci_region = %d", __func__, pci_region); + return 1; } memslot.slot_id = slot_id; @@ -1065,6 +1122,7 @@ static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta, d->guest_slots[slot_id].size = memslot.virt_end - memslot.virt_start; d->guest_slots[slot_id].delta = delta; d->guest_slots[slot_id].active = 1; + return 0; } static void qxl_del_memslot(PCIQXLDevice *d, uint32_t slot_id) @@ -1097,15 +1155,28 @@ void *qxl_phys2virt(PCIQXLDevice *qxl, QXLPHYSICAL pqxl, int group_id) case MEMSLOT_GROUP_HOST: return (void *)(intptr_t)offset; case MEMSLOT_GROUP_GUEST: - PANIC_ON(slot >= NUM_MEMSLOTS); - PANIC_ON(!qxl->guest_slots[slot].active); - PANIC_ON(offset < qxl->guest_slots[slot].delta); + if (slot >= NUM_MEMSLOTS) { + qxl_guest_bug(qxl, "slot too large %d >= %d", slot, NUM_MEMSLOTS); + return NULL; + } + if (!qxl->guest_slots[slot].active) { + qxl_guest_bug(qxl, "inactive slot %d\n", slot); + return NULL; + } + if (offset < qxl->guest_slots[slot].delta) { + qxl_guest_bug(qxl, "slot %d offset %"PRIu64" < delta %"PRIu64"\n", + slot, offset, qxl->guest_slots[slot].delta); + return NULL; + } offset -= qxl->guest_slots[slot].delta; - PANIC_ON(offset > qxl->guest_slots[slot].size) + if (offset > qxl->guest_slots[slot].size) { + qxl_guest_bug(qxl, "slot %d offset %"PRIu64" > size %"PRIu64"\n", + slot, offset, qxl->guest_slots[slot].size); + return NULL; + } return qxl->guest_slots[slot].ptr + offset; - default: - PANIC_ON(1); } + return NULL; } static void qxl_create_guest_primary_complete(PCIQXLDevice *qxl) @@ -1120,7 +1191,10 @@ static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm, QXLDevSurfaceCreate surface; QXLSurfaceCreate *sc = &qxl->guest_primary.surface; - assert(qxl->mode != QXL_MODE_NATIVE); + if (qxl->mode == QXL_MODE_NATIVE) { + qxl_guest_bug(qxl, "%s: nop since already in QXL_MODE_NATIVE", + __func__); + } qxl_exit_vga_mode(qxl); surface.format = le32_to_cpu(sc->format); @@ -1192,7 +1266,7 @@ static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm) } d->guest_slots[0].slot = slot; - qxl_add_memslot(d, 0, devmem, QXL_SYNC); + assert(qxl_add_memslot(d, 0, devmem, QXL_SYNC) == 0); d->guest_primary.surface = surface; qxl_create_guest_primary(d, 0, QXL_SYNC); @@ -1393,8 +1467,7 @@ async_common: qxl_spice_destroy_surfaces(d, async); break; default: - fprintf(stderr, "%s: ioport=0x%x, abort()\n", __FUNCTION__, io_port); - abort(); + qxl_guest_bug(d, "%s: unexpected ioport=0x%x\n", __func__, io_port); } return; cancel_async: @@ -1450,7 +1523,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events) qxl_update_irq(d); } else { if (write(d->pipe[1], d, 1) != 1) { - dprint(d, 1, "%s: write to pipe failed\n", __FUNCTION__); + dprint(d, 1, "%s: write to pipe failed\n", __func__); } } } @@ -1555,10 +1628,12 @@ static void qxl_dirty_surfaces(PCIQXLDevice *qxl) cmd = qxl_phys2virt(qxl, qxl->guest_surfaces.cmds[i], MEMSLOT_GROUP_GUEST); + assert(cmd); assert(cmd->type == QXL_SURFACE_CMD_CREATE); surface_offset = (intptr_t)qxl_phys2virt(qxl, cmd->u.surface_create.data, MEMSLOT_GROUP_GUEST); + assert(surface_offset); surface_offset -= vram_start; surface_size = cmd->u.surface_create.height * abs(cmd->u.surface_create.stride); @@ -1671,13 +1746,16 @@ static int qxl_init_common(PCIQXLDevice *qxl) switch (qxl->revision) { case 1: /* spice 0.4 -- qxl-1 */ pci_device_rev = QXL_REVISION_STABLE_V04; + io_size = 8; break; case 2: /* spice 0.6 -- qxl-2 */ pci_device_rev = QXL_REVISION_STABLE_V06; + io_size = 16; break; case 3: /* qxl-3 */ default: pci_device_rev = QXL_DEFAULT_REVISION; + io_size = msb_mask(QXL_IO_RANGE_SIZE * 2 - 1); break; } @@ -1695,11 +1773,6 @@ static int qxl_init_common(PCIQXLDevice *qxl) memory_region_init_alias(&qxl->vram32_bar, "qxl.vram32", &qxl->vram_bar, 0, qxl->vram32_size); - io_size = msb_mask(QXL_IO_RANGE_SIZE * 2 - 1); - if (qxl->revision == 1) { - io_size = 8; - } - memory_region_init_io(&qxl->io_bar, &qxl_io_ops, qxl, "qxl-ioports", io_size); if (qxl->id == 0) { @@ -142,12 +142,12 @@ void qxl_spice_reset_image_cache(PCIQXLDevice *qxl); void qxl_spice_reset_cursor(PCIQXLDevice *qxl); /* qxl-logger.c */ -void qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id); -void qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext); +int qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id); +int qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext); /* qxl-render.c */ void qxl_render_resize(PCIQXLDevice *qxl); void qxl_render_update(PCIQXLDevice *qxl); -void qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext); +int qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext); void qxl_render_update_area_done(PCIQXLDevice *qxl, QXLCookie *cookie); void qxl_render_update_area_bh(void *opaque); diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c index dbdb99ce3..8ab9bcda8 100644 --- a/hw/scsi-bus.c +++ b/hw/scsi-bus.c @@ -239,6 +239,18 @@ int scsi_bus_legacy_handle_cmdline(SCSIBus *bus) return res; } +static int32_t scsi_invalid_field(SCSIRequest *req, uint8_t *buf) +{ + scsi_req_build_sense(req, SENSE_CODE(INVALID_FIELD)); + scsi_req_complete(req, CHECK_CONDITION); + return 0; +} + +static const struct SCSIReqOps reqops_invalid_field = { + .size = sizeof(SCSIRequest), + .send_command = scsi_invalid_field +}; + /* SCSIReqOps implementation for invalid commands. */ static int32_t scsi_invalid_command(SCSIRequest *req, uint8_t *buf) @@ -355,10 +367,6 @@ static bool scsi_target_emulate_inquiry(SCSITargetReq *r) if (r->req.cmd.buf[1] & 0x1) { /* Vital product data */ uint8_t page_code = r->req.cmd.buf[2]; - if (r->req.cmd.xfer < 4) { - return false; - } - r->buf[r->len++] = page_code ; /* this page */ r->buf[r->len++] = 0x00; @@ -386,10 +394,6 @@ static bool scsi_target_emulate_inquiry(SCSITargetReq *r) } /* PAGE CODE == 0 */ - if (r->req.cmd.xfer < 5) { - return false; - } - r->len = MIN(r->req.cmd.xfer, 36); memset(r->buf, 0, r->len); if (r->req.lun != 0) { @@ -423,9 +427,6 @@ static int32_t scsi_target_send_command(SCSIRequest *req, uint8_t *buf) } break; case REQUEST_SENSE: - if (req->cmd.xfer < 4) { - goto illegal_request; - } r->len = scsi_device_get_sense(r->req.dev, r->buf, MIN(req->cmd.xfer, sizeof r->buf), (req->cmd.buf[1] & 1) == 0); @@ -517,23 +518,25 @@ SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun, cmd.lba); } - if ((d->unit_attention.key == UNIT_ATTENTION || - bus->unit_attention.key == UNIT_ATTENTION) && - (buf[0] != INQUIRY && - buf[0] != REPORT_LUNS && - buf[0] != GET_CONFIGURATION && - buf[0] != GET_EVENT_STATUS_NOTIFICATION && - - /* - * If we already have a pending unit attention condition, - * report this one before triggering another one. - */ - !(buf[0] == REQUEST_SENSE && d->sense_is_ua))) { + if (cmd.xfer > INT32_MAX) { + req = scsi_req_alloc(&reqops_invalid_field, d, tag, lun, hba_private); + } else if ((d->unit_attention.key == UNIT_ATTENTION || + bus->unit_attention.key == UNIT_ATTENTION) && + (buf[0] != INQUIRY && + buf[0] != REPORT_LUNS && + buf[0] != GET_CONFIGURATION && + buf[0] != GET_EVENT_STATUS_NOTIFICATION && + + /* + * If we already have a pending unit attention condition, + * report this one before triggering another one. + */ + !(buf[0] == REQUEST_SENSE && d->sense_is_ua))) { req = scsi_req_alloc(&reqops_unit_attention, d, tag, lun, hba_private); } else if (lun != d->lun || - buf[0] == REPORT_LUNS || - (buf[0] == REQUEST_SENSE && (d->sense_len || cmd.xfer < 4))) { + buf[0] == REPORT_LUNS || + (buf[0] == REQUEST_SENSE && d->sense_len)) { req = scsi_req_alloc(&reqops_target_command, d, tag, lun, hba_private); } else { @@ -646,7 +649,7 @@ void scsi_req_build_sense(SCSIRequest *req, SCSISense sense) trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag, sense.key, sense.asc, sense.ascq); memset(req->sense, 0, 18); - req->sense[0] = 0xf0; + req->sense[0] = 0x70; req->sense[2] = sense.key; req->sense[7] = 10; req->sense[12] = sense.asc; @@ -721,10 +724,6 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf) case 0: cmd->xfer = buf[4]; cmd->len = 6; - /* length 0 means 256 blocks */ - if (cmd->xfer == 0) { - cmd->xfer = 256; - } break; case 1: case 2: @@ -777,7 +776,8 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf) case MODE_SENSE: break; case WRITE_SAME_10: - cmd->xfer = 1; + case WRITE_SAME_16: + cmd->xfer = dev->blocksize; break; case READ_CAPACITY_10: cmd->xfer = 8; @@ -793,18 +793,26 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf) cmd->xfer = buf[9] | (buf[8] << 8); } break; + case WRITE_6: + /* length 0 means 256 blocks */ + if (cmd->xfer == 0) { + cmd->xfer = 256; + } case WRITE_10: case WRITE_VERIFY_10: - case WRITE_6: case WRITE_12: case WRITE_VERIFY_12: case WRITE_16: case WRITE_VERIFY_16: cmd->xfer *= dev->blocksize; break; - case READ_10: case READ_6: case READ_REVERSE: + /* length 0 means 256 blocks */ + if (cmd->xfer == 0) { + cmd->xfer = 256; + } + case READ_10: case RECOVER_BUFFERED_DATA: case READ_12: case READ_16: @@ -872,6 +880,16 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu cmd->xfer *= dev->blocksize; } break; + case READ_16: + case READ_REVERSE_16: + case VERIFY_16: + case WRITE_16: + cmd->len = 16; + cmd->xfer = buf[14] | (buf[13] << 8) | (buf[12] << 16); + if (buf[1] & 0x01) { /* fixed */ + cmd->xfer *= dev->blocksize; + } + break; case REWIND: case START_STOP: cmd->len = 6; @@ -895,6 +913,10 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu static void scsi_cmd_xfer_mode(SCSICommand *cmd) { + if (!cmd->xfer) { + cmd->mode = SCSI_XFER_NONE; + return; + } switch (cmd->buf[0]) { case WRITE_6: case WRITE_10: @@ -920,6 +942,8 @@ static void scsi_cmd_xfer_mode(SCSICommand *cmd) case UPDATE_BLOCK: case WRITE_LONG_10: case WRITE_SAME_10: + case WRITE_SAME_16: + case UNMAP: case SEARCH_HIGH_12: case SEARCH_EQUAL_12: case SEARCH_LOW_12: @@ -929,14 +953,11 @@ static void scsi_cmd_xfer_mode(SCSICommand *cmd) case SEND_DVD_STRUCTURE: case PERSISTENT_RESERVE_OUT: case MAINTENANCE_OUT: + case ATA_PASSTHROUGH: cmd->mode = SCSI_XFER_TO_DEV; break; default: - if (cmd->xfer) - cmd->mode = SCSI_XFER_FROM_DEV; - else { - cmd->mode = SCSI_XFER_NONE; - } + cmd->mode = SCSI_XFER_FROM_DEV; break; } } @@ -1127,7 +1148,7 @@ int scsi_build_sense(uint8_t *in_buf, int in_len, memset(buf, 0, len); if (fixed) { /* Return fixed format sense buffer */ - buf[0] = 0xf0; + buf[0] = 0x70; buf[2] = sense.key; buf[7] = 10; buf[12] = sense.asc; @@ -1270,6 +1291,7 @@ SCSIRequest *scsi_req_ref(SCSIRequest *req) void scsi_req_unref(SCSIRequest *req) { + assert(req->refcount > 0); if (--req->refcount == 0) { if (req->ops->free_req) { req->ops->free_req(req); diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h index ca24192d5..219c84dfb 100644 --- a/hw/scsi-defs.h +++ b/hw/scsi-defs.h @@ -92,6 +92,7 @@ #define PERSISTENT_RESERVE_OUT 0x5f #define VARLENGTH_CDB 0x7f #define WRITE_FILEMARKS_16 0x80 +#define READ_REVERSE_16 0x81 #define ALLOW_OVERWRITE 0x82 #define EXTENDED_COPY 0x83 #define ATA_PASSTHROUGH 0x85 diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c index a029ab6e8..045c764d9 100644 --- a/hw/scsi-disk.c +++ b/hw/scsi-disk.c @@ -28,9 +28,6 @@ do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0) #define DPRINTF(fmt, ...) do {} while(0) #endif -#define BADF(fmt, ...) \ -do { fprintf(stderr, "scsi-disk: " fmt , ## __VA_ARGS__); } while (0) - #include "qemu-common.h" #include "qemu-error.h" #include "scsi.h" @@ -61,10 +58,13 @@ typedef struct SCSIDiskReq { BlockAcctCookie acct; } SCSIDiskReq; +#define SCSI_DISK_F_REMOVABLE 0 +#define SCSI_DISK_F_DPOFUA 1 + struct SCSIDiskState { SCSIDevice qdev; - uint32_t removable; + uint32_t features; bool media_changed; bool media_event; bool eject_request; @@ -296,6 +296,13 @@ static void scsi_do_read(void *opaque, int ret) } } + if (r->req.io_canceled) { + return; + } + + /* The request is used as the AIO opaque value, so add a ref. */ + scsi_req_ref(&r->req); + if (r->req.sg) { dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BDRV_ACCT_READ); r->req.resid -= r->req.sg->size; @@ -505,20 +512,9 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); int buflen = 0; - if (req->cmd.buf[1] & 0x2) { - /* Command support data - optional, not implemented */ - BADF("optional INQUIRY command support request not implemented\n"); - return -1; - } - if (req->cmd.buf[1] & 0x1) { /* Vital product data */ uint8_t page_code = req->cmd.buf[2]; - if (req->cmd.xfer < 4) { - BADF("Error: Inquiry (EVPD[%02X]) buffer size %zd is " - "less than 4\n", page_code, req->cmd.xfer); - return -1; - } outbuf[buflen++] = s->qdev.type & 0x1f; outbuf[buflen++] = page_code ; // this page @@ -633,8 +629,6 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) break; } default: - BADF("Error: unsupported Inquiry (EVPD[%02X]) " - "buffer size %zd\n", page_code, req->cmd.xfer); return -1; } /* done with EVPD */ @@ -643,18 +637,10 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) /* Standard INQUIRY data */ if (req->cmd.buf[2] != 0) { - BADF("Error: Inquiry (STANDARD) page or code " - "is non-zero [%02X]\n", req->cmd.buf[2]); return -1; } /* PAGE CODE == 0 */ - if (req->cmd.xfer < 5) { - BADF("Error: Inquiry (STANDARD) buffer size %zd " - "is less than 5\n", req->cmd.xfer); - return -1; - } - buflen = req->cmd.xfer; if (buflen > SCSI_MAX_INQUIRY_LEN) { buflen = SCSI_MAX_INQUIRY_LEN; @@ -662,7 +648,7 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) memset(outbuf, 0, buflen); outbuf[0] = s->qdev.type & 0x1f; - outbuf[1] = s->removable ? 0x80 : 0; + outbuf[1] = (s->features & (1 << SCSI_DISK_F_REMOVABLE)) ? 0x80 : 0; if (s->qdev.type == TYPE_ROM) { memcpy(&outbuf[16], "QEMU CD-ROM ", 16); } else { @@ -1094,7 +1080,7 @@ static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf) p = outbuf; if (s->qdev.type == TYPE_DISK) { - dev_specific_param = 0x10; /* DPOFUA */ + dev_specific_param = s->features & (1 << SCSI_DISK_F_DPOFUA) ? 0x10 : 0; if (bdrv_is_read_only(s->qdev.conf.bs)) { dev_specific_param |= 0x80; /* Readonly. */ } @@ -1559,8 +1545,11 @@ static int32_t scsi_send_command(SCSIRequest *req, uint8_t *buf) } break; case WRITE_SAME_10: + len = lduw_be_p(&buf[7]); + goto write_same; case WRITE_SAME_16: - len = r->req.cmd.xfer / s->qdev.blocksize; + len = ldl_be_p(&buf[10]) & 0xffffffffULL; + write_same: DPRINTF("WRITE SAME() (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len); @@ -1700,7 +1689,8 @@ static int scsi_initfn(SCSIDevice *dev) return -1; } - if (!s->removable && !bdrv_is_inserted(s->qdev.conf.bs)) { + if (!(s->features & (1 << SCSI_DISK_F_REMOVABLE)) && + !bdrv_is_inserted(s->qdev.conf.bs)) { error_report("Device needs media, but drive is empty"); return -1; } @@ -1722,7 +1712,7 @@ static int scsi_initfn(SCSIDevice *dev) return -1; } - if (s->removable) { + if (s->features & (1 << SCSI_DISK_F_REMOVABLE)) { bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_cd_block_ops, s); } bdrv_set_buffer_alignment(s->qdev.conf.bs, s->qdev.blocksize); @@ -1745,7 +1735,7 @@ static int scsi_cd_initfn(SCSIDevice *dev) SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); s->qdev.blocksize = 2048; s->qdev.type = TYPE_ROM; - s->removable = true; + s->features |= 1 << SCSI_DISK_F_REMOVABLE; return scsi_initfn(&s->qdev); } @@ -1818,7 +1808,9 @@ static int get_device_type(SCSIDiskState *s) return -1; } s->qdev.type = buf[0]; - s->removable = (buf[1] & 0x80) != 0; + if (buf[1] & 0x80) { + s->features |= 1 << SCSI_DISK_F_REMOVABLE; + } return 0; } @@ -1918,7 +1910,10 @@ static SCSIRequest *scsi_block_new_request(SCSIDevice *d, uint32_t tag, static Property scsi_hd_properties[] = { DEFINE_SCSI_DISK_PROPERTIES(), - DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false), + DEFINE_PROP_BIT("removable", SCSIDiskState, features, + SCSI_DISK_F_REMOVABLE, false), + DEFINE_PROP_BIT("dpofua", SCSIDiskState, features, + SCSI_DISK_F_DPOFUA, false), DEFINE_PROP_END_OF_LIST(), }; @@ -2020,7 +2015,10 @@ static TypeInfo scsi_block_info = { static Property scsi_disk_properties[] = { DEFINE_SCSI_DISK_PROPERTIES(), - DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false), + DEFINE_PROP_BIT("removable", SCSIDiskState, features, + SCSI_DISK_F_REMOVABLE, false), + DEFINE_PROP_BIT("dpofua", SCSIDiskState, features, + SCSI_DISK_F_DPOFUA, false), DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c index 4ff4d40a8..e759c996c 100644 --- a/hw/usb/hcd-ehci.c +++ b/hw/usb/hcd-ehci.c @@ -1091,8 +1091,8 @@ static void ehci_mem_writel(void *ptr, target_phys_addr_t addr, uint32_t val) break; case USBSTS: - val &= USBSTS_RO_MASK; // bits 6 thru 31 are RO - ehci_clear_usbsts(s, val); // bits 0 thru 5 are R/WC + val &= USBSTS_RO_MASK; // bits 6 through 31 are RO + ehci_clear_usbsts(s, val); // bits 0 through 5 are R/WC val = s->usbsts; ehci_set_interrupt(s, 0); break; diff --git a/hw/usb/host-linux.c b/hw/usb/host-linux.c index 048f8ffa8..a95b0eda5 100644 --- a/hw/usb/host-linux.c +++ b/hw/usb/host-linux.c @@ -1058,6 +1058,15 @@ static int usb_host_handle_control(USBDevice *dev, USBPacket *p, ret = usb_host_set_interface(s, index, value); trace_usb_host_req_emulated(s->bus_num, s->addr, p, ret); return ret; + + case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: + if (value == 0) { /* clear halt */ + int pid = (index & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT; + ioctl(s->fd, USBDEVFS_CLEAR_HALT, &index); + clear_halt(s, pid, index & 0x0f); + trace_usb_host_req_emulated(s->bus_num, s->addr, p, 0); + return 0; + } } /* The rest are asynchronous */ diff --git a/include/qemu/cpu.h b/include/qemu/cpu.h index 4291279bc..78b65b35f 100644 --- a/include/qemu/cpu.h +++ b/include/qemu/cpu.h @@ -39,7 +39,7 @@ typedef struct CPUState CPUState; /** * CPUClass: - * @reset: Callback to reset the #CPU to its initial state. + * @reset: Callback to reset the #CPUState to its initial state. * * Represents a CPU family or model. */ @@ -61,7 +61,7 @@ struct CPUState { Object parent_obj; /*< public >*/ - /* TODO Move common fields from CPUState here. */ + /* TODO Move common fields from CPUArchState here. */ }; diff --git a/include/qemu/object.h b/include/qemu/object.h index ca1649c91..d93b77293 100644 --- a/include/qemu/object.h +++ b/include/qemu/object.h @@ -555,6 +555,12 @@ ObjectClass *object_class_dynamic_cast(ObjectClass *klass, */ const char *object_class_get_name(ObjectClass *klass); +/** + * object_class_by_name: + * @typename: The QOM typename to obtain the class for. + * + * Returns: The class for @typename or %NULL if not found. + */ ObjectClass *object_class_by_name(const char *typename); void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque), @@ -130,7 +130,7 @@ void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry) void kbd_put_keycode(int keycode) { - if (!runstate_is_running()) { + if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { return; } if (qemu_put_kbd_event) { @@ -154,7 +154,7 @@ void kbd_mouse_event(int dx, int dy, int dz, int buttons_state) void *mouse_event_opaque; int width, height; - if (!runstate_is_running()) { + if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { return; } if (QTAILQ_EMPTY(&mouse_handlers)) { @@ -349,6 +349,7 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, unsigned long page_number, c; target_phys_addr_t addr, addr1; unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS; + unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; /* * bitmap-traveling is faster than memory-traveling (for addr...) @@ -360,10 +361,11 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, do { j = ffsl(c) - 1; c &= ~(1ul << j); - page_number = i * HOST_LONG_BITS + j; + 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); + memory_region_set_dirty(section->mr, addr, + TARGET_PAGE_SIZE * hpratio); } while (c != 0); } } @@ -987,6 +989,14 @@ int kvm_init(void) s = g_malloc0(sizeof(KVMState)); + /* + * On systems where the kernel can support different base page + * sizes, host page size may be different from TARGET_PAGE_SIZE, + * even with KVM. TARGET_PAGE_SIZE is assumed to be the minimum + * page size for the system though. + */ + assert(TARGET_PAGE_SIZE <= getpagesize()); + #ifdef KVM_CAP_SET_GUEST_DEBUG QTAILQ_INIT(&s->kvm_sw_breakpoints); #endif diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 712861829..20d2a7487 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -4866,13 +4866,53 @@ int get_osversion(void) static int open_self_maps(void *cpu_env, int fd) { +#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32) TaskState *ts = ((CPUArchState *)cpu_env)->opaque; +#endif + FILE *fp; + char *line = NULL; + size_t len = 0; + ssize_t read; + + fp = fopen("/proc/self/maps", "r"); + if (fp == NULL) { + return -EACCES; + } + + while ((read = getline(&line, &len, fp)) != -1) { + int fields, dev_maj, dev_min, inode; + uint64_t min, max, offset; + char flag_r, flag_w, flag_x, flag_p; + char path[512] = ""; + fields = sscanf(line, "%"PRIx64"-%"PRIx64" %c%c%c%c %"PRIx64" %x:%x %d" + " %512s", &min, &max, &flag_r, &flag_w, &flag_x, + &flag_p, &offset, &dev_maj, &dev_min, &inode, path); + if ((fields < 10) || (fields > 11)) { + continue; + } + if (!strncmp(path, "[stack]", 7)) { + continue; + } + if (h2g_valid(min) && h2g_valid(max)) { + dprintf(fd, TARGET_ABI_FMT_lx "-" TARGET_ABI_FMT_lx + " %c%c%c%c %08" PRIx64 " %02x:%02x %d%s%s\n", + h2g(min), h2g(max), flag_r, flag_w, + flag_x, flag_p, offset, dev_maj, dev_min, inode, + path[0] ? " " : "", path); + } + } + + free(line); + fclose(fp); + +#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32) dprintf(fd, "%08llx-%08llx rw-p %08llx 00:00 0 [stack]\n", (unsigned long long)ts->info->stack_limit, (unsigned long long)(ts->stack_base + (TARGET_PAGE_SIZE - 1)) & TARGET_PAGE_MASK, - (unsigned long long)ts->stack_base); + (unsigned long long)0); +#endif return 0; } @@ -5045,11 +5085,7 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, NULL, NULL, 0); } thread_env = NULL; -#ifdef ENV_GET_CPU object_delete(OBJECT(ENV_GET_CPU(cpu_env))); -#else - g_free(cpu_env); -#endif g_free(ts); pthread_exit(NULL); } diff --git a/main-loop.h b/main-loop.h index c06b8bc44..dce1cd9d7 100644 --- a/main-loop.h +++ b/main-loop.h @@ -25,11 +25,7 @@ #ifndef QEMU_MAIN_LOOP_H #define QEMU_MAIN_LOOP_H 1 -#ifdef SIGRTMIN -#define SIG_IPI (SIGRTMIN+4) -#else #define SIG_IPI SIGUSR1 -#endif /** * qemu_init_main_loop: Set up the process so that it can run the main loop. diff --git a/migration-tcp.c b/migration-tcp.c index 35a578182..440804db7 100644 --- a/migration-tcp.c +++ b/migration-tcp.c @@ -79,45 +79,32 @@ static void tcp_wait_for_connect(void *opaque) } } -int tcp_start_outgoing_migration(MigrationState *s, const char *host_port) +int tcp_start_outgoing_migration(MigrationState *s, const char *host_port, + Error **errp) { - struct sockaddr_in addr; - int ret; - - ret = parse_host_port(&addr, host_port); - if (ret < 0) { - return ret; - } - s->get_error = socket_errno; s->write = socket_write; s->close = tcp_close; - s->fd = qemu_socket(PF_INET, SOCK_STREAM, 0); - if (s->fd == -1) { - DPRINTF("Unable to open socket"); - return -socket_error(); - } - - socket_set_nonblock(s->fd); - - do { - ret = connect(s->fd, (struct sockaddr *)&addr, sizeof(addr)); - if (ret == -1) { - ret = -socket_error(); - } - if (ret == -EINPROGRESS || ret == -EWOULDBLOCK) { - qemu_set_fd_handler2(s->fd, NULL, NULL, tcp_wait_for_connect, s); - return 0; - } - } while (ret == -EINTR); + s->fd = inet_connect(host_port, false, errp); - if (ret < 0) { + if (!error_is_set(errp)) { + migrate_fd_connect(s); + } else if (error_is_type(*errp, QERR_SOCKET_CONNECT_IN_PROGRESS)) { + DPRINTF("connect in progress\n"); + qemu_set_fd_handler2(s->fd, NULL, NULL, tcp_wait_for_connect, s); + } else if (error_is_type(*errp, QERR_SOCKET_CREATE_FAILED)) { + DPRINTF("connect failed\n"); + return -1; + } else if (error_is_type(*errp, QERR_SOCKET_CONNECT_FAILED)) { DPRINTF("connect failed\n"); migrate_fd_error(s); - return ret; + return -1; + } else { + DPRINTF("unknown error\n"); + return -1; } - migrate_fd_connect(s); + return 0; } @@ -155,40 +142,18 @@ out2: close(s); } -int tcp_start_incoming_migration(const char *host_port) +int tcp_start_incoming_migration(const char *host_port, Error **errp) { - struct sockaddr_in addr; - int val; int s; - DPRINTF("Attempting to start an incoming migration\n"); - - if (parse_host_port(&addr, host_port) < 0) { - fprintf(stderr, "invalid host/port combination: %s\n", host_port); - return -EINVAL; - } - - s = qemu_socket(PF_INET, SOCK_STREAM, 0); - if (s == -1) { - return -socket_error(); - } - - val = 1; - setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val)); + s = inet_listen(host_port, NULL, 256, SOCK_STREAM, 0, errp); - if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) == -1) { - goto err; - } - if (listen(s, 1) == -1) { - goto err; + if (s < 0) { + return -1; } qemu_set_fd_handler2(s, NULL, tcp_accept_incoming_migration, NULL, (void *)(intptr_t)s); return 0; - -err: - close(s); - return -socket_error(); } diff --git a/migration.c b/migration.c index 94f7839e8..3f485d33a 100644 --- a/migration.c +++ b/migration.c @@ -60,13 +60,13 @@ static MigrationState *migrate_get_current(void) return ¤t_migration; } -int qemu_start_incoming_migration(const char *uri) +int qemu_start_incoming_migration(const char *uri, Error **errp) { const char *p; int ret; if (strstart(uri, "tcp:", &p)) - ret = tcp_start_incoming_migration(p); + ret = tcp_start_incoming_migration(p, errp); #if !defined(WIN32) else if (strstart(uri, "exec:", &p)) ret = exec_start_incoming_migration(p); @@ -252,6 +252,7 @@ static void migrate_fd_put_ready(void *opaque) int old_vm_running = runstate_is_running(); DPRINTF("done iterating\n"); + qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); if (qemu_savevm_state_complete(s->file) < 0) { @@ -413,7 +414,7 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, s = migrate_init(blk, inc); if (strstart(uri, "tcp:", &p)) { - ret = tcp_start_outgoing_migration(s, p); + ret = tcp_start_outgoing_migration(s, p, errp); #if !defined(WIN32) } else if (strstart(uri, "exec:", &p)) { ret = exec_start_outgoing_migration(s, p); @@ -428,9 +429,11 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, } if (ret < 0) { - DPRINTF("migration failed: %s\n", strerror(-ret)); - /* FIXME: we should return meaningful errors */ - error_set(errp, QERR_UNDEFINED_ERROR); + if (!error_is_set(errp)) { + DPRINTF("migration failed: %s\n", strerror(-ret)); + /* FIXME: we should return meaningful errors */ + error_set(errp, QERR_UNDEFINED_ERROR); + } return; } diff --git a/migration.h b/migration.h index 691b36738..2e9ca2edf 100644 --- a/migration.h +++ b/migration.h @@ -37,7 +37,7 @@ struct MigrationState void process_incoming_migration(QEMUFile *f); -int qemu_start_incoming_migration(const char *uri); +int qemu_start_incoming_migration(const char *uri, Error **errp); uint64_t migrate_max_downtime(void); @@ -49,9 +49,10 @@ int exec_start_incoming_migration(const char *host_port); int exec_start_outgoing_migration(MigrationState *s, const char *host_port); -int tcp_start_incoming_migration(const char *host_port); +int tcp_start_incoming_migration(const char *host_port, Error **errp); -int tcp_start_outgoing_migration(MigrationState *s, const char *host_port); +int tcp_start_outgoing_migration(MigrationState *s, const char *host_port, + Error **errp); int unix_start_incoming_migration(const char *path); @@ -89,8 +89,8 @@ * TODO lift the restriction * 'i' 32 bit integer * 'l' target long (32 or 64 bit) - * 'M' just like 'l', except in user mode the value is - * multiplied by 2^20 (think Mebibyte) + * 'M' Non-negative target long (32 or 64 bit), in user mode the + * value is multiplied by 2^20 (think Mebibyte) * 'o' octets (aka bytes) * user mode accepts an optional T, t, G, g, M, m, K, k * suffix, which multiplies the value by 2^40 for @@ -3141,11 +3141,15 @@ static int64_t expr_unary(Monitor *mon) n = 0; break; default: + errno = 0; #if TARGET_PHYS_ADDR_BITS > 32 n = strtoull(pch, &p, 0); #else n = strtoul(pch, &p, 0); #endif + if (errno == ERANGE) { + expr_error(mon, "number too large"); + } if (pch == p) { expr_error(mon, "invalid char in expression"); } @@ -3639,6 +3643,10 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon, monitor_printf(mon, "integer is for 32-bit values\n"); goto fail; } else if (c == 'M') { + if (val < 0) { + monitor_printf(mon, "enter a positive value\n"); + goto fail; + } val <<= 20; } qdict_put(qdict, key, qint_from_int(val)); @@ -162,7 +162,7 @@ int tcp_socket_outgoing(const char *address, uint16_t port) int tcp_socket_outgoing_spec(const char *address_and_port) { - return inet_connect(address_and_port, SOCK_STREAM); + return inet_connect(address_and_port, true, NULL); } int tcp_socket_incoming(const char *address, uint16_t port) @@ -176,7 +176,7 @@ int tcp_socket_incoming_spec(const char *address_and_port) { char *ostr = NULL; int olen = 0; - return inet_listen(address_and_port, ostr, olen, SOCK_STREAM, 0); + return inet_listen(address_and_port, ostr, olen, SOCK_STREAM, 0, NULL); } int unix_socket_incoming(const char *path) diff --git a/qapi-schema-guest.json b/qapi-schema-guest.json index d7a073ee7..692b57067 100644 --- a/qapi-schema-guest.json +++ b/qapi-schema-guest.json @@ -18,7 +18,7 @@ # lexer/tokenizer/parser state should be flushed/reset in # preparation for reliably receiving the subsequent response. As # an optimization, clients may opt to ignore all data until a -# sentinel value is receiving to avoid unecessary processing of +# sentinel value is receiving to avoid unnecessary processing of # stale data. # # Similarly, clients should also precede this *request* diff --git a/qapi-schema.json b/qapi-schema.json index 9193fb996..2ca7195d2 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -92,6 +92,8 @@ # # @debug: QEMU is running on a debugger # +# @finish-migrate: guest is paused to finish the migration process +# # @inmigrate: guest is paused waiting for an incoming migration # # @internal-error: An internal error that prevents further guest execution @@ -106,8 +108,6 @@ # # @prelaunch: QEMU was started with -S and guest has not started # -# @finish-migrate: guest is paused to finish the migration process -# # @restore-vm: guest is paused to restore VM state # # @running: guest is actively running @@ -116,12 +116,14 @@ # # @shutdown: guest is shut down (and -no-shutdown is in use) # +# @suspended: guest is suspended (ACPI S3) +# # @watchdog: the watchdog action is configured to pause and has been triggered ## { 'enum': 'RunState', 'data': [ 'debug', 'inmigrate', 'internal-error', 'io-error', 'paused', 'postmigrate', 'prelaunch', 'finish-migrate', 'restore-vm', - 'running', 'save-vm', 'shutdown', 'watchdog' ] } + 'running', 'save-vm', 'shutdown', 'suspended', 'watchdog' ] } ## # @StatusInfo: @@ -634,6 +636,25 @@ 'tls': 'bool'} } ## +# @SpiceQueryMouseMode +# +# An enumation of Spice mouse states. +# +# @client: Mouse cursor position is determined by the client. +# +# @server: Mouse cursor position is determined by the server. +# +# @unknown: No information is available about mouse mode used by +# the spice server. +# +# Note: spice/enums.h has a SpiceMouseMode already, hence the name. +# +# Since: 1.1 +## +{ 'enum': 'SpiceQueryMouseMode', + 'data': [ 'client', 'server', 'unknown' ] } + +## # @SpiceInfo # # Information about the SPICE session. @@ -654,6 +675,12 @@ # 'spice' uses SASL or direct TLS authentication, depending on command # line options # +# @mouse-mode: The mode in which the mouse cursor is displayed currently. Can +# be determined by the client or the server, or unknown if spice +# server doesn't provide this information. +# +# Since: 1.1 +# # @channels: a list of @SpiceChannel for each active spice channel # # Since: 0.14.0 @@ -661,7 +688,7 @@ { 'type': 'SpiceInfo', 'data': {'enabled': 'bool', '*host': 'str', '*port': 'int', '*tls-port': 'int', '*auth': 'str', '*compiled-version': 'str', - '*channels': ['SpiceChannel']} } + 'mouse-mode': 'SpiceQueryMouseMode', '*channels': ['SpiceChannel']} } ## # @query-spice diff --git a/qapi/qmp-input-visitor.c b/qapi/qmp-input-visitor.c index 4cdc47dab..107d8d361 100644 --- a/qapi/qmp-input-visitor.c +++ b/qapi/qmp-input-visitor.c @@ -246,13 +246,18 @@ static void qmp_input_type_number(Visitor *v, double *obj, const char *name, QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name); - if (!qobj || qobject_type(qobj) != QTYPE_QFLOAT) { + if (!qobj || (qobject_type(qobj) != QTYPE_QFLOAT && + qobject_type(qobj) != QTYPE_QINT)) { error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", - "double"); + "number"); return; } - *obj = qfloat_get_double(qobject_to_qfloat(qobj)); + if (qobject_type(qobj) == QTYPE_QINT) { + *obj = qint_get_int(qobject_to_qint(qobj)); + } else { + *obj = qfloat_get_double(qobject_to_qfloat(qobj)); + } } static void qmp_input_start_optional(Visitor *v, bool *present, diff --git a/qemu-char.c b/qemu-char.c index a9fc50481..fe1126fe8 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -2444,9 +2444,9 @@ static CharDriverState *qemu_chr_open_socket(QemuOpts *opts) } } else { if (is_listen) { - fd = inet_listen_opts(opts, 0); + fd = inet_listen_opts(opts, 0, NULL); } else { - fd = inet_connect_opts(opts); + fd = inet_connect_opts(opts, NULL); } } if (fd < 0) { diff --git a/qemu-common.h b/qemu-common.h index 50f659af0..cccfb42dd 100644 --- a/qemu-common.h +++ b/qemu-common.h @@ -61,6 +61,9 @@ typedef struct Monitor Monitor; #if !defined(ENOTSUP) #define ENOTSUP 4096 #endif +#if !defined(ECANCELED) +#define ECANCELED 4097 +#endif #ifndef TIME_MAX #define TIME_MAX LONG_MAX #endif diff --git a/qemu-config.h b/qemu-config.h index 20d707fa1..6d7365d35 100644 --- a/qemu-config.h +++ b/qemu-config.h @@ -16,4 +16,8 @@ int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname); int qemu_read_config_file(const char *filename); +/* Read default Qemu config files + */ +int qemu_read_default_config_files(bool userconfig); + #endif /* QEMU_CONFIG_H */ diff --git a/qemu-doc.texi b/qemu-doc.texi index e5d7ac41a..0af0ff45c 100644 --- a/qemu-doc.texi +++ b/qemu-doc.texi @@ -227,15 +227,15 @@ QEMU uses GUS emulation (GUSEMU32 @url{http://www.deinmeister.de/gusemu/}) by Tibor "TS" Schütz. Note that, by default, GUS shares IRQ(7) with parallel ports and so -qemu must be told to not have parallel ports to have working GUS +QEMU must be told to not have parallel ports to have working GUS. @example -qemu dos.img -soundhw gus -parallel none +qemu-system-i386 dos.img -soundhw gus -parallel none @end example Alternatively: @example -qemu dos.img -device gus,irq=5 +qemu-system-i386 dos.img -device gus,irq=5 @end example Or some other unclaimed IRQ. @@ -251,7 +251,7 @@ CS4231A is the chip used in Windows Sound System and GUSMAX products Download and uncompress the linux image (@file{linux.img}) and type: @example -qemu linux.img +qemu-system-i386 linux.img @end example Linux should boot and give you a prompt. @@ -261,7 +261,7 @@ Linux should boot and give you a prompt. @example @c man begin SYNOPSIS -usage: qemu [options] [@var{disk_image}] +usage: qemu-system-i386 [options] [@var{disk_image}] @c man end @end example @@ -575,7 +575,7 @@ QEMU can automatically create a virtual FAT disk image from a directory tree. In order to use it, just type: @example -qemu linux.img -hdb fat:/my_directory +qemu-system-i386 linux.img -hdb fat:/my_directory @end example Then you access access to all the files in the @file{/my_directory} @@ -585,14 +585,14 @@ them via SAMBA or NFS. The default access is @emph{read-only}. Floppies can be emulated with the @code{:floppy:} option: @example -qemu linux.img -fda fat:floppy:/my_directory +qemu-system-i386 linux.img -fda fat:floppy:/my_directory @end example A read/write support is available for testing (beta stage) with the @code{:rw:} option: @example -qemu linux.img -fda fat:floppy:rw:/my_directory +qemu-system-i386 linux.img -fda fat:floppy:rw:/my_directory @end example What you should @emph{never} do: @@ -610,14 +610,14 @@ QEMU can access directly to block device exported using the Network Block Device protocol. @example -qemu linux.img -hdb nbd:my_nbd_server.mydomain.org:1024 +qemu-system-i386 linux.img -hdb nbd:my_nbd_server.mydomain.org:1024 @end example If the NBD server is located on the same host, you can use an unix socket instead of an inet socket: @example -qemu linux.img -hdb nbd:unix:/tmp/my_socket +qemu-system-i386 linux.img -hdb nbd:unix:/tmp/my_socket @end example In this case, the block device must be exported using qemu-nbd: @@ -633,15 +633,15 @@ qemu-nbd --socket=/tmp/my_socket --share=2 my_disk.qcow2 and then you can use it with two guests: @example -qemu linux1.img -hdb nbd:unix:/tmp/my_socket -qemu linux2.img -hdb nbd:unix:/tmp/my_socket +qemu-system-i386 linux1.img -hdb nbd:unix:/tmp/my_socket +qemu-system-i386 linux2.img -hdb nbd:unix:/tmp/my_socket @end example If the nbd-server uses named exports (since NBD 2.9.18), you must use the "exportname" option: @example -qemu -cdrom nbd:localhost:exportname=debian-500-ppc-netinst -qemu -cdrom nbd:localhost:exportname=openSUSE-11.1-ppc-netinst +qemu-system-i386 -cdrom nbd:localhost:exportname=debian-500-ppc-netinst +qemu-system-i386 -cdrom nbd:localhost:exportname=openSUSE-11.1-ppc-netinst @end example @node disk_images_sheepdog @@ -666,7 +666,7 @@ qemu-img convert @var{filename} sheepdog:@var{image} You can boot from the Sheepdog disk image with the command: @example -qemu sheepdog:@var{image} +qemu-system-i386 sheepdog:@var{image} @end example You can also create a snapshot of the Sheepdog image like qcow2. @@ -678,7 +678,7 @@ where @var{tag} is a tag name of the newly created snapshot. To boot from the Sheepdog snapshot, specify the tag name of the snapshot. @example -qemu sheepdog:@var{image}:@var{tag} +qemu-system-i386 sheepdog:@var{image}:@var{tag} @end example You can create a cloned image from the existing snapshot. @@ -692,7 +692,7 @@ If the Sheepdog daemon doesn't run on the local host, you need to specify one of the Sheepdog servers to connect to. @example qemu-img create sheepdog:@var{hostname}:@var{port}:@var{image} @var{size} -qemu sheepdog:@var{hostname}:@var{port}:@var{image} +qemu-system-i386 sheepdog:@var{hostname}:@var{port}:@var{image} @end example @node disk_images_iscsi @@ -899,7 +899,7 @@ zero-copy communication to the application level of the guests. The basic syntax is: @example -qemu -device ivshmem,size=<size in format accepted by -m>[,shm=<shm name>] +qemu-system-i386 -device ivshmem,size=<size in format accepted by -m>[,shm=<shm name>] @end example If desired, interrupts can be sent between guest VMs accessing the same shared @@ -909,9 +909,9 @@ is qemu.git/contrib/ivshmem-server. An example syntax when using the shared memory server is: @example -qemu -device ivshmem,size=<size in format accepted by -m>[,chardev=<id>] - [,msi=on][,ioeventfd=on][,vectors=n][,role=peer|master] -qemu -chardev socket,path=<path>,id=<id> +qemu-system-i386 -device ivshmem,size=<size in format accepted by -m>[,chardev=<id>] + [,msi=on][,ioeventfd=on][,vectors=n][,role=peer|master] +qemu-system-i386 -chardev socket,path=<path>,id=<id> @end example When using the server, the guest will be assigned a VM ID (>=0) that allows guests @@ -941,7 +941,7 @@ kernel testing. The syntax is: @example -qemu -kernel arch/i386/boot/bzImage -hda root-2.4.20.img -append "root=/dev/hda" +qemu-system-i386 -kernel arch/i386/boot/bzImage -hda root-2.4.20.img -append "root=/dev/hda" @end example Use @option{-kernel} to provide the Linux kernel image and @@ -956,8 +956,8 @@ If you do not need graphical output, you can disable it and redirect the virtual serial port and the QEMU monitor to the console with the @option{-nographic} option. The typical command line is: @example -qemu -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \ - -append "root=/dev/hda console=ttyS0" -nographic +qemu-system-i386 -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \ + -append "root=/dev/hda console=ttyS0" -nographic @end example Use @key{Ctrl-a c} to switch between the serial console and the @@ -986,7 +986,7 @@ or the @code{usb_add} monitor command. Available devices are: Virtual Mouse. This will override the PS/2 mouse emulation when activated. @item tablet Pointer device that uses absolute coordinates (like a touchscreen). -This means qemu is able to report the mouse position without having +This means QEMU is able to report the mouse position without having to grab the mouse. Also overrides the PS/2 mouse emulation when activated. @item disk:@var{file} Mass storage device based on @var{file} (@pxref{disk_images}) @@ -1020,7 +1020,7 @@ Network adapter that supports CDC ethernet and RNDIS protocols. @var{options} specifies NIC options as with @code{-net nic,}@var{options} (see description). For instance, user-mode networking can be used with @example -qemu [...OPTIONS...] -net user,vlan=0 -usbdevice net:vlan=0 +qemu-system-i386 [...OPTIONS...] -net user,vlan=0 -usbdevice net:vlan=0 @end example Currently this cannot be used in machines that support PCI NICs. @item bt[:@var{hci-type}] @@ -1030,7 +1030,7 @@ no type is given, the HCI logic corresponds to @code{-bt hci,vlan=0}. This USB device implements the USB Transport Layer of HCI. Example usage: @example -qemu [...OPTIONS...] -usbdevice bt:hci,vlan=3 -bt device:keyboard,vlan=3 +qemu-system-i386 [...OPTIONS...] -usbdevice bt:hci,vlan=3 -bt device:keyboard,vlan=3 @end example @end table @@ -1108,7 +1108,7 @@ For this setup it is recommended to restrict it to listen on a UNIX domain socket only. For example @example -qemu [...OPTIONS...] -vnc unix:/home/joebloggs/.qemu-myvm-vnc +qemu-system-i386 [...OPTIONS...] -vnc unix:/home/joebloggs/.qemu-myvm-vnc @end example This ensures that only users on local box with read/write access to that @@ -1129,7 +1129,7 @@ option, and then once QEMU is running the password is set with the monitor. Unti the monitor is used to set the password all clients will be rejected. @example -qemu [...OPTIONS...] -vnc :1,password -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,password -monitor stdio (qemu) change vnc password Password: ******** (qemu) @@ -1146,7 +1146,7 @@ support provides a secure session, but no authentication. This allows any client to connect, and provides an encrypted session. @example -qemu [...OPTIONS...] -vnc :1,tls,x509=/etc/pki/qemu -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,tls,x509=/etc/pki/qemu -monitor stdio @end example In the above example @code{/etc/pki/qemu} should contain at least three files, @@ -1164,7 +1164,7 @@ then validate against the CA certificate. This is a good choice if deploying in an environment with a private internal certificate authority. @example -qemu [...OPTIONS...] -vnc :1,tls,x509verify=/etc/pki/qemu -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,tls,x509verify=/etc/pki/qemu -monitor stdio @end example @@ -1175,7 +1175,7 @@ Finally, the previous method can be combined with VNC password authentication to provide two layers of authentication for clients. @example -qemu [...OPTIONS...] -vnc :1,password,tls,x509verify=/etc/pki/qemu -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,password,tls,x509verify=/etc/pki/qemu -monitor stdio (qemu) change vnc password Password: ******** (qemu) @@ -1198,7 +1198,7 @@ used for authentication, but assuming use of one supporting SSF, then QEMU can be launched with: @example -qemu [...OPTIONS...] -vnc :1,sasl -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,sasl -monitor stdio @end example @node vnc_sec_certificate_sasl @@ -1212,7 +1212,7 @@ credentials. This can be enabled, by combining the 'sasl' option with the aforementioned TLS + x509 options: @example -qemu [...OPTIONS...] -vnc :1,tls,x509,sasl -monitor stdio +qemu-system-i386 [...OPTIONS...] -vnc :1,tls,x509,sasl -monitor stdio @end example @@ -1377,11 +1377,11 @@ use TLS and x509 certificates to protect security credentials from snooping. QEMU has a primitive support to work with gdb, so that you can do 'Ctrl-C' while the virtual machine is running and inspect its state. -In order to use gdb, launch qemu with the '-s' option. It will wait for a +In order to use gdb, launch QEMU with the '-s' option. It will wait for a gdb connection: @example -> qemu -s -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \ - -append "root=/dev/hda" +qemu-system-i386 -s -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \ + -append "root=/dev/hda" Connected to host network interface: tun0 Waiting gdb connection on port 1234 @end example @@ -2313,8 +2313,8 @@ qemu-i386 -L / /bin/ls @code{-L /} tells that the x86 dynamic linker must be searched with a @file{/} prefix. -@item Since QEMU is also a linux process, you can launch qemu with -qemu (NOTE: you can only do that if you compiled QEMU from the sources): +@item Since QEMU is also a linux process, you can launch QEMU with +QEMU (NOTE: you can only do that if you compiled QEMU from the sources): @example qemu-i386 -L / qemu-i386 -L / /bin/ls @@ -2669,7 +2669,8 @@ installation directory. @end itemize -Wine can be used to launch the resulting qemu.exe compiled for Win32. +Wine can be used to launch the resulting qemu-system-i386.exe +and all other qemu-system-@var{target}.exe compiled for Win32. @node Mac OS X @section Mac OS X @@ -304,7 +304,7 @@ static void ga_disable_non_whitelisted(void) g_free(list_head); } -/* [re-]enable all commands, except those explictly blacklisted by user */ +/* [re-]enable all commands, except those explicitly blacklisted by user */ static void ga_enable_non_blacklisted(GList *blacklist) { char **list_head, **list; diff --git a/qemu-img.c b/qemu-img.c index 0ae543cad..c8a70ffc9 100644 --- a/qemu-img.c +++ b/qemu-img.c @@ -712,6 +712,9 @@ static int img_convert(int argc, char **argv) out_filename = argv[argc - 1]; + /* Initialize before goto out */ + qemu_progress_init(progress, 2.0); + if (options && !strcmp(options, "?")) { ret = print_block_option_help(out_filename, out_fmt); goto out; @@ -724,7 +727,6 @@ static int img_convert(int argc, char **argv) goto out; } - qemu_progress_init(progress, 2.0); qemu_progress_print(0, 100); bs = g_malloc0(bs_n * sizeof(BlockDriverState *)); @@ -1138,11 +1140,13 @@ static int img_info(int argc, char **argv) } bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename)); if (backing_filename[0] != '\0') { - path_combine(backing_filename2, sizeof(backing_filename2), - filename, backing_filename); - printf("backing file: %s (actual path: %s)\n", - backing_filename, - backing_filename2); + bdrv_get_full_backing_filename(bs, backing_filename2, + sizeof(backing_filename2)); + printf("backing file: %s", backing_filename); + if (strcmp(backing_filename, backing_filename2) != 0) { + printf(" (actual path: %s)", backing_filename2); + } + putchar('\n'); } dump_snapshots(bs); bdrv_delete(bs); @@ -1560,7 +1560,7 @@ out: static int alloc_f(int argc, char **argv) { - int64_t offset; + int64_t offset, sector_num; int nb_sectors, remaining; char s1[64]; int num, sum_alloc; @@ -1581,12 +1581,18 @@ static int alloc_f(int argc, char **argv) remaining = nb_sectors; sum_alloc = 0; + sector_num = offset >> 9; while (remaining) { - ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num); + ret = bdrv_is_allocated(bs, sector_num, remaining, &num); + sector_num += num; remaining -= num; if (ret) { sum_alloc += num; } + if (num == 0) { + nb_sectors -= remaining; + remaining = 0; + } } cvtstr(offset, s1, sizeof(s1)); diff --git a/qemu-options.hx b/qemu-options.hx index f03a5efae..125a4da2e 100644 --- a/qemu-options.hx +++ b/qemu-options.hx @@ -221,7 +221,7 @@ qcow2. If performance is more important than correctness, @option{cache=writeback} should be used with qcow2. In case you don't care about data integrity over host failures, use -cache=unsafe. This option tells qemu that it never needs to write any data +cache=unsafe. This option tells QEMU that it never needs to write any data to the disk but can instead keeps things in cache. If anything goes wrong, like your host losing power, the disk storage getting disconnected accidentally, etc. you're image will most probably be rendered unusable. When using @@ -233,47 +233,47 @@ is off. Instead of @option{-cdrom} you can use: @example -qemu -drive file=file,index=2,media=cdrom +qemu-system-i386 -drive file=file,index=2,media=cdrom @end example Instead of @option{-hda}, @option{-hdb}, @option{-hdc}, @option{-hdd}, you can use: @example -qemu -drive file=file,index=0,media=disk -qemu -drive file=file,index=1,media=disk -qemu -drive file=file,index=2,media=disk -qemu -drive file=file,index=3,media=disk +qemu-system-i386 -drive file=file,index=0,media=disk +qemu-system-i386 -drive file=file,index=1,media=disk +qemu-system-i386 -drive file=file,index=2,media=disk +qemu-system-i386 -drive file=file,index=3,media=disk @end example You can connect a CDROM to the slave of ide0: @example -qemu -drive file=file,if=ide,index=1,media=cdrom +qemu-system-i386 -drive file=file,if=ide,index=1,media=cdrom @end example If you don't specify the "file=" argument, you define an empty drive: @example -qemu -drive if=ide,index=1,media=cdrom +qemu-system-i386 -drive if=ide,index=1,media=cdrom @end example You can connect a SCSI disk with unit ID 6 on the bus #0: @example -qemu -drive file=file,if=scsi,bus=0,unit=6 +qemu-system-i386 -drive file=file,if=scsi,bus=0,unit=6 @end example Instead of @option{-fda}, @option{-fdb}, you can use: @example -qemu -drive file=file,index=0,if=floppy -qemu -drive file=file,index=1,if=floppy +qemu-system-i386 -drive file=file,index=0,if=floppy +qemu-system-i386 -drive file=file,index=1,if=floppy @end example By default, @var{interface} is "ide" and @var{index} is automatically incremented: @example -qemu -drive file=a -drive file=b" +qemu-system-i386 -drive file=a -drive file=b" @end example is interpreted like: @example -qemu -hda a -hdb b +qemu-system-i386 -hda a -hdb b @end example ETEXI @@ -297,7 +297,7 @@ STEXI Set default value of @var{driver}'s property @var{prop} to @var{value}, e.g.: @example -qemu -global ide-drive.physical_block_size=4096 -drive file=file,if=ide,index=0,media=disk +qemu-system-i386 -global ide-drive.physical_block_size=4096 -drive file=file,if=ide,index=0,media=disk @end example In particular, you can use this to set driver properties for devices which are @@ -359,11 +359,11 @@ the recommended is 320x240, 640x480, 800x640. @example # try to boot from network first, then from hard disk -qemu -boot order=nc +qemu-system-i386 -boot order=nc # boot from CD-ROM first, switch back to default order after reboot -qemu -boot once=d +qemu-system-i386 -boot once=d # boot with a splash picture for 5 seconds. -qemu -boot menu=on,splash=/root/boot.bmp,splash-time=5000 +qemu-system-i386 -boot menu=on,splash=/root/boot.bmp,splash-time=5000 @end example Note: The legacy format '-boot @var{drives}' is still supported but its @@ -454,12 +454,12 @@ Enable audio and selected sound hardware. Use ? to print all available sound hardware. @example -qemu -soundhw sb16,adlib disk.img -qemu -soundhw es1370 disk.img -qemu -soundhw ac97 disk.img -qemu -soundhw hda disk.img -qemu -soundhw all disk.img -qemu -soundhw ? +qemu-system-i386 -soundhw sb16,adlib disk.img +qemu-system-i386 -soundhw es1370 disk.img +qemu-system-i386 -soundhw ac97 disk.img +qemu-system-i386 -soundhw hda disk.img +qemu-system-i386 -soundhw all disk.img +qemu-system-i386 -soundhw ? @end example Note that Linux's i810_audio OSS kernel (for AC97) module might @@ -515,7 +515,7 @@ Virtual Mouse. This will override the PS/2 mouse emulation when activated. @item tablet Pointer device that uses absolute coordinates (like a touchscreen). This -means qemu is able to report the mouse position without having to grab the +means QEMU is able to report the mouse position without having to grab the mouse. Also overrides the PS/2 mouse emulation when activated. @item disk:[format=@var{format}]:@var{file} @@ -587,7 +587,7 @@ this path will be available to the 9p client on the guest. Specifies the security model to be used for this export path. Supported security models are "passthrough", "mapped-xattr", "mapped-file" and "none". In "passthrough" security model, files are stored using the same -credentials as they are created on the guest. This requires qemu +credentials as they are created on the guest. This requires QEMU to run as root. In "mapped-xattr" security model, some of the file attributes like uid, gid, mode bits and link target are stored as file attributes. For "mapped-file" these attributes are stored in the @@ -654,7 +654,7 @@ this path will be available to the 9p client on the guest. Specifies the security model to be used for this export path. Supported security models are "passthrough", "mapped-xattr", "mapped-file" and "none". In "passthrough" security model, files are stored using the same -credentials as they are created on the guest. This requires qemu +credentials as they are created on the guest. This requires QEMU to run as root. In "mapped-xattr" security model, some of the file attributes like uid, gid, mode bits and link target are stored as file attributes. For "mapped-file" these attributes are stored in the @@ -1117,7 +1117,7 @@ disables exclusive client access. Useful for shared desktop sessions, where you don't want someone forgetting specify -shared disconnect everybody else. 'ignore' completely ignores the shared flag and allows everybody connect unconditionally. Doesn't conform to the rfb -spec but is traditional qemu behavior. +spec but is traditional QEMU behavior. @end table ETEXI @@ -1368,7 +1368,7 @@ a guest from a local directory. Example (using pxelinux): @example -qemu -hda linux.img -boot n -net user,tftp=/path/to/tftp/files,bootfile=/pxelinux.0 +qemu-system-i386 -hda linux.img -boot n -net user,tftp=/path/to/tftp/files,bootfile=/pxelinux.0 @end example @item smb=@var{dir}[,smbserver=@var{addr}] @@ -1403,7 +1403,7 @@ screen 0, use the following: @example # on the host -qemu -net user,hostfwd=tcp:127.0.0.1:6001-:6000 [...] +qemu-system-i386 -net user,hostfwd=tcp:127.0.0.1:6001-:6000 [...] # this host xterm should open in the guest X11 server xterm -display :1 @end example @@ -1413,7 +1413,7 @@ the guest, use the following: @example # on the host -qemu -net user,hostfwd=tcp::5555-:23 [...] +qemu-system-i386 -net user,hostfwd=tcp::5555-:23 [...] telnet localhost 5555 @end example @@ -1452,20 +1452,22 @@ Examples: @example #launch a QEMU instance with the default network script -qemu linux.img -net nic -net tap +qemu-system-i386 linux.img -net nic -net tap @end example @example #launch a QEMU instance with two NICs, each one connected #to a TAP device -qemu linux.img -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \ - -net nic,vlan=1 -net tap,vlan=1,ifname=tap1 +qemu-system-i386 linux.img \ + -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \ + -net nic,vlan=1 -net tap,vlan=1,ifname=tap1 @end example @example #launch a QEMU instance with the default network helper to #connect a TAP device to bridge br0 -qemu linux.img -net nic -net tap,"helper=/usr/local/libexec/qemu-bridge-helper" +qemu-system-i386 linux.img \ + -net nic -net tap,"helper=/usr/local/libexec/qemu-bridge-helper" @end example @item -net bridge[,vlan=@var{n}][,name=@var{name}][,br=@var{bridge}][,helper=@var{helper}] @@ -1481,13 +1483,13 @@ Examples: @example #launch a QEMU instance with the default network helper to #connect a TAP device to bridge br0 -qemu linux.img -net bridge -net nic,model=virtio +qemu-system-i386 linux.img -net bridge -net nic,model=virtio @end example @example #launch a QEMU instance with the default network helper to #connect a TAP device to bridge qemubr0 -qemu linux.img -net bridge,br=qemubr0 -net nic,model=virtio +qemu-system-i386 linux.img -net bridge,br=qemubr0 -net nic,model=virtio @end example @item -net socket[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}] [,listen=[@var{host}]:@var{port}][,connect=@var{host}:@var{port}] @@ -1502,12 +1504,14 @@ specifies an already opened TCP socket. Example: @example # launch a first QEMU instance -qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \ - -net socket,listen=:1234 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:56 \ + -net socket,listen=:1234 # connect the VLAN 0 of this instance to the VLAN 0 # of the first instance -qemu linux.img -net nic,macaddr=52:54:00:12:34:57 \ - -net socket,connect=127.0.0.1:1234 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:57 \ + -net socket,connect=127.0.0.1:1234 @end example @item -net socket[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}][,mcast=@var{maddr}:@var{port}[,localaddr=@var{addr}]] @@ -1530,30 +1534,35 @@ Use @option{fd=h} to specify an already opened UDP multicast socket. Example: @example # launch one QEMU instance -qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \ - -net socket,mcast=230.0.0.1:1234 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:56 \ + -net socket,mcast=230.0.0.1:1234 # launch another QEMU instance on same "bus" -qemu linux.img -net nic,macaddr=52:54:00:12:34:57 \ - -net socket,mcast=230.0.0.1:1234 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:57 \ + -net socket,mcast=230.0.0.1:1234 # launch yet another QEMU instance on same "bus" -qemu linux.img -net nic,macaddr=52:54:00:12:34:58 \ - -net socket,mcast=230.0.0.1:1234 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:58 \ + -net socket,mcast=230.0.0.1:1234 @end example Example (User Mode Linux compat.): @example # launch QEMU instance (note mcast address selected # is UML's default) -qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \ - -net socket,mcast=239.192.168.1:1102 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:56 \ + -net socket,mcast=239.192.168.1:1102 # launch UML /path/to/linux ubd0=/path/to/root_fs eth0=mcast @end example Example (send packets from host's 1.2.3.4): @example -qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \ - -net socket,mcast=239.192.168.1:1102,localaddr=1.2.3.4 +qemu-system-i386 linux.img \ + -net nic,macaddr=52:54:00:12:34:56 \ + -net socket,mcast=239.192.168.1:1102,localaddr=1.2.3.4 @end example @item -net vde[,vlan=@var{n}][,name=@var{name}][,sock=@var{socketpath}] [,port=@var{n}][,group=@var{groupname}][,mode=@var{octalmode}] @@ -1568,7 +1577,7 @@ Example: # launch vde switch vde_switch -F -sock /tmp/myswitch # launch QEMU instance -qemu linux.img -net nic -net vde,sock=/tmp/myswitch +qemu-system-i386 linux.img -net nic -net vde,sock=/tmp/myswitch @end example @item -net dump[,vlan=@var{n}][,file=@var{file}][,len=@var{len}] @@ -1791,7 +1800,7 @@ not take any options. @option{pty} is not available on Windows hosts. @item -chardev stdio ,id=@var{id} [,signal=on|off] -Connect to standard input and standard output of the qemu process. +Connect to standard input and standard output of the QEMU process. @option{signal} controls if signals are enabled on the terminal, that includes exiting QEMU with the key sequence @key{Control-c}. This option is enabled by @@ -1853,21 +1862,21 @@ Syntax for specifying iSCSI LUNs is Example (without authentication): @example -qemu -iscsi initiator-name=iqn.2001-04.com.example:my-initiator \ --cdrom iscsi://192.0.2.1/iqn.2001-04.com.example/2 \ --drive file=iscsi://192.0.2.1/iqn.2001-04.com.example/1 +qemu-system-i386 -iscsi initiator-name=iqn.2001-04.com.example:my-initiator \ + -cdrom iscsi://192.0.2.1/iqn.2001-04.com.example/2 \ + -drive file=iscsi://192.0.2.1/iqn.2001-04.com.example/1 @end example Example (CHAP username/password via URL): @example -qemu -drive file=iscsi://user%password@@192.0.2.1/iqn.2001-04.com.example/1 +qemu-system-i386 -drive file=iscsi://user%password@@192.0.2.1/iqn.2001-04.com.example/1 @end example Example (CHAP username/password via environment variables): @example LIBISCSI_CHAP_USERNAME="user" \ LIBISCSI_CHAP_PASSWORD="password" \ -qemu -drive file=iscsi://192.0.2.1/iqn.2001-04.com.example/1 +qemu-system-i386 -drive file=iscsi://192.0.2.1/iqn.2001-04.com.example/1 @end example iSCSI support is an optional feature of QEMU and only available when @@ -1893,12 +1902,12 @@ Syntax for specifying a NBD device using Unix Domain Sockets Example for TCP @example -qemu --drive file=nbd:192.0.2.1:30000 +qemu-system-i386 --drive file=nbd:192.0.2.1:30000 @end example Example for Unix Domain Sockets @example -qemu --drive file=nbd:unix:/tmp/nbd-socket +qemu-system-i386 --drive file=nbd:unix:/tmp/nbd-socket @end example @item Sheepdog @@ -1923,7 +1932,7 @@ Syntax for specifying a sheepdog device Example @example -qemu --drive file=sheepdog:192.0.2.1:30000:MyVirtualMachine +qemu-system-i386 --drive file=sheepdog:192.0.2.1:30000:MyVirtualMachine @end example See also @url{http://http://www.osrg.net/sheepdog/}. @@ -1986,7 +1995,7 @@ and communicate. Requires the Linux @code{vhci} driver installed. Can be used as following: @example -qemu [...OPTIONS...] -bt hci,vlan=5 -bt vhci,vlan=5 +qemu-system-i386 [...OPTIONS...] -bt hci,vlan=5 -bt vhci,vlan=5 @end example @item -bt device:@var{dev}[,vlan=@var{n}] @@ -2119,19 +2128,19 @@ they default to @code{0.0.0.0}. When not using a specified @var{src_port} a random port is automatically chosen. If you just want a simple readonly console you can use @code{netcat} or -@code{nc}, by starting qemu with: @code{-serial udp::4555} and nc as: -@code{nc -u -l -p 4555}. Any time qemu writes something to that port it +@code{nc}, by starting QEMU with: @code{-serial udp::4555} and nc as: +@code{nc -u -l -p 4555}. Any time QEMU writes something to that port it will appear in the netconsole session. If you plan to send characters back via netconsole or you want to stop -and start qemu a lot of times, you should have qemu use the same +and start QEMU a lot of times, you should have QEMU use the same source port each time by using something like @code{-serial -udp::4555@@:4556} to qemu. Another approach is to use a patched +udp::4555@@:4556} to QEMU. Another approach is to use a patched version of netcat which can listen to a TCP port and send and receive characters via udp. If you have a patched version of netcat which activates telnet remote echo and single char transfer, then you can use the following options to step up a netcat redirector to allow -telnet on port 5555 to access the qemu port. +telnet on port 5555 to access the QEMU port. @table @code @item QEMU Options: -serial udp::4555@@:4556 @@ -2286,10 +2295,10 @@ STEXI @findex -gdb Wait for gdb connection on device @var{dev} (@pxref{gdb_usage}). Typical connections will likely be TCP-based, but also UDP, pseudo TTY, or even -stdio are reasonable use case. The latter is allowing to start qemu from +stdio are reasonable use case. The latter is allowing to start QEMU from within gdb and establish the connection via a pipe: @example -(gdb) target remote | exec qemu -gdb stdio ... +(gdb) target remote | exec qemu-system-i386 -gdb stdio ... @end example ETEXI @@ -2316,15 +2325,15 @@ DEF("D", HAS_ARG, QEMU_OPTION_D, \ "-D logfile output log to logfile (instead of the default /tmp/qemu.log)\n", QEMU_ARCH_ALL) STEXI -@item -D +@item -D @var{logfile} @findex -D -Output log in logfile instead of /tmp/qemu.log +Output log in @var{logfile} instead of /tmp/qemu.log ETEXI DEF("hdachs", HAS_ARG, QEMU_OPTION_hdachs, \ "-hdachs c,h,s[,t]\n" \ " force hard disk 0 physical geometry and the optional BIOS\n" \ - " translation (t=none or lba) (usually qemu can guess them)\n", + " translation (t=none or lba) (usually QEMU can guess them)\n", QEMU_ARCH_ALL) STEXI @item -hdachs @var{c},@var{h},@var{s},[,@var{t}] @@ -2370,7 +2379,7 @@ DEF("xen-create", 0, QEMU_OPTION_xen_create, QEMU_ARCH_ALL) DEF("xen-attach", 0, QEMU_OPTION_xen_attach, "-xen-attach attach to existing xen domain\n" - " xend will use this when starting qemu\n", + " xend will use this when starting QEMU\n", QEMU_ARCH_ALL) STEXI @item -xen-domid @var{id} @@ -2383,7 +2392,7 @@ Warning: should not be used when xend is in use (XEN only). @item -xen-attach @findex -xen-attach Attach to existing xen domain. -xend will use this when starting qemu (XEN only). +xend will use this when starting QEMU (XEN only). ETEXI DEF("no-reboot", 0, QEMU_OPTION_no_reboot, \ @@ -2685,9 +2694,19 @@ DEF("nodefconfig", 0, QEMU_OPTION_nodefconfig, STEXI @item -nodefconfig @findex -nodefconfig -Normally QEMU loads a configuration file from @var{sysconfdir}/qemu.conf and -@var{sysconfdir}/target-@var{ARCH}.conf on startup. The @code{-nodefconfig} -option will prevent QEMU from loading these configuration files at startup. +Normally QEMU loads configuration files from @var{sysconfdir} and @var{datadir} at startup. +The @code{-nodefconfig} option will prevent QEMU from loading any of those config files. +ETEXI +DEF("no-user-config", 0, QEMU_OPTION_nouserconfig, + "-no-user-config\n" + " do not load user-provided config files at startup\n", + QEMU_ARCH_ALL) +STEXI +@item -no-user-config +@findex -no-user-config +The @code{-no-user-config} option makes QEMU not load any of the user-provided +config files on @var{sysconfdir}, but won't make it skip the QEMU-provided config +files from @var{datadir}. ETEXI DEF("trace", HAS_ARG, QEMU_OPTION_trace, "-trace [events=<file>][,file=<file>]\n" diff --git a/qemu-sockets.c b/qemu-sockets.c index 6bcb8e3e0..46c7619c7 100644 --- a/qemu-sockets.c +++ b/qemu-sockets.c @@ -51,6 +51,9 @@ static QemuOptsList dummy_opts = { },{ .name = "ipv6", .type = QEMU_OPT_BOOL, + },{ + .name = "block", + .type = QEMU_OPT_BOOL, }, { /* end if list */ } }, @@ -100,7 +103,7 @@ const char *inet_strfamily(int family) return "unknown"; } -int inet_listen_opts(QemuOpts *opts, int port_offset) +int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp) { struct addrinfo ai,*res,*e; const char *addr; @@ -117,6 +120,7 @@ int inet_listen_opts(QemuOpts *opts, int port_offset) if ((qemu_opt_get(opts, "host") == NULL) || (qemu_opt_get(opts, "port") == NULL)) { fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__); + error_set(errp, QERR_SOCKET_CREATE_FAILED); return -1; } pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port")); @@ -135,6 +139,7 @@ int inet_listen_opts(QemuOpts *opts, int port_offset) if (rc != 0) { fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port, gai_strerror(rc)); + error_set(errp, QERR_SOCKET_CREATE_FAILED); return -1; } @@ -147,6 +152,9 @@ int inet_listen_opts(QemuOpts *opts, int port_offset) if (slisten < 0) { fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__, inet_strfamily(e->ai_family), strerror(errno)); + if (!e->ai_next) { + error_set(errp, QERR_SOCKET_CREATE_FAILED); + } continue; } @@ -170,6 +178,9 @@ int inet_listen_opts(QemuOpts *opts, int port_offset) fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__, inet_strfamily(e->ai_family), uaddr, inet_getport(e), strerror(errno)); + if (!e->ai_next) { + error_set(errp, QERR_SOCKET_BIND_FAILED); + } } } closesocket(slisten); @@ -180,6 +191,7 @@ int inet_listen_opts(QemuOpts *opts, int port_offset) listen: if (listen(slisten,1) != 0) { + error_set(errp, QERR_SOCKET_LISTEN_FAILED); perror("listen"); closesocket(slisten); freeaddrinfo(res); @@ -194,7 +206,7 @@ listen: return slisten; } -int inet_connect_opts(QemuOpts *opts) +int inet_connect_opts(QemuOpts *opts, Error **errp) { struct addrinfo ai,*res,*e; const char *addr; @@ -202,6 +214,7 @@ int inet_connect_opts(QemuOpts *opts) char uaddr[INET6_ADDRSTRLEN+1]; char uport[33]; int sock,rc; + bool block; memset(&ai,0, sizeof(ai)); ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; @@ -210,8 +223,10 @@ int inet_connect_opts(QemuOpts *opts) addr = qemu_opt_get(opts, "host"); port = qemu_opt_get(opts, "port"); + block = qemu_opt_get_bool(opts, "block", 0); if (addr == NULL || port == NULL) { fprintf(stderr, "inet_connect: host and/or port not specified\n"); + error_set(errp, QERR_SOCKET_CREATE_FAILED); return -1; } @@ -224,6 +239,7 @@ int inet_connect_opts(QemuOpts *opts) if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) { fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port, gai_strerror(rc)); + error_set(errp, QERR_SOCKET_CREATE_FAILED); return -1; } @@ -241,19 +257,37 @@ int inet_connect_opts(QemuOpts *opts) continue; } setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on)); - + if (!block) { + socket_set_nonblock(sock); + } /* connect to peer */ - if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) { + do { + rc = 0; + if (connect(sock, e->ai_addr, e->ai_addrlen) < 0) { + rc = -socket_error(); + } + } while (rc == -EINTR); + + #ifdef _WIN32 + if (!block && (rc == -EINPROGRESS || rc == -EWOULDBLOCK + || rc == -WSAEALREADY)) { + #else + if (!block && (rc == -EINPROGRESS)) { + #endif + error_set(errp, QERR_SOCKET_CONNECT_IN_PROGRESS); + } else if (rc < 0) { if (NULL == e->ai_next) fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__, inet_strfamily(e->ai_family), e->ai_canonname, uaddr, uport, strerror(errno)); closesocket(sock); + sock = -1; continue; } freeaddrinfo(res); return sock; } + error_set(errp, QERR_SOCKET_CONNECT_FAILED); freeaddrinfo(res); return -1; } @@ -421,7 +455,7 @@ static int inet_parse(QemuOpts *opts, const char *str) } int inet_listen(const char *str, char *ostr, int olen, - int socktype, int port_offset) + int socktype, int port_offset, Error **errp) { QemuOpts *opts; char *optstr; @@ -429,7 +463,7 @@ int inet_listen(const char *str, char *ostr, int olen, opts = qemu_opts_create(&dummy_opts, NULL, 0); if (inet_parse(opts, str) == 0) { - sock = inet_listen_opts(opts, port_offset); + sock = inet_listen_opts(opts, port_offset, errp); if (sock != -1 && ostr) { optstr = strchr(str, ','); if (qemu_opt_get_bool(opts, "ipv6", 0)) { @@ -444,19 +478,27 @@ int inet_listen(const char *str, char *ostr, int olen, optstr ? optstr : ""); } } + } else { + error_set(errp, QERR_SOCKET_CREATE_FAILED); } qemu_opts_del(opts); return sock; } -int inet_connect(const char *str, int socktype) +int inet_connect(const char *str, bool block, Error **errp) { QemuOpts *opts; int sock = -1; opts = qemu_opts_create(&dummy_opts, NULL, 0); - if (inet_parse(opts, str) == 0) - sock = inet_connect_opts(opts); + if (inet_parse(opts, str) == 0) { + if (block) { + qemu_opt_set(opts, "block", "on"); + } + sock = inet_connect_opts(opts, errp); + } else { + error_set(errp, QERR_SOCKET_CREATE_FAILED); + } qemu_opts_del(opts); return sock; } diff --git a/qemu-timer.c b/qemu-timer.c index 8eadd16aa..de9897788 100644 --- a/qemu-timer.c +++ b/qemu-timer.c @@ -31,10 +31,6 @@ #include "qemu-timer.h" -#ifdef __FreeBSD__ -#include <sys/param.h> -#endif - #ifdef _WIN32 #include <mmsystem.h> #endif @@ -611,7 +607,7 @@ static void unix_stop_timer(struct qemu_alarm_timer *t) #ifdef _WIN32 static MMRESULT mm_timer; -static unsigned mm_period; +static TIMECAPS mm_tc; static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, @@ -628,24 +624,19 @@ static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg, static int mm_start_timer(struct qemu_alarm_timer *t) { - TIMECAPS tc; - - memset(&tc, 0, sizeof(tc)); - timeGetDevCaps(&tc, sizeof(tc)); + timeGetDevCaps(&mm_tc, sizeof(mm_tc)); - mm_period = tc.wPeriodMin; - timeBeginPeriod(mm_period); + timeBeginPeriod(mm_tc.wPeriodMin); - mm_timer = timeSetEvent(1, /* interval (ms) */ - mm_period, /* resolution */ + mm_timer = timeSetEvent(mm_tc.wPeriodMin, /* interval (ms) */ + mm_tc.wPeriodMin, /* resolution */ mm_alarm_handler, /* function */ (DWORD_PTR)t, /* parameter */ TIME_ONESHOT | TIME_CALLBACK_FUNCTION); if (!mm_timer) { - fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n", - GetLastError()); - timeEndPeriod(mm_period); + fprintf(stderr, "Failed to initialize win32 alarm timer\n"); + timeEndPeriod(mm_tc.wPeriodMin); return -1; } @@ -655,32 +646,28 @@ static int mm_start_timer(struct qemu_alarm_timer *t) static void mm_stop_timer(struct qemu_alarm_timer *t) { timeKillEvent(mm_timer); - timeEndPeriod(mm_period); + timeEndPeriod(mm_tc.wPeriodMin); } static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta) { int64_t nearest_delta_ms = delta / 1000000; - if (nearest_delta_ms < 1) { - nearest_delta_ms = 1; - } - /* UINT_MAX can be 32 bit */ - if (nearest_delta_ms > UINT_MAX) { - nearest_delta_ms = UINT_MAX; + if (nearest_delta_ms < mm_tc.wPeriodMin) { + nearest_delta_ms = mm_tc.wPeriodMin; + } else if (nearest_delta_ms > mm_tc.wPeriodMax) { + nearest_delta_ms = mm_tc.wPeriodMax; } timeKillEvent(mm_timer); - mm_timer = timeSetEvent((unsigned int) nearest_delta_ms, - mm_period, + mm_timer = timeSetEvent((UINT)nearest_delta_ms, + mm_tc.wPeriodMin, mm_alarm_handler, (DWORD_PTR)t, TIME_ONESHOT | TIME_CALLBACK_FUNCTION); if (!mm_timer) { - fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n", - GetLastError()); - - timeEndPeriod(mm_period); + fprintf(stderr, "Failed to re-arm win32 alarm timer\n"); + timeEndPeriod(mm_tc.wPeriodMin); exit(1); } } diff --git a/qemu-timer.h b/qemu-timer.h index 5175419e5..f8af595f1 100644 --- a/qemu-timer.h +++ b/qemu-timer.h @@ -5,6 +5,10 @@ #include "main-loop.h" #include "notify.h" +#ifdef __FreeBSD__ +#include <sys/param.h> +#endif + /* timers */ #define SCALE_MS 1000000 diff --git a/qemu_socket.h b/qemu_socket.h index a5d0a84fb..4689ff340 100644 --- a/qemu_socket.h +++ b/qemu_socket.h @@ -27,6 +27,8 @@ int inet_aton(const char *cp, struct in_addr *ia); #endif /* !_WIN32 */ #include "qemu-option.h" +#include "error.h" +#include "qerror.h" /* misc helpers */ int qemu_socket(int domain, int type, int protocol); @@ -37,11 +39,11 @@ void socket_set_nonblock(int fd); int send_all(int fd, const void *buf, int len1); /* New, ipv6-ready socket helper functions, see qemu-sockets.c */ -int inet_listen_opts(QemuOpts *opts, int port_offset); +int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp); int inet_listen(const char *str, char *ostr, int olen, - int socktype, int port_offset); -int inet_connect_opts(QemuOpts *opts); -int inet_connect(const char *str, int socktype); + int socktype, int port_offset, Error **errp); +int inet_connect_opts(QemuOpts *opts, Error **errp); +int inet_connect(const char *str, bool block, Error **errp); int inet_dgram_opts(QemuOpts *opts); const char *inet_strfamily(int family); @@ -304,6 +304,26 @@ static const QErrorStringTable qerror_table[] = { .error_fmt = QERR_VNC_SERVER_FAILED, .desc = "Could not start VNC server on %(target)", }, + { + .error_fmt = QERR_SOCKET_CONNECT_IN_PROGRESS, + .desc = "Connection can not be completed immediately", + }, + { + .error_fmt = QERR_SOCKET_CONNECT_FAILED, + .desc = "Failed to connect to socket", + }, + { + .error_fmt = QERR_SOCKET_LISTEN_FAILED, + .desc = "Failed to set socket to listening mode", + }, + { + .error_fmt = QERR_SOCKET_BIND_FAILED, + .desc = "Failed to bind socket", + }, + { + .error_fmt = QERR_SOCKET_CREATE_FAILED, + .desc = "Failed to create socket", + }, {} }; @@ -248,4 +248,19 @@ QError *qobject_to_qerror(const QObject *obj); #define QERR_VNC_SERVER_FAILED \ "{ 'class': 'VNCServerFailed', 'data': { 'target': %s } }" +#define QERR_SOCKET_CONNECT_IN_PROGRESS \ + "{ 'class': 'SockConnectInprogress', 'data': {} }" + +#define QERR_SOCKET_CONNECT_FAILED \ + "{ 'class': 'SockConnectFailed', 'data': {} }" + +#define QERR_SOCKET_LISTEN_FAILED \ + "{ 'class': 'SockListenFailed', 'data': {} }" + +#define QERR_SOCKET_BIND_FAILED \ + "{ 'class': 'SockBindFailed', 'data': {} }" + +#define QERR_SOCKET_CREATE_FAILED \ + "{ 'class': 'SockCreateFailed', 'data': {} }" + #endif /* QERROR_H */ diff --git a/qga/commands-posix.c b/qga/commands-posix.c index d58730ad8..e448431c6 100644 --- a/qga/commands-posix.c +++ b/qga/commands-posix.c @@ -487,7 +487,7 @@ int64_t qmp_guest_fsfreeze_thaw(Error **err) * was returned the filesystem was *not* unfrozen by that particular * call. * - * since multiple preceeding FIFREEZEs require multiple calls to FITHAW + * since multiple preceding FIFREEZEs require multiple calls to FITHAW * to unfreeze, continuing issuing FITHAW until an error is returned, * in which case either the filesystem is in an unfreezable state, or, * more likely, it was thawed previously (and remains so afterward). @@ -789,7 +789,7 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) strncpy(ifr.ifr_name, info->value->name, IF_NAMESIZE); if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { snprintf(err_msg, sizeof(err_msg), - "failed to get MAC addres of %s: %s", + "failed to get MAC address of %s: %s", ifa->ifa_name, strerror(errno)); error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg); diff --git a/qmp-commands.hx b/qmp-commands.hx index c810c74c1..db980fa81 100644 --- a/qmp-commands.hx +++ b/qmp-commands.hx @@ -759,7 +759,7 @@ EQMP { .name = "blockdev-snapshot-sync", - .args_type = "device:B,snapshot-file:s,format:s?", + .args_type = "device:B,snapshot-file:s,format:s?,mode:s?", .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync, }, @@ -151,6 +151,8 @@ void qmp_cont(Error **errp) runstate_check(RUN_STATE_SHUTDOWN)) { error_set(errp, QERR_RESET_REQUIRED); return; + } else if (runstate_check(RUN_STATE_SUSPENDED)) { + return; } bdrv_iterate(iostatus_bdrv_it, NULL); diff --git a/qom/container.c b/qom/container.c index c9940ab2e..4ca8b5cba 100644 --- a/qom/container.c +++ b/qom/container.c @@ -43,6 +43,8 @@ Object *container_get(Object *root, const char *path) } } + g_strfreev(parts); + return obj; } diff --git a/qom/object.c b/qom/object.c index e721fc28f..6f839ad8c 100644 --- a/qom/object.c +++ b/qom/object.c @@ -830,7 +830,7 @@ char *object_property_print(Object *obj, const char *name, char *string; mo = string_output_visitor_new(); - object_property_get(obj, string_output_get_visitor(mo), name, NULL); + object_property_get(obj, string_output_get_visitor(mo), name, errp); string = string_output_get_string(mo); string_output_visitor_cleanup(mo); return string; diff --git a/scripts/qemu-binfmt-conf.sh b/scripts/qemu-binfmt-conf.sh index 83a44d8e2..0da261888 100644 --- a/scripts/qemu-binfmt-conf.sh +++ b/scripts/qemu-binfmt-conf.sh @@ -63,6 +63,7 @@ fi if [ $cpu != "sh" ] ; then echo ':sh4:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a\x00:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/local/bin/qemu-sh4:' > /proc/sys/fs/binfmt_misc/register echo ':sh4eb:M::\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2a:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-sh4eb:' > /proc/sys/fs/binfmt_misc/register +fi if [ $cpu != "s390x" ] ; then echo ':s390x:M::\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x16:\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff:/usr/local/bin/qemu-s390x:' > /proc/sys/fs/binfmt_misc/register fi diff --git a/sysconfigs/target/cpus-x86_64.conf b/sysconfigs/target/cpus-x86_64.conf new file mode 100644 index 000000000..cee0ea9e5 --- /dev/null +++ b/sysconfigs/target/cpus-x86_64.conf @@ -0,0 +1,128 @@ +# x86 CPU MODELS + +[cpudef] + name = "Conroe" + level = "2" + vendor = "GenuineIntel" + family = "6" + model = "2" + stepping = "3" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "ssse3 sse3" + extfeature_edx = "i64 xd syscall" + extfeature_ecx = "lahf_lm" + xlevel = "0x8000000A" + model_id = "Intel Celeron_4x0 (Conroe/Merom Class Core 2)" + +[cpudef] + name = "Penryn" + level = "2" + vendor = "GenuineIntel" + family = "6" + model = "2" + stepping = "3" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "sse4.1 cx16 ssse3 sse3" + extfeature_edx = "i64 xd syscall" + extfeature_ecx = "lahf_lm" + xlevel = "0x8000000A" + model_id = "Intel Core 2 Duo P9xxx (Penryn Class Core 2)" + +[cpudef] + name = "Nehalem" + level = "2" + vendor = "GenuineIntel" + family = "6" + model = "2" + stepping = "3" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "popcnt sse4.2 sse4.1 cx16 ssse3 sse3" + extfeature_edx = "i64 syscall xd" + extfeature_ecx = "lahf_lm" + xlevel = "0x8000000A" + model_id = "Intel Core i7 9xx (Nehalem Class Core i7)" + +[cpudef] + name = "Westmere" + level = "11" + vendor = "GenuineIntel" + family = "6" + model = "44" + stepping = "1" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "aes popcnt sse4.2 sse4.1 cx16 ssse3 sse3" + extfeature_edx = "i64 syscall xd" + extfeature_ecx = "lahf_lm" + xlevel = "0x8000000A" + model_id = "Westmere E56xx/L56xx/X56xx (Nehalem-C)" + +[cpudef] + name = "SandyBridge" + level = "0xd" + vendor = "GenuineIntel" + family = "6" + model = "42" + stepping = "1" + feature_edx = " sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "avx xsave aes tsc-deadline popcnt x2apic sse4.2 sse4.1 cx16 ssse3 pclmulqdq sse3" + extfeature_edx = "i64 rdtscp nx syscall " + extfeature_ecx = "lahf_lm" + xlevel = "0x8000000A" + model_id = "Intel Xeon E312xx (Sandy Bridge)" + +[cpudef] + name = "Opteron_G1" + level = "5" + vendor = "AuthenticAMD" + family = "15" + model = "6" + stepping = "1" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "sse3" + extfeature_edx = "lm fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" + extfeature_ecx = " " + xlevel = "0x80000008" + model_id = "AMD Opteron 240 (Gen 1 Class Opteron)" + +[cpudef] + name = "Opteron_G2" + level = "5" + vendor = "AuthenticAMD" + family = "15" + model = "6" + stepping = "1" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "cx16 sse3" + extfeature_edx = "lm rdtscp fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" + extfeature_ecx = "svm lahf_lm" + xlevel = "0x80000008" + model_id = "AMD Opteron 22xx (Gen 2 Class Opteron)" + +[cpudef] + name = "Opteron_G3" + level = "5" + vendor = "AuthenticAMD" + family = "15" + model = "6" + stepping = "1" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "popcnt cx16 monitor sse3" + extfeature_edx = "lm rdtscp fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" + extfeature_ecx = "misalignsse sse4a abm svm lahf_lm" + xlevel = "0x80000008" + model_id = "AMD Opteron 23xx (Gen 3 Class Opteron)" + +[cpudef] + name = "Opteron_G4" + level = "0xd" + vendor = "AuthenticAMD" + family = "21" + model = "1" + stepping = "2" + feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" + feature_ecx = "avx xsave aes popcnt sse4.2 sse4.1 cx16 ssse3 pclmulqdq sse3" + extfeature_edx = "lm rdtscp pdpe1gb fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" + extfeature_ecx = " fma4 xop 3dnowprefetch misalignsse sse4a abm svm lahf_lm" + xlevel = "0x8000001A" + model_id = "AMD Opteron 62xx class CPU" + diff --git a/sysconfigs/target/target-x86_64.conf b/sysconfigs/target/target-x86_64.conf index cee0ea9e5..e69de29bb 100644 --- a/sysconfigs/target/target-x86_64.conf +++ b/sysconfigs/target/target-x86_64.conf @@ -1,128 +0,0 @@ -# x86 CPU MODELS - -[cpudef] - name = "Conroe" - level = "2" - vendor = "GenuineIntel" - family = "6" - model = "2" - stepping = "3" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "ssse3 sse3" - extfeature_edx = "i64 xd syscall" - extfeature_ecx = "lahf_lm" - xlevel = "0x8000000A" - model_id = "Intel Celeron_4x0 (Conroe/Merom Class Core 2)" - -[cpudef] - name = "Penryn" - level = "2" - vendor = "GenuineIntel" - family = "6" - model = "2" - stepping = "3" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "sse4.1 cx16 ssse3 sse3" - extfeature_edx = "i64 xd syscall" - extfeature_ecx = "lahf_lm" - xlevel = "0x8000000A" - model_id = "Intel Core 2 Duo P9xxx (Penryn Class Core 2)" - -[cpudef] - name = "Nehalem" - level = "2" - vendor = "GenuineIntel" - family = "6" - model = "2" - stepping = "3" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "popcnt sse4.2 sse4.1 cx16 ssse3 sse3" - extfeature_edx = "i64 syscall xd" - extfeature_ecx = "lahf_lm" - xlevel = "0x8000000A" - model_id = "Intel Core i7 9xx (Nehalem Class Core i7)" - -[cpudef] - name = "Westmere" - level = "11" - vendor = "GenuineIntel" - family = "6" - model = "44" - stepping = "1" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "aes popcnt sse4.2 sse4.1 cx16 ssse3 sse3" - extfeature_edx = "i64 syscall xd" - extfeature_ecx = "lahf_lm" - xlevel = "0x8000000A" - model_id = "Westmere E56xx/L56xx/X56xx (Nehalem-C)" - -[cpudef] - name = "SandyBridge" - level = "0xd" - vendor = "GenuineIntel" - family = "6" - model = "42" - stepping = "1" - feature_edx = " sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "avx xsave aes tsc-deadline popcnt x2apic sse4.2 sse4.1 cx16 ssse3 pclmulqdq sse3" - extfeature_edx = "i64 rdtscp nx syscall " - extfeature_ecx = "lahf_lm" - xlevel = "0x8000000A" - model_id = "Intel Xeon E312xx (Sandy Bridge)" - -[cpudef] - name = "Opteron_G1" - level = "5" - vendor = "AuthenticAMD" - family = "15" - model = "6" - stepping = "1" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "sse3" - extfeature_edx = "lm fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" - extfeature_ecx = " " - xlevel = "0x80000008" - model_id = "AMD Opteron 240 (Gen 1 Class Opteron)" - -[cpudef] - name = "Opteron_G2" - level = "5" - vendor = "AuthenticAMD" - family = "15" - model = "6" - stepping = "1" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "cx16 sse3" - extfeature_edx = "lm rdtscp fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" - extfeature_ecx = "svm lahf_lm" - xlevel = "0x80000008" - model_id = "AMD Opteron 22xx (Gen 2 Class Opteron)" - -[cpudef] - name = "Opteron_G3" - level = "5" - vendor = "AuthenticAMD" - family = "15" - model = "6" - stepping = "1" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "popcnt cx16 monitor sse3" - extfeature_edx = "lm rdtscp fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" - extfeature_ecx = "misalignsse sse4a abm svm lahf_lm" - xlevel = "0x80000008" - model_id = "AMD Opteron 23xx (Gen 3 Class Opteron)" - -[cpudef] - name = "Opteron_G4" - level = "0xd" - vendor = "AuthenticAMD" - family = "21" - model = "1" - stepping = "2" - feature_edx = "sse2 sse fxsr mmx clflush pse36 pat cmov mca pge mtrr sep apic cx8 mce pae msr tsc pse de fpu" - feature_ecx = "avx xsave aes popcnt sse4.2 sse4.1 cx16 ssse3 pclmulqdq sse3" - extfeature_edx = "lm rdtscp pdpe1gb fxsr mmx nx pse36 pat cmov mca pge mtrr syscall apic cx8 mce pae msr tsc pse de fpu" - extfeature_ecx = " fma4 xop 3dnowprefetch misalignsse sse4a abm svm lahf_lm" - xlevel = "0x8000001A" - model_id = "AMD Opteron 62xx class CPU" - diff --git a/target-arm/cpu.h b/target-arm/cpu.h index 5eac07037..d01285fd5 100644 --- a/target-arm/cpu.h +++ b/target-arm/cpu.h @@ -458,7 +458,15 @@ void cpu_arm_set_cp_io(CPUARMState *env, int cpnum, #define TARGET_PHYS_ADDR_SPACE_BITS 32 #define TARGET_VIRT_ADDR_SPACE_BITS 32 -#define cpu_init(model) (&cpu_arm_init(model)->env) +static inline CPUARMState *cpu_init(const char *cpu_model) +{ + ARMCPU *cpu = cpu_arm_init(cpu_model); + if (cpu) { + return &cpu->env; + } + return NULL; +} + #define cpu_exec cpu_arm_exec #define cpu_gen_code cpu_arm_gen_code #define cpu_signal_handler cpu_arm_signal_handler diff --git a/target-arm/neon_helper.c b/target-arm/neon_helper.c index 1e02d61bd..e0b9dbf67 100644 --- a/target-arm/neon_helper.c +++ b/target-arm/neon_helper.c @@ -16,7 +16,7 @@ #define SIGNBIT (uint32_t)0x80000000 #define SIGNBIT64 ((uint64_t)1 << 63) -#define SET_QC() env->vfp.xregs[ARM_VFP_FPSCR] = CPSR_Q +#define SET_QC() env->vfp.xregs[ARM_VFP_FPSCR] |= CPSR_Q #define NEON_TYPE1(name, type) \ typedef struct \ diff --git a/target-i386/cpu-qom.h b/target-i386/cpu-qom.h index 40635c4b1..590114048 100644 --- a/target-i386/cpu-qom.h +++ b/target-i386/cpu-qom.h @@ -22,6 +22,7 @@ #include "qemu/cpu.h" #include "cpu.h" +#include "error.h" #ifdef TARGET_X86_64 #define TYPE_X86_CPU "x86_64-cpu" @@ -71,5 +72,8 @@ static inline X86CPU *x86_env_get_cpu(CPUX86State *env) #define ENV_GET_CPU(e) CPU(x86_env_get_cpu(e)) +/* TODO Drop once ObjectClass::realize is available */ +void x86_cpu_realize(Object *obj, Error **errp); + #endif diff --git a/target-i386/cpu.c b/target-i386/cpu.c index 65d9af6ac..89b4ac7ec 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -1722,6 +1722,14 @@ static void mce_init(X86CPU *cpu) } } +void x86_cpu_realize(Object *obj, Error **errp) +{ + X86CPU *cpu = X86_CPU(obj); + + mce_init(cpu); + qemu_init_vcpu(&cpu->env); +} + static void x86_cpu_initfn(Object *obj) { X86CPU *cpu = X86_CPU(obj); @@ -1755,7 +1763,6 @@ static void x86_cpu_initfn(Object *obj) x86_cpuid_set_tsc_freq, NULL, NULL, NULL); env->cpuid_apic_id = env->cpu_index; - mce_init(cpu); } static void x86_cpu_common_class_init(ObjectClass *oc, void *data) diff --git a/target-i386/helper.c b/target-i386/helper.c index 0b22582ed..3421be227 100644 --- a/target-i386/helper.c +++ b/target-i386/helper.c @@ -1181,7 +1181,7 @@ CPUX86State *cpu_x86_init(const char *cpu_model) return NULL; } - qemu_init_vcpu(env); + x86_cpu_realize(OBJECT(cpu), NULL); return env; } diff --git a/target-mips/cpu.h b/target-mips/cpu.h index c0f882659..44c1152a3 100644 --- a/target-mips/cpu.h +++ b/target-mips/cpu.h @@ -627,7 +627,6 @@ enum { int cpu_mips_exec(CPUMIPSState *s); CPUMIPSState *cpu_mips_init(const char *cpu_model); -//~ uint32_t cpu_mips_get_clock (void); int cpu_mips_signal_handler(int host_signum, void *pinfo, void *puc); /* mips_timer.c */ diff --git a/target-mips/op_helper.c b/target-mips/op_helper.c index 562744795..66037acec 100644 --- a/target-mips/op_helper.c +++ b/target-mips/op_helper.c @@ -192,12 +192,6 @@ static inline uint64_t get_HILO (void) return ((uint64_t)(env->active_tc.HI[0]) << 32) | (uint32_t)env->active_tc.LO[0]; } -static inline void set_HILO (uint64_t HILO) -{ - env->active_tc.LO[0] = (int32_t)HILO; - env->active_tc.HI[0] = (int32_t)(HILO >> 32); -} - static inline void set_HIT0_LO (target_ulong arg1, uint64_t HILO) { env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF); diff --git a/target-sparc/ldst_helper.c b/target-sparc/ldst_helper.c index 04ffddf3c..efe5e704b 100644 --- a/target-sparc/ldst_helper.c +++ b/target-sparc/ldst_helper.c @@ -2098,7 +2098,7 @@ void helper_ldf_asi(CPUSPARCState *env, target_ulong addr, int asi, int size, return; } helper_check_align(env, addr, 0x3f); - for (i = 0; i < 8; i++, rd += 2, addr += 4) { + for (i = 0; i < 8; i++, rd += 2, addr += 8) { env->fpr[rd / 2].ll = helper_ld_asi(env, addr, asi & 0x19, 8, 0); } return; diff --git a/target-sparc/translate.c b/target-sparc/translate.c index 4967152e8..b95f91cd3 100644 --- a/target-sparc/translate.c +++ b/target-sparc/translate.c @@ -1343,6 +1343,11 @@ static void do_branch(DisasContext *dc, int32_t offset, uint32_t insn, int cc, unsigned int cond = GET_FIELD(insn, 3, 6), a = (insn & (1 << 29)); target_ulong target = dc->pc + offset; +#ifdef TARGET_SPARC64 + if (unlikely(AM_CHECK(dc))) { + target &= 0xffffffffULL; + } +#endif if (cond == 0x0) { /* unconditional not taken */ if (a) { @@ -1388,6 +1393,11 @@ static void do_fbranch(DisasContext *dc, int32_t offset, uint32_t insn, int cc, unsigned int cond = GET_FIELD(insn, 3, 6), a = (insn & (1 << 29)); target_ulong target = dc->pc + offset; +#ifdef TARGET_SPARC64 + if (unlikely(AM_CHECK(dc))) { + target &= 0xffffffffULL; + } +#endif if (cond == 0x0) { /* unconditional not taken */ if (a) { @@ -1434,6 +1444,9 @@ static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn, unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29)); target_ulong target = dc->pc + offset; + if (unlikely(AM_CHECK(dc))) { + target &= 0xffffffffULL; + } flush_cond(dc, r_cond); gen_cond_reg(r_cond, cond, r_reg); if (a) { @@ -2486,6 +2499,11 @@ static void disas_sparc_insn(DisasContext * dc, unsigned int insn) tcg_temp_free(r_const); target += dc->pc; gen_mov_pc_npc(dc, cpu_cond); +#ifdef TARGET_SPARC64 + if (unlikely(AM_CHECK(dc))) { + target &= 0xffffffffULL; + } +#endif dc->npc = target; } goto jmp_insn; @@ -2610,7 +2628,11 @@ static void disas_sparc_insn(DisasContext * dc, unsigned int insn) { TCGv r_const; - r_const = tcg_const_tl(dc->pc); + if (unlikely(AM_CHECK(dc))) { + r_const = tcg_const_tl(dc->pc & 0xffffffffULL); + } else { + r_const = tcg_const_tl(dc->pc); + } gen_movl_TN_reg(rd, r_const); tcg_temp_free(r_const); } @@ -4579,6 +4601,7 @@ static void disas_sparc_insn(DisasContext * dc, unsigned int insn) r_const = tcg_const_i32(3); gen_helper_check_align(cpu_env, cpu_dst, r_const); tcg_temp_free_i32(r_const); + gen_address_mask(dc, cpu_dst); tcg_gen_mov_tl(cpu_npc, cpu_dst); dc->npc = DYNAMIC_PC; } diff --git a/tcg/ppc/tcg-target.c b/tcg/ppc/tcg-target.c index dc407166f..4cde48d2f 100644 --- a/tcg/ppc/tcg-target.c +++ b/tcg/ppc/tcg-target.c @@ -244,6 +244,19 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) tcg_regset_set32(ct->u.regs, 0, 0xffffffff); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4); +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); +#if TARGET_LONG_BITS == 64 + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6); +#ifdef TCG_TARGET_CALL_ALIGN_ARGS + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R7); +#endif +#endif +#else /* !AREG0 */ +#if TARGET_LONG_BITS == 64 + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); +#endif +#endif break; case 'K': /* qemu_st[8..32] constraint */ ct->ct |= TCG_CT_REG; @@ -251,9 +264,19 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6); +#if TARGET_LONG_BITS == 64 + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R7); +#ifdef TCG_TARGET_CALL_ALIGN_ARGS + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R8); +#endif +#endif +#else /* !AREG0 */ #if TARGET_LONG_BITS == 64 tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6); #endif +#endif break; case 'M': /* qemu_st64 constraint */ ct->ct |= TCG_CT_REG; @@ -263,6 +286,12 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6); tcg_regset_reset_reg(ct->u.regs, TCG_REG_R7); +#if defined(CONFIG_TCG_PASS_AREG0) + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R8); +#ifdef TCG_TARGET_CALL_ALIGN_ARGS + tcg_regset_reset_reg(ct->u.regs, TCG_REG_R9); +#endif +#endif break; #else case 'L': @@ -509,7 +538,6 @@ static void tcg_out_call (TCGContext *s, tcg_target_long arg, int const_arg) #include "../../softmmu_defs.h" #ifdef CONFIG_TCG_PASS_AREG0 -#error CONFIG_TCG_PASS_AREG0 is not supported /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, int mmu_idx) */ static const void * const qemu_ld_helpers[4] = { @@ -552,7 +580,7 @@ static void tcg_out_qemu_ld (TCGContext *s, const TCGArg *args, int opc) { int addr_reg, data_reg, data_reg2, r0, r1, rbase, bswap; #ifdef CONFIG_SOFTMMU - int mem_index, s_bits, r2; + int mem_index, s_bits, r2, ir; void *label1_ptr, *label2_ptr; #if TARGET_LONG_BITS == 64 int addr_reg2; @@ -614,14 +642,20 @@ static void tcg_out_qemu_ld (TCGContext *s, const TCGArg *args, int opc) #endif /* slow path */ + ir = 3; +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_out_mov (s, TCG_TYPE_I32, ir++, TCG_AREG0); +#endif #if TARGET_LONG_BITS == 32 - tcg_out_mov (s, TCG_TYPE_I32, 3, addr_reg); - tcg_out_movi (s, TCG_TYPE_I32, 4, mem_index); + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg); #else - tcg_out_mov (s, TCG_TYPE_I32, 3, addr_reg2); - tcg_out_mov (s, TCG_TYPE_I32, 4, addr_reg); - tcg_out_movi (s, TCG_TYPE_I32, 5, mem_index); +#ifdef TCG_TARGET_CALL_ALIGN_ARGS + ir |= 1; #endif + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg2); + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg); +#endif + tcg_out_movi (s, TCG_TYPE_I32, ir, mem_index); tcg_out_call (s, (tcg_target_long) qemu_ld_helpers[s_bits], 1); switch (opc) { @@ -810,17 +844,18 @@ static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc) #endif /* slow path */ + ir = 3; +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_out_mov (s, TCG_TYPE_I32, ir++, TCG_AREG0); +#endif #if TARGET_LONG_BITS == 32 - tcg_out_mov (s, TCG_TYPE_I32, 3, addr_reg); - ir = 4; + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg); #else - tcg_out_mov (s, TCG_TYPE_I32, 3, addr_reg2); - tcg_out_mov (s, TCG_TYPE_I32, 4, addr_reg); #ifdef TCG_TARGET_CALL_ALIGN_ARGS - ir = 5; -#else - ir = 4; + ir |= 1; #endif + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg2); + tcg_out_mov (s, TCG_TYPE_I32, ir++, addr_reg); #endif switch (opc) { @@ -845,7 +880,7 @@ static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc) break; case 3: #ifdef TCG_TARGET_CALL_ALIGN_ARGS - ir = 5; + ir |= 1; #endif tcg_out_mov (s, TCG_TYPE_I32, ir++, data_reg2); tcg_out_mov (s, TCG_TYPE_I32, ir, data_reg); diff --git a/tcg/ppc64/tcg-target.c b/tcg/ppc64/tcg-target.c index d0b067b78..c80057458 100644 --- a/tcg/ppc64/tcg-target.c +++ b/tcg/ppc64/tcg-target.c @@ -235,6 +235,9 @@ static int target_parse_constraint (TCGArgConstraint *ct, const char **pct_str) tcg_regset_reset_reg (ct->u.regs, TCG_REG_R3); #ifdef CONFIG_SOFTMMU tcg_regset_reset_reg (ct->u.regs, TCG_REG_R4); +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_regset_reset_reg (ct->u.regs, TCG_REG_R5); +#endif #endif break; case 'S': /* qemu_st constraint */ @@ -244,6 +247,9 @@ static int target_parse_constraint (TCGArgConstraint *ct, const char **pct_str) #ifdef CONFIG_SOFTMMU tcg_regset_reset_reg (ct->u.regs, TCG_REG_R4); tcg_regset_reset_reg (ct->u.regs, TCG_REG_R5); +#ifdef CONFIG_TCG_PASS_AREG0 + tcg_regset_reset_reg (ct->u.regs, TCG_REG_R6); +#endif #endif break; case 'Z': @@ -642,7 +648,7 @@ static void tcg_out_qemu_ld (TCGContext *s, const TCGArg *args, int opc) { int addr_reg, data_reg, r0, r1, rbase, bswap; #ifdef CONFIG_SOFTMMU - int r2, mem_index, s_bits; + int r2, mem_index, s_bits, ir; void *label1_ptr, *label2_ptr; #endif @@ -669,18 +675,13 @@ static void tcg_out_qemu_ld (TCGContext *s, const TCGArg *args, int opc) #endif /* slow path */ - tcg_out_mov (s, TCG_TYPE_I64, 3, addr_reg); - tcg_out_movi (s, TCG_TYPE_I64, 4, mem_index); - + ir = 3; #ifdef CONFIG_TCG_PASS_AREG0 - /* XXX/FIXME: suboptimal */ - tcg_out_mov (s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2], - tcg_target_call_iarg_regs[1]); - tcg_out_mov (s, TCG_TYPE_TL, tcg_target_call_iarg_regs[1], - tcg_target_call_iarg_regs[0]); - tcg_out_mov (s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], - TCG_AREG0); + tcg_out_mov (s, TCG_TYPE_I64, ir++, TCG_AREG0); #endif + tcg_out_mov (s, TCG_TYPE_I64, ir++, addr_reg); + tcg_out_movi (s, TCG_TYPE_I64, ir++, mem_index); + tcg_out_call (s, (tcg_target_long) qemu_ld_helpers[s_bits], 1); switch (opc) { @@ -799,7 +800,7 @@ static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc) { int addr_reg, r0, r1, rbase, data_reg, bswap; #ifdef CONFIG_SOFTMMU - int r2, mem_index; + int r2, mem_index, ir; void *label1_ptr, *label2_ptr; #endif @@ -825,21 +826,14 @@ static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc) #endif /* slow path */ - tcg_out_mov (s, TCG_TYPE_I64, 3, addr_reg); - tcg_out_rld (s, RLDICL, 4, data_reg, 0, 64 - (1 << (3 + opc))); - tcg_out_movi (s, TCG_TYPE_I64, 5, mem_index); - + ir = 3; #ifdef CONFIG_TCG_PASS_AREG0 - /* XXX/FIXME: suboptimal */ - tcg_out_mov (s, TCG_TYPE_I32, tcg_target_call_iarg_regs[3], - tcg_target_call_iarg_regs[2]); - tcg_out_mov (s, TCG_TYPE_I64, tcg_target_call_iarg_regs[2], - tcg_target_call_iarg_regs[1]); - tcg_out_mov (s, TCG_TYPE_TL, tcg_target_call_iarg_regs[1], - tcg_target_call_iarg_regs[0]); - tcg_out_mov (s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], - TCG_AREG0); + tcg_out_mov (s, TCG_TYPE_I64, ir++, TCG_AREG0); #endif + tcg_out_mov (s, TCG_TYPE_I64, ir++, addr_reg); + tcg_out_rld (s, RLDICL, ir++, data_reg, 0, 64 - (1 << (3 + opc))); + tcg_out_movi (s, TCG_TYPE_I64, ir++, mem_index); + tcg_out_call (s, (tcg_target_long) qemu_st_helpers[opc], 1); label2_ptr = s->code_ptr; @@ -20,7 +20,7 @@ #include "config.h" /* Defining NDEBUG disables assertions (which makes the code faster). */ -#if !defined(CONFIG_TCG_DEBUG) && !defined(NDEBUG) +#if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) # define NDEBUG #endif diff --git a/tests/Makefile b/tests/Makefile index 998868129..20e4da9fb 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -18,7 +18,8 @@ check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh # All QTests for now are POSIX-only, but the dependencies are # really in libqtest, not in the testcases themselves. -check-qtest-i386-y = tests/rtc-test +check-qtest-i386-y = tests/rtc-test$(EXESUF) +check-qtest-i386-y = tests/fdc-test$(EXESUF) check-qtest-x86_64-y = $(check-qtest-i386-y) check-qtest-sparc-y = tests/m48t59-test$(EXESUF) check-qtest-sparc64-y = tests/m48t59-test$(EXESUF) @@ -67,6 +68,7 @@ tests/test-qmp-commands$(EXESUF): tests/test-qmp-commands.o tests/test-qmp-marsh tests/rtc-test$(EXESUF): tests/rtc-test.o $(trace-obj-y) tests/m48t59-test$(EXESUF): tests/m48t59-test.o $(trace-obj-y) +tests/fdc-test$(EXESUF): tests/fdc-test.o tests/libqtest.o # QTest rules diff --git a/tests/fdc-test.c b/tests/fdc-test.c new file mode 100644 index 000000000..5b5dd7481 --- /dev/null +++ b/tests/fdc-test.c @@ -0,0 +1,195 @@ +/* + * Floppy test cases. + * + * Copyright (c) 2012 Kevin Wolf <kwolf@redhat.com> + * + * 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 <stdint.h> +#include <string.h> +#include <stdio.h> + +#include <glib.h> + +#include "libqtest.h" +#include "qemu-common.h" + +#define TEST_IMAGE_SIZE 1440 * 1024 + +#define FLOPPY_BASE 0x3f0 +#define FLOPPY_IRQ 6 + +enum { + reg_sra = 0x0, + reg_srb = 0x1, + reg_dor = 0x2, + reg_msr = 0x4, + reg_dsr = 0x4, + reg_fifo = 0x5, + reg_dir = 0x7, +}; + +enum { + CMD_SENSE_INT = 0x08, + CMD_SEEK = 0x0f, +}; + +enum { + RQM = 0x80, + DIO = 0x40, + + DSKCHG = 0x80, +}; + +char test_image[] = "/tmp/qtest.XXXXXX"; + +#define assert_bit_set(data, mask) g_assert_cmphex((data) & (mask), ==, (mask)) +#define assert_bit_clear(data, mask) g_assert_cmphex((data) & (mask), ==, 0) + +static void floppy_send(uint8_t byte) +{ + uint8_t msr; + + msr = inb(FLOPPY_BASE + reg_msr); + assert_bit_set(msr, RQM); + assert_bit_clear(msr, DIO); + + outb(FLOPPY_BASE + reg_fifo, byte); +} + +static uint8_t floppy_recv(void) +{ + uint8_t msr; + + msr = inb(FLOPPY_BASE + reg_msr); + assert_bit_set(msr, RQM | DIO); + + return inb(FLOPPY_BASE + reg_fifo); +} + +static void ack_irq(void) +{ + g_assert(get_irq(FLOPPY_IRQ)); + floppy_send(CMD_SENSE_INT); + floppy_recv(); + floppy_recv(); + g_assert(!get_irq(FLOPPY_IRQ)); +} + +static void send_step_pulse(void) +{ + int drive = 0; + int head = 0; + static int cyl = 0; + + floppy_send(CMD_SEEK); + floppy_send(head << 2 | drive); + g_assert(!get_irq(FLOPPY_IRQ)); + floppy_send(cyl); + ack_irq(); + + cyl = (cyl + 1) % 4; +} + +static void test_media_change(void) +{ + uint8_t dir; + + /* Media changed bit must be up-to-date after step pulse. Do two SEEKs + * because we may already happen to be on the right cylinder initially. */ + send_step_pulse(); + send_step_pulse(); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_clear(dir, DSKCHG); + + /* 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 */ + + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + + send_step_pulse(); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + + /* And then insert it again. 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 */ + + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); + + send_step_pulse(); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_clear(dir, DSKCHG); + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_clear(dir, DSKCHG); +} + +int main(int argc, char **argv) +{ + const char *arch = qtest_get_arch(); + char *cmdline; + int fd; + int ret; + + /* Check architecture */ + if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) { + g_test_message("Skipping test for non-x86\n"); + return 0; + } + + /* Create a temporary raw image */ + fd = mkstemp(test_image); + g_assert(fd >= 0); + ret = ftruncate(fd, TEST_IMAGE_SIZE); + g_assert(ret == 0); + close(fd); + + /* Run the tests */ + g_test_init(&argc, &argv, NULL); + + cmdline = g_strdup_printf("-vnc none " + "-drive file=%s,if=floppy,cache=writeback ", + test_image); + + qtest_start(cmdline); + qtest_irq_intercept_in(global_qtest, "ioapic"); + qtest_add_func("/fdc/media_change", test_media_change); + + ret = g_test_run(); + + /* Cleanup */ + qtest_quit(global_qtest); + unlink(test_image); + + return ret; +} diff --git a/tests/libqtest.c b/tests/libqtest.c index 295c6d49d..6d333ef0a 100644 --- a/tests/libqtest.c +++ b/tests/libqtest.c @@ -36,6 +36,7 @@ QTestState *global_qtest; struct QTestState { int fd; + int qmp_fd; bool irq_level[MAX_IRQ]; GString *rx; gchar *pid_file; @@ -45,48 +46,76 @@ struct QTestState g_assert_cmpint(ret, !=, -1); \ } while (0) +static int init_socket(const char *socket_path) +{ + struct sockaddr_un addr; + int sock; + int ret; + + sock = socket(PF_UNIX, SOCK_STREAM, 0); + g_assert_no_errno(sock); + + addr.sun_family = AF_UNIX; + snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path); + qemu_set_cloexec(sock); + + do { + ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr)); + } while (ret == -1 && errno == EINTR); + g_assert_no_errno(ret); + listen(sock, 1); + + return sock; +} + +static int socket_accept(int sock) +{ + struct sockaddr_un addr; + socklen_t addrlen; + int ret; + + do { + ret = accept(sock, (struct sockaddr *)&addr, &addrlen); + } while (ret == -1 && errno == EINTR); + g_assert_no_errno(ret); + close(sock); + + return ret; +} + QTestState *qtest_init(const char *extra_args) { QTestState *s; - struct sockaddr_un addr; - int sock, ret, i; + int sock, qmpsock, ret, i; gchar *socket_path; + gchar *qmp_socket_path; gchar *pid_file; gchar *command; const char *qemu_binary; pid_t pid; - socklen_t addrlen; qemu_binary = getenv("QTEST_QEMU_BINARY"); g_assert(qemu_binary != NULL); socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid()); + qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid()); pid_file = g_strdup_printf("/tmp/qtest-%d.pid", getpid()); s = g_malloc(sizeof(*s)); - sock = socket(PF_UNIX, SOCK_STREAM, 0); - g_assert_no_errno(sock); - - addr.sun_family = AF_UNIX; - snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path); - qemu_set_cloexec(sock); - - do { - ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr)); - } while (ret == -1 && errno == EINTR); - g_assert_no_errno(ret); - listen(sock, 1); + sock = init_socket(socket_path); + qmpsock = init_socket(qmp_socket_path); pid = fork(); if (pid == 0) { command = g_strdup_printf("%s " "-qtest unix:%s,nowait " "-qtest-log /dev/null " + "-qmp unix:%s,nowait " "-pidfile %s " "-machine accel=qtest " "%s", qemu_binary, socket_path, - pid_file, + qmp_socket_path, pid_file, extra_args ?: ""); ret = system(command); @@ -94,13 +123,9 @@ QTestState *qtest_init(const char *extra_args) g_free(command); } - do { - ret = accept(sock, (struct sockaddr *)&addr, &addrlen); - } while (ret == -1 && errno == EINTR); - g_assert_no_errno(ret); - close(sock); + s->fd = socket_accept(sock); + s->qmp_fd = socket_accept(qmpsock); - s->fd = ret; s->rx = g_string_new(""); s->pid_file = pid_file; for (i = 0; i < MAX_IRQ; i++) { @@ -108,6 +133,11 @@ QTestState *qtest_init(const char *extra_args) } g_free(socket_path); + g_free(qmp_socket_path); + + /* Read the QMP greeting and then do the handshake */ + qtest_qmp(s, ""); + qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }"); return s; } @@ -131,22 +161,19 @@ void qtest_quit(QTestState *s) } } -static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) +static void socket_sendf(int fd, const char *fmt, va_list ap) { - va_list ap; gchar *str; size_t size, offset; - va_start(ap, fmt); str = g_strdup_vprintf(fmt, ap); - va_end(ap); size = strlen(str); offset = 0; while (offset < size) { ssize_t len; - len = write(s->fd, str + offset, size - offset); + len = write(fd, str + offset, size - offset); if (len == -1 && errno == EINTR) { continue; } @@ -158,6 +185,15 @@ static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) } } +static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + socket_sendf(s->fd, fmt, ap); + va_end(ap); +} + static GString *qtest_recv_line(QTestState *s) { GString *line; @@ -233,6 +269,39 @@ redo: return words; } +void qtest_qmp(QTestState *s, const char *fmt, ...) +{ + va_list ap; + bool has_reply = false; + int nesting = 0; + + /* Send QMP request */ + va_start(ap, fmt); + socket_sendf(s->qmp_fd, fmt, ap); + va_end(ap); + + /* Receive reply */ + while (!has_reply || nesting > 0) { + ssize_t len; + char c; + + len = read(s->qmp_fd, &c, 1); + if (len == -1 && errno == EINTR) { + continue; + } + + switch (c) { + case '{': + nesting++; + has_reply = true; + break; + case '}': + nesting--; + break; + } + } +} + const char *qtest_get_arch(void) { const char *qemu = getenv("QTEST_QEMU_BINARY"); diff --git a/tests/libqtest.h b/tests/libqtest.h index 2ca85a9ee..c8ade856f 100644 --- a/tests/libqtest.h +++ b/tests/libqtest.h @@ -38,6 +38,15 @@ QTestState *qtest_init(const char *extra_args); void qtest_quit(QTestState *s); /** + * qtest_qmp: + * @s: QTestState instance to operate on. + * @fmt...: QMP message to send to qemu + * + * Sends a QMP message to QEMU + */ +void qtest_qmp(QTestState *s, const char *fmt, ...); + +/** * qtest_get_irq: * @s: QTestState instance to operate on. * @num: Interrupt to observe. @@ -207,6 +216,14 @@ void qtest_add_func(const char *str, void (*fn)); ) /** + * qmp: + * @fmt...: QMP message to send to qemu + * + * Sends a QMP message to QEMU + */ +#define qmp(fmt, ...) qtest_qmp(global_qtest, fmt, ## __VA_ARGS__) + +/** * get_irq: * @num: Interrupt to observe. * diff --git a/tests/qemu-iotests/002.out b/tests/qemu-iotests/002.out index 7535884f1..75f5876e8 100644 --- a/tests/qemu-iotests/002.out +++ b/tests/qemu-iotests/002.out @@ -15,9 +15,9 @@ read 134217728/134217728 bytes at offset 0 unaligned pwrite wrote 42/42 bytes at offset 66 -42.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +42 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) verify pattern read 42/42 bytes at offset 66 -42.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +42 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) *** done diff --git a/tests/qemu-iotests/012.out b/tests/qemu-iotests/012.out index 0d7807931..5f9b9900b 100644 --- a/tests/qemu-iotests/012.out +++ b/tests/qemu-iotests/012.out @@ -5,5 +5,5 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 == read from read-only image read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) *** done diff --git a/tests/qemu-iotests/016.out b/tests/qemu-iotests/016.out index 86ad5f6c1..18679780d 100644 --- a/tests/qemu-iotests/016.out +++ b/tests/qemu-iotests/016.out @@ -3,21 +3,21 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 == reading at EOF == read 512/512 bytes at offset 134217728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) == reading far past EOF == read 512/512 bytes at offset 268435456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) == writing at EOF == wrote 512/512 bytes at offset 134217728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) read 512/512 bytes at offset 134217728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) == writing far past EOF == wrote 512/512 bytes at offset 268435456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) read 512/512 bytes at offset 268435456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) *** done diff --git a/tests/qemu-iotests/017.out b/tests/qemu-iotests/017.out index e8ab36792..a861e5833 100644 --- a/tests/qemu-iotests/017.out +++ b/tests/qemu-iotests/017.out @@ -4,265 +4,265 @@ Filling base image === IO: pattern 0 qemu-io> wrote 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -274,265 +274,265 @@ Filling test image === IO: pattern 1 qemu-io> wrote 512/512 bytes at offset 512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -541,262 +541,262 @@ Reading === IO: pattern 0 qemu-io> read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -808,262 +808,262 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) diff --git a/tests/qemu-iotests/018.out b/tests/qemu-iotests/018.out index a3079176d..6bbd815ce 100644 --- a/tests/qemu-iotests/018.out +++ b/tests/qemu-iotests/018.out @@ -4,265 +4,265 @@ Filling base image === IO: pattern 0 qemu-io> wrote 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -274,265 +274,265 @@ Filling test image === IO: pattern 1 qemu-io> wrote 512/512 bytes at offset 512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -541,262 +541,262 @@ Reading === IO: pattern 0 qemu-io> read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -808,262 +808,262 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) diff --git a/tests/qemu-iotests/019.out b/tests/qemu-iotests/019.out index b51224b50..5f9a5f2b3 100644 --- a/tests/qemu-iotests/019.out +++ b/tests/qemu-iotests/019.out @@ -4,265 +4,265 @@ Filling base image === IO: pattern 42 qemu-io> wrote 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -274,265 +274,265 @@ Filling test image === IO: pattern 43 qemu-io> wrote 512/512 bytes at offset 512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -548,262 +548,262 @@ qemu-io> Reading === IO: pattern 42 qemu-io> read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -815,262 +815,262 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -1092,262 +1092,262 @@ qemu-io> Reading === IO: pattern 42 qemu-io> read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -1359,262 +1359,262 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) diff --git a/tests/qemu-iotests/020.out b/tests/qemu-iotests/020.out index 9b8fd43ed..4ba56bd87 100644 --- a/tests/qemu-iotests/020.out +++ b/tests/qemu-iotests/020.out @@ -4,265 +4,265 @@ Filling base image === IO: pattern 0 qemu-io> wrote 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -274,265 +274,265 @@ Filling test image === IO: pattern 1 qemu-io> wrote 512/512 bytes at offset 512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -542,262 +542,262 @@ Reading from the backing file === IO: pattern 0 qemu-io> read 512/512 bytes at offset 0 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 21504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 1536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 2560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 5632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 6656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 7680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 8704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 9728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 10752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 11776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 12800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 13824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 14848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 15872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 16896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 17920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 18944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 19968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 20992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 22016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 23040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 24064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 25088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 26112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 27136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 28160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 29184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 30208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 31232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 32256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 33280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 34304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 35328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 36352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 37376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) @@ -809,262 +809,262 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294975488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294968832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294969856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294970880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294971904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294972928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294973952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294974976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294976000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294977024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294978048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294979072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294980096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294981120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294982144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294983168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294984192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294985216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294986240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294987264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294988288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294989312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294990336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294991360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294992384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294993408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294994432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294995456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294996480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294997504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294998528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4294999552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295000576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295001600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295002624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295003648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295004672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) diff --git a/tests/qemu-iotests/023.out b/tests/qemu-iotests/023.out index 8a7c5b2ff..10c56844c 100644 --- a/tests/qemu-iotests/023.out +++ b/tests/qemu-iotests/023.out @@ -80,150 +80,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -362,150 +362,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -644,150 +644,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -926,150 +926,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -1210,150 +1210,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -1492,150 +1492,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -1774,150 +1774,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -2056,150 +2056,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -2344,150 +2344,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -2626,150 +2626,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 42496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 74752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 106496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -2910,150 +2910,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -3192,150 +3192,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295005696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295039488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295061504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -3478,150 +3478,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 66560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 67584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 68608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 69632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 70656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 71680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 72704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 73728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 75264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 76288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 77312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 78336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 79360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 80384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 81408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 82432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 83456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 84480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 85504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 86528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 87552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 88576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 89600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 90624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 91648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 92672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 93696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 94720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 95744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 96768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 97792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 98816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 99840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 100864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 101888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 102912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 103936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 104960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 105984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 107008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 108032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 109056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 110080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -3760,150 +3760,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 85504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 110080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -4042,150 +4042,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 65536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 66560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 67584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 68608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 69632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 70656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 71680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 72704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 73728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 75264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 76288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 77312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 78336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 79360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 80384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 81408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 82432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 83456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 84480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 85504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 86528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 87552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 88576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 89600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 90624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 91648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 92672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 93696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 94720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 95744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 96768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 97792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 98816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 99840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 100864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 101888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 102912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 103936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 104960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 105984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 107008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 108032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 109056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 110080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -4324,150 +4324,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 38912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 39936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 40960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 41984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 43008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 44032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 45056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 46080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 47104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 48128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 49152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 50176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 51200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 52224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 53248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 54272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 55296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 56320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 57344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 58368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 59392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 60416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 61440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 62464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 63488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 64512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 65536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 66560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 67584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 68608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 69632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 70656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 71680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 72704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 73728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 75264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 76288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 77312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 78336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 79360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 80384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 81408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 82432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 83456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 84480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 85504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 86528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 87552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 88576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 89600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 90624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 91648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 92672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 93696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 94720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 95744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 96768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 97792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 98816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 99840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 100864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 101888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 102912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 103936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 104960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 105984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 107008 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 108032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 109056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 110080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -4608,150 +4608,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295033856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295034880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295035904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295036928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295037952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295038976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295040000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295041024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295042560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295043584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295044608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295045632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295046656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295047680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295048704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295049728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295050752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295051776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295052800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295053824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295054848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295055872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295056896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295057920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295058944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295059968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295060992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295062016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295063040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295064064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295065088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295066112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295067136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295068160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295069184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295070208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295071232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295072256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295073280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295074304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295075328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295076352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295077376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -4890,150 +4890,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295041024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295077376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -5172,150 +5172,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295032832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295033856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295034880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295035904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295036928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295037952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295038976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295040000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295041024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295042560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295043584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295044608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295045632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295046656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295047680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295048704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295049728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295050752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295051776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295052800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295053824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295054848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295055872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295056896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295057920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295058944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295059968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295060992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295062016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295063040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295064064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295065088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295066112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295067136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295068160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295069184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295070208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295071232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295072256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295073280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295074304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295075328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295076352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 4295077376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 @@ -5454,150 +5454,150 @@ qemu-io> 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295006208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295007232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295008256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295009280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295010304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295011328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295012352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295013376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295014400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295015424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295016448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295017472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295018496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295019520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295020544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295021568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295022592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295023616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295024640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295025664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295026688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295027712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295028736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295029760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295030784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295031808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295032832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295033856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295034880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295035904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295036928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295037952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295038976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295040000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295041024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295042560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295043584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295044608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295045632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295046656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295047680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295048704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295049728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295050752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295051776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295052800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295053824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295054848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295055872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295056896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295057920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295058944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295059968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295060992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295062016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295063040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295064064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295065088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295066112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295067136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295068160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295069184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295070208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295071232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295072256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295073280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295074304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295075328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295076352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 4295077376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 diff --git a/tests/qemu-iotests/027.out b/tests/qemu-iotests/027.out index a45c30372..4fcb4161d 100644 --- a/tests/qemu-iotests/027.out +++ b/tests/qemu-iotests/027.out @@ -19,5 +19,5 @@ read 2048/2048 bytes at offset 0 == verify zeroes after sub-cluster pattern == read 2560/2560 bytes at offset 1024 -2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +2.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) *** done diff --git a/tests/qemu-iotests/028.out b/tests/qemu-iotests/028.out index fe007887e..8b6cfcb02 100644 --- a/tests/qemu-iotests/028.out +++ b/tests/qemu-iotests/028.out @@ -4,69 +4,69 @@ Filling base image === IO: pattern 195 qemu-io> wrote 512/512 bytes at offset 3221194240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221195264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221196288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221197312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221198336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221199360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221200384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221201408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221202432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221203456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221204480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221205504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221206528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221207552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221208576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221209600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221210624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221211648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221212672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221213696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221214720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221215744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221216768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221217792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221218816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221219840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221220864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221221888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221222912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221223936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221224960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221225984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> No errors were found on the image. Creating test image with backing file @@ -75,395 +75,395 @@ Filling test image === IO: pattern 196 qemu-io> wrote 512/512 bytes at offset 3221194752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221195776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221196800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221197824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221198848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221199872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221200896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221201920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221202944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221203968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221204992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221206016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221207040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221208064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221209088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221210112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221211136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221212160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221213184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221214208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221215232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221216256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221217280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221218304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221219328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221220352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221221376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221222400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221223424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221224448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221225472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221226496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221227520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221228544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221229568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221230592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221231616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221232640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221233664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221234688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221235712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221236736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221237760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221238784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221239808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221240832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221241856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221242880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221243904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221244928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221245952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221246976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221248000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221249024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221250048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221251072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221252096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221253120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221254144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221255168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221256192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221257216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221258240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> wrote 512/512 bytes at offset 3221259264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> No errors were found on the image. Reading === IO: pattern 195 qemu-io> read 512/512 bytes at offset 3221194240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221195264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221196288 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221197312 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221198336 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221199360 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221200384 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221201408 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221202432 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221203456 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221204480 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221205504 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221206528 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221207552 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221208576 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221209600 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221210624 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221211648 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221212672 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221213696 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221214720 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221215744 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221216768 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221217792 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221218816 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221219840 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221220864 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221221888 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221222912 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221223936 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221224960 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221225984 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221195776 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221196800 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221197824 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221198848 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221199872 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221200896 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221201920 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221202944 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221203968 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221204992 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221206016 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221207040 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221208064 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221209088 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221210112 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221211136 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221212160 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221213184 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221214208 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221215232 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221216256 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221217280 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221218304 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221219328 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221220352 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221221376 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221222400 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221223424 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221224448 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221225472 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221226496 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221227520 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221228544 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221229568 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221230592 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221231616 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221232640 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221233664 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221234688 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221235712 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221236736 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221237760 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221238784 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221239808 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221240832 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221241856 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221242880 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221243904 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221244928 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221245952 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221246976 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221248000 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221249024 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221250048 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221251072 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221252096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221253120 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221254144 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221255168 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221256192 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221257216 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221258240 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221259264 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221228032 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221229056 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221230080 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221231104 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221232128 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221233152 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221234176 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221235200 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221236224 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221237248 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221238272 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221239296 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221240320 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221241344 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221242368 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221243392 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221244416 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221245440 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221246464 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221247488 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221248512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221249536 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221250560 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221251584 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221252608 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221253632 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221254656 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221255680 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221256704 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221257728 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-io> read 512/512 bytes at offset 3221258752 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +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/030 b/tests/qemu-iotests/030 index 38abc2ce7..eb7bf996d 100755 --- a/tests/qemu-iotests/030 +++ b/tests/qemu-iotests/030 @@ -23,6 +23,7 @@ import iotests from iotests import qemu_img, qemu_io backing_img = os.path.join(iotests.test_dir, 'backing.img') +mid_img = os.path.join(iotests.test_dir, 'mid.img') test_img = os.path.join(iotests.test_dir, 'test.img') class ImageStreamingTestCase(iotests.QMPTestCase): @@ -52,13 +53,15 @@ class TestSingleDrive(ImageStreamingTestCase): def setUp(self): qemu_img('create', backing_img, str(TestSingleDrive.image_len)) - qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) + 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) self.vm = iotests.VM().add_drive(test_img) self.vm.launch() def tearDown(self): self.vm.shutdown() os.remove(test_img) + os.remove(mid_img) os.remove(backing_img) def test_stream(self): @@ -78,9 +81,34 @@ class TestSingleDrive(ImageStreamingTestCase): completed = True self.assert_no_active_streams() + self.vm.shutdown() + + self.assertEqual(qemu_io('-c', 'map', backing_img), + qemu_io('-c', 'map', test_img), + 'image file map does not match backing file after streaming') + + def test_stream_partial(self): + self.assert_no_active_streams() + + result = self.vm.qmp('block-stream', device='drive0', base=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', 'stream') + 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_streams() + self.vm.shutdown() - self.assertFalse('sectors not allocated' in qemu_io('-c', 'map', test_img), - 'image file not fully populated after streaming') + self.assertEqual(qemu_io('-c', 'map', mid_img), + qemu_io('-c', 'map', test_img), + 'image file map does not match backing file after streaming') def test_device_not_found(self): result = self.vm.qmp('block-stream', device='nonexistent') diff --git a/tests/qemu-iotests/030.out b/tests/qemu-iotests/030.out index 914e3737b..3f8a935a0 100644 --- a/tests/qemu-iotests/030.out +++ b/tests/qemu-iotests/030.out @@ -1,5 +1,5 @@ -..... +...... ---------------------------------------------------------------------- -Ran 5 tests +Ran 6 tests OK diff --git a/tests/qemu-iotests/033.out b/tests/qemu-iotests/033.out index 89348831d..2fe74df76 100644 --- a/tests/qemu-iotests/033.out +++ b/tests/qemu-iotests/033.out @@ -5,17 +5,17 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 wrote 1024/1024 bytes at offset 512 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 1536/1536 bytes at offset 131072 -2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +1.500 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 131072/131072 bytes at offset 1024 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) == verifying patterns (1) == read 512/512 bytes at offset 512 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) read 131072/131072 bytes at offset 1024 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) read 512/512 bytes at offset 132096 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) == rewriting zeroes == wrote 65536/65536 bytes at offset 65536 diff --git a/tests/qemu-iotests/035.out b/tests/qemu-iotests/035.out index de205f4a8..0c2279f21 100644 --- a/tests/qemu-iotests/035.out +++ b/tests/qemu-iotests/035.out @@ -3,389 +3,389 @@ 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 -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) wrote 512/512 bytes at offset XXX -512.000000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) checking image for errors No errors were found on the image. diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py index ec1a86a63..e27b40e28 100644 --- a/tests/qemu-iotests/iotests.py +++ b/tests/qemu-iotests/iotests.py @@ -28,9 +28,9 @@ __all__ = ['imgfmt', 'imgproto', 'test_dir' 'qemu_img', 'qemu_io', # This will not work if arguments or path contain spaces but is necessary if we # want to support the override options that ./check supports. -qemu_img_args = os.environ.get('QEMU_IMG', 'qemu-img').split(' ') -qemu_io_args = os.environ.get('QEMU_IO', 'qemu-io').split(' ') -qemu_args = os.environ.get('QEMU', 'qemu').split(' ') +qemu_img_args = os.environ.get('QEMU_IMG', 'qemu-img').strip().split(' ') +qemu_io_args = os.environ.get('QEMU_IO', 'qemu-io').strip().split(' ') +qemu_args = os.environ.get('QEMU', 'qemu').strip().split(' ') imgfmt = os.environ.get('IMGFMT', 'raw') imgproto = os.environ.get('IMGPROTO', 'file') @@ -87,10 +87,12 @@ class VM(object): def shutdown(self): '''Terminate the VM and clean up''' - self._qmp.cmd('quit') - self._popen.wait() - os.remove(self._monitor_path) - os.remove(self._qemu_log_path) + if not self._popen is None: + self._qmp.cmd('quit') + self._popen.wait() + os.remove(self._monitor_path) + os.remove(self._qemu_log_path) + self._popen = None def qmp(self, cmd, **args): '''Invoke a QMP command and return the result dict''' diff --git a/tests/tcg/test-mmap.c b/tests/tcg/test-mmap.c index c67174a26..c418b6766 100644 --- a/tests/tcg/test-mmap.c +++ b/tests/tcg/test-mmap.c @@ -3,7 +3,7 @@ * * When running qemu-linux-user with the -p flag, you may need to tell * this test program about the pagesize because getpagesize() will not reflect - * the -p choice. Simply pass one argument beeing the pagesize. + * the -p choice. Simply pass one argument being the pagesize. * * Copyright (c) 2007 AXIS Communications AB * Written by Edgar E. Iglesias. diff --git a/ui/spice-core.c b/ui/spice-core.c index a46852479..4fc48f890 100644 --- a/ui/spice-core.c +++ b/ui/spice-core.c @@ -462,6 +462,13 @@ SpiceInfo *qmp_query_spice(Error **errp) info->tls_port = tls_port; } +#if SPICE_SERVER_VERSION >= 0x000a03 /* 0.10.3 */ + info->mouse_mode = spice_server_is_server_mouse(spice_server) ? + SPICE_QUERY_MOUSE_MODE_SERVER : + SPICE_QUERY_MOUSE_MODE_CLIENT; +#else + info->mouse_mode = SPICE_QUERY_MOUSE_MODE_UNKNOWN; +#endif /* for compatibility with the original command */ info->has_channels = true; info->channels = qmp_query_spice_channels(); @@ -3068,7 +3068,7 @@ int vnc_display_open(DisplayState *ds, const char *display) if (strncmp(display, "unix:", 5) == 0) vs->lsock = unix_connect(display+5); else - vs->lsock = inet_connect(display, SOCK_STREAM); + vs->lsock = inet_connect(display, true, NULL); if (-1 == vs->lsock) { g_free(vs->display); vs->display = NULL; @@ -3088,7 +3088,8 @@ int vnc_display_open(DisplayState *ds, const char *display) pstrcpy(dpy, 256, "unix:"); vs->lsock = unix_listen(display+5, dpy+5, 256-5); } else { - vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900); + vs->lsock = inet_listen(display, dpy, 256, + SOCK_STREAM, 5900, NULL); } if (-1 == vs->lsock) { g_free(dpy); diff --git a/user-exec.c b/user-exec.c index be6bc4f64..d8c2ad9f2 100644 --- a/user-exec.c +++ b/user-exec.c @@ -97,7 +97,8 @@ static inline int handle_cpu_signal(uintptr_t pc, unsigned long address, pc, address, is_write, *(unsigned long *)old_set); #endif /* XXX: locking issue */ - if (is_write && page_unprotect(h2g(address), pc, puc)) { + if (is_write && h2g_valid(address) + && page_unprotect(h2g(address), pc, puc)) { return 1; } @@ -273,6 +273,7 @@ static int default_monitor = 1; static int default_floppy = 1; static int default_cdrom = 1; static int default_sdcard = 1; +static int default_vga = 1; static struct { const char *driver; @@ -288,6 +289,12 @@ static struct { { .driver = "virtio-serial-pci", .flag = &default_virtcon }, { .driver = "virtio-serial-s390", .flag = &default_virtcon }, { .driver = "virtio-serial", .flag = &default_virtcon }, + { .driver = "VGA", .flag = &default_vga }, + { .driver = "isa-vga", .flag = &default_vga }, + { .driver = "cirrus-vga", .flag = &default_vga }, + { .driver = "isa-cirrus-vga", .flag = &default_vga }, + { .driver = "vmware-svga", .flag = &default_vga }, + { .driver = "qxl-vga", .flag = &default_vga }, }; static void res_free(void) @@ -366,6 +373,11 @@ static const RunStateTransition runstate_transitions_def[] = { { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED }, { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE }, + { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED }, + { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED }, + { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING }, + { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE }, + { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING }, { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE }, @@ -1288,7 +1300,6 @@ static pid_t shutdown_pid; static int powerdown_requested; static int debug_requested; static int suspend_requested; -static bool is_suspended; static NotifierList suspend_notifiers = NOTIFIER_LIST_INITIALIZER(suspend_notifiers); static NotifierList wakeup_notifiers = @@ -1420,13 +1431,13 @@ static void qemu_system_suspend(void) { pause_all_vcpus(); notifier_list_notify(&suspend_notifiers, NULL); + runstate_set(RUN_STATE_SUSPENDED); monitor_protocol_event(QEVENT_SUSPEND, NULL); - is_suspended = true; } void qemu_system_suspend_request(void) { - if (is_suspended) { + if (runstate_check(RUN_STATE_SUSPENDED)) { return; } suspend_requested = 1; @@ -1441,17 +1452,17 @@ void qemu_register_suspend_notifier(Notifier *notifier) void qemu_system_wakeup_request(WakeupReason reason) { - if (!is_suspended) { + if (!runstate_check(RUN_STATE_SUSPENDED)) { return; } if (!(wakeup_reason_mask & (1 << reason))) { return; } + runstate_set(RUN_STATE_RUNNING); monitor_protocol_event(QEVENT_WAKEUP, NULL); notifier_list_notify(&wakeup_notifiers, &reason); reset_requested = 1; qemu_notify_event(); - is_suspended = false; } void qemu_system_wakeup_enable(WakeupReason reason, bool enabled) @@ -2273,13 +2284,14 @@ int main(int argc, char **argv, char **envp) const char *loadvm = NULL; QEMUMachine *machine; const char *cpu_model; - const char *vga_model = NULL; + const char *vga_model = "none"; const char *pid_file = NULL; const char *incoming = NULL; #ifdef CONFIG_VNC int show_vnc_port = 0; #endif - int defconfig = 1; + bool defconfig = true; + bool userconfig = true; const char *log_mask = NULL; const char *log_file = NULL; GMemVTable mem_trace = { @@ -2346,7 +2358,10 @@ int main(int argc, char **argv, char **envp) popt = lookup_opt(argc, argv, &optarg, &optind); switch (popt->index) { case QEMU_OPTION_nodefconfig: - defconfig=0; + defconfig = false; + break; + case QEMU_OPTION_nouserconfig: + userconfig = false; break; } } @@ -2354,14 +2369,8 @@ int main(int argc, char **argv, char **envp) if (defconfig) { int ret; - - ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf"); - if (ret < 0 && ret != -ENOENT) { - exit(1); - } - - ret = qemu_read_config_file(arch_config_name); - if (ret < 0 && ret != -ENOENT) { + ret = qemu_read_default_config_files(userconfig); + if (ret < 0) { exit(1); } } @@ -2705,6 +2714,7 @@ int main(int argc, char **argv, char **envp) break; case QEMU_OPTION_vga: vga_model = optarg; + default_vga = 0; break; case QEMU_OPTION_g: { @@ -3149,7 +3159,7 @@ int main(int argc, char **argv, char **envp) default_floppy = 0; default_cdrom = 0; default_sdcard = 0; - vga_model = "none"; + default_vga = 0; break; case QEMU_OPTION_xen_domid: if (!(xen_available())) { @@ -3519,14 +3529,11 @@ int main(int argc, char **argv, char **envp) if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0) exit(1); - /* must be after qdev registration but before machine init */ - if (vga_model) { - select_vgahw(vga_model); - } else if (cirrus_vga_available()) { - select_vgahw("cirrus"); - } else { - select_vgahw("none"); + /* If no default VGA is requested, the default is "none". */ + if (default_vga && cirrus_vga_available()) { + vga_model = "cirrus"; } + select_vgahw(vga_model); if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0) != 0) exit(0); @@ -3662,8 +3669,13 @@ int main(int argc, char **argv, char **envp) } if (incoming) { - int ret = qemu_start_incoming_migration(incoming); + Error *errp = NULL; + int ret = qemu_start_incoming_migration(incoming, &errp); if (ret < 0) { + if (error_is_set(&errp)) { + fprintf(stderr, "Migrate: %s\n", error_get_pretty(errp)); + error_free(errp); + } fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n", incoming, ret); exit(ret); |