1 /* 2 * Command line utility to exercise the QEMU I/O path. 3 * 4 * Copyright (C) 2009-2016 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/osdep.h" 12 #include "qapi/error.h" 13 #include "qapi/qmp/qdict.h" 14 #include "qemu-io.h" 15 #include "sysemu/block-backend.h" 16 #include "block/block.h" 17 #include "block/block_int.h" /* for info_f() */ 18 #include "block/qapi.h" 19 #include "qemu/error-report.h" 20 #include "qemu/main-loop.h" 21 #include "qemu/option.h" 22 #include "qemu/timer.h" 23 #include "qemu/cutils.h" 24 25 #define CMD_NOFILE_OK 0x01 26 27 bool qemuio_misalign; 28 29 static cmdinfo_t *cmdtab; 30 static int ncmds; 31 32 static int compare_cmdname(const void *a, const void *b) 33 { 34 return strcmp(((const cmdinfo_t *)a)->name, 35 ((const cmdinfo_t *)b)->name); 36 } 37 38 void qemuio_add_command(const cmdinfo_t *ci) 39 { 40 /* ci->perm assumes a file is open, but the GLOBAL and NOFILE_OK 41 * flags allow it not to be, so that combination is invalid. 42 * Catch it now rather than letting it manifest as a crash if a 43 * particular set of command line options are used. 44 */ 45 assert(ci->perm == 0 || 46 (ci->flags & (CMD_FLAG_GLOBAL | CMD_NOFILE_OK)) == 0); 47 cmdtab = g_renew(cmdinfo_t, cmdtab, ++ncmds); 48 cmdtab[ncmds - 1] = *ci; 49 qsort(cmdtab, ncmds, sizeof(*cmdtab), compare_cmdname); 50 } 51 52 void qemuio_command_usage(const cmdinfo_t *ci) 53 { 54 printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline); 55 } 56 57 static int init_check_command(BlockBackend *blk, const cmdinfo_t *ct) 58 { 59 if (ct->flags & CMD_FLAG_GLOBAL) { 60 return 1; 61 } 62 if (!(ct->flags & CMD_NOFILE_OK) && !blk) { 63 fprintf(stderr, "no file open, try 'help open'\n"); 64 return 0; 65 } 66 return 1; 67 } 68 69 static int command(BlockBackend *blk, const cmdinfo_t *ct, int argc, 70 char **argv) 71 { 72 char *cmd = argv[0]; 73 74 if (!init_check_command(blk, ct)) { 75 return -EINVAL; 76 } 77 78 if (argc - 1 < ct->argmin || (ct->argmax != -1 && argc - 1 > ct->argmax)) { 79 if (ct->argmax == -1) { 80 fprintf(stderr, 81 "bad argument count %d to %s, expected at least %d arguments\n", 82 argc-1, cmd, ct->argmin); 83 } else if (ct->argmin == ct->argmax) { 84 fprintf(stderr, 85 "bad argument count %d to %s, expected %d arguments\n", 86 argc-1, cmd, ct->argmin); 87 } else { 88 fprintf(stderr, 89 "bad argument count %d to %s, expected between %d and %d arguments\n", 90 argc-1, cmd, ct->argmin, ct->argmax); 91 } 92 return -EINVAL; 93 } 94 95 /* Request additional permissions if necessary for this command. The caller 96 * is responsible for restoring the original permissions afterwards if this 97 * is what it wants. */ 98 if (ct->perm && blk_is_available(blk)) { 99 uint64_t orig_perm, orig_shared_perm; 100 blk_get_perm(blk, &orig_perm, &orig_shared_perm); 101 102 if (ct->perm & ~orig_perm) { 103 uint64_t new_perm; 104 Error *local_err = NULL; 105 int ret; 106 107 new_perm = orig_perm | ct->perm; 108 109 ret = blk_set_perm(blk, new_perm, orig_shared_perm, &local_err); 110 if (ret < 0) { 111 error_report_err(local_err); 112 return ret; 113 } 114 } 115 } 116 117 qemu_reset_optind(); 118 return ct->cfunc(blk, argc, argv); 119 } 120 121 static const cmdinfo_t *find_command(const char *cmd) 122 { 123 cmdinfo_t *ct; 124 125 for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 126 if (strcmp(ct->name, cmd) == 0 || 127 (ct->altname && strcmp(ct->altname, cmd) == 0)) 128 { 129 return (const cmdinfo_t *)ct; 130 } 131 } 132 return NULL; 133 } 134 135 /* Invoke fn() for commands with a matching prefix */ 136 void qemuio_complete_command(const char *input, 137 void (*fn)(const char *cmd, void *opaque), 138 void *opaque) 139 { 140 cmdinfo_t *ct; 141 size_t input_len = strlen(input); 142 143 for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 144 if (strncmp(input, ct->name, input_len) == 0) { 145 fn(ct->name, opaque); 146 } 147 } 148 } 149 150 static char **breakline(char *input, int *count) 151 { 152 int c = 0; 153 char *p; 154 char **rval = g_new0(char *, 1); 155 156 while (rval && (p = qemu_strsep(&input, " ")) != NULL) { 157 if (!*p) { 158 continue; 159 } 160 c++; 161 rval = g_renew(char *, rval, (c + 1)); 162 rval[c - 1] = p; 163 rval[c] = NULL; 164 } 165 *count = c; 166 return rval; 167 } 168 169 static int64_t cvtnum(const char *s) 170 { 171 int err; 172 uint64_t value; 173 174 err = qemu_strtosz(s, NULL, &value); 175 if (err < 0) { 176 return err; 177 } 178 if (value > INT64_MAX) { 179 return -ERANGE; 180 } 181 return value; 182 } 183 184 static void print_cvtnum_err(int64_t rc, const char *arg) 185 { 186 switch (rc) { 187 case -EINVAL: 188 printf("Parsing error: non-numeric argument," 189 " or extraneous/unrecognized suffix -- %s\n", arg); 190 break; 191 case -ERANGE: 192 printf("Parsing error: argument too large -- %s\n", arg); 193 break; 194 default: 195 printf("Parsing error: %s\n", arg); 196 } 197 } 198 199 #define EXABYTES(x) ((long long)(x) << 60) 200 #define PETABYTES(x) ((long long)(x) << 50) 201 #define TERABYTES(x) ((long long)(x) << 40) 202 #define GIGABYTES(x) ((long long)(x) << 30) 203 #define MEGABYTES(x) ((long long)(x) << 20) 204 #define KILOBYTES(x) ((long long)(x) << 10) 205 206 #define TO_EXABYTES(x) ((x) / EXABYTES(1)) 207 #define TO_PETABYTES(x) ((x) / PETABYTES(1)) 208 #define TO_TERABYTES(x) ((x) / TERABYTES(1)) 209 #define TO_GIGABYTES(x) ((x) / GIGABYTES(1)) 210 #define TO_MEGABYTES(x) ((x) / MEGABYTES(1)) 211 #define TO_KILOBYTES(x) ((x) / KILOBYTES(1)) 212 213 static void cvtstr(double value, char *str, size_t size) 214 { 215 char *trim; 216 const char *suffix; 217 218 if (value >= EXABYTES(1)) { 219 suffix = " EiB"; 220 snprintf(str, size - 4, "%.3f", TO_EXABYTES(value)); 221 } else if (value >= PETABYTES(1)) { 222 suffix = " PiB"; 223 snprintf(str, size - 4, "%.3f", TO_PETABYTES(value)); 224 } else if (value >= TERABYTES(1)) { 225 suffix = " TiB"; 226 snprintf(str, size - 4, "%.3f", TO_TERABYTES(value)); 227 } else if (value >= GIGABYTES(1)) { 228 suffix = " GiB"; 229 snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value)); 230 } else if (value >= MEGABYTES(1)) { 231 suffix = " MiB"; 232 snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value)); 233 } else if (value >= KILOBYTES(1)) { 234 suffix = " KiB"; 235 snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value)); 236 } else { 237 suffix = " bytes"; 238 snprintf(str, size - 6, "%f", value); 239 } 240 241 trim = strstr(str, ".000"); 242 if (trim) { 243 strcpy(trim, suffix); 244 } else { 245 strcat(str, suffix); 246 } 247 } 248 249 250 251 static struct timeval tsub(struct timeval t1, struct timeval t2) 252 { 253 t1.tv_usec -= t2.tv_usec; 254 if (t1.tv_usec < 0) { 255 t1.tv_usec += 1000000; 256 t1.tv_sec--; 257 } 258 t1.tv_sec -= t2.tv_sec; 259 return t1; 260 } 261 262 static double tdiv(double value, struct timeval tv) 263 { 264 return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0)); 265 } 266 267 #define HOURS(sec) ((sec) / (60 * 60)) 268 #define MINUTES(sec) (((sec) % (60 * 60)) / 60) 269 #define SECONDS(sec) ((sec) % 60) 270 271 enum { 272 DEFAULT_TIME = 0x0, 273 TERSE_FIXED_TIME = 0x1, 274 VERBOSE_FIXED_TIME = 0x2, 275 }; 276 277 static void timestr(struct timeval *tv, char *ts, size_t size, int format) 278 { 279 double usec = (double)tv->tv_usec / 1000000.0; 280 281 if (format & TERSE_FIXED_TIME) { 282 if (!HOURS(tv->tv_sec)) { 283 snprintf(ts, size, "%u:%02u.%02u", 284 (unsigned int) MINUTES(tv->tv_sec), 285 (unsigned int) SECONDS(tv->tv_sec), 286 (unsigned int) (usec * 100)); 287 return; 288 } 289 format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */ 290 } 291 292 if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) { 293 snprintf(ts, size, "%u:%02u:%02u.%02u", 294 (unsigned int) HOURS(tv->tv_sec), 295 (unsigned int) MINUTES(tv->tv_sec), 296 (unsigned int) SECONDS(tv->tv_sec), 297 (unsigned int) (usec * 100)); 298 } else { 299 snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000)); 300 } 301 } 302 303 /* 304 * Parse the pattern argument to various sub-commands. 305 * 306 * Because the pattern is used as an argument to memset it must evaluate 307 * to an unsigned integer that fits into a single byte. 308 */ 309 static int parse_pattern(const char *arg) 310 { 311 char *endptr = NULL; 312 long pattern; 313 314 pattern = strtol(arg, &endptr, 0); 315 if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') { 316 printf("%s is not a valid pattern byte\n", arg); 317 return -1; 318 } 319 320 return pattern; 321 } 322 323 /* 324 * Memory allocation helpers. 325 * 326 * Make sure memory is aligned by default, or purposefully misaligned if 327 * that is specified on the command line. 328 */ 329 330 #define MISALIGN_OFFSET 16 331 static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) 332 { 333 void *buf; 334 335 if (qemuio_misalign) { 336 len += MISALIGN_OFFSET; 337 } 338 buf = blk_blockalign(blk, len); 339 memset(buf, pattern, len); 340 if (qemuio_misalign) { 341 buf += MISALIGN_OFFSET; 342 } 343 return buf; 344 } 345 346 static void qemu_io_free(void *p) 347 { 348 if (qemuio_misalign) { 349 p -= MISALIGN_OFFSET; 350 } 351 qemu_vfree(p); 352 } 353 354 static void dump_buffer(const void *buffer, int64_t offset, int64_t len) 355 { 356 uint64_t i; 357 int j; 358 const uint8_t *p; 359 360 for (i = 0, p = buffer; i < len; i += 16) { 361 const uint8_t *s = p; 362 363 printf("%08" PRIx64 ": ", offset + i); 364 for (j = 0; j < 16 && i + j < len; j++, p++) { 365 printf("%02x ", *p); 366 } 367 printf(" "); 368 for (j = 0; j < 16 && i + j < len; j++, s++) { 369 if (isalnum(*s)) { 370 printf("%c", *s); 371 } else { 372 printf("."); 373 } 374 } 375 printf("\n"); 376 } 377 } 378 379 static void print_report(const char *op, struct timeval *t, int64_t offset, 380 int64_t count, int64_t total, int cnt, bool Cflag) 381 { 382 char s1[64], s2[64], ts[64]; 383 384 timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0); 385 if (!Cflag) { 386 cvtstr((double)total, s1, sizeof(s1)); 387 cvtstr(tdiv((double)total, *t), s2, sizeof(s2)); 388 printf("%s %"PRId64"/%"PRId64" bytes at offset %" PRId64 "\n", 389 op, total, count, offset); 390 printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n", 391 s1, cnt, ts, s2, tdiv((double)cnt, *t)); 392 } else {/* bytes,ops,time,bytes/sec,ops/sec */ 393 printf("%"PRId64",%d,%s,%.3f,%.3f\n", 394 total, cnt, ts, 395 tdiv((double)total, *t), 396 tdiv((double)cnt, *t)); 397 } 398 } 399 400 /* 401 * Parse multiple length statements for vectored I/O, and construct an I/O 402 * vector matching it. 403 */ 404 static void * 405 create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov, 406 int pattern) 407 { 408 size_t *sizes = g_new0(size_t, nr_iov); 409 size_t count = 0; 410 void *buf = NULL; 411 void *p; 412 int i; 413 414 for (i = 0; i < nr_iov; i++) { 415 char *arg = argv[i]; 416 int64_t len; 417 418 len = cvtnum(arg); 419 if (len < 0) { 420 print_cvtnum_err(len, arg); 421 goto fail; 422 } 423 424 if (len > BDRV_REQUEST_MAX_BYTES) { 425 printf("Argument '%s' exceeds maximum size %" PRIu64 "\n", arg, 426 (uint64_t)BDRV_REQUEST_MAX_BYTES); 427 goto fail; 428 } 429 430 if (count > BDRV_REQUEST_MAX_BYTES - len) { 431 printf("The total number of bytes exceed the maximum size %" PRIu64 432 "\n", (uint64_t)BDRV_REQUEST_MAX_BYTES); 433 goto fail; 434 } 435 436 sizes[i] = len; 437 count += len; 438 } 439 440 qemu_iovec_init(qiov, nr_iov); 441 442 buf = p = qemu_io_alloc(blk, count, pattern); 443 444 for (i = 0; i < nr_iov; i++) { 445 qemu_iovec_add(qiov, p, sizes[i]); 446 p += sizes[i]; 447 } 448 449 fail: 450 g_free(sizes); 451 return buf; 452 } 453 454 static int do_pread(BlockBackend *blk, char *buf, int64_t offset, 455 int64_t bytes, int64_t *total) 456 { 457 if (bytes > INT_MAX) { 458 return -ERANGE; 459 } 460 461 *total = blk_pread(blk, offset, (uint8_t *)buf, bytes); 462 if (*total < 0) { 463 return *total; 464 } 465 return 1; 466 } 467 468 static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset, 469 int64_t bytes, int flags, int64_t *total) 470 { 471 if (bytes > INT_MAX) { 472 return -ERANGE; 473 } 474 475 *total = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags); 476 if (*total < 0) { 477 return *total; 478 } 479 return 1; 480 } 481 482 typedef struct { 483 BlockBackend *blk; 484 int64_t offset; 485 int64_t bytes; 486 int64_t *total; 487 int flags; 488 int ret; 489 bool done; 490 } CoWriteZeroes; 491 492 static void coroutine_fn co_pwrite_zeroes_entry(void *opaque) 493 { 494 CoWriteZeroes *data = opaque; 495 496 data->ret = blk_co_pwrite_zeroes(data->blk, data->offset, data->bytes, 497 data->flags); 498 data->done = true; 499 if (data->ret < 0) { 500 *data->total = data->ret; 501 return; 502 } 503 504 *data->total = data->bytes; 505 } 506 507 static int do_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, 508 int64_t bytes, int flags, int64_t *total) 509 { 510 Coroutine *co; 511 CoWriteZeroes data = { 512 .blk = blk, 513 .offset = offset, 514 .bytes = bytes, 515 .total = total, 516 .flags = flags, 517 .done = false, 518 }; 519 520 if (bytes > INT_MAX) { 521 return -ERANGE; 522 } 523 524 co = qemu_coroutine_create(co_pwrite_zeroes_entry, &data); 525 bdrv_coroutine_enter(blk_bs(blk), co); 526 while (!data.done) { 527 aio_poll(blk_get_aio_context(blk), true); 528 } 529 if (data.ret < 0) { 530 return data.ret; 531 } else { 532 return 1; 533 } 534 } 535 536 static int do_write_compressed(BlockBackend *blk, char *buf, int64_t offset, 537 int64_t bytes, int64_t *total) 538 { 539 int ret; 540 541 if (bytes >> 9 > BDRV_REQUEST_MAX_SECTORS) { 542 return -ERANGE; 543 } 544 545 ret = blk_pwrite_compressed(blk, offset, buf, bytes); 546 if (ret < 0) { 547 return ret; 548 } 549 *total = bytes; 550 return 1; 551 } 552 553 static int do_load_vmstate(BlockBackend *blk, char *buf, int64_t offset, 554 int64_t count, int64_t *total) 555 { 556 if (count > INT_MAX) { 557 return -ERANGE; 558 } 559 560 *total = blk_load_vmstate(blk, (uint8_t *)buf, offset, count); 561 if (*total < 0) { 562 return *total; 563 } 564 return 1; 565 } 566 567 static int do_save_vmstate(BlockBackend *blk, char *buf, int64_t offset, 568 int64_t count, int64_t *total) 569 { 570 if (count > INT_MAX) { 571 return -ERANGE; 572 } 573 574 *total = blk_save_vmstate(blk, (uint8_t *)buf, offset, count); 575 if (*total < 0) { 576 return *total; 577 } 578 return 1; 579 } 580 581 #define NOT_DONE 0x7fffffff 582 static void aio_rw_done(void *opaque, int ret) 583 { 584 *(int *)opaque = ret; 585 } 586 587 static int do_aio_readv(BlockBackend *blk, QEMUIOVector *qiov, 588 int64_t offset, int *total) 589 { 590 int async_ret = NOT_DONE; 591 592 blk_aio_preadv(blk, offset, qiov, 0, aio_rw_done, &async_ret); 593 while (async_ret == NOT_DONE) { 594 main_loop_wait(false); 595 } 596 597 *total = qiov->size; 598 return async_ret < 0 ? async_ret : 1; 599 } 600 601 static int do_aio_writev(BlockBackend *blk, QEMUIOVector *qiov, 602 int64_t offset, int flags, int *total) 603 { 604 int async_ret = NOT_DONE; 605 606 blk_aio_pwritev(blk, offset, qiov, flags, aio_rw_done, &async_ret); 607 while (async_ret == NOT_DONE) { 608 main_loop_wait(false); 609 } 610 611 *total = qiov->size; 612 return async_ret < 0 ? async_ret : 1; 613 } 614 615 static void read_help(void) 616 { 617 printf( 618 "\n" 619 " reads a range of bytes from the given offset\n" 620 "\n" 621 " Example:\n" 622 " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n" 623 "\n" 624 " Reads a segment of the currently open file, optionally dumping it to the\n" 625 " standard output stream (with -v option) for subsequent inspection.\n" 626 " -b, -- read from the VM state rather than the virtual disk\n" 627 " -C, -- report statistics in a machine parsable format\n" 628 " -l, -- length for pattern verification (only with -P)\n" 629 " -p, -- ignored for backwards compatibility\n" 630 " -P, -- use a pattern to verify read data\n" 631 " -q, -- quiet mode, do not show I/O statistics\n" 632 " -s, -- start offset for pattern verification (only with -P)\n" 633 " -v, -- dump buffer to standard output\n" 634 "\n"); 635 } 636 637 static int read_f(BlockBackend *blk, int argc, char **argv); 638 639 static const cmdinfo_t read_cmd = { 640 .name = "read", 641 .altname = "r", 642 .cfunc = read_f, 643 .argmin = 2, 644 .argmax = -1, 645 .args = "[-abCqv] [-P pattern [-s off] [-l len]] off len", 646 .oneline = "reads a number of bytes at a specified offset", 647 .help = read_help, 648 }; 649 650 static int read_f(BlockBackend *blk, int argc, char **argv) 651 { 652 struct timeval t1, t2; 653 bool Cflag = false, qflag = false, vflag = false; 654 bool Pflag = false, sflag = false, lflag = false, bflag = false; 655 int c, cnt, ret; 656 char *buf; 657 int64_t offset; 658 int64_t count; 659 /* Some compilers get confused and warn if this is not initialized. */ 660 int64_t total = 0; 661 int pattern = 0; 662 int64_t pattern_offset = 0, pattern_count = 0; 663 664 while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != -1) { 665 switch (c) { 666 case 'b': 667 bflag = true; 668 break; 669 case 'C': 670 Cflag = true; 671 break; 672 case 'l': 673 lflag = true; 674 pattern_count = cvtnum(optarg); 675 if (pattern_count < 0) { 676 print_cvtnum_err(pattern_count, optarg); 677 return pattern_count; 678 } 679 break; 680 case 'p': 681 /* Ignored for backwards compatibility */ 682 break; 683 case 'P': 684 Pflag = true; 685 pattern = parse_pattern(optarg); 686 if (pattern < 0) { 687 return -EINVAL; 688 } 689 break; 690 case 'q': 691 qflag = true; 692 break; 693 case 's': 694 sflag = true; 695 pattern_offset = cvtnum(optarg); 696 if (pattern_offset < 0) { 697 print_cvtnum_err(pattern_offset, optarg); 698 return pattern_offset; 699 } 700 break; 701 case 'v': 702 vflag = true; 703 break; 704 default: 705 qemuio_command_usage(&read_cmd); 706 return -EINVAL; 707 } 708 } 709 710 if (optind != argc - 2) { 711 qemuio_command_usage(&read_cmd); 712 return -EINVAL; 713 } 714 715 offset = cvtnum(argv[optind]); 716 if (offset < 0) { 717 print_cvtnum_err(offset, argv[optind]); 718 return offset; 719 } 720 721 optind++; 722 count = cvtnum(argv[optind]); 723 if (count < 0) { 724 print_cvtnum_err(count, argv[optind]); 725 return count; 726 } else if (count > BDRV_REQUEST_MAX_BYTES) { 727 printf("length cannot exceed %" PRIu64 ", given %s\n", 728 (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]); 729 return -EINVAL; 730 } 731 732 if (!Pflag && (lflag || sflag)) { 733 qemuio_command_usage(&read_cmd); 734 return -EINVAL; 735 } 736 737 if (!lflag) { 738 pattern_count = count - pattern_offset; 739 } 740 741 if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) { 742 printf("pattern verification range exceeds end of read data\n"); 743 return -EINVAL; 744 } 745 746 if (bflag) { 747 if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) { 748 printf("%" PRId64 " is not a sector-aligned value for 'offset'\n", 749 offset); 750 return -EINVAL; 751 } 752 if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) { 753 printf("%"PRId64" is not a sector-aligned value for 'count'\n", 754 count); 755 return -EINVAL; 756 } 757 } 758 759 buf = qemu_io_alloc(blk, count, 0xab); 760 761 gettimeofday(&t1, NULL); 762 if (bflag) { 763 ret = do_load_vmstate(blk, buf, offset, count, &total); 764 } else { 765 ret = do_pread(blk, buf, offset, count, &total); 766 } 767 gettimeofday(&t2, NULL); 768 769 if (ret < 0) { 770 printf("read failed: %s\n", strerror(-ret)); 771 goto out; 772 } 773 cnt = ret; 774 775 ret = 0; 776 777 if (Pflag) { 778 void *cmp_buf = g_malloc(pattern_count); 779 memset(cmp_buf, pattern, pattern_count); 780 if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) { 781 printf("Pattern verification failed at offset %" 782 PRId64 ", %"PRId64" bytes\n", 783 offset + pattern_offset, pattern_count); 784 ret = -EINVAL; 785 } 786 g_free(cmp_buf); 787 } 788 789 if (qflag) { 790 goto out; 791 } 792 793 if (vflag) { 794 dump_buffer(buf, offset, count); 795 } 796 797 /* Finally, report back -- -C gives a parsable format */ 798 t2 = tsub(t2, t1); 799 print_report("read", &t2, offset, count, total, cnt, Cflag); 800 801 out: 802 qemu_io_free(buf); 803 return ret; 804 } 805 806 static void readv_help(void) 807 { 808 printf( 809 "\n" 810 " reads a range of bytes from the given offset into multiple buffers\n" 811 "\n" 812 " Example:\n" 813 " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n" 814 "\n" 815 " Reads a segment of the currently open file, optionally dumping it to the\n" 816 " standard output stream (with -v option) for subsequent inspection.\n" 817 " Uses multiple iovec buffers if more than one byte range is specified.\n" 818 " -C, -- report statistics in a machine parsable format\n" 819 " -P, -- use a pattern to verify read data\n" 820 " -v, -- dump buffer to standard output\n" 821 " -q, -- quiet mode, do not show I/O statistics\n" 822 "\n"); 823 } 824 825 static int readv_f(BlockBackend *blk, int argc, char **argv); 826 827 static const cmdinfo_t readv_cmd = { 828 .name = "readv", 829 .cfunc = readv_f, 830 .argmin = 2, 831 .argmax = -1, 832 .args = "[-Cqv] [-P pattern] off len [len..]", 833 .oneline = "reads a number of bytes at a specified offset", 834 .help = readv_help, 835 }; 836 837 static int readv_f(BlockBackend *blk, int argc, char **argv) 838 { 839 struct timeval t1, t2; 840 bool Cflag = false, qflag = false, vflag = false; 841 int c, cnt, ret; 842 char *buf; 843 int64_t offset; 844 /* Some compilers get confused and warn if this is not initialized. */ 845 int total = 0; 846 int nr_iov; 847 QEMUIOVector qiov; 848 int pattern = 0; 849 bool Pflag = false; 850 851 while ((c = getopt(argc, argv, "CP:qv")) != -1) { 852 switch (c) { 853 case 'C': 854 Cflag = true; 855 break; 856 case 'P': 857 Pflag = true; 858 pattern = parse_pattern(optarg); 859 if (pattern < 0) { 860 return -EINVAL; 861 } 862 break; 863 case 'q': 864 qflag = true; 865 break; 866 case 'v': 867 vflag = true; 868 break; 869 default: 870 qemuio_command_usage(&readv_cmd); 871 return -EINVAL; 872 } 873 } 874 875 if (optind > argc - 2) { 876 qemuio_command_usage(&readv_cmd); 877 return -EINVAL; 878 } 879 880 881 offset = cvtnum(argv[optind]); 882 if (offset < 0) { 883 print_cvtnum_err(offset, argv[optind]); 884 return offset; 885 } 886 optind++; 887 888 nr_iov = argc - optind; 889 buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, 0xab); 890 if (buf == NULL) { 891 return -EINVAL; 892 } 893 894 gettimeofday(&t1, NULL); 895 ret = do_aio_readv(blk, &qiov, offset, &total); 896 gettimeofday(&t2, NULL); 897 898 if (ret < 0) { 899 printf("readv failed: %s\n", strerror(-ret)); 900 goto out; 901 } 902 cnt = ret; 903 904 ret = 0; 905 906 if (Pflag) { 907 void *cmp_buf = g_malloc(qiov.size); 908 memset(cmp_buf, pattern, qiov.size); 909 if (memcmp(buf, cmp_buf, qiov.size)) { 910 printf("Pattern verification failed at offset %" 911 PRId64 ", %zu bytes\n", offset, qiov.size); 912 ret = -EINVAL; 913 } 914 g_free(cmp_buf); 915 } 916 917 if (qflag) { 918 goto out; 919 } 920 921 if (vflag) { 922 dump_buffer(buf, offset, qiov.size); 923 } 924 925 /* Finally, report back -- -C gives a parsable format */ 926 t2 = tsub(t2, t1); 927 print_report("read", &t2, offset, qiov.size, total, cnt, Cflag); 928 929 out: 930 qemu_iovec_destroy(&qiov); 931 qemu_io_free(buf); 932 return ret; 933 } 934 935 static void write_help(void) 936 { 937 printf( 938 "\n" 939 " writes a range of bytes from the given offset\n" 940 "\n" 941 " Example:\n" 942 " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n" 943 "\n" 944 " Writes into a segment of the currently open file, using a buffer\n" 945 " filled with a set pattern (0xcdcdcdcd).\n" 946 " -b, -- write to the VM state rather than the virtual disk\n" 947 " -c, -- write compressed data with blk_write_compressed\n" 948 " -f, -- use Force Unit Access semantics\n" 949 " -n, -- with -z, don't allow slow fallback\n" 950 " -p, -- ignored for backwards compatibility\n" 951 " -P, -- use different pattern to fill file\n" 952 " -C, -- report statistics in a machine parsable format\n" 953 " -q, -- quiet mode, do not show I/O statistics\n" 954 " -u, -- with -z, allow unmapping\n" 955 " -z, -- write zeroes using blk_co_pwrite_zeroes\n" 956 "\n"); 957 } 958 959 static int write_f(BlockBackend *blk, int argc, char **argv); 960 961 static const cmdinfo_t write_cmd = { 962 .name = "write", 963 .altname = "w", 964 .cfunc = write_f, 965 .perm = BLK_PERM_WRITE, 966 .argmin = 2, 967 .argmax = -1, 968 .args = "[-bcCfnquz] [-P pattern] off len", 969 .oneline = "writes a number of bytes at a specified offset", 970 .help = write_help, 971 }; 972 973 static int write_f(BlockBackend *blk, int argc, char **argv) 974 { 975 struct timeval t1, t2; 976 bool Cflag = false, qflag = false, bflag = false; 977 bool Pflag = false, zflag = false, cflag = false; 978 int flags = 0; 979 int c, cnt, ret; 980 char *buf = NULL; 981 int64_t offset; 982 int64_t count; 983 /* Some compilers get confused and warn if this is not initialized. */ 984 int64_t total = 0; 985 int pattern = 0xcd; 986 987 while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) { 988 switch (c) { 989 case 'b': 990 bflag = true; 991 break; 992 case 'c': 993 cflag = true; 994 break; 995 case 'C': 996 Cflag = true; 997 break; 998 case 'f': 999 flags |= BDRV_REQ_FUA; 1000 break; 1001 case 'n': 1002 flags |= BDRV_REQ_NO_FALLBACK; 1003 break; 1004 case 'p': 1005 /* Ignored for backwards compatibility */ 1006 break; 1007 case 'P': 1008 Pflag = true; 1009 pattern = parse_pattern(optarg); 1010 if (pattern < 0) { 1011 return -EINVAL; 1012 } 1013 break; 1014 case 'q': 1015 qflag = true; 1016 break; 1017 case 'u': 1018 flags |= BDRV_REQ_MAY_UNMAP; 1019 break; 1020 case 'z': 1021 zflag = true; 1022 break; 1023 default: 1024 qemuio_command_usage(&write_cmd); 1025 return -EINVAL; 1026 } 1027 } 1028 1029 if (optind != argc - 2) { 1030 qemuio_command_usage(&write_cmd); 1031 return -EINVAL; 1032 } 1033 1034 if (bflag && zflag) { 1035 printf("-b and -z cannot be specified at the same time\n"); 1036 return -EINVAL; 1037 } 1038 1039 if ((flags & BDRV_REQ_FUA) && (bflag || cflag)) { 1040 printf("-f and -b or -c cannot be specified at the same time\n"); 1041 return -EINVAL; 1042 } 1043 1044 if ((flags & BDRV_REQ_NO_FALLBACK) && !zflag) { 1045 printf("-n requires -z to be specified\n"); 1046 return -EINVAL; 1047 } 1048 1049 if ((flags & BDRV_REQ_MAY_UNMAP) && !zflag) { 1050 printf("-u requires -z to be specified\n"); 1051 return -EINVAL; 1052 } 1053 1054 if (zflag && Pflag) { 1055 printf("-z and -P cannot be specified at the same time\n"); 1056 return -EINVAL; 1057 } 1058 1059 offset = cvtnum(argv[optind]); 1060 if (offset < 0) { 1061 print_cvtnum_err(offset, argv[optind]); 1062 return offset; 1063 } 1064 1065 optind++; 1066 count = cvtnum(argv[optind]); 1067 if (count < 0) { 1068 print_cvtnum_err(count, argv[optind]); 1069 return count; 1070 } else if (count > BDRV_REQUEST_MAX_BYTES) { 1071 printf("length cannot exceed %" PRIu64 ", given %s\n", 1072 (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]); 1073 return -EINVAL; 1074 } 1075 1076 if (bflag || cflag) { 1077 if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) { 1078 printf("%" PRId64 " is not a sector-aligned value for 'offset'\n", 1079 offset); 1080 return -EINVAL; 1081 } 1082 1083 if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) { 1084 printf("%"PRId64" is not a sector-aligned value for 'count'\n", 1085 count); 1086 return -EINVAL; 1087 } 1088 } 1089 1090 if (!zflag) { 1091 buf = qemu_io_alloc(blk, count, pattern); 1092 } 1093 1094 gettimeofday(&t1, NULL); 1095 if (bflag) { 1096 ret = do_save_vmstate(blk, buf, offset, count, &total); 1097 } else if (zflag) { 1098 ret = do_co_pwrite_zeroes(blk, offset, count, flags, &total); 1099 } else if (cflag) { 1100 ret = do_write_compressed(blk, buf, offset, count, &total); 1101 } else { 1102 ret = do_pwrite(blk, buf, offset, count, flags, &total); 1103 } 1104 gettimeofday(&t2, NULL); 1105 1106 if (ret < 0) { 1107 printf("write failed: %s\n", strerror(-ret)); 1108 goto out; 1109 } 1110 cnt = ret; 1111 1112 ret = 0; 1113 1114 if (qflag) { 1115 goto out; 1116 } 1117 1118 /* Finally, report back -- -C gives a parsable format */ 1119 t2 = tsub(t2, t1); 1120 print_report("wrote", &t2, offset, count, total, cnt, Cflag); 1121 1122 out: 1123 if (!zflag) { 1124 qemu_io_free(buf); 1125 } 1126 return ret; 1127 } 1128 1129 static void 1130 writev_help(void) 1131 { 1132 printf( 1133 "\n" 1134 " writes a range of bytes from the given offset source from multiple buffers\n" 1135 "\n" 1136 " Example:\n" 1137 " 'writev 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n" 1138 "\n" 1139 " Writes into a segment of the currently open file, using a buffer\n" 1140 " filled with a set pattern (0xcdcdcdcd).\n" 1141 " -P, -- use different pattern to fill file\n" 1142 " -C, -- report statistics in a machine parsable format\n" 1143 " -f, -- use Force Unit Access semantics\n" 1144 " -q, -- quiet mode, do not show I/O statistics\n" 1145 "\n"); 1146 } 1147 1148 static int writev_f(BlockBackend *blk, int argc, char **argv); 1149 1150 static const cmdinfo_t writev_cmd = { 1151 .name = "writev", 1152 .cfunc = writev_f, 1153 .perm = BLK_PERM_WRITE, 1154 .argmin = 2, 1155 .argmax = -1, 1156 .args = "[-Cfq] [-P pattern] off len [len..]", 1157 .oneline = "writes a number of bytes at a specified offset", 1158 .help = writev_help, 1159 }; 1160 1161 static int writev_f(BlockBackend *blk, int argc, char **argv) 1162 { 1163 struct timeval t1, t2; 1164 bool Cflag = false, qflag = false; 1165 int flags = 0; 1166 int c, cnt, ret; 1167 char *buf; 1168 int64_t offset; 1169 /* Some compilers get confused and warn if this is not initialized. */ 1170 int total = 0; 1171 int nr_iov; 1172 int pattern = 0xcd; 1173 QEMUIOVector qiov; 1174 1175 while ((c = getopt(argc, argv, "CfqP:")) != -1) { 1176 switch (c) { 1177 case 'C': 1178 Cflag = true; 1179 break; 1180 case 'f': 1181 flags |= BDRV_REQ_FUA; 1182 break; 1183 case 'q': 1184 qflag = true; 1185 break; 1186 case 'P': 1187 pattern = parse_pattern(optarg); 1188 if (pattern < 0) { 1189 return -EINVAL; 1190 } 1191 break; 1192 default: 1193 qemuio_command_usage(&writev_cmd); 1194 return -EINVAL; 1195 } 1196 } 1197 1198 if (optind > argc - 2) { 1199 qemuio_command_usage(&writev_cmd); 1200 return -EINVAL; 1201 } 1202 1203 offset = cvtnum(argv[optind]); 1204 if (offset < 0) { 1205 print_cvtnum_err(offset, argv[optind]); 1206 return offset; 1207 } 1208 optind++; 1209 1210 nr_iov = argc - optind; 1211 buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern); 1212 if (buf == NULL) { 1213 return -EINVAL; 1214 } 1215 1216 gettimeofday(&t1, NULL); 1217 ret = do_aio_writev(blk, &qiov, offset, flags, &total); 1218 gettimeofday(&t2, NULL); 1219 1220 if (ret < 0) { 1221 printf("writev failed: %s\n", strerror(-ret)); 1222 goto out; 1223 } 1224 cnt = ret; 1225 1226 ret = 0; 1227 1228 if (qflag) { 1229 goto out; 1230 } 1231 1232 /* Finally, report back -- -C gives a parsable format */ 1233 t2 = tsub(t2, t1); 1234 print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag); 1235 out: 1236 qemu_iovec_destroy(&qiov); 1237 qemu_io_free(buf); 1238 return ret; 1239 } 1240 1241 struct aio_ctx { 1242 BlockBackend *blk; 1243 QEMUIOVector qiov; 1244 int64_t offset; 1245 char *buf; 1246 bool qflag; 1247 bool vflag; 1248 bool Cflag; 1249 bool Pflag; 1250 bool zflag; 1251 BlockAcctCookie acct; 1252 int pattern; 1253 struct timeval t1; 1254 }; 1255 1256 static void aio_write_done(void *opaque, int ret) 1257 { 1258 struct aio_ctx *ctx = opaque; 1259 struct timeval t2; 1260 1261 gettimeofday(&t2, NULL); 1262 1263 1264 if (ret < 0) { 1265 printf("aio_write failed: %s\n", strerror(-ret)); 1266 block_acct_failed(blk_get_stats(ctx->blk), &ctx->acct); 1267 goto out; 1268 } 1269 1270 block_acct_done(blk_get_stats(ctx->blk), &ctx->acct); 1271 1272 if (ctx->qflag) { 1273 goto out; 1274 } 1275 1276 /* Finally, report back -- -C gives a parsable format */ 1277 t2 = tsub(t2, ctx->t1); 1278 print_report("wrote", &t2, ctx->offset, ctx->qiov.size, 1279 ctx->qiov.size, 1, ctx->Cflag); 1280 out: 1281 if (!ctx->zflag) { 1282 qemu_io_free(ctx->buf); 1283 qemu_iovec_destroy(&ctx->qiov); 1284 } 1285 g_free(ctx); 1286 } 1287 1288 static void aio_read_done(void *opaque, int ret) 1289 { 1290 struct aio_ctx *ctx = opaque; 1291 struct timeval t2; 1292 1293 gettimeofday(&t2, NULL); 1294 1295 if (ret < 0) { 1296 printf("readv failed: %s\n", strerror(-ret)); 1297 block_acct_failed(blk_get_stats(ctx->blk), &ctx->acct); 1298 goto out; 1299 } 1300 1301 if (ctx->Pflag) { 1302 void *cmp_buf = g_malloc(ctx->qiov.size); 1303 1304 memset(cmp_buf, ctx->pattern, ctx->qiov.size); 1305 if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) { 1306 printf("Pattern verification failed at offset %" 1307 PRId64 ", %zu bytes\n", ctx->offset, ctx->qiov.size); 1308 } 1309 g_free(cmp_buf); 1310 } 1311 1312 block_acct_done(blk_get_stats(ctx->blk), &ctx->acct); 1313 1314 if (ctx->qflag) { 1315 goto out; 1316 } 1317 1318 if (ctx->vflag) { 1319 dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size); 1320 } 1321 1322 /* Finally, report back -- -C gives a parsable format */ 1323 t2 = tsub(t2, ctx->t1); 1324 print_report("read", &t2, ctx->offset, ctx->qiov.size, 1325 ctx->qiov.size, 1, ctx->Cflag); 1326 out: 1327 qemu_io_free(ctx->buf); 1328 qemu_iovec_destroy(&ctx->qiov); 1329 g_free(ctx); 1330 } 1331 1332 static void aio_read_help(void) 1333 { 1334 printf( 1335 "\n" 1336 " asynchronously reads a range of bytes from the given offset\n" 1337 "\n" 1338 " Example:\n" 1339 " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n" 1340 "\n" 1341 " Reads a segment of the currently open file, optionally dumping it to the\n" 1342 " standard output stream (with -v option) for subsequent inspection.\n" 1343 " The read is performed asynchronously and the aio_flush command must be\n" 1344 " used to ensure all outstanding aio requests have been completed.\n" 1345 " Note that due to its asynchronous nature, this command will be\n" 1346 " considered successful once the request is submitted, independently\n" 1347 " of potential I/O errors or pattern mismatches.\n" 1348 " -C, -- report statistics in a machine parsable format\n" 1349 " -P, -- use a pattern to verify read data\n" 1350 " -i, -- treat request as invalid, for exercising stats\n" 1351 " -v, -- dump buffer to standard output\n" 1352 " -q, -- quiet mode, do not show I/O statistics\n" 1353 "\n"); 1354 } 1355 1356 static int aio_read_f(BlockBackend *blk, int argc, char **argv); 1357 1358 static const cmdinfo_t aio_read_cmd = { 1359 .name = "aio_read", 1360 .cfunc = aio_read_f, 1361 .argmin = 2, 1362 .argmax = -1, 1363 .args = "[-Ciqv] [-P pattern] off len [len..]", 1364 .oneline = "asynchronously reads a number of bytes", 1365 .help = aio_read_help, 1366 }; 1367 1368 static int aio_read_f(BlockBackend *blk, int argc, char **argv) 1369 { 1370 int nr_iov, c; 1371 struct aio_ctx *ctx = g_new0(struct aio_ctx, 1); 1372 1373 ctx->blk = blk; 1374 while ((c = getopt(argc, argv, "CP:iqv")) != -1) { 1375 switch (c) { 1376 case 'C': 1377 ctx->Cflag = true; 1378 break; 1379 case 'P': 1380 ctx->Pflag = true; 1381 ctx->pattern = parse_pattern(optarg); 1382 if (ctx->pattern < 0) { 1383 g_free(ctx); 1384 return -EINVAL; 1385 } 1386 break; 1387 case 'i': 1388 printf("injecting invalid read request\n"); 1389 block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ); 1390 g_free(ctx); 1391 return 0; 1392 case 'q': 1393 ctx->qflag = true; 1394 break; 1395 case 'v': 1396 ctx->vflag = true; 1397 break; 1398 default: 1399 g_free(ctx); 1400 qemuio_command_usage(&aio_read_cmd); 1401 return -EINVAL; 1402 } 1403 } 1404 1405 if (optind > argc - 2) { 1406 g_free(ctx); 1407 qemuio_command_usage(&aio_read_cmd); 1408 return -EINVAL; 1409 } 1410 1411 ctx->offset = cvtnum(argv[optind]); 1412 if (ctx->offset < 0) { 1413 int ret = ctx->offset; 1414 print_cvtnum_err(ret, argv[optind]); 1415 g_free(ctx); 1416 return ret; 1417 } 1418 optind++; 1419 1420 nr_iov = argc - optind; 1421 ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, 0xab); 1422 if (ctx->buf == NULL) { 1423 block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ); 1424 g_free(ctx); 1425 return -EINVAL; 1426 } 1427 1428 gettimeofday(&ctx->t1, NULL); 1429 block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size, 1430 BLOCK_ACCT_READ); 1431 blk_aio_preadv(blk, ctx->offset, &ctx->qiov, 0, aio_read_done, ctx); 1432 return 0; 1433 } 1434 1435 static void aio_write_help(void) 1436 { 1437 printf( 1438 "\n" 1439 " asynchronously writes a range of bytes from the given offset source\n" 1440 " from multiple buffers\n" 1441 "\n" 1442 " Example:\n" 1443 " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n" 1444 "\n" 1445 " Writes into a segment of the currently open file, using a buffer\n" 1446 " filled with a set pattern (0xcdcdcdcd).\n" 1447 " The write is performed asynchronously and the aio_flush command must be\n" 1448 " used to ensure all outstanding aio requests have been completed.\n" 1449 " Note that due to its asynchronous nature, this command will be\n" 1450 " considered successful once the request is submitted, independently\n" 1451 " of potential I/O errors or pattern mismatches.\n" 1452 " -P, -- use different pattern to fill file\n" 1453 " -C, -- report statistics in a machine parsable format\n" 1454 " -f, -- use Force Unit Access semantics\n" 1455 " -i, -- treat request as invalid, for exercising stats\n" 1456 " -q, -- quiet mode, do not show I/O statistics\n" 1457 " -u, -- with -z, allow unmapping\n" 1458 " -z, -- write zeroes using blk_aio_pwrite_zeroes\n" 1459 "\n"); 1460 } 1461 1462 static int aio_write_f(BlockBackend *blk, int argc, char **argv); 1463 1464 static const cmdinfo_t aio_write_cmd = { 1465 .name = "aio_write", 1466 .cfunc = aio_write_f, 1467 .perm = BLK_PERM_WRITE, 1468 .argmin = 2, 1469 .argmax = -1, 1470 .args = "[-Cfiquz] [-P pattern] off len [len..]", 1471 .oneline = "asynchronously writes a number of bytes", 1472 .help = aio_write_help, 1473 }; 1474 1475 static int aio_write_f(BlockBackend *blk, int argc, char **argv) 1476 { 1477 int nr_iov, c; 1478 int pattern = 0xcd; 1479 struct aio_ctx *ctx = g_new0(struct aio_ctx, 1); 1480 int flags = 0; 1481 1482 ctx->blk = blk; 1483 while ((c = getopt(argc, argv, "CfiqP:uz")) != -1) { 1484 switch (c) { 1485 case 'C': 1486 ctx->Cflag = true; 1487 break; 1488 case 'f': 1489 flags |= BDRV_REQ_FUA; 1490 break; 1491 case 'q': 1492 ctx->qflag = true; 1493 break; 1494 case 'u': 1495 flags |= BDRV_REQ_MAY_UNMAP; 1496 break; 1497 case 'P': 1498 pattern = parse_pattern(optarg); 1499 if (pattern < 0) { 1500 g_free(ctx); 1501 return -EINVAL; 1502 } 1503 break; 1504 case 'i': 1505 printf("injecting invalid write request\n"); 1506 block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE); 1507 g_free(ctx); 1508 return 0; 1509 case 'z': 1510 ctx->zflag = true; 1511 break; 1512 default: 1513 g_free(ctx); 1514 qemuio_command_usage(&aio_write_cmd); 1515 return -EINVAL; 1516 } 1517 } 1518 1519 if (optind > argc - 2) { 1520 g_free(ctx); 1521 qemuio_command_usage(&aio_write_cmd); 1522 return -EINVAL; 1523 } 1524 1525 if (ctx->zflag && optind != argc - 2) { 1526 printf("-z supports only a single length parameter\n"); 1527 g_free(ctx); 1528 return -EINVAL; 1529 } 1530 1531 if ((flags & BDRV_REQ_MAY_UNMAP) && !ctx->zflag) { 1532 printf("-u requires -z to be specified\n"); 1533 g_free(ctx); 1534 return -EINVAL; 1535 } 1536 1537 if (ctx->zflag && ctx->Pflag) { 1538 printf("-z and -P cannot be specified at the same time\n"); 1539 g_free(ctx); 1540 return -EINVAL; 1541 } 1542 1543 ctx->offset = cvtnum(argv[optind]); 1544 if (ctx->offset < 0) { 1545 int ret = ctx->offset; 1546 print_cvtnum_err(ret, argv[optind]); 1547 g_free(ctx); 1548 return ret; 1549 } 1550 optind++; 1551 1552 if (ctx->zflag) { 1553 int64_t count = cvtnum(argv[optind]); 1554 if (count < 0) { 1555 print_cvtnum_err(count, argv[optind]); 1556 g_free(ctx); 1557 return count; 1558 } 1559 1560 ctx->qiov.size = count; 1561 blk_aio_pwrite_zeroes(blk, ctx->offset, count, flags, aio_write_done, 1562 ctx); 1563 } else { 1564 nr_iov = argc - optind; 1565 ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, 1566 pattern); 1567 if (ctx->buf == NULL) { 1568 block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE); 1569 g_free(ctx); 1570 return -EINVAL; 1571 } 1572 1573 gettimeofday(&ctx->t1, NULL); 1574 block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size, 1575 BLOCK_ACCT_WRITE); 1576 1577 blk_aio_pwritev(blk, ctx->offset, &ctx->qiov, flags, aio_write_done, 1578 ctx); 1579 } 1580 1581 return 0; 1582 } 1583 1584 static int aio_flush_f(BlockBackend *blk, int argc, char **argv) 1585 { 1586 BlockAcctCookie cookie; 1587 block_acct_start(blk_get_stats(blk), &cookie, 0, BLOCK_ACCT_FLUSH); 1588 blk_drain_all(); 1589 block_acct_done(blk_get_stats(blk), &cookie); 1590 return 0; 1591 } 1592 1593 static const cmdinfo_t aio_flush_cmd = { 1594 .name = "aio_flush", 1595 .cfunc = aio_flush_f, 1596 .oneline = "completes all outstanding aio requests" 1597 }; 1598 1599 static int flush_f(BlockBackend *blk, int argc, char **argv) 1600 { 1601 return blk_flush(blk); 1602 } 1603 1604 static const cmdinfo_t flush_cmd = { 1605 .name = "flush", 1606 .altname = "f", 1607 .cfunc = flush_f, 1608 .oneline = "flush all in-core file state to disk", 1609 }; 1610 1611 static int truncate_f(BlockBackend *blk, int argc, char **argv) 1612 { 1613 Error *local_err = NULL; 1614 int64_t offset; 1615 int ret; 1616 1617 offset = cvtnum(argv[1]); 1618 if (offset < 0) { 1619 print_cvtnum_err(offset, argv[1]); 1620 return offset; 1621 } 1622 1623 ret = blk_truncate(blk, offset, PREALLOC_MODE_OFF, &local_err); 1624 if (ret < 0) { 1625 error_report_err(local_err); 1626 return ret; 1627 } 1628 1629 return 0; 1630 } 1631 1632 static const cmdinfo_t truncate_cmd = { 1633 .name = "truncate", 1634 .altname = "t", 1635 .cfunc = truncate_f, 1636 .perm = BLK_PERM_WRITE | BLK_PERM_RESIZE, 1637 .argmin = 1, 1638 .argmax = 1, 1639 .args = "off", 1640 .oneline = "truncates the current file at the given offset", 1641 }; 1642 1643 static int length_f(BlockBackend *blk, int argc, char **argv) 1644 { 1645 int64_t size; 1646 char s1[64]; 1647 1648 size = blk_getlength(blk); 1649 if (size < 0) { 1650 printf("getlength: %s\n", strerror(-size)); 1651 return size; 1652 } 1653 1654 cvtstr(size, s1, sizeof(s1)); 1655 printf("%s\n", s1); 1656 return 0; 1657 } 1658 1659 1660 static const cmdinfo_t length_cmd = { 1661 .name = "length", 1662 .altname = "l", 1663 .cfunc = length_f, 1664 .oneline = "gets the length of the current file", 1665 }; 1666 1667 1668 static int info_f(BlockBackend *blk, int argc, char **argv) 1669 { 1670 BlockDriverState *bs = blk_bs(blk); 1671 BlockDriverInfo bdi; 1672 ImageInfoSpecific *spec_info; 1673 Error *local_err = NULL; 1674 char s1[64], s2[64]; 1675 int ret; 1676 1677 if (bs->drv && bs->drv->format_name) { 1678 printf("format name: %s\n", bs->drv->format_name); 1679 } 1680 if (bs->drv && bs->drv->protocol_name) { 1681 printf("format name: %s\n", bs->drv->protocol_name); 1682 } 1683 1684 ret = bdrv_get_info(bs, &bdi); 1685 if (ret) { 1686 return ret; 1687 } 1688 1689 cvtstr(bdi.cluster_size, s1, sizeof(s1)); 1690 cvtstr(bdi.vm_state_offset, s2, sizeof(s2)); 1691 1692 printf("cluster size: %s\n", s1); 1693 printf("vm state offset: %s\n", s2); 1694 1695 spec_info = bdrv_get_specific_info(bs, &local_err); 1696 if (local_err) { 1697 error_report_err(local_err); 1698 return -EIO; 1699 } 1700 if (spec_info) { 1701 printf("Format specific information:\n"); 1702 bdrv_image_info_specific_dump(spec_info); 1703 qapi_free_ImageInfoSpecific(spec_info); 1704 } 1705 1706 return 0; 1707 } 1708 1709 1710 1711 static const cmdinfo_t info_cmd = { 1712 .name = "info", 1713 .altname = "i", 1714 .cfunc = info_f, 1715 .oneline = "prints information about the current file", 1716 }; 1717 1718 static void discard_help(void) 1719 { 1720 printf( 1721 "\n" 1722 " discards a range of bytes from the given offset\n" 1723 "\n" 1724 " Example:\n" 1725 " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n" 1726 "\n" 1727 " Discards a segment of the currently open file.\n" 1728 " -C, -- report statistics in a machine parsable format\n" 1729 " -q, -- quiet mode, do not show I/O statistics\n" 1730 "\n"); 1731 } 1732 1733 static int discard_f(BlockBackend *blk, int argc, char **argv); 1734 1735 static const cmdinfo_t discard_cmd = { 1736 .name = "discard", 1737 .altname = "d", 1738 .cfunc = discard_f, 1739 .perm = BLK_PERM_WRITE, 1740 .argmin = 2, 1741 .argmax = -1, 1742 .args = "[-Cq] off len", 1743 .oneline = "discards a number of bytes at a specified offset", 1744 .help = discard_help, 1745 }; 1746 1747 static int discard_f(BlockBackend *blk, int argc, char **argv) 1748 { 1749 struct timeval t1, t2; 1750 bool Cflag = false, qflag = false; 1751 int c, ret; 1752 int64_t offset, bytes; 1753 1754 while ((c = getopt(argc, argv, "Cq")) != -1) { 1755 switch (c) { 1756 case 'C': 1757 Cflag = true; 1758 break; 1759 case 'q': 1760 qflag = true; 1761 break; 1762 default: 1763 qemuio_command_usage(&discard_cmd); 1764 return -EINVAL; 1765 } 1766 } 1767 1768 if (optind != argc - 2) { 1769 qemuio_command_usage(&discard_cmd); 1770 return -EINVAL; 1771 } 1772 1773 offset = cvtnum(argv[optind]); 1774 if (offset < 0) { 1775 print_cvtnum_err(offset, argv[optind]); 1776 return offset; 1777 } 1778 1779 optind++; 1780 bytes = cvtnum(argv[optind]); 1781 if (bytes < 0) { 1782 print_cvtnum_err(bytes, argv[optind]); 1783 return bytes; 1784 } else if (bytes >> BDRV_SECTOR_BITS > BDRV_REQUEST_MAX_SECTORS) { 1785 printf("length cannot exceed %"PRIu64", given %s\n", 1786 (uint64_t)BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS, 1787 argv[optind]); 1788 return -EINVAL; 1789 } 1790 1791 gettimeofday(&t1, NULL); 1792 ret = blk_pdiscard(blk, offset, bytes); 1793 gettimeofday(&t2, NULL); 1794 1795 if (ret < 0) { 1796 printf("discard failed: %s\n", strerror(-ret)); 1797 return ret; 1798 } 1799 1800 /* Finally, report back -- -C gives a parsable format */ 1801 if (!qflag) { 1802 t2 = tsub(t2, t1); 1803 print_report("discard", &t2, offset, bytes, bytes, 1, Cflag); 1804 } 1805 1806 return 0; 1807 } 1808 1809 static int alloc_f(BlockBackend *blk, int argc, char **argv) 1810 { 1811 BlockDriverState *bs = blk_bs(blk); 1812 int64_t offset, start, remaining, count; 1813 char s1[64]; 1814 int ret; 1815 int64_t num, sum_alloc; 1816 1817 start = offset = cvtnum(argv[1]); 1818 if (offset < 0) { 1819 print_cvtnum_err(offset, argv[1]); 1820 return offset; 1821 } 1822 1823 if (argc == 3) { 1824 count = cvtnum(argv[2]); 1825 if (count < 0) { 1826 print_cvtnum_err(count, argv[2]); 1827 return count; 1828 } 1829 } else { 1830 count = BDRV_SECTOR_SIZE; 1831 } 1832 1833 remaining = count; 1834 sum_alloc = 0; 1835 while (remaining) { 1836 ret = bdrv_is_allocated(bs, offset, remaining, &num); 1837 if (ret < 0) { 1838 printf("is_allocated failed: %s\n", strerror(-ret)); 1839 return ret; 1840 } 1841 offset += num; 1842 remaining -= num; 1843 if (ret) { 1844 sum_alloc += num; 1845 } 1846 if (num == 0) { 1847 count -= remaining; 1848 remaining = 0; 1849 } 1850 } 1851 1852 cvtstr(start, s1, sizeof(s1)); 1853 1854 printf("%"PRId64"/%"PRId64" bytes allocated at offset %s\n", 1855 sum_alloc, count, s1); 1856 return 0; 1857 } 1858 1859 static const cmdinfo_t alloc_cmd = { 1860 .name = "alloc", 1861 .altname = "a", 1862 .argmin = 1, 1863 .argmax = 2, 1864 .cfunc = alloc_f, 1865 .args = "offset [count]", 1866 .oneline = "checks if offset is allocated in the file", 1867 }; 1868 1869 1870 static int map_is_allocated(BlockDriverState *bs, int64_t offset, 1871 int64_t bytes, int64_t *pnum) 1872 { 1873 int64_t num; 1874 int num_checked; 1875 int ret, firstret; 1876 1877 num_checked = MIN(bytes, BDRV_REQUEST_MAX_BYTES); 1878 ret = bdrv_is_allocated(bs, offset, num_checked, &num); 1879 if (ret < 0) { 1880 return ret; 1881 } 1882 1883 firstret = ret; 1884 *pnum = num; 1885 1886 while (bytes > 0 && ret == firstret) { 1887 offset += num; 1888 bytes -= num; 1889 1890 num_checked = MIN(bytes, BDRV_REQUEST_MAX_BYTES); 1891 ret = bdrv_is_allocated(bs, offset, num_checked, &num); 1892 if (ret == firstret && num) { 1893 *pnum += num; 1894 } else { 1895 break; 1896 } 1897 } 1898 1899 return firstret; 1900 } 1901 1902 static int map_f(BlockBackend *blk, int argc, char **argv) 1903 { 1904 int64_t offset, bytes; 1905 char s1[64], s2[64]; 1906 int64_t num; 1907 int ret; 1908 const char *retstr; 1909 1910 offset = 0; 1911 bytes = blk_getlength(blk); 1912 if (bytes < 0) { 1913 error_report("Failed to query image length: %s", strerror(-bytes)); 1914 return bytes; 1915 } 1916 1917 while (bytes) { 1918 ret = map_is_allocated(blk_bs(blk), offset, bytes, &num); 1919 if (ret < 0) { 1920 error_report("Failed to get allocation status: %s", strerror(-ret)); 1921 return ret; 1922 } else if (!num) { 1923 error_report("Unexpected end of image"); 1924 return -EIO; 1925 } 1926 1927 retstr = ret ? " allocated" : "not allocated"; 1928 cvtstr(num, s1, sizeof(s1)); 1929 cvtstr(offset, s2, sizeof(s2)); 1930 printf("%s (0x%" PRIx64 ") bytes %s at offset %s (0x%" PRIx64 ")\n", 1931 s1, num, retstr, s2, offset); 1932 1933 offset += num; 1934 bytes -= num; 1935 } 1936 1937 return 0; 1938 } 1939 1940 static const cmdinfo_t map_cmd = { 1941 .name = "map", 1942 .argmin = 0, 1943 .argmax = 0, 1944 .cfunc = map_f, 1945 .args = "", 1946 .oneline = "prints the allocated areas of a file", 1947 }; 1948 1949 static void reopen_help(void) 1950 { 1951 printf( 1952 "\n" 1953 " Changes the open options of an already opened image\n" 1954 "\n" 1955 " Example:\n" 1956 " 'reopen -o lazy-refcounts=on' - activates lazy refcount writeback on a qcow2 image\n" 1957 "\n" 1958 " -r, -- Reopen the image read-only\n" 1959 " -w, -- Reopen the image read-write\n" 1960 " -c, -- Change the cache mode to the given value\n" 1961 " -o, -- Changes block driver options (cf. 'open' command)\n" 1962 "\n"); 1963 } 1964 1965 static int reopen_f(BlockBackend *blk, int argc, char **argv); 1966 1967 static QemuOptsList reopen_opts = { 1968 .name = "reopen", 1969 .merge_lists = true, 1970 .head = QTAILQ_HEAD_INITIALIZER(reopen_opts.head), 1971 .desc = { 1972 /* no elements => accept any params */ 1973 { /* end of list */ } 1974 }, 1975 }; 1976 1977 static const cmdinfo_t reopen_cmd = { 1978 .name = "reopen", 1979 .argmin = 0, 1980 .argmax = -1, 1981 .cfunc = reopen_f, 1982 .args = "[(-r|-w)] [-c cache] [-o options]", 1983 .oneline = "reopens an image with new options", 1984 .help = reopen_help, 1985 }; 1986 1987 static int reopen_f(BlockBackend *blk, int argc, char **argv) 1988 { 1989 BlockDriverState *bs = blk_bs(blk); 1990 QemuOpts *qopts; 1991 QDict *opts; 1992 int c; 1993 int flags = bs->open_flags; 1994 bool writethrough = !blk_enable_write_cache(blk); 1995 bool has_rw_option = false; 1996 bool has_cache_option = false; 1997 1998 BlockReopenQueue *brq; 1999 Error *local_err = NULL; 2000 2001 while ((c = getopt(argc, argv, "c:o:rw")) != -1) { 2002 switch (c) { 2003 case 'c': 2004 if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) { 2005 error_report("Invalid cache option: %s", optarg); 2006 return -EINVAL; 2007 } 2008 has_cache_option = true; 2009 break; 2010 case 'o': 2011 if (!qemu_opts_parse_noisily(&reopen_opts, optarg, 0)) { 2012 qemu_opts_reset(&reopen_opts); 2013 return -EINVAL; 2014 } 2015 break; 2016 case 'r': 2017 if (has_rw_option) { 2018 error_report("Only one -r/-w option may be given"); 2019 return -EINVAL; 2020 } 2021 flags &= ~BDRV_O_RDWR; 2022 has_rw_option = true; 2023 break; 2024 case 'w': 2025 if (has_rw_option) { 2026 error_report("Only one -r/-w option may be given"); 2027 return -EINVAL; 2028 } 2029 flags |= BDRV_O_RDWR; 2030 has_rw_option = true; 2031 break; 2032 default: 2033 qemu_opts_reset(&reopen_opts); 2034 qemuio_command_usage(&reopen_cmd); 2035 return -EINVAL; 2036 } 2037 } 2038 2039 if (optind != argc) { 2040 qemu_opts_reset(&reopen_opts); 2041 qemuio_command_usage(&reopen_cmd); 2042 return -EINVAL; 2043 } 2044 2045 if (!writethrough != blk_enable_write_cache(blk) && 2046 blk_get_attached_dev(blk)) 2047 { 2048 error_report("Cannot change cache.writeback: Device attached"); 2049 qemu_opts_reset(&reopen_opts); 2050 return -EBUSY; 2051 } 2052 2053 if (!(flags & BDRV_O_RDWR)) { 2054 uint64_t orig_perm, orig_shared_perm; 2055 2056 bdrv_drain(bs); 2057 2058 blk_get_perm(blk, &orig_perm, &orig_shared_perm); 2059 blk_set_perm(blk, 2060 orig_perm & ~(BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED), 2061 orig_shared_perm, 2062 &error_abort); 2063 } 2064 2065 qopts = qemu_opts_find(&reopen_opts, NULL); 2066 opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : qdict_new(); 2067 qemu_opts_reset(&reopen_opts); 2068 2069 if (qdict_haskey(opts, BDRV_OPT_READ_ONLY)) { 2070 if (has_rw_option) { 2071 error_report("Cannot set both -r/-w and '" BDRV_OPT_READ_ONLY "'"); 2072 qobject_unref(opts); 2073 return -EINVAL; 2074 } 2075 } else { 2076 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR)); 2077 } 2078 2079 if (qdict_haskey(opts, BDRV_OPT_CACHE_DIRECT) || 2080 qdict_haskey(opts, BDRV_OPT_CACHE_NO_FLUSH)) { 2081 if (has_cache_option) { 2082 error_report("Cannot set both -c and the cache options"); 2083 qobject_unref(opts); 2084 return -EINVAL; 2085 } 2086 } else { 2087 qdict_put_bool(opts, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE); 2088 qdict_put_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, flags & BDRV_O_NO_FLUSH); 2089 } 2090 2091 bdrv_subtree_drained_begin(bs); 2092 brq = bdrv_reopen_queue(NULL, bs, opts, true); 2093 bdrv_reopen_multiple(brq, &local_err); 2094 bdrv_subtree_drained_end(bs); 2095 2096 if (local_err) { 2097 error_report_err(local_err); 2098 return -EINVAL; 2099 } 2100 2101 blk_set_enable_write_cache(blk, !writethrough); 2102 return 0; 2103 } 2104 2105 static int break_f(BlockBackend *blk, int argc, char **argv) 2106 { 2107 int ret; 2108 2109 ret = bdrv_debug_breakpoint(blk_bs(blk), argv[1], argv[2]); 2110 if (ret < 0) { 2111 printf("Could not set breakpoint: %s\n", strerror(-ret)); 2112 return ret; 2113 } 2114 2115 return 0; 2116 } 2117 2118 static int remove_break_f(BlockBackend *blk, int argc, char **argv) 2119 { 2120 int ret; 2121 2122 ret = bdrv_debug_remove_breakpoint(blk_bs(blk), argv[1]); 2123 if (ret < 0) { 2124 printf("Could not remove breakpoint %s: %s\n", argv[1], strerror(-ret)); 2125 return ret; 2126 } 2127 2128 return 0; 2129 } 2130 2131 static const cmdinfo_t break_cmd = { 2132 .name = "break", 2133 .argmin = 2, 2134 .argmax = 2, 2135 .cfunc = break_f, 2136 .args = "event tag", 2137 .oneline = "sets a breakpoint on event and tags the stopped " 2138 "request as tag", 2139 }; 2140 2141 static const cmdinfo_t remove_break_cmd = { 2142 .name = "remove_break", 2143 .argmin = 1, 2144 .argmax = 1, 2145 .cfunc = remove_break_f, 2146 .args = "tag", 2147 .oneline = "remove a breakpoint by tag", 2148 }; 2149 2150 static int resume_f(BlockBackend *blk, int argc, char **argv) 2151 { 2152 int ret; 2153 2154 ret = bdrv_debug_resume(blk_bs(blk), argv[1]); 2155 if (ret < 0) { 2156 printf("Could not resume request: %s\n", strerror(-ret)); 2157 return ret; 2158 } 2159 2160 return 0; 2161 } 2162 2163 static const cmdinfo_t resume_cmd = { 2164 .name = "resume", 2165 .argmin = 1, 2166 .argmax = 1, 2167 .cfunc = resume_f, 2168 .args = "tag", 2169 .oneline = "resumes the request tagged as tag", 2170 }; 2171 2172 static int wait_break_f(BlockBackend *blk, int argc, char **argv) 2173 { 2174 while (!bdrv_debug_is_suspended(blk_bs(blk), argv[1])) { 2175 aio_poll(blk_get_aio_context(blk), true); 2176 } 2177 return 0; 2178 } 2179 2180 static const cmdinfo_t wait_break_cmd = { 2181 .name = "wait_break", 2182 .argmin = 1, 2183 .argmax = 1, 2184 .cfunc = wait_break_f, 2185 .args = "tag", 2186 .oneline = "waits for the suspension of a request", 2187 }; 2188 2189 static int abort_f(BlockBackend *blk, int argc, char **argv) 2190 { 2191 abort(); 2192 } 2193 2194 static const cmdinfo_t abort_cmd = { 2195 .name = "abort", 2196 .cfunc = abort_f, 2197 .flags = CMD_NOFILE_OK, 2198 .oneline = "simulate a program crash using abort(3)", 2199 }; 2200 2201 static void sigraise_help(void) 2202 { 2203 printf( 2204 "\n" 2205 " raises the given signal\n" 2206 "\n" 2207 " Example:\n" 2208 " 'sigraise %i' - raises SIGTERM\n" 2209 "\n" 2210 " Invokes raise(signal), where \"signal\" is the mandatory integer argument\n" 2211 " given to sigraise.\n" 2212 "\n", SIGTERM); 2213 } 2214 2215 static int sigraise_f(BlockBackend *blk, int argc, char **argv); 2216 2217 static const cmdinfo_t sigraise_cmd = { 2218 .name = "sigraise", 2219 .cfunc = sigraise_f, 2220 .argmin = 1, 2221 .argmax = 1, 2222 .flags = CMD_NOFILE_OK, 2223 .args = "signal", 2224 .oneline = "raises a signal", 2225 .help = sigraise_help, 2226 }; 2227 2228 static int sigraise_f(BlockBackend *blk, int argc, char **argv) 2229 { 2230 int64_t sig = cvtnum(argv[1]); 2231 if (sig < 0) { 2232 print_cvtnum_err(sig, argv[1]); 2233 return sig; 2234 } else if (sig > NSIG) { 2235 printf("signal argument '%s' is too large to be a valid signal\n", 2236 argv[1]); 2237 return -EINVAL; 2238 } 2239 2240 /* Using raise() to kill this process does not necessarily flush all open 2241 * streams. At least stdout and stderr (although the latter should be 2242 * non-buffered anyway) should be flushed, though. */ 2243 fflush(stdout); 2244 fflush(stderr); 2245 2246 raise(sig); 2247 2248 return 0; 2249 } 2250 2251 static void sleep_cb(void *opaque) 2252 { 2253 bool *expired = opaque; 2254 *expired = true; 2255 } 2256 2257 static int sleep_f(BlockBackend *blk, int argc, char **argv) 2258 { 2259 char *endptr; 2260 long ms; 2261 struct QEMUTimer *timer; 2262 bool expired = false; 2263 2264 ms = strtol(argv[1], &endptr, 0); 2265 if (ms < 0 || *endptr != '\0') { 2266 printf("%s is not a valid number\n", argv[1]); 2267 return -EINVAL; 2268 } 2269 2270 timer = timer_new_ns(QEMU_CLOCK_HOST, sleep_cb, &expired); 2271 timer_mod(timer, qemu_clock_get_ns(QEMU_CLOCK_HOST) + SCALE_MS * ms); 2272 2273 while (!expired) { 2274 main_loop_wait(false); 2275 } 2276 2277 timer_free(timer); 2278 return 0; 2279 } 2280 2281 static const cmdinfo_t sleep_cmd = { 2282 .name = "sleep", 2283 .argmin = 1, 2284 .argmax = 1, 2285 .cfunc = sleep_f, 2286 .flags = CMD_NOFILE_OK, 2287 .oneline = "waits for the given value in milliseconds", 2288 }; 2289 2290 static void help_oneline(const char *cmd, const cmdinfo_t *ct) 2291 { 2292 if (cmd) { 2293 printf("%s ", cmd); 2294 } else { 2295 printf("%s ", ct->name); 2296 if (ct->altname) { 2297 printf("(or %s) ", ct->altname); 2298 } 2299 } 2300 2301 if (ct->args) { 2302 printf("%s ", ct->args); 2303 } 2304 printf("-- %s\n", ct->oneline); 2305 } 2306 2307 static void help_onecmd(const char *cmd, const cmdinfo_t *ct) 2308 { 2309 help_oneline(cmd, ct); 2310 if (ct->help) { 2311 ct->help(); 2312 } 2313 } 2314 2315 static void help_all(void) 2316 { 2317 const cmdinfo_t *ct; 2318 2319 for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) { 2320 help_oneline(ct->name, ct); 2321 } 2322 printf("\nUse 'help commandname' for extended help.\n"); 2323 } 2324 2325 static int help_f(BlockBackend *blk, int argc, char **argv) 2326 { 2327 const cmdinfo_t *ct; 2328 2329 if (argc == 1) { 2330 help_all(); 2331 return 0; 2332 } 2333 2334 ct = find_command(argv[1]); 2335 if (ct == NULL) { 2336 printf("command %s not found\n", argv[1]); 2337 return -EINVAL; 2338 } 2339 2340 help_onecmd(argv[1], ct); 2341 return 0; 2342 } 2343 2344 static const cmdinfo_t help_cmd = { 2345 .name = "help", 2346 .altname = "?", 2347 .cfunc = help_f, 2348 .argmin = 0, 2349 .argmax = 1, 2350 .flags = CMD_FLAG_GLOBAL, 2351 .args = "[command]", 2352 .oneline = "help for one or all commands", 2353 }; 2354 2355 int qemuio_command(BlockBackend *blk, const char *cmd) 2356 { 2357 AioContext *ctx; 2358 char *input; 2359 const cmdinfo_t *ct; 2360 char **v; 2361 int c; 2362 int ret = 0; 2363 2364 input = g_strdup(cmd); 2365 v = breakline(input, &c); 2366 if (c) { 2367 ct = find_command(v[0]); 2368 if (ct) { 2369 ctx = blk ? blk_get_aio_context(blk) : qemu_get_aio_context(); 2370 aio_context_acquire(ctx); 2371 ret = command(blk, ct, c, v); 2372 aio_context_release(ctx); 2373 } else { 2374 fprintf(stderr, "command \"%s\" not found\n", v[0]); 2375 ret = -EINVAL; 2376 } 2377 } 2378 g_free(input); 2379 g_free(v); 2380 2381 return ret; 2382 } 2383 2384 static void __attribute((constructor)) init_qemuio_commands(void) 2385 { 2386 /* initialize commands */ 2387 qemuio_add_command(&help_cmd); 2388 qemuio_add_command(&read_cmd); 2389 qemuio_add_command(&readv_cmd); 2390 qemuio_add_command(&write_cmd); 2391 qemuio_add_command(&writev_cmd); 2392 qemuio_add_command(&aio_read_cmd); 2393 qemuio_add_command(&aio_write_cmd); 2394 qemuio_add_command(&aio_flush_cmd); 2395 qemuio_add_command(&flush_cmd); 2396 qemuio_add_command(&truncate_cmd); 2397 qemuio_add_command(&length_cmd); 2398 qemuio_add_command(&info_cmd); 2399 qemuio_add_command(&discard_cmd); 2400 qemuio_add_command(&alloc_cmd); 2401 qemuio_add_command(&map_cmd); 2402 qemuio_add_command(&reopen_cmd); 2403 qemuio_add_command(&break_cmd); 2404 qemuio_add_command(&remove_break_cmd); 2405 qemuio_add_command(&resume_cmd); 2406 qemuio_add_command(&wait_break_cmd); 2407 qemuio_add_command(&abort_cmd); 2408 qemuio_add_command(&sleep_cmd); 2409 qemuio_add_command(&sigraise_cmd); 2410 } 2411