1797ac58cSKevin Wolf /* 2797ac58cSKevin Wolf * Command line utility to exercise the QEMU I/O path. 3797ac58cSKevin Wolf * 4093ea232SEric Blake * Copyright (C) 2009-2016 Red Hat, Inc. 5797ac58cSKevin Wolf * Copyright (c) 2003-2005 Silicon Graphics, Inc. 6797ac58cSKevin Wolf * 7797ac58cSKevin Wolf * This work is licensed under the terms of the GNU GPL, version 2 or later. 8797ac58cSKevin Wolf * See the COPYING file in the top-level directory. 9797ac58cSKevin Wolf */ 10797ac58cSKevin Wolf 1180c71a24SPeter Maydell #include "qemu/osdep.h" 12da34e65cSMarkus Armbruster #include "qapi/error.h" 133d21994fSKevin Wolf #include "qemu-io.h" 144c7b7e9bSMax Reitz #include "sysemu/block-backend.h" 154c7b7e9bSMax Reitz #include "block/block.h" 164c7b7e9bSMax Reitz #include "block/block_int.h" /* for info_f() */ 17a8d8ecb7SMax Reitz #include "block/qapi.h" 18d49b6836SMarkus Armbruster #include "qemu/error-report.h" 196a1751b7SAlex Bligh #include "qemu/main-loop.h" 20922a01a0SMarkus Armbruster #include "qemu/option.h" 21cd33d02aSKevin Wolf #include "qemu/timer.h" 22f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 23797ac58cSKevin Wolf 24797ac58cSKevin Wolf #define CMD_NOFILE_OK 0x01 25797ac58cSKevin Wolf 26f9883880SStefan Weil bool qemuio_misalign; 27797ac58cSKevin Wolf 28c2cdf5c5SKevin Wolf static cmdinfo_t *cmdtab; 29c2cdf5c5SKevin Wolf static int ncmds; 30c2cdf5c5SKevin Wolf 31c2cdf5c5SKevin Wolf static int compare_cmdname(const void *a, const void *b) 32c2cdf5c5SKevin Wolf { 33c2cdf5c5SKevin Wolf return strcmp(((const cmdinfo_t *)a)->name, 34c2cdf5c5SKevin Wolf ((const cmdinfo_t *)b)->name); 35c2cdf5c5SKevin Wolf } 36c2cdf5c5SKevin Wolf 37c2cdf5c5SKevin Wolf void qemuio_add_command(const cmdinfo_t *ci) 38c2cdf5c5SKevin Wolf { 396aabeb58SPeter Maydell /* ci->perm assumes a file is open, but the GLOBAL and NOFILE_OK 406aabeb58SPeter Maydell * flags allow it not to be, so that combination is invalid. 416aabeb58SPeter Maydell * Catch it now rather than letting it manifest as a crash if a 426aabeb58SPeter Maydell * particular set of command line options are used. 436aabeb58SPeter Maydell */ 446aabeb58SPeter Maydell assert(ci->perm == 0 || 456aabeb58SPeter Maydell (ci->flags & (CMD_FLAG_GLOBAL | CMD_NOFILE_OK)) == 0); 4602c4f26bSMarkus Armbruster cmdtab = g_renew(cmdinfo_t, cmdtab, ++ncmds); 47c2cdf5c5SKevin Wolf cmdtab[ncmds - 1] = *ci; 48c2cdf5c5SKevin Wolf qsort(cmdtab, ncmds, sizeof(*cmdtab), compare_cmdname); 49c2cdf5c5SKevin Wolf } 50c2cdf5c5SKevin Wolf 51b444d0e9SMax Reitz void qemuio_command_usage(const cmdinfo_t *ci) 52c2cdf5c5SKevin Wolf { 53c2cdf5c5SKevin Wolf printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline); 54c2cdf5c5SKevin Wolf } 55c2cdf5c5SKevin Wolf 564c7b7e9bSMax Reitz static int init_check_command(BlockBackend *blk, const cmdinfo_t *ct) 57c2cdf5c5SKevin Wolf { 58c2cdf5c5SKevin Wolf if (ct->flags & CMD_FLAG_GLOBAL) { 59c2cdf5c5SKevin Wolf return 1; 60c2cdf5c5SKevin Wolf } 614c7b7e9bSMax Reitz if (!(ct->flags & CMD_NOFILE_OK) && !blk) { 62c2cdf5c5SKevin Wolf fprintf(stderr, "no file open, try 'help open'\n"); 63c2cdf5c5SKevin Wolf return 0; 64c2cdf5c5SKevin Wolf } 65c2cdf5c5SKevin Wolf return 1; 66c2cdf5c5SKevin Wolf } 67c2cdf5c5SKevin Wolf 68b32d7a39SMax Reitz static int command(BlockBackend *blk, const cmdinfo_t *ct, int argc, 693d21994fSKevin Wolf char **argv) 70c2cdf5c5SKevin Wolf { 71c2cdf5c5SKevin Wolf char *cmd = argv[0]; 72c2cdf5c5SKevin Wolf 734c7b7e9bSMax Reitz if (!init_check_command(blk, ct)) { 74b32d7a39SMax Reitz return -EINVAL; 75c2cdf5c5SKevin Wolf } 76c2cdf5c5SKevin Wolf 77c2cdf5c5SKevin Wolf if (argc - 1 < ct->argmin || (ct->argmax != -1 && argc - 1 > ct->argmax)) { 78c2cdf5c5SKevin Wolf if (ct->argmax == -1) { 79c2cdf5c5SKevin Wolf fprintf(stderr, 80c2cdf5c5SKevin Wolf "bad argument count %d to %s, expected at least %d arguments\n", 81c2cdf5c5SKevin Wolf argc-1, cmd, ct->argmin); 82c2cdf5c5SKevin Wolf } else if (ct->argmin == ct->argmax) { 83c2cdf5c5SKevin Wolf fprintf(stderr, 84c2cdf5c5SKevin Wolf "bad argument count %d to %s, expected %d arguments\n", 85c2cdf5c5SKevin Wolf argc-1, cmd, ct->argmin); 86c2cdf5c5SKevin Wolf } else { 87c2cdf5c5SKevin Wolf fprintf(stderr, 88c2cdf5c5SKevin Wolf "bad argument count %d to %s, expected between %d and %d arguments\n", 89c2cdf5c5SKevin Wolf argc-1, cmd, ct->argmin, ct->argmax); 90c2cdf5c5SKevin Wolf } 91b32d7a39SMax Reitz return -EINVAL; 92c2cdf5c5SKevin Wolf } 93887354bdSKevin Wolf 94887354bdSKevin Wolf /* Request additional permissions if necessary for this command. The caller 95887354bdSKevin Wolf * is responsible for restoring the original permissions afterwards if this 96887354bdSKevin Wolf * is what it wants. */ 97887354bdSKevin Wolf if (ct->perm && blk_is_available(blk)) { 98887354bdSKevin Wolf uint64_t orig_perm, orig_shared_perm; 99887354bdSKevin Wolf blk_get_perm(blk, &orig_perm, &orig_shared_perm); 100887354bdSKevin Wolf 101887354bdSKevin Wolf if (ct->perm & ~orig_perm) { 102887354bdSKevin Wolf uint64_t new_perm; 103887354bdSKevin Wolf Error *local_err = NULL; 104887354bdSKevin Wolf int ret; 105887354bdSKevin Wolf 106887354bdSKevin Wolf new_perm = orig_perm | ct->perm; 107887354bdSKevin Wolf 108887354bdSKevin Wolf ret = blk_set_perm(blk, new_perm, orig_shared_perm, &local_err); 109887354bdSKevin Wolf if (ret < 0) { 110887354bdSKevin Wolf error_report_err(local_err); 111b32d7a39SMax Reitz return ret; 112887354bdSKevin Wolf } 113887354bdSKevin Wolf } 114887354bdSKevin Wolf } 115887354bdSKevin Wolf 116c2cdf5c5SKevin Wolf optind = 0; 117b32d7a39SMax Reitz return ct->cfunc(blk, argc, argv); 118c2cdf5c5SKevin Wolf } 119c2cdf5c5SKevin Wolf 120c2cdf5c5SKevin Wolf static const cmdinfo_t *find_command(const char *cmd) 121c2cdf5c5SKevin Wolf { 122c2cdf5c5SKevin Wolf cmdinfo_t *ct; 123c2cdf5c5SKevin Wolf 124c2cdf5c5SKevin Wolf for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 125c2cdf5c5SKevin Wolf if (strcmp(ct->name, cmd) == 0 || 126c2cdf5c5SKevin Wolf (ct->altname && strcmp(ct->altname, cmd) == 0)) 127c2cdf5c5SKevin Wolf { 128c2cdf5c5SKevin Wolf return (const cmdinfo_t *)ct; 129c2cdf5c5SKevin Wolf } 130c2cdf5c5SKevin Wolf } 131c2cdf5c5SKevin Wolf return NULL; 132c2cdf5c5SKevin Wolf } 133c2cdf5c5SKevin Wolf 1344694020dSStefan Hajnoczi /* Invoke fn() for commands with a matching prefix */ 1354694020dSStefan Hajnoczi void qemuio_complete_command(const char *input, 1364694020dSStefan Hajnoczi void (*fn)(const char *cmd, void *opaque), 1374694020dSStefan Hajnoczi void *opaque) 1384694020dSStefan Hajnoczi { 1394694020dSStefan Hajnoczi cmdinfo_t *ct; 1404694020dSStefan Hajnoczi size_t input_len = strlen(input); 1414694020dSStefan Hajnoczi 1424694020dSStefan Hajnoczi for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 1434694020dSStefan Hajnoczi if (strncmp(input, ct->name, input_len) == 0) { 1444694020dSStefan Hajnoczi fn(ct->name, opaque); 1454694020dSStefan Hajnoczi } 1464694020dSStefan Hajnoczi } 1474694020dSStefan Hajnoczi } 1484694020dSStefan Hajnoczi 149c2cdf5c5SKevin Wolf static char **breakline(char *input, int *count) 150c2cdf5c5SKevin Wolf { 151c2cdf5c5SKevin Wolf int c = 0; 152c2cdf5c5SKevin Wolf char *p; 1535839e53bSMarkus Armbruster char **rval = g_new0(char *, 1); 154c2cdf5c5SKevin Wolf 155c2cdf5c5SKevin Wolf while (rval && (p = qemu_strsep(&input, " ")) != NULL) { 156c2cdf5c5SKevin Wolf if (!*p) { 157c2cdf5c5SKevin Wolf continue; 158c2cdf5c5SKevin Wolf } 159c2cdf5c5SKevin Wolf c++; 16008193dd5SMarkus Armbruster rval = g_renew(char *, rval, (c + 1)); 161c2cdf5c5SKevin Wolf rval[c - 1] = p; 162c2cdf5c5SKevin Wolf rval[c] = NULL; 163c2cdf5c5SKevin Wolf } 164c2cdf5c5SKevin Wolf *count = c; 165c2cdf5c5SKevin Wolf return rval; 166c2cdf5c5SKevin Wolf } 167c2cdf5c5SKevin Wolf 168797ac58cSKevin Wolf static int64_t cvtnum(const char *s) 169797ac58cSKevin Wolf { 170f17fd4fdSMarkus Armbruster int err; 171f46bfdbfSMarkus Armbruster uint64_t value; 172ef5a7885SJohn Snow 173f17fd4fdSMarkus Armbruster err = qemu_strtosz(s, NULL, &value); 174f17fd4fdSMarkus Armbruster if (err < 0) { 175f17fd4fdSMarkus Armbruster return err; 176f17fd4fdSMarkus Armbruster } 177f46bfdbfSMarkus Armbruster if (value > INT64_MAX) { 178f46bfdbfSMarkus Armbruster return -ERANGE; 179f46bfdbfSMarkus Armbruster } 180f17fd4fdSMarkus Armbruster return value; 181797ac58cSKevin Wolf } 182797ac58cSKevin Wolf 183a9ecfa00SJohn Snow static void print_cvtnum_err(int64_t rc, const char *arg) 184a9ecfa00SJohn Snow { 185a9ecfa00SJohn Snow switch (rc) { 186a9ecfa00SJohn Snow case -EINVAL: 187a9ecfa00SJohn Snow printf("Parsing error: non-numeric argument," 188a9ecfa00SJohn Snow " or extraneous/unrecognized suffix -- %s\n", arg); 189a9ecfa00SJohn Snow break; 190a9ecfa00SJohn Snow case -ERANGE: 191a9ecfa00SJohn Snow printf("Parsing error: argument too large -- %s\n", arg); 192a9ecfa00SJohn Snow break; 193a9ecfa00SJohn Snow default: 194a9ecfa00SJohn Snow printf("Parsing error: %s\n", arg); 195a9ecfa00SJohn Snow } 196a9ecfa00SJohn Snow } 197a9ecfa00SJohn Snow 1980b613881SKevin Wolf #define EXABYTES(x) ((long long)(x) << 60) 1990b613881SKevin Wolf #define PETABYTES(x) ((long long)(x) << 50) 2000b613881SKevin Wolf #define TERABYTES(x) ((long long)(x) << 40) 2010b613881SKevin Wolf #define GIGABYTES(x) ((long long)(x) << 30) 2020b613881SKevin Wolf #define MEGABYTES(x) ((long long)(x) << 20) 2030b613881SKevin Wolf #define KILOBYTES(x) ((long long)(x) << 10) 2040b613881SKevin Wolf 2050b613881SKevin Wolf #define TO_EXABYTES(x) ((x) / EXABYTES(1)) 2060b613881SKevin Wolf #define TO_PETABYTES(x) ((x) / PETABYTES(1)) 2070b613881SKevin Wolf #define TO_TERABYTES(x) ((x) / TERABYTES(1)) 2080b613881SKevin Wolf #define TO_GIGABYTES(x) ((x) / GIGABYTES(1)) 2090b613881SKevin Wolf #define TO_MEGABYTES(x) ((x) / MEGABYTES(1)) 2100b613881SKevin Wolf #define TO_KILOBYTES(x) ((x) / KILOBYTES(1)) 2110b613881SKevin Wolf 2120b613881SKevin Wolf static void cvtstr(double value, char *str, size_t size) 2130b613881SKevin Wolf { 2140b613881SKevin Wolf char *trim; 2150b613881SKevin Wolf const char *suffix; 2160b613881SKevin Wolf 2170b613881SKevin Wolf if (value >= EXABYTES(1)) { 2180b613881SKevin Wolf suffix = " EiB"; 2190b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_EXABYTES(value)); 2200b613881SKevin Wolf } else if (value >= PETABYTES(1)) { 2210b613881SKevin Wolf suffix = " PiB"; 2220b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_PETABYTES(value)); 2230b613881SKevin Wolf } else if (value >= TERABYTES(1)) { 2240b613881SKevin Wolf suffix = " TiB"; 2250b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_TERABYTES(value)); 2260b613881SKevin Wolf } else if (value >= GIGABYTES(1)) { 2270b613881SKevin Wolf suffix = " GiB"; 2280b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value)); 2290b613881SKevin Wolf } else if (value >= MEGABYTES(1)) { 2300b613881SKevin Wolf suffix = " MiB"; 2310b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value)); 2320b613881SKevin Wolf } else if (value >= KILOBYTES(1)) { 2330b613881SKevin Wolf suffix = " KiB"; 2340b613881SKevin Wolf snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value)); 2350b613881SKevin Wolf } else { 2360b613881SKevin Wolf suffix = " bytes"; 2370b613881SKevin Wolf snprintf(str, size - 6, "%f", value); 2380b613881SKevin Wolf } 2390b613881SKevin Wolf 2400b613881SKevin Wolf trim = strstr(str, ".000"); 2410b613881SKevin Wolf if (trim) { 2420b613881SKevin Wolf strcpy(trim, suffix); 2430b613881SKevin Wolf } else { 2440b613881SKevin Wolf strcat(str, suffix); 2450b613881SKevin Wolf } 2460b613881SKevin Wolf } 2470b613881SKevin Wolf 2480b613881SKevin Wolf 2490b613881SKevin Wolf 2500b613881SKevin Wolf static struct timeval tsub(struct timeval t1, struct timeval t2) 2510b613881SKevin Wolf { 2520b613881SKevin Wolf t1.tv_usec -= t2.tv_usec; 2530b613881SKevin Wolf if (t1.tv_usec < 0) { 2540b613881SKevin Wolf t1.tv_usec += 1000000; 2550b613881SKevin Wolf t1.tv_sec--; 2560b613881SKevin Wolf } 2570b613881SKevin Wolf t1.tv_sec -= t2.tv_sec; 2580b613881SKevin Wolf return t1; 2590b613881SKevin Wolf } 2600b613881SKevin Wolf 2610b613881SKevin Wolf static double tdiv(double value, struct timeval tv) 2620b613881SKevin Wolf { 2630b613881SKevin Wolf return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0)); 2640b613881SKevin Wolf } 2650b613881SKevin Wolf 2660b613881SKevin Wolf #define HOURS(sec) ((sec) / (60 * 60)) 2670b613881SKevin Wolf #define MINUTES(sec) (((sec) % (60 * 60)) / 60) 2680b613881SKevin Wolf #define SECONDS(sec) ((sec) % 60) 2690b613881SKevin Wolf 2700b613881SKevin Wolf enum { 2710b613881SKevin Wolf DEFAULT_TIME = 0x0, 2720b613881SKevin Wolf TERSE_FIXED_TIME = 0x1, 2730b613881SKevin Wolf VERBOSE_FIXED_TIME = 0x2, 2740b613881SKevin Wolf }; 2750b613881SKevin Wolf 2760b613881SKevin Wolf static void timestr(struct timeval *tv, char *ts, size_t size, int format) 2770b613881SKevin Wolf { 2780b613881SKevin Wolf double usec = (double)tv->tv_usec / 1000000.0; 2790b613881SKevin Wolf 2800b613881SKevin Wolf if (format & TERSE_FIXED_TIME) { 2810b613881SKevin Wolf if (!HOURS(tv->tv_sec)) { 2820b613881SKevin Wolf snprintf(ts, size, "%u:%02u.%02u", 2830b613881SKevin Wolf (unsigned int) MINUTES(tv->tv_sec), 2840b613881SKevin Wolf (unsigned int) SECONDS(tv->tv_sec), 2850b613881SKevin Wolf (unsigned int) (usec * 100)); 2860b613881SKevin Wolf return; 2870b613881SKevin Wolf } 2880b613881SKevin Wolf format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */ 2890b613881SKevin Wolf } 2900b613881SKevin Wolf 2910b613881SKevin Wolf if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) { 2920b613881SKevin Wolf snprintf(ts, size, "%u:%02u:%02u.%02u", 2930b613881SKevin Wolf (unsigned int) HOURS(tv->tv_sec), 2940b613881SKevin Wolf (unsigned int) MINUTES(tv->tv_sec), 2950b613881SKevin Wolf (unsigned int) SECONDS(tv->tv_sec), 2960b613881SKevin Wolf (unsigned int) (usec * 100)); 2970b613881SKevin Wolf } else { 2980b613881SKevin Wolf snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000)); 2990b613881SKevin Wolf } 3000b613881SKevin Wolf } 3010b613881SKevin Wolf 302797ac58cSKevin Wolf /* 303797ac58cSKevin Wolf * Parse the pattern argument to various sub-commands. 304797ac58cSKevin Wolf * 305797ac58cSKevin Wolf * Because the pattern is used as an argument to memset it must evaluate 306797ac58cSKevin Wolf * to an unsigned integer that fits into a single byte. 307797ac58cSKevin Wolf */ 308797ac58cSKevin Wolf static int parse_pattern(const char *arg) 309797ac58cSKevin Wolf { 310797ac58cSKevin Wolf char *endptr = NULL; 311797ac58cSKevin Wolf long pattern; 312797ac58cSKevin Wolf 313797ac58cSKevin Wolf pattern = strtol(arg, &endptr, 0); 314797ac58cSKevin Wolf if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') { 315797ac58cSKevin Wolf printf("%s is not a valid pattern byte\n", arg); 316797ac58cSKevin Wolf return -1; 317797ac58cSKevin Wolf } 318797ac58cSKevin Wolf 319797ac58cSKevin Wolf return pattern; 320797ac58cSKevin Wolf } 321797ac58cSKevin Wolf 322797ac58cSKevin Wolf /* 323797ac58cSKevin Wolf * Memory allocation helpers. 324797ac58cSKevin Wolf * 325797ac58cSKevin Wolf * Make sure memory is aligned by default, or purposefully misaligned if 326797ac58cSKevin Wolf * that is specified on the command line. 327797ac58cSKevin Wolf */ 328797ac58cSKevin Wolf 329797ac58cSKevin Wolf #define MISALIGN_OFFSET 16 3304c7b7e9bSMax Reitz static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) 331797ac58cSKevin Wolf { 332797ac58cSKevin Wolf void *buf; 333797ac58cSKevin Wolf 334797ac58cSKevin Wolf if (qemuio_misalign) { 335797ac58cSKevin Wolf len += MISALIGN_OFFSET; 336797ac58cSKevin Wolf } 3374c7b7e9bSMax Reitz buf = blk_blockalign(blk, len); 338797ac58cSKevin Wolf memset(buf, pattern, len); 339797ac58cSKevin Wolf if (qemuio_misalign) { 340797ac58cSKevin Wolf buf += MISALIGN_OFFSET; 341797ac58cSKevin Wolf } 342797ac58cSKevin Wolf return buf; 343797ac58cSKevin Wolf } 344797ac58cSKevin Wolf 345797ac58cSKevin Wolf static void qemu_io_free(void *p) 346797ac58cSKevin Wolf { 347797ac58cSKevin Wolf if (qemuio_misalign) { 348797ac58cSKevin Wolf p -= MISALIGN_OFFSET; 349797ac58cSKevin Wolf } 350797ac58cSKevin Wolf qemu_vfree(p); 351797ac58cSKevin Wolf } 352797ac58cSKevin Wolf 3539b0beaf3SJohn Snow static void dump_buffer(const void *buffer, int64_t offset, int64_t len) 354797ac58cSKevin Wolf { 3559b0beaf3SJohn Snow uint64_t i; 3569b0beaf3SJohn Snow int j; 357797ac58cSKevin Wolf const uint8_t *p; 358797ac58cSKevin Wolf 359797ac58cSKevin Wolf for (i = 0, p = buffer; i < len; i += 16) { 360797ac58cSKevin Wolf const uint8_t *s = p; 361797ac58cSKevin Wolf 362797ac58cSKevin Wolf printf("%08" PRIx64 ": ", offset + i); 363797ac58cSKevin Wolf for (j = 0; j < 16 && i + j < len; j++, p++) { 364797ac58cSKevin Wolf printf("%02x ", *p); 365797ac58cSKevin Wolf } 366797ac58cSKevin Wolf printf(" "); 367797ac58cSKevin Wolf for (j = 0; j < 16 && i + j < len; j++, s++) { 368797ac58cSKevin Wolf if (isalnum(*s)) { 369797ac58cSKevin Wolf printf("%c", *s); 370797ac58cSKevin Wolf } else { 371797ac58cSKevin Wolf printf("."); 372797ac58cSKevin Wolf } 373797ac58cSKevin Wolf } 374797ac58cSKevin Wolf printf("\n"); 375797ac58cSKevin Wolf } 376797ac58cSKevin Wolf } 377797ac58cSKevin Wolf 378797ac58cSKevin Wolf static void print_report(const char *op, struct timeval *t, int64_t offset, 379dc38852aSEric Blake int64_t count, int64_t total, int cnt, bool Cflag) 380797ac58cSKevin Wolf { 381797ac58cSKevin Wolf char s1[64], s2[64], ts[64]; 382797ac58cSKevin Wolf 383797ac58cSKevin Wolf timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0); 384797ac58cSKevin Wolf if (!Cflag) { 385797ac58cSKevin Wolf cvtstr((double)total, s1, sizeof(s1)); 386797ac58cSKevin Wolf cvtstr(tdiv((double)total, *t), s2, sizeof(s2)); 3879b0beaf3SJohn Snow printf("%s %"PRId64"/%"PRId64" bytes at offset %" PRId64 "\n", 388797ac58cSKevin Wolf op, total, count, offset); 389797ac58cSKevin Wolf printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n", 390797ac58cSKevin Wolf s1, cnt, ts, s2, tdiv((double)cnt, *t)); 391797ac58cSKevin Wolf } else {/* bytes,ops,time,bytes/sec,ops/sec */ 3929b0beaf3SJohn Snow printf("%"PRId64",%d,%s,%.3f,%.3f\n", 393797ac58cSKevin Wolf total, cnt, ts, 394797ac58cSKevin Wolf tdiv((double)total, *t), 395797ac58cSKevin Wolf tdiv((double)cnt, *t)); 396797ac58cSKevin Wolf } 397797ac58cSKevin Wolf } 398797ac58cSKevin Wolf 399797ac58cSKevin Wolf /* 400797ac58cSKevin Wolf * Parse multiple length statements for vectored I/O, and construct an I/O 401797ac58cSKevin Wolf * vector matching it. 402797ac58cSKevin Wolf */ 403797ac58cSKevin Wolf static void * 4044c7b7e9bSMax Reitz create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov, 405797ac58cSKevin Wolf int pattern) 406797ac58cSKevin Wolf { 407797ac58cSKevin Wolf size_t *sizes = g_new0(size_t, nr_iov); 408797ac58cSKevin Wolf size_t count = 0; 409797ac58cSKevin Wolf void *buf = NULL; 410797ac58cSKevin Wolf void *p; 411797ac58cSKevin Wolf int i; 412797ac58cSKevin Wolf 413797ac58cSKevin Wolf for (i = 0; i < nr_iov; i++) { 414797ac58cSKevin Wolf char *arg = argv[i]; 415797ac58cSKevin Wolf int64_t len; 416797ac58cSKevin Wolf 417797ac58cSKevin Wolf len = cvtnum(arg); 418797ac58cSKevin Wolf if (len < 0) { 419a9ecfa00SJohn Snow print_cvtnum_err(len, arg); 420797ac58cSKevin Wolf goto fail; 421797ac58cSKevin Wolf } 422797ac58cSKevin Wolf 4233026c468SAlberto Garcia if (len > BDRV_REQUEST_MAX_BYTES) { 4243026c468SAlberto Garcia printf("Argument '%s' exceeds maximum size %" PRIu64 "\n", arg, 4253026c468SAlberto Garcia (uint64_t)BDRV_REQUEST_MAX_BYTES); 4263026c468SAlberto Garcia goto fail; 4273026c468SAlberto Garcia } 4283026c468SAlberto Garcia 4293026c468SAlberto Garcia if (count > BDRV_REQUEST_MAX_BYTES - len) { 4303026c468SAlberto Garcia printf("The total number of bytes exceed the maximum size %" PRIu64 4313026c468SAlberto Garcia "\n", (uint64_t)BDRV_REQUEST_MAX_BYTES); 432797ac58cSKevin Wolf goto fail; 433797ac58cSKevin Wolf } 434797ac58cSKevin Wolf 435797ac58cSKevin Wolf sizes[i] = len; 436797ac58cSKevin Wolf count += len; 437797ac58cSKevin Wolf } 438797ac58cSKevin Wolf 439797ac58cSKevin Wolf qemu_iovec_init(qiov, nr_iov); 440797ac58cSKevin Wolf 4414c7b7e9bSMax Reitz buf = p = qemu_io_alloc(blk, count, pattern); 442797ac58cSKevin Wolf 443797ac58cSKevin Wolf for (i = 0; i < nr_iov; i++) { 444797ac58cSKevin Wolf qemu_iovec_add(qiov, p, sizes[i]); 445797ac58cSKevin Wolf p += sizes[i]; 446797ac58cSKevin Wolf } 447797ac58cSKevin Wolf 448797ac58cSKevin Wolf fail: 449797ac58cSKevin Wolf g_free(sizes); 450797ac58cSKevin Wolf return buf; 451797ac58cSKevin Wolf } 452797ac58cSKevin Wolf 4539b0beaf3SJohn Snow static int do_pread(BlockBackend *blk, char *buf, int64_t offset, 454f5a5ca79SManos Pitsidianakis int64_t bytes, int64_t *total) 455797ac58cSKevin Wolf { 456f5a5ca79SManos Pitsidianakis if (bytes > INT_MAX) { 4579b0beaf3SJohn Snow return -ERANGE; 4589b0beaf3SJohn Snow } 4599b0beaf3SJohn Snow 460f5a5ca79SManos Pitsidianakis *total = blk_pread(blk, offset, (uint8_t *)buf, bytes); 461797ac58cSKevin Wolf if (*total < 0) { 462797ac58cSKevin Wolf return *total; 463797ac58cSKevin Wolf } 464797ac58cSKevin Wolf return 1; 465797ac58cSKevin Wolf } 466797ac58cSKevin Wolf 4679b0beaf3SJohn Snow static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset, 468f5a5ca79SManos Pitsidianakis int64_t bytes, int flags, int64_t *total) 469797ac58cSKevin Wolf { 470f5a5ca79SManos Pitsidianakis if (bytes > INT_MAX) { 4719b0beaf3SJohn Snow return -ERANGE; 4729b0beaf3SJohn Snow } 4739b0beaf3SJohn Snow 474f5a5ca79SManos Pitsidianakis *total = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags); 475797ac58cSKevin Wolf if (*total < 0) { 476797ac58cSKevin Wolf return *total; 477797ac58cSKevin Wolf } 478797ac58cSKevin Wolf return 1; 479797ac58cSKevin Wolf } 480797ac58cSKevin Wolf 481797ac58cSKevin Wolf typedef struct { 4824c7b7e9bSMax Reitz BlockBackend *blk; 483797ac58cSKevin Wolf int64_t offset; 484f5a5ca79SManos Pitsidianakis int64_t bytes; 4859b0beaf3SJohn Snow int64_t *total; 486770e0e0eSEric Blake int flags; 487797ac58cSKevin Wolf int ret; 488797ac58cSKevin Wolf bool done; 489797ac58cSKevin Wolf } CoWriteZeroes; 490797ac58cSKevin Wolf 491d004bd52SEric Blake static void coroutine_fn co_pwrite_zeroes_entry(void *opaque) 492797ac58cSKevin Wolf { 493797ac58cSKevin Wolf CoWriteZeroes *data = opaque; 494797ac58cSKevin Wolf 495f5a5ca79SManos Pitsidianakis data->ret = blk_co_pwrite_zeroes(data->blk, data->offset, data->bytes, 496770e0e0eSEric Blake data->flags); 497797ac58cSKevin Wolf data->done = true; 498797ac58cSKevin Wolf if (data->ret < 0) { 499797ac58cSKevin Wolf *data->total = data->ret; 500797ac58cSKevin Wolf return; 501797ac58cSKevin Wolf } 502797ac58cSKevin Wolf 503f5a5ca79SManos Pitsidianakis *data->total = data->bytes; 504797ac58cSKevin Wolf } 505797ac58cSKevin Wolf 506d004bd52SEric Blake static int do_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, 507f5a5ca79SManos Pitsidianakis int64_t bytes, int flags, int64_t *total) 508797ac58cSKevin Wolf { 509797ac58cSKevin Wolf Coroutine *co; 510797ac58cSKevin Wolf CoWriteZeroes data = { 5114c7b7e9bSMax Reitz .blk = blk, 512797ac58cSKevin Wolf .offset = offset, 513f5a5ca79SManos Pitsidianakis .bytes = bytes, 514797ac58cSKevin Wolf .total = total, 515770e0e0eSEric Blake .flags = flags, 516797ac58cSKevin Wolf .done = false, 517797ac58cSKevin Wolf }; 518797ac58cSKevin Wolf 519f5a5ca79SManos Pitsidianakis if (bytes > INT_MAX) { 5209b0beaf3SJohn Snow return -ERANGE; 5219b0beaf3SJohn Snow } 5229b0beaf3SJohn Snow 5230b8b8753SPaolo Bonzini co = qemu_coroutine_create(co_pwrite_zeroes_entry, &data); 524324ec3e4SFam Zheng bdrv_coroutine_enter(blk_bs(blk), co); 525797ac58cSKevin Wolf while (!data.done) { 5264c7b7e9bSMax Reitz aio_poll(blk_get_aio_context(blk), true); 527797ac58cSKevin Wolf } 528797ac58cSKevin Wolf if (data.ret < 0) { 529797ac58cSKevin Wolf return data.ret; 530797ac58cSKevin Wolf } else { 531797ac58cSKevin Wolf return 1; 532797ac58cSKevin Wolf } 533797ac58cSKevin Wolf } 534797ac58cSKevin Wolf 5354c7b7e9bSMax Reitz static int do_write_compressed(BlockBackend *blk, char *buf, int64_t offset, 536f5a5ca79SManos Pitsidianakis int64_t bytes, int64_t *total) 537797ac58cSKevin Wolf { 538797ac58cSKevin Wolf int ret; 539797ac58cSKevin Wolf 540f5a5ca79SManos Pitsidianakis if (bytes >> 9 > BDRV_REQUEST_MAX_SECTORS) { 5419b0beaf3SJohn Snow return -ERANGE; 5429b0beaf3SJohn Snow } 5439b0beaf3SJohn Snow 544f5a5ca79SManos Pitsidianakis ret = blk_pwrite_compressed(blk, offset, buf, bytes); 545797ac58cSKevin Wolf if (ret < 0) { 546797ac58cSKevin Wolf return ret; 547797ac58cSKevin Wolf } 548f5a5ca79SManos Pitsidianakis *total = bytes; 549797ac58cSKevin Wolf return 1; 550797ac58cSKevin Wolf } 551797ac58cSKevin Wolf 5524c7b7e9bSMax Reitz static int do_load_vmstate(BlockBackend *blk, char *buf, int64_t offset, 5539b0beaf3SJohn Snow int64_t count, int64_t *total) 554797ac58cSKevin Wolf { 5559b0beaf3SJohn Snow if (count > INT_MAX) { 5569b0beaf3SJohn Snow return -ERANGE; 5579b0beaf3SJohn Snow } 5589b0beaf3SJohn Snow 5594c7b7e9bSMax Reitz *total = blk_load_vmstate(blk, (uint8_t *)buf, offset, count); 560797ac58cSKevin Wolf if (*total < 0) { 561797ac58cSKevin Wolf return *total; 562797ac58cSKevin Wolf } 563797ac58cSKevin Wolf return 1; 564797ac58cSKevin Wolf } 565797ac58cSKevin Wolf 5664c7b7e9bSMax Reitz static int do_save_vmstate(BlockBackend *blk, char *buf, int64_t offset, 5679b0beaf3SJohn Snow int64_t count, int64_t *total) 568797ac58cSKevin Wolf { 5699b0beaf3SJohn Snow if (count > INT_MAX) { 5709b0beaf3SJohn Snow return -ERANGE; 5719b0beaf3SJohn Snow } 5729b0beaf3SJohn Snow 5734c7b7e9bSMax Reitz *total = blk_save_vmstate(blk, (uint8_t *)buf, offset, count); 574797ac58cSKevin Wolf if (*total < 0) { 575797ac58cSKevin Wolf return *total; 576797ac58cSKevin Wolf } 577797ac58cSKevin Wolf return 1; 578797ac58cSKevin Wolf } 579797ac58cSKevin Wolf 580797ac58cSKevin Wolf #define NOT_DONE 0x7fffffff 581797ac58cSKevin Wolf static void aio_rw_done(void *opaque, int ret) 582797ac58cSKevin Wolf { 583797ac58cSKevin Wolf *(int *)opaque = ret; 584797ac58cSKevin Wolf } 585797ac58cSKevin Wolf 5864c7b7e9bSMax Reitz static int do_aio_readv(BlockBackend *blk, QEMUIOVector *qiov, 587797ac58cSKevin Wolf int64_t offset, int *total) 588797ac58cSKevin Wolf { 589797ac58cSKevin Wolf int async_ret = NOT_DONE; 590797ac58cSKevin Wolf 5917b3f9712SEric Blake blk_aio_preadv(blk, offset, qiov, 0, aio_rw_done, &async_ret); 592797ac58cSKevin Wolf while (async_ret == NOT_DONE) { 593797ac58cSKevin Wolf main_loop_wait(false); 594797ac58cSKevin Wolf } 595797ac58cSKevin Wolf 596797ac58cSKevin Wolf *total = qiov->size; 597797ac58cSKevin Wolf return async_ret < 0 ? async_ret : 1; 598797ac58cSKevin Wolf } 599797ac58cSKevin Wolf 6004c7b7e9bSMax Reitz static int do_aio_writev(BlockBackend *blk, QEMUIOVector *qiov, 601770e0e0eSEric Blake int64_t offset, int flags, int *total) 602797ac58cSKevin Wolf { 603797ac58cSKevin Wolf int async_ret = NOT_DONE; 604797ac58cSKevin Wolf 605770e0e0eSEric Blake blk_aio_pwritev(blk, offset, qiov, flags, aio_rw_done, &async_ret); 606797ac58cSKevin Wolf while (async_ret == NOT_DONE) { 607797ac58cSKevin Wolf main_loop_wait(false); 608797ac58cSKevin Wolf } 609797ac58cSKevin Wolf 610797ac58cSKevin Wolf *total = qiov->size; 611797ac58cSKevin Wolf return async_ret < 0 ? async_ret : 1; 612797ac58cSKevin Wolf } 613797ac58cSKevin Wolf 614797ac58cSKevin Wolf static void read_help(void) 615797ac58cSKevin Wolf { 616797ac58cSKevin Wolf printf( 617797ac58cSKevin Wolf "\n" 618797ac58cSKevin Wolf " reads a range of bytes from the given offset\n" 619797ac58cSKevin Wolf "\n" 620797ac58cSKevin Wolf " Example:\n" 621797ac58cSKevin Wolf " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n" 622797ac58cSKevin Wolf "\n" 623797ac58cSKevin Wolf " Reads a segment of the currently open file, optionally dumping it to the\n" 624797ac58cSKevin Wolf " standard output stream (with -v option) for subsequent inspection.\n" 625797ac58cSKevin Wolf " -b, -- read from the VM state rather than the virtual disk\n" 626797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 627797ac58cSKevin Wolf " -l, -- length for pattern verification (only with -P)\n" 628093ea232SEric Blake " -p, -- ignored for backwards compatibility\n" 629797ac58cSKevin Wolf " -P, -- use a pattern to verify read data\n" 630797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 631797ac58cSKevin Wolf " -s, -- start offset for pattern verification (only with -P)\n" 632797ac58cSKevin Wolf " -v, -- dump buffer to standard output\n" 633797ac58cSKevin Wolf "\n"); 634797ac58cSKevin Wolf } 635797ac58cSKevin Wolf 636b32d7a39SMax Reitz static int read_f(BlockBackend *blk, int argc, char **argv); 637797ac58cSKevin Wolf 638797ac58cSKevin Wolf static const cmdinfo_t read_cmd = { 639797ac58cSKevin Wolf .name = "read", 640797ac58cSKevin Wolf .altname = "r", 641797ac58cSKevin Wolf .cfunc = read_f, 642797ac58cSKevin Wolf .argmin = 2, 643797ac58cSKevin Wolf .argmax = -1, 644093ea232SEric Blake .args = "[-abCqv] [-P pattern [-s off] [-l len]] off len", 645797ac58cSKevin Wolf .oneline = "reads a number of bytes at a specified offset", 646797ac58cSKevin Wolf .help = read_help, 647797ac58cSKevin Wolf }; 648797ac58cSKevin Wolf 649b32d7a39SMax Reitz static int read_f(BlockBackend *blk, int argc, char **argv) 650797ac58cSKevin Wolf { 651797ac58cSKevin Wolf struct timeval t1, t2; 652093ea232SEric Blake bool Cflag = false, qflag = false, vflag = false; 653dc38852aSEric Blake bool Pflag = false, sflag = false, lflag = false, bflag = false; 654b32d7a39SMax Reitz int c, cnt, ret; 655797ac58cSKevin Wolf char *buf; 656797ac58cSKevin Wolf int64_t offset; 6579b0beaf3SJohn Snow int64_t count; 658797ac58cSKevin Wolf /* Some compilers get confused and warn if this is not initialized. */ 6599b0beaf3SJohn Snow int64_t total = 0; 6609b0beaf3SJohn Snow int pattern = 0; 6619b0beaf3SJohn Snow int64_t pattern_offset = 0, pattern_count = 0; 662797ac58cSKevin Wolf 663b062ad86SEric Blake while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != -1) { 664797ac58cSKevin Wolf switch (c) { 665797ac58cSKevin Wolf case 'b': 666dc38852aSEric Blake bflag = true; 667797ac58cSKevin Wolf break; 668797ac58cSKevin Wolf case 'C': 669dc38852aSEric Blake Cflag = true; 670797ac58cSKevin Wolf break; 671797ac58cSKevin Wolf case 'l': 672dc38852aSEric Blake lflag = true; 673797ac58cSKevin Wolf pattern_count = cvtnum(optarg); 674797ac58cSKevin Wolf if (pattern_count < 0) { 675a9ecfa00SJohn Snow print_cvtnum_err(pattern_count, optarg); 676b32d7a39SMax Reitz return pattern_count; 677797ac58cSKevin Wolf } 678797ac58cSKevin Wolf break; 679797ac58cSKevin Wolf case 'p': 680093ea232SEric Blake /* Ignored for backwards compatibility */ 681797ac58cSKevin Wolf break; 682797ac58cSKevin Wolf case 'P': 683dc38852aSEric Blake Pflag = true; 684797ac58cSKevin Wolf pattern = parse_pattern(optarg); 685797ac58cSKevin Wolf if (pattern < 0) { 686b32d7a39SMax Reitz return -EINVAL; 687797ac58cSKevin Wolf } 688797ac58cSKevin Wolf break; 689797ac58cSKevin Wolf case 'q': 690dc38852aSEric Blake qflag = true; 691797ac58cSKevin Wolf break; 692797ac58cSKevin Wolf case 's': 693dc38852aSEric Blake sflag = true; 694797ac58cSKevin Wolf pattern_offset = cvtnum(optarg); 695797ac58cSKevin Wolf if (pattern_offset < 0) { 696a9ecfa00SJohn Snow print_cvtnum_err(pattern_offset, optarg); 697b32d7a39SMax Reitz return pattern_offset; 698797ac58cSKevin Wolf } 699797ac58cSKevin Wolf break; 700797ac58cSKevin Wolf case 'v': 701dc38852aSEric Blake vflag = true; 702797ac58cSKevin Wolf break; 703797ac58cSKevin Wolf default: 704b444d0e9SMax Reitz qemuio_command_usage(&read_cmd); 705b32d7a39SMax Reitz return -EINVAL; 706797ac58cSKevin Wolf } 707797ac58cSKevin Wolf } 708797ac58cSKevin Wolf 709797ac58cSKevin Wolf if (optind != argc - 2) { 710b444d0e9SMax Reitz qemuio_command_usage(&read_cmd); 711b32d7a39SMax Reitz return -EINVAL; 712797ac58cSKevin Wolf } 713797ac58cSKevin Wolf 714797ac58cSKevin Wolf offset = cvtnum(argv[optind]); 715797ac58cSKevin Wolf if (offset < 0) { 716a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[optind]); 717b32d7a39SMax Reitz return offset; 718797ac58cSKevin Wolf } 719797ac58cSKevin Wolf 720797ac58cSKevin Wolf optind++; 721797ac58cSKevin Wolf count = cvtnum(argv[optind]); 722797ac58cSKevin Wolf if (count < 0) { 723a9ecfa00SJohn Snow print_cvtnum_err(count, argv[optind]); 724b32d7a39SMax Reitz return count; 7253026c468SAlberto Garcia } else if (count > BDRV_REQUEST_MAX_BYTES) { 7269b0beaf3SJohn Snow printf("length cannot exceed %" PRIu64 ", given %s\n", 7273026c468SAlberto Garcia (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]); 728b32d7a39SMax Reitz return -EINVAL; 729797ac58cSKevin Wolf } 730797ac58cSKevin Wolf 731797ac58cSKevin Wolf if (!Pflag && (lflag || sflag)) { 732b444d0e9SMax Reitz qemuio_command_usage(&read_cmd); 733b32d7a39SMax Reitz return -EINVAL; 734797ac58cSKevin Wolf } 735797ac58cSKevin Wolf 736797ac58cSKevin Wolf if (!lflag) { 737797ac58cSKevin Wolf pattern_count = count - pattern_offset; 738797ac58cSKevin Wolf } 739797ac58cSKevin Wolf 740797ac58cSKevin Wolf if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) { 741797ac58cSKevin Wolf printf("pattern verification range exceeds end of read data\n"); 742b32d7a39SMax Reitz return -EINVAL; 743797ac58cSKevin Wolf } 744797ac58cSKevin Wolf 745093ea232SEric Blake if (bflag) { 7461bce6b4cSEric Blake if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) { 7471bce6b4cSEric Blake printf("%" PRId64 " is not a sector-aligned value for 'offset'\n", 748797ac58cSKevin Wolf offset); 749b32d7a39SMax Reitz return -EINVAL; 750797ac58cSKevin Wolf } 7511bce6b4cSEric Blake if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) { 7521bce6b4cSEric Blake printf("%"PRId64" is not a sector-aligned value for 'count'\n", 753797ac58cSKevin Wolf count); 754b32d7a39SMax Reitz return -EINVAL; 755797ac58cSKevin Wolf } 756797ac58cSKevin Wolf } 757797ac58cSKevin Wolf 7584c7b7e9bSMax Reitz buf = qemu_io_alloc(blk, count, 0xab); 759797ac58cSKevin Wolf 760797ac58cSKevin Wolf gettimeofday(&t1, NULL); 7617b3f9712SEric Blake if (bflag) { 762b32d7a39SMax Reitz ret = do_load_vmstate(blk, buf, offset, count, &total); 763797ac58cSKevin Wolf } else { 764b32d7a39SMax Reitz ret = do_pread(blk, buf, offset, count, &total); 765797ac58cSKevin Wolf } 766797ac58cSKevin Wolf gettimeofday(&t2, NULL); 767797ac58cSKevin Wolf 768b32d7a39SMax Reitz if (ret < 0) { 769b32d7a39SMax Reitz printf("read failed: %s\n", strerror(-ret)); 770797ac58cSKevin Wolf goto out; 771797ac58cSKevin Wolf } 772b32d7a39SMax Reitz cnt = ret; 773b32d7a39SMax Reitz 774b32d7a39SMax Reitz ret = 0; 775797ac58cSKevin Wolf 776797ac58cSKevin Wolf if (Pflag) { 777797ac58cSKevin Wolf void *cmp_buf = g_malloc(pattern_count); 778797ac58cSKevin Wolf memset(cmp_buf, pattern, pattern_count); 779797ac58cSKevin Wolf if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) { 780797ac58cSKevin Wolf printf("Pattern verification failed at offset %" 7819b0beaf3SJohn Snow PRId64 ", %"PRId64" bytes\n", 782797ac58cSKevin Wolf offset + pattern_offset, pattern_count); 783b32d7a39SMax Reitz ret = -EINVAL; 784797ac58cSKevin Wolf } 785797ac58cSKevin Wolf g_free(cmp_buf); 786797ac58cSKevin Wolf } 787797ac58cSKevin Wolf 788797ac58cSKevin Wolf if (qflag) { 789797ac58cSKevin Wolf goto out; 790797ac58cSKevin Wolf } 791797ac58cSKevin Wolf 792797ac58cSKevin Wolf if (vflag) { 793797ac58cSKevin Wolf dump_buffer(buf, offset, count); 794797ac58cSKevin Wolf } 795797ac58cSKevin Wolf 796797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 797797ac58cSKevin Wolf t2 = tsub(t2, t1); 798797ac58cSKevin Wolf print_report("read", &t2, offset, count, total, cnt, Cflag); 799797ac58cSKevin Wolf 800797ac58cSKevin Wolf out: 801797ac58cSKevin Wolf qemu_io_free(buf); 802b32d7a39SMax Reitz return ret; 803797ac58cSKevin Wolf } 804797ac58cSKevin Wolf 805797ac58cSKevin Wolf static void readv_help(void) 806797ac58cSKevin Wolf { 807797ac58cSKevin Wolf printf( 808797ac58cSKevin Wolf "\n" 809797ac58cSKevin Wolf " reads a range of bytes from the given offset into multiple buffers\n" 810797ac58cSKevin Wolf "\n" 811797ac58cSKevin Wolf " Example:\n" 812797ac58cSKevin Wolf " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n" 813797ac58cSKevin Wolf "\n" 814797ac58cSKevin Wolf " Reads a segment of the currently open file, optionally dumping it to the\n" 815797ac58cSKevin Wolf " standard output stream (with -v option) for subsequent inspection.\n" 816797ac58cSKevin Wolf " Uses multiple iovec buffers if more than one byte range is specified.\n" 817797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 818797ac58cSKevin Wolf " -P, -- use a pattern to verify read data\n" 819797ac58cSKevin Wolf " -v, -- dump buffer to standard output\n" 820797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 821797ac58cSKevin Wolf "\n"); 822797ac58cSKevin Wolf } 823797ac58cSKevin Wolf 824b32d7a39SMax Reitz static int readv_f(BlockBackend *blk, int argc, char **argv); 825797ac58cSKevin Wolf 826797ac58cSKevin Wolf static const cmdinfo_t readv_cmd = { 827797ac58cSKevin Wolf .name = "readv", 828797ac58cSKevin Wolf .cfunc = readv_f, 829797ac58cSKevin Wolf .argmin = 2, 830797ac58cSKevin Wolf .argmax = -1, 831797ac58cSKevin Wolf .args = "[-Cqv] [-P pattern] off len [len..]", 832797ac58cSKevin Wolf .oneline = "reads a number of bytes at a specified offset", 833797ac58cSKevin Wolf .help = readv_help, 834797ac58cSKevin Wolf }; 835797ac58cSKevin Wolf 836b32d7a39SMax Reitz static int readv_f(BlockBackend *blk, int argc, char **argv) 837797ac58cSKevin Wolf { 838797ac58cSKevin Wolf struct timeval t1, t2; 839dc38852aSEric Blake bool Cflag = false, qflag = false, vflag = false; 840b32d7a39SMax Reitz int c, cnt, ret; 841797ac58cSKevin Wolf char *buf; 842797ac58cSKevin Wolf int64_t offset; 843797ac58cSKevin Wolf /* Some compilers get confused and warn if this is not initialized. */ 844797ac58cSKevin Wolf int total = 0; 845797ac58cSKevin Wolf int nr_iov; 846797ac58cSKevin Wolf QEMUIOVector qiov; 847797ac58cSKevin Wolf int pattern = 0; 848dc38852aSEric Blake bool Pflag = false; 849797ac58cSKevin Wolf 850b062ad86SEric Blake while ((c = getopt(argc, argv, "CP:qv")) != -1) { 851797ac58cSKevin Wolf switch (c) { 852797ac58cSKevin Wolf case 'C': 853dc38852aSEric Blake Cflag = true; 854797ac58cSKevin Wolf break; 855797ac58cSKevin Wolf case 'P': 856dc38852aSEric Blake Pflag = true; 857797ac58cSKevin Wolf pattern = parse_pattern(optarg); 858797ac58cSKevin Wolf if (pattern < 0) { 859b32d7a39SMax Reitz return -EINVAL; 860797ac58cSKevin Wolf } 861797ac58cSKevin Wolf break; 862797ac58cSKevin Wolf case 'q': 863dc38852aSEric Blake qflag = true; 864797ac58cSKevin Wolf break; 865797ac58cSKevin Wolf case 'v': 866dc38852aSEric Blake vflag = true; 867797ac58cSKevin Wolf break; 868797ac58cSKevin Wolf default: 869b444d0e9SMax Reitz qemuio_command_usage(&readv_cmd); 870b32d7a39SMax Reitz return -EINVAL; 871797ac58cSKevin Wolf } 872797ac58cSKevin Wolf } 873797ac58cSKevin Wolf 874797ac58cSKevin Wolf if (optind > argc - 2) { 875b444d0e9SMax Reitz qemuio_command_usage(&readv_cmd); 876b32d7a39SMax Reitz return -EINVAL; 877797ac58cSKevin Wolf } 878797ac58cSKevin Wolf 879797ac58cSKevin Wolf 880797ac58cSKevin Wolf offset = cvtnum(argv[optind]); 881797ac58cSKevin Wolf if (offset < 0) { 882a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[optind]); 883b32d7a39SMax Reitz return offset; 884797ac58cSKevin Wolf } 885797ac58cSKevin Wolf optind++; 886797ac58cSKevin Wolf 887797ac58cSKevin Wolf nr_iov = argc - optind; 8884c7b7e9bSMax Reitz buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, 0xab); 889797ac58cSKevin Wolf if (buf == NULL) { 890b32d7a39SMax Reitz return -EINVAL; 891797ac58cSKevin Wolf } 892797ac58cSKevin Wolf 893797ac58cSKevin Wolf gettimeofday(&t1, NULL); 894b32d7a39SMax Reitz ret = do_aio_readv(blk, &qiov, offset, &total); 895797ac58cSKevin Wolf gettimeofday(&t2, NULL); 896797ac58cSKevin Wolf 897b32d7a39SMax Reitz if (ret < 0) { 898b32d7a39SMax Reitz printf("readv failed: %s\n", strerror(-ret)); 899797ac58cSKevin Wolf goto out; 900797ac58cSKevin Wolf } 901b32d7a39SMax Reitz cnt = ret; 902b32d7a39SMax Reitz 903b32d7a39SMax Reitz ret = 0; 904797ac58cSKevin Wolf 905797ac58cSKevin Wolf if (Pflag) { 906797ac58cSKevin Wolf void *cmp_buf = g_malloc(qiov.size); 907797ac58cSKevin Wolf memset(cmp_buf, pattern, qiov.size); 908797ac58cSKevin Wolf if (memcmp(buf, cmp_buf, qiov.size)) { 909797ac58cSKevin Wolf printf("Pattern verification failed at offset %" 910*cf67b692SStefan Weil PRId64 ", %zu bytes\n", offset, qiov.size); 911b32d7a39SMax Reitz ret = -EINVAL; 912797ac58cSKevin Wolf } 913797ac58cSKevin Wolf g_free(cmp_buf); 914797ac58cSKevin Wolf } 915797ac58cSKevin Wolf 916797ac58cSKevin Wolf if (qflag) { 917797ac58cSKevin Wolf goto out; 918797ac58cSKevin Wolf } 919797ac58cSKevin Wolf 920797ac58cSKevin Wolf if (vflag) { 921797ac58cSKevin Wolf dump_buffer(buf, offset, qiov.size); 922797ac58cSKevin Wolf } 923797ac58cSKevin Wolf 924797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 925797ac58cSKevin Wolf t2 = tsub(t2, t1); 926797ac58cSKevin Wolf print_report("read", &t2, offset, qiov.size, total, cnt, Cflag); 927797ac58cSKevin Wolf 928797ac58cSKevin Wolf out: 929797ac58cSKevin Wolf qemu_iovec_destroy(&qiov); 930797ac58cSKevin Wolf qemu_io_free(buf); 931b32d7a39SMax Reitz return ret; 932797ac58cSKevin Wolf } 933797ac58cSKevin Wolf 934797ac58cSKevin Wolf static void write_help(void) 935797ac58cSKevin Wolf { 936797ac58cSKevin Wolf printf( 937797ac58cSKevin Wolf "\n" 938797ac58cSKevin Wolf " writes a range of bytes from the given offset\n" 939797ac58cSKevin Wolf "\n" 940797ac58cSKevin Wolf " Example:\n" 941797ac58cSKevin Wolf " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n" 942797ac58cSKevin Wolf "\n" 943797ac58cSKevin Wolf " Writes into a segment of the currently open file, using a buffer\n" 944797ac58cSKevin Wolf " filled with a set pattern (0xcdcdcdcd).\n" 945797ac58cSKevin Wolf " -b, -- write to the VM state rather than the virtual disk\n" 9464c7b7e9bSMax Reitz " -c, -- write compressed data with blk_write_compressed\n" 947770e0e0eSEric Blake " -f, -- use Force Unit Access semantics\n" 948093ea232SEric Blake " -p, -- ignored for backwards compatibility\n" 949797ac58cSKevin Wolf " -P, -- use different pattern to fill file\n" 950797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 951797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 952c2e001ccSEric Blake " -u, -- with -z, allow unmapping\n" 953d004bd52SEric Blake " -z, -- write zeroes using blk_co_pwrite_zeroes\n" 954797ac58cSKevin Wolf "\n"); 955797ac58cSKevin Wolf } 956797ac58cSKevin Wolf 957b32d7a39SMax Reitz static int write_f(BlockBackend *blk, int argc, char **argv); 958797ac58cSKevin Wolf 959797ac58cSKevin Wolf static const cmdinfo_t write_cmd = { 960797ac58cSKevin Wolf .name = "write", 961797ac58cSKevin Wolf .altname = "w", 962797ac58cSKevin Wolf .cfunc = write_f, 963887354bdSKevin Wolf .perm = BLK_PERM_WRITE, 964797ac58cSKevin Wolf .argmin = 2, 965797ac58cSKevin Wolf .argmax = -1, 966c2e001ccSEric Blake .args = "[-bcCfquz] [-P pattern] off len", 967797ac58cSKevin Wolf .oneline = "writes a number of bytes at a specified offset", 968797ac58cSKevin Wolf .help = write_help, 969797ac58cSKevin Wolf }; 970797ac58cSKevin Wolf 971b32d7a39SMax Reitz static int write_f(BlockBackend *blk, int argc, char **argv) 972797ac58cSKevin Wolf { 973797ac58cSKevin Wolf struct timeval t1, t2; 974093ea232SEric Blake bool Cflag = false, qflag = false, bflag = false; 975dc38852aSEric Blake bool Pflag = false, zflag = false, cflag = false; 976770e0e0eSEric Blake int flags = 0; 977b32d7a39SMax Reitz int c, cnt, ret; 978797ac58cSKevin Wolf char *buf = NULL; 979797ac58cSKevin Wolf int64_t offset; 9809b0beaf3SJohn Snow int64_t count; 981797ac58cSKevin Wolf /* Some compilers get confused and warn if this is not initialized. */ 9829b0beaf3SJohn Snow int64_t total = 0; 983797ac58cSKevin Wolf int pattern = 0xcd; 984797ac58cSKevin Wolf 985c2e001ccSEric Blake while ((c = getopt(argc, argv, "bcCfpP:quz")) != -1) { 986797ac58cSKevin Wolf switch (c) { 987797ac58cSKevin Wolf case 'b': 988dc38852aSEric Blake bflag = true; 989797ac58cSKevin Wolf break; 990797ac58cSKevin Wolf case 'c': 991dc38852aSEric Blake cflag = true; 992797ac58cSKevin Wolf break; 993797ac58cSKevin Wolf case 'C': 994dc38852aSEric Blake Cflag = true; 995797ac58cSKevin Wolf break; 996770e0e0eSEric Blake case 'f': 997770e0e0eSEric Blake flags |= BDRV_REQ_FUA; 998770e0e0eSEric Blake break; 999797ac58cSKevin Wolf case 'p': 1000093ea232SEric Blake /* Ignored for backwards compatibility */ 1001797ac58cSKevin Wolf break; 1002797ac58cSKevin Wolf case 'P': 1003dc38852aSEric Blake Pflag = true; 1004797ac58cSKevin Wolf pattern = parse_pattern(optarg); 1005797ac58cSKevin Wolf if (pattern < 0) { 1006b32d7a39SMax Reitz return -EINVAL; 1007797ac58cSKevin Wolf } 1008797ac58cSKevin Wolf break; 1009797ac58cSKevin Wolf case 'q': 1010dc38852aSEric Blake qflag = true; 1011797ac58cSKevin Wolf break; 1012c2e001ccSEric Blake case 'u': 1013c2e001ccSEric Blake flags |= BDRV_REQ_MAY_UNMAP; 1014c2e001ccSEric Blake break; 1015797ac58cSKevin Wolf case 'z': 1016dc38852aSEric Blake zflag = true; 1017797ac58cSKevin Wolf break; 1018797ac58cSKevin Wolf default: 1019b444d0e9SMax Reitz qemuio_command_usage(&write_cmd); 1020b32d7a39SMax Reitz return -EINVAL; 1021797ac58cSKevin Wolf } 1022797ac58cSKevin Wolf } 1023797ac58cSKevin Wolf 1024797ac58cSKevin Wolf if (optind != argc - 2) { 1025b444d0e9SMax Reitz qemuio_command_usage(&write_cmd); 1026b32d7a39SMax Reitz return -EINVAL; 1027797ac58cSKevin Wolf } 1028797ac58cSKevin Wolf 1029093ea232SEric Blake if (bflag && zflag) { 1030093ea232SEric Blake printf("-b and -z cannot be specified at the same time\n"); 1031b32d7a39SMax Reitz return -EINVAL; 1032797ac58cSKevin Wolf } 1033797ac58cSKevin Wolf 1034770e0e0eSEric Blake if ((flags & BDRV_REQ_FUA) && (bflag || cflag)) { 1035770e0e0eSEric Blake printf("-f and -b or -c cannot be specified at the same time\n"); 1036b32d7a39SMax Reitz return -EINVAL; 1037770e0e0eSEric Blake } 1038770e0e0eSEric Blake 1039c2e001ccSEric Blake if ((flags & BDRV_REQ_MAY_UNMAP) && !zflag) { 1040c2e001ccSEric Blake printf("-u requires -z to be specified\n"); 1041b32d7a39SMax Reitz return -EINVAL; 1042c2e001ccSEric Blake } 1043c2e001ccSEric Blake 1044797ac58cSKevin Wolf if (zflag && Pflag) { 1045797ac58cSKevin Wolf printf("-z and -P cannot be specified at the same time\n"); 1046b32d7a39SMax Reitz return -EINVAL; 1047797ac58cSKevin Wolf } 1048797ac58cSKevin Wolf 1049797ac58cSKevin Wolf offset = cvtnum(argv[optind]); 1050797ac58cSKevin Wolf if (offset < 0) { 1051a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[optind]); 1052b32d7a39SMax Reitz return offset; 1053797ac58cSKevin Wolf } 1054797ac58cSKevin Wolf 1055797ac58cSKevin Wolf optind++; 1056797ac58cSKevin Wolf count = cvtnum(argv[optind]); 1057797ac58cSKevin Wolf if (count < 0) { 1058a9ecfa00SJohn Snow print_cvtnum_err(count, argv[optind]); 1059b32d7a39SMax Reitz return count; 10603026c468SAlberto Garcia } else if (count > BDRV_REQUEST_MAX_BYTES) { 10619b0beaf3SJohn Snow printf("length cannot exceed %" PRIu64 ", given %s\n", 10623026c468SAlberto Garcia (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]); 1063b32d7a39SMax Reitz return -EINVAL; 1064797ac58cSKevin Wolf } 1065797ac58cSKevin Wolf 1066093ea232SEric Blake if (bflag || cflag) { 10671bce6b4cSEric Blake if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) { 10681bce6b4cSEric Blake printf("%" PRId64 " is not a sector-aligned value for 'offset'\n", 1069797ac58cSKevin Wolf offset); 1070b32d7a39SMax Reitz return -EINVAL; 1071797ac58cSKevin Wolf } 1072797ac58cSKevin Wolf 10731bce6b4cSEric Blake if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) { 10741bce6b4cSEric Blake printf("%"PRId64" is not a sector-aligned value for 'count'\n", 1075797ac58cSKevin Wolf count); 1076b32d7a39SMax Reitz return -EINVAL; 1077797ac58cSKevin Wolf } 1078797ac58cSKevin Wolf } 1079797ac58cSKevin Wolf 1080797ac58cSKevin Wolf if (!zflag) { 10814c7b7e9bSMax Reitz buf = qemu_io_alloc(blk, count, pattern); 1082797ac58cSKevin Wolf } 1083797ac58cSKevin Wolf 1084797ac58cSKevin Wolf gettimeofday(&t1, NULL); 10857b3f9712SEric Blake if (bflag) { 1086b32d7a39SMax Reitz ret = do_save_vmstate(blk, buf, offset, count, &total); 1087797ac58cSKevin Wolf } else if (zflag) { 1088b32d7a39SMax Reitz ret = do_co_pwrite_zeroes(blk, offset, count, flags, &total); 1089797ac58cSKevin Wolf } else if (cflag) { 1090b32d7a39SMax Reitz ret = do_write_compressed(blk, buf, offset, count, &total); 1091797ac58cSKevin Wolf } else { 1092b32d7a39SMax Reitz ret = do_pwrite(blk, buf, offset, count, flags, &total); 1093797ac58cSKevin Wolf } 1094797ac58cSKevin Wolf gettimeofday(&t2, NULL); 1095797ac58cSKevin Wolf 1096b32d7a39SMax Reitz if (ret < 0) { 1097b32d7a39SMax Reitz printf("write failed: %s\n", strerror(-ret)); 1098797ac58cSKevin Wolf goto out; 1099797ac58cSKevin Wolf } 1100b32d7a39SMax Reitz cnt = ret; 1101b32d7a39SMax Reitz 1102b32d7a39SMax Reitz ret = 0; 1103797ac58cSKevin Wolf 1104797ac58cSKevin Wolf if (qflag) { 1105797ac58cSKevin Wolf goto out; 1106797ac58cSKevin Wolf } 1107797ac58cSKevin Wolf 1108797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 1109797ac58cSKevin Wolf t2 = tsub(t2, t1); 1110797ac58cSKevin Wolf print_report("wrote", &t2, offset, count, total, cnt, Cflag); 1111797ac58cSKevin Wolf 1112797ac58cSKevin Wolf out: 1113797ac58cSKevin Wolf if (!zflag) { 1114797ac58cSKevin Wolf qemu_io_free(buf); 1115797ac58cSKevin Wolf } 1116b32d7a39SMax Reitz return ret; 1117797ac58cSKevin Wolf } 1118797ac58cSKevin Wolf 1119797ac58cSKevin Wolf static void 1120797ac58cSKevin Wolf writev_help(void) 1121797ac58cSKevin Wolf { 1122797ac58cSKevin Wolf printf( 1123797ac58cSKevin Wolf "\n" 1124797ac58cSKevin Wolf " writes a range of bytes from the given offset source from multiple buffers\n" 1125797ac58cSKevin Wolf "\n" 1126797ac58cSKevin Wolf " Example:\n" 11276e6507c0SMaria Kustova " 'writev 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n" 1128797ac58cSKevin Wolf "\n" 1129797ac58cSKevin Wolf " Writes into a segment of the currently open file, using a buffer\n" 1130797ac58cSKevin Wolf " filled with a set pattern (0xcdcdcdcd).\n" 1131797ac58cSKevin Wolf " -P, -- use different pattern to fill file\n" 1132797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 1133770e0e0eSEric Blake " -f, -- use Force Unit Access semantics\n" 1134797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 1135797ac58cSKevin Wolf "\n"); 1136797ac58cSKevin Wolf } 1137797ac58cSKevin Wolf 1138b32d7a39SMax Reitz static int writev_f(BlockBackend *blk, int argc, char **argv); 1139797ac58cSKevin Wolf 1140797ac58cSKevin Wolf static const cmdinfo_t writev_cmd = { 1141797ac58cSKevin Wolf .name = "writev", 1142797ac58cSKevin Wolf .cfunc = writev_f, 1143887354bdSKevin Wolf .perm = BLK_PERM_WRITE, 1144797ac58cSKevin Wolf .argmin = 2, 1145797ac58cSKevin Wolf .argmax = -1, 1146770e0e0eSEric Blake .args = "[-Cfq] [-P pattern] off len [len..]", 1147797ac58cSKevin Wolf .oneline = "writes a number of bytes at a specified offset", 1148797ac58cSKevin Wolf .help = writev_help, 1149797ac58cSKevin Wolf }; 1150797ac58cSKevin Wolf 1151b32d7a39SMax Reitz static int writev_f(BlockBackend *blk, int argc, char **argv) 1152797ac58cSKevin Wolf { 1153797ac58cSKevin Wolf struct timeval t1, t2; 1154dc38852aSEric Blake bool Cflag = false, qflag = false; 1155770e0e0eSEric Blake int flags = 0; 1156b32d7a39SMax Reitz int c, cnt, ret; 1157797ac58cSKevin Wolf char *buf; 1158797ac58cSKevin Wolf int64_t offset; 1159797ac58cSKevin Wolf /* Some compilers get confused and warn if this is not initialized. */ 1160797ac58cSKevin Wolf int total = 0; 1161797ac58cSKevin Wolf int nr_iov; 1162797ac58cSKevin Wolf int pattern = 0xcd; 1163797ac58cSKevin Wolf QEMUIOVector qiov; 1164797ac58cSKevin Wolf 11654ca1d340SEric Blake while ((c = getopt(argc, argv, "CfqP:")) != -1) { 1166797ac58cSKevin Wolf switch (c) { 1167797ac58cSKevin Wolf case 'C': 1168dc38852aSEric Blake Cflag = true; 1169797ac58cSKevin Wolf break; 1170770e0e0eSEric Blake case 'f': 1171770e0e0eSEric Blake flags |= BDRV_REQ_FUA; 1172770e0e0eSEric Blake break; 1173797ac58cSKevin Wolf case 'q': 1174dc38852aSEric Blake qflag = true; 1175797ac58cSKevin Wolf break; 1176797ac58cSKevin Wolf case 'P': 1177797ac58cSKevin Wolf pattern = parse_pattern(optarg); 1178797ac58cSKevin Wolf if (pattern < 0) { 1179b32d7a39SMax Reitz return -EINVAL; 1180797ac58cSKevin Wolf } 1181797ac58cSKevin Wolf break; 1182797ac58cSKevin Wolf default: 1183b444d0e9SMax Reitz qemuio_command_usage(&writev_cmd); 1184b32d7a39SMax Reitz return -EINVAL; 1185797ac58cSKevin Wolf } 1186797ac58cSKevin Wolf } 1187797ac58cSKevin Wolf 1188797ac58cSKevin Wolf if (optind > argc - 2) { 1189b444d0e9SMax Reitz qemuio_command_usage(&writev_cmd); 1190b32d7a39SMax Reitz return -EINVAL; 1191797ac58cSKevin Wolf } 1192797ac58cSKevin Wolf 1193797ac58cSKevin Wolf offset = cvtnum(argv[optind]); 1194797ac58cSKevin Wolf if (offset < 0) { 1195a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[optind]); 1196b32d7a39SMax Reitz return offset; 1197797ac58cSKevin Wolf } 1198797ac58cSKevin Wolf optind++; 1199797ac58cSKevin Wolf 1200797ac58cSKevin Wolf nr_iov = argc - optind; 12014c7b7e9bSMax Reitz buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern); 1202797ac58cSKevin Wolf if (buf == NULL) { 1203b32d7a39SMax Reitz return -EINVAL; 1204797ac58cSKevin Wolf } 1205797ac58cSKevin Wolf 1206797ac58cSKevin Wolf gettimeofday(&t1, NULL); 1207b32d7a39SMax Reitz ret = do_aio_writev(blk, &qiov, offset, flags, &total); 1208797ac58cSKevin Wolf gettimeofday(&t2, NULL); 1209797ac58cSKevin Wolf 1210b32d7a39SMax Reitz if (ret < 0) { 1211b32d7a39SMax Reitz printf("writev failed: %s\n", strerror(-ret)); 1212797ac58cSKevin Wolf goto out; 1213797ac58cSKevin Wolf } 1214b32d7a39SMax Reitz cnt = ret; 1215b32d7a39SMax Reitz 1216b32d7a39SMax Reitz ret = 0; 1217797ac58cSKevin Wolf 1218797ac58cSKevin Wolf if (qflag) { 1219797ac58cSKevin Wolf goto out; 1220797ac58cSKevin Wolf } 1221797ac58cSKevin Wolf 1222797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 1223797ac58cSKevin Wolf t2 = tsub(t2, t1); 1224797ac58cSKevin Wolf print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag); 1225797ac58cSKevin Wolf out: 1226797ac58cSKevin Wolf qemu_iovec_destroy(&qiov); 1227797ac58cSKevin Wolf qemu_io_free(buf); 1228b32d7a39SMax Reitz return ret; 1229797ac58cSKevin Wolf } 1230797ac58cSKevin Wolf 1231797ac58cSKevin Wolf struct aio_ctx { 12324c7b7e9bSMax Reitz BlockBackend *blk; 1233797ac58cSKevin Wolf QEMUIOVector qiov; 1234797ac58cSKevin Wolf int64_t offset; 1235797ac58cSKevin Wolf char *buf; 1236dc38852aSEric Blake bool qflag; 1237dc38852aSEric Blake bool vflag; 1238dc38852aSEric Blake bool Cflag; 1239dc38852aSEric Blake bool Pflag; 1240dc38852aSEric Blake bool zflag; 1241a91f9584SFam Zheng BlockAcctCookie acct; 1242797ac58cSKevin Wolf int pattern; 1243797ac58cSKevin Wolf struct timeval t1; 1244797ac58cSKevin Wolf }; 1245797ac58cSKevin Wolf 1246797ac58cSKevin Wolf static void aio_write_done(void *opaque, int ret) 1247797ac58cSKevin Wolf { 1248797ac58cSKevin Wolf struct aio_ctx *ctx = opaque; 1249797ac58cSKevin Wolf struct timeval t2; 1250797ac58cSKevin Wolf 1251797ac58cSKevin Wolf gettimeofday(&t2, NULL); 1252797ac58cSKevin Wolf 1253797ac58cSKevin Wolf 1254797ac58cSKevin Wolf if (ret < 0) { 1255797ac58cSKevin Wolf printf("aio_write failed: %s\n", strerror(-ret)); 1256556c2b60SAlberto Garcia block_acct_failed(blk_get_stats(ctx->blk), &ctx->acct); 1257797ac58cSKevin Wolf goto out; 1258797ac58cSKevin Wolf } 1259797ac58cSKevin Wolf 12604c7b7e9bSMax Reitz block_acct_done(blk_get_stats(ctx->blk), &ctx->acct); 1261a91f9584SFam Zheng 1262797ac58cSKevin Wolf if (ctx->qflag) { 1263797ac58cSKevin Wolf goto out; 1264797ac58cSKevin Wolf } 1265797ac58cSKevin Wolf 1266797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 1267797ac58cSKevin Wolf t2 = tsub(t2, ctx->t1); 1268797ac58cSKevin Wolf print_report("wrote", &t2, ctx->offset, ctx->qiov.size, 1269797ac58cSKevin Wolf ctx->qiov.size, 1, ctx->Cflag); 1270797ac58cSKevin Wolf out: 12715ceb7765SKevin Wolf if (!ctx->zflag) { 1272797ac58cSKevin Wolf qemu_io_free(ctx->buf); 1273797ac58cSKevin Wolf qemu_iovec_destroy(&ctx->qiov); 12745ceb7765SKevin Wolf } 1275797ac58cSKevin Wolf g_free(ctx); 1276797ac58cSKevin Wolf } 1277797ac58cSKevin Wolf 1278797ac58cSKevin Wolf static void aio_read_done(void *opaque, int ret) 1279797ac58cSKevin Wolf { 1280797ac58cSKevin Wolf struct aio_ctx *ctx = opaque; 1281797ac58cSKevin Wolf struct timeval t2; 1282797ac58cSKevin Wolf 1283797ac58cSKevin Wolf gettimeofday(&t2, NULL); 1284797ac58cSKevin Wolf 1285797ac58cSKevin Wolf if (ret < 0) { 1286797ac58cSKevin Wolf printf("readv failed: %s\n", strerror(-ret)); 1287556c2b60SAlberto Garcia block_acct_failed(blk_get_stats(ctx->blk), &ctx->acct); 1288797ac58cSKevin Wolf goto out; 1289797ac58cSKevin Wolf } 1290797ac58cSKevin Wolf 1291797ac58cSKevin Wolf if (ctx->Pflag) { 1292797ac58cSKevin Wolf void *cmp_buf = g_malloc(ctx->qiov.size); 1293797ac58cSKevin Wolf 1294797ac58cSKevin Wolf memset(cmp_buf, ctx->pattern, ctx->qiov.size); 1295797ac58cSKevin Wolf if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) { 1296797ac58cSKevin Wolf printf("Pattern verification failed at offset %" 1297*cf67b692SStefan Weil PRId64 ", %zu bytes\n", ctx->offset, ctx->qiov.size); 1298797ac58cSKevin Wolf } 1299797ac58cSKevin Wolf g_free(cmp_buf); 1300797ac58cSKevin Wolf } 1301797ac58cSKevin Wolf 13024c7b7e9bSMax Reitz block_acct_done(blk_get_stats(ctx->blk), &ctx->acct); 1303a91f9584SFam Zheng 1304797ac58cSKevin Wolf if (ctx->qflag) { 1305797ac58cSKevin Wolf goto out; 1306797ac58cSKevin Wolf } 1307797ac58cSKevin Wolf 1308797ac58cSKevin Wolf if (ctx->vflag) { 1309797ac58cSKevin Wolf dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size); 1310797ac58cSKevin Wolf } 1311797ac58cSKevin Wolf 1312797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 1313797ac58cSKevin Wolf t2 = tsub(t2, ctx->t1); 1314797ac58cSKevin Wolf print_report("read", &t2, ctx->offset, ctx->qiov.size, 1315797ac58cSKevin Wolf ctx->qiov.size, 1, ctx->Cflag); 1316797ac58cSKevin Wolf out: 1317797ac58cSKevin Wolf qemu_io_free(ctx->buf); 1318797ac58cSKevin Wolf qemu_iovec_destroy(&ctx->qiov); 1319797ac58cSKevin Wolf g_free(ctx); 1320797ac58cSKevin Wolf } 1321797ac58cSKevin Wolf 1322797ac58cSKevin Wolf static void aio_read_help(void) 1323797ac58cSKevin Wolf { 1324797ac58cSKevin Wolf printf( 1325797ac58cSKevin Wolf "\n" 1326797ac58cSKevin Wolf " asynchronously reads a range of bytes from the given offset\n" 1327797ac58cSKevin Wolf "\n" 1328797ac58cSKevin Wolf " Example:\n" 1329797ac58cSKevin Wolf " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n" 1330797ac58cSKevin Wolf "\n" 1331797ac58cSKevin Wolf " Reads a segment of the currently open file, optionally dumping it to the\n" 1332797ac58cSKevin Wolf " standard output stream (with -v option) for subsequent inspection.\n" 1333797ac58cSKevin Wolf " The read is performed asynchronously and the aio_flush command must be\n" 1334797ac58cSKevin Wolf " used to ensure all outstanding aio requests have been completed.\n" 1335b32d7a39SMax Reitz " Note that due to its asynchronous nature, this command will be\n" 1336b32d7a39SMax Reitz " considered successful once the request is submitted, independently\n" 1337b32d7a39SMax Reitz " of potential I/O errors or pattern mismatches.\n" 1338797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 1339797ac58cSKevin Wolf " -P, -- use a pattern to verify read data\n" 134037546ff2SEric Blake " -i, -- treat request as invalid, for exercising stats\n" 1341797ac58cSKevin Wolf " -v, -- dump buffer to standard output\n" 1342797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 1343797ac58cSKevin Wolf "\n"); 1344797ac58cSKevin Wolf } 1345797ac58cSKevin Wolf 1346b32d7a39SMax Reitz static int aio_read_f(BlockBackend *blk, int argc, char **argv); 1347797ac58cSKevin Wolf 1348797ac58cSKevin Wolf static const cmdinfo_t aio_read_cmd = { 1349797ac58cSKevin Wolf .name = "aio_read", 1350797ac58cSKevin Wolf .cfunc = aio_read_f, 1351797ac58cSKevin Wolf .argmin = 2, 1352797ac58cSKevin Wolf .argmax = -1, 135337546ff2SEric Blake .args = "[-Ciqv] [-P pattern] off len [len..]", 1354797ac58cSKevin Wolf .oneline = "asynchronously reads a number of bytes", 1355797ac58cSKevin Wolf .help = aio_read_help, 1356797ac58cSKevin Wolf }; 1357797ac58cSKevin Wolf 1358b32d7a39SMax Reitz static int aio_read_f(BlockBackend *blk, int argc, char **argv) 1359797ac58cSKevin Wolf { 1360797ac58cSKevin Wolf int nr_iov, c; 1361797ac58cSKevin Wolf struct aio_ctx *ctx = g_new0(struct aio_ctx, 1); 1362797ac58cSKevin Wolf 13634c7b7e9bSMax Reitz ctx->blk = blk; 136437546ff2SEric Blake while ((c = getopt(argc, argv, "CP:iqv")) != -1) { 1365797ac58cSKevin Wolf switch (c) { 1366797ac58cSKevin Wolf case 'C': 1367dc38852aSEric Blake ctx->Cflag = true; 1368797ac58cSKevin Wolf break; 1369797ac58cSKevin Wolf case 'P': 1370dc38852aSEric Blake ctx->Pflag = true; 1371797ac58cSKevin Wolf ctx->pattern = parse_pattern(optarg); 1372797ac58cSKevin Wolf if (ctx->pattern < 0) { 1373797ac58cSKevin Wolf g_free(ctx); 1374b32d7a39SMax Reitz return -EINVAL; 1375797ac58cSKevin Wolf } 1376797ac58cSKevin Wolf break; 137737546ff2SEric Blake case 'i': 137837546ff2SEric Blake printf("injecting invalid read request\n"); 137937546ff2SEric Blake block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ); 138037546ff2SEric Blake g_free(ctx); 1381b32d7a39SMax Reitz return 0; 1382797ac58cSKevin Wolf case 'q': 1383dc38852aSEric Blake ctx->qflag = true; 1384797ac58cSKevin Wolf break; 1385797ac58cSKevin Wolf case 'v': 1386dc38852aSEric Blake ctx->vflag = true; 1387797ac58cSKevin Wolf break; 1388797ac58cSKevin Wolf default: 1389797ac58cSKevin Wolf g_free(ctx); 1390b444d0e9SMax Reitz qemuio_command_usage(&aio_read_cmd); 1391b32d7a39SMax Reitz return -EINVAL; 1392797ac58cSKevin Wolf } 1393797ac58cSKevin Wolf } 1394797ac58cSKevin Wolf 1395797ac58cSKevin Wolf if (optind > argc - 2) { 1396797ac58cSKevin Wolf g_free(ctx); 1397b444d0e9SMax Reitz qemuio_command_usage(&aio_read_cmd); 1398b32d7a39SMax Reitz return -EINVAL; 1399797ac58cSKevin Wolf } 1400797ac58cSKevin Wolf 1401797ac58cSKevin Wolf ctx->offset = cvtnum(argv[optind]); 1402797ac58cSKevin Wolf if (ctx->offset < 0) { 1403b32d7a39SMax Reitz int ret = ctx->offset; 1404b32d7a39SMax Reitz print_cvtnum_err(ret, argv[optind]); 1405797ac58cSKevin Wolf g_free(ctx); 1406b32d7a39SMax Reitz return ret; 1407797ac58cSKevin Wolf } 1408797ac58cSKevin Wolf optind++; 1409797ac58cSKevin Wolf 1410797ac58cSKevin Wolf nr_iov = argc - optind; 14114c7b7e9bSMax Reitz ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, 0xab); 1412797ac58cSKevin Wolf if (ctx->buf == NULL) { 1413556c2b60SAlberto Garcia block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ); 1414797ac58cSKevin Wolf g_free(ctx); 1415b32d7a39SMax Reitz return -EINVAL; 1416797ac58cSKevin Wolf } 1417797ac58cSKevin Wolf 1418797ac58cSKevin Wolf gettimeofday(&ctx->t1, NULL); 14194c7b7e9bSMax Reitz block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size, 14204c7b7e9bSMax Reitz BLOCK_ACCT_READ); 14217b3f9712SEric Blake blk_aio_preadv(blk, ctx->offset, &ctx->qiov, 0, aio_read_done, ctx); 1422b32d7a39SMax Reitz return 0; 1423797ac58cSKevin Wolf } 1424797ac58cSKevin Wolf 1425797ac58cSKevin Wolf static void aio_write_help(void) 1426797ac58cSKevin Wolf { 1427797ac58cSKevin Wolf printf( 1428797ac58cSKevin Wolf "\n" 1429797ac58cSKevin Wolf " asynchronously writes a range of bytes from the given offset source\n" 1430797ac58cSKevin Wolf " from multiple buffers\n" 1431797ac58cSKevin Wolf "\n" 1432797ac58cSKevin Wolf " Example:\n" 1433797ac58cSKevin Wolf " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n" 1434797ac58cSKevin Wolf "\n" 1435797ac58cSKevin Wolf " Writes into a segment of the currently open file, using a buffer\n" 1436797ac58cSKevin Wolf " filled with a set pattern (0xcdcdcdcd).\n" 1437797ac58cSKevin Wolf " The write is performed asynchronously and the aio_flush command must be\n" 1438797ac58cSKevin Wolf " used to ensure all outstanding aio requests have been completed.\n" 1439b32d7a39SMax Reitz " Note that due to its asynchronous nature, this command will be\n" 1440b32d7a39SMax Reitz " considered successful once the request is submitted, independently\n" 1441b32d7a39SMax Reitz " of potential I/O errors or pattern mismatches.\n" 1442797ac58cSKevin Wolf " -P, -- use different pattern to fill file\n" 1443797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 1444770e0e0eSEric Blake " -f, -- use Force Unit Access semantics\n" 144537546ff2SEric Blake " -i, -- treat request as invalid, for exercising stats\n" 1446797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 1447c2e001ccSEric Blake " -u, -- with -z, allow unmapping\n" 1448d004bd52SEric Blake " -z, -- write zeroes using blk_aio_pwrite_zeroes\n" 1449797ac58cSKevin Wolf "\n"); 1450797ac58cSKevin Wolf } 1451797ac58cSKevin Wolf 1452b32d7a39SMax Reitz static int aio_write_f(BlockBackend *blk, int argc, char **argv); 1453797ac58cSKevin Wolf 1454797ac58cSKevin Wolf static const cmdinfo_t aio_write_cmd = { 1455797ac58cSKevin Wolf .name = "aio_write", 1456797ac58cSKevin Wolf .cfunc = aio_write_f, 1457887354bdSKevin Wolf .perm = BLK_PERM_WRITE, 1458797ac58cSKevin Wolf .argmin = 2, 1459797ac58cSKevin Wolf .argmax = -1, 146037546ff2SEric Blake .args = "[-Cfiquz] [-P pattern] off len [len..]", 1461797ac58cSKevin Wolf .oneline = "asynchronously writes a number of bytes", 1462797ac58cSKevin Wolf .help = aio_write_help, 1463797ac58cSKevin Wolf }; 1464797ac58cSKevin Wolf 1465b32d7a39SMax Reitz static int aio_write_f(BlockBackend *blk, int argc, char **argv) 1466797ac58cSKevin Wolf { 1467797ac58cSKevin Wolf int nr_iov, c; 1468797ac58cSKevin Wolf int pattern = 0xcd; 1469797ac58cSKevin Wolf struct aio_ctx *ctx = g_new0(struct aio_ctx, 1); 1470770e0e0eSEric Blake int flags = 0; 1471797ac58cSKevin Wolf 14724c7b7e9bSMax Reitz ctx->blk = blk; 147337546ff2SEric Blake while ((c = getopt(argc, argv, "CfiqP:uz")) != -1) { 1474797ac58cSKevin Wolf switch (c) { 1475797ac58cSKevin Wolf case 'C': 1476dc38852aSEric Blake ctx->Cflag = true; 1477797ac58cSKevin Wolf break; 1478770e0e0eSEric Blake case 'f': 1479770e0e0eSEric Blake flags |= BDRV_REQ_FUA; 1480770e0e0eSEric Blake break; 1481797ac58cSKevin Wolf case 'q': 1482dc38852aSEric Blake ctx->qflag = true; 1483797ac58cSKevin Wolf break; 1484c2e001ccSEric Blake case 'u': 1485c2e001ccSEric Blake flags |= BDRV_REQ_MAY_UNMAP; 1486c2e001ccSEric Blake break; 1487797ac58cSKevin Wolf case 'P': 1488797ac58cSKevin Wolf pattern = parse_pattern(optarg); 1489797ac58cSKevin Wolf if (pattern < 0) { 1490797ac58cSKevin Wolf g_free(ctx); 1491b32d7a39SMax Reitz return -EINVAL; 1492797ac58cSKevin Wolf } 1493797ac58cSKevin Wolf break; 149437546ff2SEric Blake case 'i': 149537546ff2SEric Blake printf("injecting invalid write request\n"); 149637546ff2SEric Blake block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE); 149737546ff2SEric Blake g_free(ctx); 1498b32d7a39SMax Reitz return 0; 14995ceb7765SKevin Wolf case 'z': 1500dc38852aSEric Blake ctx->zflag = true; 15015ceb7765SKevin Wolf break; 1502797ac58cSKevin Wolf default: 1503797ac58cSKevin Wolf g_free(ctx); 1504b444d0e9SMax Reitz qemuio_command_usage(&aio_write_cmd); 1505b32d7a39SMax Reitz return -EINVAL; 1506797ac58cSKevin Wolf } 1507797ac58cSKevin Wolf } 1508797ac58cSKevin Wolf 1509797ac58cSKevin Wolf if (optind > argc - 2) { 1510797ac58cSKevin Wolf g_free(ctx); 1511b444d0e9SMax Reitz qemuio_command_usage(&aio_write_cmd); 1512b32d7a39SMax Reitz return -EINVAL; 1513797ac58cSKevin Wolf } 1514797ac58cSKevin Wolf 15155ceb7765SKevin Wolf if (ctx->zflag && optind != argc - 2) { 15165ceb7765SKevin Wolf printf("-z supports only a single length parameter\n"); 15175ceb7765SKevin Wolf g_free(ctx); 1518b32d7a39SMax Reitz return -EINVAL; 15195ceb7765SKevin Wolf } 15205ceb7765SKevin Wolf 1521c2e001ccSEric Blake if ((flags & BDRV_REQ_MAY_UNMAP) && !ctx->zflag) { 1522c2e001ccSEric Blake printf("-u requires -z to be specified\n"); 15234ca1d340SEric Blake g_free(ctx); 1524b32d7a39SMax Reitz return -EINVAL; 1525c2e001ccSEric Blake } 1526c2e001ccSEric Blake 15275ceb7765SKevin Wolf if (ctx->zflag && ctx->Pflag) { 15285ceb7765SKevin Wolf printf("-z and -P cannot be specified at the same time\n"); 15295ceb7765SKevin Wolf g_free(ctx); 1530b32d7a39SMax Reitz return -EINVAL; 15315ceb7765SKevin Wolf } 15325ceb7765SKevin Wolf 1533797ac58cSKevin Wolf ctx->offset = cvtnum(argv[optind]); 1534797ac58cSKevin Wolf if (ctx->offset < 0) { 1535b32d7a39SMax Reitz int ret = ctx->offset; 1536b32d7a39SMax Reitz print_cvtnum_err(ret, argv[optind]); 1537797ac58cSKevin Wolf g_free(ctx); 1538b32d7a39SMax Reitz return ret; 1539797ac58cSKevin Wolf } 1540797ac58cSKevin Wolf optind++; 1541797ac58cSKevin Wolf 15425ceb7765SKevin Wolf if (ctx->zflag) { 15435ceb7765SKevin Wolf int64_t count = cvtnum(argv[optind]); 15445ceb7765SKevin Wolf if (count < 0) { 15455ceb7765SKevin Wolf print_cvtnum_err(count, argv[optind]); 15460e01b76eSKevin Wolf g_free(ctx); 1547b32d7a39SMax Reitz return count; 15485ceb7765SKevin Wolf } 15495ceb7765SKevin Wolf 15505ceb7765SKevin Wolf ctx->qiov.size = count; 1551d004bd52SEric Blake blk_aio_pwrite_zeroes(blk, ctx->offset, count, flags, aio_write_done, 1552770e0e0eSEric Blake ctx); 15535ceb7765SKevin Wolf } else { 1554797ac58cSKevin Wolf nr_iov = argc - optind; 15555ceb7765SKevin Wolf ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, 15565ceb7765SKevin Wolf pattern); 1557797ac58cSKevin Wolf if (ctx->buf == NULL) { 1558556c2b60SAlberto Garcia block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE); 1559797ac58cSKevin Wolf g_free(ctx); 1560b32d7a39SMax Reitz return -EINVAL; 1561797ac58cSKevin Wolf } 1562797ac58cSKevin Wolf 1563797ac58cSKevin Wolf gettimeofday(&ctx->t1, NULL); 15644c7b7e9bSMax Reitz block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size, 15654c7b7e9bSMax Reitz BLOCK_ACCT_WRITE); 15665ceb7765SKevin Wolf 1567770e0e0eSEric Blake blk_aio_pwritev(blk, ctx->offset, &ctx->qiov, flags, aio_write_done, 1568770e0e0eSEric Blake ctx); 15695ceb7765SKevin Wolf } 1570b32d7a39SMax Reitz 1571b32d7a39SMax Reitz return 0; 1572797ac58cSKevin Wolf } 1573797ac58cSKevin Wolf 1574b32d7a39SMax Reitz static int aio_flush_f(BlockBackend *blk, int argc, char **argv) 1575797ac58cSKevin Wolf { 1576556c2b60SAlberto Garcia BlockAcctCookie cookie; 1577556c2b60SAlberto Garcia block_acct_start(blk_get_stats(blk), &cookie, 0, BLOCK_ACCT_FLUSH); 15784c7b7e9bSMax Reitz blk_drain_all(); 1579556c2b60SAlberto Garcia block_acct_done(blk_get_stats(blk), &cookie); 1580b32d7a39SMax Reitz return 0; 1581797ac58cSKevin Wolf } 1582797ac58cSKevin Wolf 1583797ac58cSKevin Wolf static const cmdinfo_t aio_flush_cmd = { 1584797ac58cSKevin Wolf .name = "aio_flush", 1585797ac58cSKevin Wolf .cfunc = aio_flush_f, 1586797ac58cSKevin Wolf .oneline = "completes all outstanding aio requests" 1587797ac58cSKevin Wolf }; 1588797ac58cSKevin Wolf 1589b32d7a39SMax Reitz static int flush_f(BlockBackend *blk, int argc, char **argv) 1590797ac58cSKevin Wolf { 1591b32d7a39SMax Reitz return blk_flush(blk); 1592797ac58cSKevin Wolf } 1593797ac58cSKevin Wolf 1594797ac58cSKevin Wolf static const cmdinfo_t flush_cmd = { 1595797ac58cSKevin Wolf .name = "flush", 1596797ac58cSKevin Wolf .altname = "f", 1597797ac58cSKevin Wolf .cfunc = flush_f, 1598797ac58cSKevin Wolf .oneline = "flush all in-core file state to disk", 1599797ac58cSKevin Wolf }; 1600797ac58cSKevin Wolf 1601b32d7a39SMax Reitz static int truncate_f(BlockBackend *blk, int argc, char **argv) 1602797ac58cSKevin Wolf { 1603ed3d2ec9SMax Reitz Error *local_err = NULL; 1604797ac58cSKevin Wolf int64_t offset; 1605797ac58cSKevin Wolf int ret; 1606797ac58cSKevin Wolf 1607797ac58cSKevin Wolf offset = cvtnum(argv[1]); 1608797ac58cSKevin Wolf if (offset < 0) { 1609a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[1]); 1610b32d7a39SMax Reitz return offset; 1611797ac58cSKevin Wolf } 1612797ac58cSKevin Wolf 16133a691c50SMax Reitz ret = blk_truncate(blk, offset, PREALLOC_MODE_OFF, &local_err); 1614797ac58cSKevin Wolf if (ret < 0) { 1615ed3d2ec9SMax Reitz error_report_err(local_err); 1616b32d7a39SMax Reitz return ret; 1617797ac58cSKevin Wolf } 1618b32d7a39SMax Reitz 1619b32d7a39SMax Reitz return 0; 1620797ac58cSKevin Wolf } 1621797ac58cSKevin Wolf 1622797ac58cSKevin Wolf static const cmdinfo_t truncate_cmd = { 1623797ac58cSKevin Wolf .name = "truncate", 1624797ac58cSKevin Wolf .altname = "t", 1625797ac58cSKevin Wolf .cfunc = truncate_f, 1626887354bdSKevin Wolf .perm = BLK_PERM_WRITE | BLK_PERM_RESIZE, 1627797ac58cSKevin Wolf .argmin = 1, 1628797ac58cSKevin Wolf .argmax = 1, 1629797ac58cSKevin Wolf .args = "off", 1630797ac58cSKevin Wolf .oneline = "truncates the current file at the given offset", 1631797ac58cSKevin Wolf }; 1632797ac58cSKevin Wolf 1633b32d7a39SMax Reitz static int length_f(BlockBackend *blk, int argc, char **argv) 1634797ac58cSKevin Wolf { 1635797ac58cSKevin Wolf int64_t size; 1636797ac58cSKevin Wolf char s1[64]; 1637797ac58cSKevin Wolf 16384c7b7e9bSMax Reitz size = blk_getlength(blk); 1639797ac58cSKevin Wolf if (size < 0) { 1640797ac58cSKevin Wolf printf("getlength: %s\n", strerror(-size)); 1641b32d7a39SMax Reitz return size; 1642797ac58cSKevin Wolf } 1643797ac58cSKevin Wolf 1644797ac58cSKevin Wolf cvtstr(size, s1, sizeof(s1)); 1645797ac58cSKevin Wolf printf("%s\n", s1); 1646b32d7a39SMax Reitz return 0; 1647797ac58cSKevin Wolf } 1648797ac58cSKevin Wolf 1649797ac58cSKevin Wolf 1650797ac58cSKevin Wolf static const cmdinfo_t length_cmd = { 1651797ac58cSKevin Wolf .name = "length", 1652797ac58cSKevin Wolf .altname = "l", 1653797ac58cSKevin Wolf .cfunc = length_f, 1654797ac58cSKevin Wolf .oneline = "gets the length of the current file", 1655797ac58cSKevin Wolf }; 1656797ac58cSKevin Wolf 1657797ac58cSKevin Wolf 1658b32d7a39SMax Reitz static int info_f(BlockBackend *blk, int argc, char **argv) 1659797ac58cSKevin Wolf { 16604c7b7e9bSMax Reitz BlockDriverState *bs = blk_bs(blk); 1661797ac58cSKevin Wolf BlockDriverInfo bdi; 1662a8d8ecb7SMax Reitz ImageInfoSpecific *spec_info; 1663797ac58cSKevin Wolf char s1[64], s2[64]; 1664797ac58cSKevin Wolf int ret; 1665797ac58cSKevin Wolf 1666797ac58cSKevin Wolf if (bs->drv && bs->drv->format_name) { 1667797ac58cSKevin Wolf printf("format name: %s\n", bs->drv->format_name); 1668797ac58cSKevin Wolf } 1669797ac58cSKevin Wolf if (bs->drv && bs->drv->protocol_name) { 1670797ac58cSKevin Wolf printf("format name: %s\n", bs->drv->protocol_name); 1671797ac58cSKevin Wolf } 1672797ac58cSKevin Wolf 1673797ac58cSKevin Wolf ret = bdrv_get_info(bs, &bdi); 1674797ac58cSKevin Wolf if (ret) { 1675b32d7a39SMax Reitz return ret; 1676797ac58cSKevin Wolf } 1677797ac58cSKevin Wolf 1678797ac58cSKevin Wolf cvtstr(bdi.cluster_size, s1, sizeof(s1)); 1679797ac58cSKevin Wolf cvtstr(bdi.vm_state_offset, s2, sizeof(s2)); 1680797ac58cSKevin Wolf 1681797ac58cSKevin Wolf printf("cluster size: %s\n", s1); 1682797ac58cSKevin Wolf printf("vm state offset: %s\n", s2); 1683797ac58cSKevin Wolf 1684a8d8ecb7SMax Reitz spec_info = bdrv_get_specific_info(bs); 1685a8d8ecb7SMax Reitz if (spec_info) { 1686a8d8ecb7SMax Reitz printf("Format specific information:\n"); 1687a8d8ecb7SMax Reitz bdrv_image_info_specific_dump(fprintf, stdout, spec_info); 1688a8d8ecb7SMax Reitz qapi_free_ImageInfoSpecific(spec_info); 1689a8d8ecb7SMax Reitz } 1690b32d7a39SMax Reitz 1691b32d7a39SMax Reitz return 0; 1692797ac58cSKevin Wolf } 1693797ac58cSKevin Wolf 1694797ac58cSKevin Wolf 1695797ac58cSKevin Wolf 1696797ac58cSKevin Wolf static const cmdinfo_t info_cmd = { 1697797ac58cSKevin Wolf .name = "info", 1698797ac58cSKevin Wolf .altname = "i", 1699797ac58cSKevin Wolf .cfunc = info_f, 1700797ac58cSKevin Wolf .oneline = "prints information about the current file", 1701797ac58cSKevin Wolf }; 1702797ac58cSKevin Wolf 1703797ac58cSKevin Wolf static void discard_help(void) 1704797ac58cSKevin Wolf { 1705797ac58cSKevin Wolf printf( 1706797ac58cSKevin Wolf "\n" 1707797ac58cSKevin Wolf " discards a range of bytes from the given offset\n" 1708797ac58cSKevin Wolf "\n" 1709797ac58cSKevin Wolf " Example:\n" 1710797ac58cSKevin Wolf " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n" 1711797ac58cSKevin Wolf "\n" 1712797ac58cSKevin Wolf " Discards a segment of the currently open file.\n" 1713797ac58cSKevin Wolf " -C, -- report statistics in a machine parsable format\n" 1714797ac58cSKevin Wolf " -q, -- quiet mode, do not show I/O statistics\n" 1715797ac58cSKevin Wolf "\n"); 1716797ac58cSKevin Wolf } 1717797ac58cSKevin Wolf 1718b32d7a39SMax Reitz static int discard_f(BlockBackend *blk, int argc, char **argv); 1719797ac58cSKevin Wolf 1720797ac58cSKevin Wolf static const cmdinfo_t discard_cmd = { 1721797ac58cSKevin Wolf .name = "discard", 1722797ac58cSKevin Wolf .altname = "d", 1723797ac58cSKevin Wolf .cfunc = discard_f, 1724887354bdSKevin Wolf .perm = BLK_PERM_WRITE, 1725797ac58cSKevin Wolf .argmin = 2, 1726797ac58cSKevin Wolf .argmax = -1, 1727797ac58cSKevin Wolf .args = "[-Cq] off len", 1728797ac58cSKevin Wolf .oneline = "discards a number of bytes at a specified offset", 1729797ac58cSKevin Wolf .help = discard_help, 1730797ac58cSKevin Wolf }; 1731797ac58cSKevin Wolf 1732b32d7a39SMax Reitz static int discard_f(BlockBackend *blk, int argc, char **argv) 1733797ac58cSKevin Wolf { 1734797ac58cSKevin Wolf struct timeval t1, t2; 1735dc38852aSEric Blake bool Cflag = false, qflag = false; 1736797ac58cSKevin Wolf int c, ret; 1737f5a5ca79SManos Pitsidianakis int64_t offset, bytes; 1738797ac58cSKevin Wolf 1739b062ad86SEric Blake while ((c = getopt(argc, argv, "Cq")) != -1) { 1740797ac58cSKevin Wolf switch (c) { 1741797ac58cSKevin Wolf case 'C': 1742dc38852aSEric Blake Cflag = true; 1743797ac58cSKevin Wolf break; 1744797ac58cSKevin Wolf case 'q': 1745dc38852aSEric Blake qflag = true; 1746797ac58cSKevin Wolf break; 1747797ac58cSKevin Wolf default: 1748b444d0e9SMax Reitz qemuio_command_usage(&discard_cmd); 1749b32d7a39SMax Reitz return -EINVAL; 1750797ac58cSKevin Wolf } 1751797ac58cSKevin Wolf } 1752797ac58cSKevin Wolf 1753797ac58cSKevin Wolf if (optind != argc - 2) { 1754b444d0e9SMax Reitz qemuio_command_usage(&discard_cmd); 1755b32d7a39SMax Reitz return -EINVAL; 1756797ac58cSKevin Wolf } 1757797ac58cSKevin Wolf 1758797ac58cSKevin Wolf offset = cvtnum(argv[optind]); 1759797ac58cSKevin Wolf if (offset < 0) { 1760a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[optind]); 1761b32d7a39SMax Reitz return offset; 1762797ac58cSKevin Wolf } 1763797ac58cSKevin Wolf 1764797ac58cSKevin Wolf optind++; 1765f5a5ca79SManos Pitsidianakis bytes = cvtnum(argv[optind]); 1766f5a5ca79SManos Pitsidianakis if (bytes < 0) { 1767f5a5ca79SManos Pitsidianakis print_cvtnum_err(bytes, argv[optind]); 1768b32d7a39SMax Reitz return bytes; 1769f5a5ca79SManos Pitsidianakis } else if (bytes >> BDRV_SECTOR_BITS > BDRV_REQUEST_MAX_SECTORS) { 17709b0beaf3SJohn Snow printf("length cannot exceed %"PRIu64", given %s\n", 1771a3674679SMax Reitz (uint64_t)BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS, 17729b0beaf3SJohn Snow argv[optind]); 1773b32d7a39SMax Reitz return -EINVAL; 1774797ac58cSKevin Wolf } 1775797ac58cSKevin Wolf 1776797ac58cSKevin Wolf gettimeofday(&t1, NULL); 1777f5a5ca79SManos Pitsidianakis ret = blk_pdiscard(blk, offset, bytes); 1778797ac58cSKevin Wolf gettimeofday(&t2, NULL); 1779797ac58cSKevin Wolf 1780797ac58cSKevin Wolf if (ret < 0) { 1781797ac58cSKevin Wolf printf("discard failed: %s\n", strerror(-ret)); 1782b32d7a39SMax Reitz return ret; 1783797ac58cSKevin Wolf } 1784797ac58cSKevin Wolf 1785797ac58cSKevin Wolf /* Finally, report back -- -C gives a parsable format */ 1786797ac58cSKevin Wolf if (!qflag) { 1787797ac58cSKevin Wolf t2 = tsub(t2, t1); 1788f5a5ca79SManos Pitsidianakis print_report("discard", &t2, offset, bytes, bytes, 1, Cflag); 1789797ac58cSKevin Wolf } 1790b32d7a39SMax Reitz 1791b32d7a39SMax Reitz return 0; 1792797ac58cSKevin Wolf } 1793797ac58cSKevin Wolf 1794b32d7a39SMax Reitz static int alloc_f(BlockBackend *blk, int argc, char **argv) 1795797ac58cSKevin Wolf { 17964c7b7e9bSMax Reitz BlockDriverState *bs = blk_bs(blk); 1797d6a644bbSEric Blake int64_t offset, start, remaining, count; 1798797ac58cSKevin Wolf char s1[64]; 1799d6a644bbSEric Blake int ret; 1800d6a644bbSEric Blake int64_t num, sum_alloc; 1801797ac58cSKevin Wolf 1802d6a644bbSEric Blake start = offset = cvtnum(argv[1]); 1803797ac58cSKevin Wolf if (offset < 0) { 1804a9ecfa00SJohn Snow print_cvtnum_err(offset, argv[1]); 1805b32d7a39SMax Reitz return offset; 1806797ac58cSKevin Wolf } 1807797ac58cSKevin Wolf 1808797ac58cSKevin Wolf if (argc == 3) { 18094401fdc7SEric Blake count = cvtnum(argv[2]); 18104401fdc7SEric Blake if (count < 0) { 18114401fdc7SEric Blake print_cvtnum_err(count, argv[2]); 1812b32d7a39SMax Reitz return count; 1813797ac58cSKevin Wolf } 1814797ac58cSKevin Wolf } else { 18154401fdc7SEric Blake count = BDRV_SECTOR_SIZE; 1816797ac58cSKevin Wolf } 1817797ac58cSKevin Wolf 1818d6a644bbSEric Blake remaining = count; 1819797ac58cSKevin Wolf sum_alloc = 0; 1820797ac58cSKevin Wolf while (remaining) { 1821d6a644bbSEric Blake ret = bdrv_is_allocated(bs, offset, remaining, &num); 1822d663640cSPaolo Bonzini if (ret < 0) { 1823d663640cSPaolo Bonzini printf("is_allocated failed: %s\n", strerror(-ret)); 1824b32d7a39SMax Reitz return ret; 1825d663640cSPaolo Bonzini } 1826d6a644bbSEric Blake offset += num; 1827797ac58cSKevin Wolf remaining -= num; 1828797ac58cSKevin Wolf if (ret) { 1829797ac58cSKevin Wolf sum_alloc += num; 1830797ac58cSKevin Wolf } 1831797ac58cSKevin Wolf if (num == 0) { 1832d6a644bbSEric Blake count -= remaining; 1833797ac58cSKevin Wolf remaining = 0; 1834797ac58cSKevin Wolf } 1835797ac58cSKevin Wolf } 1836797ac58cSKevin Wolf 1837d6a644bbSEric Blake cvtstr(start, s1, sizeof(s1)); 1838797ac58cSKevin Wolf 18394401fdc7SEric Blake printf("%"PRId64"/%"PRId64" bytes allocated at offset %s\n", 1840d6a644bbSEric Blake sum_alloc, count, s1); 1841b32d7a39SMax Reitz return 0; 1842797ac58cSKevin Wolf } 1843797ac58cSKevin Wolf 1844797ac58cSKevin Wolf static const cmdinfo_t alloc_cmd = { 1845797ac58cSKevin Wolf .name = "alloc", 1846797ac58cSKevin Wolf .altname = "a", 1847797ac58cSKevin Wolf .argmin = 1, 1848797ac58cSKevin Wolf .argmax = 2, 1849797ac58cSKevin Wolf .cfunc = alloc_f, 18504401fdc7SEric Blake .args = "offset [count]", 18514401fdc7SEric Blake .oneline = "checks if offset is allocated in the file", 1852797ac58cSKevin Wolf }; 1853797ac58cSKevin Wolf 1854797ac58cSKevin Wolf 1855d6a644bbSEric Blake static int map_is_allocated(BlockDriverState *bs, int64_t offset, 1856d6a644bbSEric Blake int64_t bytes, int64_t *pnum) 1857797ac58cSKevin Wolf { 1858d6a644bbSEric Blake int64_t num; 1859d6a644bbSEric Blake int num_checked; 1860797ac58cSKevin Wolf int ret, firstret; 1861797ac58cSKevin Wolf 1862d6a644bbSEric Blake num_checked = MIN(bytes, BDRV_REQUEST_MAX_BYTES); 1863d6a644bbSEric Blake ret = bdrv_is_allocated(bs, offset, num_checked, &num); 1864797ac58cSKevin Wolf if (ret < 0) { 1865797ac58cSKevin Wolf return ret; 1866797ac58cSKevin Wolf } 1867797ac58cSKevin Wolf 1868797ac58cSKevin Wolf firstret = ret; 1869797ac58cSKevin Wolf *pnum = num; 1870797ac58cSKevin Wolf 1871d6a644bbSEric Blake while (bytes > 0 && ret == firstret) { 1872d6a644bbSEric Blake offset += num; 1873d6a644bbSEric Blake bytes -= num; 1874797ac58cSKevin Wolf 1875d6a644bbSEric Blake num_checked = MIN(bytes, BDRV_REQUEST_MAX_BYTES); 1876d6a644bbSEric Blake ret = bdrv_is_allocated(bs, offset, num_checked, &num); 18774b25bbc4SMax Reitz if (ret == firstret && num) { 1878797ac58cSKevin Wolf *pnum += num; 1879797ac58cSKevin Wolf } else { 1880797ac58cSKevin Wolf break; 1881797ac58cSKevin Wolf } 1882797ac58cSKevin Wolf } 1883797ac58cSKevin Wolf 1884797ac58cSKevin Wolf return firstret; 1885797ac58cSKevin Wolf } 1886797ac58cSKevin Wolf 1887b32d7a39SMax Reitz static int map_f(BlockBackend *blk, int argc, char **argv) 1888797ac58cSKevin Wolf { 1889d6a644bbSEric Blake int64_t offset, bytes; 18906f3c90afSEric Blake char s1[64], s2[64]; 1891797ac58cSKevin Wolf int64_t num; 1892797ac58cSKevin Wolf int ret; 1893797ac58cSKevin Wolf const char *retstr; 1894797ac58cSKevin Wolf 1895797ac58cSKevin Wolf offset = 0; 1896d6a644bbSEric Blake bytes = blk_getlength(blk); 1897d6a644bbSEric Blake if (bytes < 0) { 1898d6a644bbSEric Blake error_report("Failed to query image length: %s", strerror(-bytes)); 1899b32d7a39SMax Reitz return bytes; 19004c7b7e9bSMax Reitz } 19014c7b7e9bSMax Reitz 1902d6a644bbSEric Blake while (bytes) { 1903d6a644bbSEric Blake ret = map_is_allocated(blk_bs(blk), offset, bytes, &num); 1904797ac58cSKevin Wolf if (ret < 0) { 1905797ac58cSKevin Wolf error_report("Failed to get allocation status: %s", strerror(-ret)); 1906b32d7a39SMax Reitz return ret; 19074b25bbc4SMax Reitz } else if (!num) { 19084b25bbc4SMax Reitz error_report("Unexpected end of image"); 1909b32d7a39SMax Reitz return -EIO; 1910797ac58cSKevin Wolf } 1911797ac58cSKevin Wolf 1912797ac58cSKevin Wolf retstr = ret ? " allocated" : "not allocated"; 1913d6a644bbSEric Blake cvtstr(num, s1, sizeof(s1)); 1914d6a644bbSEric Blake cvtstr(offset, s2, sizeof(s2)); 19156f3c90afSEric Blake printf("%s (0x%" PRIx64 ") bytes %s at offset %s (0x%" PRIx64 ")\n", 1916d6a644bbSEric Blake s1, num, retstr, s2, offset); 1917797ac58cSKevin Wolf 1918797ac58cSKevin Wolf offset += num; 1919d6a644bbSEric Blake bytes -= num; 1920d6a644bbSEric Blake } 1921b32d7a39SMax Reitz 1922b32d7a39SMax Reitz return 0; 1923797ac58cSKevin Wolf } 1924797ac58cSKevin Wolf 1925797ac58cSKevin Wolf static const cmdinfo_t map_cmd = { 1926797ac58cSKevin Wolf .name = "map", 1927797ac58cSKevin Wolf .argmin = 0, 1928797ac58cSKevin Wolf .argmax = 0, 1929797ac58cSKevin Wolf .cfunc = map_f, 1930797ac58cSKevin Wolf .args = "", 1931797ac58cSKevin Wolf .oneline = "prints the allocated areas of a file", 1932797ac58cSKevin Wolf }; 1933797ac58cSKevin Wolf 19345bbd2e59SKevin Wolf static void reopen_help(void) 19355bbd2e59SKevin Wolf { 19365bbd2e59SKevin Wolf printf( 19375bbd2e59SKevin Wolf "\n" 19385bbd2e59SKevin Wolf " Changes the open options of an already opened image\n" 19395bbd2e59SKevin Wolf "\n" 19405bbd2e59SKevin Wolf " Example:\n" 19415bbd2e59SKevin Wolf " 'reopen -o lazy-refcounts=on' - activates lazy refcount writeback on a qcow2 image\n" 19425bbd2e59SKevin Wolf "\n" 19435bbd2e59SKevin Wolf " -r, -- Reopen the image read-only\n" 1944ea92203cSKevin Wolf " -w, -- Reopen the image read-write\n" 19455bbd2e59SKevin Wolf " -c, -- Change the cache mode to the given value\n" 19465bbd2e59SKevin Wolf " -o, -- Changes block driver options (cf. 'open' command)\n" 19475bbd2e59SKevin Wolf "\n"); 19485bbd2e59SKevin Wolf } 19495bbd2e59SKevin Wolf 1950b32d7a39SMax Reitz static int reopen_f(BlockBackend *blk, int argc, char **argv); 19515bbd2e59SKevin Wolf 19525bbd2e59SKevin Wolf static QemuOptsList reopen_opts = { 19535bbd2e59SKevin Wolf .name = "reopen", 19545bbd2e59SKevin Wolf .merge_lists = true, 19555bbd2e59SKevin Wolf .head = QTAILQ_HEAD_INITIALIZER(reopen_opts.head), 19565bbd2e59SKevin Wolf .desc = { 19575bbd2e59SKevin Wolf /* no elements => accept any params */ 19585bbd2e59SKevin Wolf { /* end of list */ } 19595bbd2e59SKevin Wolf }, 19605bbd2e59SKevin Wolf }; 19615bbd2e59SKevin Wolf 19625bbd2e59SKevin Wolf static const cmdinfo_t reopen_cmd = { 19635bbd2e59SKevin Wolf .name = "reopen", 19645bbd2e59SKevin Wolf .argmin = 0, 19655bbd2e59SKevin Wolf .argmax = -1, 19665bbd2e59SKevin Wolf .cfunc = reopen_f, 1967ea92203cSKevin Wolf .args = "[(-r|-w)] [-c cache] [-o options]", 19685bbd2e59SKevin Wolf .oneline = "reopens an image with new options", 19695bbd2e59SKevin Wolf .help = reopen_help, 19705bbd2e59SKevin Wolf }; 19715bbd2e59SKevin Wolf 1972b32d7a39SMax Reitz static int reopen_f(BlockBackend *blk, int argc, char **argv) 19735bbd2e59SKevin Wolf { 19745bbd2e59SKevin Wolf BlockDriverState *bs = blk_bs(blk); 19755bbd2e59SKevin Wolf QemuOpts *qopts; 19765bbd2e59SKevin Wolf QDict *opts; 19775bbd2e59SKevin Wolf int c; 19785bbd2e59SKevin Wolf int flags = bs->open_flags; 197919dbecdcSKevin Wolf bool writethrough = !blk_enable_write_cache(blk); 1980ea92203cSKevin Wolf bool has_rw_option = false; 19815bbd2e59SKevin Wolf 19825bbd2e59SKevin Wolf BlockReopenQueue *brq; 19835bbd2e59SKevin Wolf Error *local_err = NULL; 19845bbd2e59SKevin Wolf 1985ea92203cSKevin Wolf while ((c = getopt(argc, argv, "c:o:rw")) != -1) { 19865bbd2e59SKevin Wolf switch (c) { 19875bbd2e59SKevin Wolf case 'c': 198819dbecdcSKevin Wolf if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) { 19895bbd2e59SKevin Wolf error_report("Invalid cache option: %s", optarg); 1990b32d7a39SMax Reitz return -EINVAL; 19915bbd2e59SKevin Wolf } 19925bbd2e59SKevin Wolf break; 19935bbd2e59SKevin Wolf case 'o': 19945bbd2e59SKevin Wolf if (!qemu_opts_parse_noisily(&reopen_opts, optarg, 0)) { 19955bbd2e59SKevin Wolf qemu_opts_reset(&reopen_opts); 1996b32d7a39SMax Reitz return -EINVAL; 19975bbd2e59SKevin Wolf } 19985bbd2e59SKevin Wolf break; 19995bbd2e59SKevin Wolf case 'r': 2000ea92203cSKevin Wolf if (has_rw_option) { 2001ea92203cSKevin Wolf error_report("Only one -r/-w option may be given"); 2002b32d7a39SMax Reitz return -EINVAL; 2003ea92203cSKevin Wolf } 20045bbd2e59SKevin Wolf flags &= ~BDRV_O_RDWR; 2005ea92203cSKevin Wolf has_rw_option = true; 2006ea92203cSKevin Wolf break; 2007ea92203cSKevin Wolf case 'w': 2008ea92203cSKevin Wolf if (has_rw_option) { 2009ea92203cSKevin Wolf error_report("Only one -r/-w option may be given"); 2010b32d7a39SMax Reitz return -EINVAL; 2011ea92203cSKevin Wolf } 2012ea92203cSKevin Wolf flags |= BDRV_O_RDWR; 2013ea92203cSKevin Wolf has_rw_option = true; 20145bbd2e59SKevin Wolf break; 20155bbd2e59SKevin Wolf default: 20165bbd2e59SKevin Wolf qemu_opts_reset(&reopen_opts); 2017b444d0e9SMax Reitz qemuio_command_usage(&reopen_cmd); 2018b32d7a39SMax Reitz return -EINVAL; 20195bbd2e59SKevin Wolf } 20205bbd2e59SKevin Wolf } 20215bbd2e59SKevin Wolf 20225bbd2e59SKevin Wolf if (optind != argc) { 20235bbd2e59SKevin Wolf qemu_opts_reset(&reopen_opts); 2024b444d0e9SMax Reitz qemuio_command_usage(&reopen_cmd); 2025b32d7a39SMax Reitz return -EINVAL; 20265bbd2e59SKevin Wolf } 20275bbd2e59SKevin Wolf 2028a8003ec4SAlberto Garcia if (!writethrough != blk_enable_write_cache(blk) && 202919dbecdcSKevin Wolf blk_get_attached_dev(blk)) 203019dbecdcSKevin Wolf { 203119dbecdcSKevin Wolf error_report("Cannot change cache.writeback: Device attached"); 203219dbecdcSKevin Wolf qemu_opts_reset(&reopen_opts); 2033b32d7a39SMax Reitz return -EBUSY; 203419dbecdcSKevin Wolf } 203519dbecdcSKevin Wolf 2036f3adefb2SKevin Wolf if (!(flags & BDRV_O_RDWR)) { 2037f3adefb2SKevin Wolf uint64_t orig_perm, orig_shared_perm; 2038f3adefb2SKevin Wolf 2039f3adefb2SKevin Wolf bdrv_drain(bs); 2040f3adefb2SKevin Wolf 2041f3adefb2SKevin Wolf blk_get_perm(blk, &orig_perm, &orig_shared_perm); 2042f3adefb2SKevin Wolf blk_set_perm(blk, 2043f3adefb2SKevin Wolf orig_perm & ~(BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED), 2044f3adefb2SKevin Wolf orig_shared_perm, 2045f3adefb2SKevin Wolf &error_abort); 2046f3adefb2SKevin Wolf } 2047f3adefb2SKevin Wolf 20485bbd2e59SKevin Wolf qopts = qemu_opts_find(&reopen_opts, NULL); 20495bbd2e59SKevin Wolf opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL; 20505bbd2e59SKevin Wolf qemu_opts_reset(&reopen_opts); 20515bbd2e59SKevin Wolf 20521a63a907SKevin Wolf bdrv_subtree_drained_begin(bs); 20535bbd2e59SKevin Wolf brq = bdrv_reopen_queue(NULL, bs, opts, flags); 2054720150f3SPaolo Bonzini bdrv_reopen_multiple(bdrv_get_aio_context(bs), brq, &local_err); 20551a63a907SKevin Wolf bdrv_subtree_drained_end(bs); 20561a63a907SKevin Wolf 20575bbd2e59SKevin Wolf if (local_err) { 20585bbd2e59SKevin Wolf error_report_err(local_err); 2059b32d7a39SMax Reitz return -EINVAL; 20605bbd2e59SKevin Wolf } 20615bbd2e59SKevin Wolf 2062b32d7a39SMax Reitz blk_set_enable_write_cache(blk, !writethrough); 2063b32d7a39SMax Reitz return 0; 2064b32d7a39SMax Reitz } 2065b32d7a39SMax Reitz 2066b32d7a39SMax Reitz static int break_f(BlockBackend *blk, int argc, char **argv) 2067797ac58cSKevin Wolf { 2068797ac58cSKevin Wolf int ret; 2069797ac58cSKevin Wolf 20704c7b7e9bSMax Reitz ret = bdrv_debug_breakpoint(blk_bs(blk), argv[1], argv[2]); 2071797ac58cSKevin Wolf if (ret < 0) { 2072797ac58cSKevin Wolf printf("Could not set breakpoint: %s\n", strerror(-ret)); 2073b32d7a39SMax Reitz return ret; 2074797ac58cSKevin Wolf } 2075797ac58cSKevin Wolf 2076b32d7a39SMax Reitz return 0; 2077b32d7a39SMax Reitz } 2078b32d7a39SMax Reitz 2079b32d7a39SMax Reitz static int remove_break_f(BlockBackend *blk, int argc, char **argv) 20804cc70e93SFam Zheng { 20814cc70e93SFam Zheng int ret; 20824cc70e93SFam Zheng 20834c7b7e9bSMax Reitz ret = bdrv_debug_remove_breakpoint(blk_bs(blk), argv[1]); 20844cc70e93SFam Zheng if (ret < 0) { 20854cc70e93SFam Zheng printf("Could not remove breakpoint %s: %s\n", argv[1], strerror(-ret)); 2086b32d7a39SMax Reitz return ret; 20874cc70e93SFam Zheng } 2088b32d7a39SMax Reitz 2089b32d7a39SMax Reitz return 0; 20904cc70e93SFam Zheng } 20914cc70e93SFam Zheng 2092797ac58cSKevin Wolf static const cmdinfo_t break_cmd = { 2093797ac58cSKevin Wolf .name = "break", 2094797ac58cSKevin Wolf .argmin = 2, 2095797ac58cSKevin Wolf .argmax = 2, 2096797ac58cSKevin Wolf .cfunc = break_f, 2097797ac58cSKevin Wolf .args = "event tag", 2098797ac58cSKevin Wolf .oneline = "sets a breakpoint on event and tags the stopped " 2099797ac58cSKevin Wolf "request as tag", 2100797ac58cSKevin Wolf }; 2101797ac58cSKevin Wolf 21024cc70e93SFam Zheng static const cmdinfo_t remove_break_cmd = { 21034cc70e93SFam Zheng .name = "remove_break", 21044cc70e93SFam Zheng .argmin = 1, 21054cc70e93SFam Zheng .argmax = 1, 21064cc70e93SFam Zheng .cfunc = remove_break_f, 21074cc70e93SFam Zheng .args = "tag", 21084cc70e93SFam Zheng .oneline = "remove a breakpoint by tag", 21094cc70e93SFam Zheng }; 21104cc70e93SFam Zheng 2111b32d7a39SMax Reitz static int resume_f(BlockBackend *blk, int argc, char **argv) 2112797ac58cSKevin Wolf { 2113797ac58cSKevin Wolf int ret; 2114797ac58cSKevin Wolf 21154c7b7e9bSMax Reitz ret = bdrv_debug_resume(blk_bs(blk), argv[1]); 2116797ac58cSKevin Wolf if (ret < 0) { 2117797ac58cSKevin Wolf printf("Could not resume request: %s\n", strerror(-ret)); 2118b32d7a39SMax Reitz return ret; 2119797ac58cSKevin Wolf } 2120b32d7a39SMax Reitz 2121b32d7a39SMax Reitz return 0; 2122797ac58cSKevin Wolf } 2123797ac58cSKevin Wolf 2124797ac58cSKevin Wolf static const cmdinfo_t resume_cmd = { 2125797ac58cSKevin Wolf .name = "resume", 2126797ac58cSKevin Wolf .argmin = 1, 2127797ac58cSKevin Wolf .argmax = 1, 2128797ac58cSKevin Wolf .cfunc = resume_f, 2129797ac58cSKevin Wolf .args = "tag", 2130797ac58cSKevin Wolf .oneline = "resumes the request tagged as tag", 2131797ac58cSKevin Wolf }; 2132797ac58cSKevin Wolf 2133b32d7a39SMax Reitz static int wait_break_f(BlockBackend *blk, int argc, char **argv) 2134797ac58cSKevin Wolf { 21354c7b7e9bSMax Reitz while (!bdrv_debug_is_suspended(blk_bs(blk), argv[1])) { 21364c7b7e9bSMax Reitz aio_poll(blk_get_aio_context(blk), true); 2137797ac58cSKevin Wolf } 2138b32d7a39SMax Reitz return 0; 2139797ac58cSKevin Wolf } 2140797ac58cSKevin Wolf 2141797ac58cSKevin Wolf static const cmdinfo_t wait_break_cmd = { 2142797ac58cSKevin Wolf .name = "wait_break", 2143797ac58cSKevin Wolf .argmin = 1, 2144797ac58cSKevin Wolf .argmax = 1, 2145797ac58cSKevin Wolf .cfunc = wait_break_f, 2146797ac58cSKevin Wolf .args = "tag", 2147797ac58cSKevin Wolf .oneline = "waits for the suspension of a request", 2148797ac58cSKevin Wolf }; 2149797ac58cSKevin Wolf 2150b32d7a39SMax Reitz static int abort_f(BlockBackend *blk, int argc, char **argv) 2151797ac58cSKevin Wolf { 2152797ac58cSKevin Wolf abort(); 2153797ac58cSKevin Wolf } 2154797ac58cSKevin Wolf 2155797ac58cSKevin Wolf static const cmdinfo_t abort_cmd = { 2156797ac58cSKevin Wolf .name = "abort", 2157797ac58cSKevin Wolf .cfunc = abort_f, 2158797ac58cSKevin Wolf .flags = CMD_NOFILE_OK, 2159797ac58cSKevin Wolf .oneline = "simulate a program crash using abort(3)", 2160797ac58cSKevin Wolf }; 2161797ac58cSKevin Wolf 21620e82dc7bSMax Reitz static void sigraise_help(void) 21630e82dc7bSMax Reitz { 21640e82dc7bSMax Reitz printf( 21650e82dc7bSMax Reitz "\n" 21660e82dc7bSMax Reitz " raises the given signal\n" 21670e82dc7bSMax Reitz "\n" 21680e82dc7bSMax Reitz " Example:\n" 21690e82dc7bSMax Reitz " 'sigraise %i' - raises SIGTERM\n" 21700e82dc7bSMax Reitz "\n" 21710e82dc7bSMax Reitz " Invokes raise(signal), where \"signal\" is the mandatory integer argument\n" 21720e82dc7bSMax Reitz " given to sigraise.\n" 21730e82dc7bSMax Reitz "\n", SIGTERM); 21740e82dc7bSMax Reitz } 21750e82dc7bSMax Reitz 2176b32d7a39SMax Reitz static int sigraise_f(BlockBackend *blk, int argc, char **argv); 21770e82dc7bSMax Reitz 21780e82dc7bSMax Reitz static const cmdinfo_t sigraise_cmd = { 21790e82dc7bSMax Reitz .name = "sigraise", 21800e82dc7bSMax Reitz .cfunc = sigraise_f, 21810e82dc7bSMax Reitz .argmin = 1, 21820e82dc7bSMax Reitz .argmax = 1, 21830e82dc7bSMax Reitz .flags = CMD_NOFILE_OK, 21840e82dc7bSMax Reitz .args = "signal", 21850e82dc7bSMax Reitz .oneline = "raises a signal", 21860e82dc7bSMax Reitz .help = sigraise_help, 21870e82dc7bSMax Reitz }; 21880e82dc7bSMax Reitz 2189b32d7a39SMax Reitz static int sigraise_f(BlockBackend *blk, int argc, char **argv) 21900e82dc7bSMax Reitz { 21919b0beaf3SJohn Snow int64_t sig = cvtnum(argv[1]); 21920e82dc7bSMax Reitz if (sig < 0) { 2193a9ecfa00SJohn Snow print_cvtnum_err(sig, argv[1]); 2194b32d7a39SMax Reitz return sig; 21959b0beaf3SJohn Snow } else if (sig > NSIG) { 21969b0beaf3SJohn Snow printf("signal argument '%s' is too large to be a valid signal\n", 21979b0beaf3SJohn Snow argv[1]); 2198b32d7a39SMax Reitz return -EINVAL; 21990e82dc7bSMax Reitz } 22000e82dc7bSMax Reitz 22010e82dc7bSMax Reitz /* Using raise() to kill this process does not necessarily flush all open 22020e82dc7bSMax Reitz * streams. At least stdout and stderr (although the latter should be 22030e82dc7bSMax Reitz * non-buffered anyway) should be flushed, though. */ 22040e82dc7bSMax Reitz fflush(stdout); 22050e82dc7bSMax Reitz fflush(stderr); 22060e82dc7bSMax Reitz 22070e82dc7bSMax Reitz raise(sig); 2208b32d7a39SMax Reitz 2209b32d7a39SMax Reitz return 0; 22100e82dc7bSMax Reitz } 22110e82dc7bSMax Reitz 2212cd33d02aSKevin Wolf static void sleep_cb(void *opaque) 2213cd33d02aSKevin Wolf { 2214cd33d02aSKevin Wolf bool *expired = opaque; 2215cd33d02aSKevin Wolf *expired = true; 2216cd33d02aSKevin Wolf } 2217cd33d02aSKevin Wolf 2218b32d7a39SMax Reitz static int sleep_f(BlockBackend *blk, int argc, char **argv) 2219cd33d02aSKevin Wolf { 2220cd33d02aSKevin Wolf char *endptr; 2221cd33d02aSKevin Wolf long ms; 2222cd33d02aSKevin Wolf struct QEMUTimer *timer; 2223cd33d02aSKevin Wolf bool expired = false; 2224cd33d02aSKevin Wolf 2225cd33d02aSKevin Wolf ms = strtol(argv[1], &endptr, 0); 2226cd33d02aSKevin Wolf if (ms < 0 || *endptr != '\0') { 2227cd33d02aSKevin Wolf printf("%s is not a valid number\n", argv[1]); 2228b32d7a39SMax Reitz return -EINVAL; 2229cd33d02aSKevin Wolf } 2230cd33d02aSKevin Wolf 2231cd33d02aSKevin Wolf timer = timer_new_ns(QEMU_CLOCK_HOST, sleep_cb, &expired); 2232cd33d02aSKevin Wolf timer_mod(timer, qemu_clock_get_ns(QEMU_CLOCK_HOST) + SCALE_MS * ms); 2233cd33d02aSKevin Wolf 2234cd33d02aSKevin Wolf while (!expired) { 2235cd33d02aSKevin Wolf main_loop_wait(false); 2236cd33d02aSKevin Wolf } 2237cd33d02aSKevin Wolf 2238cd33d02aSKevin Wolf timer_free(timer); 2239b32d7a39SMax Reitz return 0; 2240cd33d02aSKevin Wolf } 2241cd33d02aSKevin Wolf 2242cd33d02aSKevin Wolf static const cmdinfo_t sleep_cmd = { 2243cd33d02aSKevin Wolf .name = "sleep", 2244cd33d02aSKevin Wolf .argmin = 1, 2245cd33d02aSKevin Wolf .argmax = 1, 2246cd33d02aSKevin Wolf .cfunc = sleep_f, 2247cd33d02aSKevin Wolf .flags = CMD_NOFILE_OK, 2248cd33d02aSKevin Wolf .oneline = "waits for the given value in milliseconds", 2249cd33d02aSKevin Wolf }; 2250cd33d02aSKevin Wolf 2251f18a834aSKevin Wolf static void help_oneline(const char *cmd, const cmdinfo_t *ct) 2252f18a834aSKevin Wolf { 2253f18a834aSKevin Wolf if (cmd) { 2254f18a834aSKevin Wolf printf("%s ", cmd); 2255f18a834aSKevin Wolf } else { 2256f18a834aSKevin Wolf printf("%s ", ct->name); 2257f18a834aSKevin Wolf if (ct->altname) { 2258f18a834aSKevin Wolf printf("(or %s) ", ct->altname); 2259f18a834aSKevin Wolf } 2260f18a834aSKevin Wolf } 2261f18a834aSKevin Wolf 2262f18a834aSKevin Wolf if (ct->args) { 2263f18a834aSKevin Wolf printf("%s ", ct->args); 2264f18a834aSKevin Wolf } 2265f18a834aSKevin Wolf printf("-- %s\n", ct->oneline); 2266f18a834aSKevin Wolf } 2267f18a834aSKevin Wolf 2268f18a834aSKevin Wolf static void help_onecmd(const char *cmd, const cmdinfo_t *ct) 2269f18a834aSKevin Wolf { 2270f18a834aSKevin Wolf help_oneline(cmd, ct); 2271f18a834aSKevin Wolf if (ct->help) { 2272f18a834aSKevin Wolf ct->help(); 2273f18a834aSKevin Wolf } 2274f18a834aSKevin Wolf } 2275f18a834aSKevin Wolf 2276f18a834aSKevin Wolf static void help_all(void) 2277f18a834aSKevin Wolf { 2278f18a834aSKevin Wolf const cmdinfo_t *ct; 2279f18a834aSKevin Wolf 2280f18a834aSKevin Wolf for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 2281f18a834aSKevin Wolf help_oneline(ct->name, ct); 2282f18a834aSKevin Wolf } 2283f18a834aSKevin Wolf printf("\nUse 'help commandname' for extended help.\n"); 2284f18a834aSKevin Wolf } 2285f18a834aSKevin Wolf 2286b32d7a39SMax Reitz static int help_f(BlockBackend *blk, int argc, char **argv) 2287f18a834aSKevin Wolf { 2288f18a834aSKevin Wolf const cmdinfo_t *ct; 2289f18a834aSKevin Wolf 2290f18a834aSKevin Wolf if (argc == 1) { 2291f18a834aSKevin Wolf help_all(); 2292b32d7a39SMax Reitz return 0; 2293f18a834aSKevin Wolf } 2294f18a834aSKevin Wolf 2295f18a834aSKevin Wolf ct = find_command(argv[1]); 2296f18a834aSKevin Wolf if (ct == NULL) { 2297f18a834aSKevin Wolf printf("command %s not found\n", argv[1]); 2298b32d7a39SMax Reitz return -EINVAL; 2299f18a834aSKevin Wolf } 2300f18a834aSKevin Wolf 2301f18a834aSKevin Wolf help_onecmd(argv[1], ct); 2302b32d7a39SMax Reitz return 0; 2303f18a834aSKevin Wolf } 2304f18a834aSKevin Wolf 2305f18a834aSKevin Wolf static const cmdinfo_t help_cmd = { 2306f18a834aSKevin Wolf .name = "help", 2307f18a834aSKevin Wolf .altname = "?", 2308f18a834aSKevin Wolf .cfunc = help_f, 2309f18a834aSKevin Wolf .argmin = 0, 2310f18a834aSKevin Wolf .argmax = 1, 2311f18a834aSKevin Wolf .flags = CMD_FLAG_GLOBAL, 2312f18a834aSKevin Wolf .args = "[command]", 2313f18a834aSKevin Wolf .oneline = "help for one or all commands", 2314f18a834aSKevin Wolf }; 2315f18a834aSKevin Wolf 2316b32d7a39SMax Reitz int qemuio_command(BlockBackend *blk, const char *cmd) 2317dd583296SKevin Wolf { 231815afd94aSPaolo Bonzini AioContext *ctx; 2319dd583296SKevin Wolf char *input; 2320dd583296SKevin Wolf const cmdinfo_t *ct; 2321dd583296SKevin Wolf char **v; 2322dd583296SKevin Wolf int c; 2323b32d7a39SMax Reitz int ret = 0; 2324dd583296SKevin Wolf 2325dd583296SKevin Wolf input = g_strdup(cmd); 2326dd583296SKevin Wolf v = breakline(input, &c); 2327dd583296SKevin Wolf if (c) { 2328dd583296SKevin Wolf ct = find_command(v[0]); 2329dd583296SKevin Wolf if (ct) { 233015afd94aSPaolo Bonzini ctx = blk ? blk_get_aio_context(blk) : qemu_get_aio_context(); 233115afd94aSPaolo Bonzini aio_context_acquire(ctx); 2332b32d7a39SMax Reitz ret = command(blk, ct, c, v); 233315afd94aSPaolo Bonzini aio_context_release(ctx); 2334dd583296SKevin Wolf } else { 2335dd583296SKevin Wolf fprintf(stderr, "command \"%s\" not found\n", v[0]); 2336b32d7a39SMax Reitz ret = -EINVAL; 2337dd583296SKevin Wolf } 2338dd583296SKevin Wolf } 2339dd583296SKevin Wolf g_free(input); 2340dd583296SKevin Wolf g_free(v); 2341b32d7a39SMax Reitz 2342b32d7a39SMax Reitz return ret; 2343dd583296SKevin Wolf } 2344dd583296SKevin Wolf 2345797ac58cSKevin Wolf static void __attribute((constructor)) init_qemuio_commands(void) 2346797ac58cSKevin Wolf { 2347797ac58cSKevin Wolf /* initialize commands */ 2348c2cdf5c5SKevin Wolf qemuio_add_command(&help_cmd); 2349c2cdf5c5SKevin Wolf qemuio_add_command(&read_cmd); 2350c2cdf5c5SKevin Wolf qemuio_add_command(&readv_cmd); 2351c2cdf5c5SKevin Wolf qemuio_add_command(&write_cmd); 2352c2cdf5c5SKevin Wolf qemuio_add_command(&writev_cmd); 2353c2cdf5c5SKevin Wolf qemuio_add_command(&aio_read_cmd); 2354c2cdf5c5SKevin Wolf qemuio_add_command(&aio_write_cmd); 2355c2cdf5c5SKevin Wolf qemuio_add_command(&aio_flush_cmd); 2356c2cdf5c5SKevin Wolf qemuio_add_command(&flush_cmd); 2357c2cdf5c5SKevin Wolf qemuio_add_command(&truncate_cmd); 2358c2cdf5c5SKevin Wolf qemuio_add_command(&length_cmd); 2359c2cdf5c5SKevin Wolf qemuio_add_command(&info_cmd); 2360c2cdf5c5SKevin Wolf qemuio_add_command(&discard_cmd); 2361c2cdf5c5SKevin Wolf qemuio_add_command(&alloc_cmd); 2362c2cdf5c5SKevin Wolf qemuio_add_command(&map_cmd); 23635bbd2e59SKevin Wolf qemuio_add_command(&reopen_cmd); 2364c2cdf5c5SKevin Wolf qemuio_add_command(&break_cmd); 23654cc70e93SFam Zheng qemuio_add_command(&remove_break_cmd); 2366c2cdf5c5SKevin Wolf qemuio_add_command(&resume_cmd); 2367c2cdf5c5SKevin Wolf qemuio_add_command(&wait_break_cmd); 2368c2cdf5c5SKevin Wolf qemuio_add_command(&abort_cmd); 2369cd33d02aSKevin Wolf qemuio_add_command(&sleep_cmd); 23700e82dc7bSMax Reitz qemuio_add_command(&sigraise_cmd); 2371797ac58cSKevin Wolf } 2372