usb-redir: Notify our peer when we reject a device due to a speed mismatch
[qemu.git] / qemu-io.c
blobe6fcd7719ef75f03f4358c6f38386274b0f44404
1 /*
2 * Command line utility to exercise the QEMU I/O path.
4 * Copyright (C) 2009 Red Hat, Inc.
5 * Copyright (c) 2003-2005 Silicon Graphics, Inc.
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 #include <sys/time.h>
11 #include <sys/types.h>
12 #include <stdarg.h>
13 #include <stdio.h>
14 #include <getopt.h>
15 #include <libgen.h>
17 #include "qemu-common.h"
18 #include "block_int.h"
19 #include "cmd.h"
20 #include "trace/control.h"
22 #define VERSION "0.0.1"
24 #define CMD_NOFILE_OK 0x01
26 char *progname;
27 static BlockDriverState *bs;
29 static int misalign;
32 * Parse the pattern argument to various sub-commands.
34 * Because the pattern is used as an argument to memset it must evaluate
35 * to an unsigned integer that fits into a single byte.
37 static int parse_pattern(const char *arg)
39 char *endptr = NULL;
40 long pattern;
42 pattern = strtol(arg, &endptr, 0);
43 if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {
44 printf("%s is not a valid pattern byte\n", arg);
45 return -1;
48 return pattern;
52 * Memory allocation helpers.
54 * Make sure memory is aligned by default, or purposefully misaligned if
55 * that is specified on the command line.
58 #define MISALIGN_OFFSET 16
59 static void *qemu_io_alloc(size_t len, int pattern)
61 void *buf;
63 if (misalign) {
64 len += MISALIGN_OFFSET;
66 buf = qemu_blockalign(bs, len);
67 memset(buf, pattern, len);
68 if (misalign) {
69 buf += MISALIGN_OFFSET;
71 return buf;
74 static void qemu_io_free(void *p)
76 if (misalign) {
77 p -= MISALIGN_OFFSET;
79 qemu_vfree(p);
82 static void dump_buffer(const void *buffer, int64_t offset, int len)
84 int i, j;
85 const uint8_t *p;
87 for (i = 0, p = buffer; i < len; i += 16) {
88 const uint8_t *s = p;
90 printf("%08" PRIx64 ": ", offset + i);
91 for (j = 0; j < 16 && i + j < len; j++, p++) {
92 printf("%02x ", *p);
94 printf(" ");
95 for (j = 0; j < 16 && i + j < len; j++, s++) {
96 if (isalnum(*s)) {
97 printf("%c", *s);
98 } else {
99 printf(".");
102 printf("\n");
106 static void print_report(const char *op, struct timeval *t, int64_t offset,
107 int count, int total, int cnt, int Cflag)
109 char s1[64], s2[64], ts[64];
111 timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
112 if (!Cflag) {
113 cvtstr((double)total, s1, sizeof(s1));
114 cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
115 printf("%s %d/%d bytes at offset %" PRId64 "\n",
116 op, total, count, offset);
117 printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
118 s1, cnt, ts, s2, tdiv((double)cnt, *t));
119 } else {/* bytes,ops,time,bytes/sec,ops/sec */
120 printf("%d,%d,%s,%.3f,%.3f\n",
121 total, cnt, ts,
122 tdiv((double)total, *t),
123 tdiv((double)cnt, *t));
128 * Parse multiple length statements for vectored I/O, and construct an I/O
129 * vector matching it.
131 static void *
132 create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
134 size_t *sizes = g_new0(size_t, nr_iov);
135 size_t count = 0;
136 void *buf = NULL;
137 void *p;
138 int i;
140 for (i = 0; i < nr_iov; i++) {
141 char *arg = argv[i];
142 int64_t len;
144 len = cvtnum(arg);
145 if (len < 0) {
146 printf("non-numeric length argument -- %s\n", arg);
147 goto fail;
150 /* should be SIZE_T_MAX, but that doesn't exist */
151 if (len > INT_MAX) {
152 printf("too large length argument -- %s\n", arg);
153 goto fail;
156 if (len & 0x1ff) {
157 printf("length argument %" PRId64
158 " is not sector aligned\n", len);
159 goto fail;
162 sizes[i] = len;
163 count += len;
166 qemu_iovec_init(qiov, nr_iov);
168 buf = p = qemu_io_alloc(count, pattern);
170 for (i = 0; i < nr_iov; i++) {
171 qemu_iovec_add(qiov, p, sizes[i]);
172 p += sizes[i];
175 fail:
176 g_free(sizes);
177 return buf;
180 static int do_read(char *buf, int64_t offset, int count, int *total)
182 int ret;
184 ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
185 if (ret < 0) {
186 return ret;
188 *total = count;
189 return 1;
192 static int do_write(char *buf, int64_t offset, int count, int *total)
194 int ret;
196 ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
197 if (ret < 0) {
198 return ret;
200 *total = count;
201 return 1;
204 static int do_pread(char *buf, int64_t offset, int count, int *total)
206 *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
207 if (*total < 0) {
208 return *total;
210 return 1;
213 static int do_pwrite(char *buf, int64_t offset, int count, int *total)
215 *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
216 if (*total < 0) {
217 return *total;
219 return 1;
222 typedef struct {
223 int64_t offset;
224 int count;
225 int *total;
226 int ret;
227 bool done;
228 } CoWriteZeroes;
230 static void coroutine_fn co_write_zeroes_entry(void *opaque)
232 CoWriteZeroes *data = opaque;
234 data->ret = bdrv_co_write_zeroes(bs, data->offset / BDRV_SECTOR_SIZE,
235 data->count / BDRV_SECTOR_SIZE);
236 data->done = true;
237 if (data->ret < 0) {
238 *data->total = data->ret;
239 return;
242 *data->total = data->count;
245 static int do_co_write_zeroes(int64_t offset, int count, int *total)
247 Coroutine *co;
248 CoWriteZeroes data = {
249 .offset = offset,
250 .count = count,
251 .total = total,
252 .done = false,
255 co = qemu_coroutine_create(co_write_zeroes_entry);
256 qemu_coroutine_enter(co, &data);
257 while (!data.done) {
258 qemu_aio_wait();
260 if (data.ret < 0) {
261 return data.ret;
262 } else {
263 return 1;
267 static int do_load_vmstate(char *buf, int64_t offset, int count, int *total)
269 *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
270 if (*total < 0) {
271 return *total;
273 return 1;
276 static int do_save_vmstate(char *buf, int64_t offset, int count, int *total)
278 *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
279 if (*total < 0) {
280 return *total;
282 return 1;
285 #define NOT_DONE 0x7fffffff
286 static void aio_rw_done(void *opaque, int ret)
288 *(int *)opaque = ret;
291 static int do_aio_readv(QEMUIOVector *qiov, int64_t offset, int *total)
293 int async_ret = NOT_DONE;
295 bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
296 aio_rw_done, &async_ret);
297 while (async_ret == NOT_DONE) {
298 qemu_aio_wait();
301 *total = qiov->size;
302 return async_ret < 0 ? async_ret : 1;
305 static int do_aio_writev(QEMUIOVector *qiov, int64_t offset, int *total)
307 int async_ret = NOT_DONE;
309 bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
310 aio_rw_done, &async_ret);
311 while (async_ret == NOT_DONE) {
312 qemu_aio_wait();
315 *total = qiov->size;
316 return async_ret < 0 ? async_ret : 1;
319 struct multiwrite_async_ret {
320 int num_done;
321 int error;
324 static void multiwrite_cb(void *opaque, int ret)
326 struct multiwrite_async_ret *async_ret = opaque;
328 async_ret->num_done++;
329 if (ret < 0) {
330 async_ret->error = ret;
334 static int do_aio_multiwrite(BlockRequest* reqs, int num_reqs, int *total)
336 int i, ret;
337 struct multiwrite_async_ret async_ret = {
338 .num_done = 0,
339 .error = 0,
342 *total = 0;
343 for (i = 0; i < num_reqs; i++) {
344 reqs[i].cb = multiwrite_cb;
345 reqs[i].opaque = &async_ret;
346 *total += reqs[i].qiov->size;
349 ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
350 if (ret < 0) {
351 return ret;
354 while (async_ret.num_done < num_reqs) {
355 qemu_aio_wait();
358 return async_ret.error < 0 ? async_ret.error : 1;
361 static void read_help(void)
363 printf(
364 "\n"
365 " reads a range of bytes from the given offset\n"
366 "\n"
367 " Example:\n"
368 " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
369 "\n"
370 " Reads a segment of the currently open file, optionally dumping it to the\n"
371 " standard output stream (with -v option) for subsequent inspection.\n"
372 " -b, -- read from the VM state rather than the virtual disk\n"
373 " -C, -- report statistics in a machine parsable format\n"
374 " -l, -- length for pattern verification (only with -P)\n"
375 " -p, -- use bdrv_pread to read the file\n"
376 " -P, -- use a pattern to verify read data\n"
377 " -q, -- quiet mode, do not show I/O statistics\n"
378 " -s, -- start offset for pattern verification (only with -P)\n"
379 " -v, -- dump buffer to standard output\n"
380 "\n");
383 static int read_f(int argc, char **argv);
385 static const cmdinfo_t read_cmd = {
386 .name = "read",
387 .altname = "r",
388 .cfunc = read_f,
389 .argmin = 2,
390 .argmax = -1,
391 .args = "[-abCpqv] [-P pattern [-s off] [-l len]] off len",
392 .oneline = "reads a number of bytes at a specified offset",
393 .help = read_help,
396 static int read_f(int argc, char **argv)
398 struct timeval t1, t2;
399 int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
400 int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
401 int c, cnt;
402 char *buf;
403 int64_t offset;
404 int count;
405 /* Some compilers get confused and warn if this is not initialized. */
406 int total = 0;
407 int pattern = 0, pattern_offset = 0, pattern_count = 0;
409 while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
410 switch (c) {
411 case 'b':
412 bflag = 1;
413 break;
414 case 'C':
415 Cflag = 1;
416 break;
417 case 'l':
418 lflag = 1;
419 pattern_count = cvtnum(optarg);
420 if (pattern_count < 0) {
421 printf("non-numeric length argument -- %s\n", optarg);
422 return 0;
424 break;
425 case 'p':
426 pflag = 1;
427 break;
428 case 'P':
429 Pflag = 1;
430 pattern = parse_pattern(optarg);
431 if (pattern < 0) {
432 return 0;
434 break;
435 case 'q':
436 qflag = 1;
437 break;
438 case 's':
439 sflag = 1;
440 pattern_offset = cvtnum(optarg);
441 if (pattern_offset < 0) {
442 printf("non-numeric length argument -- %s\n", optarg);
443 return 0;
445 break;
446 case 'v':
447 vflag = 1;
448 break;
449 default:
450 return command_usage(&read_cmd);
454 if (optind != argc - 2) {
455 return command_usage(&read_cmd);
458 if (bflag && pflag) {
459 printf("-b and -p cannot be specified at the same time\n");
460 return 0;
463 offset = cvtnum(argv[optind]);
464 if (offset < 0) {
465 printf("non-numeric length argument -- %s\n", argv[optind]);
466 return 0;
469 optind++;
470 count = cvtnum(argv[optind]);
471 if (count < 0) {
472 printf("non-numeric length argument -- %s\n", argv[optind]);
473 return 0;
476 if (!Pflag && (lflag || sflag)) {
477 return command_usage(&read_cmd);
480 if (!lflag) {
481 pattern_count = count - pattern_offset;
484 if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) {
485 printf("pattern verification range exceeds end of read data\n");
486 return 0;
489 if (!pflag) {
490 if (offset & 0x1ff) {
491 printf("offset %" PRId64 " is not sector aligned\n",
492 offset);
493 return 0;
495 if (count & 0x1ff) {
496 printf("count %d is not sector aligned\n",
497 count);
498 return 0;
502 buf = qemu_io_alloc(count, 0xab);
504 gettimeofday(&t1, NULL);
505 if (pflag) {
506 cnt = do_pread(buf, offset, count, &total);
507 } else if (bflag) {
508 cnt = do_load_vmstate(buf, offset, count, &total);
509 } else {
510 cnt = do_read(buf, offset, count, &total);
512 gettimeofday(&t2, NULL);
514 if (cnt < 0) {
515 printf("read failed: %s\n", strerror(-cnt));
516 goto out;
519 if (Pflag) {
520 void *cmp_buf = g_malloc(pattern_count);
521 memset(cmp_buf, pattern, pattern_count);
522 if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
523 printf("Pattern verification failed at offset %"
524 PRId64 ", %d bytes\n",
525 offset + pattern_offset, pattern_count);
527 g_free(cmp_buf);
530 if (qflag) {
531 goto out;
534 if (vflag) {
535 dump_buffer(buf, offset, count);
538 /* Finally, report back -- -C gives a parsable format */
539 t2 = tsub(t2, t1);
540 print_report("read", &t2, offset, count, total, cnt, Cflag);
542 out:
543 qemu_io_free(buf);
545 return 0;
548 static void readv_help(void)
550 printf(
551 "\n"
552 " reads a range of bytes from the given offset into multiple buffers\n"
553 "\n"
554 " Example:\n"
555 " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
556 "\n"
557 " Reads a segment of the currently open file, optionally dumping it to the\n"
558 " standard output stream (with -v option) for subsequent inspection.\n"
559 " Uses multiple iovec buffers if more than one byte range is specified.\n"
560 " -C, -- report statistics in a machine parsable format\n"
561 " -P, -- use a pattern to verify read data\n"
562 " -v, -- dump buffer to standard output\n"
563 " -q, -- quiet mode, do not show I/O statistics\n"
564 "\n");
567 static int readv_f(int argc, char **argv);
569 static const cmdinfo_t readv_cmd = {
570 .name = "readv",
571 .cfunc = readv_f,
572 .argmin = 2,
573 .argmax = -1,
574 .args = "[-Cqv] [-P pattern ] off len [len..]",
575 .oneline = "reads a number of bytes at a specified offset",
576 .help = readv_help,
579 static int readv_f(int argc, char **argv)
581 struct timeval t1, t2;
582 int Cflag = 0, qflag = 0, vflag = 0;
583 int c, cnt;
584 char *buf;
585 int64_t offset;
586 /* Some compilers get confused and warn if this is not initialized. */
587 int total = 0;
588 int nr_iov;
589 QEMUIOVector qiov;
590 int pattern = 0;
591 int Pflag = 0;
593 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
594 switch (c) {
595 case 'C':
596 Cflag = 1;
597 break;
598 case 'P':
599 Pflag = 1;
600 pattern = parse_pattern(optarg);
601 if (pattern < 0) {
602 return 0;
604 break;
605 case 'q':
606 qflag = 1;
607 break;
608 case 'v':
609 vflag = 1;
610 break;
611 default:
612 return command_usage(&readv_cmd);
616 if (optind > argc - 2) {
617 return command_usage(&readv_cmd);
621 offset = cvtnum(argv[optind]);
622 if (offset < 0) {
623 printf("non-numeric length argument -- %s\n", argv[optind]);
624 return 0;
626 optind++;
628 if (offset & 0x1ff) {
629 printf("offset %" PRId64 " is not sector aligned\n",
630 offset);
631 return 0;
634 nr_iov = argc - optind;
635 buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab);
636 if (buf == NULL) {
637 return 0;
640 gettimeofday(&t1, NULL);
641 cnt = do_aio_readv(&qiov, offset, &total);
642 gettimeofday(&t2, NULL);
644 if (cnt < 0) {
645 printf("readv failed: %s\n", strerror(-cnt));
646 goto out;
649 if (Pflag) {
650 void *cmp_buf = g_malloc(qiov.size);
651 memset(cmp_buf, pattern, qiov.size);
652 if (memcmp(buf, cmp_buf, qiov.size)) {
653 printf("Pattern verification failed at offset %"
654 PRId64 ", %zd bytes\n", offset, qiov.size);
656 g_free(cmp_buf);
659 if (qflag) {
660 goto out;
663 if (vflag) {
664 dump_buffer(buf, offset, qiov.size);
667 /* Finally, report back -- -C gives a parsable format */
668 t2 = tsub(t2, t1);
669 print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
671 out:
672 qemu_io_free(buf);
673 return 0;
676 static void write_help(void)
678 printf(
679 "\n"
680 " writes a range of bytes from the given offset\n"
681 "\n"
682 " Example:\n"
683 " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
684 "\n"
685 " Writes into a segment of the currently open file, using a buffer\n"
686 " filled with a set pattern (0xcdcdcdcd).\n"
687 " -b, -- write to the VM state rather than the virtual disk\n"
688 " -p, -- use bdrv_pwrite to write the file\n"
689 " -P, -- use different pattern to fill file\n"
690 " -C, -- report statistics in a machine parsable format\n"
691 " -q, -- quiet mode, do not show I/O statistics\n"
692 " -z, -- write zeroes using bdrv_co_write_zeroes\n"
693 "\n");
696 static int write_f(int argc, char **argv);
698 static const cmdinfo_t write_cmd = {
699 .name = "write",
700 .altname = "w",
701 .cfunc = write_f,
702 .argmin = 2,
703 .argmax = -1,
704 .args = "[-bCpqz] [-P pattern ] off len",
705 .oneline = "writes a number of bytes at a specified offset",
706 .help = write_help,
709 static int write_f(int argc, char **argv)
711 struct timeval t1, t2;
712 int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0;
713 int c, cnt;
714 char *buf = NULL;
715 int64_t offset;
716 int count;
717 /* Some compilers get confused and warn if this is not initialized. */
718 int total = 0;
719 int pattern = 0xcd;
721 while ((c = getopt(argc, argv, "bCpP:qz")) != EOF) {
722 switch (c) {
723 case 'b':
724 bflag = 1;
725 break;
726 case 'C':
727 Cflag = 1;
728 break;
729 case 'p':
730 pflag = 1;
731 break;
732 case 'P':
733 Pflag = 1;
734 pattern = parse_pattern(optarg);
735 if (pattern < 0) {
736 return 0;
738 break;
739 case 'q':
740 qflag = 1;
741 break;
742 case 'z':
743 zflag = 1;
744 break;
745 default:
746 return command_usage(&write_cmd);
750 if (optind != argc - 2) {
751 return command_usage(&write_cmd);
754 if (bflag + pflag + zflag > 1) {
755 printf("-b, -p, or -z cannot be specified at the same time\n");
756 return 0;
759 if (zflag && Pflag) {
760 printf("-z and -P cannot be specified at the same time\n");
761 return 0;
764 offset = cvtnum(argv[optind]);
765 if (offset < 0) {
766 printf("non-numeric length argument -- %s\n", argv[optind]);
767 return 0;
770 optind++;
771 count = cvtnum(argv[optind]);
772 if (count < 0) {
773 printf("non-numeric length argument -- %s\n", argv[optind]);
774 return 0;
777 if (!pflag) {
778 if (offset & 0x1ff) {
779 printf("offset %" PRId64 " is not sector aligned\n",
780 offset);
781 return 0;
784 if (count & 0x1ff) {
785 printf("count %d is not sector aligned\n",
786 count);
787 return 0;
791 if (!zflag) {
792 buf = qemu_io_alloc(count, pattern);
795 gettimeofday(&t1, NULL);
796 if (pflag) {
797 cnt = do_pwrite(buf, offset, count, &total);
798 } else if (bflag) {
799 cnt = do_save_vmstate(buf, offset, count, &total);
800 } else if (zflag) {
801 cnt = do_co_write_zeroes(offset, count, &total);
802 } else {
803 cnt = do_write(buf, offset, count, &total);
805 gettimeofday(&t2, NULL);
807 if (cnt < 0) {
808 printf("write failed: %s\n", strerror(-cnt));
809 goto out;
812 if (qflag) {
813 goto out;
816 /* Finally, report back -- -C gives a parsable format */
817 t2 = tsub(t2, t1);
818 print_report("wrote", &t2, offset, count, total, cnt, Cflag);
820 out:
821 if (!zflag) {
822 qemu_io_free(buf);
825 return 0;
828 static void
829 writev_help(void)
831 printf(
832 "\n"
833 " writes a range of bytes from the given offset source from multiple buffers\n"
834 "\n"
835 " Example:\n"
836 " 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
837 "\n"
838 " Writes into a segment of the currently open file, using a buffer\n"
839 " filled with a set pattern (0xcdcdcdcd).\n"
840 " -P, -- use different pattern to fill file\n"
841 " -C, -- report statistics in a machine parsable format\n"
842 " -q, -- quiet mode, do not show I/O statistics\n"
843 "\n");
846 static int writev_f(int argc, char **argv);
848 static const cmdinfo_t writev_cmd = {
849 .name = "writev",
850 .cfunc = writev_f,
851 .argmin = 2,
852 .argmax = -1,
853 .args = "[-Cq] [-P pattern ] off len [len..]",
854 .oneline = "writes a number of bytes at a specified offset",
855 .help = writev_help,
858 static int writev_f(int argc, char **argv)
860 struct timeval t1, t2;
861 int Cflag = 0, qflag = 0;
862 int c, cnt;
863 char *buf;
864 int64_t offset;
865 /* Some compilers get confused and warn if this is not initialized. */
866 int total = 0;
867 int nr_iov;
868 int pattern = 0xcd;
869 QEMUIOVector qiov;
871 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
872 switch (c) {
873 case 'C':
874 Cflag = 1;
875 break;
876 case 'q':
877 qflag = 1;
878 break;
879 case 'P':
880 pattern = parse_pattern(optarg);
881 if (pattern < 0) {
882 return 0;
884 break;
885 default:
886 return command_usage(&writev_cmd);
890 if (optind > argc - 2) {
891 return command_usage(&writev_cmd);
894 offset = cvtnum(argv[optind]);
895 if (offset < 0) {
896 printf("non-numeric length argument -- %s\n", argv[optind]);
897 return 0;
899 optind++;
901 if (offset & 0x1ff) {
902 printf("offset %" PRId64 " is not sector aligned\n",
903 offset);
904 return 0;
907 nr_iov = argc - optind;
908 buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern);
909 if (buf == NULL) {
910 return 0;
913 gettimeofday(&t1, NULL);
914 cnt = do_aio_writev(&qiov, offset, &total);
915 gettimeofday(&t2, NULL);
917 if (cnt < 0) {
918 printf("writev failed: %s\n", strerror(-cnt));
919 goto out;
922 if (qflag) {
923 goto out;
926 /* Finally, report back -- -C gives a parsable format */
927 t2 = tsub(t2, t1);
928 print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
929 out:
930 qemu_io_free(buf);
931 return 0;
934 static void multiwrite_help(void)
936 printf(
937 "\n"
938 " writes a range of bytes from the given offset source from multiple buffers,\n"
939 " in a batch of requests that may be merged by qemu\n"
940 "\n"
941 " Example:\n"
942 " 'multiwrite 512 1k 1k ; 4k 1k'\n"
943 " writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"
944 "\n"
945 " Writes into a segment of the currently open file, using a buffer\n"
946 " filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"
947 " by one for each request contained in the multiwrite command.\n"
948 " -P, -- use different pattern to fill file\n"
949 " -C, -- report statistics in a machine parsable format\n"
950 " -q, -- quiet mode, do not show I/O statistics\n"
951 "\n");
954 static int multiwrite_f(int argc, char **argv);
956 static const cmdinfo_t multiwrite_cmd = {
957 .name = "multiwrite",
958 .cfunc = multiwrite_f,
959 .argmin = 2,
960 .argmax = -1,
961 .args = "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",
962 .oneline = "issues multiple write requests at once",
963 .help = multiwrite_help,
966 static int multiwrite_f(int argc, char **argv)
968 struct timeval t1, t2;
969 int Cflag = 0, qflag = 0;
970 int c, cnt;
971 char **buf;
972 int64_t offset, first_offset = 0;
973 /* Some compilers get confused and warn if this is not initialized. */
974 int total = 0;
975 int nr_iov;
976 int nr_reqs;
977 int pattern = 0xcd;
978 QEMUIOVector *qiovs;
979 int i;
980 BlockRequest *reqs;
982 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
983 switch (c) {
984 case 'C':
985 Cflag = 1;
986 break;
987 case 'q':
988 qflag = 1;
989 break;
990 case 'P':
991 pattern = parse_pattern(optarg);
992 if (pattern < 0) {
993 return 0;
995 break;
996 default:
997 return command_usage(&writev_cmd);
1001 if (optind > argc - 2) {
1002 return command_usage(&writev_cmd);
1005 nr_reqs = 1;
1006 for (i = optind; i < argc; i++) {
1007 if (!strcmp(argv[i], ";")) {
1008 nr_reqs++;
1012 reqs = g_malloc0(nr_reqs * sizeof(*reqs));
1013 buf = g_malloc0(nr_reqs * sizeof(*buf));
1014 qiovs = g_malloc(nr_reqs * sizeof(*qiovs));
1016 for (i = 0; i < nr_reqs && optind < argc; i++) {
1017 int j;
1019 /* Read the offset of the request */
1020 offset = cvtnum(argv[optind]);
1021 if (offset < 0) {
1022 printf("non-numeric offset argument -- %s\n", argv[optind]);
1023 goto out;
1025 optind++;
1027 if (offset & 0x1ff) {
1028 printf("offset %lld is not sector aligned\n",
1029 (long long)offset);
1030 goto out;
1033 if (i == 0) {
1034 first_offset = offset;
1037 /* Read lengths for qiov entries */
1038 for (j = optind; j < argc; j++) {
1039 if (!strcmp(argv[j], ";")) {
1040 break;
1044 nr_iov = j - optind;
1046 /* Build request */
1047 buf[i] = create_iovec(&qiovs[i], &argv[optind], nr_iov, pattern);
1048 if (buf[i] == NULL) {
1049 goto out;
1052 reqs[i].qiov = &qiovs[i];
1053 reqs[i].sector = offset >> 9;
1054 reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
1056 optind = j + 1;
1058 pattern++;
1061 /* If there were empty requests at the end, ignore them */
1062 nr_reqs = i;
1064 gettimeofday(&t1, NULL);
1065 cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
1066 gettimeofday(&t2, NULL);
1068 if (cnt < 0) {
1069 printf("aio_multiwrite failed: %s\n", strerror(-cnt));
1070 goto out;
1073 if (qflag) {
1074 goto out;
1077 /* Finally, report back -- -C gives a parsable format */
1078 t2 = tsub(t2, t1);
1079 print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
1080 out:
1081 for (i = 0; i < nr_reqs; i++) {
1082 qemu_io_free(buf[i]);
1083 if (reqs[i].qiov != NULL) {
1084 qemu_iovec_destroy(&qiovs[i]);
1087 g_free(buf);
1088 g_free(reqs);
1089 g_free(qiovs);
1090 return 0;
1093 struct aio_ctx {
1094 QEMUIOVector qiov;
1095 int64_t offset;
1096 char *buf;
1097 int qflag;
1098 int vflag;
1099 int Cflag;
1100 int Pflag;
1101 int pattern;
1102 struct timeval t1;
1105 static void aio_write_done(void *opaque, int ret)
1107 struct aio_ctx *ctx = opaque;
1108 struct timeval t2;
1110 gettimeofday(&t2, NULL);
1113 if (ret < 0) {
1114 printf("aio_write failed: %s\n", strerror(-ret));
1115 goto out;
1118 if (ctx->qflag) {
1119 goto out;
1122 /* Finally, report back -- -C gives a parsable format */
1123 t2 = tsub(t2, ctx->t1);
1124 print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
1125 ctx->qiov.size, 1, ctx->Cflag);
1126 out:
1127 qemu_io_free(ctx->buf);
1128 g_free(ctx);
1131 static void aio_read_done(void *opaque, int ret)
1133 struct aio_ctx *ctx = opaque;
1134 struct timeval t2;
1136 gettimeofday(&t2, NULL);
1138 if (ret < 0) {
1139 printf("readv failed: %s\n", strerror(-ret));
1140 goto out;
1143 if (ctx->Pflag) {
1144 void *cmp_buf = g_malloc(ctx->qiov.size);
1146 memset(cmp_buf, ctx->pattern, ctx->qiov.size);
1147 if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
1148 printf("Pattern verification failed at offset %"
1149 PRId64 ", %zd bytes\n", ctx->offset, ctx->qiov.size);
1151 g_free(cmp_buf);
1154 if (ctx->qflag) {
1155 goto out;
1158 if (ctx->vflag) {
1159 dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
1162 /* Finally, report back -- -C gives a parsable format */
1163 t2 = tsub(t2, ctx->t1);
1164 print_report("read", &t2, ctx->offset, ctx->qiov.size,
1165 ctx->qiov.size, 1, ctx->Cflag);
1166 out:
1167 qemu_io_free(ctx->buf);
1168 g_free(ctx);
1171 static void aio_read_help(void)
1173 printf(
1174 "\n"
1175 " asynchronously reads a range of bytes from the given offset\n"
1176 "\n"
1177 " Example:\n"
1178 " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
1179 "\n"
1180 " Reads a segment of the currently open file, optionally dumping it to the\n"
1181 " standard output stream (with -v option) for subsequent inspection.\n"
1182 " The read is performed asynchronously and the aio_flush command must be\n"
1183 " used to ensure all outstanding aio requests have been completed.\n"
1184 " -C, -- report statistics in a machine parsable format\n"
1185 " -P, -- use a pattern to verify read data\n"
1186 " -v, -- dump buffer to standard output\n"
1187 " -q, -- quiet mode, do not show I/O statistics\n"
1188 "\n");
1191 static int aio_read_f(int argc, char **argv);
1193 static const cmdinfo_t aio_read_cmd = {
1194 .name = "aio_read",
1195 .cfunc = aio_read_f,
1196 .argmin = 2,
1197 .argmax = -1,
1198 .args = "[-Cqv] [-P pattern ] off len [len..]",
1199 .oneline = "asynchronously reads a number of bytes",
1200 .help = aio_read_help,
1203 static int aio_read_f(int argc, char **argv)
1205 int nr_iov, c;
1206 struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
1208 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
1209 switch (c) {
1210 case 'C':
1211 ctx->Cflag = 1;
1212 break;
1213 case 'P':
1214 ctx->Pflag = 1;
1215 ctx->pattern = parse_pattern(optarg);
1216 if (ctx->pattern < 0) {
1217 g_free(ctx);
1218 return 0;
1220 break;
1221 case 'q':
1222 ctx->qflag = 1;
1223 break;
1224 case 'v':
1225 ctx->vflag = 1;
1226 break;
1227 default:
1228 g_free(ctx);
1229 return command_usage(&aio_read_cmd);
1233 if (optind > argc - 2) {
1234 g_free(ctx);
1235 return command_usage(&aio_read_cmd);
1238 ctx->offset = cvtnum(argv[optind]);
1239 if (ctx->offset < 0) {
1240 printf("non-numeric length argument -- %s\n", argv[optind]);
1241 g_free(ctx);
1242 return 0;
1244 optind++;
1246 if (ctx->offset & 0x1ff) {
1247 printf("offset %" PRId64 " is not sector aligned\n",
1248 ctx->offset);
1249 g_free(ctx);
1250 return 0;
1253 nr_iov = argc - optind;
1254 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab);
1255 if (ctx->buf == NULL) {
1256 g_free(ctx);
1257 return 0;
1260 gettimeofday(&ctx->t1, NULL);
1261 bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
1262 ctx->qiov.size >> 9, aio_read_done, ctx);
1263 return 0;
1266 static void aio_write_help(void)
1268 printf(
1269 "\n"
1270 " asynchronously writes a range of bytes from the given offset source\n"
1271 " from multiple buffers\n"
1272 "\n"
1273 " Example:\n"
1274 " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1275 "\n"
1276 " Writes into a segment of the currently open file, using a buffer\n"
1277 " filled with a set pattern (0xcdcdcdcd).\n"
1278 " The write is performed asynchronously and the aio_flush command must be\n"
1279 " used to ensure all outstanding aio requests have been completed.\n"
1280 " -P, -- use different pattern to fill file\n"
1281 " -C, -- report statistics in a machine parsable format\n"
1282 " -q, -- quiet mode, do not show I/O statistics\n"
1283 "\n");
1286 static int aio_write_f(int argc, char **argv);
1288 static const cmdinfo_t aio_write_cmd = {
1289 .name = "aio_write",
1290 .cfunc = aio_write_f,
1291 .argmin = 2,
1292 .argmax = -1,
1293 .args = "[-Cq] [-P pattern ] off len [len..]",
1294 .oneline = "asynchronously writes a number of bytes",
1295 .help = aio_write_help,
1298 static int aio_write_f(int argc, char **argv)
1300 int nr_iov, c;
1301 int pattern = 0xcd;
1302 struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
1304 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1305 switch (c) {
1306 case 'C':
1307 ctx->Cflag = 1;
1308 break;
1309 case 'q':
1310 ctx->qflag = 1;
1311 break;
1312 case 'P':
1313 pattern = parse_pattern(optarg);
1314 if (pattern < 0) {
1315 g_free(ctx);
1316 return 0;
1318 break;
1319 default:
1320 g_free(ctx);
1321 return command_usage(&aio_write_cmd);
1325 if (optind > argc - 2) {
1326 g_free(ctx);
1327 return command_usage(&aio_write_cmd);
1330 ctx->offset = cvtnum(argv[optind]);
1331 if (ctx->offset < 0) {
1332 printf("non-numeric length argument -- %s\n", argv[optind]);
1333 g_free(ctx);
1334 return 0;
1336 optind++;
1338 if (ctx->offset & 0x1ff) {
1339 printf("offset %" PRId64 " is not sector aligned\n",
1340 ctx->offset);
1341 g_free(ctx);
1342 return 0;
1345 nr_iov = argc - optind;
1346 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
1347 if (ctx->buf == NULL) {
1348 g_free(ctx);
1349 return 0;
1352 gettimeofday(&ctx->t1, NULL);
1353 bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
1354 ctx->qiov.size >> 9, aio_write_done, ctx);
1355 return 0;
1358 static int aio_flush_f(int argc, char **argv)
1360 qemu_aio_flush();
1361 return 0;
1364 static const cmdinfo_t aio_flush_cmd = {
1365 .name = "aio_flush",
1366 .cfunc = aio_flush_f,
1367 .oneline = "completes all outstanding aio requests"
1370 static int flush_f(int argc, char **argv)
1372 bdrv_flush(bs);
1373 return 0;
1376 static const cmdinfo_t flush_cmd = {
1377 .name = "flush",
1378 .altname = "f",
1379 .cfunc = flush_f,
1380 .oneline = "flush all in-core file state to disk",
1383 static int truncate_f(int argc, char **argv)
1385 int64_t offset;
1386 int ret;
1388 offset = cvtnum(argv[1]);
1389 if (offset < 0) {
1390 printf("non-numeric truncate argument -- %s\n", argv[1]);
1391 return 0;
1394 ret = bdrv_truncate(bs, offset);
1395 if (ret < 0) {
1396 printf("truncate: %s\n", strerror(-ret));
1397 return 0;
1400 return 0;
1403 static const cmdinfo_t truncate_cmd = {
1404 .name = "truncate",
1405 .altname = "t",
1406 .cfunc = truncate_f,
1407 .argmin = 1,
1408 .argmax = 1,
1409 .args = "off",
1410 .oneline = "truncates the current file at the given offset",
1413 static int length_f(int argc, char **argv)
1415 int64_t size;
1416 char s1[64];
1418 size = bdrv_getlength(bs);
1419 if (size < 0) {
1420 printf("getlength: %s\n", strerror(-size));
1421 return 0;
1424 cvtstr(size, s1, sizeof(s1));
1425 printf("%s\n", s1);
1426 return 0;
1430 static const cmdinfo_t length_cmd = {
1431 .name = "length",
1432 .altname = "l",
1433 .cfunc = length_f,
1434 .oneline = "gets the length of the current file",
1438 static int info_f(int argc, char **argv)
1440 BlockDriverInfo bdi;
1441 char s1[64], s2[64];
1442 int ret;
1444 if (bs->drv && bs->drv->format_name) {
1445 printf("format name: %s\n", bs->drv->format_name);
1447 if (bs->drv && bs->drv->protocol_name) {
1448 printf("format name: %s\n", bs->drv->protocol_name);
1451 ret = bdrv_get_info(bs, &bdi);
1452 if (ret) {
1453 return 0;
1456 cvtstr(bdi.cluster_size, s1, sizeof(s1));
1457 cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
1459 printf("cluster size: %s\n", s1);
1460 printf("vm state offset: %s\n", s2);
1462 return 0;
1467 static const cmdinfo_t info_cmd = {
1468 .name = "info",
1469 .altname = "i",
1470 .cfunc = info_f,
1471 .oneline = "prints information about the current file",
1474 static void discard_help(void)
1476 printf(
1477 "\n"
1478 " discards a range of bytes from the given offset\n"
1479 "\n"
1480 " Example:\n"
1481 " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
1482 "\n"
1483 " Discards a segment of the currently open file.\n"
1484 " -C, -- report statistics in a machine parsable format\n"
1485 " -q, -- quiet mode, do not show I/O statistics\n"
1486 "\n");
1489 static int discard_f(int argc, char **argv);
1491 static const cmdinfo_t discard_cmd = {
1492 .name = "discard",
1493 .altname = "d",
1494 .cfunc = discard_f,
1495 .argmin = 2,
1496 .argmax = -1,
1497 .args = "[-Cq] off len",
1498 .oneline = "discards a number of bytes at a specified offset",
1499 .help = discard_help,
1502 static int discard_f(int argc, char **argv)
1504 struct timeval t1, t2;
1505 int Cflag = 0, qflag = 0;
1506 int c, ret;
1507 int64_t offset;
1508 int count;
1510 while ((c = getopt(argc, argv, "Cq")) != EOF) {
1511 switch (c) {
1512 case 'C':
1513 Cflag = 1;
1514 break;
1515 case 'q':
1516 qflag = 1;
1517 break;
1518 default:
1519 return command_usage(&discard_cmd);
1523 if (optind != argc - 2) {
1524 return command_usage(&discard_cmd);
1527 offset = cvtnum(argv[optind]);
1528 if (offset < 0) {
1529 printf("non-numeric length argument -- %s\n", argv[optind]);
1530 return 0;
1533 optind++;
1534 count = cvtnum(argv[optind]);
1535 if (count < 0) {
1536 printf("non-numeric length argument -- %s\n", argv[optind]);
1537 return 0;
1540 gettimeofday(&t1, NULL);
1541 ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS,
1542 count >> BDRV_SECTOR_BITS);
1543 gettimeofday(&t2, NULL);
1545 if (ret < 0) {
1546 printf("discard failed: %s\n", strerror(-ret));
1547 goto out;
1550 /* Finally, report back -- -C gives a parsable format */
1551 if (!qflag) {
1552 t2 = tsub(t2, t1);
1553 print_report("discard", &t2, offset, count, count, 1, Cflag);
1556 out:
1557 return 0;
1560 static int alloc_f(int argc, char **argv)
1562 int64_t offset;
1563 int nb_sectors, remaining;
1564 char s1[64];
1565 int num, sum_alloc;
1566 int ret;
1568 offset = cvtnum(argv[1]);
1569 if (offset & 0x1ff) {
1570 printf("offset %" PRId64 " is not sector aligned\n",
1571 offset);
1572 return 0;
1575 if (argc == 3) {
1576 nb_sectors = cvtnum(argv[2]);
1577 } else {
1578 nb_sectors = 1;
1581 remaining = nb_sectors;
1582 sum_alloc = 0;
1583 while (remaining) {
1584 ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
1585 remaining -= num;
1586 if (ret) {
1587 sum_alloc += num;
1591 cvtstr(offset, s1, sizeof(s1));
1593 printf("%d/%d sectors allocated at offset %s\n",
1594 sum_alloc, nb_sectors, s1);
1595 return 0;
1598 static const cmdinfo_t alloc_cmd = {
1599 .name = "alloc",
1600 .altname = "a",
1601 .argmin = 1,
1602 .argmax = 2,
1603 .cfunc = alloc_f,
1604 .args = "off [sectors]",
1605 .oneline = "checks if a sector is present in the file",
1608 static int map_f(int argc, char **argv)
1610 int64_t offset;
1611 int64_t nb_sectors;
1612 char s1[64];
1613 int num, num_checked;
1614 int ret;
1615 const char *retstr;
1617 offset = 0;
1618 nb_sectors = bs->total_sectors;
1620 do {
1621 num_checked = MIN(nb_sectors, INT_MAX);
1622 ret = bdrv_is_allocated(bs, offset, num_checked, &num);
1623 retstr = ret ? " allocated" : "not allocated";
1624 cvtstr(offset << 9ULL, s1, sizeof(s1));
1625 printf("[% 24" PRId64 "] % 8d/% 8d sectors %s at offset %s (%d)\n",
1626 offset << 9ULL, num, num_checked, retstr, s1, ret);
1628 offset += num;
1629 nb_sectors -= num;
1630 } while (offset < bs->total_sectors);
1632 return 0;
1635 static const cmdinfo_t map_cmd = {
1636 .name = "map",
1637 .argmin = 0,
1638 .argmax = 0,
1639 .cfunc = map_f,
1640 .args = "",
1641 .oneline = "prints the allocated areas of a file",
1645 static int close_f(int argc, char **argv)
1647 bdrv_delete(bs);
1648 bs = NULL;
1649 return 0;
1652 static const cmdinfo_t close_cmd = {
1653 .name = "close",
1654 .altname = "c",
1655 .cfunc = close_f,
1656 .oneline = "close the current open file",
1659 static int openfile(char *name, int flags, int growable)
1661 if (bs) {
1662 fprintf(stderr, "file open already, try 'help close'\n");
1663 return 1;
1666 if (growable) {
1667 if (bdrv_file_open(&bs, name, flags)) {
1668 fprintf(stderr, "%s: can't open device %s\n", progname, name);
1669 return 1;
1671 } else {
1672 bs = bdrv_new("hda");
1674 if (bdrv_open(bs, name, flags, NULL) < 0) {
1675 fprintf(stderr, "%s: can't open device %s\n", progname, name);
1676 bdrv_delete(bs);
1677 bs = NULL;
1678 return 1;
1682 return 0;
1685 static void open_help(void)
1687 printf(
1688 "\n"
1689 " opens a new file in the requested mode\n"
1690 "\n"
1691 " Example:\n"
1692 " 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
1693 "\n"
1694 " Opens a file for subsequent use by all of the other qemu-io commands.\n"
1695 " -r, -- open file read-only\n"
1696 " -s, -- use snapshot file\n"
1697 " -n, -- disable host cache\n"
1698 " -g, -- allow file to grow (only applies to protocols)"
1699 "\n");
1702 static int open_f(int argc, char **argv);
1704 static const cmdinfo_t open_cmd = {
1705 .name = "open",
1706 .altname = "o",
1707 .cfunc = open_f,
1708 .argmin = 1,
1709 .argmax = -1,
1710 .flags = CMD_NOFILE_OK,
1711 .args = "[-Crsn] [path]",
1712 .oneline = "open the file specified by path",
1713 .help = open_help,
1716 static int open_f(int argc, char **argv)
1718 int flags = 0;
1719 int readonly = 0;
1720 int growable = 0;
1721 int c;
1723 while ((c = getopt(argc, argv, "snrg")) != EOF) {
1724 switch (c) {
1725 case 's':
1726 flags |= BDRV_O_SNAPSHOT;
1727 break;
1728 case 'n':
1729 flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
1730 break;
1731 case 'r':
1732 readonly = 1;
1733 break;
1734 case 'g':
1735 growable = 1;
1736 break;
1737 default:
1738 return command_usage(&open_cmd);
1742 if (!readonly) {
1743 flags |= BDRV_O_RDWR;
1746 if (optind != argc - 1) {
1747 return command_usage(&open_cmd);
1750 return openfile(argv[optind], flags, growable);
1753 static int init_args_command(int index)
1755 /* only one device allowed so far */
1756 if (index >= 1) {
1757 return 0;
1759 return ++index;
1762 static int init_check_command(const cmdinfo_t *ct)
1764 if (ct->flags & CMD_FLAG_GLOBAL) {
1765 return 1;
1767 if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
1768 fprintf(stderr, "no file open, try 'help open'\n");
1769 return 0;
1771 return 1;
1774 static void usage(const char *name)
1776 printf(
1777 "Usage: %s [-h] [-V] [-rsnm] [-c cmd] ... [file]\n"
1778 "QEMU Disk exerciser\n"
1779 "\n"
1780 " -c, --cmd command to execute\n"
1781 " -r, --read-only export read-only\n"
1782 " -s, --snapshot use snapshot file\n"
1783 " -n, --nocache disable host cache\n"
1784 " -g, --growable allow file to grow (only applies to protocols)\n"
1785 " -m, --misalign misalign allocations for O_DIRECT\n"
1786 " -k, --native-aio use kernel AIO implementation (on Linux only)\n"
1787 " -T, --trace FILE enable trace events listed in the given file\n"
1788 " -h, --help display this help and exit\n"
1789 " -V, --version output version information and exit\n"
1790 "\n",
1791 name);
1795 int main(int argc, char **argv)
1797 int readonly = 0;
1798 int growable = 0;
1799 const char *sopt = "hVc:rsnmgkT:";
1800 const struct option lopt[] = {
1801 { "help", 0, NULL, 'h' },
1802 { "version", 0, NULL, 'V' },
1803 { "offset", 1, NULL, 'o' },
1804 { "cmd", 1, NULL, 'c' },
1805 { "read-only", 0, NULL, 'r' },
1806 { "snapshot", 0, NULL, 's' },
1807 { "nocache", 0, NULL, 'n' },
1808 { "misalign", 0, NULL, 'm' },
1809 { "growable", 0, NULL, 'g' },
1810 { "native-aio", 0, NULL, 'k' },
1811 { "trace", 1, NULL, 'T' },
1812 { NULL, 0, NULL, 0 }
1814 int c;
1815 int opt_index = 0;
1816 int flags = 0;
1818 progname = basename(argv[0]);
1820 while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
1821 switch (c) {
1822 case 's':
1823 flags |= BDRV_O_SNAPSHOT;
1824 break;
1825 case 'n':
1826 flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
1827 break;
1828 case 'c':
1829 add_user_command(optarg);
1830 break;
1831 case 'r':
1832 readonly = 1;
1833 break;
1834 case 'm':
1835 misalign = 1;
1836 break;
1837 case 'g':
1838 growable = 1;
1839 break;
1840 case 'k':
1841 flags |= BDRV_O_NATIVE_AIO;
1842 break;
1843 case 'T':
1844 if (!trace_backend_init(optarg, NULL)) {
1845 exit(1); /* error message will have been printed */
1847 break;
1848 case 'V':
1849 printf("%s version %s\n", progname, VERSION);
1850 exit(0);
1851 case 'h':
1852 usage(progname);
1853 exit(0);
1854 default:
1855 usage(progname);
1856 exit(1);
1860 if ((argc - optind) > 1) {
1861 usage(progname);
1862 exit(1);
1865 bdrv_init();
1867 qemu_init_main_loop();
1869 /* initialize commands */
1870 quit_init();
1871 help_init();
1872 add_command(&open_cmd);
1873 add_command(&close_cmd);
1874 add_command(&read_cmd);
1875 add_command(&readv_cmd);
1876 add_command(&write_cmd);
1877 add_command(&writev_cmd);
1878 add_command(&multiwrite_cmd);
1879 add_command(&aio_read_cmd);
1880 add_command(&aio_write_cmd);
1881 add_command(&aio_flush_cmd);
1882 add_command(&flush_cmd);
1883 add_command(&truncate_cmd);
1884 add_command(&length_cmd);
1885 add_command(&info_cmd);
1886 add_command(&discard_cmd);
1887 add_command(&alloc_cmd);
1888 add_command(&map_cmd);
1890 add_args_command(init_args_command);
1891 add_check_command(init_check_command);
1893 /* open the device */
1894 if (!readonly) {
1895 flags |= BDRV_O_RDWR;
1898 if ((argc - optind) == 1) {
1899 openfile(argv[optind], flags, growable);
1901 command_loop();
1904 * Make sure all outstanding requests complete before the program exits.
1906 bdrv_drain_all();
1908 if (bs) {
1909 bdrv_delete(bs);
1911 return 0;