diff options
167 files changed, 7043 insertions, 5550 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.1.50 diff --git a/arch_init.c b/arch_init.c index 9a35aeea30..a9e8b7442b 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 @@ -101,6 +100,10 @@ const uint32_t arch_type = QEMU_ARCH; #define VECTYPE vector unsigned char #define SPLAT(p) vec_splat(vec_ld(0, p), 0) #define ALL_EQ(v1, v2) vec_all_eq(v1, v2) +/* altivec.h may redefine the bool macro as vector type. + * Reset it to POSIX semantics. */ +#undef bool +#define bool _Bool #elif defined __SSE2__ #include <emmintrin.h> #define VECTYPE __m128i @@ -112,6 +115,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 828256cc42..c7cb94a932 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 8debd19e3a..88ca9bb1b7 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: diff --git a/audio/audio.c b/audio/audio.c index bd9237e9d3..583ee51eab 100644 --- a/audio/audio.c +++ b/audio/audio.c @@ -1775,10 +1775,12 @@ static void audio_atexit (void) HWVoiceOut *hwo = NULL; HWVoiceIn *hwi = NULL; - while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { + while ((hwo = audio_pcm_hw_find_any_out (hwo))) { SWVoiceCap *sc; - hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE); + if (hwo->enabled) { + hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE); + } hwo->pcm_ops->fini_out (hwo); for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) { @@ -1791,8 +1793,10 @@ static void audio_atexit (void) } } - while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { - hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE); + while ((hwi = audio_pcm_hw_find_any_in (hwi))) { + if (hwi->enabled) { + hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE); + } hwi->pcm_ops->fini_in (hwi); } diff --git a/audio/mixeng.c b/audio/mixeng.c index 5446be674f..02a9d9fb92 100644 --- a/audio/mixeng.c +++ b/audio/mixeng.c @@ -33,7 +33,8 @@ #define ENDIAN_CONVERT(v) (v) /* Signed 8 bit */ -#define IN_T int8_t +#define BSIZE 8 +#define ITYPE int #define IN_MIN SCHAR_MIN #define IN_MAX SCHAR_MAX #define SIGNED @@ -42,25 +43,29 @@ #undef SIGNED #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT /* Unsigned 8 bit */ -#define IN_T uint8_t +#define BSIZE 8 +#define ITYPE uint #define IN_MIN 0 #define IN_MAX UCHAR_MAX #define SHIFT 8 #include "mixeng_template.h" #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT #undef ENDIAN_CONVERT #undef ENDIAN_CONVERSION /* Signed 16 bit */ -#define IN_T int16_t +#define BSIZE 16 +#define ITYPE int #define IN_MIN SHRT_MIN #define IN_MAX SHRT_MAX #define SIGNED @@ -78,11 +83,13 @@ #undef SIGNED #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT /* Unsigned 16 bit */ -#define IN_T uint16_t +#define BSIZE 16 +#define ITYPE uint #define IN_MIN 0 #define IN_MAX USHRT_MAX #define SHIFT 16 @@ -98,11 +105,13 @@ #undef ENDIAN_CONVERSION #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT /* Signed 32 bit */ -#define IN_T int32_t +#define BSIZE 32 +#define ITYPE int #define IN_MIN INT32_MIN #define IN_MAX INT32_MAX #define SIGNED @@ -120,11 +129,13 @@ #undef SIGNED #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT /* Unsigned 32 bit */ -#define IN_T uint32_t +#define BSIZE 32 +#define ITYPE uint #define IN_MIN 0 #define IN_MAX UINT32_MAX #define SHIFT 32 @@ -140,7 +151,8 @@ #undef ENDIAN_CONVERSION #undef IN_MAX #undef IN_MIN -#undef IN_T +#undef BSIZE +#undef ITYPE #undef SHIFT t_sample *mixeng_conv[2][2][2][3] = { diff --git a/audio/mixeng_template.h b/audio/mixeng_template.h index e644c231ad..30849a62a1 100644 --- a/audio/mixeng_template.h +++ b/audio/mixeng_template.h @@ -31,7 +31,8 @@ #define HALF (IN_MAX >> 1) #endif -#define ET glue (ENDIAN_CONVERSION, glue (_, IN_T)) +#define ET glue (ENDIAN_CONVERSION, glue (glue (glue (_, ITYPE), BSIZE), _t)) +#define IN_T glue (glue (ITYPE, BSIZE), _t) #ifdef FLOAT_MIXENG static mixeng_real inline glue (conv_, ET) (IN_T v) @@ -150,3 +151,4 @@ static void glue (glue (clip_, ET), _from_mono) #undef ET #undef HALF +#undef IN_T @@ -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(); + } + } + + ret = cco.ret; + g_free(cco.filename); - return drv->bdrv_create(filename, options); + return ret; } int bdrv_create_file(const char* filename, QEMUOptionParameter *options) @@ -362,28 +409,36 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options) return bdrv_create(drv, filename, options); } -#ifdef _WIN32 -void get_tmp_filename(char *filename, int size) +/* + * Create a uniquely-named empty temporary file. + * Return 0 upon success, otherwise a negative errno value. + */ +int get_tmp_filename(char *filename, int size) { +#ifdef _WIN32 char temp_dir[MAX_PATH]; - - GetTempPath(MAX_PATH, temp_dir); - GetTempFileName(temp_dir, "qem", 0, filename); -} + /* GetTempFileName requires that its output buffer (4th param) + have length MAX_PATH or greater. */ + assert(size >= MAX_PATH); + return (GetTempPath(MAX_PATH, temp_dir) + && GetTempFileName(temp_dir, "qem", 0, filename) + ? 0 : -GetLastError()); #else -void get_tmp_filename(char *filename, int size) -{ int fd; const char *tmpdir; - /* XXX: race condition possible */ tmpdir = getenv("TMPDIR"); if (!tmpdir) tmpdir = "/tmp"; - snprintf(filename, size, "%s/vl.XXXXXX", tmpdir); + if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) { + return -EOVERFLOW; + } fd = mkstemp(filename); - close(fd); -} + if (fd < 0 || close(fd)) { + return -errno; + } + return 0; #endif +} /* * Detect host devices. By convention, /dev/cdrom[N] is always @@ -572,16 +627,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 +640,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; @@ -712,7 +761,10 @@ int bdrv_open(BlockDriverState *bs, const char *filename, int flags, bdrv_delete(bs1); - get_tmp_filename(tmp_filename, sizeof(tmp_filename)); + ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename)); + if (ret < 0) { + return ret; + } /* Real path is meaningless for protocols */ if (is_protocol) @@ -764,14 +816,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 +884,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 +920,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 +963,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 +991,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 +1059,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 +1074,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 +1481,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 +1606,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 +1618,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 +3924,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 +4127,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 +4199,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 +4249,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 +4259,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 5222726d0f..22888a0845 100644 --- a/block/iscsi.c +++ b/block/iscsi.c @@ -25,10 +25,12 @@ #include "config-host.h" #include <poll.h> +#include <arpa/inet.h> #include "qemu-common.h" #include "qemu-error.h" #include "block_int.h" #include "trace.h" +#include "hw/scsi-defs.h" #include <iscsi/iscsi.h> #include <iscsi/scsi-lowlevel.h> @@ -37,8 +39,10 @@ typedef struct IscsiLun { struct iscsi_context *iscsi; int lun; + enum scsi_inquiry_peripheral_device_type type; int block_size; - unsigned long num_blocks; + uint64_t num_blocks; + int events; } IscsiLun; typedef struct IscsiAIOCB { @@ -104,11 +108,27 @@ static void iscsi_set_events(IscsiLun *iscsilun) { struct iscsi_context *iscsi = iscsilun->iscsi; + int ev; - qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), iscsi_process_read, - (iscsi_which_events(iscsi) & POLLOUT) - ? iscsi_process_write : NULL, - iscsi_process_flush, iscsilun); + /* We always register a read handler. */ + ev = POLLIN; + ev |= iscsi_which_events(iscsi); + if (ev != iscsilun->events) { + qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), + iscsi_process_read, + (ev & POLLOUT) ? iscsi_process_write : NULL, + iscsi_process_flush, + iscsilun); + + } + + /* If we just added an event, the callback might be delayed + * unless we call qemu_notify_event(). + */ + if (ev & ~iscsilun->events) { + qemu_notify_event(); + } + iscsilun->events = ev; } static void @@ -161,12 +181,12 @@ iscsi_readv_writev_bh_cb(void *p) static void -iscsi_aio_write10_cb(struct iscsi_context *iscsi, int status, +iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { IscsiAIOCB *acb = opaque; - trace_iscsi_aio_write10_cb(iscsi, status, acb, acb->canceled); + trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled); g_free(acb->buf); @@ -179,7 +199,7 @@ iscsi_aio_write10_cb(struct iscsi_context *iscsi, int status, acb->status = 0; if (status < 0) { - error_report("Failed to write10 data to iSCSI lun. %s", + error_report("Failed to write16 data to iSCSI lun. %s", iscsi_get_error(iscsi)); acb->status = -EIO; } @@ -204,12 +224,9 @@ iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num, struct iscsi_context *iscsi = iscsilun->iscsi; IscsiAIOCB *acb; size_t size; - int fua = 0; - - /* set FUA on writes when cache mode is write through */ - if (!(bs->open_flags & BDRV_O_CACHE_WB)) { - fua = 1; - } + uint32_t num_sectors; + uint64_t lba; + struct iscsi_data data; acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque); trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb); @@ -219,18 +236,44 @@ iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num, acb->canceled = 0; - /* XXX we should pass the iovec to write10 to avoid the extra copy */ + /* XXX we should pass the iovec to write16 to avoid the extra copy */ /* this will allow us to get rid of 'buf' completely */ size = nb_sectors * BDRV_SECTOR_SIZE; acb->buf = g_malloc(size); qemu_iovec_to_buffer(acb->qiov, acb->buf); - acb->task = iscsi_write10_task(iscsi, iscsilun->lun, acb->buf, size, - sector_qemu2lun(sector_num, iscsilun), - fua, 0, iscsilun->block_size, - iscsi_aio_write10_cb, acb); + + + acb->task = malloc(sizeof(struct scsi_task)); if (acb->task == NULL) { - error_report("iSCSI: Failed to send write10 command. %s", - iscsi_get_error(iscsi)); + error_report("iSCSI: Failed to allocate task for scsi WRITE16 " + "command. %s", iscsi_get_error(iscsi)); + qemu_aio_release(acb); + return NULL; + } + memset(acb->task, 0, sizeof(struct scsi_task)); + + acb->task->xfer_dir = SCSI_XFER_WRITE; + acb->task->cdb_size = 16; + acb->task->cdb[0] = 0x8a; + if (!(bs->open_flags & BDRV_O_CACHE_WB)) { + /* set FUA on writes when cache mode is write through */ + acb->task->cdb[1] |= 0x04; + } + lba = sector_qemu2lun(sector_num, iscsilun); + *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32); + *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff); + num_sectors = size / iscsilun->block_size; + *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors); + acb->task->expxferlen = size; + + data.data = acb->buf; + data.size = size; + + if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, + iscsi_aio_write16_cb, + &data, + acb) != 0) { + scsi_free_scsi_task(acb->task); g_free(acb->buf); qemu_aio_release(acb); return NULL; @@ -242,12 +285,12 @@ iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num, } static void -iscsi_aio_read10_cb(struct iscsi_context *iscsi, int status, +iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { IscsiAIOCB *acb = opaque; - trace_iscsi_aio_read10_cb(iscsi, status, acb, acb->canceled); + trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled); if (acb->canceled != 0) { qemu_aio_release(acb); @@ -258,7 +301,7 @@ iscsi_aio_read10_cb(struct iscsi_context *iscsi, int status, acb->status = 0; if (status != 0) { - error_report("Failed to read10 data from iSCSI lun. %s", + error_report("Failed to read16 data from iSCSI lun. %s", iscsi_get_error(iscsi)); acb->status = -EIO; } @@ -277,8 +320,10 @@ iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num, IscsiLun *iscsilun = bs->opaque; struct iscsi_context *iscsi = iscsilun->iscsi; IscsiAIOCB *acb; - size_t qemu_read_size, lun_read_size; + size_t qemu_read_size; int i; + uint64_t lba; + uint32_t num_sectors; qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors; @@ -303,16 +348,44 @@ iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num, acb->read_offset = bdrv_offset % iscsilun->block_size; } - lun_read_size = (qemu_read_size + iscsilun->block_size - + acb->read_offset - 1) - / iscsilun->block_size * iscsilun->block_size; - acb->task = iscsi_read10_task(iscsi, iscsilun->lun, - sector_qemu2lun(sector_num, iscsilun), - lun_read_size, iscsilun->block_size, - iscsi_aio_read10_cb, acb); + num_sectors = (qemu_read_size + iscsilun->block_size + + acb->read_offset - 1) + / iscsilun->block_size; + + acb->task = malloc(sizeof(struct scsi_task)); if (acb->task == NULL) { - error_report("iSCSI: Failed to send read10 command. %s", - iscsi_get_error(iscsi)); + error_report("iSCSI: Failed to allocate task for scsi READ16 " + "command. %s", iscsi_get_error(iscsi)); + qemu_aio_release(acb); + return NULL; + } + memset(acb->task, 0, sizeof(struct scsi_task)); + + acb->task->xfer_dir = SCSI_XFER_READ; + lba = sector_qemu2lun(sector_num, iscsilun); + acb->task->expxferlen = qemu_read_size; + + switch (iscsilun->type) { + case TYPE_DISK: + acb->task->cdb_size = 16; + acb->task->cdb[0] = 0x88; + *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32); + *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff); + *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors); + break; + default: + acb->task->cdb_size = 10; + acb->task->cdb[0] = 0x28; + *(uint32_t *)&acb->task->cdb[2] = htonl(lba); + *(uint16_t *)&acb->task->cdb[7] = htons(num_sectors); + break; + } + + if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task, + iscsi_aio_read16_cb, + NULL, + acb) != 0) { + scsi_free_scsi_task(acb->task); qemu_aio_release(acb); return NULL; } @@ -383,6 +456,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,6 +528,42 @@ iscsi_getlength(BlockDriverState *bs) } static void +iscsi_readcapacity16_cb(struct iscsi_context *iscsi, int status, + void *command_data, void *opaque) +{ + struct IscsiTask *itask = opaque; + struct scsi_readcapacity16 *rc16; + struct scsi_task *task = command_data; + + if (status != 0) { + error_report("iSCSI: Failed to read capacity of iSCSI lun. %s", + iscsi_get_error(iscsi)); + itask->status = 1; + itask->complete = 1; + scsi_free_scsi_task(task); + return; + } + + 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 = 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_readcapacity10_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { @@ -422,15 +590,70 @@ iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status, } 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->num_blocks = rc10->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_inquiry_cb(struct iscsi_context *iscsi, int status, void *command_data, + void *opaque) +{ + struct IscsiTask *itask = opaque; + struct scsi_task *task = command_data; + struct scsi_inquiry_standard *inq; + + if (status != 0) { + itask->status = 1; + itask->complete = 1; + scsi_free_scsi_task(task); + return; + } + + inq = scsi_datain_unmarshall(task); + if (inq == NULL) { + error_report("iSCSI: Failed to unmarshall inquiry data."); + itask->status = 1; + itask->complete = 1; + scsi_free_scsi_task(task); + return; + } + + itask->iscsilun->type = inq->periperal_device_type; + + scsi_free_scsi_task(task); + + switch (itask->iscsilun->type) { + case TYPE_DISK: + task = iscsi_readcapacity16_task(iscsi, itask->iscsilun->lun, + iscsi_readcapacity16_cb, opaque); + if (task == NULL) { + error_report("iSCSI: failed to send readcapacity16 command."); + itask->status = 1; + itask->complete = 1; + return; + } + break; + case TYPE_ROM: + task = iscsi_readcapacity10_task(iscsi, itask->iscsilun->lun, + 0, 0, + iscsi_readcapacity10_cb, opaque); + if (task == NULL) { + error_report("iSCSI: failed to send readcapacity16 command."); + itask->status = 1; + itask->complete = 1; + return; + } + break; + default: + itask->status = 0; + itask->complete = 1; + } +} static void iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data, @@ -445,10 +668,11 @@ 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_inquiry_task(iscsi, itask->iscsilun->lun, + 0, 0, 36, + iscsi_inquiry_cb, opaque); if (task == NULL) { - error_report("iSCSI: failed to send readcapacity command."); + error_report("iSCSI: failed to send inquiry command."); itask->status = 1; itask->complete = 1; return; @@ -700,6 +924,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 353889d41b..4b3345b11b 100644 --- a/block/qcow2-cluster.c +++ b/block/qcow2-cluster.c @@ -762,7 +762,6 @@ static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset, uint64_t *host_offset, unsigned int *nb_clusters) { BDRVQcowState *s = bs->opaque; - int64_t cluster_offset; QCowL2Meta *old_alloc; trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset, @@ -808,17 +807,21 @@ static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset, /* Allocate new clusters */ trace_qcow2_cluster_alloc_phys(qemu_coroutine_self()); if (*host_offset == 0) { - cluster_offset = qcow2_alloc_clusters(bs, *nb_clusters * s->cluster_size); + int64_t cluster_offset = + qcow2_alloc_clusters(bs, *nb_clusters * s->cluster_size); + if (cluster_offset < 0) { + return cluster_offset; + } + *host_offset = cluster_offset; + return 0; } else { - cluster_offset = *host_offset; - *nb_clusters = qcow2_alloc_clusters_at(bs, cluster_offset, *nb_clusters); - } - - if (cluster_offset < 0) { - return cluster_offset; + int ret = qcow2_alloc_clusters_at(bs, *host_offset, *nb_clusters); + if (ret < 0) { + return ret; + } + *nb_clusters = ret; + return 0; } - *host_offset = cluster_offset; - return 0; } /* @@ -883,15 +886,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 8c60a6f061..c2e49cded3 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 */ @@ -916,7 +919,8 @@ int qcow2_update_header(BlockDriverState *bs) ret = sizeof(*header); break; default: - return -EINVAL; + ret = -EINVAL; + goto fail; } buf += ret; @@ -1011,11 +1015,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 +1191,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 366cde7ad8..30a31f907f 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 0ed6b193c9..f46ca8fb69 100644 --- a/block/sheepdog.c +++ b/block/sheepdog.c @@ -468,7 +468,7 @@ static int connect_to_sdog(const char *addr, const char *port) if (ret) { error_report("unable to get address info %s, %s", addr, strerror(errno)); - return -1; + return -errno; } for (res = res0; res; res = res->ai_next) { @@ -495,7 +495,7 @@ static int connect_to_sdog(const char *addr, const char *port) dprintf("connected to %s:%s\n", addr, port); goto success; } - fd = -1; + fd = -errno; error_report("failed connect to %s:%s", addr, port); success: freeaddrinfo(res0); @@ -510,12 +510,13 @@ static int send_req(int sockfd, SheepdogReq *hdr, void *data, ret = qemu_send_full(sockfd, hdr, sizeof(*hdr), 0); if (ret < sizeof(*hdr)) { error_report("failed to send a req, %s", strerror(errno)); - return ret; + return -errno; } ret = qemu_send_full(sockfd, data, *wlen, 0); if (ret < *wlen) { error_report("failed to send a req, %s", strerror(errno)); + ret = -errno; } return ret; @@ -553,6 +554,7 @@ static int do_req(int sockfd, SheepdogReq *hdr, void *data, ret = qemu_recv_full(sockfd, hdr, sizeof(*hdr), 0); if (ret < sizeof(*hdr)) { error_report("failed to get a rsp, %s", strerror(errno)); + ret = -errno; goto out; } @@ -564,6 +566,7 @@ static int do_req(int sockfd, SheepdogReq *hdr, void *data, ret = qemu_recv_full(sockfd, data, *rlen, 0); if (ret < *rlen) { error_report("failed to get the data, %s", strerror(errno)); + ret = -errno; goto out; } } @@ -587,6 +590,7 @@ static int do_co_req(int sockfd, SheepdogReq *hdr, void *data, ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr)); if (ret < sizeof(*hdr)) { error_report("failed to get a rsp, %s", strerror(errno)); + ret = -errno; goto out; } @@ -598,6 +602,7 @@ static int do_co_req(int sockfd, SheepdogReq *hdr, void *data, ret = qemu_co_recv(sockfd, data, *rlen); if (ret < *rlen) { error_report("failed to get the data, %s", strerror(errno)); + ret = -errno; goto out; } } @@ -787,7 +792,7 @@ static int get_sheep_fd(BDRVSheepdogState *s) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { error_report("%s", strerror(errno)); - return -1; + return fd; } socket_set_nonblock(fd); @@ -796,7 +801,7 @@ static int get_sheep_fd(BDRVSheepdogState *s) if (ret) { error_report("%s", strerror(errno)); closesocket(fd); - return -1; + return -errno; } qemu_aio_set_fd_handler(fd, co_read_response, NULL, aio_flush_request, s); @@ -883,7 +888,7 @@ static int find_vdi_name(BDRVSheepdogState *s, char *filename, uint32_t snapid, fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { - return -1; + return fd; } memset(buf, 0, sizeof(buf)); @@ -904,14 +909,17 @@ static int find_vdi_name(BDRVSheepdogState *s, char *filename, uint32_t snapid, ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen); if (ret) { - ret = -1; goto out; } if (rsp->result != SD_RES_SUCCESS) { error_report("cannot get vdi info, %s, %s %d %s", sd_strerror(rsp->result), filename, snapid, tag); - ret = -1; + if (rsp->result == SD_RES_NO_VDI) { + ret = -ENOENT; + } else { + ret = -EIO; + } goto out; } *vid = rsp->vdi_id; @@ -980,7 +988,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req, if (ret < 0) { qemu_co_mutex_unlock(&s->lock); error_report("failed to send a req, %s", strerror(errno)); - return -EIO; + return -errno; } if (wlen) { @@ -988,7 +996,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req, if (ret < 0) { qemu_co_mutex_unlock(&s->lock); error_report("failed to send a data, %s", strerror(errno)); - return -EIO; + return -errno; } } @@ -1038,7 +1046,7 @@ static int read_write_object(int fd, char *buf, uint64_t oid, int copies, ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen); if (ret) { error_report("failed to send a request to the sheep"); - return -1; + return ret; } switch (rsp->result) { @@ -1046,7 +1054,7 @@ static int read_write_object(int fd, char *buf, uint64_t oid, int copies, return 0; default: error_report("%s", sd_strerror(rsp->result)); - return -1; + return -EIO; } } @@ -1082,10 +1090,12 @@ static int sd_open(BlockDriverState *bs, const char *filename, int flags) memset(vdi, 0, sizeof(vdi)); memset(tag, 0, sizeof(tag)); if (parse_vdiname(s, filename, vdi, &snapid, tag) < 0) { + ret = -EINVAL; goto out; } s->fd = get_sheep_fd(s); if (s->fd < 0) { + ret = s->fd; goto out; } @@ -1099,11 +1109,12 @@ static int sd_open(BlockDriverState *bs, const char *filename, int flags) s->flush_fd = connect_to_sdog(s->addr, s->port); if (s->flush_fd < 0) { error_report("failed to connect"); + ret = s->flush_fd; goto out; } } - if (snapid) { + if (snapid || tag[0] != '\0') { dprintf("%" PRIx32 " snapshot inode was open.\n", vid); s->is_snapshot = 1; } @@ -1111,6 +1122,7 @@ static int sd_open(BlockDriverState *bs, const char *filename, int flags) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { error_report("failed to connect"); + ret = fd; goto out; } @@ -1139,7 +1151,7 @@ out: closesocket(s->fd); } g_free(buf); - return -1; + return ret; } static int do_sd_create(char *filename, int64_t vdi_size, @@ -1154,7 +1166,7 @@ static int do_sd_create(char *filename, int64_t vdi_size, fd = connect_to_sdog(addr, port); if (fd < 0) { - return -EIO; + return fd; } memset(buf, 0, sizeof(buf)); @@ -1177,7 +1189,7 @@ static int do_sd_create(char *filename, int64_t vdi_size, closesocket(fd); if (ret) { - return -EIO; + return ret; } if (rsp->result != SD_RES_SUCCESS) { @@ -1237,24 +1249,26 @@ out: static int sd_create(const char *filename, QEMUOptionParameter *options) { - int ret; + int ret = 0; uint32_t vid = 0, base_vid = 0; int64_t vdi_size = 0; char *backing_file = NULL; - BDRVSheepdogState s; + BDRVSheepdogState *s; char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN]; uint32_t snapid; int prealloc = 0; const char *vdiname; + s = g_malloc0(sizeof(BDRVSheepdogState)); + strstart(filename, "sheepdog:", &vdiname); - memset(&s, 0, sizeof(s)); memset(vdi, 0, sizeof(vdi)); memset(tag, 0, sizeof(tag)); - if (parse_vdiname(&s, vdiname, vdi, &snapid, tag) < 0) { + if (parse_vdiname(s, vdiname, vdi, &snapid, tag) < 0) { error_report("invalid filename"); - return -EINVAL; + ret = -EINVAL; + goto out; } while (options && options->name) { @@ -1270,7 +1284,8 @@ static int sd_create(const char *filename, QEMUOptionParameter *options) } else { error_report("Invalid preallocation mode: '%s'", options->value.s); - return -EINVAL; + ret = -EINVAL; + goto out; } } options++; @@ -1278,7 +1293,8 @@ static int sd_create(const char *filename, QEMUOptionParameter *options) if (vdi_size > SD_MAX_VDI_SIZE) { error_report("too big image size"); - return -EINVAL; + ret = -EINVAL; + goto out; } if (backing_file) { @@ -1290,31 +1306,37 @@ static int sd_create(const char *filename, QEMUOptionParameter *options) drv = bdrv_find_protocol(backing_file); if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) { error_report("backing_file must be a sheepdog image"); - return -EINVAL; + ret = -EINVAL; + goto out; } ret = bdrv_file_open(&bs, backing_file, 0); - if (ret < 0) - return -EIO; + if (ret < 0) { + goto out; + } s = bs->opaque; if (!is_snapshot(&s->inode)) { error_report("cannot clone from a non snapshot vdi"); bdrv_delete(bs); - return -EINVAL; + ret = -EINVAL; + goto out; } base_vid = s->inode.vdi_id; bdrv_delete(bs); } - ret = do_sd_create(vdi, vdi_size, base_vid, &vid, 0, s.addr, s.port); + ret = do_sd_create(vdi, vdi_size, base_vid, &vid, 0, s->addr, s->port); if (!prealloc || ret) { - return ret; + goto out; } - return sd_prealloc(filename); + ret = sd_prealloc(filename); +out: + g_free(s); + return ret; } static void sd_close(BlockDriverState *bs) @@ -1379,7 +1401,7 @@ static int sd_truncate(BlockDriverState *bs, int64_t offset) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { - return -EIO; + return fd; } /* we don't need to update entire object */ @@ -1391,10 +1413,9 @@ static int sd_truncate(BlockDriverState *bs, int64_t offset) if (ret < 0) { error_report("failed to update an inode."); - return -EIO; } - return 0; + return ret; } /* @@ -1464,6 +1485,7 @@ static int sd_create_branch(BDRVSheepdogState *s) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { error_report("failed to connect"); + ret = fd; goto out; } @@ -1606,8 +1628,9 @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num, if (bs->growable && sector_num + nb_sectors > bs->total_sectors) { /* TODO: shouldn't block here */ - if (sd_truncate(bs, (sector_num + nb_sectors) * SECTOR_SIZE) < 0) { - return -EIO; + ret = sd_truncate(bs, (sector_num + nb_sectors) * SECTOR_SIZE); + if (ret < 0) { + return ret; } bs->total_sectors = sector_num + nb_sectors; } @@ -1678,6 +1701,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; @@ -1716,7 +1747,7 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) /* refresh inode. */ fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { - ret = -EIO; + ret = fd; goto cleanup; } @@ -1724,7 +1755,6 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) s->inode.nr_copies, datalen, 0, 0, s->cache_enabled); if (ret < 0) { error_report("failed to write snapshot's inode."); - ret = -EIO; goto cleanup; } @@ -1733,7 +1763,6 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) if (ret < 0) { error_report("failed to create inode for snapshot. %s", strerror(errno)); - ret = -EIO; goto cleanup; } @@ -1744,7 +1773,6 @@ static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) if (ret < 0) { error_report("failed to read new inode info. %s", strerror(errno)); - ret = -EIO; goto cleanup; } @@ -1765,7 +1793,7 @@ static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id) char *buf = NULL; uint32_t vid; uint32_t snapid = 0; - int ret = -ENOENT, fd; + int ret = 0, fd; old_s = g_malloc(sizeof(BDRVSheepdogState)); @@ -1783,13 +1811,13 @@ static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id) ret = find_vdi_name(s, vdi, snapid, tag, &vid, 1); if (ret) { error_report("Failed to find_vdi_name"); - ret = -ENOENT; goto out; } fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { error_report("failed to connect"); + ret = fd; goto out; } @@ -1800,7 +1828,6 @@ static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id) closesocket(fd); if (ret) { - ret = -ENOENT; goto out; } @@ -1853,6 +1880,7 @@ static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { + ret = fd; goto out; } @@ -1880,6 +1908,7 @@ static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab) fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { error_report("failed to connect"); + ret = fd; goto out; } @@ -1917,6 +1946,10 @@ out: g_free(vdi_inuse); + if (ret < 0) { + return ret; + } + return found; } @@ -1924,7 +1957,7 @@ static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data, int64_t pos, int size, int load) { int fd, create; - int ret = 0; + int ret = 0, remaining = size; unsigned int data_len; uint64_t vmstate_oid; uint32_t vdi_index; @@ -1932,15 +1965,14 @@ static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data, fd = connect_to_sdog(s->addr, s->port); if (fd < 0) { - ret = -EIO; - goto cleanup; + return fd; } - while (size) { + while (remaining) { vdi_index = pos / SD_DATA_OBJ_SIZE; offset = pos % SD_DATA_OBJ_SIZE; - data_len = MIN(size, SD_DATA_OBJ_SIZE); + data_len = MIN(remaining, SD_DATA_OBJ_SIZE); vmstate_oid = vid_to_vmstate_oid(s->inode.vdi_id, vdi_index); @@ -1957,14 +1989,13 @@ static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data, if (ret < 0) { error_report("failed to save vmstate %s", strerror(errno)); - ret = -EIO; goto cleanup; } pos += data_len; - size -= data_len; - ret += data_len; + remaining -= data_len; } + ret = size; cleanup: closesocket(fd); return ret; diff --git a/block/stream.c b/block/stream.c index 6724af2764..8e5832273b 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 9ef21ddfc5..0fd3367d82 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; @@ -2802,7 +2808,12 @@ static int enable_write_target(BDRVVVFATState *s) array_init(&(s->commits), sizeof(commit_t)); s->qcow_filename = g_malloc(1024); - get_tmp_filename(s->qcow_filename, 1024); + ret = get_tmp_filename(s->qcow_filename, 1024); + if (ret < 0) { + g_free(s->qcow_filename); + s->qcow_filename = NULL; + return ret; + } bdrv_qcow = bdrv_find_format("qcow"); options = parse_option_parameters("", bdrv_qcow->create_options, NULL); @@ -2855,6 +2866,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 086832aab9..3d4abc6575 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); @@ -331,7 +335,7 @@ struct BlockDriverState { BlockJob *job; }; -void get_tmp_filename(char *filename, int size); +int get_tmp_filename(char *filename, int size); void bdrv_set_io_limits(BlockDriverState *bs, BlockIOLimit *io_limits); @@ -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 d25ffea926..67895b25d5 100644 --- a/blockdev.c +++ b/blockdev.c @@ -756,14 +756,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); } } @@ -1006,7 +1006,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" @@ -2546,10 +2546,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" @@ -2592,6 +2595,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" @@ -2827,6 +2831,21 @@ if compile_prog "" "" ; then linux_magic_h=yes fi +######################################## +# check if environ is declared + +has_environ=no +cat > $TMPC << EOF +#include <unistd.h> +int main(void) { + environ = environ; + return 0; +} +EOF +if compile_prog "" "" ; then + has_environ=yes +fi + ########################################## # End of CC checks # After here, no more $cc or $ld runs @@ -2891,14 +2910,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" @@ -3337,6 +3357,10 @@ if test "$linux_magic_h" = "yes" ; then echo "CONFIG_LINUX_MAGIC_H=y" >> $config_host_mak fi +if test "$has_environ" = "yes" ; then + echo "CONFIG_HAS_ENVIRON=y" >> $config_host_mak +fi + # USB host support case "$usb" in linux) diff --git a/coroutine-sigaltstack.c b/coroutine-sigaltstack.c index 7ff2d3379e..861e87805a 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 diff --git a/docs/usb2.txt b/docs/usb2.txt index 228aa33ceb..d17e3c0044 100644 --- a/docs/usb2.txt +++ b/docs/usb2.txt @@ -55,6 +55,21 @@ try ... ... then use "bus=ehci.0" to assign your usb devices to that bus. +xhci controller support +----------------------- + +There also is xhci host controller support available. It got alot +less testing than ehci and there are a bunch of known limitations, so +ehci may work better for you. On the other hand the xhci hardware +design is much more virtualization-friendly, thus xhci emulation uses +less ressources (especially cpu). If you wanna give xhci a try +use this to add the host controller ... + + qemu -device nec-usb-xhci,id=xhci + +... then use "bus=xhci.0" when assigning usb devices. + + More USB tips & tricks ====================== diff --git a/exec-all.h b/exec-all.h index c1b7e1f263..9bda7f7354 100644 --- a/exec-all.h +++ b/exec-all.h @@ -96,6 +96,8 @@ void QEMU_NORETURN cpu_loop_exit(CPUArchState *env1); int page_unprotect(target_ulong address, uintptr_t pc, void *puc); void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end, int is_cpu_write_access); +void tb_invalidate_phys_range(tb_page_addr_t start, tb_page_addr_t end, + int is_cpu_write_access); #if !defined(CONFIG_USER_ONLY) /* cputlb.c */ void tlb_flush_page(CPUArchState *env, target_ulong addr); @@ -1075,6 +1075,23 @@ TranslationBlock *tb_gen_code(CPUArchState *env, return tb; } +/* + * invalidate all TBs which intersect with the target physical pages + * starting in range [start;end[. NOTE: start and end may refer to + * different physical pages. 'is_cpu_write_access' should be true if called + * from a real cpu write access: the virtual CPU will exit the current + * TB if code is modified inside this TB. + */ +void tb_invalidate_phys_range(tb_page_addr_t start, tb_page_addr_t end, + int is_cpu_write_access) +{ + while (start < end) { + tb_invalidate_phys_page_range(start, end, is_cpu_write_access); + start &= TARGET_PAGE_MASK; + start += TARGET_PAGE_SIZE; + } +} + /* invalidate all TBs which intersect with the target physical page starting in range [start;end[. NOTE: start and end must refer to the same physical page. 'is_cpu_write_access' should be true if called @@ -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/acpi_piix4.c b/hw/acpi_piix4.c index 585da4e3eb..0345490ee0 100644 --- a/hw/acpi_piix4.c +++ b/hw/acpi_piix4.c @@ -299,6 +299,7 @@ static void acpi_piix_eject_slot(PIIX4PMState *s, unsigned slots) if (pc->no_hotplug) { slot_free = false; } else { + object_unparent(OBJECT(dev)); qdev_free(qdev); } } diff --git a/hw/apb_pci.c b/hw/apb_pci.c index 7e28808ec4..c28411a460 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 */ diff --git a/hw/es1370.c b/hw/es1370.c index f19cef31a6..573f747362 100644 --- a/hw/es1370.c +++ b/hw/es1370.c @@ -410,7 +410,7 @@ static void es1370_update_voices (ES1370State *s, uint32_t ctl, uint32_t sctl) if ((old_fmt != new_fmt) || (old_freq != new_freq)) { d->shift = (new_fmt & 1) + (new_fmt >> 1); - ldebug ("channel %d, freq = %d, nchannels %d, fmt %d, shift %d\n", + ldebug ("channel %zu, freq = %d, nchannels %d, fmt %d, shift %d\n", i, new_freq, 1 << (new_fmt & 1), @@ -578,7 +578,7 @@ IO_WRITE_PROTO (es1370_writel) d++; case ES1370_REG_DAC1_SCOUNT: d->scount = (val & 0xffff) | (d->scount & ~0xffff); - ldebug ("chan %d CURR_SAMP_CT %d, SAMP_CT %d\n", + ldebug ("chan %td CURR_SAMP_CT %d, SAMP_CT %d\n", d - &s->chan[0], val >> 16, (val & 0xffff)); break; @@ -588,7 +588,7 @@ IO_WRITE_PROTO (es1370_writel) d++; case ES1370_REG_DAC1_FRAMEADR: d->frame_addr = val; - ldebug ("chan %d frame address %#x\n", d - &s->chan[0], val); + ldebug ("chan %td frame address %#x\n", d - &s->chan[0], val); break; case ES1370_REG_PHANTOM_FRAMECNT: @@ -605,7 +605,7 @@ IO_WRITE_PROTO (es1370_writel) case ES1370_REG_DAC1_FRAMECNT: d->frame_cnt = val; d->leftover = 0; - ldebug ("chan %d frame count %d, buffer size %d\n", + ldebug ("chan %td frame count %d, buffer size %d\n", d - &s->chan[0], val >> 16, val & 0xffff); break; @@ -745,9 +745,10 @@ IO_READ_PROTO (es1370_readl) { uint32_t size = ((d->frame_cnt & 0xffff) + 1) << 2; uint32_t curr = ((d->frame_cnt >> 16) + 1) << 2; - if (curr > size) + if (curr > size) { dolog ("read framecnt curr %d, size %d %d\n", curr, size, curr > size); + } } #endif break; @@ -179,12 +179,14 @@ static void fd_revalidate(FDrive *drv) FDriveRate rate; FLOPPY_DPRINTF("revalidate\n"); - if (drv->bs != NULL && bdrv_is_inserted(drv->bs)) { + if (drv->bs != NULL) { ro = bdrv_is_read_only(drv->bs); bdrv_get_floppy_geometry_hint(drv->bs, &nb_heads, &max_track, &last_sect, drv->drive, &drive, &rate); - if (nb_heads != 0 && max_track != 0 && last_sect != 0) { - FLOPPY_DPRINTF("User defined disk (%d %d %d)", + if (!bdrv_is_inserted(drv->bs)) { + FLOPPY_DPRINTF("No disk in drive\n"); + } else if (nb_heads != 0 && max_track != 0 && last_sect != 0) { + FLOPPY_DPRINTF("User defined disk (%d %d %d)\n", nb_heads - 1, max_track, last_sect); } else { FLOPPY_DPRINTF("Floppy disk (%d h %d t %d s) %s\n", nb_heads, @@ -201,7 +203,7 @@ static void fd_revalidate(FDrive *drv) drv->drive = drive; drv->media_rate = rate; } else { - FLOPPY_DPRINTF("No disk in drive\n"); + FLOPPY_DPRINTF("No drive connected\n"); drv->last_sect = 0; drv->max_track = 0; drv->flags &= ~FDISK_DBL_SIDES; @@ -705,6 +707,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->bs != NULL && bdrv_is_inserted(cur_drv->bs)) { + 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 +947,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 +1851,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 = { @@ -1884,9 +1880,8 @@ static int fdctrl_connect_drives(FDCtrl *fdctrl) } fd_init(drive); - fd_revalidate(drive); + fdctrl_change_cb(drive, 0); if (drive->bs) { - drive->media_changed = 1; bdrv_set_dev_ops(drive->bs, &fdctrl_block_ops, drive); } } diff --git a/hw/ide/ahci.c b/hw/ide/ahci.c index a883a920be..2d7d03d772 100644 --- a/hw/ide/ahci.c +++ b/hw/ide/ahci.c @@ -462,7 +462,7 @@ static void ahci_check_cmd_bh(void *opaque) static void ahci_init_d2h(AHCIDevice *ad) { - uint8_t init_fis[0x20]; + uint8_t init_fis[20]; IDEState *ide_state = &ad->port.ifs[0]; memset(init_fis, 0, sizeof(init_fis)); @@ -619,7 +619,7 @@ static void ahci_write_fis_d2h(AHCIDevice *ad, uint8_t *cmd_fis) d2h_fis[11] = cmd_fis[11]; d2h_fis[12] = cmd_fis[12]; d2h_fis[13] = cmd_fis[13]; - for (i = 14; i < 0x20; i++) { + for (i = 14; i < 20; i++) { d2h_fis[i] = 0; } diff --git a/hw/loader.c b/hw/loader.c index 415cdce534..7d64113e7f 100644 --- a/hw/loader.c +++ b/hw/loader.c @@ -103,7 +103,7 @@ ssize_t read_targphys(const char *name, /* return the size or -1 if error */ int load_image_targphys(const char *filename, - target_phys_addr_t addr, int max_sz) + target_phys_addr_t addr, uint64_t max_sz) { int size; diff --git a/hw/loader.h b/hw/loader.h index fbcaba9f0c..6da291e31f 100644 --- a/hw/loader.h +++ b/hw/loader.h @@ -4,7 +4,8 @@ /* loader.c */ int get_image_size(const char *filename); int load_image(const char *filename, uint8_t *addr); /* deprecated */ -int load_image_targphys(const char *filename, target_phys_addr_t, int max_sz); +int load_image_targphys(const char *filename, target_phys_addr_t, + uint64_t max_sz); int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t), void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr, int big_endian, int elf_machine, diff --git a/hw/mips_fulong2e.c b/hw/mips_fulong2e.c index 37dc711e08..1a8df10429 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/multiboot.c b/hw/multiboot.c index b4484a3262..b1e04c5718 100644 --- a/hw/multiboot.c +++ b/hw/multiboot.c @@ -202,10 +202,16 @@ int load_multiboot(void *fw_cfg, uint32_t mh_bss_end_addr = ldl_p(header+i+24); mh_load_addr = ldl_p(header+i+16); uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr); - uint32_t mb_load_size = mh_load_end_addr - mh_load_addr; - + uint32_t mb_load_size = 0; mh_entry_addr = ldl_p(header+i+28); - mb_kernel_size = mh_bss_end_addr - mh_load_addr; + + if (mh_load_end_addr) { + mb_kernel_size = mh_bss_end_addr - mh_load_addr; + mb_load_size = mh_load_end_addr - mh_load_addr; + } else { + mb_kernel_size = kernel_file_size - mb_kernel_text_offset; + mb_load_size = mb_kernel_size; + } /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_VBE. uint32_t mh_mode_type = ldl_p(header+i+32); @@ -47,6 +47,7 @@ #include "ui/qemu-spice.h" #include "memory.h" #include "exec-memory.h" +#include "arch_init.h" /* output Bochs bios info messages */ //#define DEBUG_BIOS @@ -382,7 +383,7 @@ void pc_cmos_init(ram_addr_t ram_size, ram_addr_t above_4g_mem_size, if (floppy) { fdc_get_bs(fd, floppy); for (i = 0; i < 2; i++) { - if (fd[i] && bdrv_is_inserted(fd[i])) { + if (fd[i]) { bdrv_get_floppy_geometry_hint(fd[i], &nb_heads, &max_track, &last_sect, FDRIVE_DRV_NONE, &fd_type[i], &rate); @@ -1088,7 +1089,7 @@ void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, qemu_irq pit_alt_irq = NULL; qemu_irq rtc_irq = NULL; qemu_irq *a20_line; - ISADevice *i8042, *port92, *vmmouse, *pit; + ISADevice *i8042, *port92, *vmmouse, *pit = NULL; qemu_irq *cpu_exit_irq; register_ioport_write(0x80, 1, 1, ioport80_write, NULL); @@ -1117,16 +1118,18 @@ void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, qemu_register_boot_set(pc_boot_set, *rtc_state); - if (kvm_irqchip_in_kernel()) { - pit = kvm_pit_init(isa_bus, 0x40); - } else { - pit = pit_init(isa_bus, 0x40, pit_isa_irq, pit_alt_irq); - } - if (hpet) { - /* connect PIT to output control line of the HPET */ - qdev_connect_gpio_out(hpet, 0, qdev_get_gpio_in(&pit->qdev, 0)); + if (!xen_enabled()) { + if (kvm_irqchip_in_kernel()) { + pit = kvm_pit_init(isa_bus, 0x40); + } else { + pit = pit_init(isa_bus, 0x40, pit_isa_irq, pit_alt_irq); + } + if (hpet) { + /* connect PIT to output control line of the HPET */ + qdev_connect_gpio_out(hpet, 0, qdev_get_gpio_in(&pit->qdev, 0)); + } + pcspk_init(isa_bus, pit); } - pcspk_init(isa_bus, pit); for(i = 0; i < MAX_SERIAL_PORTS; i++) { if (serial_hds[i]) { diff --git a/hw/pc_piix.c b/hw/pc_piix.c index 044dfcb377..f49b0aaf89 100644 --- a/hw/pc_piix.c +++ b/hw/pc_piix.c @@ -518,6 +518,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 fafdf9b1c1..f0d7c21b5c 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; } @@ -1527,7 +1527,6 @@ static int pci_unplug_device(DeviceState *qdev) qerror_report(QERR_DEVICE_NO_HOTPLUG, object_get_typename(OBJECT(dev))); return -1; } - object_unparent(OBJECT(dev)); return dev->bus->hotplug(dev->bus->hotplug_qdev, dev, PCI_HOTPLUG_DISABLED); } diff --git a/hw/qdev-monitor.c b/hw/qdev-monitor.c index dc4e4e1b84..eed781d2f0 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 98dd06aeba..b7b5597c62 100644 --- a/hw/qdev-properties.c +++ b/hw/qdev-properties.c @@ -753,10 +753,12 @@ static void set_mac(Object *obj, Visitor *v, void *opaque, } mac->a[i] = strtol(str+pos, &p, 16); } + g_free(str); return; inval: error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); + g_free(str); } PropertyInfo qdev_prop_macaddr = { @@ -825,7 +827,7 @@ static void set_pci_devfn(Object *obj, Visitor *v, void *opaque, uint32_t *ptr = qdev_get_prop_ptr(dev, prop); unsigned int slot, fn, n; Error *local_err = NULL; - char *str = (char *)""; + char *str; if (dev->state != DEV_STATE_CREATED) { error_set(errp, QERR_PERMISSION_DENIED); @@ -834,6 +836,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); } @@ -847,10 +850,12 @@ static void set_pci_devfn(Object *obj, Visitor *v, void *opaque, goto invalid; } *ptr = slot << 3 | fn; + g_free(str); return; invalid: error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); + g_free(str); } static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len) @@ -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 367aad19f4..fe2878c836 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 f7f1bfda04..e2e3fe2d37 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/rtl8139.c b/hw/rtl8139.c index 4d0f5ba518..eb22d04fad 100644 --- a/hw/rtl8139.c +++ b/hw/rtl8139.c @@ -2500,7 +2500,7 @@ static uint32_t rtl8139_TxStatus_TxAddr_read(RTL8139State *s, uint32_t regs[], case 1: /* fall through */ case 2: /* fall through */ case 4: - ret = (regs[reg] >> offset * 8) & ((1 << (size * 8)) - 1); + ret = (regs[reg] >> offset * 8) & (((uint64_t)1 << (size * 8)) - 1); DPRINTF("TxStatus/TxAddr[%d] read addr=0x%x size=0x%x val=0x%08x\n", reg, addr, size, ret); break; diff --git a/hw/s390-virtio-bus.c b/hw/s390-virtio-bus.c index 63ccd5c35a..1d38a8f5c5 100644 --- a/hw/s390-virtio-bus.c +++ b/hw/s390-virtio-bus.c @@ -163,8 +163,7 @@ static int s390_virtio_blk_init(VirtIOS390Device *dev) { VirtIODevice *vdev; - vdev = virtio_blk_init((DeviceState *)dev, &dev->block, - &dev->block_serial); + vdev = virtio_blk_init((DeviceState *)dev, &dev->blk); if (!vdev) { return -1; } @@ -400,8 +399,11 @@ static TypeInfo s390_virtio_net = { }; static Property s390_virtio_blk_properties[] = { - DEFINE_BLOCK_PROPERTIES(VirtIOS390Device, block), - DEFINE_PROP_STRING("serial", VirtIOS390Device, block_serial), + DEFINE_BLOCK_PROPERTIES(VirtIOS390Device, blk.conf), + DEFINE_PROP_STRING("serial", VirtIOS390Device, blk.serial), +#ifdef __linux__ + DEFINE_PROP_BIT("scsi", VirtIOS390Device, blk.scsi, 0, true), +#endif DEFINE_PROP_END_OF_LIST(), }; diff --git a/hw/s390-virtio-bus.h b/hw/s390-virtio-bus.h index 49e6c462df..4b99d02298 100644 --- a/hw/s390-virtio-bus.h +++ b/hw/s390-virtio-bus.h @@ -17,6 +17,7 @@ * License along with this library; if not, see <http://www.gnu.org/licenses/>. */ +#include "virtio-blk.h" #include "virtio-net.h" #include "virtio-serial.h" #include "virtio-scsi.h" @@ -64,8 +65,7 @@ struct VirtIOS390Device { ram_addr_t feat_offs; uint8_t feat_len; VirtIODevice *vdev; - BlockConf block; - char *block_serial; + VirtIOBlkConf blk; NICConf nic; uint32_t host_features; virtio_serial_conf serial; diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c index dbdb99ce35..f10f3ec25c 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); @@ -1539,7 +1561,7 @@ static int get_scsi_requests(QEMUFile *f, void *pv, size_t size) return 0; } -const VMStateInfo vmstate_info_scsi_requests = { +static const VMStateInfo vmstate_info_scsi_requests = { .name = "scsi-requests", .get = get_scsi_requests, .put = put_scsi_requests, diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h index ca24192d53..219c84dfb1 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 a029ab6e84..045c764d9b 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/sun4u.c b/hw/sun4u.c index fe3313890d..517bdb818d 100644 --- a/hw/sun4u.c +++ b/hw/sun4u.c @@ -67,7 +67,6 @@ #define KERNEL_LOAD_ADDR 0x00404000 #define CMDLINE_ADDR 0x003ff000 -#define INITRD_LOAD_ADDR 0x00300000 #define PROM_SIZE_MAX (4 * 1024 * 1024) #define PROM_VADDR 0x000ffd00000ULL #define APB_SPECIAL_BASE 0x1fe00000000ULL @@ -181,14 +180,18 @@ static int sun4u_NVRAM_set_params(M48t59State *nvram, uint16_t NVRAM_size, return 0; } -static unsigned long sun4u_load_kernel(const char *kernel_filename, - const char *initrd_filename, - ram_addr_t RAM_size, long *initrd_size) + +static uint64_t sun4u_load_kernel(const char *kernel_filename, + const char *initrd_filename, + ram_addr_t RAM_size, uint64_t *initrd_size, + uint64_t *initrd_addr, uint64_t *kernel_addr, + uint64_t *kernel_entry) { int linux_boot; unsigned int i; long kernel_size; uint8_t *ptr; + uint64_t kernel_top; linux_boot = (kernel_filename != NULL); @@ -201,29 +204,34 @@ static unsigned long sun4u_load_kernel(const char *kernel_filename, #else bswap_needed = 0; #endif - kernel_size = load_elf(kernel_filename, NULL, NULL, NULL, - NULL, NULL, 1, ELF_MACHINE, 0); - if (kernel_size < 0) + kernel_size = load_elf(kernel_filename, NULL, NULL, kernel_entry, + kernel_addr, &kernel_top, 1, ELF_MACHINE, 0); + if (kernel_size < 0) { + *kernel_addr = KERNEL_LOAD_ADDR; + *kernel_entry = KERNEL_LOAD_ADDR; kernel_size = load_aout(kernel_filename, KERNEL_LOAD_ADDR, RAM_size - KERNEL_LOAD_ADDR, bswap_needed, TARGET_PAGE_SIZE); - if (kernel_size < 0) + } + if (kernel_size < 0) { kernel_size = load_image_targphys(kernel_filename, KERNEL_LOAD_ADDR, RAM_size - KERNEL_LOAD_ADDR); + } if (kernel_size < 0) { fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename); exit(1); } - - /* load initrd */ + /* load initrd above kernel */ *initrd_size = 0; if (initrd_filename) { + *initrd_addr = TARGET_PAGE_ALIGN(kernel_top); + *initrd_size = load_image_targphys(initrd_filename, - INITRD_LOAD_ADDR, - RAM_size - INITRD_LOAD_ADDR); - if (*initrd_size < 0) { + *initrd_addr, + RAM_size - *initrd_addr); + if ((int)*initrd_size < 0) { fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", initrd_filename); exit(1); @@ -231,9 +239,9 @@ static unsigned long sun4u_load_kernel(const char *kernel_filename, } if (*initrd_size > 0) { for (i = 0; i < 64 * TARGET_PAGE_SIZE; i += TARGET_PAGE_SIZE) { - ptr = rom_ptr(KERNEL_LOAD_ADDR + i); + ptr = rom_ptr(*kernel_addr + i); if (ldl_p(ptr + 8) == 0x48647253) { /* HdrS */ - stl_p(ptr + 24, INITRD_LOAD_ADDR + KERNEL_LOAD_ADDR - 0x4000); + stl_p(ptr + 24, *initrd_addr + *kernel_addr); stl_p(ptr + 28, *initrd_size); break; } @@ -788,7 +796,7 @@ static void sun4uv_init(MemoryRegion *address_space_mem, CPUSPARCState *env; M48t59State *nvram; unsigned int i; - long initrd_size, kernel_size; + uint64_t initrd_addr, initrd_size, kernel_addr, kernel_size, kernel_entry; PCIBus *pci_bus, *pci_bus2, *pci_bus3; ISABus *isa_bus; qemu_irq *ivec_irqs, *pbm_irqs; @@ -845,13 +853,15 @@ static void sun4uv_init(MemoryRegion *address_space_mem, nvram = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 59); initrd_size = 0; + initrd_addr = 0; kernel_size = sun4u_load_kernel(kernel_filename, initrd_filename, - ram_size, &initrd_size); + ram_size, &initrd_size, &initrd_addr, + &kernel_addr, &kernel_entry); sun4u_NVRAM_set_params(nvram, NVRAM_SIZE, "Sun4u", RAM_size, boot_devices, - KERNEL_LOAD_ADDR, kernel_size, + kernel_addr, kernel_size, kernel_cmdline, - INITRD_LOAD_ADDR, initrd_size, + initrd_addr, initrd_size, /* XXX: need an option to load a NVRAM image */ 0, graphic_width, graphic_height, graphic_depth, @@ -861,8 +871,8 @@ static void sun4uv_init(MemoryRegion *address_space_mem, fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1); fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size); fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, hwdef->machine_id); - fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, KERNEL_LOAD_ADDR); - fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); + fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_entry); + fw_cfg_add_i64(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); if (kernel_cmdline) { fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, strlen(kernel_cmdline) + 1); @@ -872,8 +882,8 @@ static void sun4uv_init(MemoryRegion *address_space_mem, } else { fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 0); } - fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, INITRD_LOAD_ADDR); - fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); + fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr); + fw_cfg_add_i64(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, boot_devices[0]); fw_cfg_add_i16(fw_cfg, FW_CFG_SPARC64_WIDTH, graphic_width); diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c index 4ff4d40a8c..e759c996ce 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 048f8ffa8b..a95b0eda55 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 */ @@ -2357,10 +2357,15 @@ void vga_init(VGACommonState *s, MemoryRegion *address_space, void vga_init_vbe(VGACommonState *s, MemoryRegion *system_memory) { #ifdef CONFIG_BOCHS_VBE + /* With pc-0.12 and below we map both the PCI BAR and the fixed VBE region, + * so use an alias to avoid double-mapping the same region. + */ + memory_region_init_alias(&s->vram_vbe, "vram.vbe", + &s->vram, 0, memory_region_size(&s->vram)); /* XXX: use optimized standard vga accesses */ memory_region_add_subregion(system_memory, VBE_DISPI_LFB_PHYSICAL_ADDRESS, - &s->vram); + &s->vram_vbe); s->vbe_mapped = 1; #endif } diff --git a/hw/vga_int.h b/hw/vga_int.h index 7685b2b167..d244d8ff99 100644 --- a/hw/vga_int.h +++ b/hw/vga_int.h @@ -105,6 +105,7 @@ typedef struct VGACommonState { MemoryRegion *legacy_address_space; uint8_t *vram_ptr; MemoryRegion vram; + MemoryRegion vram_vbe; uint32_t vram_size; uint32_t latch; MemoryRegion *chain4_alias; diff --git a/hw/virtio-balloon.c b/hw/virtio-balloon.c index ce9d2c9759..075ed87e37 100644 --- a/hw/virtio-balloon.c +++ b/hw/virtio-balloon.c @@ -211,11 +211,15 @@ static void virtio_balloon_save(QEMUFile *f, void *opaque) static int virtio_balloon_load(QEMUFile *f, void *opaque, int version_id) { VirtIOBalloon *s = opaque; + int ret; if (version_id != 1) return -EINVAL; - virtio_load(&s->vdev, f); + ret = virtio_load(&s->vdev, f); + if (ret) { + return ret; + } s->num_pages = qemu_get_be32(f); s->actual = qemu_get_be32(f); diff --git a/hw/virtio-blk.c b/hw/virtio-blk.c index 49990f8efe..fe0774617b 100644 --- a/hw/virtio-blk.c +++ b/hw/virtio-blk.c @@ -29,7 +29,7 @@ typedef struct VirtIOBlock void *rq; QEMUBH *bh; BlockConf *conf; - char *serial; + VirtIOBlkConf *blk; unsigned short sector_mask; DeviceState *qdev; } VirtIOBlock; @@ -145,19 +145,13 @@ static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s) return req; } -#ifdef __linux__ static void virtio_blk_handle_scsi(VirtIOBlockReq *req) { - struct sg_io_hdr hdr; +#ifdef __linux__ int ret; - int status; int i; - - if ((req->dev->vdev.guest_features & (1 << VIRTIO_BLK_F_SCSI)) == 0) { - virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); - g_free(req); - return; - } +#endif + int status = VIRTIO_BLK_S_OK; /* * We require at least one output segment each for the virtio_blk_outhdr @@ -173,20 +167,26 @@ static void virtio_blk_handle_scsi(VirtIOBlockReq *req) } /* - * No support for bidirection commands yet. + * The scsi inhdr is placed in the second-to-last input segment, just + * before the regular inhdr. */ - if (req->elem.out_num > 2 && req->elem.in_num > 3) { - virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); - g_free(req); - return; + req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base; + + if (!req->dev->blk->scsi) { + status = VIRTIO_BLK_S_UNSUPP; + goto fail; } /* - * The scsi inhdr is placed in the second-to-last input segment, just - * before the regular inhdr. + * No support for bidirection commands yet. */ - req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base; + if (req->elem.out_num > 2 && req->elem.in_num > 3) { + status = VIRTIO_BLK_S_UNSUPP; + goto fail; + } +#ifdef __linux__ + struct sg_io_hdr hdr; memset(&hdr, 0, sizeof(struct sg_io_hdr)); hdr.interface_id = 'S'; hdr.cmd_len = req->elem.out_sg[1].iov_len; @@ -230,12 +230,7 @@ static void virtio_blk_handle_scsi(VirtIOBlockReq *req) ret = bdrv_ioctl(req->dev->bs, SG_IO, &hdr); if (ret) { status = VIRTIO_BLK_S_UNSUPP; - hdr.status = ret; - hdr.resid = hdr.dxfer_len; - } else if (hdr.status) { - status = VIRTIO_BLK_S_IOERR; - } else { - status = VIRTIO_BLK_S_OK; + goto fail; } /* @@ -258,14 +253,16 @@ static void virtio_blk_handle_scsi(VirtIOBlockReq *req) virtio_blk_req_complete(req, status); g_free(req); -} #else -static void virtio_blk_handle_scsi(VirtIOBlockReq *req) -{ - virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); + abort(); +#endif + +fail: + /* Just put anything nonzero so that the ioctl fails in the guest. */ + stl_p(&req->scsi->errors, 255); + virtio_blk_req_complete(req, status); g_free(req); } -#endif /* __linux__ */ typedef struct MultiReqBuffer { BlockRequest blkreq[32]; @@ -394,7 +391,7 @@ static void virtio_blk_handle_request(VirtIOBlockReq *req, * terminated by '\0' only when shorter than buffer. */ strncpy(req->elem.in_sg[0].iov_base, - s->serial ? s->serial : "", + s->blk->serial ? s->blk->serial : "", MIN(req->elem.in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES)); virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); g_free(req); @@ -494,7 +491,22 @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) stw_raw(&blkcfg.min_io_size, s->conf->min_io_size / blk_size); stw_raw(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size); blkcfg.heads = heads; - blkcfg.sectors = secs & ~s->sector_mask; + /* + * We must ensure that the block device capacity is a multiple of + * the logical block size. If that is not the case, lets use + * sector_mask to adopt the geometry to have a correct picture. + * For those devices where the capacity is ok for the given geometry + * we dont touch the sector value of the geometry, since some devices + * (like s390 dasd) need a specific value. Here the capacity is already + * cyls*heads*secs*blk_size and the sector value is not block size + * divided by 512 - instead it is the amount of blk_size blocks + * per track (cylinder). + */ + if (bdrv_getlength(s->bs) / heads / secs % blk_size) { + blkcfg.sectors = secs & ~s->sector_mask; + } else { + blkcfg.sectors = secs; + } blkcfg.size_max = 0; blkcfg.physical_block_exp = get_physical_block_exp(s->conf); blkcfg.alignment_offset = 0; @@ -509,6 +521,7 @@ static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) features |= (1 << VIRTIO_BLK_F_GEOMETRY); features |= (1 << VIRTIO_BLK_F_TOPOLOGY); features |= (1 << VIRTIO_BLK_F_BLK_SIZE); + features |= (1 << VIRTIO_BLK_F_SCSI); if (bdrv_enable_write_cache(s->bs)) features |= (1 << VIRTIO_BLK_F_WCACHE); @@ -537,11 +550,16 @@ static void virtio_blk_save(QEMUFile *f, void *opaque) static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id) { VirtIOBlock *s = opaque; + int ret; if (version_id != 2) return -EINVAL; - virtio_load(&s->vdev, f); + ret = virtio_load(&s->vdev, f); + if (ret) { + return ret; + } + while (qemu_get_sbyte(f)) { VirtIOBlockReq *req = virtio_blk_alloc_request(s); qemu_get_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem)); @@ -568,28 +586,27 @@ static const BlockDevOps virtio_block_ops = { .resize_cb = virtio_blk_resize, }; -VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf, - char **serial) +VirtIODevice *virtio_blk_init(DeviceState *dev, VirtIOBlkConf *blk) { VirtIOBlock *s; int cylinders, heads, secs; static int virtio_blk_id; DriveInfo *dinfo; - if (!conf->bs) { + if (!blk->conf.bs) { error_report("drive property not set"); return NULL; } - if (!bdrv_is_inserted(conf->bs)) { + if (!bdrv_is_inserted(blk->conf.bs)) { error_report("Device needs media, but drive is empty"); return NULL; } - if (!*serial) { + if (!blk->serial) { /* try to fall back to value set with legacy -drive serial=... */ - dinfo = drive_get_by_blockdev(conf->bs); + dinfo = drive_get_by_blockdev(blk->conf.bs); if (*dinfo->serial) { - *serial = strdup(dinfo->serial); + blk->serial = strdup(dinfo->serial); } } @@ -600,9 +617,9 @@ VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf, s->vdev.get_config = virtio_blk_update_config; s->vdev.get_features = virtio_blk_get_features; s->vdev.reset = virtio_blk_reset; - s->bs = conf->bs; - s->conf = conf; - s->serial = *serial; + s->bs = blk->conf.bs; + s->conf = &blk->conf; + s->blk = blk; s->rq = NULL; s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1; bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs); @@ -614,10 +631,10 @@ VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf, register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, virtio_blk_save, virtio_blk_load, s); bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); - bdrv_set_buffer_alignment(s->bs, conf->logical_block_size); + bdrv_set_buffer_alignment(s->bs, s->conf->logical_block_size); bdrv_iostatus_enable(s->bs); - add_boot_device_path(conf->bootindex, dev, "/disk@0,0"); + add_boot_device_path(s->conf->bootindex, dev, "/disk@0,0"); return &s->vdev; } @@ -626,5 +643,6 @@ void virtio_blk_exit(VirtIODevice *vdev) { VirtIOBlock *s = to_virtio_blk(vdev); unregister_savevm(s->qdev, "virtio-blk", s); + blockdev_mark_auto_del(s->bs); virtio_cleanup(vdev); } diff --git a/hw/virtio-blk.h b/hw/virtio-blk.h index 244dce45aa..d7850012bd 100644 --- a/hw/virtio-blk.h +++ b/hw/virtio-blk.h @@ -97,12 +97,14 @@ struct virtio_scsi_inhdr uint32_t residual; }; -#ifdef __linux__ -#define DEFINE_VIRTIO_BLK_FEATURES(_state, _field) \ - DEFINE_VIRTIO_COMMON_FEATURES(_state, _field), \ - DEFINE_PROP_BIT("scsi", _state, _field, VIRTIO_BLK_F_SCSI, true) -#else +struct VirtIOBlkConf +{ + BlockConf conf; + char *serial; + uint32_t scsi; +}; + #define DEFINE_VIRTIO_BLK_FEATURES(_state, _field) \ DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) -#endif + #endif diff --git a/hw/virtio-net.c b/hw/virtio-net.c index bc5e3a83d1..3f190d417e 100644 --- a/hw/virtio-net.c +++ b/hw/virtio-net.c @@ -891,11 +891,15 @@ static int virtio_net_load(QEMUFile *f, void *opaque, int version_id) { VirtIONet *n = opaque; int i; + int ret; if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION) return -EINVAL; - virtio_load(&n->vdev, f); + ret = virtio_load(&n->vdev, f); + if (ret) { + return ret; + } qemu_get_buffer(f, n->mac, ETH_ALEN); n->tx_waiting = qemu_get_be32(f); diff --git a/hw/virtio-pci.c b/hw/virtio-pci.c index 01f5b92b1c..d08c1590d2 100644 --- a/hw/virtio-pci.c +++ b/hw/virtio-pci.c @@ -492,7 +492,7 @@ static void virtio_pci_config_writel(void *opaque, uint32_t addr, uint32_t val) virtio_config_writel(proxy->vdev, addr, val); } -const MemoryRegionPortio virtio_portio[] = { +static const MemoryRegionPortio virtio_portio[] = { { 0, 0x10000, 1, .write = virtio_pci_config_writeb, }, { 0, 0x10000, 2, .write = virtio_pci_config_writew, }, { 0, 0x10000, 4, .write = virtio_pci_config_writel, }, @@ -823,8 +823,7 @@ static int virtio_blk_init_pci(PCIDevice *pci_dev) proxy->class_code != PCI_CLASS_STORAGE_OTHER) proxy->class_code = PCI_CLASS_STORAGE_SCSI; - vdev = virtio_blk_init(&pci_dev->qdev, &proxy->block, - &proxy->block_serial); + vdev = virtio_blk_init(&pci_dev->qdev, &proxy->blk); if (!vdev) { return -1; } @@ -852,7 +851,6 @@ static int virtio_blk_exit_pci(PCIDevice *pci_dev) virtio_pci_stop_ioeventfd(proxy); virtio_blk_exit(proxy->vdev); - blockdev_mark_auto_del(proxy->block.bs); return virtio_exit_pci(pci_dev); } @@ -940,8 +938,11 @@ static int virtio_balloon_exit_pci(PCIDevice *pci_dev) static Property virtio_blk_properties[] = { DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0), - DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, block), - DEFINE_PROP_STRING("serial", VirtIOPCIProxy, block_serial), + DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, blk.conf), + DEFINE_PROP_STRING("serial", VirtIOPCIProxy, blk.serial), +#ifdef __linux__ + DEFINE_PROP_BIT("scsi", VirtIOPCIProxy, blk.scsi, 0, true), +#endif DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true), DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2), DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features), diff --git a/hw/virtio-pci.h b/hw/virtio-pci.h index 8d28d4b789..91b791ba9d 100644 --- a/hw/virtio-pci.h +++ b/hw/virtio-pci.h @@ -15,6 +15,7 @@ #ifndef QEMU_VIRTIO_PCI_H #define QEMU_VIRTIO_PCI_H +#include "virtio-blk.h" #include "virtio-net.h" #include "virtio-serial.h" #include "virtio-scsi.h" @@ -37,8 +38,7 @@ typedef struct { uint32_t flags; uint32_t class_code; uint32_t nvectors; - BlockConf block; - char *block_serial; + VirtIOBlkConf blk; NICConf nic; uint32_t host_features; #ifdef CONFIG_LINUX diff --git a/hw/virtio-scsi.c b/hw/virtio-scsi.c index e8328f4652..5e39ce93c4 100644 --- a/hw/virtio-scsi.c +++ b/hw/virtio-scsi.c @@ -564,7 +564,12 @@ static void virtio_scsi_save(QEMUFile *f, void *opaque) static int virtio_scsi_load(QEMUFile *f, void *opaque, int version_id) { VirtIOSCSI *s = opaque; - virtio_load(&s->vdev, f); + int ret; + + ret = virtio_load(&s->vdev, f); + if (ret) { + return ret; + } return 0; } diff --git a/hw/virtio-serial-bus.c b/hw/virtio-serial-bus.c index ffbdfc2de1..72287d10ce 100644 --- a/hw/virtio-serial-bus.c +++ b/hw/virtio-serial-bus.c @@ -637,13 +637,17 @@ static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id) VirtIOSerialPort *port; uint32_t max_nr_ports, nr_active_ports, ports_map; unsigned int i; + int ret; if (version_id > 3) { return -EINVAL; } /* The virtio device */ - virtio_load(&s->vdev, f); + ret = virtio_load(&s->vdev, f); + if (ret) { + return ret; + } if (version_id < 2) { return 0; diff --git a/hw/virtio.h b/hw/virtio.h index 0aef7d1bc0..85aabe53d8 100644 --- a/hw/virtio.h +++ b/hw/virtio.h @@ -191,8 +191,8 @@ void virtio_bind_device(VirtIODevice *vdev, const VirtIOBindings *binding, void *opaque); /* Base devices. */ -VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf, - char **serial); +typedef struct VirtIOBlkConf VirtIOBlkConf; +VirtIODevice *virtio_blk_init(DeviceState *dev, VirtIOBlkConf *blk); struct virtio_net_conf; VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf, struct virtio_net_conf *net); diff --git a/hw/xen_common.h b/hw/xen_common.h index 7043c14cae..fe7f227f92 100644 --- a/hw/xen_common.h +++ b/hw/xen_common.h @@ -148,6 +148,6 @@ static inline int xen_xc_hvm_inject_msi(XenXC xen_xc, domid_t dom, } #endif -void destroy_hvm_domain(void); +void destroy_hvm_domain(bool reboot); #endif /* QEMU_HW_XEN_COMMON_H */ diff --git a/hw/xen_disk.c b/hw/xen_disk.c index 22dbd10303..07594bc0c8 100644 --- a/hw/xen_disk.c +++ b/hw/xen_disk.c @@ -48,7 +48,6 @@ /* ------------------------------------------------------------- */ -static int syncwrite = 0; static int batch_maps = 0; static int max_requests = 32; @@ -67,6 +66,7 @@ struct ioreq { QEMUIOVector v; int presync; int postsync; + uint8_t mapped; /* grant mapping */ uint32_t domids[BLKIF_MAX_SEGMENTS_PER_REQUEST]; @@ -154,7 +154,7 @@ static void ioreq_finish(struct ioreq *ioreq) blkdev->requests_finished++; } -static void ioreq_release(struct ioreq *ioreq) +static void ioreq_release(struct ioreq *ioreq, bool finish) { struct XenBlkDev *blkdev = ioreq->blkdev; @@ -162,7 +162,11 @@ static void ioreq_release(struct ioreq *ioreq) memset(ioreq, 0, sizeof(*ioreq)); ioreq->blkdev = blkdev; QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); - blkdev->requests_finished--; + if (finish) { + blkdev->requests_finished--; + } else { + blkdev->requests_inflight--; + } } /* @@ -189,15 +193,10 @@ static int ioreq_parse(struct ioreq *ioreq) ioreq->presync = 1; return 0; } - if (!syncwrite) { - ioreq->presync = ioreq->postsync = 1; - } + ioreq->presync = ioreq->postsync = 1; /* fall through */ case BLKIF_OP_WRITE: ioreq->prot = PROT_READ; /* from memory */ - if (syncwrite) { - ioreq->postsync = 1; - } break; default: xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", @@ -248,7 +247,7 @@ static void ioreq_unmap(struct ioreq *ioreq) XenGnttab gnt = ioreq->blkdev->xendev.gnttabdev; int i; - if (ioreq->v.niov == 0) { + if (ioreq->v.niov == 0 || ioreq->mapped == 0) { return; } if (batch_maps) { @@ -274,6 +273,7 @@ static void ioreq_unmap(struct ioreq *ioreq) ioreq->page[i] = NULL; } } + ioreq->mapped = 0; } static int ioreq_map(struct ioreq *ioreq) @@ -281,7 +281,7 @@ static int ioreq_map(struct ioreq *ioreq) XenGnttab gnt = ioreq->blkdev->xendev.gnttabdev; int i; - if (ioreq->v.niov == 0) { + if (ioreq->v.niov == 0 || ioreq->mapped == 1) { return 0; } if (batch_maps) { @@ -313,9 +313,12 @@ static int ioreq_map(struct ioreq *ioreq) ioreq->blkdev->cnt_map++; } } + ioreq->mapped = 1; return 0; } +static int ioreq_runio_qemu_aio(struct ioreq *ioreq); + static void qemu_aio_complete(void *opaque, int ret) { struct ioreq *ioreq = opaque; @@ -327,11 +330,19 @@ static void qemu_aio_complete(void *opaque, int ret) } ioreq->aio_inflight--; + if (ioreq->presync) { + ioreq->presync = 0; + ioreq_runio_qemu_aio(ioreq); + return; + } if (ioreq->aio_inflight > 0) { return; } if (ioreq->postsync) { - bdrv_flush(ioreq->blkdev->bs); + ioreq->postsync = 0; + ioreq->aio_inflight++; + bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); + return; } ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; @@ -351,7 +362,8 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) ioreq->aio_inflight++; if (ioreq->presync) { - bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ + bdrv_aio_flush(ioreq->blkdev->bs, qemu_aio_complete, ioreq); + return 0; } switch (ioreq->req.operation) { @@ -449,7 +461,7 @@ static void blk_send_response_all(struct XenBlkDev *blkdev) while (!QLIST_EMPTY(&blkdev->finished)) { ioreq = QLIST_FIRST(&blkdev->finished); send_notify += blk_send_response_one(ioreq); - ioreq_release(ioreq); + ioreq_release(ioreq, true); } if (send_notify) { xen_be_send_notify(&blkdev->xendev); @@ -505,7 +517,7 @@ static void blk_handle_requests(struct XenBlkDev *blkdev) if (blk_send_response_one(ioreq)) { xen_be_send_notify(&blkdev->xendev); } - ioreq_release(ioreq); + ioreq_release(ioreq, false); continue; } diff --git a/hw/xen_platform.c b/hw/xen_platform.c index a9c52a6e36..0214f370b2 100644 --- a/hw/xen_platform.c +++ b/hw/xen_platform.c @@ -87,7 +87,10 @@ static void unplug_nic(PCIBus *b, PCIDevice *d) { if (pci_get_word(d->config + PCI_CLASS_DEVICE) == PCI_CLASS_NETWORK_ETHERNET) { - qdev_unplug(&(d->qdev), NULL); + /* Until qdev_free includes a call to object_unparent, we call it here + */ + object_unparent(&d->qdev.parent_obj); + qdev_free(&d->qdev); } } diff --git a/include/qemu/cpu.h b/include/qemu/cpu.h index 4291279bc5..78b65b35fc 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 ca1649c918..d93b77293f 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)) { diff --git a/linux-user/mmap.c b/linux-user/mmap.c index 7125d1cd4b..d9468fea90 100644 --- a/linux-user/mmap.c +++ b/linux-user/mmap.c @@ -573,6 +573,7 @@ abi_long target_mmap(abi_ulong start, abi_ulong len, int prot, page_dump(stdout); printf("\n"); #endif + tb_invalidate_phys_range(start, start + len, 0); mmap_unlock(); return start; fail: @@ -675,8 +676,10 @@ int target_munmap(abi_ulong start, abi_ulong len) } } - if (ret == 0) + if (ret == 0) { page_set_flags(start, start + len, 0); + tb_invalidate_phys_range(start, start + len, 0); + } mmap_unlock(); return ret; } @@ -754,6 +757,7 @@ abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size, page_set_flags(old_addr, old_addr + old_size, 0); page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID); } + tb_invalidate_phys_range(new_addr, new_addr + new_size, 0); mmap_unlock(); return new_addr; } diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 712861829a..20d2a74877 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 c06b8bc441..dce1cd9d7c 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 35a5781823..440804db75 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 94f7839e8b..3f485d33a5 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 691b367389..2e9ca2edf2 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 @@ -3120,11 +3120,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"); } @@ -3618,6 +3622,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/pc-bios/README b/pc-bios/README index 6b64d68681..e56e9e5f04 100644 --- a/pc-bios/README +++ b/pc-bios/README @@ -12,7 +12,7 @@ 1275-1994 (referred to as Open Firmware) compliant firmware. The included images for PowerPC (for 32 and 64 bit PPC CPUs), Sparc32 and Sparc64 are built from OpenBIOS SVN revision - 1056. + 1060. - SLOF (Slimline Open Firmware) is a free IEEE 1275 Open Firmware implementation for certain IBM POWER hardware. The sources are at diff --git a/pc-bios/openbios-ppc b/pc-bios/openbios-ppc Binary files differindex d4656db8b3..aeae265880 100644 --- a/pc-bios/openbios-ppc +++ b/pc-bios/openbios-ppc diff --git a/pc-bios/openbios-sparc32 b/pc-bios/openbios-sparc32 Binary files differindex 4312c690ab..d90c4e59a0 100644 --- a/pc-bios/openbios-sparc32 +++ b/pc-bios/openbios-sparc32 diff --git a/pc-bios/openbios-sparc64 b/pc-bios/openbios-sparc64 Binary files differindex b186105089..457d264228 100644 --- a/pc-bios/openbios-sparc64 +++ b/pc-bios/openbios-sparc64 diff --git a/qapi-schema-guest.json b/qapi-schema-guest.json index d7a073ee70..d4055d262a 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* @@ -126,16 +126,19 @@ # @guest-shutdown: # # Initiate guest-activated shutdown. Note: this is an asynchronous -# shutdown request, with no guaruntee of successful shutdown. Errors -# will be logged to guest's syslog. +# shutdown request, with no guarantee of successful shutdown. # # @mode: #optional "halt", "powerdown" (default), or "reboot" # -# Returns: Nothing on success +# This command does NOT return a response on success. Success condition +# is indicated by the VM exiting with a zero exit status or, when +# running with --no-shutdown, by issuing the query-status QMP command +# to confirm the VM status is "shutdown". # # Since: 0.15.0 ## -{ 'command': 'guest-shutdown', 'data': { '*mode': 'str' } } +{ 'command': 'guest-shutdown', 'data': { '*mode': 'str' }, + 'success-response': 'no' } ## # @guest-file-open: @@ -359,17 +362,21 @@ # For the best results it's strongly recommended to have the pm-utils # package installed in the guest. # -# Returns: nothing on success +# This command does NOT return a response on success. There is a high chance +# the command succeeded if the VM exits with a zero exit status or, when +# running with --no-shutdown, by issuing the query-status QMP command to +# to confirm the VM status is "shutdown". However, the VM could also exit +# (or set its status to "shutdown") due to other reasons. +# +# The following errors may be returned: # If suspend to disk is not supported, Unsupported # -# Notes: o This is an asynchronous request. There's no guarantee a response -# will be sent -# o It's strongly recommended to issue the guest-sync command before -# sending commands when the guest resumes +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes # # Since: 1.1 ## -{ 'command': 'guest-suspend-disk' } +{ 'command': 'guest-suspend-disk', 'success-response': 'no' } ## # @guest-suspend-ram @@ -387,17 +394,21 @@ # command. Thus, it's *required* to query QEMU for the presence of the # 'system_wakeup' command before issuing guest-suspend-ram. # -# Returns: nothing on success +# This command does NOT return a response on success. There are two options +# to check for success: +# 1. Wait for the SUSPEND QMP event from QEMU +# 2. Issue the query-status QMP command to confirm the VM status is +# "suspended" +# +# The following errors may be returned: # If suspend to ram is not supported, Unsupported # -# Notes: o This is an asynchronous request. There's no guarantee a response -# will be sent -# o It's strongly recommended to issue the guest-sync command before -# sending commands when the guest resumes +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes # # Since: 1.1 ## -{ 'command': 'guest-suspend-ram' } +{ 'command': 'guest-suspend-ram', 'success-response': 'no' } ## # @guest-suspend-hybrid @@ -410,17 +421,21 @@ # command. Thus, it's *required* to query QEMU for the presence of the # 'system_wakeup' command before issuing guest-suspend-hybrid. # -# Returns: nothing on success +# This command does NOT return a response on success. There are two options +# to check for success: +# 1. Wait for the SUSPEND QMP event from QEMU +# 2. Issue the query-status QMP command to confirm the VM status is +# "suspended" +# +# The following errors may be returned: # If hybrid suspend is not supported, Unsupported # -# Notes: o This is an asynchronous request. There's no guarantee a response -# will be sent -# o It's strongly recommended to issue the guest-sync command before -# sending commands when the guest resumes +# Notes: It's strongly recommended to issue the guest-sync command before +# sending commands when the guest resumes # # Since: 1.1 ## -{ 'command': 'guest-suspend-hybrid' } +{ 'command': 'guest-suspend-hybrid', 'success-response': 'no' } ## # @GuestIpAddressType: diff --git a/qapi-schema.json b/qapi-schema.json index 9193fb9968..2ca7195d25 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-core.h b/qapi/qmp-core.h index 431ddbb337..b0f64ba1ee 100644 --- a/qapi/qmp-core.h +++ b/qapi/qmp-core.h @@ -25,16 +25,24 @@ typedef enum QmpCommandType QCT_NORMAL, } QmpCommandType; +typedef enum QmpCommandOptions +{ + QCO_NO_OPTIONS = 0x0, + QCO_NO_SUCCESS_RESP = 0x1, +} QmpCommandOptions; + typedef struct QmpCommand { const char *name; QmpCommandType type; QmpCommandFunc *fn; + QmpCommandOptions options; QTAILQ_ENTRY(QmpCommand) node; bool enabled; } QmpCommand; -void qmp_register_command(const char *name, QmpCommandFunc *fn); +void qmp_register_command(const char *name, QmpCommandFunc *fn, + QmpCommandOptions options); QmpCommand *qmp_find_command(const char *name); QObject *qmp_dispatch(QObject *request); void qmp_disable_command(const char *name); diff --git a/qapi/qmp-dispatch.c b/qapi/qmp-dispatch.c index 43f640a95e..122c1a29ba 100644 --- a/qapi/qmp-dispatch.c +++ b/qapi/qmp-dispatch.c @@ -94,8 +94,12 @@ static QObject *do_qmp_dispatch(QObject *request, Error **errp) switch (cmd->type) { case QCT_NORMAL: cmd->fn(args, &ret, errp); - if (!error_is_set(errp) && ret == NULL) { - ret = QOBJECT(qdict_new()); + if (!error_is_set(errp)) { + if (cmd->options & QCO_NO_SUCCESS_RESP) { + g_assert(!ret); + } else if (!ret) { + ret = QOBJECT(qdict_new()); + } } break; } diff --git a/qapi/qmp-input-visitor.c b/qapi/qmp-input-visitor.c index 4cdc47dab5..107d8d361b 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/qapi/qmp-registry.c b/qapi/qmp-registry.c index 43d5cdeb64..5414613377 100644 --- a/qapi/qmp-registry.c +++ b/qapi/qmp-registry.c @@ -17,7 +17,8 @@ static QTAILQ_HEAD(QmpCommandList, QmpCommand) qmp_commands = QTAILQ_HEAD_INITIALIZER(qmp_commands); -void qmp_register_command(const char *name, QmpCommandFunc *fn) +void qmp_register_command(const char *name, QmpCommandFunc *fn, + QmpCommandOptions options) { QmpCommand *cmd = g_malloc0(sizeof(*cmd)); @@ -25,6 +26,7 @@ void qmp_register_command(const char *name, QmpCommandFunc *fn) cmd->type = QCT_NORMAL; cmd->fn = fn; cmd->enabled = true; + cmd->options = options; QTAILQ_INSERT_TAIL(&qmp_commands, cmd, node); } diff --git a/qemu-char.c b/qemu-char.c index a9fc50481a..fe1126fe86 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 57fe28fd9a..91e056296d 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 20d707fa1f..6d7365d35b 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 e5d7ac41ab..0af0ff45c2 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 @@ -104,16 +104,9 @@ static void quit_handler(int sig) } #ifndef _WIN32 -/* reap _all_ terminated children */ -static void child_handler(int sig) -{ - int status; - while (waitpid(-1, &status, WNOHANG) > 0) /* NOTHING */; -} - static gboolean register_signal_handlers(void) { - struct sigaction sigact, sigact_chld; + struct sigaction sigact; int ret; memset(&sigact, 0, sizeof(struct sigaction)); @@ -130,15 +123,24 @@ static gboolean register_signal_handlers(void) return false; } - memset(&sigact_chld, 0, sizeof(struct sigaction)); - sigact_chld.sa_handler = child_handler; - sigact_chld.sa_flags = SA_NOCLDSTOP; - ret = sigaction(SIGCHLD, &sigact_chld, NULL); - if (ret == -1) { - g_error("error configuring signal handler: %s", strerror(errno)); + return true; +} + +/* TODO: use this in place of all post-fork() fclose(std*) callers */ +void reopen_fd_to_null(int fd) +{ + int nullfd; + + nullfd = open("/dev/null", O_RDWR); + if (nullfd < 0) { + return; } - return true; + dup2(nullfd, fd); + + if (nullfd != fd) { + close(nullfd); + } } #endif @@ -167,7 +169,7 @@ static void usage(const char *cmd) " -h, --help display this help and exit\n" "\n" "Report bugs to <mdroth@linux.vnet.ibm.com>\n" - , cmd, QGA_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT, + , cmd, QEMU_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT, QGA_STATEDIR_DEFAULT); } @@ -304,7 +306,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; @@ -428,9 +430,9 @@ static void become_daemon(const char *pidfile) goto fail; } - close(STDIN_FILENO); - close(STDOUT_FILENO); - close(STDERR_FILENO); + reopen_fd_to_null(STDIN_FILENO); + reopen_fd_to_null(STDOUT_FILENO); + reopen_fd_to_null(STDERR_FILENO); return; fail: @@ -488,8 +490,6 @@ static void process_command(GAState *s, QDict *req) g_warning("error sending response: %s", strerror(ret)); } qobject_decref(rsp); - } else { - g_warning("error getting response"); } } @@ -729,7 +729,7 @@ int main(int argc, char **argv) log_level = G_LOG_LEVEL_MASK; break; case 'V': - printf("QEMU Guest Agent %s\n", QGA_VERSION); + printf("QEMU Guest Agent %s\n", QEMU_VERSION); return 0; case 'd': daemonize = 1; @@ -836,12 +836,13 @@ int main(int argc, char **argv) become_daemon(pid_filepath); } if (log_filepath) { - s->log_file = fopen(log_filepath, "a"); - if (!s->log_file) { + FILE *log_file = fopen(log_filepath, "a"); + if (!log_file) { g_critical("unable to open specified log file: %s", strerror(errno)); goto out_bad; } + s->log_file = log_file; } } diff --git a/qemu-img.c b/qemu-img.c index 0ae543cade..c8a70ffc93 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); diff --git a/qemu-img.texi b/qemu-img.texi index b2ca3a542c..6fc3c28e0d 100644 --- a/qemu-img.texi +++ b/qemu-img.texi @@ -159,6 +159,24 @@ It can be used without an accessible old backing file, i.e. you can use it to fix an image whose backing file has already been moved/renamed. @end table +You can use @code{rebase} to perform a ``diff'' operation on two +disk images. This can be useful when you have copied or cloned +a guest, and you want to get back to a thin image on top of a +template or base image. + +Say that @code{base.img} has been cloned as @code{modified.img} by +copying it, and that the @code{modified.img} guest has run so there +are now some changes compared to @code{base.img}. To construct a thin +image called @code{diff.qcow2} that contains just the differences, do: + +@example +qemu-img create -f qcow2 -b modified.img diff.qcow2 +qemu-img rebase -b base.img diff.qcow2 +@end example + +At this point, @code{modified.img} can be discarded, since +@code{base.img + diff.qcow2} contains the same information. + @item resize @var{filename} [+ | -]@var{size} Change the disk image as if it had been created with @var{size}. @@ -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 a169792f07..8b662648ae 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 6bcb8e3e0f..46c7619c7e 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 8eadd16aa2..de9897788d 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 5175419e5f..f8af595f13 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 a5d0a84fb6..4689ff340d 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 d58730ad80..00d035da95 100644 --- a/qga/commands-posix.c +++ b/qga/commands-posix.c @@ -14,12 +14,22 @@ #include <glib.h> #include <sys/types.h> #include <sys/ioctl.h> +#include <sys/wait.h> #include "qga/guest-agent-core.h" #include "qga-qmp-commands.h" #include "qerror.h" #include "qemu-queue.h" #include "host-utils.h" +#ifndef CONFIG_HAS_ENVIRON +#ifdef __APPLE__ +#include <crt_externs.h> +#define environ (*_NSGetEnviron()) +#else +extern char **environ; +#endif +#endif + #if defined(__linux__) #include <mntent.h> #include <linux/fs.h> @@ -27,36 +37,17 @@ #include <arpa/inet.h> #include <sys/socket.h> #include <net/if.h> -#include <sys/wait.h> #if defined(__linux__) && defined(FIFREEZE) #define CONFIG_FSFREEZE #endif #endif -#if defined(__linux__) -/* TODO: use this in place of all post-fork() fclose(std*) callers */ -static void reopen_fd_to_null(int fd) -{ - int nullfd; - - nullfd = open("/dev/null", O_RDWR); - if (nullfd < 0) { - return; - } - - dup2(nullfd, fd); - - if (nullfd != fd) { - close(nullfd); - } -} -#endif /* defined(__linux__) */ - void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) { - int ret; const char *shutdown_flag; + pid_t rpid, pid; + int status; slog("guest-shutdown called, mode: %s", mode); if (!has_mode || strcmp(mode, "powerdown") == 0) { @@ -71,23 +62,30 @@ void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) return; } - ret = fork(); - if (ret == 0) { + pid = fork(); + if (pid == 0) { /* child, start the shutdown */ setsid(); - fclose(stdin); - fclose(stdout); - fclose(stderr); - - ret = execl("/sbin/shutdown", "shutdown", shutdown_flag, "+0", - "hypervisor initiated shutdown", (char*)NULL); - if (ret) { - slog("guest-shutdown failed: %s", strerror(errno)); - } - exit(!!ret); - } else if (ret < 0) { - error_set(err, QERR_UNDEFINED_ERROR); + reopen_fd_to_null(0); + reopen_fd_to_null(1); + reopen_fd_to_null(2); + + execle("/sbin/shutdown", "shutdown", shutdown_flag, "+0", + "hypervisor initiated shutdown", (char*)NULL, environ); + _exit(EXIT_FAILURE); + } else if (pid < 0) { + goto exit_err; + } + + do { + rpid = waitpid(pid, &status, 0); + } while (rpid == -1 && errno == EINTR); + if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) { + return; } + +exit_err: + error_set(err, QERR_UNDEFINED_ERROR); } typedef struct GuestFileHandle { @@ -347,7 +345,7 @@ static int guest_fsfreeze_build_mount_list(GuestFsfreezeMountList *mounts) { struct mntent *ment; GuestFsfreezeMount *mount; - char const *mtab = MOUNTED; + char const *mtab = "/proc/self/mounts"; FILE *fp; fp = setmntent(mtab, "r"); @@ -487,7 +485,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). @@ -531,117 +529,88 @@ static void guest_fsfreeze_cleanup(void) #define SUSPEND_SUPPORTED 0 #define SUSPEND_NOT_SUPPORTED 1 -/** - * This function forks twice and the information about the mode support - * status is passed to the qemu-ga process via a pipe. - * - * This approach allows us to keep the way we reap terminated children - * in qemu-ga quite simple. - */ static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg, const char *sysfile_str, Error **err) { - pid_t pid; - ssize_t ret; char *pmutils_path; - int status, pipefds[2]; - - if (pipe(pipefds) < 0) { - error_set(err, QERR_UNDEFINED_ERROR); - return; - } + pid_t pid, rpid; + int status; pmutils_path = g_find_program_in_path(pmutils_bin); pid = fork(); if (!pid) { - struct sigaction act; - - memset(&act, 0, sizeof(act)); - act.sa_handler = SIG_DFL; - sigaction(SIGCHLD, &act, NULL); + char buf[32]; /* hopefully big enough */ + ssize_t ret; + int fd; setsid(); - close(pipefds[0]); reopen_fd_to_null(0); reopen_fd_to_null(1); reopen_fd_to_null(2); - pid = fork(); - if (!pid) { - int fd; - char buf[32]; /* hopefully big enough */ - - if (pmutils_path) { - execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ); - } - - /* - * If we get here either pm-utils is not installed or execle() has - * failed. Let's try the manual method if the caller wants it. - */ - - if (!sysfile_str) { - _exit(SUSPEND_NOT_SUPPORTED); - } - - fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); - if (fd < 0) { - _exit(SUSPEND_NOT_SUPPORTED); - } + if (pmutils_path) { + execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ); + } - ret = read(fd, buf, sizeof(buf)-1); - if (ret <= 0) { - _exit(SUSPEND_NOT_SUPPORTED); - } - buf[ret] = '\0'; + /* + * If we get here either pm-utils is not installed or execle() has + * failed. Let's try the manual method if the caller wants it. + */ - if (strstr(buf, sysfile_str)) { - _exit(SUSPEND_SUPPORTED); - } + if (!sysfile_str) { + _exit(SUSPEND_NOT_SUPPORTED); + } + fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); + if (fd < 0) { _exit(SUSPEND_NOT_SUPPORTED); } - if (pid > 0) { - wait(&status); - } else { - status = SUSPEND_NOT_SUPPORTED; + ret = read(fd, buf, sizeof(buf)-1); + if (ret <= 0) { + _exit(SUSPEND_NOT_SUPPORTED); } + buf[ret] = '\0'; - ret = write(pipefds[1], &status, sizeof(status)); - if (ret != sizeof(status)) { - _exit(EXIT_FAILURE); + if (strstr(buf, sysfile_str)) { + _exit(SUSPEND_SUPPORTED); } - _exit(EXIT_SUCCESS); + _exit(SUSPEND_NOT_SUPPORTED); } - close(pipefds[1]); g_free(pmutils_path); if (pid < 0) { - error_set(err, QERR_UNDEFINED_ERROR); - goto out; - } - - ret = read(pipefds[0], &status, sizeof(status)); - if (ret == sizeof(status) && WIFEXITED(status) && - WEXITSTATUS(status) == SUSPEND_SUPPORTED) { - goto out; + goto undef_err; + } + + do { + rpid = waitpid(pid, &status, 0); + } while (rpid == -1 && errno == EINTR); + if (rpid == pid && WIFEXITED(status)) { + switch (WEXITSTATUS(status)) { + case SUSPEND_SUPPORTED: + return; + case SUSPEND_NOT_SUPPORTED: + error_set(err, QERR_UNSUPPORTED); + return; + default: + goto undef_err; + } } - error_set(err, QERR_UNSUPPORTED); - -out: - close(pipefds[0]); +undef_err: + error_set(err, QERR_UNDEFINED_ERROR); } static void guest_suspend(const char *pmutils_bin, const char *sysfile_str, Error **err) { - pid_t pid; char *pmutils_path; + pid_t rpid, pid; + int status; pmutils_path = g_find_program_in_path(pmutils_bin); @@ -683,9 +652,18 @@ static void guest_suspend(const char *pmutils_bin, const char *sysfile_str, g_free(pmutils_path); if (pid < 0) { - error_set(err, QERR_UNDEFINED_ERROR); + goto exit_err; + } + + do { + rpid = waitpid(pid, &status, 0); + } while (rpid == -1 && errno == EINTR); + if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) { return; } + +exit_err: + error_set(err, QERR_UNDEFINED_ERROR); } void qmp_guest_suspend_disk(Error **err) @@ -789,7 +767,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/qga/commands.c b/qga/commands.c index 5bcceaae34..46b0b083bc 100644 --- a/qga/commands.c +++ b/qga/commands.c @@ -52,7 +52,7 @@ struct GuestAgentInfo *qmp_guest_info(Error **err) GuestAgentCommandInfoList *cmd_info_list; char **cmd_list_head, **cmd_list; - info->version = g_strdup(QGA_VERSION); + info->version = g_strdup(QEMU_VERSION); cmd_list_head = cmd_list = qmp_get_command_list(); if (*cmd_list_head == NULL) { diff --git a/qga/guest-agent-core.h b/qga/guest-agent-core.h index bbb8b9b125..49a7abee95 100644 --- a/qga/guest-agent-core.h +++ b/qga/guest-agent-core.h @@ -13,7 +13,6 @@ #include "qapi/qmp-core.h" #include "qemu-common.h" -#define QGA_VERSION "1.0" #define QGA_READ_COUNT_DEFAULT 4096 typedef struct GAState GAState; @@ -35,3 +34,7 @@ void ga_set_response_delimited(GAState *s); bool ga_is_frozen(GAState *s); void ga_set_frozen(GAState *s); void ga_unset_frozen(GAState *s); + +#ifndef _WIN32 +void reopen_fd_to_null(int fd); +#endif diff --git a/qmp-commands.hx b/qmp-commands.hx index c810c74c11..db980fa811 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 c9940ab2e1..4ca8b5cba3 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 e721fc28fb..6f839ad8c9 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/roms/openbios b/roms/openbios -Subproject ff61d973e5a4a68b29e485b3f88e6a2d1d96cf4 +Subproject d1d2787f87167edf487a60e61b9168514d5a743 diff --git a/scripts/qapi-commands.py b/scripts/qapi-commands.py index 0b4f0a0fe1..9eed40e18a 100644 --- a/scripts/qapi-commands.py +++ b/scripts/qapi-commands.py @@ -291,14 +291,24 @@ out: return ret +def option_value_matches(opt, val, cmd): + if opt in cmd and cmd[opt] == val: + return True + return False + def gen_registry(commands): registry="" push_indent() for cmd in commands: + options = 'QCO_NO_OPTIONS' + if option_value_matches('success-response', 'no', cmd): + options = 'QCO_NO_SUCCESS_RESP' + registry += mcgen(''' -qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s); +qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s, %(opts)s); ''', - name=cmd['command'], c_name=c_fun(cmd['command'])) + name=cmd['command'], c_name=c_fun(cmd['command']), + opts=options) pop_indent() ret = mcgen(''' static void qmp_init_marshal(void) diff --git a/scripts/qemu-binfmt-conf.sh b/scripts/qemu-binfmt-conf.sh index 83a44d8e2a..0da2618883 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/slirp/ip.h b/slirp/ip.h index 88c903fccd..e2ee5e304c 100644 --- a/slirp/ip.h +++ b/slirp/ip.h @@ -34,18 +34,14 @@ #define _IP_H_ #ifdef HOST_WORDS_BIGENDIAN -# ifndef NTOHL -# define NTOHL(d) -# endif -# ifndef NTOHS -# define NTOHS(d) -# endif -# ifndef HTONL -# define HTONL(d) -# endif -# ifndef HTONS -# define HTONS(d) -# endif +# undef NTOHL +# undef NTOHS +# undef HTONL +# undef HTONS +# define NTOHL(d) +# define NTOHS(d) +# define HTONL(d) +# define HTONS(d) #else # ifndef NTOHL # define NTOHL(d) ((d) = ntohl((d))) diff --git a/slirp/tcp.h b/slirp/tcp.h index 82996031e0..2e2b4033a6 100644 --- a/slirp/tcp.h +++ b/slirp/tcp.h @@ -79,20 +79,23 @@ struct tcphdr { #define TCPOPT_EOL 0 #define TCPOPT_NOP 1 #define TCPOPT_MAXSEG 2 -#define TCPOLEN_MAXSEG 4 #define TCPOPT_WINDOW 3 -#define TCPOLEN_WINDOW 3 #define TCPOPT_SACK_PERMITTED 4 /* Experimental */ -#define TCPOLEN_SACK_PERMITTED 2 #define TCPOPT_SACK 5 /* Experimental */ #define TCPOPT_TIMESTAMP 8 -#define TCPOLEN_TIMESTAMP 10 -#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2) /* appendix A */ #define TCPOPT_TSTAMP_HDR \ (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP) #endif +#ifndef TCPOLEN_MAXSEG +#define TCPOLEN_MAXSEG 4 +#define TCPOLEN_WINDOW 3 +#define TCPOLEN_SACK_PERMITTED 2 +#define TCPOLEN_TIMESTAMP 10 +#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2) /* appendix A */ +#endif + /* * Default maximum segment size for TCP. * With an IP MSS of 576, this is 536, diff --git a/slirp/tcp_output.c b/slirp/tcp_output.c index 779314bf9a..8aa3d90470 100644 --- a/slirp/tcp_output.c +++ b/slirp/tcp_output.c @@ -47,6 +47,7 @@ static const u_char tcp_outflags[TCP_NSTATES] = { }; +#undef MAX_TCPOPTLEN #define MAX_TCPOPTLEN 32 /* max # bytes that go in options */ /* diff --git a/sysconfigs/target/cpus-x86_64.conf b/sysconfigs/target/cpus-x86_64.conf new file mode 100644 index 0000000000..cee0ea9e55 --- /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 cee0ea9e55..e69de29bb2 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 5eac070379..d01285fd57 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 1e02d61bdc..e0b9dbf67e 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 40635c4b1c..5901140480 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 65d9af6ac7..388bc5c527 100644 --- a/target-i386/cpu.c +++ b/target-i386/cpu.c @@ -238,6 +238,8 @@ typedef struct x86_def_t { /* Store the results of Centaur's CPUID instructions */ uint32_t ext4_features; uint32_t xlevel2; + /* The feature bits on CPUID[EAX=7,ECX=0].EBX */ + uint32_t cpuid_7_0_ebx_features; } x86_def_t; #define I486_FEATURES (CPUID_FP87 | CPUID_VME | CPUID_PSE) @@ -521,6 +523,12 @@ static int cpu_x86_fill_host(x86_def_t *x86_cpu_def) x86_cpu_def->ext_features = ecx; x86_cpu_def->features = edx; + if (kvm_enabled() && x86_cpu_def->level >= 7) { + x86_cpu_def->cpuid_7_0_ebx_features = kvm_arch_get_supported_cpuid(kvm_state, 0x7, 0, R_EBX); + } else { + x86_cpu_def->cpuid_7_0_ebx_features = 0; + } + host_cpuid(0x80000000, 0, &eax, &ebx, &ecx, &edx); x86_cpu_def->xlevel = eax; @@ -1185,6 +1193,7 @@ int cpu_x86_register(X86CPU *cpu, const char *cpu_model) env->cpuid_kvm_features = def->kvm_features; env->cpuid_svm_features = def->svm_features; env->cpuid_ext4_features = def->ext4_features; + env->cpuid_7_0_ebx = def->cpuid_7_0_ebx_features; env->cpuid_xlevel2 = def->xlevel2; object_property_set_int(OBJECT(cpu), (int64_t)def->tsc_khz * 1000, "tsc-frequency", &error); @@ -1451,13 +1460,12 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, *edx = 0; break; case 7: - if (kvm_enabled()) { - KVMState *s = env->kvm_state; - - *eax = kvm_arch_get_supported_cpuid(s, 0x7, count, R_EAX); - *ebx = kvm_arch_get_supported_cpuid(s, 0x7, count, R_EBX); - *ecx = kvm_arch_get_supported_cpuid(s, 0x7, count, R_ECX); - *edx = kvm_arch_get_supported_cpuid(s, 0x7, count, R_EDX); + /* Structured Extended Feature Flags Enumeration Leaf */ + if (count == 0) { + *eax = 0; /* Maximum ECX value for sub-leaves */ + *ebx = env->cpuid_7_0_ebx; /* Feature flags */ + *ecx = 0; /* Reserved */ + *edx = 0; /* Reserved */ } else { *eax = 0; *ebx = 0; @@ -1722,6 +1730,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 +1771,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/cpu.h b/target-i386/cpu.h index b5b9a50695..2460f6348b 100644 --- a/target-i386/cpu.h +++ b/target-i386/cpu.h @@ -741,6 +741,8 @@ typedef struct CPUX86State { /* Store the results of Centaur's CPUID instructions */ uint32_t cpuid_xlevel2; uint32_t cpuid_ext4_features; + /* Flags from CPUID[EAX=7,ECX=0].EBX */ + uint32_t cpuid_7_0_ebx; /* MTRRs */ uint64_t mtrr_fixed[11]; diff --git a/target-i386/helper.c b/target-i386/helper.c index 0b22582ed6..3421be2276 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-microblaze/translate.c b/target-microblaze/translate.c index 742b3957c0..a362938e41 100644 --- a/target-microblaze/translate.c +++ b/target-microblaze/translate.c @@ -743,7 +743,7 @@ static void dec_bit(DisasContext *dc) unsigned int op; int mem_index = cpu_mmu_index(dc->env); - op = dc->ir & ((1 << 8) - 1); + op = dc->ir & ((1 << 9) - 1); switch (op) { case 0x21: /* src. */ @@ -825,6 +825,16 @@ static void dec_bit(DisasContext *dc) gen_helper_clz(cpu_R[dc->rd], cpu_R[dc->ra]); } break; + case 0x1e0: + /* swapb */ + LOG_DIS("swapb r%d r%d\n", dc->rd, dc->ra); + tcg_gen_bswap32_i32(cpu_R[dc->rd], cpu_R[dc->ra]); + break; + case 0x1e1: + /*swaph */ + LOG_DIS("swaph r%d r%d\n", dc->rd, dc->ra); + tcg_gen_rotri_i32(cpu_R[dc->rd], cpu_R[dc->ra], 16); + break; default: cpu_abort(dc->env, "unknown bit oc=%x op=%x rd=%d ra=%d rb=%d\n", dc->pc, op, dc->rd, dc->ra, dc->rb); diff --git a/target-mips/cpu.h b/target-mips/cpu.h index c0f882659c..44c1152a3a 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 5627447953..66037acec5 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-mips/translate.c b/target-mips/translate.c index f5297b0392..0c563eedfa 100644 --- a/target-mips/translate.c +++ b/target-mips/translate.c @@ -6099,7 +6099,7 @@ static void gen_compute_branch1 (CPUMIPSState *env, DisasContext *ctx, uint32_t TCGv_i32 t1 = tcg_temp_new_i32(); tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc)); tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1)); - tcg_gen_nor_i32(t0, t0, t1); + tcg_gen_nand_i32(t0, t0, t1); tcg_temp_free_i32(t1); tcg_gen_andi_i32(t0, t0, 1); tcg_gen_extu_i32_tl(bcond, t0); @@ -6123,11 +6123,11 @@ static void gen_compute_branch1 (CPUMIPSState *env, DisasContext *ctx, uint32_t TCGv_i32 t1 = tcg_temp_new_i32(); tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc)); tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1)); - tcg_gen_or_i32(t0, t0, t1); + tcg_gen_and_i32(t0, t0, t1); tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+2)); - tcg_gen_or_i32(t0, t0, t1); + tcg_gen_and_i32(t0, t0, t1); tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+3)); - tcg_gen_nor_i32(t0, t0, t1); + tcg_gen_nand_i32(t0, t0, t1); tcg_temp_free_i32(t1); tcg_gen_andi_i32(t0, t0, 1); tcg_gen_extu_i32_tl(bcond, t0); diff --git a/target-sparc/ldst_helper.c b/target-sparc/ldst_helper.c index 04ffddf3c0..efe5e704b5 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 4967152e88..b95f91cd3b 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 dc407166f5..d26569715b 100644 --- a/tcg/ppc/tcg-target.c +++ b/tcg/ppc/tcg-target.c @@ -24,7 +24,11 @@ static uint8_t *tb_ret_addr; -#ifdef _CALL_DARWIN +#if defined _CALL_DARWIN || defined __APPLE__ +#define TCG_TARGET_CALL_DARWIN +#endif + +#ifdef TCG_TARGET_CALL_DARWIN #define LINKAGE_AREA_SIZE 24 #define LR_OFFSET 8 #elif defined _CALL_AIX @@ -99,7 +103,7 @@ static const int tcg_target_reg_alloc_order[] = { TCG_REG_R29, TCG_REG_R30, TCG_REG_R31, -#ifdef _CALL_DARWIN +#ifdef TCG_TARGET_CALL_DARWIN TCG_REG_R2, #endif TCG_REG_R3, @@ -110,7 +114,7 @@ static const int tcg_target_reg_alloc_order[] = { TCG_REG_R8, TCG_REG_R9, TCG_REG_R10, -#ifndef _CALL_DARWIN +#ifndef TCG_TARGET_CALL_DARWIN TCG_REG_R11, #endif TCG_REG_R12, @@ -140,7 +144,7 @@ static const int tcg_target_call_oarg_regs[2] = { }; static const int tcg_target_callee_save_regs[] = { -#ifdef _CALL_DARWIN +#ifdef TCG_TARGET_CALL_DARWIN TCG_REG_R11, TCG_REG_R13, #endif @@ -244,6 +248,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 +268,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 +290,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 +542,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 +584,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 +646,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 +848,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 +884,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); @@ -1930,7 +1969,7 @@ static void tcg_target_init(TCGContext *s) tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffffffff); tcg_regset_set32(tcg_target_call_clobber_regs, 0, (1 << TCG_REG_R0) | -#ifdef _CALL_DARWIN +#ifdef TCG_TARGET_CALL_DARWIN (1 << TCG_REG_R2) | #endif (1 << TCG_REG_R3) | @@ -1948,7 +1987,7 @@ static void tcg_target_init(TCGContext *s) tcg_regset_clear(s->reserved_regs); tcg_regset_set_reg(s->reserved_regs, TCG_REG_R0); tcg_regset_set_reg(s->reserved_regs, TCG_REG_R1); -#ifndef _CALL_DARWIN +#ifndef TCG_TARGET_CALL_DARWIN tcg_regset_set_reg(s->reserved_regs, TCG_REG_R2); #endif #ifdef _CALL_SYSV diff --git a/tcg/ppc64/tcg-target.c b/tcg/ppc64/tcg-target.c index d0b067b784..c800574588 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 9988681293..ab7f667009 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/fdc-test$(EXESUF) +check-qtest-i386-y += tests/rtc-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 $(trace-obj-y) # QTest rules diff --git a/tests/fdc-test.c b/tests/fdc-test.c new file mode 100644 index 0000000000..22d24ac7dc --- /dev/null +++ b/tests/fdc-test.c @@ -0,0 +1,226 @@ +/* + * 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 uint8_t base = 0x70; + +enum { + CMOS_FLOPPY = 0x10, +}; + +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 uint8_t cmos_read(uint8_t reg) +{ + outb(base + 0, reg); + return inb(base + 1); +} + +static void test_cmos(void) +{ + uint8_t cmos; + + cmos = cmos_read(CMOS_FLOPPY); + g_assert(cmos == 0x40); +} + +static void test_no_media_on_start(void) +{ + uint8_t dir; + + /* Media changed bit must be set all time after start if there is + * no media in drive. */ + 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(); + 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); +} + +static void test_media_change(void) +{ + uint8_t dir; + + /* Insert media in drive. DSKCHK should not be reset until a step pulse + * is sent. */ + qmp("{'execute':'change', 'arguments':{ 'device':'floppy0', " + "'target': '%s' }}", test_image); + qmp(""); /* ignore event (FIXME open -> open transition?!) */ + qmp(""); /* ignore event */ + + 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); + + /* 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); +} + +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 "); + + qtest_start(cmdline); + qtest_irq_intercept_in(global_qtest, "ioapic"); + qtest_add_func("/fdc/cmos", test_cmos); + qtest_add_func("/fdc/no_media_on_start", test_no_media_on_start); + 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 295c6d49d0..6d333ef0ac 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 2ca85a9ee9..c8ade856fc 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 7535884f14..75f5876e88 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 0d7807931b..5f9b9900b3 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 86ad5f6c1f..18679780d0 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 e8ab367926..a861e58331 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 a3079176d7..6bbd815ce7 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 b51224b504..5f9a5f2b34 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 9b8fd43edc..4ba56bd87c 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 8a7c5b2ffb..10c56844c5 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 a45c303724..4fcb4161da 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 fe007887e3..8b6cfcb020 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 38abc2ce77..eb7bf996d1 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 914e3737bd..3f8a935a08 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 89348831db..2fe74df763 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 b/tests/qemu-iotests/035 index 56616a1b7d..9d2d3472e7 100755 --- a/tests/qemu-iotests/035 +++ b/tests/qemu-iotests/035 @@ -39,7 +39,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 . ./common.rc . ./common.filter -_supported_fmt generic +_supported_fmt qcow2 _supported_proto generic _supported_os Linux diff --git a/tests/qemu-iotests/035.out b/tests/qemu-iotests/035.out index de205f4a86..0c2279f21b 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 ec1a86a632..e27b40e289 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 c67174a260..c418b67660 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/trace-events b/trace-events index 87cb96cabf..45c6bc1271 100644 --- a/trace-events +++ b/trace-events @@ -602,9 +602,9 @@ escc_kbd_command(int val) "Command %d" escc_sunmouse_event(int dx, int dy, int buttons_state) "dx=%d dy=%d buttons=%01x" # block/iscsi.c -iscsi_aio_write10_cb(void *iscsi, int status, void *acb, int canceled) "iscsi %p status %d acb %p canceled %d" +iscsi_aio_write16_cb(void *iscsi, int status, void *acb, int canceled) "iscsi %p status %d acb %p canceled %d" iscsi_aio_writev(void *iscsi, int64_t sector_num, int nb_sectors, void *opaque, void *acb) "iscsi %p sector_num %"PRId64" nb_sectors %d opaque %p acb %p" -iscsi_aio_read10_cb(void *iscsi, int status, void *acb, int canceled) "iscsi %p status %d acb %p canceled %d" +iscsi_aio_read16_cb(void *iscsi, int status, void *acb, int canceled) "iscsi %p status %d acb %p canceled %d" iscsi_aio_readv(void *iscsi, int64_t sector_num, int nb_sectors, void *opaque, void *acb) "iscsi %p sector_num %"PRId64" nb_sectors %d opaque %p acb %p" # hw/esp.c diff --git a/ui/cocoa.m b/ui/cocoa.m index e7d6e898ee..2383646dc0 100644 --- a/ui/cocoa.m +++ b/ui/cocoa.m @@ -879,7 +879,8 @@ int main (int argc, const char * argv[]) { !strcmp(opt, "-vnc") || !strcmp(opt, "-nographic") || !strcmp(opt, "-version") || - !strcmp(opt, "-curses")) { + !strcmp(opt, "-curses") || + !strcmp(opt, "-qtest")) { return qemu_main(gArgc, gArgv, *_NSGetEnviron()); } } diff --git a/ui/spice-core.c b/ui/spice-core.c index a468524799..4fc48f8902 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(); @@ -2849,6 +2849,10 @@ int vnc_display_pw_expire(DisplayState *ds, time_t expires) { VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display; + if (!vs) { + return -EINVAL; + } + vs->expires = expires; return 0; } @@ -3068,7 +3072,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 +3092,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 be6bc4f64c..d8c2ad9f2f 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: { @@ -3114,7 +3124,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())) { @@ -3484,14 +3494,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); @@ -3627,8 +3634,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); @@ -603,6 +603,10 @@ void xen_vcpu_init(void) qemu_register_reset(xen_reset_vcpu, first_cpu); xen_reset_vcpu(first_cpu); } + /* if rtc_clock is left to default (host_clock), disable it */ + if (rtc_clock == host_clock) { + qemu_clock_enable(rtc_clock, false); + } } /* get the ioreq packets from share mem */ @@ -856,7 +860,7 @@ static void cpu_handle_ioreq(void *opaque) "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", req->state, req->data_is_ptr, req->addr, req->data, req->count, req->size); - destroy_hvm_domain(); + destroy_hvm_domain(false); return; } @@ -870,10 +874,11 @@ static void cpu_handle_ioreq(void *opaque) */ if (runstate_is_running()) { if (qemu_shutdown_requested_get()) { - destroy_hvm_domain(); + destroy_hvm_domain(false); } if (qemu_reset_requested_get()) { qemu_system_reset(VMRESET_REPORT); + destroy_hvm_domain(true); } } @@ -1159,7 +1164,7 @@ int xen_hvm_init(void) return 0; } -void destroy_hvm_domain(void) +void destroy_hvm_domain(bool reboot) { XenXC xc_handle; int sts; @@ -1168,12 +1173,15 @@ void destroy_hvm_domain(void) if (xc_handle == XC_HANDLER_INITIAL_VALUE) { fprintf(stderr, "Cannot acquire xenctrl handle\n"); } else { - sts = xc_domain_shutdown(xc_handle, xen_domid, SHUTDOWN_poweroff); + sts = xc_domain_shutdown(xc_handle, xen_domid, + reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff); if (sts != 0) { - fprintf(stderr, "? xc_domain_shutdown failed to issue poweroff, " - "sts %d, %s\n", sts, strerror(errno)); + fprintf(stderr, "xc_domain_shutdown failed to issue %s, " + "sts %d, %s\n", reboot ? "reboot" : "poweroff", + sts, strerror(errno)); } else { - fprintf(stderr, "Issued domain %d poweroff\n", xen_domid); + fprintf(stderr, "Issued domain %d %s\n", xen_domid, + reboot ? "reboot" : "poweroff"); } xc_interface_close(xc_handle); } |