blob: ffa62fb46fb9ee50d0f02a61107ab6c111474f85 [file] [log] [blame]
aliguorie3aff4f2009-04-05 19:14:04 +00001/*
2 * Command line utility to exercise the QEMU I/O path.
3 *
4 * Copyright (C) 2009 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 */
Stefan Weilc32d7662009-08-31 22:16:16 +020010#include <sys/time.h>
aliguorie3aff4f2009-04-05 19:14:04 +000011#include <sys/types.h>
12#include <stdarg.h>
13#include <stdio.h>
14#include <getopt.h>
Stefan Weilc32d7662009-08-31 22:16:16 +020015#include <libgen.h>
aliguorie3aff4f2009-04-05 19:14:04 +000016
17#include "qemu-common.h"
18#include "block_int.h"
19#include "cmd.h"
20
21#define VERSION "0.0.1"
22
Devin Nakamura43642b32011-07-11 11:22:16 -040023#define CMD_NOFILE_OK 0x01
aliguorie3aff4f2009-04-05 19:14:04 +000024
25char *progname;
26static BlockDriverState *bs;
27
28static int misalign;
29
30/*
Christoph Hellwigcf070d72009-07-20 01:19:25 +020031 * Parse the pattern argument to various sub-commands.
32 *
33 * Because the pattern is used as an argument to memset it must evaluate
34 * to an unsigned integer that fits into a single byte.
35 */
36static int parse_pattern(const char *arg)
37{
Devin Nakamura43642b32011-07-11 11:22:16 -040038 char *endptr = NULL;
39 long pattern;
Christoph Hellwigcf070d72009-07-20 01:19:25 +020040
Devin Nakamura43642b32011-07-11 11:22:16 -040041 pattern = strtol(arg, &endptr, 0);
42 if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {
43 printf("%s is not a valid pattern byte\n", arg);
44 return -1;
45 }
Christoph Hellwigcf070d72009-07-20 01:19:25 +020046
Devin Nakamura43642b32011-07-11 11:22:16 -040047 return pattern;
Christoph Hellwigcf070d72009-07-20 01:19:25 +020048}
49
50/*
aliguorie3aff4f2009-04-05 19:14:04 +000051 * Memory allocation helpers.
52 *
53 * Make sure memory is aligned by default, or purposefully misaligned if
54 * that is specified on the command line.
55 */
56
Devin Nakamura43642b32011-07-11 11:22:16 -040057#define MISALIGN_OFFSET 16
aliguorie3aff4f2009-04-05 19:14:04 +000058static void *qemu_io_alloc(size_t len, int pattern)
59{
Devin Nakamura43642b32011-07-11 11:22:16 -040060 void *buf;
aliguorie3aff4f2009-04-05 19:14:04 +000061
Devin Nakamura43642b32011-07-11 11:22:16 -040062 if (misalign) {
63 len += MISALIGN_OFFSET;
64 }
65 buf = qemu_blockalign(bs, len);
66 memset(buf, pattern, len);
67 if (misalign) {
68 buf += MISALIGN_OFFSET;
69 }
70 return buf;
aliguorie3aff4f2009-04-05 19:14:04 +000071}
72
73static void qemu_io_free(void *p)
74{
Devin Nakamura43642b32011-07-11 11:22:16 -040075 if (misalign) {
76 p -= MISALIGN_OFFSET;
77 }
78 qemu_vfree(p);
aliguorie3aff4f2009-04-05 19:14:04 +000079}
80
Devin Nakamura43642b32011-07-11 11:22:16 -040081static void dump_buffer(const void *buffer, int64_t offset, int len)
aliguorie3aff4f2009-04-05 19:14:04 +000082{
Devin Nakamura43642b32011-07-11 11:22:16 -040083 int i, j;
84 const uint8_t *p;
aliguorie3aff4f2009-04-05 19:14:04 +000085
Devin Nakamura43642b32011-07-11 11:22:16 -040086 for (i = 0, p = buffer; i < len; i += 16) {
87 const uint8_t *s = p;
aliguorie3aff4f2009-04-05 19:14:04 +000088
Devin Nakamura43642b32011-07-11 11:22:16 -040089 printf("%08" PRIx64 ": ", offset + i);
90 for (j = 0; j < 16 && i + j < len; j++, p++) {
91 printf("%02x ", *p);
92 }
93 printf(" ");
94 for (j = 0; j < 16 && i + j < len; j++, s++) {
95 if (isalnum(*s)) {
96 printf("%c", *s);
97 } else {
98 printf(".");
99 }
100 }
101 printf("\n");
102 }
aliguorie3aff4f2009-04-05 19:14:04 +0000103}
104
Devin Nakamura43642b32011-07-11 11:22:16 -0400105static void print_report(const char *op, struct timeval *t, int64_t offset,
106 int count, int total, int cnt, int Cflag)
aliguorie3aff4f2009-04-05 19:14:04 +0000107{
Devin Nakamura43642b32011-07-11 11:22:16 -0400108 char s1[64], s2[64], ts[64];
aliguorie3aff4f2009-04-05 19:14:04 +0000109
Devin Nakamura43642b32011-07-11 11:22:16 -0400110 timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
111 if (!Cflag) {
112 cvtstr((double)total, s1, sizeof(s1));
113 cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
114 printf("%s %d/%d bytes at offset %" PRId64 "\n",
115 op, total, count, offset);
116 printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
117 s1, cnt, ts, s2, tdiv((double)cnt, *t));
118 } else {/* bytes,ops,time,bytes/sec,ops/sec */
119 printf("%d,%d,%s,%.3f,%.3f\n",
120 total, cnt, ts,
121 tdiv((double)total, *t),
122 tdiv((double)cnt, *t));
123 }
aliguorie3aff4f2009-04-05 19:14:04 +0000124}
125
Christoph Hellwigcf572982009-07-10 13:33:42 +0200126/*
127 * Parse multiple length statements for vectored I/O, and construct an I/O
128 * vector matching it.
129 */
130static void *
131create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
132{
Devin Nakamura43642b32011-07-11 11:22:16 -0400133 size_t *sizes = calloc(nr_iov, sizeof(size_t));
134 size_t count = 0;
135 void *buf = NULL;
136 void *p;
137 int i;
Christoph Hellwigcf572982009-07-10 13:33:42 +0200138
Devin Nakamura43642b32011-07-11 11:22:16 -0400139 for (i = 0; i < nr_iov; i++) {
140 char *arg = argv[i];
141 int64_t len;
Christoph Hellwigcf572982009-07-10 13:33:42 +0200142
Devin Nakamura43642b32011-07-11 11:22:16 -0400143 len = cvtnum(arg);
144 if (len < 0) {
145 printf("non-numeric length argument -- %s\n", arg);
146 goto fail;
147 }
Christoph Hellwigcf572982009-07-10 13:33:42 +0200148
Devin Nakamura43642b32011-07-11 11:22:16 -0400149 /* should be SIZE_T_MAX, but that doesn't exist */
150 if (len > INT_MAX) {
151 printf("too large length argument -- %s\n", arg);
152 goto fail;
153 }
Christoph Hellwigcf572982009-07-10 13:33:42 +0200154
Devin Nakamura43642b32011-07-11 11:22:16 -0400155 if (len & 0x1ff) {
156 printf("length argument %" PRId64
157 " is not sector aligned\n", len);
158 goto fail;
159 }
Christoph Hellwigcf572982009-07-10 13:33:42 +0200160
Devin Nakamura43642b32011-07-11 11:22:16 -0400161 sizes[i] = len;
162 count += len;
163 }
Christoph Hellwigcf572982009-07-10 13:33:42 +0200164
Devin Nakamura43642b32011-07-11 11:22:16 -0400165 qemu_iovec_init(qiov, nr_iov);
Christoph Hellwigcf572982009-07-10 13:33:42 +0200166
Devin Nakamura43642b32011-07-11 11:22:16 -0400167 buf = p = qemu_io_alloc(count, pattern);
Christoph Hellwigcf572982009-07-10 13:33:42 +0200168
Devin Nakamura43642b32011-07-11 11:22:16 -0400169 for (i = 0; i < nr_iov; i++) {
170 qemu_iovec_add(qiov, p, sizes[i]);
171 p += sizes[i];
172 }
Christoph Hellwigcf572982009-07-10 13:33:42 +0200173
Kevin Wolf40a0d7c2009-11-18 10:42:59 +0100174fail:
Devin Nakamura43642b32011-07-11 11:22:16 -0400175 free(sizes);
176 return buf;
Christoph Hellwigcf572982009-07-10 13:33:42 +0200177}
178
aliguorie3aff4f2009-04-05 19:14:04 +0000179static int do_read(char *buf, int64_t offset, int count, int *total)
180{
Devin Nakamura43642b32011-07-11 11:22:16 -0400181 int ret;
aliguorie3aff4f2009-04-05 19:14:04 +0000182
Devin Nakamura43642b32011-07-11 11:22:16 -0400183 ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
184 if (ret < 0) {
185 return ret;
186 }
187 *total = count;
188 return 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000189}
190
191static int do_write(char *buf, int64_t offset, int count, int *total)
192{
Devin Nakamura43642b32011-07-11 11:22:16 -0400193 int ret;
aliguorie3aff4f2009-04-05 19:14:04 +0000194
Devin Nakamura43642b32011-07-11 11:22:16 -0400195 ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
196 if (ret < 0) {
197 return ret;
198 }
199 *total = count;
200 return 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000201}
202
203static int do_pread(char *buf, int64_t offset, int count, int *total)
204{
Devin Nakamura43642b32011-07-11 11:22:16 -0400205 *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
206 if (*total < 0) {
207 return *total;
208 }
209 return 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000210}
211
212static int do_pwrite(char *buf, int64_t offset, int count, int *total)
213{
Devin Nakamura43642b32011-07-11 11:22:16 -0400214 *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
215 if (*total < 0) {
216 return *total;
217 }
218 return 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000219}
220
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200221static int do_load_vmstate(char *buf, int64_t offset, int count, int *total)
222{
Devin Nakamura43642b32011-07-11 11:22:16 -0400223 *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
224 if (*total < 0) {
225 return *total;
226 }
227 return 1;
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200228}
229
230static int do_save_vmstate(char *buf, int64_t offset, int count, int *total)
231{
Devin Nakamura43642b32011-07-11 11:22:16 -0400232 *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
233 if (*total < 0) {
234 return *total;
235 }
236 return 1;
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200237}
238
aliguorie3aff4f2009-04-05 19:14:04 +0000239#define NOT_DONE 0x7fffffff
240static void aio_rw_done(void *opaque, int ret)
241{
Devin Nakamura43642b32011-07-11 11:22:16 -0400242 *(int *)opaque = ret;
aliguorie3aff4f2009-04-05 19:14:04 +0000243}
244
245static int do_aio_readv(QEMUIOVector *qiov, int64_t offset, int *total)
246{
Devin Nakamura43642b32011-07-11 11:22:16 -0400247 int async_ret = NOT_DONE;
aliguorie3aff4f2009-04-05 19:14:04 +0000248
Paolo Bonziniad54ae82011-11-30 09:12:30 +0100249 bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
250 aio_rw_done, &async_ret);
Devin Nakamura43642b32011-07-11 11:22:16 -0400251 while (async_ret == NOT_DONE) {
252 qemu_aio_wait();
253 }
aliguorie3aff4f2009-04-05 19:14:04 +0000254
Devin Nakamura43642b32011-07-11 11:22:16 -0400255 *total = qiov->size;
256 return async_ret < 0 ? async_ret : 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000257}
258
259static int do_aio_writev(QEMUIOVector *qiov, int64_t offset, int *total)
260{
Devin Nakamura43642b32011-07-11 11:22:16 -0400261 int async_ret = NOT_DONE;
aliguorie3aff4f2009-04-05 19:14:04 +0000262
Paolo Bonziniad54ae82011-11-30 09:12:30 +0100263 bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
264 aio_rw_done, &async_ret);
Devin Nakamura43642b32011-07-11 11:22:16 -0400265 while (async_ret == NOT_DONE) {
266 qemu_aio_wait();
267 }
aliguorie3aff4f2009-04-05 19:14:04 +0000268
Devin Nakamura43642b32011-07-11 11:22:16 -0400269 *total = qiov->size;
270 return async_ret < 0 ? async_ret : 1;
aliguorie3aff4f2009-04-05 19:14:04 +0000271}
272
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200273struct multiwrite_async_ret {
Devin Nakamura43642b32011-07-11 11:22:16 -0400274 int num_done;
275 int error;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200276};
277
278static void multiwrite_cb(void *opaque, int ret)
279{
Devin Nakamura43642b32011-07-11 11:22:16 -0400280 struct multiwrite_async_ret *async_ret = opaque;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200281
Devin Nakamura43642b32011-07-11 11:22:16 -0400282 async_ret->num_done++;
283 if (ret < 0) {
284 async_ret->error = ret;
285 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200286}
287
288static int do_aio_multiwrite(BlockRequest* reqs, int num_reqs, int *total)
289{
Devin Nakamura43642b32011-07-11 11:22:16 -0400290 int i, ret;
291 struct multiwrite_async_ret async_ret = {
292 .num_done = 0,
293 .error = 0,
294 };
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200295
Devin Nakamura43642b32011-07-11 11:22:16 -0400296 *total = 0;
297 for (i = 0; i < num_reqs; i++) {
298 reqs[i].cb = multiwrite_cb;
299 reqs[i].opaque = &async_ret;
300 *total += reqs[i].qiov->size;
301 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200302
Devin Nakamura43642b32011-07-11 11:22:16 -0400303 ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
304 if (ret < 0) {
305 return ret;
306 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200307
Devin Nakamura43642b32011-07-11 11:22:16 -0400308 while (async_ret.num_done < num_reqs) {
309 qemu_aio_wait();
310 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200311
Devin Nakamura43642b32011-07-11 11:22:16 -0400312 return async_ret.error < 0 ? async_ret.error : 1;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200313}
aliguorie3aff4f2009-04-05 19:14:04 +0000314
Devin Nakamura43642b32011-07-11 11:22:16 -0400315static void read_help(void)
aliguorie3aff4f2009-04-05 19:14:04 +0000316{
Devin Nakamura43642b32011-07-11 11:22:16 -0400317 printf(
aliguorie3aff4f2009-04-05 19:14:04 +0000318"\n"
319" reads a range of bytes from the given offset\n"
320"\n"
321" Example:\n"
322" 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
323"\n"
324" Reads a segment of the currently open file, optionally dumping it to the\n"
325" standard output stream (with -v option) for subsequent inspection.\n"
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200326" -b, -- read from the VM state rather than the virtual disk\n"
Kevin Wolfd9654a52009-04-23 15:11:13 +0200327" -C, -- report statistics in a machine parsable format\n"
328" -l, -- length for pattern verification (only with -P)\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000329" -p, -- use bdrv_pread to read the file\n"
aliguoric48101a2009-04-18 15:36:23 +0000330" -P, -- use a pattern to verify read data\n"
Kevin Wolf095343a2010-12-17 11:55:37 +0100331" -q, -- quiet mode, do not show I/O statistics\n"
Kevin Wolfd9654a52009-04-23 15:11:13 +0200332" -s, -- start offset for pattern verification (only with -P)\n"
333" -v, -- dump buffer to standard output\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000334"\n");
335}
336
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000337static int read_f(int argc, char **argv);
338
339static const cmdinfo_t read_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -0400340 .name = "read",
341 .altname = "r",
342 .cfunc = read_f,
343 .argmin = 2,
344 .argmax = -1,
345 .args = "[-abCpqv] [-P pattern [-s off] [-l len]] off len",
346 .oneline = "reads a number of bytes at a specified offset",
347 .help = read_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000348};
349
Devin Nakamura43642b32011-07-11 11:22:16 -0400350static int read_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +0000351{
Devin Nakamura43642b32011-07-11 11:22:16 -0400352 struct timeval t1, t2;
353 int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
354 int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
355 int c, cnt;
356 char *buf;
357 int64_t offset;
358 int count;
359 /* Some compilers get confused and warn if this is not initialized. */
360 int total = 0;
361 int pattern = 0, pattern_offset = 0, pattern_count = 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000362
Devin Nakamura43642b32011-07-11 11:22:16 -0400363 while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
364 switch (c) {
365 case 'b':
366 bflag = 1;
367 break;
368 case 'C':
369 Cflag = 1;
370 break;
371 case 'l':
372 lflag = 1;
373 pattern_count = cvtnum(optarg);
374 if (pattern_count < 0) {
375 printf("non-numeric length argument -- %s\n", optarg);
376 return 0;
377 }
378 break;
379 case 'p':
380 pflag = 1;
381 break;
382 case 'P':
383 Pflag = 1;
384 pattern = parse_pattern(optarg);
385 if (pattern < 0) {
386 return 0;
387 }
388 break;
389 case 'q':
390 qflag = 1;
391 break;
392 case 's':
393 sflag = 1;
394 pattern_offset = cvtnum(optarg);
395 if (pattern_offset < 0) {
396 printf("non-numeric length argument -- %s\n", optarg);
397 return 0;
398 }
399 break;
400 case 'v':
401 vflag = 1;
402 break;
403 default:
404 return command_usage(&read_cmd);
405 }
406 }
aliguorie3aff4f2009-04-05 19:14:04 +0000407
Devin Nakamura43642b32011-07-11 11:22:16 -0400408 if (optind != argc - 2) {
409 return command_usage(&read_cmd);
410 }
aliguorie3aff4f2009-04-05 19:14:04 +0000411
Devin Nakamura43642b32011-07-11 11:22:16 -0400412 if (bflag && pflag) {
413 printf("-b and -p cannot be specified at the same time\n");
414 return 0;
415 }
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200416
Devin Nakamura43642b32011-07-11 11:22:16 -0400417 offset = cvtnum(argv[optind]);
418 if (offset < 0) {
419 printf("non-numeric length argument -- %s\n", argv[optind]);
420 return 0;
421 }
aliguorie3aff4f2009-04-05 19:14:04 +0000422
Devin Nakamura43642b32011-07-11 11:22:16 -0400423 optind++;
424 count = cvtnum(argv[optind]);
425 if (count < 0) {
426 printf("non-numeric length argument -- %s\n", argv[optind]);
427 return 0;
428 }
aliguorie3aff4f2009-04-05 19:14:04 +0000429
Kevin Wolfd9654a52009-04-23 15:11:13 +0200430 if (!Pflag && (lflag || sflag)) {
431 return command_usage(&read_cmd);
432 }
433
434 if (!lflag) {
435 pattern_count = count - pattern_offset;
436 }
437
438 if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) {
Dong Xu Wang07f35072011-11-22 18:06:26 +0800439 printf("pattern verification range exceeds end of read data\n");
Kevin Wolfd9654a52009-04-23 15:11:13 +0200440 return 0;
441 }
442
Devin Nakamura5afc8b32011-07-11 11:20:25 -0400443 if (!pflag) {
Devin Nakamura43642b32011-07-11 11:22:16 -0400444 if (offset & 0x1ff) {
445 printf("offset %" PRId64 " is not sector aligned\n",
446 offset);
447 return 0;
448 }
449 if (count & 0x1ff) {
450 printf("count %d is not sector aligned\n",
451 count);
452 return 0;
453 }
Devin Nakamura5afc8b32011-07-11 11:20:25 -0400454 }
aliguorie3aff4f2009-04-05 19:14:04 +0000455
Devin Nakamura43642b32011-07-11 11:22:16 -0400456 buf = qemu_io_alloc(count, 0xab);
aliguorie3aff4f2009-04-05 19:14:04 +0000457
Devin Nakamura43642b32011-07-11 11:22:16 -0400458 gettimeofday(&t1, NULL);
459 if (pflag) {
460 cnt = do_pread(buf, offset, count, &total);
461 } else if (bflag) {
462 cnt = do_load_vmstate(buf, offset, count, &total);
463 } else {
464 cnt = do_read(buf, offset, count, &total);
465 }
466 gettimeofday(&t2, NULL);
aliguorie3aff4f2009-04-05 19:14:04 +0000467
Devin Nakamura43642b32011-07-11 11:22:16 -0400468 if (cnt < 0) {
469 printf("read failed: %s\n", strerror(-cnt));
470 goto out;
471 }
aliguorie3aff4f2009-04-05 19:14:04 +0000472
Devin Nakamura43642b32011-07-11 11:22:16 -0400473 if (Pflag) {
474 void *cmp_buf = malloc(pattern_count);
475 memset(cmp_buf, pattern, pattern_count);
476 if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
477 printf("Pattern verification failed at offset %"
478 PRId64 ", %d bytes\n",
479 offset + pattern_offset, pattern_count);
480 }
481 free(cmp_buf);
482 }
aliguorie3aff4f2009-04-05 19:14:04 +0000483
Devin Nakamura43642b32011-07-11 11:22:16 -0400484 if (qflag) {
485 goto out;
486 }
aliguoric48101a2009-04-18 15:36:23 +0000487
Devin Nakamura43642b32011-07-11 11:22:16 -0400488 if (vflag) {
489 dump_buffer(buf, offset, count);
490 }
aliguorie3aff4f2009-04-05 19:14:04 +0000491
Devin Nakamura43642b32011-07-11 11:22:16 -0400492 /* Finally, report back -- -C gives a parsable format */
493 t2 = tsub(t2, t1);
494 print_report("read", &t2, offset, count, total, cnt, Cflag);
aliguorie3aff4f2009-04-05 19:14:04 +0000495
Kevin Wolf7d8abfc2009-07-10 13:33:52 +0200496out:
Devin Nakamura43642b32011-07-11 11:22:16 -0400497 qemu_io_free(buf);
aliguorie3aff4f2009-04-05 19:14:04 +0000498
Devin Nakamura43642b32011-07-11 11:22:16 -0400499 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000500}
501
Devin Nakamura43642b32011-07-11 11:22:16 -0400502static void readv_help(void)
aliguorie3aff4f2009-04-05 19:14:04 +0000503{
Devin Nakamura43642b32011-07-11 11:22:16 -0400504 printf(
aliguorie3aff4f2009-04-05 19:14:04 +0000505"\n"
506" reads a range of bytes from the given offset into multiple buffers\n"
507"\n"
508" Example:\n"
509" 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
510"\n"
511" Reads a segment of the currently open file, optionally dumping it to the\n"
512" standard output stream (with -v option) for subsequent inspection.\n"
513" Uses multiple iovec buffers if more than one byte range is specified.\n"
514" -C, -- report statistics in a machine parsable format\n"
aliguoric48101a2009-04-18 15:36:23 +0000515" -P, -- use a pattern to verify read data\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000516" -v, -- dump buffer to standard output\n"
Kevin Wolf095343a2010-12-17 11:55:37 +0100517" -q, -- quiet mode, do not show I/O statistics\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000518"\n");
519}
520
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000521static int readv_f(int argc, char **argv);
522
523static const cmdinfo_t readv_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -0400524 .name = "readv",
525 .cfunc = readv_f,
526 .argmin = 2,
527 .argmax = -1,
528 .args = "[-Cqv] [-P pattern ] off len [len..]",
529 .oneline = "reads a number of bytes at a specified offset",
530 .help = readv_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000531};
532
Devin Nakamura43642b32011-07-11 11:22:16 -0400533static int readv_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +0000534{
Devin Nakamura43642b32011-07-11 11:22:16 -0400535 struct timeval t1, t2;
536 int Cflag = 0, qflag = 0, vflag = 0;
537 int c, cnt;
538 char *buf;
539 int64_t offset;
540 /* Some compilers get confused and warn if this is not initialized. */
541 int total = 0;
542 int nr_iov;
543 QEMUIOVector qiov;
544 int pattern = 0;
545 int Pflag = 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000546
Devin Nakamura43642b32011-07-11 11:22:16 -0400547 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
548 switch (c) {
549 case 'C':
550 Cflag = 1;
551 break;
552 case 'P':
553 Pflag = 1;
554 pattern = parse_pattern(optarg);
555 if (pattern < 0) {
556 return 0;
557 }
558 break;
559 case 'q':
560 qflag = 1;
561 break;
562 case 'v':
563 vflag = 1;
564 break;
565 default:
566 return command_usage(&readv_cmd);
567 }
568 }
aliguorie3aff4f2009-04-05 19:14:04 +0000569
Devin Nakamura43642b32011-07-11 11:22:16 -0400570 if (optind > argc - 2) {
571 return command_usage(&readv_cmd);
572 }
aliguorie3aff4f2009-04-05 19:14:04 +0000573
574
Devin Nakamura43642b32011-07-11 11:22:16 -0400575 offset = cvtnum(argv[optind]);
576 if (offset < 0) {
577 printf("non-numeric length argument -- %s\n", argv[optind]);
578 return 0;
579 }
580 optind++;
aliguorie3aff4f2009-04-05 19:14:04 +0000581
Devin Nakamura43642b32011-07-11 11:22:16 -0400582 if (offset & 0x1ff) {
583 printf("offset %" PRId64 " is not sector aligned\n",
584 offset);
585 return 0;
586 }
aliguorie3aff4f2009-04-05 19:14:04 +0000587
Devin Nakamura43642b32011-07-11 11:22:16 -0400588 nr_iov = argc - optind;
589 buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab);
Kevin Wolff2360622011-10-31 11:36:32 +0100590 if (buf == NULL) {
591 return 0;
592 }
aliguorie3aff4f2009-04-05 19:14:04 +0000593
Devin Nakamura43642b32011-07-11 11:22:16 -0400594 gettimeofday(&t1, NULL);
595 cnt = do_aio_readv(&qiov, offset, &total);
596 gettimeofday(&t2, NULL);
aliguorie3aff4f2009-04-05 19:14:04 +0000597
Devin Nakamura43642b32011-07-11 11:22:16 -0400598 if (cnt < 0) {
599 printf("readv failed: %s\n", strerror(-cnt));
600 goto out;
601 }
aliguorie3aff4f2009-04-05 19:14:04 +0000602
Devin Nakamura43642b32011-07-11 11:22:16 -0400603 if (Pflag) {
604 void *cmp_buf = malloc(qiov.size);
605 memset(cmp_buf, pattern, qiov.size);
606 if (memcmp(buf, cmp_buf, qiov.size)) {
607 printf("Pattern verification failed at offset %"
608 PRId64 ", %zd bytes\n", offset, qiov.size);
609 }
610 free(cmp_buf);
611 }
aliguoric48101a2009-04-18 15:36:23 +0000612
Devin Nakamura43642b32011-07-11 11:22:16 -0400613 if (qflag) {
614 goto out;
615 }
aliguorie3aff4f2009-04-05 19:14:04 +0000616
Devin Nakamura43642b32011-07-11 11:22:16 -0400617 if (vflag) {
618 dump_buffer(buf, offset, qiov.size);
619 }
aliguorie3aff4f2009-04-05 19:14:04 +0000620
Devin Nakamura43642b32011-07-11 11:22:16 -0400621 /* Finally, report back -- -C gives a parsable format */
622 t2 = tsub(t2, t1);
623 print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
aliguorie3aff4f2009-04-05 19:14:04 +0000624
Kevin Wolf7d8abfc2009-07-10 13:33:52 +0200625out:
Devin Nakamura43642b32011-07-11 11:22:16 -0400626 qemu_io_free(buf);
627 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000628}
629
Devin Nakamura43642b32011-07-11 11:22:16 -0400630static void write_help(void)
aliguorie3aff4f2009-04-05 19:14:04 +0000631{
Devin Nakamura43642b32011-07-11 11:22:16 -0400632 printf(
aliguorie3aff4f2009-04-05 19:14:04 +0000633"\n"
634" writes a range of bytes from the given offset\n"
635"\n"
636" Example:\n"
637" 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
638"\n"
639" Writes into a segment of the currently open file, using a buffer\n"
640" filled with a set pattern (0xcdcdcdcd).\n"
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200641" -b, -- write to the VM state rather than the virtual disk\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000642" -p, -- use bdrv_pwrite to write the file\n"
643" -P, -- use different pattern to fill file\n"
644" -C, -- report statistics in a machine parsable format\n"
Kevin Wolf095343a2010-12-17 11:55:37 +0100645" -q, -- quiet mode, do not show I/O statistics\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000646"\n");
647}
648
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000649static int write_f(int argc, char **argv);
650
651static const cmdinfo_t write_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -0400652 .name = "write",
653 .altname = "w",
654 .cfunc = write_f,
655 .argmin = 2,
656 .argmax = -1,
657 .args = "[-abCpq] [-P pattern ] off len",
658 .oneline = "writes a number of bytes at a specified offset",
659 .help = write_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000660};
661
Devin Nakamura43642b32011-07-11 11:22:16 -0400662static int write_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +0000663{
Devin Nakamura43642b32011-07-11 11:22:16 -0400664 struct timeval t1, t2;
665 int Cflag = 0, pflag = 0, qflag = 0, bflag = 0;
666 int c, cnt;
667 char *buf;
668 int64_t offset;
669 int count;
670 /* Some compilers get confused and warn if this is not initialized. */
671 int total = 0;
672 int pattern = 0xcd;
aliguorie3aff4f2009-04-05 19:14:04 +0000673
Devin Nakamura43642b32011-07-11 11:22:16 -0400674 while ((c = getopt(argc, argv, "bCpP:q")) != EOF) {
675 switch (c) {
676 case 'b':
677 bflag = 1;
678 break;
679 case 'C':
680 Cflag = 1;
681 break;
682 case 'p':
683 pflag = 1;
684 break;
685 case 'P':
686 pattern = parse_pattern(optarg);
687 if (pattern < 0) {
688 return 0;
689 }
690 break;
691 case 'q':
692 qflag = 1;
693 break;
694 default:
695 return command_usage(&write_cmd);
696 }
697 }
aliguorie3aff4f2009-04-05 19:14:04 +0000698
Devin Nakamura43642b32011-07-11 11:22:16 -0400699 if (optind != argc - 2) {
700 return command_usage(&write_cmd);
701 }
aliguorie3aff4f2009-04-05 19:14:04 +0000702
Devin Nakamura43642b32011-07-11 11:22:16 -0400703 if (bflag && pflag) {
704 printf("-b and -p cannot be specified at the same time\n");
705 return 0;
706 }
Kevin Wolfca94dbc2009-07-15 12:06:58 +0200707
Devin Nakamura43642b32011-07-11 11:22:16 -0400708 offset = cvtnum(argv[optind]);
709 if (offset < 0) {
710 printf("non-numeric length argument -- %s\n", argv[optind]);
711 return 0;
712 }
aliguorie3aff4f2009-04-05 19:14:04 +0000713
Devin Nakamura43642b32011-07-11 11:22:16 -0400714 optind++;
715 count = cvtnum(argv[optind]);
716 if (count < 0) {
717 printf("non-numeric length argument -- %s\n", argv[optind]);
718 return 0;
719 }
aliguorie3aff4f2009-04-05 19:14:04 +0000720
Devin Nakamura43642b32011-07-11 11:22:16 -0400721 if (!pflag) {
722 if (offset & 0x1ff) {
723 printf("offset %" PRId64 " is not sector aligned\n",
724 offset);
725 return 0;
726 }
aliguorie3aff4f2009-04-05 19:14:04 +0000727
Devin Nakamura43642b32011-07-11 11:22:16 -0400728 if (count & 0x1ff) {
729 printf("count %d is not sector aligned\n",
730 count);
731 return 0;
732 }
733 }
aliguorie3aff4f2009-04-05 19:14:04 +0000734
Devin Nakamura43642b32011-07-11 11:22:16 -0400735 buf = qemu_io_alloc(count, pattern);
aliguorie3aff4f2009-04-05 19:14:04 +0000736
Devin Nakamura43642b32011-07-11 11:22:16 -0400737 gettimeofday(&t1, NULL);
738 if (pflag) {
739 cnt = do_pwrite(buf, offset, count, &total);
740 } else if (bflag) {
741 cnt = do_save_vmstate(buf, offset, count, &total);
742 } else {
743 cnt = do_write(buf, offset, count, &total);
744 }
745 gettimeofday(&t2, NULL);
aliguorie3aff4f2009-04-05 19:14:04 +0000746
Devin Nakamura43642b32011-07-11 11:22:16 -0400747 if (cnt < 0) {
748 printf("write failed: %s\n", strerror(-cnt));
749 goto out;
750 }
aliguorie3aff4f2009-04-05 19:14:04 +0000751
Devin Nakamura43642b32011-07-11 11:22:16 -0400752 if (qflag) {
753 goto out;
754 }
aliguorie3aff4f2009-04-05 19:14:04 +0000755
Devin Nakamura43642b32011-07-11 11:22:16 -0400756 /* Finally, report back -- -C gives a parsable format */
757 t2 = tsub(t2, t1);
758 print_report("wrote", &t2, offset, count, total, cnt, Cflag);
aliguorie3aff4f2009-04-05 19:14:04 +0000759
Kevin Wolf7d8abfc2009-07-10 13:33:52 +0200760out:
Devin Nakamura43642b32011-07-11 11:22:16 -0400761 qemu_io_free(buf);
aliguorie3aff4f2009-04-05 19:14:04 +0000762
Devin Nakamura43642b32011-07-11 11:22:16 -0400763 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000764}
765
aliguorie3aff4f2009-04-05 19:14:04 +0000766static void
767writev_help(void)
768{
Devin Nakamura43642b32011-07-11 11:22:16 -0400769 printf(
aliguorie3aff4f2009-04-05 19:14:04 +0000770"\n"
771" writes a range of bytes from the given offset source from multiple buffers\n"
772"\n"
773" Example:\n"
774" 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
775"\n"
776" Writes into a segment of the currently open file, using a buffer\n"
777" filled with a set pattern (0xcdcdcdcd).\n"
778" -P, -- use different pattern to fill file\n"
779" -C, -- report statistics in a machine parsable format\n"
Kevin Wolf095343a2010-12-17 11:55:37 +0100780" -q, -- quiet mode, do not show I/O statistics\n"
aliguorie3aff4f2009-04-05 19:14:04 +0000781"\n");
782}
783
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000784static int writev_f(int argc, char **argv);
785
786static const cmdinfo_t writev_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -0400787 .name = "writev",
788 .cfunc = writev_f,
789 .argmin = 2,
790 .argmax = -1,
791 .args = "[-Cq] [-P pattern ] off len [len..]",
792 .oneline = "writes a number of bytes at a specified offset",
793 .help = writev_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +0000794};
795
Devin Nakamura43642b32011-07-11 11:22:16 -0400796static int writev_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +0000797{
Devin Nakamura43642b32011-07-11 11:22:16 -0400798 struct timeval t1, t2;
799 int Cflag = 0, qflag = 0;
800 int c, cnt;
801 char *buf;
802 int64_t offset;
803 /* Some compilers get confused and warn if this is not initialized. */
804 int total = 0;
805 int nr_iov;
806 int pattern = 0xcd;
807 QEMUIOVector qiov;
aliguorie3aff4f2009-04-05 19:14:04 +0000808
Devin Nakamura43642b32011-07-11 11:22:16 -0400809 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
810 switch (c) {
811 case 'C':
812 Cflag = 1;
813 break;
814 case 'q':
815 qflag = 1;
816 break;
817 case 'P':
818 pattern = parse_pattern(optarg);
819 if (pattern < 0) {
820 return 0;
821 }
822 break;
823 default:
824 return command_usage(&writev_cmd);
825 }
826 }
aliguorie3aff4f2009-04-05 19:14:04 +0000827
Devin Nakamura43642b32011-07-11 11:22:16 -0400828 if (optind > argc - 2) {
829 return command_usage(&writev_cmd);
830 }
aliguorie3aff4f2009-04-05 19:14:04 +0000831
Devin Nakamura43642b32011-07-11 11:22:16 -0400832 offset = cvtnum(argv[optind]);
833 if (offset < 0) {
834 printf("non-numeric length argument -- %s\n", argv[optind]);
835 return 0;
836 }
837 optind++;
aliguorie3aff4f2009-04-05 19:14:04 +0000838
Devin Nakamura43642b32011-07-11 11:22:16 -0400839 if (offset & 0x1ff) {
840 printf("offset %" PRId64 " is not sector aligned\n",
841 offset);
842 return 0;
843 }
aliguorie3aff4f2009-04-05 19:14:04 +0000844
Devin Nakamura43642b32011-07-11 11:22:16 -0400845 nr_iov = argc - optind;
846 buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern);
Kevin Wolff2360622011-10-31 11:36:32 +0100847 if (buf == NULL) {
848 return 0;
849 }
aliguorie3aff4f2009-04-05 19:14:04 +0000850
Devin Nakamura43642b32011-07-11 11:22:16 -0400851 gettimeofday(&t1, NULL);
852 cnt = do_aio_writev(&qiov, offset, &total);
853 gettimeofday(&t2, NULL);
aliguorie3aff4f2009-04-05 19:14:04 +0000854
Devin Nakamura43642b32011-07-11 11:22:16 -0400855 if (cnt < 0) {
856 printf("writev failed: %s\n", strerror(-cnt));
857 goto out;
858 }
aliguorie3aff4f2009-04-05 19:14:04 +0000859
Devin Nakamura43642b32011-07-11 11:22:16 -0400860 if (qflag) {
861 goto out;
862 }
aliguorie3aff4f2009-04-05 19:14:04 +0000863
Devin Nakamura43642b32011-07-11 11:22:16 -0400864 /* Finally, report back -- -C gives a parsable format */
865 t2 = tsub(t2, t1);
866 print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
Kevin Wolf7d8abfc2009-07-10 13:33:52 +0200867out:
Devin Nakamura43642b32011-07-11 11:22:16 -0400868 qemu_io_free(buf);
869 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +0000870}
871
Devin Nakamura43642b32011-07-11 11:22:16 -0400872static void multiwrite_help(void)
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200873{
Devin Nakamura43642b32011-07-11 11:22:16 -0400874 printf(
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200875"\n"
876" writes a range of bytes from the given offset source from multiple buffers,\n"
877" in a batch of requests that may be merged by qemu\n"
878"\n"
879" Example:\n"
Stefan Weilb2bedb22011-09-12 22:33:01 +0200880" 'multiwrite 512 1k 1k ; 4k 1k'\n"
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200881" writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"
882"\n"
883" Writes into a segment of the currently open file, using a buffer\n"
884" filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"
885" by one for each request contained in the multiwrite command.\n"
886" -P, -- use different pattern to fill file\n"
887" -C, -- report statistics in a machine parsable format\n"
888" -q, -- quiet mode, do not show I/O statistics\n"
889"\n");
890}
891
892static int multiwrite_f(int argc, char **argv);
893
894static const cmdinfo_t multiwrite_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -0400895 .name = "multiwrite",
896 .cfunc = multiwrite_f,
897 .argmin = 2,
898 .argmax = -1,
899 .args = "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",
900 .oneline = "issues multiple write requests at once",
901 .help = multiwrite_help,
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200902};
903
Devin Nakamura43642b32011-07-11 11:22:16 -0400904static int multiwrite_f(int argc, char **argv)
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200905{
Devin Nakamura43642b32011-07-11 11:22:16 -0400906 struct timeval t1, t2;
907 int Cflag = 0, qflag = 0;
908 int c, cnt;
909 char **buf;
910 int64_t offset, first_offset = 0;
911 /* Some compilers get confused and warn if this is not initialized. */
912 int total = 0;
913 int nr_iov;
914 int nr_reqs;
915 int pattern = 0xcd;
916 QEMUIOVector *qiovs;
917 int i;
918 BlockRequest *reqs;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200919
Devin Nakamura43642b32011-07-11 11:22:16 -0400920 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
921 switch (c) {
922 case 'C':
923 Cflag = 1;
924 break;
925 case 'q':
926 qflag = 1;
927 break;
928 case 'P':
929 pattern = parse_pattern(optarg);
930 if (pattern < 0) {
931 return 0;
932 }
933 break;
934 default:
935 return command_usage(&writev_cmd);
936 }
937 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200938
Devin Nakamura43642b32011-07-11 11:22:16 -0400939 if (optind > argc - 2) {
940 return command_usage(&writev_cmd);
941 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200942
Devin Nakamura43642b32011-07-11 11:22:16 -0400943 nr_reqs = 1;
944 for (i = optind; i < argc; i++) {
945 if (!strcmp(argv[i], ";")) {
946 nr_reqs++;
947 }
948 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200949
Kevin Wolff2360622011-10-31 11:36:32 +0100950 reqs = g_malloc0(nr_reqs * sizeof(*reqs));
951 buf = g_malloc0(nr_reqs * sizeof(*buf));
Anthony Liguori7267c092011-08-20 22:09:37 -0500952 qiovs = g_malloc(nr_reqs * sizeof(*qiovs));
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200953
Kevin Wolf67403db2011-10-31 11:49:21 +0100954 for (i = 0; i < nr_reqs && optind < argc; i++) {
Devin Nakamura43642b32011-07-11 11:22:16 -0400955 int j;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200956
Devin Nakamura43642b32011-07-11 11:22:16 -0400957 /* Read the offset of the request */
958 offset = cvtnum(argv[optind]);
959 if (offset < 0) {
960 printf("non-numeric offset argument -- %s\n", argv[optind]);
Kevin Wolf67403db2011-10-31 11:49:21 +0100961 goto out;
Devin Nakamura43642b32011-07-11 11:22:16 -0400962 }
963 optind++;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200964
Devin Nakamura43642b32011-07-11 11:22:16 -0400965 if (offset & 0x1ff) {
966 printf("offset %lld is not sector aligned\n",
967 (long long)offset);
Kevin Wolf67403db2011-10-31 11:49:21 +0100968 goto out;
Devin Nakamura43642b32011-07-11 11:22:16 -0400969 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200970
971 if (i == 0) {
972 first_offset = offset;
973 }
974
Devin Nakamura43642b32011-07-11 11:22:16 -0400975 /* Read lengths for qiov entries */
976 for (j = optind; j < argc; j++) {
977 if (!strcmp(argv[j], ";")) {
978 break;
979 }
980 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200981
Devin Nakamura43642b32011-07-11 11:22:16 -0400982 nr_iov = j - optind;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200983
Devin Nakamura43642b32011-07-11 11:22:16 -0400984 /* Build request */
Kevin Wolff2360622011-10-31 11:36:32 +0100985 buf[i] = create_iovec(&qiovs[i], &argv[optind], nr_iov, pattern);
986 if (buf[i] == NULL) {
987 goto out;
988 }
989
Devin Nakamura43642b32011-07-11 11:22:16 -0400990 reqs[i].qiov = &qiovs[i];
Devin Nakamura43642b32011-07-11 11:22:16 -0400991 reqs[i].sector = offset >> 9;
992 reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200993
Devin Nakamura43642b32011-07-11 11:22:16 -0400994 optind = j + 1;
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200995
Devin Nakamura43642b32011-07-11 11:22:16 -0400996 pattern++;
997 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +0200998
Kevin Wolf67403db2011-10-31 11:49:21 +0100999 /* If there were empty requests at the end, ignore them */
1000 nr_reqs = i;
1001
Devin Nakamura43642b32011-07-11 11:22:16 -04001002 gettimeofday(&t1, NULL);
1003 cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
1004 gettimeofday(&t2, NULL);
Kevin Wolf776cbbb2010-05-21 11:37:26 +02001005
Devin Nakamura43642b32011-07-11 11:22:16 -04001006 if (cnt < 0) {
1007 printf("aio_multiwrite failed: %s\n", strerror(-cnt));
1008 goto out;
1009 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +02001010
Devin Nakamura43642b32011-07-11 11:22:16 -04001011 if (qflag) {
1012 goto out;
1013 }
Kevin Wolf776cbbb2010-05-21 11:37:26 +02001014
Devin Nakamura43642b32011-07-11 11:22:16 -04001015 /* Finally, report back -- -C gives a parsable format */
1016 t2 = tsub(t2, t1);
1017 print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
Kevin Wolf776cbbb2010-05-21 11:37:26 +02001018out:
Devin Nakamura43642b32011-07-11 11:22:16 -04001019 for (i = 0; i < nr_reqs; i++) {
1020 qemu_io_free(buf[i]);
Kevin Wolff2360622011-10-31 11:36:32 +01001021 if (reqs[i].qiov != NULL) {
1022 qemu_iovec_destroy(&qiovs[i]);
1023 }
Devin Nakamura43642b32011-07-11 11:22:16 -04001024 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001025 g_free(buf);
1026 g_free(reqs);
1027 g_free(qiovs);
Devin Nakamura43642b32011-07-11 11:22:16 -04001028 return 0;
Kevin Wolf776cbbb2010-05-21 11:37:26 +02001029}
1030
Christoph Hellwig95533d52009-06-20 21:10:44 +02001031struct aio_ctx {
Devin Nakamura43642b32011-07-11 11:22:16 -04001032 QEMUIOVector qiov;
1033 int64_t offset;
1034 char *buf;
1035 int qflag;
1036 int vflag;
1037 int Cflag;
1038 int Pflag;
1039 int pattern;
1040 struct timeval t1;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001041};
1042
Devin Nakamura43642b32011-07-11 11:22:16 -04001043static void aio_write_done(void *opaque, int ret)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001044{
Devin Nakamura43642b32011-07-11 11:22:16 -04001045 struct aio_ctx *ctx = opaque;
1046 struct timeval t2;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001047
Devin Nakamura43642b32011-07-11 11:22:16 -04001048 gettimeofday(&t2, NULL);
Christoph Hellwig95533d52009-06-20 21:10:44 +02001049
Christoph Hellwig95533d52009-06-20 21:10:44 +02001050
Devin Nakamura43642b32011-07-11 11:22:16 -04001051 if (ret < 0) {
1052 printf("aio_write failed: %s\n", strerror(-ret));
1053 goto out;
1054 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001055
Devin Nakamura43642b32011-07-11 11:22:16 -04001056 if (ctx->qflag) {
1057 goto out;
1058 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001059
Devin Nakamura43642b32011-07-11 11:22:16 -04001060 /* Finally, report back -- -C gives a parsable format */
1061 t2 = tsub(t2, ctx->t1);
1062 print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
1063 ctx->qiov.size, 1, ctx->Cflag);
Kevin Wolf7d8abfc2009-07-10 13:33:52 +02001064out:
Devin Nakamura43642b32011-07-11 11:22:16 -04001065 qemu_io_free(ctx->buf);
1066 free(ctx);
Christoph Hellwig95533d52009-06-20 21:10:44 +02001067}
1068
Devin Nakamura43642b32011-07-11 11:22:16 -04001069static void aio_read_done(void *opaque, int ret)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001070{
Devin Nakamura43642b32011-07-11 11:22:16 -04001071 struct aio_ctx *ctx = opaque;
1072 struct timeval t2;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001073
Devin Nakamura43642b32011-07-11 11:22:16 -04001074 gettimeofday(&t2, NULL);
Christoph Hellwig95533d52009-06-20 21:10:44 +02001075
Devin Nakamura43642b32011-07-11 11:22:16 -04001076 if (ret < 0) {
1077 printf("readv failed: %s\n", strerror(-ret));
1078 goto out;
1079 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001080
Devin Nakamura43642b32011-07-11 11:22:16 -04001081 if (ctx->Pflag) {
1082 void *cmp_buf = malloc(ctx->qiov.size);
Christoph Hellwig95533d52009-06-20 21:10:44 +02001083
Devin Nakamura43642b32011-07-11 11:22:16 -04001084 memset(cmp_buf, ctx->pattern, ctx->qiov.size);
1085 if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
1086 printf("Pattern verification failed at offset %"
1087 PRId64 ", %zd bytes\n", ctx->offset, ctx->qiov.size);
1088 }
1089 free(cmp_buf);
1090 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001091
Devin Nakamura43642b32011-07-11 11:22:16 -04001092 if (ctx->qflag) {
1093 goto out;
1094 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001095
Devin Nakamura43642b32011-07-11 11:22:16 -04001096 if (ctx->vflag) {
1097 dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
1098 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001099
Devin Nakamura43642b32011-07-11 11:22:16 -04001100 /* Finally, report back -- -C gives a parsable format */
1101 t2 = tsub(t2, ctx->t1);
1102 print_report("read", &t2, ctx->offset, ctx->qiov.size,
1103 ctx->qiov.size, 1, ctx->Cflag);
Kevin Wolf7d8abfc2009-07-10 13:33:52 +02001104out:
Devin Nakamura43642b32011-07-11 11:22:16 -04001105 qemu_io_free(ctx->buf);
1106 free(ctx);
Christoph Hellwig95533d52009-06-20 21:10:44 +02001107}
1108
Devin Nakamura43642b32011-07-11 11:22:16 -04001109static void aio_read_help(void)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001110{
Devin Nakamura43642b32011-07-11 11:22:16 -04001111 printf(
Christoph Hellwig95533d52009-06-20 21:10:44 +02001112"\n"
1113" asynchronously reads a range of bytes from the given offset\n"
1114"\n"
1115" Example:\n"
1116" 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
1117"\n"
1118" Reads a segment of the currently open file, optionally dumping it to the\n"
1119" standard output stream (with -v option) for subsequent inspection.\n"
Christoph Hellwige432cef2010-03-28 12:19:31 +02001120" The read is performed asynchronously and the aio_flush command must be\n"
1121" used to ensure all outstanding aio requests have been completed\n"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001122" -C, -- report statistics in a machine parsable format\n"
1123" -P, -- use a pattern to verify read data\n"
1124" -v, -- dump buffer to standard output\n"
Kevin Wolf095343a2010-12-17 11:55:37 +01001125" -q, -- quiet mode, do not show I/O statistics\n"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001126"\n");
1127}
1128
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001129static int aio_read_f(int argc, char **argv);
1130
1131static const cmdinfo_t aio_read_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001132 .name = "aio_read",
1133 .cfunc = aio_read_f,
1134 .argmin = 2,
1135 .argmax = -1,
1136 .args = "[-Cqv] [-P pattern ] off len [len..]",
1137 .oneline = "asynchronously reads a number of bytes",
1138 .help = aio_read_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001139};
1140
Devin Nakamura43642b32011-07-11 11:22:16 -04001141static int aio_read_f(int argc, char **argv)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001142{
Devin Nakamura43642b32011-07-11 11:22:16 -04001143 int nr_iov, c;
1144 struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
Christoph Hellwig95533d52009-06-20 21:10:44 +02001145
Devin Nakamura43642b32011-07-11 11:22:16 -04001146 while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
1147 switch (c) {
1148 case 'C':
1149 ctx->Cflag = 1;
1150 break;
1151 case 'P':
1152 ctx->Pflag = 1;
1153 ctx->pattern = parse_pattern(optarg);
1154 if (ctx->pattern < 0) {
1155 free(ctx);
1156 return 0;
1157 }
1158 break;
1159 case 'q':
1160 ctx->qflag = 1;
1161 break;
1162 case 'v':
1163 ctx->vflag = 1;
1164 break;
1165 default:
1166 free(ctx);
1167 return command_usage(&aio_read_cmd);
1168 }
1169 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001170
Devin Nakamura43642b32011-07-11 11:22:16 -04001171 if (optind > argc - 2) {
1172 free(ctx);
1173 return command_usage(&aio_read_cmd);
1174 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001175
Devin Nakamura43642b32011-07-11 11:22:16 -04001176 ctx->offset = cvtnum(argv[optind]);
1177 if (ctx->offset < 0) {
1178 printf("non-numeric length argument -- %s\n", argv[optind]);
1179 free(ctx);
1180 return 0;
1181 }
1182 optind++;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001183
Devin Nakamura43642b32011-07-11 11:22:16 -04001184 if (ctx->offset & 0x1ff) {
1185 printf("offset %" PRId64 " is not sector aligned\n",
1186 ctx->offset);
1187 free(ctx);
1188 return 0;
1189 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001190
Devin Nakamura43642b32011-07-11 11:22:16 -04001191 nr_iov = argc - optind;
1192 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab);
Kevin Wolff2360622011-10-31 11:36:32 +01001193 if (ctx->buf == NULL) {
1194 free(ctx);
1195 return 0;
1196 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001197
Devin Nakamura43642b32011-07-11 11:22:16 -04001198 gettimeofday(&ctx->t1, NULL);
Paolo Bonziniad54ae82011-11-30 09:12:30 +01001199 bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
1200 ctx->qiov.size >> 9, aio_read_done, ctx);
Devin Nakamura43642b32011-07-11 11:22:16 -04001201 return 0;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001202}
1203
Devin Nakamura43642b32011-07-11 11:22:16 -04001204static void aio_write_help(void)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001205{
Devin Nakamura43642b32011-07-11 11:22:16 -04001206 printf(
Christoph Hellwig95533d52009-06-20 21:10:44 +02001207"\n"
Devin Nakamura43642b32011-07-11 11:22:16 -04001208" asynchronously writes a range of bytes from the given offset source\n"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001209" from multiple buffers\n"
1210"\n"
1211" Example:\n"
1212" 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
1213"\n"
1214" Writes into a segment of the currently open file, using a buffer\n"
1215" filled with a set pattern (0xcdcdcdcd).\n"
Christoph Hellwige432cef2010-03-28 12:19:31 +02001216" The write is performed asynchronously and the aio_flush command must be\n"
1217" used to ensure all outstanding aio requests have been completed\n"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001218" -P, -- use different pattern to fill file\n"
1219" -C, -- report statistics in a machine parsable format\n"
Kevin Wolf095343a2010-12-17 11:55:37 +01001220" -q, -- quiet mode, do not show I/O statistics\n"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001221"\n");
1222}
1223
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001224static int aio_write_f(int argc, char **argv);
1225
1226static const cmdinfo_t aio_write_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001227 .name = "aio_write",
1228 .cfunc = aio_write_f,
1229 .argmin = 2,
1230 .argmax = -1,
1231 .args = "[-Cq] [-P pattern ] off len [len..]",
1232 .oneline = "asynchronously writes a number of bytes",
1233 .help = aio_write_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001234};
Christoph Hellwig95533d52009-06-20 21:10:44 +02001235
Devin Nakamura43642b32011-07-11 11:22:16 -04001236static int aio_write_f(int argc, char **argv)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001237{
Devin Nakamura43642b32011-07-11 11:22:16 -04001238 int nr_iov, c;
1239 int pattern = 0xcd;
1240 struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
Christoph Hellwig95533d52009-06-20 21:10:44 +02001241
Devin Nakamura43642b32011-07-11 11:22:16 -04001242 while ((c = getopt(argc, argv, "CqP:")) != EOF) {
1243 switch (c) {
1244 case 'C':
1245 ctx->Cflag = 1;
1246 break;
1247 case 'q':
1248 ctx->qflag = 1;
1249 break;
1250 case 'P':
1251 pattern = parse_pattern(optarg);
1252 if (pattern < 0) {
Alex Jiab1b1dad2011-09-28 14:57:01 +08001253 free(ctx);
Devin Nakamura43642b32011-07-11 11:22:16 -04001254 return 0;
1255 }
1256 break;
1257 default:
1258 free(ctx);
1259 return command_usage(&aio_write_cmd);
1260 }
1261 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001262
Devin Nakamura43642b32011-07-11 11:22:16 -04001263 if (optind > argc - 2) {
1264 free(ctx);
1265 return command_usage(&aio_write_cmd);
1266 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001267
Devin Nakamura43642b32011-07-11 11:22:16 -04001268 ctx->offset = cvtnum(argv[optind]);
1269 if (ctx->offset < 0) {
1270 printf("non-numeric length argument -- %s\n", argv[optind]);
1271 free(ctx);
1272 return 0;
1273 }
1274 optind++;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001275
Devin Nakamura43642b32011-07-11 11:22:16 -04001276 if (ctx->offset & 0x1ff) {
1277 printf("offset %" PRId64 " is not sector aligned\n",
1278 ctx->offset);
1279 free(ctx);
1280 return 0;
1281 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001282
Devin Nakamura43642b32011-07-11 11:22:16 -04001283 nr_iov = argc - optind;
1284 ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
Kevin Wolff2360622011-10-31 11:36:32 +01001285 if (ctx->buf == NULL) {
1286 free(ctx);
1287 return 0;
1288 }
Christoph Hellwig95533d52009-06-20 21:10:44 +02001289
Devin Nakamura43642b32011-07-11 11:22:16 -04001290 gettimeofday(&ctx->t1, NULL);
Paolo Bonziniad54ae82011-11-30 09:12:30 +01001291 bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
1292 ctx->qiov.size >> 9, aio_write_done, ctx);
Devin Nakamura43642b32011-07-11 11:22:16 -04001293 return 0;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001294}
1295
Devin Nakamura43642b32011-07-11 11:22:16 -04001296static int aio_flush_f(int argc, char **argv)
Christoph Hellwig95533d52009-06-20 21:10:44 +02001297{
Devin Nakamura43642b32011-07-11 11:22:16 -04001298 qemu_aio_flush();
1299 return 0;
Christoph Hellwig95533d52009-06-20 21:10:44 +02001300}
1301
1302static const cmdinfo_t aio_flush_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001303 .name = "aio_flush",
1304 .cfunc = aio_flush_f,
1305 .oneline = "completes all outstanding aio requests"
Christoph Hellwig95533d52009-06-20 21:10:44 +02001306};
1307
Devin Nakamura43642b32011-07-11 11:22:16 -04001308static int flush_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001309{
Devin Nakamura43642b32011-07-11 11:22:16 -04001310 bdrv_flush(bs);
1311 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001312}
1313
1314static const cmdinfo_t flush_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001315 .name = "flush",
1316 .altname = "f",
1317 .cfunc = flush_f,
1318 .oneline = "flush all in-core file state to disk",
aliguorie3aff4f2009-04-05 19:14:04 +00001319};
1320
Devin Nakamura43642b32011-07-11 11:22:16 -04001321static int truncate_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001322{
Devin Nakamura43642b32011-07-11 11:22:16 -04001323 int64_t offset;
1324 int ret;
aliguorie3aff4f2009-04-05 19:14:04 +00001325
Devin Nakamura43642b32011-07-11 11:22:16 -04001326 offset = cvtnum(argv[1]);
1327 if (offset < 0) {
1328 printf("non-numeric truncate argument -- %s\n", argv[1]);
1329 return 0;
1330 }
aliguorie3aff4f2009-04-05 19:14:04 +00001331
Devin Nakamura43642b32011-07-11 11:22:16 -04001332 ret = bdrv_truncate(bs, offset);
1333 if (ret < 0) {
1334 printf("truncate: %s\n", strerror(-ret));
1335 return 0;
1336 }
aliguorie3aff4f2009-04-05 19:14:04 +00001337
Devin Nakamura43642b32011-07-11 11:22:16 -04001338 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001339}
1340
1341static const cmdinfo_t truncate_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001342 .name = "truncate",
1343 .altname = "t",
1344 .cfunc = truncate_f,
1345 .argmin = 1,
1346 .argmax = 1,
1347 .args = "off",
1348 .oneline = "truncates the current file at the given offset",
aliguorie3aff4f2009-04-05 19:14:04 +00001349};
1350
Devin Nakamura43642b32011-07-11 11:22:16 -04001351static int length_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001352{
Devin Nakamura43642b32011-07-11 11:22:16 -04001353 int64_t size;
1354 char s1[64];
aliguorie3aff4f2009-04-05 19:14:04 +00001355
Devin Nakamura43642b32011-07-11 11:22:16 -04001356 size = bdrv_getlength(bs);
1357 if (size < 0) {
1358 printf("getlength: %s\n", strerror(-size));
1359 return 0;
1360 }
aliguorie3aff4f2009-04-05 19:14:04 +00001361
Devin Nakamura43642b32011-07-11 11:22:16 -04001362 cvtstr(size, s1, sizeof(s1));
1363 printf("%s\n", s1);
1364 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001365}
1366
1367
1368static const cmdinfo_t length_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001369 .name = "length",
1370 .altname = "l",
1371 .cfunc = length_f,
1372 .oneline = "gets the length of the current file",
aliguorie3aff4f2009-04-05 19:14:04 +00001373};
1374
1375
Devin Nakamura43642b32011-07-11 11:22:16 -04001376static int info_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001377{
Devin Nakamura43642b32011-07-11 11:22:16 -04001378 BlockDriverInfo bdi;
1379 char s1[64], s2[64];
1380 int ret;
aliguorie3aff4f2009-04-05 19:14:04 +00001381
Devin Nakamura43642b32011-07-11 11:22:16 -04001382 if (bs->drv && bs->drv->format_name) {
1383 printf("format name: %s\n", bs->drv->format_name);
1384 }
1385 if (bs->drv && bs->drv->protocol_name) {
1386 printf("format name: %s\n", bs->drv->protocol_name);
1387 }
aliguorie3aff4f2009-04-05 19:14:04 +00001388
Devin Nakamura43642b32011-07-11 11:22:16 -04001389 ret = bdrv_get_info(bs, &bdi);
1390 if (ret) {
1391 return 0;
1392 }
aliguorie3aff4f2009-04-05 19:14:04 +00001393
Devin Nakamura43642b32011-07-11 11:22:16 -04001394 cvtstr(bdi.cluster_size, s1, sizeof(s1));
1395 cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
aliguorie3aff4f2009-04-05 19:14:04 +00001396
Devin Nakamura43642b32011-07-11 11:22:16 -04001397 printf("cluster size: %s\n", s1);
1398 printf("vm state offset: %s\n", s2);
aliguorie3aff4f2009-04-05 19:14:04 +00001399
Devin Nakamura43642b32011-07-11 11:22:16 -04001400 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001401}
1402
1403
1404
1405static const cmdinfo_t info_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001406 .name = "info",
1407 .altname = "i",
1408 .cfunc = info_f,
1409 .oneline = "prints information about the current file",
aliguorie3aff4f2009-04-05 19:14:04 +00001410};
1411
Devin Nakamura43642b32011-07-11 11:22:16 -04001412static void discard_help(void)
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001413{
Devin Nakamura43642b32011-07-11 11:22:16 -04001414 printf(
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001415"\n"
1416" discards a range of bytes from the given offset\n"
1417"\n"
1418" Example:\n"
1419" 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
1420"\n"
1421" Discards a segment of the currently open file.\n"
1422" -C, -- report statistics in a machine parsable format\n"
Kevin Wolf095343a2010-12-17 11:55:37 +01001423" -q, -- quiet mode, do not show I/O statistics\n"
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001424"\n");
1425}
1426
1427static int discard_f(int argc, char **argv);
1428
1429static const cmdinfo_t discard_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001430 .name = "discard",
1431 .altname = "d",
1432 .cfunc = discard_f,
1433 .argmin = 2,
1434 .argmax = -1,
1435 .args = "[-Cq] off len",
1436 .oneline = "discards a number of bytes at a specified offset",
1437 .help = discard_help,
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001438};
1439
Devin Nakamura43642b32011-07-11 11:22:16 -04001440static int discard_f(int argc, char **argv)
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001441{
Devin Nakamura43642b32011-07-11 11:22:16 -04001442 struct timeval t1, t2;
1443 int Cflag = 0, qflag = 0;
1444 int c, ret;
1445 int64_t offset;
1446 int count;
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001447
Devin Nakamura43642b32011-07-11 11:22:16 -04001448 while ((c = getopt(argc, argv, "Cq")) != EOF) {
1449 switch (c) {
1450 case 'C':
1451 Cflag = 1;
1452 break;
1453 case 'q':
1454 qflag = 1;
1455 break;
1456 default:
1457 return command_usage(&discard_cmd);
1458 }
1459 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001460
Devin Nakamura43642b32011-07-11 11:22:16 -04001461 if (optind != argc - 2) {
1462 return command_usage(&discard_cmd);
1463 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001464
Devin Nakamura43642b32011-07-11 11:22:16 -04001465 offset = cvtnum(argv[optind]);
1466 if (offset < 0) {
1467 printf("non-numeric length argument -- %s\n", argv[optind]);
1468 return 0;
1469 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001470
Devin Nakamura43642b32011-07-11 11:22:16 -04001471 optind++;
1472 count = cvtnum(argv[optind]);
1473 if (count < 0) {
1474 printf("non-numeric length argument -- %s\n", argv[optind]);
1475 return 0;
1476 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001477
Devin Nakamura43642b32011-07-11 11:22:16 -04001478 gettimeofday(&t1, NULL);
1479 ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS,
1480 count >> BDRV_SECTOR_BITS);
1481 gettimeofday(&t2, NULL);
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001482
Devin Nakamura43642b32011-07-11 11:22:16 -04001483 if (ret < 0) {
1484 printf("discard failed: %s\n", strerror(-ret));
1485 goto out;
1486 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001487
Devin Nakamura43642b32011-07-11 11:22:16 -04001488 /* Finally, report back -- -C gives a parsable format */
1489 if (!qflag) {
1490 t2 = tsub(t2, t1);
1491 print_report("discard", &t2, offset, count, count, 1, Cflag);
1492 }
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001493
1494out:
Devin Nakamura43642b32011-07-11 11:22:16 -04001495 return 0;
Stefan Hajnocziedff5db2010-12-13 09:36:26 +00001496}
1497
Devin Nakamura43642b32011-07-11 11:22:16 -04001498static int alloc_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001499{
Devin Nakamura43642b32011-07-11 11:22:16 -04001500 int64_t offset;
1501 int nb_sectors, remaining;
1502 char s1[64];
1503 int num, sum_alloc;
1504 int ret;
aliguorie3aff4f2009-04-05 19:14:04 +00001505
Devin Nakamura43642b32011-07-11 11:22:16 -04001506 offset = cvtnum(argv[1]);
1507 if (offset & 0x1ff) {
1508 printf("offset %" PRId64 " is not sector aligned\n",
1509 offset);
1510 return 0;
1511 }
aliguorie3aff4f2009-04-05 19:14:04 +00001512
Devin Nakamura43642b32011-07-11 11:22:16 -04001513 if (argc == 3) {
1514 nb_sectors = cvtnum(argv[2]);
1515 } else {
1516 nb_sectors = 1;
1517 }
aliguorie3aff4f2009-04-05 19:14:04 +00001518
Devin Nakamura43642b32011-07-11 11:22:16 -04001519 remaining = nb_sectors;
1520 sum_alloc = 0;
1521 while (remaining) {
1522 ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
1523 remaining -= num;
1524 if (ret) {
1525 sum_alloc += num;
1526 }
1527 }
aliguorie3aff4f2009-04-05 19:14:04 +00001528
Devin Nakamura43642b32011-07-11 11:22:16 -04001529 cvtstr(offset, s1, sizeof(s1));
aliguorie3aff4f2009-04-05 19:14:04 +00001530
Devin Nakamura43642b32011-07-11 11:22:16 -04001531 printf("%d/%d sectors allocated at offset %s\n",
1532 sum_alloc, nb_sectors, s1);
1533 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001534}
1535
1536static const cmdinfo_t alloc_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001537 .name = "alloc",
1538 .altname = "a",
1539 .argmin = 1,
1540 .argmax = 2,
1541 .cfunc = alloc_f,
1542 .args = "off [sectors]",
1543 .oneline = "checks if a sector is present in the file",
aliguorie3aff4f2009-04-05 19:14:04 +00001544};
1545
Devin Nakamura43642b32011-07-11 11:22:16 -04001546static int map_f(int argc, char **argv)
Kevin Wolf191c2892010-09-16 13:18:08 +02001547{
Devin Nakamura43642b32011-07-11 11:22:16 -04001548 int64_t offset;
1549 int64_t nb_sectors;
1550 char s1[64];
1551 int num, num_checked;
1552 int ret;
1553 const char *retstr;
Kevin Wolf191c2892010-09-16 13:18:08 +02001554
Devin Nakamura43642b32011-07-11 11:22:16 -04001555 offset = 0;
1556 nb_sectors = bs->total_sectors;
Kevin Wolf191c2892010-09-16 13:18:08 +02001557
Devin Nakamura43642b32011-07-11 11:22:16 -04001558 do {
1559 num_checked = MIN(nb_sectors, INT_MAX);
1560 ret = bdrv_is_allocated(bs, offset, num_checked, &num);
1561 retstr = ret ? " allocated" : "not allocated";
1562 cvtstr(offset << 9ULL, s1, sizeof(s1));
1563 printf("[% 24" PRId64 "] % 8d/% 8d sectors %s at offset %s (%d)\n",
1564 offset << 9ULL, num, num_checked, retstr, s1, ret);
Kevin Wolf191c2892010-09-16 13:18:08 +02001565
Devin Nakamura43642b32011-07-11 11:22:16 -04001566 offset += num;
1567 nb_sectors -= num;
1568 } while (offset < bs->total_sectors);
Kevin Wolf191c2892010-09-16 13:18:08 +02001569
Devin Nakamura43642b32011-07-11 11:22:16 -04001570 return 0;
Kevin Wolf191c2892010-09-16 13:18:08 +02001571}
1572
1573static const cmdinfo_t map_cmd = {
1574 .name = "map",
1575 .argmin = 0,
1576 .argmax = 0,
1577 .cfunc = map_f,
1578 .args = "",
1579 .oneline = "prints the allocated areas of a file",
1580};
1581
1582
Devin Nakamura43642b32011-07-11 11:22:16 -04001583static int close_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001584{
Stefan Hajnoczib4657852011-10-27 10:54:26 +01001585 bdrv_delete(bs);
Devin Nakamura43642b32011-07-11 11:22:16 -04001586 bs = NULL;
1587 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001588}
1589
1590static const cmdinfo_t close_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001591 .name = "close",
1592 .altname = "c",
1593 .cfunc = close_f,
1594 .oneline = "close the current open file",
aliguorie3aff4f2009-04-05 19:14:04 +00001595};
1596
Christoph Hellwig9c4bab22009-07-10 13:33:47 +02001597static int openfile(char *name, int flags, int growable)
aliguorie3aff4f2009-04-05 19:14:04 +00001598{
Devin Nakamura43642b32011-07-11 11:22:16 -04001599 if (bs) {
1600 fprintf(stderr, "file open already, try 'help close'\n");
1601 return 1;
1602 }
aliguorie3aff4f2009-04-05 19:14:04 +00001603
Devin Nakamura43642b32011-07-11 11:22:16 -04001604 if (growable) {
1605 if (bdrv_file_open(&bs, name, flags)) {
1606 fprintf(stderr, "%s: can't open device %s\n", progname, name);
1607 return 1;
1608 }
1609 } else {
1610 bs = bdrv_new("hda");
Christoph Hellwig6db95602010-04-05 16:53:57 +02001611
Devin Nakamura43642b32011-07-11 11:22:16 -04001612 if (bdrv_open(bs, name, flags, NULL) < 0) {
1613 fprintf(stderr, "%s: can't open device %s\n", progname, name);
Stefan Hajnoczib4657852011-10-27 10:54:26 +01001614 bdrv_delete(bs);
Devin Nakamura43642b32011-07-11 11:22:16 -04001615 bs = NULL;
1616 return 1;
1617 }
1618 }
Christoph Hellwig1db69472009-07-15 23:11:21 +02001619
Devin Nakamura43642b32011-07-11 11:22:16 -04001620 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001621}
1622
Devin Nakamura43642b32011-07-11 11:22:16 -04001623static void open_help(void)
aliguorie3aff4f2009-04-05 19:14:04 +00001624{
Devin Nakamura43642b32011-07-11 11:22:16 -04001625 printf(
aliguorie3aff4f2009-04-05 19:14:04 +00001626"\n"
1627" opens a new file in the requested mode\n"
1628"\n"
1629" Example:\n"
1630" 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
1631"\n"
1632" Opens a file for subsequent use by all of the other qemu-io commands.\n"
aliguorie3aff4f2009-04-05 19:14:04 +00001633" -r, -- open file read-only\n"
1634" -s, -- use snapshot file\n"
1635" -n, -- disable host cache\n"
Christoph Hellwig9c4bab22009-07-10 13:33:47 +02001636" -g, -- allow file to grow (only applies to protocols)"
aliguorie3aff4f2009-04-05 19:14:04 +00001637"\n");
1638}
1639
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001640static int open_f(int argc, char **argv);
1641
1642static const cmdinfo_t open_cmd = {
Devin Nakamura43642b32011-07-11 11:22:16 -04001643 .name = "open",
1644 .altname = "o",
1645 .cfunc = open_f,
1646 .argmin = 1,
1647 .argmax = -1,
1648 .flags = CMD_NOFILE_OK,
1649 .args = "[-Crsn] [path]",
1650 .oneline = "open the file specified by path",
1651 .help = open_help,
Blue Swirl22a2bdc2009-11-21 09:06:46 +00001652};
aliguorie3aff4f2009-04-05 19:14:04 +00001653
Devin Nakamura43642b32011-07-11 11:22:16 -04001654static int open_f(int argc, char **argv)
aliguorie3aff4f2009-04-05 19:14:04 +00001655{
Devin Nakamura43642b32011-07-11 11:22:16 -04001656 int flags = 0;
1657 int readonly = 0;
1658 int growable = 0;
1659 int c;
aliguorie3aff4f2009-04-05 19:14:04 +00001660
Devin Nakamura43642b32011-07-11 11:22:16 -04001661 while ((c = getopt(argc, argv, "snrg")) != EOF) {
1662 switch (c) {
1663 case 's':
1664 flags |= BDRV_O_SNAPSHOT;
1665 break;
1666 case 'n':
1667 flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
1668 break;
1669 case 'r':
1670 readonly = 1;
1671 break;
1672 case 'g':
1673 growable = 1;
1674 break;
1675 default:
1676 return command_usage(&open_cmd);
Naphtali Spreif5edb012010-01-17 16:48:13 +02001677 }
Devin Nakamura43642b32011-07-11 11:22:16 -04001678 }
aliguorie3aff4f2009-04-05 19:14:04 +00001679
Devin Nakamura43642b32011-07-11 11:22:16 -04001680 if (!readonly) {
1681 flags |= BDRV_O_RDWR;
1682 }
aliguorie3aff4f2009-04-05 19:14:04 +00001683
Devin Nakamura43642b32011-07-11 11:22:16 -04001684 if (optind != argc - 1) {
1685 return command_usage(&open_cmd);
1686 }
1687
1688 return openfile(argv[optind], flags, growable);
aliguorie3aff4f2009-04-05 19:14:04 +00001689}
1690
Devin Nakamura43642b32011-07-11 11:22:16 -04001691static int init_args_command(int index)
aliguorie3aff4f2009-04-05 19:14:04 +00001692{
Devin Nakamura43642b32011-07-11 11:22:16 -04001693 /* only one device allowed so far */
1694 if (index >= 1) {
1695 return 0;
1696 }
1697 return ++index;
aliguorie3aff4f2009-04-05 19:14:04 +00001698}
1699
Devin Nakamura43642b32011-07-11 11:22:16 -04001700static int init_check_command(const cmdinfo_t *ct)
aliguorie3aff4f2009-04-05 19:14:04 +00001701{
Devin Nakamura43642b32011-07-11 11:22:16 -04001702 if (ct->flags & CMD_FLAG_GLOBAL) {
1703 return 1;
1704 }
1705 if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
1706 fprintf(stderr, "no file open, try 'help open'\n");
1707 return 0;
1708 }
1709 return 1;
aliguorie3aff4f2009-04-05 19:14:04 +00001710}
1711
1712static void usage(const char *name)
1713{
Devin Nakamura43642b32011-07-11 11:22:16 -04001714 printf(
Christoph Hellwig9a2d77a2010-01-20 18:13:42 +01001715"Usage: %s [-h] [-V] [-rsnm] [-c cmd] ... [file]\n"
Stefan Weil84844a22009-06-22 15:08:47 +02001716"QEMU Disk exerciser\n"
aliguorie3aff4f2009-04-05 19:14:04 +00001717"\n"
aliguorie3aff4f2009-04-05 19:14:04 +00001718" -c, --cmd command to execute\n"
1719" -r, --read-only export read-only\n"
1720" -s, --snapshot use snapshot file\n"
1721" -n, --nocache disable host cache\n"
Christoph Hellwig1db69472009-07-15 23:11:21 +02001722" -g, --growable allow file to grow (only applies to protocols)\n"
aliguorie3aff4f2009-04-05 19:14:04 +00001723" -m, --misalign misalign allocations for O_DIRECT\n"
Christoph Hellwig5c6c3a62009-08-20 16:58:35 +02001724" -k, --native-aio use kernel AIO implementation (on Linux only)\n"
aliguorie3aff4f2009-04-05 19:14:04 +00001725" -h, --help display this help and exit\n"
1726" -V, --version output version information and exit\n"
1727"\n",
Devin Nakamura43642b32011-07-11 11:22:16 -04001728 name);
aliguorie3aff4f2009-04-05 19:14:04 +00001729}
1730
1731
1732int main(int argc, char **argv)
1733{
Devin Nakamura43642b32011-07-11 11:22:16 -04001734 int readonly = 0;
1735 int growable = 0;
1736 const char *sopt = "hVc:rsnmgk";
1737 const struct option lopt[] = {
1738 { "help", 0, NULL, 'h' },
1739 { "version", 0, NULL, 'V' },
1740 { "offset", 1, NULL, 'o' },
1741 { "cmd", 1, NULL, 'c' },
1742 { "read-only", 0, NULL, 'r' },
1743 { "snapshot", 0, NULL, 's' },
1744 { "nocache", 0, NULL, 'n' },
1745 { "misalign", 0, NULL, 'm' },
1746 { "growable", 0, NULL, 'g' },
1747 { "native-aio", 0, NULL, 'k' },
1748 { NULL, 0, NULL, 0 }
1749 };
1750 int c;
1751 int opt_index = 0;
1752 int flags = 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001753
Devin Nakamura43642b32011-07-11 11:22:16 -04001754 progname = basename(argv[0]);
aliguorie3aff4f2009-04-05 19:14:04 +00001755
Devin Nakamura43642b32011-07-11 11:22:16 -04001756 while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
1757 switch (c) {
1758 case 's':
1759 flags |= BDRV_O_SNAPSHOT;
1760 break;
1761 case 'n':
1762 flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
1763 break;
1764 case 'c':
1765 add_user_command(optarg);
1766 break;
1767 case 'r':
1768 readonly = 1;
1769 break;
1770 case 'm':
1771 misalign = 1;
1772 break;
1773 case 'g':
1774 growable = 1;
1775 break;
1776 case 'k':
1777 flags |= BDRV_O_NATIVE_AIO;
1778 break;
1779 case 'V':
1780 printf("%s version %s\n", progname, VERSION);
1781 exit(0);
1782 case 'h':
1783 usage(progname);
1784 exit(0);
1785 default:
1786 usage(progname);
1787 exit(1);
Naphtali Spreif5edb012010-01-17 16:48:13 +02001788 }
Devin Nakamura43642b32011-07-11 11:22:16 -04001789 }
aliguorie3aff4f2009-04-05 19:14:04 +00001790
Devin Nakamura43642b32011-07-11 11:22:16 -04001791 if ((argc - optind) > 1) {
1792 usage(progname);
1793 exit(1);
1794 }
aliguorie3aff4f2009-04-05 19:14:04 +00001795
Devin Nakamura43642b32011-07-11 11:22:16 -04001796 bdrv_init();
Christoph Hellwig95533d52009-06-20 21:10:44 +02001797
Devin Nakamura43642b32011-07-11 11:22:16 -04001798 /* initialize commands */
1799 quit_init();
1800 help_init();
1801 add_command(&open_cmd);
1802 add_command(&close_cmd);
1803 add_command(&read_cmd);
1804 add_command(&readv_cmd);
1805 add_command(&write_cmd);
1806 add_command(&writev_cmd);
1807 add_command(&multiwrite_cmd);
1808 add_command(&aio_read_cmd);
1809 add_command(&aio_write_cmd);
1810 add_command(&aio_flush_cmd);
1811 add_command(&flush_cmd);
1812 add_command(&truncate_cmd);
1813 add_command(&length_cmd);
1814 add_command(&info_cmd);
1815 add_command(&discard_cmd);
1816 add_command(&alloc_cmd);
1817 add_command(&map_cmd);
1818
1819 add_args_command(init_args_command);
1820 add_check_command(init_check_command);
1821
1822 /* open the device */
1823 if (!readonly) {
1824 flags |= BDRV_O_RDWR;
1825 }
1826
1827 if ((argc - optind) == 1) {
1828 openfile(argv[optind], flags, growable);
1829 }
1830 command_loop();
1831
1832 /*
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001833 * Make sure all outstanding requests complete before the program exits.
Devin Nakamura43642b32011-07-11 11:22:16 -04001834 */
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001835 bdrv_drain_all();
Devin Nakamura43642b32011-07-11 11:22:16 -04001836
1837 if (bs) {
Stefan Hajnoczib4657852011-10-27 10:54:26 +01001838 bdrv_delete(bs);
Devin Nakamura43642b32011-07-11 11:22:16 -04001839 }
1840 return 0;
aliguorie3aff4f2009-04-05 19:14:04 +00001841}