qemu-io-cmds.c

   1 /*
   2  * Command line utility to exercise the QEMU I/O path.
   3  *
   4  * Copyright (C) 2009 Red Hat, Inc.
   5  * Copyright (c) 2003-2005 Silicon Graphics, Inc.
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   8  * See the COPYING file in the top-level directory.
   9  */
  10
  11 #include "qemu-io.h"
  12 #include "block/block_int.h"
  13
  14 #define CMD_NOFILE_OK   0x01
  15
  16 int qemuio_misalign;
  17
  18 static cmdinfo_t *cmdtab;
  19 static int ncmds;
  20
  21 static int compare_cmdname(const void *a, const void *b)
  22 {
  23     return strcmp(((const cmdinfo_t *)a)->name,
  24                   ((const cmdinfo_t *)b)->name);
  25 }
  26
  27 void qemuio_add_command(const cmdinfo_t *ci)
  28 {
  29     cmdtab = g_realloc(cmdtab, ++ncmds * sizeof(*cmdtab));
  30     cmdtab[ncmds - 1] = *ci;
  31     qsort(cmdtab, ncmds, sizeof(*cmdtab), compare_cmdname);
  32 }
  33
  34 int qemuio_command_usage(const cmdinfo_t *ci)
  35 {
  36     printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);
  37     return 0;
  38 }
  39
  40 static int init_check_command(BlockDriverState *bs, const cmdinfo_t *ct)
  41 {
  42     if (ct->flags & CMD_FLAG_GLOBAL) {
  43         return 1;
  44     }
  45     if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
  46         fprintf(stderr, "no file open, try 'help open'\n");
  47         return 0;
  48     }
  49     return 1;
  50 }
  51
  52 static int command(BlockDriverState *bs, const cmdinfo_t *ct, int argc,
  53                    char **argv)
  54 {
  55     char *cmd = argv[0];
  56
  57     if (!init_check_command(bs, ct)) {
  58         return 0;
  59     }
  60
  61     if (argc - 1 < ct->argmin || (ct->argmax != -1 && argc - 1 > ct->argmax)) {
  62         if (ct->argmax == -1) {
  63             fprintf(stderr,
  64                     "bad argument count %d to %s, expected at least %d arguments\n",
  65                     argc-1, cmd, ct->argmin);
  66         } else if (ct->argmin == ct->argmax) {
  67             fprintf(stderr,
  68                     "bad argument count %d to %s, expected %d arguments\n",
  69                     argc-1, cmd, ct->argmin);
  70         } else {
  71             fprintf(stderr,
  72                     "bad argument count %d to %s, expected between %d and %d arguments\n",
  73                     argc-1, cmd, ct->argmin, ct->argmax);
  74         }
  75         return 0;
  76     }
  77     optind = 0;
  78     return ct->cfunc(bs, argc, argv);
  79 }
  80
  81 static const cmdinfo_t *find_command(const char *cmd)
  82 {
  83     cmdinfo_t *ct;
  84
  85     for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
  86         if (strcmp(ct->name, cmd) == 0 ||
  87             (ct->altname && strcmp(ct->altname, cmd) == 0))
  88         {
  89             return (const cmdinfo_t *)ct;
  90         }
  91     }
  92     return NULL;
  93 }
  94
  95 static char **breakline(char *input, int *count)
  96 {
  97     int c = 0;
  98     char *p;
  99     char **rval = g_malloc0(sizeof(char *));
 100     char **tmp;
 101
 102     while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
 103         if (!*p) {
 104             continue;
 105         }
 106         c++;
 107         tmp = g_realloc(rval, sizeof(*rval) * (c + 1));
 108         if (!tmp) {
 109             g_free(rval);
 110             rval = NULL;
 111             c = 0;
 112             break;
 113         } else {
 114             rval = tmp;
 115         }
 116         rval[c - 1] = p;
 117         rval[c] = NULL;
 118     }
 119     *count = c;
 120     return rval;
 121 }
 122
 123 static int64_t cvtnum(const char *s)
 124 {
 125     char *end;
 126     return strtosz_suffix(s, &end, STRTOSZ_DEFSUFFIX_B);
 127 }
 128
 129 #define EXABYTES(x)     ((long long)(x) << 60)
 130 #define PETABYTES(x)    ((long long)(x) << 50)
 131 #define TERABYTES(x)    ((long long)(x) << 40)
 132 #define GIGABYTES(x)    ((long long)(x) << 30)
 133 #define MEGABYTES(x)    ((long long)(x) << 20)
 134 #define KILOBYTES(x)    ((long long)(x) << 10)
 135
 136 #define TO_EXABYTES(x)  ((x) / EXABYTES(1))
 137 #define TO_PETABYTES(x) ((x) / PETABYTES(1))
 138 #define TO_TERABYTES(x) ((x) / TERABYTES(1))
 139 #define TO_GIGABYTES(x) ((x) / GIGABYTES(1))
 140 #define TO_MEGABYTES(x) ((x) / MEGABYTES(1))
 141 #define TO_KILOBYTES(x) ((x) / KILOBYTES(1))
 142
 143 static void cvtstr(double value, char *str, size_t size)
 144 {
 145     char *trim;
 146     const char *suffix;
 147
 148     if (value >= EXABYTES(1)) {
 149         suffix = " EiB";
 150         snprintf(str, size - 4, "%.3f", TO_EXABYTES(value));
 151     } else if (value >= PETABYTES(1)) {
 152         suffix = " PiB";
 153         snprintf(str, size - 4, "%.3f", TO_PETABYTES(value));
 154     } else if (value >= TERABYTES(1)) {
 155         suffix = " TiB";
 156         snprintf(str, size - 4, "%.3f", TO_TERABYTES(value));
 157     } else if (value >= GIGABYTES(1)) {
 158         suffix = " GiB";
 159         snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value));
 160     } else if (value >= MEGABYTES(1)) {
 161         suffix = " MiB";
 162         snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value));
 163     } else if (value >= KILOBYTES(1)) {
 164         suffix = " KiB";
 165         snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value));
 166     } else {
 167         suffix = " bytes";
 168         snprintf(str, size - 6, "%f", value);
 169     }
 170
 171     trim = strstr(str, ".000");
 172     if (trim) {
 173         strcpy(trim, suffix);
 174     } else {
 175         strcat(str, suffix);
 176     }
 177 }
 178
 179
 180
 181 static struct timeval tsub(struct timeval t1, struct timeval t2)
 182 {
 183     t1.tv_usec -= t2.tv_usec;
 184     if (t1.tv_usec < 0) {
 185         t1.tv_usec += 1000000;
 186         t1.tv_sec--;
 187     }
 188     t1.tv_sec -= t2.tv_sec;
 189     return t1;
 190 }
 191
 192 static double tdiv(double value, struct timeval tv)
 193 {
 194     return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
 195 }
 196
 197 #define HOURS(sec)      ((sec) / (60 * 60))
 198 #define MINUTES(sec)    (((sec) % (60 * 60)) / 60)
 199 #define SECONDS(sec)    ((sec) % 60)
 200
 201 enum {
 202     DEFAULT_TIME        = 0x0,
 203     TERSE_FIXED_TIME    = 0x1,
 204     VERBOSE_FIXED_TIME  = 0x2,
 205 };
 206
 207 static void timestr(struct timeval *tv, char *ts, size_t size, int format)
 208 {
 209     double usec = (double)tv->tv_usec / 1000000.0;
 210
 211     if (format & TERSE_FIXED_TIME) {
 212         if (!HOURS(tv->tv_sec)) {
 213             snprintf(ts, size, "%u:%02u.%02u",
 214                     (unsigned int) MINUTES(tv->tv_sec),
 215                     (unsigned int) SECONDS(tv->tv_sec),
 216                     (unsigned int) (usec * 100));
 217             return;
 218         }
 219         format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */
 220     }
 221
 222     if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) {
 223         snprintf(ts, size, "%u:%02u:%02u.%02u",
 224                 (unsigned int) HOURS(tv->tv_sec),
 225                 (unsigned int) MINUTES(tv->tv_sec),
 226                 (unsigned int) SECONDS(tv->tv_sec),
 227                 (unsigned int) (usec * 100));
 228     } else {
 229         snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
 230     }
 231 }
 232
 233 /*
 234  * Parse the pattern argument to various sub-commands.
 235  *
 236  * Because the pattern is used as an argument to memset it must evaluate
 237  * to an unsigned integer that fits into a single byte.
 238  */
 239 static int parse_pattern(const char *arg)
 240 {
 241     char *endptr = NULL;
 242     long pattern;
 243
 244     pattern = strtol(arg, &endptr, 0);
 245     if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {
 246         printf("%s is not a valid pattern byte\n", arg);
 247         return -1;
 248     }
 249
 250     return pattern;
 251 }
 252
 253 /*
 254  * Memory allocation helpers.
 255  *
 256  * Make sure memory is aligned by default, or purposefully misaligned if
 257  * that is specified on the command line.
 258  */
 259
 260 #define MISALIGN_OFFSET     16
 261 static void *qemu_io_alloc(BlockDriverState *bs, size_t len, int pattern)
 262 {
 263     void *buf;
 264
 265     if (qemuio_misalign) {
 266         len += MISALIGN_OFFSET;
 267     }
 268     buf = qemu_blockalign(bs, len);
 269     memset(buf, pattern, len);
 270     if (qemuio_misalign) {
 271         buf += MISALIGN_OFFSET;
 272     }
 273     return buf;
 274 }
 275
 276 static void qemu_io_free(void *p)
 277 {
 278     if (qemuio_misalign) {
 279         p -= MISALIGN_OFFSET;
 280     }
 281     qemu_vfree(p);
 282 }
 283
 284 static void dump_buffer(const void *buffer, int64_t offset, int len)
 285 {
 286     int i, j;
 287     const uint8_t *p;
 288
 289     for (i = 0, p = buffer; i < len; i += 16) {
 290         const uint8_t *s = p;
 291
 292         printf("%08" PRIx64 ":  ", offset + i);
 293         for (j = 0; j < 16 && i + j < len; j++, p++) {
 294             printf("%02x ", *p);
 295         }
 296         printf(" ");
 297         for (j = 0; j < 16 && i + j < len; j++, s++) {
 298             if (isalnum(*s)) {
 299                 printf("%c", *s);
 300             } else {
 301                 printf(".");
 302             }
 303         }
 304         printf("\n");
 305     }
 306 }
 307
 308 static void print_report(const char *op, struct timeval *t, int64_t offset,
 309                          int count, int total, int cnt, int Cflag)
 310 {
 311     char s1[64], s2[64], ts[64];
 312
 313     timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
 314     if (!Cflag) {
 315         cvtstr((double)total, s1, sizeof(s1));
 316         cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
 317         printf("%s %d/%d bytes at offset %" PRId64 "\n",
 318                op, total, count, offset);
 319         printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
 320                s1, cnt, ts, s2, tdiv((double)cnt, *t));
 321     } else {/* bytes,ops,time,bytes/sec,ops/sec */
 322         printf("%d,%d,%s,%.3f,%.3f\n",
 323             total, cnt, ts,
 324             tdiv((double)total, *t),
 325             tdiv((double)cnt, *t));
 326     }
 327 }
 328
 329 /*
 330  * Parse multiple length statements for vectored I/O, and construct an I/O
 331  * vector matching it.
 332  */
 333 static void *
 334 create_iovec(BlockDriverState *bs, QEMUIOVector *qiov, char **argv, int nr_iov,
 335              int pattern)
 336 {
 337     size_t *sizes = g_new0(size_t, nr_iov);
 338     size_t count = 0;
 339     void *buf = NULL;
 340     void *p;
 341     int i;
 342
 343     for (i = 0; i < nr_iov; i++) {
 344         char *arg = argv[i];
 345         int64_t len;
 346
 347         len = cvtnum(arg);
 348         if (len < 0) {
 349             printf("non-numeric length argument -- %s\n", arg);
 350             goto fail;
 351         }
 352
 353         /* should be SIZE_T_MAX, but that doesn't exist */
 354         if (len > INT_MAX) {
 355             printf("too large length argument -- %s\n", arg);
 356             goto fail;
 357         }
 358
 359         if (len & 0x1ff) {
 360             printf("length argument %" PRId64
 361                    " is not sector aligned\n", len);
 362             goto fail;
 363         }
 364
 365         sizes[i] = len;
 366         count += len;
 367     }
 368
 369     qemu_iovec_init(qiov, nr_iov);
 370
 371     buf = p = qemu_io_alloc(bs, count, pattern);
 372
 373     for (i = 0; i < nr_iov; i++) {
 374         qemu_iovec_add(qiov, p, sizes[i]);
 375         p += sizes[i];
 376     }
 377
 378 fail:
 379     g_free(sizes);
 380     return buf;
 381 }
 382
 383 static int do_read(BlockDriverState *bs, char *buf, int64_t offset, int count,
 384                    int *total)
 385 {
 386     int ret;
 387
 388     ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
 389     if (ret < 0) {
 390         return ret;
 391     }
 392     *total = count;
 393     return 1;
 394 }
 395
 396 static int do_write(BlockDriverState *bs, char *buf, int64_t offset, int count,
 397                     int *total)
 398 {
 399     int ret;
 400
 401     ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
 402     if (ret < 0) {
 403         return ret;
 404     }
 405     *total = count;
 406     return 1;
 407 }
 408
 409 static int do_pread(BlockDriverState *bs, char *buf, int64_t offset, int count,
 410                     int *total)
 411 {
 412     *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
 413     if (*total < 0) {
 414         return *total;
 415     }
 416     return 1;
 417 }
 418
 419 static int do_pwrite(BlockDriverState *bs, char *buf, int64_t offset, int count,
 420                      int *total)
 421 {
 422     *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
 423     if (*total < 0) {
 424         return *total;
 425     }
 426     return 1;
 427 }
 428
 429 typedef struct {
 430     BlockDriverState *bs;
 431     int64_t offset;
 432     int count;
 433     int *total;
 434     int ret;
 435     bool done;
 436 } CoWriteZeroes;
 437
 438 static void coroutine_fn co_write_zeroes_entry(void *opaque)
 439 {
 440     CoWriteZeroes *data = opaque;
 441
 442     data->ret = bdrv_co_write_zeroes(data->bs, data->offset / BDRV_SECTOR_SIZE,
 443                                      data->count / BDRV_SECTOR_SIZE);
 444     data->done = true;
 445     if (data->ret < 0) {
 446         *data->total = data->ret;
 447         return;
 448     }
 449
 450     *data->total = data->count;
 451 }
 452
 453 static int do_co_write_zeroes(BlockDriverState *bs, int64_t offset, int count,
 454                               int *total)
 455 {
 456     Coroutine *co;
 457     CoWriteZeroes data = {
 458         .bs     = bs,
 459         .offset = offset,
 460         .count  = count,
 461         .total  = total,
 462         .done   = false,
 463     };
 464
 465     co = qemu_coroutine_create(co_write_zeroes_entry);
 466     qemu_coroutine_enter(co, &data);
 467     while (!data.done) {
 468         qemu_aio_wait();
 469     }
 470     if (data.ret < 0) {
 471         return data.ret;
 472     } else {
 473         return 1;
 474     }
 475 }
 476
 477 static int do_write_compressed(BlockDriverState *bs, char *buf, int64_t offset,
 478                                int count, int *total)
 479 {
 480     int ret;
 481
 482     ret = bdrv_write_compressed(bs, offset >> 9, (uint8_t *)buf, count >> 9);
 483     if (ret < 0) {
 484         return ret;
 485     }
 486     *total = count;
 487     return 1;
 488 }
 489
 490 static int do_load_vmstate(BlockDriverState *bs, char *buf, int64_t offset,
 491                            int count, int *total)
 492 {
 493     *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
 494     if (*total < 0) {
 495         return *total;
 496     }
 497     return 1;
 498 }
 499
 500 static int do_save_vmstate(BlockDriverState *bs, char *buf, int64_t offset,
 501                            int count, int *total)
 502 {
 503     *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
 504     if (*total < 0) {
 505         return *total;
 506     }
 507     return 1;
 508 }
 509
 510 #define NOT_DONE 0x7fffffff
 511 static void aio_rw_done(void *opaque, int ret)
 512 {
 513     *(int *)opaque = ret;
 514 }
 515
 516 static int do_aio_readv(BlockDriverState *bs, QEMUIOVector *qiov,
 517                         int64_t offset, int *total)
 518 {
 519     int async_ret = NOT_DONE;
 520
 521     bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
 522                    aio_rw_done, &async_ret);
 523     while (async_ret == NOT_DONE) {
 524         main_loop_wait(false);
 525     }
 526
 527     *total = qiov->size;
 528     return async_ret < 0 ? async_ret : 1;
 529 }
 530
 531 static int do_aio_writev(BlockDriverState *bs, QEMUIOVector *qiov,
 532                          int64_t offset, int *total)
 533 {
 534     int async_ret = NOT_DONE;
 535
 536     bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
 537                     aio_rw_done, &async_ret);
 538     while (async_ret == NOT_DONE) {
 539         main_loop_wait(false);
 540     }
 541
 542     *total = qiov->size;
 543     return async_ret < 0 ? async_ret : 1;
 544 }
 545
 546 struct multiwrite_async_ret {
 547     int num_done;
 548     int error;
 549 };
 550
 551 static void multiwrite_cb(void *opaque, int ret)
 552 {
 553     struct multiwrite_async_ret *async_ret = opaque;
 554
 555     async_ret->num_done++;
 556     if (ret < 0) {
 557         async_ret->error = ret;
 558     }
 559 }
 560
 561 static int do_aio_multiwrite(BlockDriverState *bs, BlockRequest* reqs,
 562                              int num_reqs, int *total)
 563 {
 564     int i, ret;
 565     struct multiwrite_async_ret async_ret = {
 566         .num_done = 0,
 567         .error = 0,
 568     };
 569
 570     *total = 0;
 571     for (i = 0; i < num_reqs; i++) {
 572         reqs[i].cb = multiwrite_cb;
 573         reqs[i].opaque = &async_ret;
 574         *total += reqs[i].qiov->size;
 575     }
 576
 577     ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
 578     if (ret < 0) {
 579         return ret;
 580     }
 581
 582     while (async_ret.num_done < num_reqs) {
 583         main_loop_wait(false);
 584     }
 585
 586     return async_ret.error < 0 ? async_ret.error : 1;
 587 }
 588
 589 static void read_help(void)
 590 {
 591     printf(
 592 "\n"
 593 " reads a range of bytes from the given offset\n"
 594 "\n"
 595 " Example:\n"
 596 " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
 597 "\n"
 598 " Reads a segment of the currently open file, optionally dumping it to the\n"
 599 " standard output stream (with -v option) for subsequent inspection.\n"
 600 " -b, -- read from the VM state rather than the virtual disk\n"
 601 " -C, -- report statistics in a machine parsable format\n"
 602 " -l, -- length for pattern verification (only with -P)\n"
 603 " -p, -- use bdrv_pread to read the file\n"
 604 " -P, -- use a pattern to verify read data\n"
 605 " -q, -- quiet mode, do not show I/O statistics\n"
 606 " -s, -- start offset for pattern verification (only with -P)\n"
 607 " -v, -- dump buffer to standard output\n"
 608 "\n");
 609 }
 610
 611 static int read_f(BlockDriverState *bs, int argc, char **argv);
 612
 613 static const cmdinfo_t read_cmd = {
 614     .name       = "read",
 615     .altname    = "r",
 616     .cfunc      = read_f,
 617     .argmin     = 2,
 618     .argmax     = -1,
 619     .args       = "[-abCpqv] [-P pattern [-s off] [-l len]] off len",
 620     .oneline    = "reads a number of bytes at a specified offset",
 621     .help       = read_help,
 622 };
 623
 624 static int read_f(BlockDriverState *bs, int argc, char **argv)
 625 {
 626     struct timeval t1, t2;
 627     int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
 628     int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
 629     int c, cnt;
 630     char *buf;
 631     int64_t offset;
 632     int count;
 633     /* Some compilers get confused and warn if this is not initialized.  */
 634     int total = 0;
 635     int pattern = 0, pattern_offset = 0, pattern_count = 0;
 636
 637     while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
 638         switch (c) {
 639         case 'b':
 640             bflag = 1;
 641             break;
 642         case 'C':
 643             Cflag = 1;
 644             break;
 645         case 'l':
 646             lflag = 1;
 647             pattern_count = cvtnum(optarg);
 648             if (pattern_count < 0) {
 649                 printf("non-numeric length argument -- %s\n", optarg);
 650                 return 0;
 651             }
 652             break;
 653         case 'p':
 654             pflag = 1;
 655             break;
 656         case 'P':
 657             Pflag = 1;
 658             pattern = parse_pattern(optarg);
 659             if (pattern < 0) {
 660                 return 0;
 661             }
 662             break;
 663         case 'q':
 664             qflag = 1;
 665             break;
 666         case 's':
 667             sflag = 1;
 668             pattern_offset = cvtnum(optarg);
 669             if (pattern_offset < 0) {
 670                 printf("non-numeric length argument -- %s\n", optarg);
 671                 return 0;
 672             }
 673             break;
 674         case 'v':
 675             vflag = 1;
 676             break;
 677         default:
 678             return qemuio_command_usage(&read_cmd);
 679         }
 680     }
 681
 682     if (optind != argc - 2) {
 683         return qemuio_command_usage(&read_cmd);
 684     }
 685
 686     if (bflag && pflag) {
 687         printf("-b and -p cannot be specified at the same time\n");
 688         return 0;
 689     }
 690
 691     offset = cvtnum(argv[optind]);
 692     if (offset < 0) {
 693         printf("non-numeric length argument -- %s\n", argv[optind]);
 694         return 0;
 695     }
 696
 697     optind++;
 698     count = cvtnum(argv[optind]);
 699     if (count < 0) {
 700         printf("non-numeric length argument -- %s\n", argv[optind]);
 701         return 0;
 702     }
 703
 704     if (!Pflag && (lflag || sflag)) {
 705         return qemuio_command_usage(&read_cmd);
 706     }
 707
 708     if (!lflag) {
 709         pattern_count = count - pattern_offset;
 710     }
 711
 712     if ((pattern_count < 0) || (pattern_count + pattern_offset > count))  {
 713         printf("pattern verification range exceeds end of read data\n");
 714         return 0;
 715     }
 716
 717     if (!pflag) {
 718         if (offset & 0x1ff) {
 719             printf("offset %" PRId64 " is not sector aligned\n",
 720                    offset);
 721             return 0;
 722         }
 723         if (count & 0x1ff) {
 724             printf("count %d is not sector aligned\n",
 725                    count);
 726             return 0;
 727         }
 728     }
 729
 730     buf = qemu_io_alloc(bs, count, 0xab);
 731
 732     gettimeofday(&t1, NULL);
 733     if (pflag) {
 734         cnt = do_pread(bs, buf, offset, count, &total);
 735     } else if (bflag) {
 736         cnt = do_load_vmstate(bs, buf, offset, count, &total);
 737     } else {
 738         cnt = do_read(bs, buf, offset, count, &total);
 739     }
 740     gettimeofday(&t2, NULL);
 741
 742     if (cnt < 0) {
 743         printf("read failed: %s\n", strerror(-cnt));
 744         goto out;
 745     }
 746
 747     if (Pflag) {
 748         void *cmp_buf = g_malloc(pattern_count);
 749         memset(cmp_buf, pattern, pattern_count);
 750         if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
 751             printf("Pattern verification failed at offset %"
 752                    PRId64 ", %d bytes\n",
 753                    offset + pattern_offset, pattern_count);
 754         }
 755         g_free(cmp_buf);
 756     }
 757
 758     if (qflag) {
 759         goto out;
 760     }
 761
 762     if (vflag) {
 763         dump_buffer(buf, offset, count);
 764     }
 765
 766     /* Finally, report back -- -C gives a parsable format */
 767     t2 = tsub(t2, t1);
 768     print_report("read", &t2, offset, count, total, cnt, Cflag);
 769
 770 out:
 771     qemu_io_free(buf);
 772
 773     return 0;
 774 }
 775
 776 static void readv_help(void)
 777 {
 778     printf(
 779 "\n"
 780 " reads a range of bytes from the given offset into multiple buffers\n"
 781 "\n"
 782 " Example:\n"
 783 " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
 784 "\n"
 785 " Reads a segment of the currently open file, optionally dumping it to the\n"
 786 " standard output stream (with -v option) for subsequent inspection.\n"
 787 " Uses multiple iovec buffers if more than one byte range is specified.\n"
 788 " -C, -- report statistics in a machine parsable format\n"
 789 " -P, -- use a pattern to verify read data\n"
 790 " -v, -- dump buffer to standard output\n"
 791 " -q, -- quiet mode, do not show I/O statistics\n"
 792 "\n");
 793 }
 794
 795 static int readv_f(BlockDriverState *bs, int argc, char **argv);
 796
 797 static const cmdinfo_t readv_cmd = {
 798     .name       = "readv",
 799     .cfunc      = readv_f,
 800     .argmin     = 2,
 801     .argmax     = -1,
 802     .args       = "[-Cqv] [-P pattern ] off len [len..]",
 803     .oneline    = "reads a number of bytes at a specified offset",
 804     .help       = readv_help,
 805 };
 806
 807 static int readv_f(BlockDriverState *bs, int argc, char **argv)
 808 {
 809     struct timeval t1, t2;
 810     int Cflag = 0, qflag = 0, vflag = 0;
 811     int c, cnt;
 812     char *buf;
 813     int64_t offset;
 814     /* Some compilers get confused and warn if this is not initialized.  */
 815     int total = 0;
 816     int nr_iov;
 817     QEMUIOVector qiov;
 818     int pattern = 0;
 819     int Pflag = 0;
 820
 821     while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
 822         switch (c) {
 823         case 'C':
 824             Cflag = 1;
 825             break;
 826         case 'P':
 827             Pflag = 1;
 828             pattern = parse_pattern(optarg);
 829             if (pattern < 0) {
 830                 return 0;
 831             }
 832             break;
 833         case 'q':
 834             qflag = 1;
 835             break;
 836         case 'v':
 837             vflag = 1;
 838             break;
 839         default:
 840             return qemuio_command_usage(&readv_cmd);
 841         }
 842     }
 843
 844     if (optind > argc - 2) {
 845         return qemuio_command_usage(&readv_cmd);
 846     }
 847
 848
 849     offset = cvtnum(argv[optind]);
 850     if (offset < 0) {
 851         printf("non-numeric length argument -- %s\n", argv[optind]);
 852         return 0;
 853     }
 854     optind++;
 855
 856     if (offset & 0x1ff) {
 857         printf("offset %" PRId64 " is not sector aligned\n",
 858                offset);
 859         return 0;
 860     }
 861
 862     nr_iov = argc - optind;
 863     buf = create_iovec(bs, &qiov, &argv[optind], nr_iov, 0xab);
 864     if (buf == NULL) {
 865         return 0;
 866     }
 867
 868     gettimeofday(&t1, NULL);
 869     cnt = do_aio_readv(bs, &qiov, offset, &total);
 870     gettimeofday(&t2, NULL);
 871
 872     if (cnt < 0) {
 873         printf("readv failed: %s\n", strerror(-cnt));
 874         goto out;
 875     }
 876
 877     if (Pflag) {
 878         void *cmp_buf = g_malloc(qiov.size);
 879         memset(cmp_buf, pattern, qiov.size);
 880         if (memcmp(buf, cmp_buf, qiov.size)) {
 881             printf("Pattern verification failed at offset %"
 882                    PRId64 ", %zd bytes\n", offset, qiov.size);
 883         }
 884         g_free(cmp_buf);
 885     }
 886
 887     if (qflag) {
 888         goto out;
 889     }
 890
 891     if (vflag) {
 892         dump_buffer(buf, offset, qiov.size);
 893     }
 894
 895     /* Finally, report back -- -C gives a parsable format */
 896     t2 = tsub(t2, t1);
 897     print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
 898
 899 out:
 900     qemu_iovec_destroy(&qiov);
 901     qemu_io_free(buf);
 902     return 0;
 903 }
 904
 905 static void write_help(void)
 906 {
 907     printf(
 908 "\n"
 909 " writes a range of bytes from the given offset\n"
 910 "\n"
 911 " Example:\n"
 912 " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
 913 "\n"
 914 " Writes into a segment of the currently open file, using a buffer\n"
 915 " filled with a set pattern (0xcdcdcdcd).\n"
 916 " -b, -- write to the VM state rather than the virtual disk\n"
 917 " -c, -- write compressed data with bdrv_write_compressed\n"
 918 " -p, -- use bdrv_pwrite to write the file\n"
 919 " -P, -- use different pattern to fill file\n"
 920 " -C, -- report statistics in a machine parsable format\n"
 921 " -q, -- quiet mode, do not show I/O statistics\n"
 922 " -z, -- write zeroes using bdrv_co_write_zeroes\n"
 923 "\n");
 924 }
 925
 926 static int write_f(BlockDriverState *bs, int argc, char **argv);
 927
 928 static const cmdinfo_t write_cmd = {
 929     .name       = "write",
 930     .altname    = "w",
 931     .cfunc      = write_f,
 932     .argmin     = 2,
 933     .argmax     = -1,
 934     .args       = "[-bcCpqz] [-P pattern ] off len",
 935     .oneline    = "writes a number of bytes at a specified offset",
 936     .help       = write_help,
 937 };
 938
 939 static int write_f(BlockDriverState *bs, int argc, char **argv)
 940 {
 941     struct timeval t1, t2;
 942     int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0;
 943     int cflag = 0;
 944     int c, cnt;
 945     char *buf = NULL;
 946     int64_t offset;
 947     int count;
 948     /* Some compilers get confused and warn if this is not initialized.  */
 949     int total = 0;
 950     int pattern = 0xcd;
 951
 952     while ((c = getopt(argc, argv, "bcCpP:qz")) != EOF) {
 953         switch (c) {
 954         case 'b':
 955             bflag = 1;
 956             break;
 957         case 'c':
 958             cflag = 1;
 959             break;
 960         case 'C':
 961             Cflag = 1;
 962             break;
 963         case 'p':
 964             pflag = 1;
 965             break;
 966         case 'P':
 967             Pflag = 1;
 968             pattern = parse_pattern(optarg);
 969             if (pattern < 0) {
 970                 return 0;
 971             }
 972             break;
 973         case 'q':
 974             qflag = 1;
 975             break;
 976         case 'z':
 977             zflag = 1;
 978             break;
 979         default:
 980             return qemuio_command_usage(&write_cmd);
 981         }
 982     }
 983
 984     if (optind != argc - 2) {
 985         return qemuio_command_usage(&write_cmd);
 986     }
 987
 988     if (bflag + pflag + zflag > 1) {
 989         printf("-b, -p, or -z cannot be specified at the same time\n");
 990         return 0;
 991     }
 992
 993     if (zflag && Pflag) {
 994         printf("-z and -P cannot be specified at the same time\n");
 995         return 0;
 996     }
 997
 998     offset = cvtnum(argv[optind]);
 999     if (offset < 0) {
1000         printf("non-numeric length argument -- %s\n", argv[optind]);
1001         return 0;
1002     }
1003
1004     optind++;
1005     count = cvtnum(argv[optind]);
1006     if (count < 0) {
1007         printf("non-numeric length argument -- %s\n", argv[optind]);
1008         return 0;
1009     }
1010
1011     if (!pflag) {
1012         if (offset & 0x1ff) {
1013             printf("offset %" PRId64 " is not sector aligned\n",
1014                    offset);
1015             return 0;
1016         }
1017
1018         if (count & 0x1ff) {
1019             printf("count %d is not sector aligned\n",
1020                    count);
1021             return 0;
1022         }
1023     }
1024
1025     if (!zflag) {
1026         buf = qemu_io_alloc(bs, count, pattern);
1027     }
1028
1029     gettimeofday(&t1, NULL);
1030     if (pflag) {
1031         cnt = do_pwrite(bs, buf, offset, count, &total);
1032     } else if (bflag) {
1033         cnt = do_save_vmstate(bs, buf, offset, count, &total);
1034     } else if (zflag) {
1035         cnt = do_co_write_zeroes(bs, offset, count, &total);
1036     } else if (cflag) {
1037         cnt = do_write_compressed(bs, buf, offset, count, &total);
1038     } else {
1039         cnt = do_write(bs, buf, offset, count, &total);
1040     }
1041     gettimeofday(&t2, NULL);
1042
1043     if (cnt < 0) {
1044         printf("write failed: %s\n", strerror(-cnt));
1045         goto out;
1046     }
1047
1048     if (qflag) {
1049         goto out;
1050     }
1051
1052     /* Finally, report back -- -C gives a parsable format */
1053     t2 = tsub(t2, t1);
1054     print_report("wrote", &t2, offset, count, total, cnt, Cflag);
1055
1056 out:
1057     if (!zflag) {
1058         qemu_io_free(buf);
1059     }
1060
1061     return 0;
1062 }
1063
1064 static void
1065 writev_help(void)
1066 {
1067     printf(
1068 "\n"
1069 " writes a range of bytes from the given offset source from multiple buffers\n"
1070 "\n"
1071 " Example:\n"
1072 " 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1073 "\n"
1074 " Writes into a segment of the currently open file, using a buffer\n"
1075 " filled with a set pattern (0xcdcdcdcd).\n"
1076 " -P, -- use different pattern to fill file\n"
1077 " -C, -- report statistics in a machine parsable format\n"
1078 " -q, -- quiet mode, do not show I/O statistics\n"
1079 "\n");
1080 }
1081
1082 static int writev_f(BlockDriverState *bs, int argc, char **argv);
1083
1084 static const cmdinfo_t writev_cmd = {
1085     .name       = "writev",
1086     .cfunc      = writev_f,
1087     .argmin     = 2,
1088     .argmax     = -1,
1089     .args       = "[-Cq] [-P pattern ] off len [len..]",
1090     .oneline    = "writes a number of bytes at a specified offset",
1091     .help       = writev_help,
1092 };
1093
1094 static int writev_f(BlockDriverState *bs, int argc, char **argv)
1095 {
1096     struct timeval t1, t2;
1097     int Cflag = 0, qflag = 0;
1098     int c, cnt;
1099     char *buf;
1100     int64_t offset;
1101     /* Some compilers get confused and warn if this is not initialized.  */
1102     int total = 0;
1103     int nr_iov;
1104     int pattern = 0xcd;
1105     QEMUIOVector qiov;
1106
1107     while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1108         switch (c) {
1109         case 'C':
1110             Cflag = 1;
1111             break;
1112         case 'q':
1113             qflag = 1;
1114             break;
1115         case 'P':
1116             pattern = parse_pattern(optarg);
1117             if (pattern < 0) {
1118                 return 0;
1119             }
1120             break;
1121         default:
1122             return qemuio_command_usage(&writev_cmd);
1123         }
1124     }
1125
1126     if (optind > argc - 2) {
1127         return qemuio_command_usage(&writev_cmd);
1128     }
1129
1130     offset = cvtnum(argv[optind]);
1131     if (offset < 0) {
1132         printf("non-numeric length argument -- %s\n", argv[optind]);
1133         return 0;
1134     }
1135     optind++;
1136
1137     if (offset & 0x1ff) {
1138         printf("offset %" PRId64 " is not sector aligned\n",
1139                offset);
1140         return 0;
1141     }
1142
1143     nr_iov = argc - optind;
1144     buf = create_iovec(bs, &qiov, &argv[optind], nr_iov, pattern);
1145     if (buf == NULL) {
1146         return 0;
1147     }
1148
1149     gettimeofday(&t1, NULL);
1150     cnt = do_aio_writev(bs, &qiov, offset, &total);
1151     gettimeofday(&t2, NULL);
1152
1153     if (cnt < 0) {
1154         printf("writev failed: %s\n", strerror(-cnt));
1155         goto out;
1156     }
1157
1158     if (qflag) {
1159         goto out;
1160     }
1161
1162     /* Finally, report back -- -C gives a parsable format */
1163     t2 = tsub(t2, t1);
1164     print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
1165 out:
1166     qemu_iovec_destroy(&qiov);
1167     qemu_io_free(buf);
1168     return 0;
1169 }
1170
1171 static void multiwrite_help(void)
1172 {
1173     printf(
1174 "\n"
1175 " writes a range of bytes from the given offset source from multiple buffers,\n"
1176 " in a batch of requests that may be merged by qemu\n"
1177 "\n"
1178 " Example:\n"
1179 " 'multiwrite 512 1k 1k ; 4k 1k'\n"
1180 "  writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"
1181 "\n"
1182 " Writes into a segment of the currently open file, using a buffer\n"
1183 " filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"
1184 " by one for each request contained in the multiwrite command.\n"
1185 " -P, -- use different pattern to fill file\n"
1186 " -C, -- report statistics in a machine parsable format\n"
1187 " -q, -- quiet mode, do not show I/O statistics\n"
1188 "\n");
1189 }
1190
1191 static int multiwrite_f(BlockDriverState *bs, int argc, char **argv);
1192
1193 static const cmdinfo_t multiwrite_cmd = {
1194     .name       = "multiwrite",
1195     .cfunc      = multiwrite_f,
1196     .argmin     = 2,
1197     .argmax     = -1,
1198     .args       = "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",
1199     .oneline    = "issues multiple write requests at once",
1200     .help       = multiwrite_help,
1201 };
1202
1203 static int multiwrite_f(BlockDriverState *bs, int argc, char **argv)
1204 {
1205     struct timeval t1, t2;
1206     int Cflag = 0, qflag = 0;
1207     int c, cnt;
1208     char **buf;
1209     int64_t offset, first_offset = 0;
1210     /* Some compilers get confused and warn if this is not initialized.  */
1211     int total = 0;
1212     int nr_iov;
1213     int nr_reqs;
1214     int pattern = 0xcd;
1215     QEMUIOVector *qiovs;
1216     int i;
1217     BlockRequest *reqs;
1218
1219     while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1220         switch (c) {
1221         case 'C':
1222             Cflag = 1;
1223             break;
1224         case 'q':
1225             qflag = 1;
1226             break;
1227         case 'P':
1228             pattern = parse_pattern(optarg);
1229             if (pattern < 0) {
1230                 return 0;
1231             }
1232             break;
1233         default:
1234             return qemuio_command_usage(&writev_cmd);
1235         }
1236     }
1237
1238     if (optind > argc - 2) {
1239         return qemuio_command_usage(&writev_cmd);
1240     }
1241
1242     nr_reqs = 1;
1243     for (i = optind; i < argc; i++) {
1244         if (!strcmp(argv[i], ";")) {
1245             nr_reqs++;
1246         }
1247     }
1248
1249     reqs = g_malloc0(nr_reqs * sizeof(*reqs));
1250     buf = g_malloc0(nr_reqs * sizeof(*buf));
1251     qiovs = g_malloc(nr_reqs * sizeof(*qiovs));
1252
1253     for (i = 0; i < nr_reqs && optind < argc; i++) {
1254         int j;
1255
1256         /* Read the offset of the request */
1257         offset = cvtnum(argv[optind]);
1258         if (offset < 0) {
1259             printf("non-numeric offset argument -- %s\n", argv[optind]);
1260             goto out;
1261         }
1262         optind++;
1263
1264         if (offset & 0x1ff) {
1265             printf("offset %lld is not sector aligned\n",
1266                    (long long)offset);
1267             goto out;
1268         }
1269
1270         if (i == 0) {
1271             first_offset = offset;
1272         }
1273
1274         /* Read lengths for qiov entries */
1275         for (j = optind; j < argc; j++) {
1276             if (!strcmp(argv[j], ";")) {
1277                 break;
1278             }
1279         }
1280
1281         nr_iov = j - optind;
1282
1283         /* Build request */
1284         buf[i] = create_iovec(bs, &qiovs[i], &argv[optind], nr_iov, pattern);
1285         if (buf[i] == NULL) {
1286             goto out;
1287         }
1288
1289         reqs[i].qiov = &qiovs[i];
1290         reqs[i].sector = offset >> 9;
1291         reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
1292
1293         optind = j + 1;
1294
1295         pattern++;
1296     }
1297
1298     /* If there were empty requests at the end, ignore them */
1299     nr_reqs = i;
1300
1301     gettimeofday(&t1, NULL);
1302     cnt = do_aio_multiwrite(bs, reqs, nr_reqs, &total);
1303     gettimeofday(&t2, NULL);
1304
1305     if (cnt < 0) {
1306         printf("aio_multiwrite failed: %s\n", strerror(-cnt));
1307         goto out;
1308     }
1309
1310     if (qflag) {
1311         goto out;
1312     }
1313
1314     /* Finally, report back -- -C gives a parsable format */
1315     t2 = tsub(t2, t1);
1316     print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
1317 out:
1318     for (i = 0; i < nr_reqs; i++) {
1319         qemu_io_free(buf[i]);
1320         if (reqs[i].qiov != NULL) {
1321             qemu_iovec_destroy(&qiovs[i]);
1322         }
1323     }
1324     g_free(buf);
1325     g_free(reqs);
1326     g_free(qiovs);
1327     return 0;
1328 }
1329
1330 struct aio_ctx {
1331     QEMUIOVector qiov;
1332     int64_t offset;
1333     char *buf;
1334     int qflag;
1335     int vflag;
1336     int Cflag;
1337     int Pflag;
1338     int pattern;
1339     struct timeval t1;
1340 };
1341
1342 static void aio_write_done(void *opaque, int ret)
1343 {
1344     struct aio_ctx *ctx = opaque;
1345     struct timeval t2;
1346
1347     gettimeofday(&t2, NULL);
1348
1349
1350     if (ret < 0) {
1351         printf("aio_write failed: %s\n", strerror(-ret));
1352         goto out;
1353     }
1354
1355     if (ctx->qflag) {
1356         goto out;
1357     }
1358
1359     /* Finally, report back -- -C gives a parsable format */
1360     t2 = tsub(t2, ctx->t1);
1361     print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
1362                  ctx->qiov.size, 1, ctx->Cflag);
1363 out:
1364     qemu_io_free(ctx->buf);
1365     qemu_iovec_destroy(&ctx->qiov);
1366     g_free(ctx);
1367 }
1368
1369 static void aio_read_done(void *opaque, int ret)
1370 {
1371     struct aio_ctx *ctx = opaque;
1372     struct timeval t2;
1373
1374     gettimeofday(&t2, NULL);
1375
1376     if (ret < 0) {
1377         printf("readv failed: %s\n", strerror(-ret));
1378         goto out;
1379     }
1380
1381     if (ctx->Pflag) {
1382         void *cmp_buf = g_malloc(ctx->qiov.size);
1383
1384         memset(cmp_buf, ctx->pattern, ctx->qiov.size);
1385         if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
1386             printf("Pattern verification failed at offset %"
1387                    PRId64 ", %zd bytes\n", ctx->offset, ctx->qiov.size);
1388         }
1389         g_free(cmp_buf);
1390     }
1391
1392     if (ctx->qflag) {
1393         goto out;
1394     }
1395
1396     if (ctx->vflag) {
1397         dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
1398     }
1399
1400     /* Finally, report back -- -C gives a parsable format */
1401     t2 = tsub(t2, ctx->t1);
1402     print_report("read", &t2, ctx->offset, ctx->qiov.size,
1403                  ctx->qiov.size, 1, ctx->Cflag);
1404 out:
1405     qemu_io_free(ctx->buf);
1406     qemu_iovec_destroy(&ctx->qiov);
1407     g_free(ctx);
1408 }
1409
1410 static void aio_read_help(void)
1411 {
1412     printf(
1413 "\n"
1414 " asynchronously reads a range of bytes from the given offset\n"
1415 "\n"
1416 " Example:\n"
1417 " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
1418 "\n"
1419 " Reads a segment of the currently open file, optionally dumping it to the\n"
1420 " standard output stream (with -v option) for subsequent inspection.\n"
1421 " The read is performed asynchronously and the aio_flush command must be\n"
1422 " used to ensure all outstanding aio requests have been completed.\n"
1423 " -C, -- report statistics in a machine parsable format\n"
1424 " -P, -- use a pattern to verify read data\n"
1425 " -v, -- dump buffer to standard output\n"
1426 " -q, -- quiet mode, do not show I/O statistics\n"
1427 "\n");
1428 }
1429
1430 static int aio_read_f(BlockDriverState *bs, int argc, char **argv);
1431
1432 static const cmdinfo_t aio_read_cmd = {
1433     .name       = "aio_read",
1434     .cfunc      = aio_read_f,
1435     .argmin     = 2,
1436     .argmax     = -1,
1437     .args       = "[-Cqv] [-P pattern ] off len [len..]",
1438     .oneline    = "asynchronously reads a number of bytes",
1439     .help       = aio_read_help,
1440 };
1441
1442 static int aio_read_f(BlockDriverState *bs, int argc, char **argv)
1443 {
1444     int nr_iov, c;
1445     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
1446
1447     while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
1448         switch (c) {
1449         case 'C':
1450             ctx->Cflag = 1;
1451             break;
1452         case 'P':
1453             ctx->Pflag = 1;
1454             ctx->pattern = parse_pattern(optarg);
1455             if (ctx->pattern < 0) {
1456                 g_free(ctx);
1457                 return 0;
1458             }
1459             break;
1460         case 'q':
1461             ctx->qflag = 1;
1462             break;
1463         case 'v':
1464             ctx->vflag = 1;
1465             break;
1466         default:
1467             g_free(ctx);
1468             return qemuio_command_usage(&aio_read_cmd);
1469         }
1470     }
1471
1472     if (optind > argc - 2) {
1473         g_free(ctx);
1474         return qemuio_command_usage(&aio_read_cmd);
1475     }
1476
1477     ctx->offset = cvtnum(argv[optind]);
1478     if (ctx->offset < 0) {
1479         printf("non-numeric length argument -- %s\n", argv[optind]);
1480         g_free(ctx);
1481         return 0;
1482     }
1483     optind++;
1484
1485     if (ctx->offset & 0x1ff) {
1486         printf("offset %" PRId64 " is not sector aligned\n",
1487                ctx->offset);
1488         g_free(ctx);
1489         return 0;
1490     }
1491
1492     nr_iov = argc - optind;
1493     ctx->buf = create_iovec(bs, &ctx->qiov, &argv[optind], nr_iov, 0xab);
1494     if (ctx->buf == NULL) {
1495         g_free(ctx);
1496         return 0;
1497     }
1498
1499     gettimeofday(&ctx->t1, NULL);
1500     bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
1501                    ctx->qiov.size >> 9, aio_read_done, ctx);
1502     return 0;
1503 }
1504
1505 static void aio_write_help(void)
1506 {
1507     printf(
1508 "\n"
1509 " asynchronously writes a range of bytes from the given offset source\n"
1510 " from multiple buffers\n"
1511 "\n"
1512 " Example:\n"
1513 " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1514 "\n"
1515 " Writes into a segment of the currently open file, using a buffer\n"
1516 " filled with a set pattern (0xcdcdcdcd).\n"
1517 " The write is performed asynchronously and the aio_flush command must be\n"
1518 " used to ensure all outstanding aio requests have been completed.\n"
1519 " -P, -- use different pattern to fill file\n"
1520 " -C, -- report statistics in a machine parsable format\n"
1521 " -q, -- quiet mode, do not show I/O statistics\n"
1522 "\n");
1523 }
1524
1525 static int aio_write_f(BlockDriverState *bs, int argc, char **argv);
1526
1527 static const cmdinfo_t aio_write_cmd = {
1528     .name       = "aio_write",
1529     .cfunc      = aio_write_f,
1530     .argmin     = 2,
1531     .argmax     = -1,
1532     .args       = "[-Cq] [-P pattern ] off len [len..]",
1533     .oneline    = "asynchronously writes a number of bytes",
1534     .help       = aio_write_help,
1535 };
1536
1537 static int aio_write_f(BlockDriverState *bs, int argc, char **argv)
1538 {
1539     int nr_iov, c;
1540     int pattern = 0xcd;
1541     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
1542
1543     while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1544         switch (c) {
1545         case 'C':
1546             ctx->Cflag = 1;
1547             break;
1548         case 'q':
1549             ctx->qflag = 1;
1550             break;
1551         case 'P':
1552             pattern = parse_pattern(optarg);
1553             if (pattern < 0) {
1554                 g_free(ctx);
1555                 return 0;
1556             }
1557             break;
1558         default:
1559             g_free(ctx);
1560             return qemuio_command_usage(&aio_write_cmd);
1561         }
1562     }
1563
1564     if (optind > argc - 2) {
1565         g_free(ctx);
1566         return qemuio_command_usage(&aio_write_cmd);
1567     }
1568
1569     ctx->offset = cvtnum(argv[optind]);
1570     if (ctx->offset < 0) {
1571         printf("non-numeric length argument -- %s\n", argv[optind]);
1572         g_free(ctx);
1573         return 0;
1574     }
1575     optind++;
1576
1577     if (ctx->offset & 0x1ff) {
1578         printf("offset %" PRId64 " is not sector aligned\n",
1579                ctx->offset);
1580         g_free(ctx);
1581         return 0;
1582     }
1583
1584     nr_iov = argc - optind;
1585     ctx->buf = create_iovec(bs, &ctx->qiov, &argv[optind], nr_iov, pattern);
1586     if (ctx->buf == NULL) {
1587         g_free(ctx);
1588         return 0;
1589     }
1590
1591     gettimeofday(&ctx->t1, NULL);
1592     bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
1593                     ctx->qiov.size >> 9, aio_write_done, ctx);
1594     return 0;
1595 }
1596
1597 static int aio_flush_f(BlockDriverState *bs, int argc, char **argv)
1598 {
1599     bdrv_drain_all();
1600     return 0;
1601 }
1602
1603 static const cmdinfo_t aio_flush_cmd = {
1604     .name       = "aio_flush",
1605     .cfunc      = aio_flush_f,
1606     .oneline    = "completes all outstanding aio requests"
1607 };
1608
1609 static int flush_f(BlockDriverState *bs, int argc, char **argv)
1610 {
1611     bdrv_flush(bs);
1612     return 0;
1613 }
1614
1615 static const cmdinfo_t flush_cmd = {
1616     .name       = "flush",
1617     .altname    = "f",
1618     .cfunc      = flush_f,
1619     .oneline    = "flush all in-core file state to disk",
1620 };
1621
1622 static int truncate_f(BlockDriverState *bs, int argc, char **argv)
1623 {
1624     int64_t offset;
1625     int ret;
1626
1627     offset = cvtnum(argv[1]);
1628     if (offset < 0) {
1629         printf("non-numeric truncate argument -- %s\n", argv[1]);
1630         return 0;
1631     }
1632
1633     ret = bdrv_truncate(bs, offset);
1634     if (ret < 0) {
1635         printf("truncate: %s\n", strerror(-ret));
1636         return 0;
1637     }
1638
1639     return 0;
1640 }
1641
1642 static const cmdinfo_t truncate_cmd = {
1643     .name       = "truncate",
1644     .altname    = "t",
1645     .cfunc      = truncate_f,
1646     .argmin     = 1,
1647     .argmax     = 1,
1648     .args       = "off",
1649     .oneline    = "truncates the current file at the given offset",
1650 };
1651
1652 static int length_f(BlockDriverState *bs, int argc, char **argv)
1653 {
1654     int64_t size;
1655     char s1[64];
1656
1657     size = bdrv_getlength(bs);
1658     if (size < 0) {
1659         printf("getlength: %s\n", strerror(-size));
1660         return 0;
1661     }
1662
1663     cvtstr(size, s1, sizeof(s1));
1664     printf("%s\n", s1);
1665     return 0;
1666 }
1667
1668
1669 static const cmdinfo_t length_cmd = {
1670     .name   = "length",
1671     .altname    = "l",
1672     .cfunc      = length_f,
1673     .oneline    = "gets the length of the current file",
1674 };
1675
1676
1677 static int info_f(BlockDriverState *bs, int argc, char **argv)
1678 {
1679     BlockDriverInfo bdi;
1680     char s1[64], s2[64];
1681     int ret;
1682
1683     if (bs->drv && bs->drv->format_name) {
1684         printf("format name: %s\n", bs->drv->format_name);
1685     }
1686     if (bs->drv && bs->drv->protocol_name) {
1687         printf("format name: %s\n", bs->drv->protocol_name);
1688     }
1689
1690     ret = bdrv_get_info(bs, &bdi);
1691     if (ret) {
1692         return 0;
1693     }
1694
1695     cvtstr(bdi.cluster_size, s1, sizeof(s1));
1696     cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
1697
1698     printf("cluster size: %s\n", s1);
1699     printf("vm state offset: %s\n", s2);
1700
1701     return 0;
1702 }
1703
1704
1705
1706 static const cmdinfo_t info_cmd = {
1707     .name       = "info",
1708     .altname    = "i",
1709     .cfunc      = info_f,
1710     .oneline    = "prints information about the current file",
1711 };
1712
1713 static void discard_help(void)
1714 {
1715     printf(
1716 "\n"
1717 " discards a range of bytes from the given offset\n"
1718 "\n"
1719 " Example:\n"
1720 " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
1721 "\n"
1722 " Discards a segment of the currently open file.\n"
1723 " -C, -- report statistics in a machine parsable format\n"
1724 " -q, -- quiet mode, do not show I/O statistics\n"
1725 "\n");
1726 }
1727
1728 static int discard_f(BlockDriverState *bs, int argc, char **argv);
1729
1730 static const cmdinfo_t discard_cmd = {
1731     .name       = "discard",
1732     .altname    = "d",
1733     .cfunc      = discard_f,
1734     .argmin     = 2,
1735     .argmax     = -1,
1736     .args       = "[-Cq] off len",
1737     .oneline    = "discards a number of bytes at a specified offset",
1738     .help       = discard_help,
1739 };
1740
1741 static int discard_f(BlockDriverState *bs, int argc, char **argv)
1742 {
1743     struct timeval t1, t2;
1744     int Cflag = 0, qflag = 0;
1745     int c, ret;
1746     int64_t offset;
1747     int count;
1748
1749     while ((c = getopt(argc, argv, "Cq")) != EOF) {
1750         switch (c) {
1751         case 'C':
1752             Cflag = 1;
1753             break;
1754         case 'q':
1755             qflag = 1;
1756             break;
1757         default:
1758             return qemuio_command_usage(&discard_cmd);
1759         }
1760     }
1761
1762     if (optind != argc - 2) {
1763         return qemuio_command_usage(&discard_cmd);
1764     }
1765
1766     offset = cvtnum(argv[optind]);
1767     if (offset < 0) {
1768         printf("non-numeric length argument -- %s\n", argv[optind]);
1769         return 0;
1770     }
1771
1772     optind++;
1773     count = cvtnum(argv[optind]);
1774     if (count < 0) {
1775         printf("non-numeric length argument -- %s\n", argv[optind]);
1776         return 0;
1777     }
1778
1779     gettimeofday(&t1, NULL);
1780     ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS,
1781                        count >> BDRV_SECTOR_BITS);
1782     gettimeofday(&t2, NULL);
1783
1784     if (ret < 0) {
1785         printf("discard failed: %s\n", strerror(-ret));
1786         goto out;
1787     }
1788
1789     /* Finally, report back -- -C gives a parsable format */
1790     if (!qflag) {
1791         t2 = tsub(t2, t1);
1792         print_report("discard", &t2, offset, count, count, 1, Cflag);
1793     }
1794
1795 out:
1796     return 0;
1797 }
1798
1799 static int alloc_f(BlockDriverState *bs, int argc, char **argv)
1800 {
1801     int64_t offset, sector_num;
1802     int nb_sectors, remaining;
1803     char s1[64];
1804     int num, sum_alloc;
1805     int ret;
1806
1807     offset = cvtnum(argv[1]);
1808     if (offset < 0) {
1809         printf("non-numeric offset argument -- %s\n", argv[1]);
1810         return 0;
1811     } else if (offset & 0x1ff) {
1812         printf("offset %" PRId64 " is not sector aligned\n",
1813                offset);
1814         return 0;
1815     }
1816
1817     if (argc == 3) {
1818         nb_sectors = cvtnum(argv[2]);
1819         if (nb_sectors < 0) {
1820             printf("non-numeric length argument -- %s\n", argv[2]);
1821             return 0;
1822         }
1823     } else {
1824         nb_sectors = 1;
1825     }
1826
1827     remaining = nb_sectors;
1828     sum_alloc = 0;
1829     sector_num = offset >> 9;
1830     while (remaining) {
1831         ret = bdrv_is_allocated(bs, sector_num, remaining, &num);
1832         sector_num += num;
1833         remaining -= num;
1834         if (ret) {
1835             sum_alloc += num;
1836         }
1837         if (num == 0) {
1838             nb_sectors -= remaining;
1839             remaining = 0;
1840         }
1841     }
1842
1843     cvtstr(offset, s1, sizeof(s1));
1844
1845     printf("%d/%d sectors allocated at offset %s\n",
1846            sum_alloc, nb_sectors, s1);
1847     return 0;
1848 }
1849
1850 static const cmdinfo_t alloc_cmd = {
1851     .name       = "alloc",
1852     .altname    = "a",
1853     .argmin     = 1,
1854     .argmax     = 2,
1855     .cfunc      = alloc_f,
1856     .args       = "off [sectors]",
1857     .oneline    = "checks if a sector is present in the file",
1858 };
1859
1860
1861 static int map_is_allocated(BlockDriverState *bs, int64_t sector_num,
1862                             int64_t nb_sectors, int64_t *pnum)
1863 {
1864     int num, num_checked;
1865     int ret, firstret;
1866
1867     num_checked = MIN(nb_sectors, INT_MAX);
1868     ret = bdrv_is_allocated(bs, sector_num, num_checked, &num);
1869     if (ret < 0) {
1870         return ret;
1871     }
1872
1873     firstret = ret;
1874     *pnum = num;
1875
1876     while (nb_sectors > 0 && ret == firstret) {
1877         sector_num += num;
1878         nb_sectors -= num;
1879
1880         num_checked = MIN(nb_sectors, INT_MAX);
1881         ret = bdrv_is_allocated(bs, sector_num, num_checked, &num);
1882         if (ret == firstret) {
1883             *pnum += num;
1884         } else {
1885             break;
1886         }
1887     }
1888
1889     return firstret;
1890 }
1891
1892 static int map_f(BlockDriverState *bs, int argc, char **argv)
1893 {
1894     int64_t offset;
1895     int64_t nb_sectors;
1896     char s1[64];
1897     int64_t num;
1898     int ret;
1899     const char *retstr;
1900
1901     offset = 0;
1902     nb_sectors = bs->total_sectors;
1903
1904     do {
1905         ret = map_is_allocated(bs, offset, nb_sectors, &num);
1906         if (ret < 0) {
1907             error_report("Failed to get allocation status: %s", strerror(-ret));
1908             return 0;
1909         }
1910
1911         retstr = ret ? "    allocated" : "not allocated";
1912         cvtstr(offset << 9ULL, s1, sizeof(s1));
1913         printf("[% 24" PRId64 "] % 8" PRId64 "/% 8" PRId64 " sectors %s "
1914                "at offset %s (%d)\n",
1915                offset << 9ULL, num, nb_sectors, retstr, s1, ret);
1916
1917         offset += num;
1918         nb_sectors -= num;
1919     } while (offset < bs->total_sectors);
1920
1921     return 0;
1922 }
1923
1924 static const cmdinfo_t map_cmd = {
1925        .name           = "map",
1926        .argmin         = 0,
1927        .argmax         = 0,
1928        .cfunc          = map_f,
1929        .args           = "",
1930        .oneline        = "prints the allocated areas of a file",
1931 };
1932
1933 static int break_f(BlockDriverState *bs, int argc, char **argv)
1934 {
1935     int ret;
1936
1937     ret = bdrv_debug_breakpoint(bs, argv[1], argv[2]);
1938     if (ret < 0) {
1939         printf("Could not set breakpoint: %s\n", strerror(-ret));
1940     }
1941
1942     return 0;
1943 }
1944
1945 static const cmdinfo_t break_cmd = {
1946        .name           = "break",
1947        .argmin         = 2,
1948        .argmax         = 2,
1949        .cfunc          = break_f,
1950        .args           = "event tag",
1951        .oneline        = "sets a breakpoint on event and tags the stopped "
1952                          "request as tag",
1953 };
1954
1955 static int resume_f(BlockDriverState *bs, int argc, char **argv)
1956 {
1957     int ret;
1958
1959     ret = bdrv_debug_resume(bs, argv[1]);
1960     if (ret < 0) {
1961         printf("Could not resume request: %s\n", strerror(-ret));
1962     }
1963
1964     return 0;
1965 }
1966
1967 static const cmdinfo_t resume_cmd = {
1968        .name           = "resume",
1969        .argmin         = 1,
1970        .argmax         = 1,
1971        .cfunc          = resume_f,
1972        .args           = "tag",
1973        .oneline        = "resumes the request tagged as tag",
1974 };
1975
1976 static int wait_break_f(BlockDriverState *bs, int argc, char **argv)
1977 {
1978     while (!bdrv_debug_is_suspended(bs, argv[1])) {
1979         qemu_aio_wait();
1980     }
1981
1982     return 0;
1983 }
1984
1985 static const cmdinfo_t wait_break_cmd = {
1986        .name           = "wait_break",
1987        .argmin         = 1,
1988        .argmax         = 1,
1989        .cfunc          = wait_break_f,
1990        .args           = "tag",
1991        .oneline        = "waits for the suspension of a request",
1992 };
1993
1994 static int abort_f(BlockDriverState *bs, int argc, char **argv)
1995 {
1996     abort();
1997 }
1998
1999 static const cmdinfo_t abort_cmd = {
2000        .name           = "abort",
2001        .cfunc          = abort_f,
2002        .flags          = CMD_NOFILE_OK,
2003        .oneline        = "simulate a program crash using abort(3)",
2004 };
2005
2006 static void help_oneline(const char *cmd, const cmdinfo_t *ct)
2007 {
2008     if (cmd) {
2009         printf("%s ", cmd);
2010     } else {
2011         printf("%s ", ct->name);
2012         if (ct->altname) {
2013             printf("(or %s) ", ct->altname);
2014         }
2015     }
2016
2017     if (ct->args) {
2018         printf("%s ", ct->args);
2019     }
2020     printf("-- %s\n", ct->oneline);
2021 }
2022
2023 static void help_onecmd(const char *cmd, const cmdinfo_t *ct)
2024 {
2025     help_oneline(cmd, ct);
2026     if (ct->help) {
2027         ct->help();
2028     }
2029 }
2030
2031 static void help_all(void)
2032 {
2033     const cmdinfo_t *ct;
2034
2035     for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
2036         help_oneline(ct->name, ct);
2037     }
2038     printf("\nUse 'help commandname' for extended help.\n");
2039 }
2040
2041 static int help_f(BlockDriverState *bs, int argc, char **argv)
2042 {
2043     const cmdinfo_t *ct;
2044
2045     if (argc == 1) {
2046         help_all();
2047         return 0;
2048     }
2049
2050     ct = find_command(argv[1]);
2051     if (ct == NULL) {
2052         printf("command %s not found\n", argv[1]);
2053         return 0;
2054     }
2055
2056     help_onecmd(argv[1], ct);
2057     return 0;
2058 }
2059
2060 static const cmdinfo_t help_cmd = {
2061     .name       = "help",
2062     .altname    = "?",
2063     .cfunc      = help_f,
2064     .argmin     = 0,
2065     .argmax     = 1,
2066     .flags      = CMD_FLAG_GLOBAL,
2067     .args       = "[command]",
2068     .oneline    = "help for one or all commands",
2069 };
2070
2071 bool qemuio_command(BlockDriverState *bs, const char *cmd)
2072 {
2073     char *input;
2074     const cmdinfo_t *ct;
2075     char **v;
2076     int c;
2077     bool done = false;
2078
2079     input = g_strdup(cmd);
2080     v = breakline(input, &c);
2081     if (c) {
2082         ct = find_command(v[0]);
2083         if (ct) {
2084             done = command(bs, ct, c, v);
2085         } else {
2086             fprintf(stderr, "command \"%s\" not found\n", v[0]);
2087         }
2088     }
2089     g_free(input);
2090     g_free(v);
2091
2092     return done;
2093 }
2094
2095 static void __attribute((constructor)) init_qemuio_commands(void)
2096 {
2097     /* initialize commands */
2098     qemuio_add_command(&help_cmd);
2099     qemuio_add_command(&read_cmd);
2100     qemuio_add_command(&readv_cmd);
2101     qemuio_add_command(&write_cmd);
2102     qemuio_add_command(&writev_cmd);
2103     qemuio_add_command(&multiwrite_cmd);
2104     qemuio_add_command(&aio_read_cmd);
2105     qemuio_add_command(&aio_write_cmd);
2106     qemuio_add_command(&aio_flush_cmd);
2107     qemuio_add_command(&flush_cmd);
2108     qemuio_add_command(&truncate_cmd);
2109     qemuio_add_command(&length_cmd);
2110     qemuio_add_command(&info_cmd);
2111     qemuio_add_command(&discard_cmd);
2112     qemuio_add_command(&alloc_cmd);
2113     qemuio_add_command(&map_cmd);
2114     qemuio_add_command(&break_cmd);
2115     qemuio_add_command(&resume_cmd);
2116     qemuio_add_command(&wait_break_cmd);
2117     qemuio_add_command(&abort_cmd);
2118 }