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