2 * Command line utility to exercise the QEMU I/O path.
4 * Copyright (C) 2009-2016 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.
11 #include "qemu/osdep.h"
12 #include "qapi/error.h"
13 #include "qapi/qmp/qdict.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"
25 #define CMD_NOFILE_OK 0x01
29 static cmdinfo_t
*cmdtab
;
32 static int compare_cmdname(const void *a
, const void *b
)
34 return strcmp(((const cmdinfo_t
*)a
)->name
,
35 ((const cmdinfo_t
*)b
)->name
);
38 void qemuio_add_command(const cmdinfo_t
*ci
)
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.
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
);
52 void qemuio_command_usage(const cmdinfo_t
*ci
)
54 printf("%s %s -- %s\n", ci
->name
, ci
->args
, ci
->oneline
);
57 static int init_check_command(BlockBackend
*blk
, const cmdinfo_t
*ct
)
59 if (ct
->flags
& CMD_FLAG_GLOBAL
) {
62 if (!(ct
->flags
& CMD_NOFILE_OK
) && !blk
) {
63 fprintf(stderr
, "no file open, try 'help open'\n");
69 static int command(BlockBackend
*blk
, const cmdinfo_t
*ct
, int argc
,
74 if (!init_check_command(blk
, ct
)) {
78 if (argc
- 1 < ct
->argmin
|| (ct
->argmax
!= -1 && argc
- 1 > ct
->argmax
)) {
79 if (ct
->argmax
== -1) {
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
) {
85 "bad argument count %d to %s, expected %d arguments\n",
86 argc
-1, cmd
, ct
->argmin
);
89 "bad argument count %d to %s, expected between %d and %d arguments\n",
90 argc
-1, cmd
, ct
->argmin
, ct
->argmax
);
96 * Request additional permissions if necessary for this command. The caller
97 * is responsible for restoring the original permissions afterwards if this
100 * Coverity thinks that blk may be NULL in the following if condition. It's
101 * not so: in init_check_command() we fail if blk is NULL for command with
102 * both CMD_FLAG_GLOBAL and CMD_NOFILE_OK flags unset. And in
103 * qemuio_add_command() we assert that command with non-zero .perm field
104 * doesn't set this flags. So, the following assertion is to silence
107 assert(blk
|| !ct
->perm
);
108 if (ct
->perm
&& blk_is_available(blk
)) {
109 uint64_t orig_perm
, orig_shared_perm
;
110 blk_get_perm(blk
, &orig_perm
, &orig_shared_perm
);
112 if (ct
->perm
& ~orig_perm
) {
114 Error
*local_err
= NULL
;
117 new_perm
= orig_perm
| ct
->perm
;
119 ret
= blk_set_perm(blk
, new_perm
, orig_shared_perm
, &local_err
);
121 error_report_err(local_err
);
128 return ct
->cfunc(blk
, argc
, argv
);
131 static const cmdinfo_t
*find_command(const char *cmd
)
135 for (ct
= cmdtab
; ct
< &cmdtab
[ncmds
]; ct
++) {
136 if (strcmp(ct
->name
, cmd
) == 0 ||
137 (ct
->altname
&& strcmp(ct
->altname
, cmd
) == 0))
139 return (const cmdinfo_t
*)ct
;
145 /* Invoke fn() for commands with a matching prefix */
146 void qemuio_complete_command(const char *input
,
147 void (*fn
)(const char *cmd
, void *opaque
),
151 size_t input_len
= strlen(input
);
153 for (ct
= cmdtab
; ct
< &cmdtab
[ncmds
]; ct
++) {
154 if (strncmp(input
, ct
->name
, input_len
) == 0) {
155 fn(ct
->name
, opaque
);
160 static char **breakline(char *input
, int *count
)
164 char **rval
= g_new0(char *, 1);
166 while (rval
&& (p
= qemu_strsep(&input
, " ")) != NULL
) {
171 rval
= g_renew(char *, rval
, (c
+ 1));
179 static int64_t cvtnum(const char *s
)
184 err
= qemu_strtosz(s
, NULL
, &value
);
188 if (value
> INT64_MAX
) {
194 static void print_cvtnum_err(int64_t rc
, const char *arg
)
198 printf("Parsing error: non-numeric argument,"
199 " or extraneous/unrecognized suffix -- %s\n", arg
);
202 printf("Parsing error: argument too large -- %s\n", arg
);
205 printf("Parsing error: %s\n", arg
);
209 #define EXABYTES(x) ((long long)(x) << 60)
210 #define PETABYTES(x) ((long long)(x) << 50)
211 #define TERABYTES(x) ((long long)(x) << 40)
212 #define GIGABYTES(x) ((long long)(x) << 30)
213 #define MEGABYTES(x) ((long long)(x) << 20)
214 #define KILOBYTES(x) ((long long)(x) << 10)
216 #define TO_EXABYTES(x) ((x) / EXABYTES(1))
217 #define TO_PETABYTES(x) ((x) / PETABYTES(1))
218 #define TO_TERABYTES(x) ((x) / TERABYTES(1))
219 #define TO_GIGABYTES(x) ((x) / GIGABYTES(1))
220 #define TO_MEGABYTES(x) ((x) / MEGABYTES(1))
221 #define TO_KILOBYTES(x) ((x) / KILOBYTES(1))
223 static void cvtstr(double value
, char *str
, size_t size
)
228 if (value
>= EXABYTES(1)) {
230 snprintf(str
, size
- 4, "%.3f", TO_EXABYTES(value
));
231 } else if (value
>= PETABYTES(1)) {
233 snprintf(str
, size
- 4, "%.3f", TO_PETABYTES(value
));
234 } else if (value
>= TERABYTES(1)) {
236 snprintf(str
, size
- 4, "%.3f", TO_TERABYTES(value
));
237 } else if (value
>= GIGABYTES(1)) {
239 snprintf(str
, size
- 4, "%.3f", TO_GIGABYTES(value
));
240 } else if (value
>= MEGABYTES(1)) {
242 snprintf(str
, size
- 4, "%.3f", TO_MEGABYTES(value
));
243 } else if (value
>= KILOBYTES(1)) {
245 snprintf(str
, size
- 4, "%.3f", TO_KILOBYTES(value
));
248 snprintf(str
, size
- 6, "%f", value
);
251 trim
= strstr(str
, ".000");
253 strcpy(trim
, suffix
);
261 static struct timespec
tsub(struct timespec t1
, struct timespec t2
)
263 t1
.tv_nsec
-= t2
.tv_nsec
;
264 if (t1
.tv_nsec
< 0) {
265 t1
.tv_nsec
+= NANOSECONDS_PER_SECOND
;
268 t1
.tv_sec
-= t2
.tv_sec
;
272 static double tdiv(double value
, struct timespec tv
)
274 double seconds
= tv
.tv_sec
+ (tv
.tv_nsec
/ 1e9
);
275 return value
/ seconds
;
278 #define HOURS(sec) ((sec) / (60 * 60))
279 #define MINUTES(sec) (((sec) % (60 * 60)) / 60)
280 #define SECONDS(sec) ((sec) % 60)
284 TERSE_FIXED_TIME
= 0x1,
285 VERBOSE_FIXED_TIME
= 0x2,
288 static void timestr(struct timespec
*tv
, char *ts
, size_t size
, int format
)
290 double frac_sec
= tv
->tv_nsec
/ 1e9
;
292 if (format
& TERSE_FIXED_TIME
) {
293 if (!HOURS(tv
->tv_sec
)) {
294 snprintf(ts
, size
, "%u:%05.2f",
295 (unsigned int) MINUTES(tv
->tv_sec
),
296 SECONDS(tv
->tv_sec
) + frac_sec
);
299 format
|= VERBOSE_FIXED_TIME
; /* fallback if hours needed */
302 if ((format
& VERBOSE_FIXED_TIME
) || tv
->tv_sec
) {
303 snprintf(ts
, size
, "%u:%02u:%05.2f",
304 (unsigned int) HOURS(tv
->tv_sec
),
305 (unsigned int) MINUTES(tv
->tv_sec
),
306 SECONDS(tv
->tv_sec
) + frac_sec
);
308 snprintf(ts
, size
, "%05.2f sec", frac_sec
);
313 * Parse the pattern argument to various sub-commands.
315 * Because the pattern is used as an argument to memset it must evaluate
316 * to an unsigned integer that fits into a single byte.
318 static int parse_pattern(const char *arg
)
323 pattern
= strtol(arg
, &endptr
, 0);
324 if (pattern
< 0 || pattern
> UCHAR_MAX
|| *endptr
!= '\0') {
325 printf("%s is not a valid pattern byte\n", arg
);
333 * Memory allocation helpers.
335 * Make sure memory is aligned by default, or purposefully misaligned if
336 * that is specified on the command line.
339 #define MISALIGN_OFFSET 16
340 static void *qemu_io_alloc(BlockBackend
*blk
, size_t len
, int pattern
)
344 if (qemuio_misalign
) {
345 len
+= MISALIGN_OFFSET
;
347 buf
= blk_blockalign(blk
, len
);
348 memset(buf
, pattern
, len
);
349 if (qemuio_misalign
) {
350 buf
+= MISALIGN_OFFSET
;
355 static void qemu_io_free(void *p
)
357 if (qemuio_misalign
) {
358 p
-= MISALIGN_OFFSET
;
364 * qemu_io_alloc_from_file()
366 * Allocates the buffer and populates it with the content of the given file
367 * up to @len bytes. If the file length is less than @len, then the buffer
368 * is populated with the file content cyclically.
370 * @blk - the block backend where the buffer content is going to be written to
371 * @len - the buffer length
372 * @file_name - the file to read the content from
374 * Returns: the buffer pointer on success
377 static void *qemu_io_alloc_from_file(BlockBackend
*blk
, size_t len
,
378 const char *file_name
)
380 char *buf
, *buf_origin
;
381 FILE *f
= fopen(file_name
, "r");
389 if (qemuio_misalign
) {
390 len
+= MISALIGN_OFFSET
;
393 buf_origin
= buf
= blk_blockalign(blk
, len
);
395 if (qemuio_misalign
) {
396 buf_origin
+= MISALIGN_OFFSET
;
397 buf
+= MISALIGN_OFFSET
;
398 len
-= MISALIGN_OFFSET
;
401 pattern_len
= fread(buf_origin
, 1, len
, f
);
408 if (pattern_len
== 0) {
409 fprintf(stderr
, "%s: file is empty\n", file_name
);
416 if (len
> pattern_len
) {
421 size_t len_to_copy
= MIN(pattern_len
, len
);
423 memcpy(buf
, buf_origin
, len_to_copy
);
433 qemu_io_free(buf_origin
);
440 static void dump_buffer(const void *buffer
, int64_t offset
, int64_t len
)
446 for (i
= 0, p
= buffer
; i
< len
; i
+= 16) {
447 const uint8_t *s
= p
;
449 printf("%08" PRIx64
": ", offset
+ i
);
450 for (j
= 0; j
< 16 && i
+ j
< len
; j
++, p
++) {
454 for (j
= 0; j
< 16 && i
+ j
< len
; j
++, s
++) {
465 static void print_report(const char *op
, struct timespec
*t
, int64_t offset
,
466 int64_t count
, int64_t total
, int cnt
, bool Cflag
)
468 char s1
[64], s2
[64], ts
[64];
470 timestr(t
, ts
, sizeof(ts
), Cflag
? VERBOSE_FIXED_TIME
: 0);
472 cvtstr((double)total
, s1
, sizeof(s1
));
473 cvtstr(tdiv((double)total
, *t
), s2
, sizeof(s2
));
474 printf("%s %"PRId64
"/%"PRId64
" bytes at offset %" PRId64
"\n",
475 op
, total
, count
, offset
);
476 printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
477 s1
, cnt
, ts
, s2
, tdiv((double)cnt
, *t
));
478 } else {/* bytes,ops,time,bytes/sec,ops/sec */
479 printf("%"PRId64
",%d,%s,%.3f,%.3f\n",
481 tdiv((double)total
, *t
),
482 tdiv((double)cnt
, *t
));
487 * Parse multiple length statements for vectored I/O, and construct an I/O
488 * vector matching it.
491 create_iovec(BlockBackend
*blk
, QEMUIOVector
*qiov
, char **argv
, int nr_iov
,
494 size_t *sizes
= g_new0(size_t, nr_iov
);
500 for (i
= 0; i
< nr_iov
; i
++) {
506 print_cvtnum_err(len
, arg
);
510 if (len
> BDRV_REQUEST_MAX_BYTES
) {
511 printf("Argument '%s' exceeds maximum size %" PRIu64
"\n", arg
,
512 (uint64_t)BDRV_REQUEST_MAX_BYTES
);
516 if (count
> BDRV_REQUEST_MAX_BYTES
- len
) {
517 printf("The total number of bytes exceed the maximum size %" PRIu64
518 "\n", (uint64_t)BDRV_REQUEST_MAX_BYTES
);
526 qemu_iovec_init(qiov
, nr_iov
);
528 buf
= p
= qemu_io_alloc(blk
, count
, pattern
);
530 for (i
= 0; i
< nr_iov
; i
++) {
531 qemu_iovec_add(qiov
, p
, sizes
[i
]);
540 static int do_pread(BlockBackend
*blk
, char *buf
, int64_t offset
,
541 int64_t bytes
, int64_t *total
)
543 if (bytes
> INT_MAX
) {
547 *total
= blk_pread(blk
, offset
, (uint8_t *)buf
, bytes
);
554 static int do_pwrite(BlockBackend
*blk
, char *buf
, int64_t offset
,
555 int64_t bytes
, int flags
, int64_t *total
)
557 if (bytes
> INT_MAX
) {
561 *total
= blk_pwrite(blk
, offset
, (uint8_t *)buf
, bytes
, flags
);
578 static void coroutine_fn
co_pwrite_zeroes_entry(void *opaque
)
580 CoWriteZeroes
*data
= opaque
;
582 data
->ret
= blk_co_pwrite_zeroes(data
->blk
, data
->offset
, data
->bytes
,
586 *data
->total
= data
->ret
;
590 *data
->total
= data
->bytes
;
593 static int do_co_pwrite_zeroes(BlockBackend
*blk
, int64_t offset
,
594 int64_t bytes
, int flags
, int64_t *total
)
597 CoWriteZeroes data
= {
606 co
= qemu_coroutine_create(co_pwrite_zeroes_entry
, &data
);
607 bdrv_coroutine_enter(blk_bs(blk
), co
);
609 aio_poll(blk_get_aio_context(blk
), true);
618 static int do_write_compressed(BlockBackend
*blk
, char *buf
, int64_t offset
,
619 int64_t bytes
, int64_t *total
)
623 if (bytes
> BDRV_REQUEST_MAX_BYTES
) {
627 ret
= blk_pwrite_compressed(blk
, offset
, buf
, bytes
);
635 static int do_load_vmstate(BlockBackend
*blk
, char *buf
, int64_t offset
,
636 int64_t count
, int64_t *total
)
638 if (count
> INT_MAX
) {
642 *total
= blk_load_vmstate(blk
, (uint8_t *)buf
, offset
, count
);
649 static int do_save_vmstate(BlockBackend
*blk
, char *buf
, int64_t offset
,
650 int64_t count
, int64_t *total
)
652 if (count
> INT_MAX
) {
656 *total
= blk_save_vmstate(blk
, (uint8_t *)buf
, offset
, count
);
663 #define NOT_DONE 0x7fffffff
664 static void aio_rw_done(void *opaque
, int ret
)
666 *(int *)opaque
= ret
;
669 static int do_aio_readv(BlockBackend
*blk
, QEMUIOVector
*qiov
,
670 int64_t offset
, int *total
)
672 int async_ret
= NOT_DONE
;
674 blk_aio_preadv(blk
, offset
, qiov
, 0, aio_rw_done
, &async_ret
);
675 while (async_ret
== NOT_DONE
) {
676 main_loop_wait(false);
680 return async_ret
< 0 ? async_ret
: 1;
683 static int do_aio_writev(BlockBackend
*blk
, QEMUIOVector
*qiov
,
684 int64_t offset
, int flags
, int *total
)
686 int async_ret
= NOT_DONE
;
688 blk_aio_pwritev(blk
, offset
, qiov
, flags
, aio_rw_done
, &async_ret
);
689 while (async_ret
== NOT_DONE
) {
690 main_loop_wait(false);
694 return async_ret
< 0 ? async_ret
: 1;
697 static void read_help(void)
701 " reads a range of bytes from the given offset\n"
704 " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
706 " Reads a segment of the currently open file, optionally dumping it to the\n"
707 " standard output stream (with -v option) for subsequent inspection.\n"
708 " -b, -- read from the VM state rather than the virtual disk\n"
709 " -C, -- report statistics in a machine parsable format\n"
710 " -l, -- length for pattern verification (only with -P)\n"
711 " -p, -- ignored for backwards compatibility\n"
712 " -P, -- use a pattern to verify read data\n"
713 " -q, -- quiet mode, do not show I/O statistics\n"
714 " -s, -- start offset for pattern verification (only with -P)\n"
715 " -v, -- dump buffer to standard output\n"
719 static int read_f(BlockBackend
*blk
, int argc
, char **argv
);
721 static const cmdinfo_t read_cmd
= {
727 .args
= "[-abCqv] [-P pattern [-s off] [-l len]] off len",
728 .oneline
= "reads a number of bytes at a specified offset",
732 static int read_f(BlockBackend
*blk
, int argc
, char **argv
)
734 struct timespec t1
, t2
;
735 bool Cflag
= false, qflag
= false, vflag
= false;
736 bool Pflag
= false, sflag
= false, lflag
= false, bflag
= false;
741 /* Some compilers get confused and warn if this is not initialized. */
744 int64_t pattern_offset
= 0, pattern_count
= 0;
746 while ((c
= getopt(argc
, argv
, "bCl:pP:qs:v")) != -1) {
756 pattern_count
= cvtnum(optarg
);
757 if (pattern_count
< 0) {
758 print_cvtnum_err(pattern_count
, optarg
);
759 return pattern_count
;
763 /* Ignored for backwards compatibility */
767 pattern
= parse_pattern(optarg
);
777 pattern_offset
= cvtnum(optarg
);
778 if (pattern_offset
< 0) {
779 print_cvtnum_err(pattern_offset
, optarg
);
780 return pattern_offset
;
787 qemuio_command_usage(&read_cmd
);
792 if (optind
!= argc
- 2) {
793 qemuio_command_usage(&read_cmd
);
797 offset
= cvtnum(argv
[optind
]);
799 print_cvtnum_err(offset
, argv
[optind
]);
804 count
= cvtnum(argv
[optind
]);
806 print_cvtnum_err(count
, argv
[optind
]);
808 } else if (count
> BDRV_REQUEST_MAX_BYTES
) {
809 printf("length cannot exceed %" PRIu64
", given %s\n",
810 (uint64_t)BDRV_REQUEST_MAX_BYTES
, argv
[optind
]);
814 if (!Pflag
&& (lflag
|| sflag
)) {
815 qemuio_command_usage(&read_cmd
);
820 pattern_count
= count
- pattern_offset
;
823 if ((pattern_count
< 0) || (pattern_count
+ pattern_offset
> count
)) {
824 printf("pattern verification range exceeds end of read data\n");
829 if (!QEMU_IS_ALIGNED(offset
, BDRV_SECTOR_SIZE
)) {
830 printf("%" PRId64
" is not a sector-aligned value for 'offset'\n",
834 if (!QEMU_IS_ALIGNED(count
, BDRV_SECTOR_SIZE
)) {
835 printf("%"PRId64
" is not a sector-aligned value for 'count'\n",
841 buf
= qemu_io_alloc(blk
, count
, 0xab);
843 clock_gettime(CLOCK_MONOTONIC
, &t1
);
845 ret
= do_load_vmstate(blk
, buf
, offset
, count
, &total
);
847 ret
= do_pread(blk
, buf
, offset
, count
, &total
);
849 clock_gettime(CLOCK_MONOTONIC
, &t2
);
852 printf("read failed: %s\n", strerror(-ret
));
860 void *cmp_buf
= g_malloc(pattern_count
);
861 memset(cmp_buf
, pattern
, pattern_count
);
862 if (memcmp(buf
+ pattern_offset
, cmp_buf
, pattern_count
)) {
863 printf("Pattern verification failed at offset %"
864 PRId64
", %"PRId64
" bytes\n",
865 offset
+ pattern_offset
, pattern_count
);
876 dump_buffer(buf
, offset
, count
);
879 /* Finally, report back -- -C gives a parsable format */
881 print_report("read", &t2
, offset
, count
, total
, cnt
, Cflag
);
888 static void readv_help(void)
892 " reads a range of bytes from the given offset into multiple buffers\n"
895 " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
897 " Reads a segment of the currently open file, optionally dumping it to the\n"
898 " standard output stream (with -v option) for subsequent inspection.\n"
899 " Uses multiple iovec buffers if more than one byte range is specified.\n"
900 " -C, -- report statistics in a machine parsable format\n"
901 " -P, -- use a pattern to verify read data\n"
902 " -v, -- dump buffer to standard output\n"
903 " -q, -- quiet mode, do not show I/O statistics\n"
907 static int readv_f(BlockBackend
*blk
, int argc
, char **argv
);
909 static const cmdinfo_t readv_cmd
= {
914 .args
= "[-Cqv] [-P pattern] off len [len..]",
915 .oneline
= "reads a number of bytes at a specified offset",
919 static int readv_f(BlockBackend
*blk
, int argc
, char **argv
)
921 struct timespec t1
, t2
;
922 bool Cflag
= false, qflag
= false, vflag
= false;
926 /* Some compilers get confused and warn if this is not initialized. */
933 while ((c
= getopt(argc
, argv
, "CP:qv")) != -1) {
940 pattern
= parse_pattern(optarg
);
952 qemuio_command_usage(&readv_cmd
);
957 if (optind
> argc
- 2) {
958 qemuio_command_usage(&readv_cmd
);
963 offset
= cvtnum(argv
[optind
]);
965 print_cvtnum_err(offset
, argv
[optind
]);
970 nr_iov
= argc
- optind
;
971 buf
= create_iovec(blk
, &qiov
, &argv
[optind
], nr_iov
, 0xab);
976 clock_gettime(CLOCK_MONOTONIC
, &t1
);
977 ret
= do_aio_readv(blk
, &qiov
, offset
, &total
);
978 clock_gettime(CLOCK_MONOTONIC
, &t2
);
981 printf("readv failed: %s\n", strerror(-ret
));
989 void *cmp_buf
= g_malloc(qiov
.size
);
990 memset(cmp_buf
, pattern
, qiov
.size
);
991 if (memcmp(buf
, cmp_buf
, qiov
.size
)) {
992 printf("Pattern verification failed at offset %"
993 PRId64
", %zu bytes\n", offset
, qiov
.size
);
1004 dump_buffer(buf
, offset
, qiov
.size
);
1007 /* Finally, report back -- -C gives a parsable format */
1009 print_report("read", &t2
, offset
, qiov
.size
, total
, cnt
, Cflag
);
1012 qemu_iovec_destroy(&qiov
);
1017 static void write_help(void)
1021 " writes a range of bytes from the given offset\n"
1024 " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
1026 " Writes into a segment of the currently open file, using a buffer\n"
1027 " filled with a set pattern (0xcdcdcdcd).\n"
1028 " -b, -- write to the VM state rather than the virtual disk\n"
1029 " -c, -- write compressed data with blk_write_compressed\n"
1030 " -f, -- use Force Unit Access semantics\n"
1031 " -n, -- with -z, don't allow slow fallback\n"
1032 " -p, -- ignored for backwards compatibility\n"
1033 " -P, -- use different pattern to fill file\n"
1034 " -s, -- use a pattern file to fill the write buffer\n"
1035 " -C, -- report statistics in a machine parsable format\n"
1036 " -q, -- quiet mode, do not show I/O statistics\n"
1037 " -u, -- with -z, allow unmapping\n"
1038 " -z, -- write zeroes using blk_co_pwrite_zeroes\n"
1042 static int write_f(BlockBackend
*blk
, int argc
, char **argv
);
1044 static const cmdinfo_t write_cmd
= {
1048 .perm
= BLK_PERM_WRITE
,
1051 .args
= "[-bcCfnquz] [-P pattern | -s source_file] off len",
1052 .oneline
= "writes a number of bytes at a specified offset",
1056 static int write_f(BlockBackend
*blk
, int argc
, char **argv
)
1058 struct timespec t1
, t2
;
1059 bool Cflag
= false, qflag
= false, bflag
= false;
1060 bool Pflag
= false, zflag
= false, cflag
= false, sflag
= false;
1066 /* Some compilers get confused and warn if this is not initialized. */
1069 const char *file_name
= NULL
;
1071 while ((c
= getopt(argc
, argv
, "bcCfnpP:qs:uz")) != -1) {
1083 flags
|= BDRV_REQ_FUA
;
1086 flags
|= BDRV_REQ_NO_FALLBACK
;
1089 /* Ignored for backwards compatibility */
1093 pattern
= parse_pattern(optarg
);
1106 flags
|= BDRV_REQ_MAY_UNMAP
;
1112 qemuio_command_usage(&write_cmd
);
1117 if (optind
!= argc
- 2) {
1118 qemuio_command_usage(&write_cmd
);
1122 if (bflag
&& zflag
) {
1123 printf("-b and -z cannot be specified at the same time\n");
1127 if ((flags
& BDRV_REQ_FUA
) && (bflag
|| cflag
)) {
1128 printf("-f and -b or -c cannot be specified at the same time\n");
1132 if ((flags
& BDRV_REQ_NO_FALLBACK
) && !zflag
) {
1133 printf("-n requires -z to be specified\n");
1137 if ((flags
& BDRV_REQ_MAY_UNMAP
) && !zflag
) {
1138 printf("-u requires -z to be specified\n");
1142 if (zflag
+ Pflag
+ sflag
> 1) {
1143 printf("Only one of -z, -P, and -s "
1144 "can be specified at the same time\n");
1148 offset
= cvtnum(argv
[optind
]);
1150 print_cvtnum_err(offset
, argv
[optind
]);
1155 count
= cvtnum(argv
[optind
]);
1157 print_cvtnum_err(count
, argv
[optind
]);
1159 } else if (count
> BDRV_REQUEST_MAX_BYTES
&&
1160 !(flags
& BDRV_REQ_NO_FALLBACK
)) {
1161 printf("length cannot exceed %" PRIu64
" without -n, given %s\n",
1162 (uint64_t)BDRV_REQUEST_MAX_BYTES
, argv
[optind
]);
1166 if (bflag
|| cflag
) {
1167 if (!QEMU_IS_ALIGNED(offset
, BDRV_SECTOR_SIZE
)) {
1168 printf("%" PRId64
" is not a sector-aligned value for 'offset'\n",
1173 if (!QEMU_IS_ALIGNED(count
, BDRV_SECTOR_SIZE
)) {
1174 printf("%"PRId64
" is not a sector-aligned value for 'count'\n",
1182 buf
= qemu_io_alloc_from_file(blk
, count
, file_name
);
1187 buf
= qemu_io_alloc(blk
, count
, pattern
);
1191 clock_gettime(CLOCK_MONOTONIC
, &t1
);
1193 ret
= do_save_vmstate(blk
, buf
, offset
, count
, &total
);
1195 ret
= do_co_pwrite_zeroes(blk
, offset
, count
, flags
, &total
);
1197 ret
= do_write_compressed(blk
, buf
, offset
, count
, &total
);
1199 ret
= do_pwrite(blk
, buf
, offset
, count
, flags
, &total
);
1201 clock_gettime(CLOCK_MONOTONIC
, &t2
);
1204 printf("write failed: %s\n", strerror(-ret
));
1215 /* Finally, report back -- -C gives a parsable format */
1217 print_report("wrote", &t2
, offset
, count
, total
, cnt
, Cflag
);
1231 " writes a range of bytes from the given offset source from multiple buffers\n"
1234 " 'writev 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1236 " Writes into a segment of the currently open file, using a buffer\n"
1237 " filled with a set pattern (0xcdcdcdcd).\n"
1238 " -P, -- use different pattern to fill file\n"
1239 " -C, -- report statistics in a machine parsable format\n"
1240 " -f, -- use Force Unit Access semantics\n"
1241 " -q, -- quiet mode, do not show I/O statistics\n"
1245 static int writev_f(BlockBackend
*blk
, int argc
, char **argv
);
1247 static const cmdinfo_t writev_cmd
= {
1250 .perm
= BLK_PERM_WRITE
,
1253 .args
= "[-Cfq] [-P pattern] off len [len..]",
1254 .oneline
= "writes a number of bytes at a specified offset",
1255 .help
= writev_help
,
1258 static int writev_f(BlockBackend
*blk
, int argc
, char **argv
)
1260 struct timespec t1
, t2
;
1261 bool Cflag
= false, qflag
= false;
1266 /* Some compilers get confused and warn if this is not initialized. */
1272 while ((c
= getopt(argc
, argv
, "CfqP:")) != -1) {
1278 flags
|= BDRV_REQ_FUA
;
1284 pattern
= parse_pattern(optarg
);
1290 qemuio_command_usage(&writev_cmd
);
1295 if (optind
> argc
- 2) {
1296 qemuio_command_usage(&writev_cmd
);
1300 offset
= cvtnum(argv
[optind
]);
1302 print_cvtnum_err(offset
, argv
[optind
]);
1307 nr_iov
= argc
- optind
;
1308 buf
= create_iovec(blk
, &qiov
, &argv
[optind
], nr_iov
, pattern
);
1313 clock_gettime(CLOCK_MONOTONIC
, &t1
);
1314 ret
= do_aio_writev(blk
, &qiov
, offset
, flags
, &total
);
1315 clock_gettime(CLOCK_MONOTONIC
, &t2
);
1318 printf("writev failed: %s\n", strerror(-ret
));
1329 /* Finally, report back -- -C gives a parsable format */
1331 print_report("wrote", &t2
, offset
, qiov
.size
, total
, cnt
, Cflag
);
1333 qemu_iovec_destroy(&qiov
);
1348 BlockAcctCookie acct
;
1353 static void aio_write_done(void *opaque
, int ret
)
1355 struct aio_ctx
*ctx
= opaque
;
1358 clock_gettime(CLOCK_MONOTONIC
, &t2
);
1362 printf("aio_write failed: %s\n", strerror(-ret
));
1363 block_acct_failed(blk_get_stats(ctx
->blk
), &ctx
->acct
);
1367 block_acct_done(blk_get_stats(ctx
->blk
), &ctx
->acct
);
1373 /* Finally, report back -- -C gives a parsable format */
1374 t2
= tsub(t2
, ctx
->t1
);
1375 print_report("wrote", &t2
, ctx
->offset
, ctx
->qiov
.size
,
1376 ctx
->qiov
.size
, 1, ctx
->Cflag
);
1379 qemu_io_free(ctx
->buf
);
1380 qemu_iovec_destroy(&ctx
->qiov
);
1385 static void aio_read_done(void *opaque
, int ret
)
1387 struct aio_ctx
*ctx
= opaque
;
1390 clock_gettime(CLOCK_MONOTONIC
, &t2
);
1393 printf("readv failed: %s\n", strerror(-ret
));
1394 block_acct_failed(blk_get_stats(ctx
->blk
), &ctx
->acct
);
1399 void *cmp_buf
= g_malloc(ctx
->qiov
.size
);
1401 memset(cmp_buf
, ctx
->pattern
, ctx
->qiov
.size
);
1402 if (memcmp(ctx
->buf
, cmp_buf
, ctx
->qiov
.size
)) {
1403 printf("Pattern verification failed at offset %"
1404 PRId64
", %zu bytes\n", ctx
->offset
, ctx
->qiov
.size
);
1409 block_acct_done(blk_get_stats(ctx
->blk
), &ctx
->acct
);
1416 dump_buffer(ctx
->buf
, ctx
->offset
, ctx
->qiov
.size
);
1419 /* Finally, report back -- -C gives a parsable format */
1420 t2
= tsub(t2
, ctx
->t1
);
1421 print_report("read", &t2
, ctx
->offset
, ctx
->qiov
.size
,
1422 ctx
->qiov
.size
, 1, ctx
->Cflag
);
1424 qemu_io_free(ctx
->buf
);
1425 qemu_iovec_destroy(&ctx
->qiov
);
1429 static void aio_read_help(void)
1433 " asynchronously reads a range of bytes from the given offset\n"
1436 " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
1438 " Reads a segment of the currently open file, optionally dumping it to the\n"
1439 " standard output stream (with -v option) for subsequent inspection.\n"
1440 " The read is performed asynchronously and the aio_flush command must be\n"
1441 " used to ensure all outstanding aio requests have been completed.\n"
1442 " Note that due to its asynchronous nature, this command will be\n"
1443 " considered successful once the request is submitted, independently\n"
1444 " of potential I/O errors or pattern mismatches.\n"
1445 " -C, -- report statistics in a machine parsable format\n"
1446 " -P, -- use a pattern to verify read data\n"
1447 " -i, -- treat request as invalid, for exercising stats\n"
1448 " -v, -- dump buffer to standard output\n"
1449 " -q, -- quiet mode, do not show I/O statistics\n"
1453 static int aio_read_f(BlockBackend
*blk
, int argc
, char **argv
);
1455 static const cmdinfo_t aio_read_cmd
= {
1457 .cfunc
= aio_read_f
,
1460 .args
= "[-Ciqv] [-P pattern] off len [len..]",
1461 .oneline
= "asynchronously reads a number of bytes",
1462 .help
= aio_read_help
,
1465 static int aio_read_f(BlockBackend
*blk
, int argc
, char **argv
)
1468 struct aio_ctx
*ctx
= g_new0(struct aio_ctx
, 1);
1471 while ((c
= getopt(argc
, argv
, "CP:iqv")) != -1) {
1478 ctx
->pattern
= parse_pattern(optarg
);
1479 if (ctx
->pattern
< 0) {
1485 printf("injecting invalid read request\n");
1486 block_acct_invalid(blk_get_stats(blk
), BLOCK_ACCT_READ
);
1497 qemuio_command_usage(&aio_read_cmd
);
1502 if (optind
> argc
- 2) {
1504 qemuio_command_usage(&aio_read_cmd
);
1508 ctx
->offset
= cvtnum(argv
[optind
]);
1509 if (ctx
->offset
< 0) {
1510 int ret
= ctx
->offset
;
1511 print_cvtnum_err(ret
, argv
[optind
]);
1517 nr_iov
= argc
- optind
;
1518 ctx
->buf
= create_iovec(blk
, &ctx
->qiov
, &argv
[optind
], nr_iov
, 0xab);
1519 if (ctx
->buf
== NULL
) {
1520 block_acct_invalid(blk_get_stats(blk
), BLOCK_ACCT_READ
);
1525 clock_gettime(CLOCK_MONOTONIC
, &ctx
->t1
);
1526 block_acct_start(blk_get_stats(blk
), &ctx
->acct
, ctx
->qiov
.size
,
1528 blk_aio_preadv(blk
, ctx
->offset
, &ctx
->qiov
, 0, aio_read_done
, ctx
);
1532 static void aio_write_help(void)
1536 " asynchronously writes a range of bytes from the given offset source\n"
1537 " from multiple buffers\n"
1540 " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1542 " Writes into a segment of the currently open file, using a buffer\n"
1543 " filled with a set pattern (0xcdcdcdcd).\n"
1544 " The write is performed asynchronously and the aio_flush command must be\n"
1545 " used to ensure all outstanding aio requests have been completed.\n"
1546 " Note that due to its asynchronous nature, this command will be\n"
1547 " considered successful once the request is submitted, independently\n"
1548 " of potential I/O errors or pattern mismatches.\n"
1549 " -P, -- use different pattern to fill file\n"
1550 " -C, -- report statistics in a machine parsable format\n"
1551 " -f, -- use Force Unit Access semantics\n"
1552 " -i, -- treat request as invalid, for exercising stats\n"
1553 " -q, -- quiet mode, do not show I/O statistics\n"
1554 " -u, -- with -z, allow unmapping\n"
1555 " -z, -- write zeroes using blk_aio_pwrite_zeroes\n"
1559 static int aio_write_f(BlockBackend
*blk
, int argc
, char **argv
);
1561 static const cmdinfo_t aio_write_cmd
= {
1562 .name
= "aio_write",
1563 .cfunc
= aio_write_f
,
1564 .perm
= BLK_PERM_WRITE
,
1567 .args
= "[-Cfiquz] [-P pattern] off len [len..]",
1568 .oneline
= "asynchronously writes a number of bytes",
1569 .help
= aio_write_help
,
1572 static int aio_write_f(BlockBackend
*blk
, int argc
, char **argv
)
1576 struct aio_ctx
*ctx
= g_new0(struct aio_ctx
, 1);
1580 while ((c
= getopt(argc
, argv
, "CfiqP:uz")) != -1) {
1586 flags
|= BDRV_REQ_FUA
;
1592 flags
|= BDRV_REQ_MAY_UNMAP
;
1595 pattern
= parse_pattern(optarg
);
1602 printf("injecting invalid write request\n");
1603 block_acct_invalid(blk_get_stats(blk
), BLOCK_ACCT_WRITE
);
1611 qemuio_command_usage(&aio_write_cmd
);
1616 if (optind
> argc
- 2) {
1618 qemuio_command_usage(&aio_write_cmd
);
1622 if (ctx
->zflag
&& optind
!= argc
- 2) {
1623 printf("-z supports only a single length parameter\n");
1628 if ((flags
& BDRV_REQ_MAY_UNMAP
) && !ctx
->zflag
) {
1629 printf("-u requires -z to be specified\n");
1634 if (ctx
->zflag
&& ctx
->Pflag
) {
1635 printf("-z and -P cannot be specified at the same time\n");
1640 ctx
->offset
= cvtnum(argv
[optind
]);
1641 if (ctx
->offset
< 0) {
1642 int ret
= ctx
->offset
;
1643 print_cvtnum_err(ret
, argv
[optind
]);
1650 int64_t count
= cvtnum(argv
[optind
]);
1652 print_cvtnum_err(count
, argv
[optind
]);
1657 ctx
->qiov
.size
= count
;
1658 blk_aio_pwrite_zeroes(blk
, ctx
->offset
, count
, flags
, aio_write_done
,
1661 nr_iov
= argc
- optind
;
1662 ctx
->buf
= create_iovec(blk
, &ctx
->qiov
, &argv
[optind
], nr_iov
,
1664 if (ctx
->buf
== NULL
) {
1665 block_acct_invalid(blk_get_stats(blk
), BLOCK_ACCT_WRITE
);
1670 clock_gettime(CLOCK_MONOTONIC
, &ctx
->t1
);
1671 block_acct_start(blk_get_stats(blk
), &ctx
->acct
, ctx
->qiov
.size
,
1674 blk_aio_pwritev(blk
, ctx
->offset
, &ctx
->qiov
, flags
, aio_write_done
,
1681 static int aio_flush_f(BlockBackend
*blk
, int argc
, char **argv
)
1683 BlockAcctCookie cookie
;
1684 block_acct_start(blk_get_stats(blk
), &cookie
, 0, BLOCK_ACCT_FLUSH
);
1686 block_acct_done(blk_get_stats(blk
), &cookie
);
1690 static const cmdinfo_t aio_flush_cmd
= {
1691 .name
= "aio_flush",
1692 .cfunc
= aio_flush_f
,
1693 .oneline
= "completes all outstanding aio requests"
1696 static int flush_f(BlockBackend
*blk
, int argc
, char **argv
)
1698 return blk_flush(blk
);
1701 static const cmdinfo_t flush_cmd
= {
1705 .oneline
= "flush all in-core file state to disk",
1708 static int truncate_f(BlockBackend
*blk
, int argc
, char **argv
);
1709 static const cmdinfo_t truncate_cmd
= {
1712 .cfunc
= truncate_f
,
1713 .perm
= BLK_PERM_WRITE
| BLK_PERM_RESIZE
,
1716 .args
= "[-m prealloc_mode] off",
1717 .oneline
= "truncates the current file at the given offset",
1720 static int truncate_f(BlockBackend
*blk
, int argc
, char **argv
)
1722 Error
*local_err
= NULL
;
1725 PreallocMode prealloc
= PREALLOC_MODE_OFF
;
1727 while ((c
= getopt(argc
, argv
, "m:")) != -1) {
1730 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optarg
,
1731 PREALLOC_MODE__MAX
, NULL
);
1732 if (prealloc
== PREALLOC_MODE__MAX
) {
1733 error_report("Invalid preallocation mode '%s'", optarg
);
1738 qemuio_command_usage(&truncate_cmd
);
1743 offset
= cvtnum(argv
[optind
]);
1745 print_cvtnum_err(offset
, argv
[1]);
1750 * qemu-io is a debugging tool, so let us be strict here and pass
1751 * exact=true. It is better to err on the "emit more errors" side
1752 * than to be overly permissive.
1754 ret
= blk_truncate(blk
, offset
, false, prealloc
, 0, &local_err
);
1756 error_report_err(local_err
);
1763 static int length_f(BlockBackend
*blk
, int argc
, char **argv
)
1768 size
= blk_getlength(blk
);
1770 printf("getlength: %s\n", strerror(-size
));
1774 cvtstr(size
, s1
, sizeof(s1
));
1780 static const cmdinfo_t length_cmd
= {
1784 .oneline
= "gets the length of the current file",
1788 static int info_f(BlockBackend
*blk
, int argc
, char **argv
)
1790 BlockDriverState
*bs
= blk_bs(blk
);
1791 BlockDriverInfo bdi
;
1792 ImageInfoSpecific
*spec_info
;
1793 Error
*local_err
= NULL
;
1794 char s1
[64], s2
[64];
1797 if (bs
->drv
&& bs
->drv
->format_name
) {
1798 printf("format name: %s\n", bs
->drv
->format_name
);
1800 if (bs
->drv
&& bs
->drv
->protocol_name
) {
1801 printf("format name: %s\n", bs
->drv
->protocol_name
);
1804 ret
= bdrv_get_info(bs
, &bdi
);
1809 cvtstr(bdi
.cluster_size
, s1
, sizeof(s1
));
1810 cvtstr(bdi
.vm_state_offset
, s2
, sizeof(s2
));
1812 printf("cluster size: %s\n", s1
);
1813 printf("vm state offset: %s\n", s2
);
1815 spec_info
= bdrv_get_specific_info(bs
, &local_err
);
1817 error_report_err(local_err
);
1821 printf("Format specific information:\n");
1822 bdrv_image_info_specific_dump(spec_info
);
1823 qapi_free_ImageInfoSpecific(spec_info
);
1831 static const cmdinfo_t info_cmd
= {
1835 .oneline
= "prints information about the current file",
1838 static void discard_help(void)
1842 " discards a range of bytes from the given offset\n"
1845 " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
1847 " Discards a segment of the currently open file.\n"
1848 " -C, -- report statistics in a machine parsable format\n"
1849 " -q, -- quiet mode, do not show I/O statistics\n"
1853 static int discard_f(BlockBackend
*blk
, int argc
, char **argv
);
1855 static const cmdinfo_t discard_cmd
= {
1859 .perm
= BLK_PERM_WRITE
,
1862 .args
= "[-Cq] off len",
1863 .oneline
= "discards a number of bytes at a specified offset",
1864 .help
= discard_help
,
1867 static int discard_f(BlockBackend
*blk
, int argc
, char **argv
)
1869 struct timespec t1
, t2
;
1870 bool Cflag
= false, qflag
= false;
1872 int64_t offset
, bytes
;
1874 while ((c
= getopt(argc
, argv
, "Cq")) != -1) {
1883 qemuio_command_usage(&discard_cmd
);
1888 if (optind
!= argc
- 2) {
1889 qemuio_command_usage(&discard_cmd
);
1893 offset
= cvtnum(argv
[optind
]);
1895 print_cvtnum_err(offset
, argv
[optind
]);
1900 bytes
= cvtnum(argv
[optind
]);
1902 print_cvtnum_err(bytes
, argv
[optind
]);
1904 } else if (bytes
> BDRV_REQUEST_MAX_BYTES
) {
1905 printf("length cannot exceed %"PRIu64
", given %s\n",
1906 (uint64_t)BDRV_REQUEST_MAX_BYTES
, argv
[optind
]);
1910 clock_gettime(CLOCK_MONOTONIC
, &t1
);
1911 ret
= blk_pdiscard(blk
, offset
, bytes
);
1912 clock_gettime(CLOCK_MONOTONIC
, &t2
);
1915 printf("discard failed: %s\n", strerror(-ret
));
1919 /* Finally, report back -- -C gives a parsable format */
1922 print_report("discard", &t2
, offset
, bytes
, bytes
, 1, Cflag
);
1928 static int alloc_f(BlockBackend
*blk
, int argc
, char **argv
)
1930 BlockDriverState
*bs
= blk_bs(blk
);
1931 int64_t offset
, start
, remaining
, count
;
1934 int64_t num
, sum_alloc
;
1936 start
= offset
= cvtnum(argv
[1]);
1938 print_cvtnum_err(offset
, argv
[1]);
1943 count
= cvtnum(argv
[2]);
1945 print_cvtnum_err(count
, argv
[2]);
1949 count
= BDRV_SECTOR_SIZE
;
1955 ret
= bdrv_is_allocated(bs
, offset
, remaining
, &num
);
1957 printf("is_allocated failed: %s\n", strerror(-ret
));
1971 cvtstr(start
, s1
, sizeof(s1
));
1973 printf("%"PRId64
"/%"PRId64
" bytes allocated at offset %s\n",
1974 sum_alloc
, count
, s1
);
1978 static const cmdinfo_t alloc_cmd
= {
1984 .args
= "offset [count]",
1985 .oneline
= "checks if offset is allocated in the file",
1989 static int map_is_allocated(BlockDriverState
*bs
, int64_t offset
,
1990 int64_t bytes
, int64_t *pnum
)
1995 ret
= bdrv_is_allocated(bs
, offset
, bytes
, &num
);
2003 while (bytes
> 0 && ret
== firstret
) {
2007 ret
= bdrv_is_allocated(bs
, offset
, bytes
, &num
);
2008 if (ret
== firstret
&& num
) {
2018 static int map_f(BlockBackend
*blk
, int argc
, char **argv
)
2020 int64_t offset
, bytes
;
2021 char s1
[64], s2
[64];
2027 bytes
= blk_getlength(blk
);
2029 error_report("Failed to query image length: %s", strerror(-bytes
));
2034 ret
= map_is_allocated(blk_bs(blk
), offset
, bytes
, &num
);
2036 error_report("Failed to get allocation status: %s", strerror(-ret
));
2039 error_report("Unexpected end of image");
2043 retstr
= ret
? " allocated" : "not allocated";
2044 cvtstr(num
, s1
, sizeof(s1
));
2045 cvtstr(offset
, s2
, sizeof(s2
));
2046 printf("%s (0x%" PRIx64
") bytes %s at offset %s (0x%" PRIx64
")\n",
2047 s1
, num
, retstr
, s2
, offset
);
2056 static const cmdinfo_t map_cmd
= {
2062 .oneline
= "prints the allocated areas of a file",
2065 static void reopen_help(void)
2069 " Changes the open options of an already opened image\n"
2072 " 'reopen -o lazy-refcounts=on' - activates lazy refcount writeback on a qcow2 image\n"
2074 " -r, -- Reopen the image read-only\n"
2075 " -w, -- Reopen the image read-write\n"
2076 " -c, -- Change the cache mode to the given value\n"
2077 " -o, -- Changes block driver options (cf. 'open' command)\n"
2081 static int reopen_f(BlockBackend
*blk
, int argc
, char **argv
);
2083 static QemuOptsList reopen_opts
= {
2085 .merge_lists
= true,
2086 .head
= QTAILQ_HEAD_INITIALIZER(reopen_opts
.head
),
2088 /* no elements => accept any params */
2089 { /* end of list */ }
2093 static const cmdinfo_t reopen_cmd
= {
2098 .args
= "[(-r|-w)] [-c cache] [-o options]",
2099 .oneline
= "reopens an image with new options",
2100 .help
= reopen_help
,
2103 static int reopen_f(BlockBackend
*blk
, int argc
, char **argv
)
2105 BlockDriverState
*bs
= blk_bs(blk
);
2109 int flags
= bs
->open_flags
;
2110 bool writethrough
= !blk_enable_write_cache(blk
);
2111 bool has_rw_option
= false;
2112 bool has_cache_option
= false;
2113 Error
*local_err
= NULL
;
2115 while ((c
= getopt(argc
, argv
, "c:o:rw")) != -1) {
2118 if (bdrv_parse_cache_mode(optarg
, &flags
, &writethrough
) < 0) {
2119 error_report("Invalid cache option: %s", optarg
);
2122 has_cache_option
= true;
2125 if (!qemu_opts_parse_noisily(&reopen_opts
, optarg
, 0)) {
2126 qemu_opts_reset(&reopen_opts
);
2131 if (has_rw_option
) {
2132 error_report("Only one -r/-w option may be given");
2135 flags
&= ~BDRV_O_RDWR
;
2136 has_rw_option
= true;
2139 if (has_rw_option
) {
2140 error_report("Only one -r/-w option may be given");
2143 flags
|= BDRV_O_RDWR
;
2144 has_rw_option
= true;
2147 qemu_opts_reset(&reopen_opts
);
2148 qemuio_command_usage(&reopen_cmd
);
2153 if (optind
!= argc
) {
2154 qemu_opts_reset(&reopen_opts
);
2155 qemuio_command_usage(&reopen_cmd
);
2159 if (!writethrough
!= blk_enable_write_cache(blk
) &&
2160 blk_get_attached_dev(blk
))
2162 error_report("Cannot change cache.writeback: Device attached");
2163 qemu_opts_reset(&reopen_opts
);
2167 if (!(flags
& BDRV_O_RDWR
)) {
2168 uint64_t orig_perm
, orig_shared_perm
;
2172 blk_get_perm(blk
, &orig_perm
, &orig_shared_perm
);
2174 orig_perm
& ~(BLK_PERM_WRITE
| BLK_PERM_WRITE_UNCHANGED
),
2179 qopts
= qemu_opts_find(&reopen_opts
, NULL
);
2180 opts
= qopts
? qemu_opts_to_qdict(qopts
, NULL
) : qdict_new();
2181 qemu_opts_reset(&reopen_opts
);
2183 if (qdict_haskey(opts
, BDRV_OPT_READ_ONLY
)) {
2184 if (has_rw_option
) {
2185 error_report("Cannot set both -r/-w and '" BDRV_OPT_READ_ONLY
"'");
2186 qobject_unref(opts
);
2190 qdict_put_bool(opts
, BDRV_OPT_READ_ONLY
, !(flags
& BDRV_O_RDWR
));
2193 if (qdict_haskey(opts
, BDRV_OPT_CACHE_DIRECT
) ||
2194 qdict_haskey(opts
, BDRV_OPT_CACHE_NO_FLUSH
)) {
2195 if (has_cache_option
) {
2196 error_report("Cannot set both -c and the cache options");
2197 qobject_unref(opts
);
2201 qdict_put_bool(opts
, BDRV_OPT_CACHE_DIRECT
, flags
& BDRV_O_NOCACHE
);
2202 qdict_put_bool(opts
, BDRV_OPT_CACHE_NO_FLUSH
, flags
& BDRV_O_NO_FLUSH
);
2205 bdrv_reopen(bs
, opts
, true, &local_err
);
2208 error_report_err(local_err
);
2212 blk_set_enable_write_cache(blk
, !writethrough
);
2216 static int break_f(BlockBackend
*blk
, int argc
, char **argv
)
2220 ret
= bdrv_debug_breakpoint(blk_bs(blk
), argv
[1], argv
[2]);
2222 printf("Could not set breakpoint: %s\n", strerror(-ret
));
2229 static int remove_break_f(BlockBackend
*blk
, int argc
, char **argv
)
2233 ret
= bdrv_debug_remove_breakpoint(blk_bs(blk
), argv
[1]);
2235 printf("Could not remove breakpoint %s: %s\n", argv
[1], strerror(-ret
));
2242 static const cmdinfo_t break_cmd
= {
2247 .args
= "event tag",
2248 .oneline
= "sets a breakpoint on event and tags the stopped "
2252 static const cmdinfo_t remove_break_cmd
= {
2253 .name
= "remove_break",
2256 .cfunc
= remove_break_f
,
2258 .oneline
= "remove a breakpoint by tag",
2261 static int resume_f(BlockBackend
*blk
, int argc
, char **argv
)
2265 ret
= bdrv_debug_resume(blk_bs(blk
), argv
[1]);
2267 printf("Could not resume request: %s\n", strerror(-ret
));
2274 static const cmdinfo_t resume_cmd
= {
2280 .oneline
= "resumes the request tagged as tag",
2283 static int wait_break_f(BlockBackend
*blk
, int argc
, char **argv
)
2285 while (!bdrv_debug_is_suspended(blk_bs(blk
), argv
[1])) {
2286 aio_poll(blk_get_aio_context(blk
), true);
2291 static const cmdinfo_t wait_break_cmd
= {
2292 .name
= "wait_break",
2295 .cfunc
= wait_break_f
,
2297 .oneline
= "waits for the suspension of a request",
2300 static int abort_f(BlockBackend
*blk
, int argc
, char **argv
)
2305 static const cmdinfo_t abort_cmd
= {
2308 .flags
= CMD_NOFILE_OK
,
2309 .oneline
= "simulate a program crash using abort(3)",
2312 static void sigraise_help(void)
2316 " raises the given signal\n"
2319 " 'sigraise %i' - raises SIGTERM\n"
2321 " Invokes raise(signal), where \"signal\" is the mandatory integer argument\n"
2322 " given to sigraise.\n"
2326 static int sigraise_f(BlockBackend
*blk
, int argc
, char **argv
);
2328 static const cmdinfo_t sigraise_cmd
= {
2330 .cfunc
= sigraise_f
,
2333 .flags
= CMD_NOFILE_OK
,
2335 .oneline
= "raises a signal",
2336 .help
= sigraise_help
,
2339 static int sigraise_f(BlockBackend
*blk
, int argc
, char **argv
)
2341 int64_t sig
= cvtnum(argv
[1]);
2343 print_cvtnum_err(sig
, argv
[1]);
2345 } else if (sig
> NSIG
) {
2346 printf("signal argument '%s' is too large to be a valid signal\n",
2351 /* Using raise() to kill this process does not necessarily flush all open
2352 * streams. At least stdout and stderr (although the latter should be
2353 * non-buffered anyway) should be flushed, though. */
2362 static void sleep_cb(void *opaque
)
2364 bool *expired
= opaque
;
2368 static int sleep_f(BlockBackend
*blk
, int argc
, char **argv
)
2372 struct QEMUTimer
*timer
;
2373 bool expired
= false;
2375 ms
= strtol(argv
[1], &endptr
, 0);
2376 if (ms
< 0 || *endptr
!= '\0') {
2377 printf("%s is not a valid number\n", argv
[1]);
2381 timer
= timer_new_ns(QEMU_CLOCK_HOST
, sleep_cb
, &expired
);
2382 timer_mod(timer
, qemu_clock_get_ns(QEMU_CLOCK_HOST
) + SCALE_MS
* ms
);
2385 main_loop_wait(false);
2392 static const cmdinfo_t sleep_cmd
= {
2397 .flags
= CMD_NOFILE_OK
,
2398 .oneline
= "waits for the given value in milliseconds",
2401 static void help_oneline(const char *cmd
, const cmdinfo_t
*ct
)
2406 printf("%s ", ct
->args
);
2408 printf("-- %s\n", ct
->oneline
);
2411 static void help_onecmd(const char *cmd
, const cmdinfo_t
*ct
)
2413 help_oneline(cmd
, ct
);
2419 static void help_all(void)
2421 const cmdinfo_t
*ct
;
2423 for (ct
= cmdtab
; ct
< &cmdtab
[ncmds
]; ct
++) {
2424 help_oneline(ct
->name
, ct
);
2426 printf("\nUse 'help commandname' for extended help.\n");
2429 static int help_f(BlockBackend
*blk
, int argc
, char **argv
)
2431 const cmdinfo_t
*ct
;
2438 ct
= find_command(argv
[1]);
2440 printf("command %s not found\n", argv
[1]);
2444 help_onecmd(argv
[1], ct
);
2448 static const cmdinfo_t help_cmd
= {
2454 .flags
= CMD_FLAG_GLOBAL
,
2455 .args
= "[command]",
2456 .oneline
= "help for one or all commands",
2460 * Called with aio context of blk acquired. Or with qemu_get_aio_context()
2461 * context acquired if blk is NULL.
2463 int qemuio_command(BlockBackend
*blk
, const char *cmd
)
2466 const cmdinfo_t
*ct
;
2471 input
= g_strdup(cmd
);
2472 v
= breakline(input
, &c
);
2474 ct
= find_command(v
[0]);
2476 ret
= command(blk
, ct
, c
, v
);
2478 fprintf(stderr
, "command \"%s\" not found\n", v
[0]);
2488 static void __attribute((constructor
)) init_qemuio_commands(void)
2490 /* initialize commands */
2491 qemuio_add_command(&help_cmd
);
2492 qemuio_add_command(&read_cmd
);
2493 qemuio_add_command(&readv_cmd
);
2494 qemuio_add_command(&write_cmd
);
2495 qemuio_add_command(&writev_cmd
);
2496 qemuio_add_command(&aio_read_cmd
);
2497 qemuio_add_command(&aio_write_cmd
);
2498 qemuio_add_command(&aio_flush_cmd
);
2499 qemuio_add_command(&flush_cmd
);
2500 qemuio_add_command(&truncate_cmd
);
2501 qemuio_add_command(&length_cmd
);
2502 qemuio_add_command(&info_cmd
);
2503 qemuio_add_command(&discard_cmd
);
2504 qemuio_add_command(&alloc_cmd
);
2505 qemuio_add_command(&map_cmd
);
2506 qemuio_add_command(&reopen_cmd
);
2507 qemuio_add_command(&break_cmd
);
2508 qemuio_add_command(&remove_break_cmd
);
2509 qemuio_add_command(&resume_cmd
);
2510 qemuio_add_command(&wait_break_cmd
);
2511 qemuio_add_command(&abort_cmd
);
2512 qemuio_add_command(&sleep_cmd
);
2513 qemuio_add_command(&sigraise_cmd
);