piix_pci: optimize set irq path
[qemu.git] / qemu-io.c
blob4470e49bc88481ebd304df558b716b2893752d82
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"
21 #define VERSION "0.0.1"
23 #define CMD_NOFILE_OK 0x01
25 char *progname;
26 static BlockDriverState *bs;
28 static int misalign;
31 * Parse the pattern argument to various sub-commands.
33 * Because the pattern is used as an argument to memset it must evaluate
34 * to an unsigned integer that fits into a single byte.
36 static int parse_pattern(const char *arg)
38 char *endptr = NULL;
39 long pattern;
41 pattern = strtol(arg, &endptr, 0);
42 if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {
43 printf("%s is not a valid pattern byte\n", arg);
44 return -1;
47 return pattern;
51 * Memory allocation helpers.
53 * Make sure memory is aligned by default, or purposefully misaligned if
54 * that is specified on the command line.
57 #define MISALIGN_OFFSET 16
58 static void *qemu_io_alloc(size_t len, int pattern)
60 void *buf;
62 if (misalign)
63 len += MISALIGN_OFFSET;
64 buf = qemu_blockalign(bs, len);
65 memset(buf, pattern, len);
66 if (misalign)
67 buf += MISALIGN_OFFSET;
68 return buf;
71 static void qemu_io_free(void *p)
73 if (misalign)
74 p -= MISALIGN_OFFSET;
75 qemu_vfree(p);
78 static void
79 dump_buffer(const void *buffer, int64_t offset, int len)
81 int i, j;
82 const uint8_t *p;
84 for (i = 0, p = buffer; i < len; i += 16) {
85 const uint8_t *s = p;
87 printf("%08" PRIx64 ": ", offset + i);
88 for (j = 0; j < 16 && i + j < len; j++, p++)
89 printf("%02x ", *p);
90 printf(" ");
91 for (j = 0; j < 16 && i + j < len; j++, s++) {
92 if (isalnum(*s))
93 printf("%c", *s);
94 else
95 printf(".");
97 printf("\n");
101 static void
102 print_report(const char *op, struct timeval *t, int64_t offset,
103 int count, int total, int cnt, int Cflag)
105 char s1[64], s2[64], ts[64];
107 timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
108 if (!Cflag) {
109 cvtstr((double)total, s1, sizeof(s1));
110 cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
111 printf("%s %d/%d bytes at offset %" PRId64 "\n",
112 op, total, count, offset);
113 printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
114 s1, cnt, ts, s2, tdiv((double)cnt, *t));
115 } else {/* bytes,ops,time,bytes/sec,ops/sec */
116 printf("%d,%d,%s,%.3f,%.3f\n",
117 total, cnt, ts,
118 tdiv((double)total, *t),
119 tdiv((double)cnt, *t));
124 * Parse multiple length statements for vectored I/O, and construct an I/O
125 * vector matching it.
127 static void *
128 create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
130 size_t *sizes = calloc(nr_iov, sizeof(size_t));
131 size_t count = 0;
132 void *buf = NULL;
133 void *p;
134 int i;
136 for (i = 0; i < nr_iov; i++) {
137 char *arg = argv[i];
138 int64_t len;
140 len = cvtnum(arg);
141 if (len < 0) {
142 printf("non-numeric length argument -- %s\n", arg);
143 goto fail;
146 /* should be SIZE_T_MAX, but that doesn't exist */
147 if (len > INT_MAX) {
148 printf("too large length argument -- %s\n", arg);
149 goto fail;
152 if (len & 0x1ff) {
153 printf("length argument %" PRId64
154 " is not sector aligned\n", len);
155 goto fail;
158 sizes[i] = len;
159 count += len;
162 qemu_iovec_init(qiov, nr_iov);
164 buf = p = qemu_io_alloc(count, pattern);
166 for (i = 0; i < nr_iov; i++) {
167 qemu_iovec_add(qiov, p, sizes[i]);
168 p += sizes[i];
171 fail:
172 free(sizes);
173 return buf;
176 static int do_read(char *buf, int64_t offset, int count, int *total)
178 int ret;
180 ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
181 if (ret < 0)
182 return ret;
183 *total = count;
184 return 1;
187 static int do_write(char *buf, int64_t offset, int count, int *total)
189 int ret;
191 ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
192 if (ret < 0)
193 return ret;
194 *total = count;
195 return 1;
198 static int do_pread(char *buf, int64_t offset, int count, int *total)
200 *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
201 if (*total < 0)
202 return *total;
203 return 1;
206 static int do_pwrite(char *buf, int64_t offset, int count, int *total)
208 *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
209 if (*total < 0)
210 return *total;
211 return 1;
214 static int do_load_vmstate(char *buf, int64_t offset, int count, int *total)
216 *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
217 if (*total < 0)
218 return *total;
219 return 1;
222 static int do_save_vmstate(char *buf, int64_t offset, int count, int *total)
224 *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
225 if (*total < 0)
226 return *total;
227 return 1;
230 #define NOT_DONE 0x7fffffff
231 static void aio_rw_done(void *opaque, int ret)
233 *(int *)opaque = ret;
236 static int do_aio_readv(QEMUIOVector *qiov, int64_t offset, int *total)
238 BlockDriverAIOCB *acb;
239 int async_ret = NOT_DONE;
241 acb = bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
242 aio_rw_done, &async_ret);
243 if (!acb)
244 return -EIO;
246 while (async_ret == NOT_DONE)
247 qemu_aio_wait();
249 *total = qiov->size;
250 return async_ret < 0 ? async_ret : 1;
253 static int do_aio_writev(QEMUIOVector *qiov, int64_t offset, int *total)
255 BlockDriverAIOCB *acb;
256 int async_ret = NOT_DONE;
258 acb = bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
259 aio_rw_done, &async_ret);
260 if (!acb)
261 return -EIO;
263 while (async_ret == NOT_DONE)
264 qemu_aio_wait();
266 *total = qiov->size;
267 return async_ret < 0 ? async_ret : 1;
270 struct multiwrite_async_ret {
271 int num_done;
272 int error;
275 static void multiwrite_cb(void *opaque, int ret)
277 struct multiwrite_async_ret *async_ret = opaque;
279 async_ret->num_done++;
280 if (ret < 0) {
281 async_ret->error = ret;
285 static int do_aio_multiwrite(BlockRequest* reqs, int num_reqs, int *total)
287 int i, ret;
288 struct multiwrite_async_ret async_ret = {
289 .num_done = 0,
290 .error = 0,
293 *total = 0;
294 for (i = 0; i < num_reqs; i++) {
295 reqs[i].cb = multiwrite_cb;
296 reqs[i].opaque = &async_ret;
297 *total += reqs[i].qiov->size;
300 ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
301 if (ret < 0) {
302 return ret;
305 while (async_ret.num_done < num_reqs) {
306 qemu_aio_wait();
309 return async_ret.error < 0 ? async_ret.error : 1;
312 static void
313 read_help(void)
315 printf(
316 "\n"
317 " reads a range of bytes from the given offset\n"
318 "\n"
319 " Example:\n"
320 " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
321 "\n"
322 " Reads a segment of the currently open file, optionally dumping it to the\n"
323 " standard output stream (with -v option) for subsequent inspection.\n"
324 " -b, -- read from the VM state rather than the virtual disk\n"
325 " -C, -- report statistics in a machine parsable format\n"
326 " -l, -- length for pattern verification (only with -P)\n"
327 " -p, -- use bdrv_pread to read the file\n"
328 " -P, -- use a pattern to verify read data\n"
329 " -q, -- quiet mode, do not show I/O statistics\n"
330 " -s, -- start offset for pattern verification (only with -P)\n"
331 " -v, -- dump buffer to standard output\n"
332 "\n");
335 static int read_f(int argc, char **argv);
337 static const cmdinfo_t read_cmd = {
338 .name = "read",
339 .altname = "r",
340 .cfunc = read_f,
341 .argmin = 2,
342 .argmax = -1,
343 .args = "[-abCpqv] [-P pattern [-s off] [-l len]] off len",
344 .oneline = "reads a number of bytes at a specified offset",
345 .help = read_help,
348 static int
349 read_f(int argc, char **argv)
351 struct timeval t1, t2;
352 int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
353 int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
354 int c, cnt;
355 char *buf;
356 int64_t offset;
357 int count;
358 /* Some compilers get confused and warn if this is not initialized. */
359 int total = 0;
360 int pattern = 0, pattern_offset = 0, pattern_count = 0;
362 while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
363 switch (c) {
364 case 'b':
365 bflag = 1;
366 break;
367 case 'C':
368 Cflag = 1;
369 break;
370 case 'l':
371 lflag = 1;
372 pattern_count = cvtnum(optarg);
373 if (pattern_count < 0) {
374 printf("non-numeric length argument -- %s\n", optarg);
375 return 0;
377 break;
378 case 'p':
379 pflag = 1;
380 break;
381 case 'P':
382 Pflag = 1;
383 pattern = parse_pattern(optarg);
384 if (pattern < 0)
385 return 0;
386 break;
387 case 'q':
388 qflag = 1;
389 break;
390 case 's':
391 sflag = 1;
392 pattern_offset = cvtnum(optarg);
393 if (pattern_offset < 0) {
394 printf("non-numeric length argument -- %s\n", optarg);
395 return 0;
397 break;
398 case 'v':
399 vflag = 1;
400 break;
401 default:
402 return command_usage(&read_cmd);
406 if (optind != argc - 2)
407 return command_usage(&read_cmd);
409 if (bflag && pflag) {
410 printf("-b and -p cannot be specified at the same time\n");
411 return 0;
414 offset = cvtnum(argv[optind]);
415 if (offset < 0) {
416 printf("non-numeric length argument -- %s\n", argv[optind]);
417 return 0;
420 optind++;
421 count = cvtnum(argv[optind]);
422 if (count < 0) {
423 printf("non-numeric length argument -- %s\n", argv[optind]);
424 return 0;
427 if (!Pflag && (lflag || sflag)) {
428 return command_usage(&read_cmd);
431 if (!lflag) {
432 pattern_count = count - pattern_offset;
435 if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) {
436 printf("pattern verfication range exceeds end of read data\n");
437 return 0;
440 if (!pflag)
441 if (offset & 0x1ff) {
442 printf("offset %" PRId64 " is not sector aligned\n",
443 offset);
444 return 0;
446 if (count & 0x1ff) {
447 printf("count %d is not sector aligned\n",
448 count);
449 return 0;
453 buf = qemu_io_alloc(count, 0xab);
455 gettimeofday(&t1, NULL);
456 if (pflag)
457 cnt = do_pread(buf, offset, count, &total);
458 else if (bflag)
459 cnt = do_load_vmstate(buf, offset, count, &total);
460 else
461 cnt = do_read(buf, offset, count, &total);
462 gettimeofday(&t2, NULL);
464 if (cnt < 0) {
465 printf("read failed: %s\n", strerror(-cnt));
466 goto out;
469 if (Pflag) {
470 void* cmp_buf = malloc(pattern_count);
471 memset(cmp_buf, pattern, pattern_count);
472 if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
473 printf("Pattern verification failed at offset %"
474 PRId64 ", %d bytes\n",
475 offset + pattern_offset, pattern_count);
477 free(cmp_buf);
480 if (qflag)
481 goto out;
483 if (vflag)
484 dump_buffer(buf, offset, count);
486 /* Finally, report back -- -C gives a parsable format */
487 t2 = tsub(t2, t1);
488 print_report("read", &t2, offset, count, total, cnt, Cflag);
490 out:
491 qemu_io_free(buf);
493 return 0;
496 static void
497 readv_help(void)
499 printf(
500 "\n"
501 " reads a range of bytes from the given offset into multiple buffers\n"
502 "\n"
503 " Example:\n"
504 " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
505 "\n"
506 " Reads a segment of the currently open file, optionally dumping it to the\n"
507 " standard output stream (with -v option) for subsequent inspection.\n"
508 " Uses multiple iovec buffers if more than one byte range is specified.\n"
509 " -C, -- report statistics in a machine parsable format\n"
510 " -P, -- use a pattern to verify read data\n"
511 " -v, -- dump buffer to standard output\n"
512 " -q, -- quiet mode, do not show I/O statistics\n"
513 "\n");
516 static int readv_f(int argc, char **argv);
518 static const cmdinfo_t readv_cmd = {
519 .name = "readv",
520 .cfunc = readv_f,
521 .argmin = 2,
522 .argmax = -1,
523 .args = "[-Cqv] [-P pattern ] off len [len..]",
524 .oneline = "reads a number of bytes at a specified offset",
525 .help = readv_help,
528 static int
529 readv_f(int argc, char **argv)
531 struct timeval t1, t2;
532 int Cflag = 0, qflag = 0, vflag = 0;
533 int c, cnt;
534 char *buf;
535 int64_t offset;
536 /* Some compilers get confused and warn if this is not initialized. */
537 int total = 0;
538 int nr_iov;
539 QEMUIOVector qiov;
540 int pattern = 0;
541 int Pflag = 0;
543 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
544 switch (c) {
545 case 'C':
546 Cflag = 1;
547 break;
548 case 'P':
549 Pflag = 1;
550 pattern = parse_pattern(optarg);
551 if (pattern < 0)
552 return 0;
553 break;
554 case 'q':
555 qflag = 1;
556 break;
557 case 'v':
558 vflag = 1;
559 break;
560 default:
561 return command_usage(&readv_cmd);
565 if (optind > argc - 2)
566 return command_usage(&readv_cmd);
569 offset = cvtnum(argv[optind]);
570 if (offset < 0) {
571 printf("non-numeric length argument -- %s\n", argv[optind]);
572 return 0;
574 optind++;
576 if (offset & 0x1ff) {
577 printf("offset %" PRId64 " is not sector aligned\n",
578 offset);
579 return 0;
582 nr_iov = argc - optind;
583 buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab);
585 gettimeofday(&t1, NULL);
586 cnt = do_aio_readv(&qiov, offset, &total);
587 gettimeofday(&t2, NULL);
589 if (cnt < 0) {
590 printf("readv failed: %s\n", strerror(-cnt));
591 goto out;
594 if (Pflag) {
595 void* cmp_buf = malloc(qiov.size);
596 memset(cmp_buf, pattern, qiov.size);
597 if (memcmp(buf, cmp_buf, qiov.size)) {
598 printf("Pattern verification failed at offset %"
599 PRId64 ", %zd bytes\n",
600 offset, qiov.size);
602 free(cmp_buf);
605 if (qflag)
606 goto out;
608 if (vflag)
609 dump_buffer(buf, offset, qiov.size);
611 /* Finally, report back -- -C gives a parsable format */
612 t2 = tsub(t2, t1);
613 print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
615 out:
616 qemu_io_free(buf);
617 return 0;
620 static void
621 write_help(void)
623 printf(
624 "\n"
625 " writes a range of bytes from the given offset\n"
626 "\n"
627 " Example:\n"
628 " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
629 "\n"
630 " Writes into a segment of the currently open file, using a buffer\n"
631 " filled with a set pattern (0xcdcdcdcd).\n"
632 " -b, -- write to the VM state rather than the virtual disk\n"
633 " -p, -- use bdrv_pwrite to write the file\n"
634 " -P, -- use different pattern to fill file\n"
635 " -C, -- report statistics in a machine parsable format\n"
636 " -q, -- quiet mode, do not show I/O statistics\n"
637 "\n");
640 static int write_f(int argc, char **argv);
642 static const cmdinfo_t write_cmd = {
643 .name = "write",
644 .altname = "w",
645 .cfunc = write_f,
646 .argmin = 2,
647 .argmax = -1,
648 .args = "[-abCpq] [-P pattern ] off len",
649 .oneline = "writes a number of bytes at a specified offset",
650 .help = write_help,
653 static int
654 write_f(int argc, char **argv)
656 struct timeval t1, t2;
657 int Cflag = 0, pflag = 0, qflag = 0, bflag = 0;
658 int c, cnt;
659 char *buf;
660 int64_t offset;
661 int count;
662 /* Some compilers get confused and warn if this is not initialized. */
663 int total = 0;
664 int pattern = 0xcd;
666 while ((c = getopt(argc, argv, "bCpP:q")) != EOF) {
667 switch (c) {
668 case 'b':
669 bflag = 1;
670 break;
671 case 'C':
672 Cflag = 1;
673 break;
674 case 'p':
675 pflag = 1;
676 break;
677 case 'P':
678 pattern = parse_pattern(optarg);
679 if (pattern < 0)
680 return 0;
681 break;
682 case 'q':
683 qflag = 1;
684 break;
685 default:
686 return command_usage(&write_cmd);
690 if (optind != argc - 2)
691 return command_usage(&write_cmd);
693 if (bflag && pflag) {
694 printf("-b and -p cannot be specified at the same time\n");
695 return 0;
698 offset = cvtnum(argv[optind]);
699 if (offset < 0) {
700 printf("non-numeric length argument -- %s\n", argv[optind]);
701 return 0;
704 optind++;
705 count = cvtnum(argv[optind]);
706 if (count < 0) {
707 printf("non-numeric length argument -- %s\n", argv[optind]);
708 return 0;
711 if (!pflag) {
712 if (offset & 0x1ff) {
713 printf("offset %" PRId64 " is not sector aligned\n",
714 offset);
715 return 0;
718 if (count & 0x1ff) {
719 printf("count %d is not sector aligned\n",
720 count);
721 return 0;
725 buf = qemu_io_alloc(count, pattern);
727 gettimeofday(&t1, NULL);
728 if (pflag)
729 cnt = do_pwrite(buf, offset, count, &total);
730 else if (bflag)
731 cnt = do_save_vmstate(buf, offset, count, &total);
732 else
733 cnt = do_write(buf, offset, count, &total);
734 gettimeofday(&t2, NULL);
736 if (cnt < 0) {
737 printf("write failed: %s\n", strerror(-cnt));
738 goto out;
741 if (qflag)
742 goto out;
744 /* Finally, report back -- -C gives a parsable format */
745 t2 = tsub(t2, t1);
746 print_report("wrote", &t2, offset, count, total, cnt, Cflag);
748 out:
749 qemu_io_free(buf);
751 return 0;
754 static void
755 writev_help(void)
757 printf(
758 "\n"
759 " writes a range of bytes from the given offset source from multiple buffers\n"
760 "\n"
761 " Example:\n"
762 " 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
763 "\n"
764 " Writes into a segment of the currently open file, using a buffer\n"
765 " filled with a set pattern (0xcdcdcdcd).\n"
766 " -P, -- use different pattern to fill file\n"
767 " -C, -- report statistics in a machine parsable format\n"
768 " -q, -- quiet mode, do not show I/O statistics\n"
769 "\n");
772 static int writev_f(int argc, char **argv);
774 static const cmdinfo_t writev_cmd = {
775 .name = "writev",
776 .cfunc = writev_f,
777 .argmin = 2,
778 .argmax = -1,
779 .args = "[-Cq] [-P pattern ] off len [len..]",
780 .oneline = "writes a number of bytes at a specified offset",
781 .help = writev_help,
784 static int
785 writev_f(int argc, char **argv)
787 struct timeval t1, t2;
788 int Cflag = 0, qflag = 0;
789 int c, cnt;
790 char *buf;
791 int64_t offset;
792 /* Some compilers get confused and warn if this is not initialized. */
793 int total = 0;
794 int nr_iov;
795 int pattern = 0xcd;
796 QEMUIOVector qiov;
798 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
799 switch (c) {
800 case 'C':
801 Cflag = 1;
802 break;
803 case 'q':
804 qflag = 1;
805 break;
806 case 'P':
807 pattern = parse_pattern(optarg);
808 if (pattern < 0)
809 return 0;
810 break;
811 default:
812 return command_usage(&writev_cmd);
816 if (optind > argc - 2)
817 return command_usage(&writev_cmd);
819 offset = cvtnum(argv[optind]);
820 if (offset < 0) {
821 printf("non-numeric length argument -- %s\n", argv[optind]);
822 return 0;
824 optind++;
826 if (offset & 0x1ff) {
827 printf("offset %" PRId64 " is not sector aligned\n",
828 offset);
829 return 0;
832 nr_iov = argc - optind;
833 buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern);
835 gettimeofday(&t1, NULL);
836 cnt = do_aio_writev(&qiov, offset, &total);
837 gettimeofday(&t2, NULL);
839 if (cnt < 0) {
840 printf("writev failed: %s\n", strerror(-cnt));
841 goto out;
844 if (qflag)
845 goto out;
847 /* Finally, report back -- -C gives a parsable format */
848 t2 = tsub(t2, t1);
849 print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
850 out:
851 qemu_io_free(buf);
852 return 0;
855 static void
856 multiwrite_help(void)
858 printf(
859 "\n"
860 " writes a range of bytes from the given offset source from multiple buffers,\n"
861 " in a batch of requests that may be merged by qemu\n"
862 "\n"
863 " Example:\n"
864 " 'multiwrite 512 1k 1k ; 4k 1k' \n"
865 " writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"
866 "\n"
867 " Writes into a segment of the currently open file, using a buffer\n"
868 " filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"
869 " by one for each request contained in the multiwrite command.\n"
870 " -P, -- use different pattern to fill file\n"
871 " -C, -- report statistics in a machine parsable format\n"
872 " -q, -- quiet mode, do not show I/O statistics\n"
873 "\n");
876 static int multiwrite_f(int argc, char **argv);
878 static const cmdinfo_t multiwrite_cmd = {
879 .name = "multiwrite",
880 .cfunc = multiwrite_f,
881 .argmin = 2,
882 .argmax = -1,
883 .args = "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",
884 .oneline = "issues multiple write requests at once",
885 .help = multiwrite_help,
888 static int
889 multiwrite_f(int argc, char **argv)
891 struct timeval t1, t2;
892 int Cflag = 0, qflag = 0;
893 int c, cnt;
894 char **buf;
895 int64_t offset, first_offset = 0;
896 /* Some compilers get confused and warn if this is not initialized. */
897 int total = 0;
898 int nr_iov;
899 int nr_reqs;
900 int pattern = 0xcd;
901 QEMUIOVector *qiovs;
902 int i;
903 BlockRequest *reqs;
905 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
906 switch (c) {
907 case 'C':
908 Cflag = 1;
909 break;
910 case 'q':
911 qflag = 1;
912 break;
913 case 'P':
914 pattern = parse_pattern(optarg);
915 if (pattern < 0)
916 return 0;
917 break;
918 default:
919 return command_usage(&writev_cmd);
923 if (optind > argc - 2)
924 return command_usage(&writev_cmd);
926 nr_reqs = 1;
927 for (i = optind; i < argc; i++) {
928 if (!strcmp(argv[i], ";")) {
929 nr_reqs++;
933 reqs = qemu_malloc(nr_reqs * sizeof(*reqs));
934 buf = qemu_malloc(nr_reqs * sizeof(*buf));
935 qiovs = qemu_malloc(nr_reqs * sizeof(*qiovs));
937 for (i = 0; i < nr_reqs; i++) {
938 int j;
940 /* Read the offset of the request */
941 offset = cvtnum(argv[optind]);
942 if (offset < 0) {
943 printf("non-numeric offset argument -- %s\n", argv[optind]);
944 return 0;
946 optind++;
948 if (offset & 0x1ff) {
949 printf("offset %lld is not sector aligned\n",
950 (long long)offset);
951 return 0;
954 if (i == 0) {
955 first_offset = offset;
958 /* Read lengths for qiov entries */
959 for (j = optind; j < argc; j++) {
960 if (!strcmp(argv[j], ";")) {
961 break;
965 nr_iov = j - optind;
967 /* Build request */
968 reqs[i].qiov = &qiovs[i];
969 buf[i] = create_iovec(reqs[i].qiov, &argv[optind], nr_iov, pattern);
970 reqs[i].sector = offset >> 9;
971 reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
973 optind = j + 1;
975 offset += reqs[i].qiov->size;
976 pattern++;
979 gettimeofday(&t1, NULL);
980 cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
981 gettimeofday(&t2, NULL);
983 if (cnt < 0) {
984 printf("aio_multiwrite failed: %s\n", strerror(-cnt));
985 goto out;
988 if (qflag)
989 goto out;
991 /* Finally, report back -- -C gives a parsable format */
992 t2 = tsub(t2, t1);
993 print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
994 out:
995 for (i = 0; i < nr_reqs; i++) {
996 qemu_io_free(buf[i]);
997 qemu_iovec_destroy(&qiovs[i]);
999 qemu_free(buf);
1000 qemu_free(reqs);
1001 qemu_free(qiovs);
1002 return 0;
1005 struct aio_ctx {
1006 QEMUIOVector qiov;
1007 int64_t offset;
1008 char *buf;
1009 int qflag;
1010 int vflag;
1011 int Cflag;
1012 int Pflag;
1013 int pattern;
1014 struct timeval t1;
1017 static void
1018 aio_write_done(void *opaque, int ret)
1020 struct aio_ctx *ctx = opaque;
1021 struct timeval t2;
1023 gettimeofday(&t2, NULL);
1026 if (ret < 0) {
1027 printf("aio_write failed: %s\n", strerror(-ret));
1028 goto out;
1031 if (ctx->qflag) {
1032 goto out;
1035 /* Finally, report back -- -C gives a parsable format */
1036 t2 = tsub(t2, ctx->t1);
1037 print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
1038 ctx->qiov.size, 1, ctx->Cflag);
1039 out:
1040 qemu_io_free(ctx->buf);
1041 free(ctx);
1044 static void
1045 aio_read_done(void *opaque, int ret)
1047 struct aio_ctx *ctx = opaque;
1048 struct timeval t2;
1050 gettimeofday(&t2, NULL);
1052 if (ret < 0) {
1053 printf("readv failed: %s\n", strerror(-ret));
1054 goto out;
1057 if (ctx->Pflag) {
1058 void *cmp_buf = malloc(ctx->qiov.size);
1060 memset(cmp_buf, ctx->pattern, ctx->qiov.size);
1061 if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
1062 printf("Pattern verification failed at offset %"
1063 PRId64 ", %zd bytes\n",
1064 ctx->offset, ctx->qiov.size);
1066 free(cmp_buf);
1069 if (ctx->qflag) {
1070 goto out;
1073 if (ctx->vflag) {
1074 dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
1077 /* Finally, report back -- -C gives a parsable format */
1078 t2 = tsub(t2, ctx->t1);
1079 print_report("read", &t2, ctx->offset, ctx->qiov.size,
1080 ctx->qiov.size, 1, ctx->Cflag);
1081 out:
1082 qemu_io_free(ctx->buf);
1083 free(ctx);
1086 static void
1087 aio_read_help(void)
1089 printf(
1090 "\n"
1091 " asynchronously reads a range of bytes from the given offset\n"
1092 "\n"
1093 " Example:\n"
1094 " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
1095 "\n"
1096 " Reads a segment of the currently open file, optionally dumping it to the\n"
1097 " standard output stream (with -v option) for subsequent inspection.\n"
1098 " The read is performed asynchronously and the aio_flush command must be\n"
1099 " used to ensure all outstanding aio requests have been completed\n"
1100 " -C, -- report statistics in a machine parsable format\n"
1101 " -P, -- use a pattern to verify read data\n"
1102 " -v, -- dump buffer to standard output\n"
1103 " -q, -- quiet mode, do not show I/O statistics\n"
1104 "\n");
1107 static int aio_read_f(int argc, char **argv);
1109 static const cmdinfo_t aio_read_cmd = {
1110 .name = "aio_read",
1111 .cfunc = aio_read_f,
1112 .argmin = 2,
1113 .argmax = -1,
1114 .args = "[-Cqv] [-P pattern ] off len [len..]",
1115 .oneline = "asynchronously reads a number of bytes",
1116 .help = aio_read_help,
1119 static int
1120 aio_read_f(int argc, char **argv)
1122 int nr_iov, c;
1123 struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
1124 BlockDriverAIOCB *acb;
1126 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
1127 switch (c) {
1128 case 'C':
1129 ctx->Cflag = 1;
1130 break;
1131 case 'P':
1132 ctx->Pflag = 1;
1133 ctx->pattern = parse_pattern(optarg);
1134 if (ctx->pattern < 0) {
1135 free(ctx);
1136 return 0;
1138 break;
1139 case 'q':
1140 ctx->qflag = 1;
1141 break;
1142 case 'v':
1143 ctx->vflag = 1;
1144 break;
1145 default:
1146 free(ctx);
1147 return command_usage(&aio_read_cmd);
1151 if (optind > argc - 2) {
1152 free(ctx);
1153 return command_usage(&aio_read_cmd);
1156 ctx->offset = cvtnum(argv[optind]);
1157 if (ctx->offset < 0) {
1158 printf("non-numeric length argument -- %s\n", argv[optind]);
1159 free(ctx);
1160 return 0;
1162 optind++;
1164 if (ctx->offset & 0x1ff) {
1165 printf("offset %" PRId64 " is not sector aligned\n",
1166 ctx->offset);
1167 free(ctx);
1168 return 0;
1171 nr_iov = argc - optind;
1172 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab);
1174 gettimeofday(&ctx->t1, NULL);
1175 acb = bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
1176 ctx->qiov.size >> 9, aio_read_done, ctx);
1177 if (!acb) {
1178 free(ctx->buf);
1179 free(ctx);
1180 return -EIO;
1183 return 0;
1186 static void
1187 aio_write_help(void)
1189 printf(
1190 "\n"
1191 " asynchronously writes a range of bytes from the given offset source \n"
1192 " from multiple buffers\n"
1193 "\n"
1194 " Example:\n"
1195 " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1196 "\n"
1197 " Writes into a segment of the currently open file, using a buffer\n"
1198 " filled with a set pattern (0xcdcdcdcd).\n"
1199 " The write is performed asynchronously and the aio_flush command must be\n"
1200 " used to ensure all outstanding aio requests have been completed\n"
1201 " -P, -- use different pattern to fill file\n"
1202 " -C, -- report statistics in a machine parsable format\n"
1203 " -q, -- quiet mode, do not show I/O statistics\n"
1204 "\n");
1207 static int aio_write_f(int argc, char **argv);
1209 static const cmdinfo_t aio_write_cmd = {
1210 .name = "aio_write",
1211 .cfunc = aio_write_f,
1212 .argmin = 2,
1213 .argmax = -1,
1214 .args = "[-Cq] [-P pattern ] off len [len..]",
1215 .oneline = "asynchronously writes a number of bytes",
1216 .help = aio_write_help,
1219 static int
1220 aio_write_f(int argc, char **argv)
1222 int nr_iov, c;
1223 int pattern = 0xcd;
1224 struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
1225 BlockDriverAIOCB *acb;
1227 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1228 switch (c) {
1229 case 'C':
1230 ctx->Cflag = 1;
1231 break;
1232 case 'q':
1233 ctx->qflag = 1;
1234 break;
1235 case 'P':
1236 pattern = parse_pattern(optarg);
1237 if (pattern < 0)
1238 return 0;
1239 break;
1240 default:
1241 free(ctx);
1242 return command_usage(&aio_write_cmd);
1246 if (optind > argc - 2) {
1247 free(ctx);
1248 return command_usage(&aio_write_cmd);
1251 ctx->offset = cvtnum(argv[optind]);
1252 if (ctx->offset < 0) {
1253 printf("non-numeric length argument -- %s\n", argv[optind]);
1254 free(ctx);
1255 return 0;
1257 optind++;
1259 if (ctx->offset & 0x1ff) {
1260 printf("offset %" PRId64 " is not sector aligned\n",
1261 ctx->offset);
1262 free(ctx);
1263 return 0;
1266 nr_iov = argc - optind;
1267 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
1269 gettimeofday(&ctx->t1, NULL);
1270 acb = bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
1271 ctx->qiov.size >> 9, aio_write_done, ctx);
1272 if (!acb) {
1273 free(ctx->buf);
1274 free(ctx);
1275 return -EIO;
1278 return 0;
1281 static int
1282 aio_flush_f(int argc, char **argv)
1284 qemu_aio_flush();
1285 return 0;
1288 static const cmdinfo_t aio_flush_cmd = {
1289 .name = "aio_flush",
1290 .cfunc = aio_flush_f,
1291 .oneline = "completes all outstanding aio requests"
1294 static int
1295 flush_f(int argc, char **argv)
1297 bdrv_flush(bs);
1298 return 0;
1301 static const cmdinfo_t flush_cmd = {
1302 .name = "flush",
1303 .altname = "f",
1304 .cfunc = flush_f,
1305 .oneline = "flush all in-core file state to disk",
1308 static int
1309 truncate_f(int argc, char **argv)
1311 int64_t offset;
1312 int ret;
1314 offset = cvtnum(argv[1]);
1315 if (offset < 0) {
1316 printf("non-numeric truncate argument -- %s\n", argv[1]);
1317 return 0;
1320 ret = bdrv_truncate(bs, offset);
1321 if (ret < 0) {
1322 printf("truncate: %s\n", strerror(-ret));
1323 return 0;
1326 return 0;
1329 static const cmdinfo_t truncate_cmd = {
1330 .name = "truncate",
1331 .altname = "t",
1332 .cfunc = truncate_f,
1333 .argmin = 1,
1334 .argmax = 1,
1335 .args = "off",
1336 .oneline = "truncates the current file at the given offset",
1339 static int
1340 length_f(int argc, char **argv)
1342 int64_t size;
1343 char s1[64];
1345 size = bdrv_getlength(bs);
1346 if (size < 0) {
1347 printf("getlength: %s\n", strerror(-size));
1348 return 0;
1351 cvtstr(size, s1, sizeof(s1));
1352 printf("%s\n", s1);
1353 return 0;
1357 static const cmdinfo_t length_cmd = {
1358 .name = "length",
1359 .altname = "l",
1360 .cfunc = length_f,
1361 .oneline = "gets the length of the current file",
1365 static int
1366 info_f(int argc, char **argv)
1368 BlockDriverInfo bdi;
1369 char s1[64], s2[64];
1370 int ret;
1372 if (bs->drv && bs->drv->format_name)
1373 printf("format name: %s\n", bs->drv->format_name);
1374 if (bs->drv && bs->drv->protocol_name)
1375 printf("format name: %s\n", bs->drv->protocol_name);
1377 ret = bdrv_get_info(bs, &bdi);
1378 if (ret)
1379 return 0;
1381 cvtstr(bdi.cluster_size, s1, sizeof(s1));
1382 cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
1384 printf("cluster size: %s\n", s1);
1385 printf("vm state offset: %s\n", s2);
1387 return 0;
1392 static const cmdinfo_t info_cmd = {
1393 .name = "info",
1394 .altname = "i",
1395 .cfunc = info_f,
1396 .oneline = "prints information about the current file",
1399 static void
1400 discard_help(void)
1402 printf(
1403 "\n"
1404 " discards a range of bytes from the given offset\n"
1405 "\n"
1406 " Example:\n"
1407 " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
1408 "\n"
1409 " Discards a segment of the currently open file.\n"
1410 " -C, -- report statistics in a machine parsable format\n"
1411 " -q, -- quiet mode, do not show I/O statistics\n"
1412 "\n");
1415 static int discard_f(int argc, char **argv);
1417 static const cmdinfo_t discard_cmd = {
1418 .name = "discard",
1419 .altname = "d",
1420 .cfunc = discard_f,
1421 .argmin = 2,
1422 .argmax = -1,
1423 .args = "[-Cq] off len",
1424 .oneline = "discards a number of bytes at a specified offset",
1425 .help = discard_help,
1428 static int
1429 discard_f(int argc, char **argv)
1431 struct timeval t1, t2;
1432 int Cflag = 0, qflag = 0;
1433 int c, ret;
1434 int64_t offset;
1435 int count;
1437 while ((c = getopt(argc, argv, "Cq")) != EOF) {
1438 switch (c) {
1439 case 'C':
1440 Cflag = 1;
1441 break;
1442 case 'q':
1443 qflag = 1;
1444 break;
1445 default:
1446 return command_usage(&discard_cmd);
1450 if (optind != argc - 2) {
1451 return command_usage(&discard_cmd);
1454 offset = cvtnum(argv[optind]);
1455 if (offset < 0) {
1456 printf("non-numeric length argument -- %s\n", argv[optind]);
1457 return 0;
1460 optind++;
1461 count = cvtnum(argv[optind]);
1462 if (count < 0) {
1463 printf("non-numeric length argument -- %s\n", argv[optind]);
1464 return 0;
1467 gettimeofday(&t1, NULL);
1468 ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS, count >> BDRV_SECTOR_BITS);
1469 gettimeofday(&t2, NULL);
1471 if (ret < 0) {
1472 printf("discard failed: %s\n", strerror(-ret));
1473 goto out;
1476 /* Finally, report back -- -C gives a parsable format */
1477 if (!qflag) {
1478 t2 = tsub(t2, t1);
1479 print_report("discard", &t2, offset, count, count, 1, Cflag);
1482 out:
1483 return 0;
1486 static int
1487 alloc_f(int argc, char **argv)
1489 int64_t offset;
1490 int nb_sectors, remaining;
1491 char s1[64];
1492 int num, sum_alloc;
1493 int ret;
1495 offset = cvtnum(argv[1]);
1496 if (offset & 0x1ff) {
1497 printf("offset %" PRId64 " is not sector aligned\n",
1498 offset);
1499 return 0;
1502 if (argc == 3)
1503 nb_sectors = cvtnum(argv[2]);
1504 else
1505 nb_sectors = 1;
1507 remaining = nb_sectors;
1508 sum_alloc = 0;
1509 while (remaining) {
1510 ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
1511 remaining -= num;
1512 if (ret) {
1513 sum_alloc += num;
1517 cvtstr(offset, s1, sizeof(s1));
1519 printf("%d/%d sectors allocated at offset %s\n",
1520 sum_alloc, nb_sectors, s1);
1521 return 0;
1524 static const cmdinfo_t alloc_cmd = {
1525 .name = "alloc",
1526 .altname = "a",
1527 .argmin = 1,
1528 .argmax = 2,
1529 .cfunc = alloc_f,
1530 .args = "off [sectors]",
1531 .oneline = "checks if a sector is present in the file",
1534 static int
1535 map_f(int argc, char **argv)
1537 int64_t offset;
1538 int64_t nb_sectors;
1539 char s1[64];
1540 int num, num_checked;
1541 int ret;
1542 const char *retstr;
1544 offset = 0;
1545 nb_sectors = bs->total_sectors;
1547 do {
1548 num_checked = MIN(nb_sectors, INT_MAX);
1549 ret = bdrv_is_allocated(bs, offset, num_checked, &num);
1550 retstr = ret ? " allocated" : "not allocated";
1551 cvtstr(offset << 9ULL, s1, sizeof(s1));
1552 printf("[% 24" PRId64 "] % 8d/% 8d sectors %s at offset %s (%d)\n",
1553 offset << 9ULL, num, num_checked, retstr, s1, ret);
1555 offset += num;
1556 nb_sectors -= num;
1557 } while(offset < bs->total_sectors);
1559 return 0;
1562 static const cmdinfo_t map_cmd = {
1563 .name = "map",
1564 .argmin = 0,
1565 .argmax = 0,
1566 .cfunc = map_f,
1567 .args = "",
1568 .oneline = "prints the allocated areas of a file",
1572 static int
1573 close_f(int argc, char **argv)
1575 bdrv_close(bs);
1576 bs = NULL;
1577 return 0;
1580 static const cmdinfo_t close_cmd = {
1581 .name = "close",
1582 .altname = "c",
1583 .cfunc = close_f,
1584 .oneline = "close the current open file",
1587 static int openfile(char *name, int flags, int growable)
1589 if (bs) {
1590 fprintf(stderr, "file open already, try 'help close'\n");
1591 return 1;
1594 if (growable) {
1595 if (bdrv_file_open(&bs, name, flags)) {
1596 fprintf(stderr, "%s: can't open device %s\n", progname, name);
1597 return 1;
1599 } else {
1600 bs = bdrv_new("hda");
1602 if (bdrv_open(bs, name, flags, NULL) < 0) {
1603 fprintf(stderr, "%s: can't open device %s\n", progname, name);
1604 bs = NULL;
1605 return 1;
1609 return 0;
1612 static void
1613 open_help(void)
1615 printf(
1616 "\n"
1617 " opens a new file in the requested mode\n"
1618 "\n"
1619 " Example:\n"
1620 " 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
1621 "\n"
1622 " Opens a file for subsequent use by all of the other qemu-io commands.\n"
1623 " -r, -- open file read-only\n"
1624 " -s, -- use snapshot file\n"
1625 " -n, -- disable host cache\n"
1626 " -g, -- allow file to grow (only applies to protocols)"
1627 "\n");
1630 static int open_f(int argc, char **argv);
1632 static const cmdinfo_t open_cmd = {
1633 .name = "open",
1634 .altname = "o",
1635 .cfunc = open_f,
1636 .argmin = 1,
1637 .argmax = -1,
1638 .flags = CMD_NOFILE_OK,
1639 .args = "[-Crsn] [path]",
1640 .oneline = "open the file specified by path",
1641 .help = open_help,
1644 static int
1645 open_f(int argc, char **argv)
1647 int flags = 0;
1648 int readonly = 0;
1649 int growable = 0;
1650 int c;
1652 while ((c = getopt(argc, argv, "snrg")) != EOF) {
1653 switch (c) {
1654 case 's':
1655 flags |= BDRV_O_SNAPSHOT;
1656 break;
1657 case 'n':
1658 flags |= BDRV_O_NOCACHE;
1659 break;
1660 case 'r':
1661 readonly = 1;
1662 break;
1663 case 'g':
1664 growable = 1;
1665 break;
1666 default:
1667 return command_usage(&open_cmd);
1671 if (!readonly) {
1672 flags |= BDRV_O_RDWR;
1675 if (optind != argc - 1)
1676 return command_usage(&open_cmd);
1678 return openfile(argv[optind], flags, growable);
1681 static int
1682 init_args_command(
1683 int index)
1685 /* only one device allowed so far */
1686 if (index >= 1)
1687 return 0;
1688 return ++index;
1691 static int
1692 init_check_command(
1693 const cmdinfo_t *ct)
1695 if (ct->flags & CMD_FLAG_GLOBAL)
1696 return 1;
1697 if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
1698 fprintf(stderr, "no file open, try 'help open'\n");
1699 return 0;
1701 return 1;
1704 static void usage(const char *name)
1706 printf(
1707 "Usage: %s [-h] [-V] [-rsnm] [-c cmd] ... [file]\n"
1708 "QEMU Disk exerciser\n"
1709 "\n"
1710 " -c, --cmd command to execute\n"
1711 " -r, --read-only export read-only\n"
1712 " -s, --snapshot use snapshot file\n"
1713 " -n, --nocache disable host cache\n"
1714 " -g, --growable allow file to grow (only applies to protocols)\n"
1715 " -m, --misalign misalign allocations for O_DIRECT\n"
1716 " -k, --native-aio use kernel AIO implementation (on Linux only)\n"
1717 " -h, --help display this help and exit\n"
1718 " -V, --version output version information and exit\n"
1719 "\n",
1720 name);
1724 int main(int argc, char **argv)
1726 int readonly = 0;
1727 int growable = 0;
1728 const char *sopt = "hVc:rsnmgk";
1729 const struct option lopt[] = {
1730 { "help", 0, NULL, 'h' },
1731 { "version", 0, NULL, 'V' },
1732 { "offset", 1, NULL, 'o' },
1733 { "cmd", 1, NULL, 'c' },
1734 { "read-only", 0, NULL, 'r' },
1735 { "snapshot", 0, NULL, 's' },
1736 { "nocache", 0, NULL, 'n' },
1737 { "misalign", 0, NULL, 'm' },
1738 { "growable", 0, NULL, 'g' },
1739 { "native-aio", 0, NULL, 'k' },
1740 { NULL, 0, NULL, 0 }
1742 int c;
1743 int opt_index = 0;
1744 int flags = 0;
1746 progname = basename(argv[0]);
1748 while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
1749 switch (c) {
1750 case 's':
1751 flags |= BDRV_O_SNAPSHOT;
1752 break;
1753 case 'n':
1754 flags |= BDRV_O_NOCACHE;
1755 break;
1756 case 'c':
1757 add_user_command(optarg);
1758 break;
1759 case 'r':
1760 readonly = 1;
1761 break;
1762 case 'm':
1763 misalign = 1;
1764 break;
1765 case 'g':
1766 growable = 1;
1767 break;
1768 case 'k':
1769 flags |= BDRV_O_NATIVE_AIO;
1770 break;
1771 case 'V':
1772 printf("%s version %s\n", progname, VERSION);
1773 exit(0);
1774 case 'h':
1775 usage(progname);
1776 exit(0);
1777 default:
1778 usage(progname);
1779 exit(1);
1783 if ((argc - optind) > 1) {
1784 usage(progname);
1785 exit(1);
1788 bdrv_init();
1790 /* initialize commands */
1791 quit_init();
1792 help_init();
1793 add_command(&open_cmd);
1794 add_command(&close_cmd);
1795 add_command(&read_cmd);
1796 add_command(&readv_cmd);
1797 add_command(&write_cmd);
1798 add_command(&writev_cmd);
1799 add_command(&multiwrite_cmd);
1800 add_command(&aio_read_cmd);
1801 add_command(&aio_write_cmd);
1802 add_command(&aio_flush_cmd);
1803 add_command(&flush_cmd);
1804 add_command(&truncate_cmd);
1805 add_command(&length_cmd);
1806 add_command(&info_cmd);
1807 add_command(&discard_cmd);
1808 add_command(&alloc_cmd);
1809 add_command(&map_cmd);
1811 add_args_command(init_args_command);
1812 add_check_command(init_check_command);
1814 /* open the device */
1815 if (!readonly) {
1816 flags |= BDRV_O_RDWR;
1819 if ((argc - optind) == 1)
1820 openfile(argv[optind], flags, growable);
1821 command_loop();
1824 * Make sure all outstanding requests get flushed the program exits.
1826 qemu_aio_flush();
1828 if (bs)
1829 bdrv_close(bs);
1830 return 0;