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