File:  [Qemu by Fabrice Bellard] / qemu / qemu-io.c
Revision 1.1.1.4 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:34:33 2018 UTC (19 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

    1: /*
    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:  */
   10: #include <sys/time.h>
   11: #include <sys/types.h>
   12: #include <stdarg.h>
   13: #include <stdio.h>
   14: #include <getopt.h>
   15: #include <libgen.h>
   16: 
   17: #include "qemu-common.h"
   18: #include "block_int.h"
   19: #include "cmd.h"
   20: 
   21: #define VERSION	"0.0.1"
   22: 
   23: #define CMD_NOFILE_OK	0x01
   24: 
   25: char *progname;
   26: static BlockDriverState *bs;
   27: 
   28: static int misalign;
   29: 
   30: /*
   31:  * 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:  */
   36: static int parse_pattern(const char *arg)
   37: {
   38: 	char *endptr = NULL;
   39: 	long pattern;
   40: 
   41: 	pattern = strtol(arg, &endptr, 0);
   42: 	if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {
   43: 		printf("%s is not a valid pattern byte\n", arg);
   44: 		return -1;
   45: 	}
   46: 
   47: 	return pattern;
   48: }
   49: 
   50: /*
   51:  * 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: 
   57: #define MISALIGN_OFFSET		16
   58: static void *qemu_io_alloc(size_t len, int pattern)
   59: {
   60: 	void *buf;
   61: 
   62: 	if (misalign)
   63: 		len += MISALIGN_OFFSET;
   64: 	buf = qemu_blockalign(bs, len);
   65: 	memset(buf, pattern, len);
   66: 	if (misalign)
   67: 		buf += MISALIGN_OFFSET;
   68: 	return buf;
   69: }
   70: 
   71: static void qemu_io_free(void *p)
   72: {
   73: 	if (misalign)
   74: 		p -= MISALIGN_OFFSET;
   75: 	qemu_vfree(p);
   76: }
   77: 
   78: static void
   79: dump_buffer(const void *buffer, int64_t offset, int len)
   80: {
   81: 	int i, j;
   82: 	const uint8_t *p;
   83: 
   84: 	for (i = 0, p = buffer; i < len; i += 16) {
   85: 		const uint8_t *s = p;
   86: 
   87:                 printf("%08" PRIx64 ":  ", offset + i);
   88: 		for (j = 0; j < 16 && i + j < len; j++, p++)
   89: 			printf("%02x ", *p);
   90: 		printf(" ");
   91: 		for (j = 0; j < 16 && i + j < len; j++, s++) {
   92: 			if (isalnum(*s))
   93: 				printf("%c", *s);
   94: 			else
   95: 				printf(".");
   96: 		}
   97: 		printf("\n");
   98: 	}
   99: }
  100: 
  101: static void
  102: print_report(const char *op, struct timeval *t, int64_t offset,
  103: 		int count, int total, int cnt, int Cflag)
  104: {
  105: 	char s1[64], s2[64], ts[64];
  106: 
  107: 	timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
  108: 	if (!Cflag) {
  109: 		cvtstr((double)total, s1, sizeof(s1));
  110: 		cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
  111:                 printf("%s %d/%d bytes at offset %" PRId64 "\n",
  112:                        op, total, count, offset);
  113: 		printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
  114: 			s1, cnt, ts, s2, tdiv((double)cnt, *t));
  115: 	} else {/* bytes,ops,time,bytes/sec,ops/sec */
  116: 		printf("%d,%d,%s,%.3f,%.3f\n",
  117: 			total, cnt, ts,
  118: 			tdiv((double)total, *t),
  119: 			tdiv((double)cnt, *t));
  120: 	}
  121: }
  122: 
  123: /*
  124:  * Parse multiple length statements for vectored I/O, and construct an I/O
  125:  * vector matching it.
  126:  */
  127: static void *
  128: create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
  129: {
  130: 	size_t *sizes = calloc(nr_iov, sizeof(size_t));
  131: 	size_t count = 0;
  132: 	void *buf = NULL;
  133: 	void *p;
  134: 	int i;
  135: 
  136: 	for (i = 0; i < nr_iov; i++) {
  137: 		char *arg = argv[i];
  138:                 int64_t len;
  139: 
  140: 		len = cvtnum(arg);
  141: 		if (len < 0) {
  142: 			printf("non-numeric length argument -- %s\n", arg);
  143: 			goto fail;
  144: 		}
  145: 
  146: 		/* should be SIZE_T_MAX, but that doesn't exist */
  147: 		if (len > INT_MAX) {
  148: 			printf("too large length argument -- %s\n", arg);
  149: 			goto fail;
  150: 		}
  151: 
  152: 		if (len & 0x1ff) {
  153:                         printf("length argument %" PRId64
  154:                                " is not sector aligned\n", len);
  155: 			goto fail;
  156: 		}
  157: 
  158: 		sizes[i] = len;
  159: 		count += len;
  160: 	}
  161: 
  162: 	qemu_iovec_init(qiov, nr_iov);
  163: 
  164: 	buf = p = qemu_io_alloc(count, pattern);
  165: 
  166: 	for (i = 0; i < nr_iov; i++) {
  167: 		qemu_iovec_add(qiov, p, sizes[i]);
  168: 		p += sizes[i];
  169: 	}
  170: 
  171: fail:
  172: 	free(sizes);
  173: 	return buf;
  174: }
  175: 
  176: static int do_read(char *buf, int64_t offset, int count, int *total)
  177: {
  178: 	int ret;
  179: 
  180: 	ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
  181: 	if (ret < 0)
  182: 		return ret;
  183: 	*total = count;
  184: 	return 1;
  185: }
  186: 
  187: static int do_write(char *buf, int64_t offset, int count, int *total)
  188: {
  189: 	int ret;
  190: 
  191: 	ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
  192: 	if (ret < 0)
  193: 		return ret;
  194: 	*total = count;
  195: 	return 1;
  196: }
  197: 
  198: static int do_pread(char *buf, int64_t offset, int count, int *total)
  199: {
  200: 	*total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
  201: 	if (*total < 0)
  202: 		return *total;
  203: 	return 1;
  204: }
  205: 
  206: static int do_pwrite(char *buf, int64_t offset, int count, int *total)
  207: {
  208: 	*total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
  209: 	if (*total < 0)
  210: 		return *total;
  211: 	return 1;
  212: }
  213: 
  214: static int do_load_vmstate(char *buf, int64_t offset, int count, int *total)
  215: {
  216: 	*total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
  217: 	if (*total < 0)
  218: 		return *total;
  219: 	return 1;
  220: }
  221: 
  222: static int do_save_vmstate(char *buf, int64_t offset, int count, int *total)
  223: {
  224: 	*total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
  225: 	if (*total < 0)
  226: 		return *total;
  227: 	return 1;
  228: }
  229: 
  230: #define NOT_DONE 0x7fffffff
  231: static void aio_rw_done(void *opaque, int ret)
  232: {
  233: 	*(int *)opaque = ret;
  234: }
  235: 
  236: static int do_aio_readv(QEMUIOVector *qiov, int64_t offset, int *total)
  237: {
  238: 	BlockDriverAIOCB *acb;
  239: 	int async_ret = NOT_DONE;
  240: 
  241: 	acb = bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
  242: 			     aio_rw_done, &async_ret);
  243: 	if (!acb)
  244: 		return -EIO;
  245: 
  246: 	while (async_ret == NOT_DONE)
  247: 		qemu_aio_wait();
  248: 
  249: 	*total = qiov->size;
  250: 	return async_ret < 0 ? async_ret : 1;
  251: }
  252: 
  253: static int do_aio_writev(QEMUIOVector *qiov, int64_t offset, int *total)
  254: {
  255: 	BlockDriverAIOCB *acb;
  256: 	int async_ret = NOT_DONE;
  257: 
  258: 	acb = bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
  259: 			      aio_rw_done, &async_ret);
  260: 	if (!acb)
  261: 		return -EIO;
  262: 
  263: 	while (async_ret == NOT_DONE)
  264: 		qemu_aio_wait();
  265: 
  266: 	*total = qiov->size;
  267: 	return async_ret < 0 ? async_ret : 1;
  268: }
  269: 
  270: struct multiwrite_async_ret {
  271: 	int num_done;
  272: 	int error;
  273: };
  274: 
  275: static void multiwrite_cb(void *opaque, int ret)
  276: {
  277: 	struct multiwrite_async_ret *async_ret = opaque;
  278: 
  279: 	async_ret->num_done++;
  280: 	if (ret < 0) {
  281: 		async_ret->error = ret;
  282: 	}
  283: }
  284: 
  285: static int do_aio_multiwrite(BlockRequest* reqs, int num_reqs, int *total)
  286: {
  287: 	int i, ret;
  288: 	struct multiwrite_async_ret async_ret = {
  289: 		.num_done = 0,
  290: 		.error = 0,
  291: 	};
  292: 
  293: 	*total = 0;
  294: 	for (i = 0; i < num_reqs; i++) {
  295: 		reqs[i].cb = multiwrite_cb;
  296: 		reqs[i].opaque = &async_ret;
  297: 		*total += reqs[i].qiov->size;
  298: 	}
  299: 
  300: 	ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
  301: 	if (ret < 0) {
  302: 		return ret;
  303: 	}
  304: 
  305: 	while (async_ret.num_done < num_reqs) {
  306: 		qemu_aio_wait();
  307: 	}
  308: 
  309: 	return async_ret.error < 0 ? async_ret.error : 1;
  310: }
  311: 
  312: static void
  313: read_help(void)
  314: {
  315: 	printf(
  316: "\n"
  317: " reads a range of bytes from the given offset\n"
  318: "\n"
  319: " Example:\n"
  320: " 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
  321: "\n"
  322: " Reads a segment of the currently open file, optionally dumping it to the\n"
  323: " standard output stream (with -v option) for subsequent inspection.\n"
  324: " -b, -- read from the VM state rather than the virtual disk\n"
  325: " -C, -- report statistics in a machine parsable format\n"
  326: " -l, -- length for pattern verification (only with -P)\n"
  327: " -p, -- use bdrv_pread to read the file\n"
  328: " -P, -- use a pattern to verify read data\n"
  329: " -q, -- quiet mode, do not show I/O statistics\n"
  330: " -s, -- start offset for pattern verification (only with -P)\n"
  331: " -v, -- dump buffer to standard output\n"
  332: "\n");
  333: }
  334: 
  335: static int read_f(int argc, char **argv);
  336: 
  337: static const cmdinfo_t read_cmd = {
  338: 	.name		= "read",
  339: 	.altname	= "r",
  340: 	.cfunc		= read_f,
  341: 	.argmin		= 2,
  342: 	.argmax		= -1,
  343: 	.args		= "[-abCpqv] [-P pattern [-s off] [-l len]] off len",
  344: 	.oneline	= "reads a number of bytes at a specified offset",
  345: 	.help		= read_help,
  346: };
  347: 
  348: static int
  349: read_f(int argc, char **argv)
  350: {
  351: 	struct timeval t1, t2;
  352: 	int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
  353: 	int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;
  354: 	int c, cnt;
  355: 	char *buf;
  356: 	int64_t offset;
  357: 	int count;
  358:         /* Some compilers get confused and warn if this is not initialized.  */
  359:         int total = 0;
  360: 	int pattern = 0, pattern_offset = 0, pattern_count = 0;
  361: 
  362: 	while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {
  363: 		switch (c) {
  364: 		case 'b':
  365: 			bflag = 1;
  366: 			break;
  367: 		case 'C':
  368: 			Cflag = 1;
  369: 			break;
  370: 		case 'l':
  371: 			lflag = 1;
  372: 			pattern_count = cvtnum(optarg);
  373: 			if (pattern_count < 0) {
  374: 				printf("non-numeric length argument -- %s\n", optarg);
  375: 				return 0;
  376: 			}
  377: 			break;
  378: 		case 'p':
  379: 			pflag = 1;
  380: 			break;
  381: 		case 'P':
  382: 			Pflag = 1;
  383: 			pattern = parse_pattern(optarg);
  384: 			if (pattern < 0)
  385: 				return 0;
  386: 			break;
  387: 		case 'q':
  388: 			qflag = 1;
  389: 			break;
  390: 		case 's':
  391: 			sflag = 1;
  392: 			pattern_offset = cvtnum(optarg);
  393: 			if (pattern_offset < 0) {
  394: 				printf("non-numeric length argument -- %s\n", optarg);
  395: 				return 0;
  396: 			}
  397: 			break;
  398: 		case 'v':
  399: 			vflag = 1;
  400: 			break;
  401: 		default:
  402: 			return command_usage(&read_cmd);
  403: 		}
  404: 	}
  405: 
  406: 	if (optind != argc - 2)
  407: 		return command_usage(&read_cmd);
  408: 
  409: 	if (bflag && pflag) {
  410: 		printf("-b and -p cannot be specified at the same time\n");
  411: 		return 0;
  412: 	}
  413: 
  414: 	offset = cvtnum(argv[optind]);
  415: 	if (offset < 0) {
  416: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  417: 		return 0;
  418: 	}
  419: 
  420: 	optind++;
  421: 	count = cvtnum(argv[optind]);
  422: 	if (count < 0) {
  423: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  424: 		return 0;
  425: 	}
  426: 
  427:     if (!Pflag && (lflag || sflag)) {
  428:         return command_usage(&read_cmd);
  429:     }
  430: 
  431:     if (!lflag) {
  432:         pattern_count = count - pattern_offset;
  433:     }
  434: 
  435:     if ((pattern_count < 0) || (pattern_count + pattern_offset > count))  {
  436:         printf("pattern verfication range exceeds end of read data\n");
  437:         return 0;
  438:     }
  439: 
  440: 	if (!pflag)
  441: 		if (offset & 0x1ff) {
  442:                         printf("offset %" PRId64 " is not sector aligned\n",
  443:                                offset);
  444: 			return 0;
  445: 
  446: 		if (count & 0x1ff) {
  447: 			printf("count %d is not sector aligned\n",
  448: 				count);
  449: 			return 0;
  450: 		}
  451: 	}
  452: 
  453: 	buf = qemu_io_alloc(count, 0xab);
  454: 
  455: 	gettimeofday(&t1, NULL);
  456: 	if (pflag)
  457: 		cnt = do_pread(buf, offset, count, &total);
  458: 	else if (bflag)
  459: 		cnt = do_load_vmstate(buf, offset, count, &total);
  460: 	else
  461: 		cnt = do_read(buf, offset, count, &total);
  462: 	gettimeofday(&t2, NULL);
  463: 
  464: 	if (cnt < 0) {
  465: 		printf("read failed: %s\n", strerror(-cnt));
  466: 		goto out;
  467: 	}
  468: 
  469: 	if (Pflag) {
  470: 		void* cmp_buf = malloc(pattern_count);
  471: 		memset(cmp_buf, pattern, pattern_count);
  472: 		if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {
  473: 			printf("Pattern verification failed at offset %"
  474:                                PRId64 ", %d bytes\n",
  475:                                offset + pattern_offset, pattern_count);
  476: 		}
  477: 		free(cmp_buf);
  478: 	}
  479: 
  480: 	if (qflag)
  481: 		goto out;
  482: 
  483:         if (vflag)
  484: 		dump_buffer(buf, offset, count);
  485: 
  486: 	/* Finally, report back -- -C gives a parsable format */
  487: 	t2 = tsub(t2, t1);
  488: 	print_report("read", &t2, offset, count, total, cnt, Cflag);
  489: 
  490: out:
  491: 	qemu_io_free(buf);
  492: 
  493: 	return 0;
  494: }
  495: 
  496: static void
  497: readv_help(void)
  498: {
  499: 	printf(
  500: "\n"
  501: " reads a range of bytes from the given offset into multiple buffers\n"
  502: "\n"
  503: " Example:\n"
  504: " 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
  505: "\n"
  506: " Reads a segment of the currently open file, optionally dumping it to the\n"
  507: " standard output stream (with -v option) for subsequent inspection.\n"
  508: " Uses multiple iovec buffers if more than one byte range is specified.\n"
  509: " -C, -- report statistics in a machine parsable format\n"
  510: " -P, -- use a pattern to verify read data\n"
  511: " -v, -- dump buffer to standard output\n"
  512: " -q, -- quiet mode, do not show I/O statistics\n"
  513: "\n");
  514: }
  515: 
  516: static int readv_f(int argc, char **argv);
  517: 
  518: static const cmdinfo_t readv_cmd = {
  519: 	.name		= "readv",
  520: 	.cfunc		= readv_f,
  521: 	.argmin		= 2,
  522: 	.argmax		= -1,
  523: 	.args		= "[-Cqv] [-P pattern ] off len [len..]",
  524: 	.oneline	= "reads a number of bytes at a specified offset",
  525: 	.help		= readv_help,
  526: };
  527: 
  528: static int
  529: readv_f(int argc, char **argv)
  530: {
  531: 	struct timeval t1, t2;
  532: 	int Cflag = 0, qflag = 0, vflag = 0;
  533: 	int c, cnt;
  534: 	char *buf;
  535: 	int64_t offset;
  536:         /* Some compilers get confused and warn if this is not initialized.  */
  537:         int total = 0;
  538: 	int nr_iov;
  539: 	QEMUIOVector qiov;
  540: 	int pattern = 0;
  541: 	int Pflag = 0;
  542: 
  543: 	while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
  544: 		switch (c) {
  545: 		case 'C':
  546: 			Cflag = 1;
  547: 			break;
  548: 		case 'P':
  549: 			Pflag = 1;
  550: 			pattern = parse_pattern(optarg);
  551: 			if (pattern < 0)
  552: 				return 0;
  553: 			break;
  554: 		case 'q':
  555: 			qflag = 1;
  556: 			break;
  557: 		case 'v':
  558: 			vflag = 1;
  559: 			break;
  560: 		default:
  561: 			return command_usage(&readv_cmd);
  562: 		}
  563: 	}
  564: 
  565: 	if (optind > argc - 2)
  566: 		return command_usage(&readv_cmd);
  567: 
  568: 
  569: 	offset = cvtnum(argv[optind]);
  570: 	if (offset < 0) {
  571: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  572: 		return 0;
  573: 	}
  574: 	optind++;
  575: 
  576: 	if (offset & 0x1ff) {
  577:                 printf("offset %" PRId64 " is not sector aligned\n",
  578:                        offset);
  579: 		return 0;
  580: 	}
  581: 
  582: 	nr_iov = argc - optind;
  583: 	buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab);
  584: 
  585: 	gettimeofday(&t1, NULL);
  586: 	cnt = do_aio_readv(&qiov, offset, &total);
  587: 	gettimeofday(&t2, NULL);
  588: 
  589: 	if (cnt < 0) {
  590: 		printf("readv failed: %s\n", strerror(-cnt));
  591: 		goto out;
  592: 	}
  593: 
  594: 	if (Pflag) {
  595: 		void* cmp_buf = malloc(qiov.size);
  596: 		memset(cmp_buf, pattern, qiov.size);
  597: 		if (memcmp(buf, cmp_buf, qiov.size)) {
  598: 			printf("Pattern verification failed at offset %"
  599:                                PRId64 ", %zd bytes\n",
  600:                                offset, qiov.size);
  601: 		}
  602: 		free(cmp_buf);
  603: 	}
  604: 
  605: 	if (qflag)
  606: 		goto out;
  607: 
  608:         if (vflag)
  609: 		dump_buffer(buf, offset, qiov.size);
  610: 
  611: 	/* Finally, report back -- -C gives a parsable format */
  612: 	t2 = tsub(t2, t1);
  613: 	print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
  614: 
  615: out:
  616: 	qemu_io_free(buf);
  617: 	return 0;
  618: }
  619: 
  620: static void
  621: write_help(void)
  622: {
  623: 	printf(
  624: "\n"
  625: " writes a range of bytes from the given offset\n"
  626: "\n"
  627: " Example:\n"
  628: " 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
  629: "\n"
  630: " Writes into a segment of the currently open file, using a buffer\n"
  631: " filled with a set pattern (0xcdcdcdcd).\n"
  632: " -b, -- write to the VM state rather than the virtual disk\n"
  633: " -p, -- use bdrv_pwrite to write the file\n"
  634: " -P, -- use different pattern to fill file\n"
  635: " -C, -- report statistics in a machine parsable format\n"
  636: " -q, -- quiet mode, do not show I/O statistics\n"
  637: "\n");
  638: }
  639: 
  640: static int write_f(int argc, char **argv);
  641: 
  642: static const cmdinfo_t write_cmd = {
  643: 	.name		= "write",
  644: 	.altname	= "w",
  645: 	.cfunc		= write_f,
  646: 	.argmin		= 2,
  647: 	.argmax		= -1,
  648: 	.args		= "[-abCpq] [-P pattern ] off len",
  649: 	.oneline	= "writes a number of bytes at a specified offset",
  650: 	.help		= write_help,
  651: };
  652: 
  653: static int
  654: write_f(int argc, char **argv)
  655: {
  656: 	struct timeval t1, t2;
  657: 	int Cflag = 0, pflag = 0, qflag = 0, bflag = 0;
  658: 	int c, cnt;
  659: 	char *buf;
  660: 	int64_t offset;
  661: 	int count;
  662:         /* Some compilers get confused and warn if this is not initialized.  */
  663:         int total = 0;
  664: 	int pattern = 0xcd;
  665: 
  666: 	while ((c = getopt(argc, argv, "bCpP:q")) != EOF) {
  667: 		switch (c) {
  668: 		case 'b':
  669: 			bflag = 1;
  670: 			break;
  671: 		case 'C':
  672: 			Cflag = 1;
  673: 			break;
  674: 		case 'p':
  675: 			pflag = 1;
  676: 			break;
  677: 		case 'P':
  678: 			pattern = parse_pattern(optarg);
  679: 			if (pattern < 0)
  680: 				return 0;
  681: 			break;
  682: 		case 'q':
  683: 			qflag = 1;
  684: 			break;
  685: 		default:
  686: 			return command_usage(&write_cmd);
  687: 		}
  688: 	}
  689: 
  690: 	if (optind != argc - 2)
  691: 		return command_usage(&write_cmd);
  692: 
  693: 	if (bflag && pflag) {
  694: 		printf("-b and -p cannot be specified at the same time\n");
  695: 		return 0;
  696: 	}
  697: 
  698: 	offset = cvtnum(argv[optind]);
  699: 	if (offset < 0) {
  700: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  701: 		return 0;
  702: 	}
  703: 
  704: 	optind++;
  705: 	count = cvtnum(argv[optind]);
  706: 	if (count < 0) {
  707: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  708: 		return 0;
  709: 	}
  710: 
  711: 	if (!pflag) {
  712: 		if (offset & 0x1ff) {
  713:                         printf("offset %" PRId64 " is not sector aligned\n",
  714:                                offset);
  715: 			return 0;
  716: 		}
  717: 
  718: 		if (count & 0x1ff) {
  719: 			printf("count %d is not sector aligned\n",
  720: 				count);
  721: 			return 0;
  722: 		}
  723: 	}
  724: 
  725: 	buf = qemu_io_alloc(count, pattern);
  726: 
  727: 	gettimeofday(&t1, NULL);
  728: 	if (pflag)
  729: 		cnt = do_pwrite(buf, offset, count, &total);
  730: 	else if (bflag)
  731: 		cnt = do_save_vmstate(buf, offset, count, &total);
  732: 	else
  733: 		cnt = do_write(buf, offset, count, &total);
  734: 	gettimeofday(&t2, NULL);
  735: 
  736: 	if (cnt < 0) {
  737: 		printf("write failed: %s\n", strerror(-cnt));
  738: 		goto out;
  739: 	}
  740: 
  741: 	if (qflag)
  742: 		goto out;
  743: 
  744: 	/* Finally, report back -- -C gives a parsable format */
  745: 	t2 = tsub(t2, t1);
  746: 	print_report("wrote", &t2, offset, count, total, cnt, Cflag);
  747: 
  748: out:
  749: 	qemu_io_free(buf);
  750: 
  751: 	return 0;
  752: }
  753: 
  754: static void
  755: writev_help(void)
  756: {
  757: 	printf(
  758: "\n"
  759: " writes a range of bytes from the given offset source from multiple buffers\n"
  760: "\n"
  761: " Example:\n"
  762: " 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
  763: "\n"
  764: " Writes into a segment of the currently open file, using a buffer\n"
  765: " filled with a set pattern (0xcdcdcdcd).\n"
  766: " -P, -- use different pattern to fill file\n"
  767: " -C, -- report statistics in a machine parsable format\n"
  768: " -q, -- quiet mode, do not show I/O statistics\n"
  769: "\n");
  770: }
  771: 
  772: static int writev_f(int argc, char **argv);
  773: 
  774: static const cmdinfo_t writev_cmd = {
  775: 	.name		= "writev",
  776: 	.cfunc		= writev_f,
  777: 	.argmin		= 2,
  778: 	.argmax		= -1,
  779: 	.args		= "[-Cq] [-P pattern ] off len [len..]",
  780: 	.oneline	= "writes a number of bytes at a specified offset",
  781: 	.help		= writev_help,
  782: };
  783: 
  784: static int
  785: writev_f(int argc, char **argv)
  786: {
  787: 	struct timeval t1, t2;
  788: 	int Cflag = 0, qflag = 0;
  789: 	int c, cnt;
  790: 	char *buf;
  791: 	int64_t offset;
  792:         /* Some compilers get confused and warn if this is not initialized.  */
  793:         int total = 0;
  794: 	int nr_iov;
  795: 	int pattern = 0xcd;
  796: 	QEMUIOVector qiov;
  797: 
  798: 	while ((c = getopt(argc, argv, "CqP:")) != EOF) {
  799: 		switch (c) {
  800: 		case 'C':
  801: 			Cflag = 1;
  802: 			break;
  803: 		case 'q':
  804: 			qflag = 1;
  805: 			break;
  806: 		case 'P':
  807: 			pattern = parse_pattern(optarg);
  808: 			if (pattern < 0)
  809: 				return 0;
  810: 			break;
  811: 		default:
  812: 			return command_usage(&writev_cmd);
  813: 		}
  814: 	}
  815: 
  816: 	if (optind > argc - 2)
  817: 		return command_usage(&writev_cmd);
  818: 
  819: 	offset = cvtnum(argv[optind]);
  820: 	if (offset < 0) {
  821: 		printf("non-numeric length argument -- %s\n", argv[optind]);
  822: 		return 0;
  823: 	}
  824: 	optind++;
  825: 
  826: 	if (offset & 0x1ff) {
  827:                 printf("offset %" PRId64 " is not sector aligned\n",
  828:                        offset);
  829: 		return 0;
  830: 	}
  831: 
  832: 	nr_iov = argc - optind;
  833: 	buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern);
  834: 
  835: 	gettimeofday(&t1, NULL);
  836: 	cnt = do_aio_writev(&qiov, offset, &total);
  837: 	gettimeofday(&t2, NULL);
  838: 
  839: 	if (cnt < 0) {
  840: 		printf("writev failed: %s\n", strerror(-cnt));
  841: 		goto out;
  842: 	}
  843: 
  844: 	if (qflag)
  845: 		goto out;
  846: 
  847: 	/* Finally, report back -- -C gives a parsable format */
  848: 	t2 = tsub(t2, t1);
  849: 	print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
  850: out:
  851: 	qemu_io_free(buf);
  852: 	return 0;
  853: }
  854: 
  855: static void
  856: multiwrite_help(void)
  857: {
  858: 	printf(
  859: "\n"
  860: " writes a range of bytes from the given offset source from multiple buffers,\n"
  861: " in a batch of requests that may be merged by qemu\n"
  862: "\n"
  863: " Example:\n"
  864: " 'multiwrite 512 1k 1k ; 4k 1k' \n"
  865: "  writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"
  866: "\n"
  867: " Writes into a segment of the currently open file, using a buffer\n"
  868: " filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"
  869: " by one for each request contained in the multiwrite command.\n"
  870: " -P, -- use different pattern to fill file\n"
  871: " -C, -- report statistics in a machine parsable format\n"
  872: " -q, -- quiet mode, do not show I/O statistics\n"
  873: "\n");
  874: }
  875: 
  876: static int multiwrite_f(int argc, char **argv);
  877: 
  878: static const cmdinfo_t multiwrite_cmd = {
  879: 	.name		= "multiwrite",
  880: 	.cfunc		= multiwrite_f,
  881: 	.argmin		= 2,
  882: 	.argmax		= -1,
  883: 	.args		= "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",
  884: 	.oneline	= "issues multiple write requests at once",
  885: 	.help		= multiwrite_help,
  886: };
  887: 
  888: static int
  889: multiwrite_f(int argc, char **argv)
  890: {
  891: 	struct timeval t1, t2;
  892: 	int Cflag = 0, qflag = 0;
  893: 	int c, cnt;
  894: 	char **buf;
  895: 	int64_t offset, first_offset = 0;
  896: 	/* Some compilers get confused and warn if this is not initialized.  */
  897: 	int total = 0;
  898: 	int nr_iov;
  899: 	int nr_reqs;
  900: 	int pattern = 0xcd;
  901: 	QEMUIOVector *qiovs;
  902: 	int i;
  903: 	BlockRequest *reqs;
  904: 
  905: 	while ((c = getopt(argc, argv, "CqP:")) != EOF) {
  906: 		switch (c) {
  907: 		case 'C':
  908: 			Cflag = 1;
  909: 			break;
  910: 		case 'q':
  911: 			qflag = 1;
  912: 			break;
  913: 		case 'P':
  914: 			pattern = parse_pattern(optarg);
  915: 			if (pattern < 0)
  916: 				return 0;
  917: 			break;
  918: 		default:
  919: 			return command_usage(&writev_cmd);
  920: 		}
  921: 	}
  922: 
  923: 	if (optind > argc - 2)
  924: 		return command_usage(&writev_cmd);
  925: 
  926: 	nr_reqs = 1;
  927: 	for (i = optind; i < argc; i++) {
  928: 		if (!strcmp(argv[i], ";")) {
  929: 			nr_reqs++;
  930: 		}
  931: 	}
  932: 
  933: 	reqs = qemu_malloc(nr_reqs * sizeof(*reqs));
  934: 	buf = qemu_malloc(nr_reqs * sizeof(*buf));
  935: 	qiovs = qemu_malloc(nr_reqs * sizeof(*qiovs));
  936: 
  937: 	for (i = 0; i < nr_reqs; i++) {
  938: 		int j;
  939: 
  940: 		/* Read the offset of the request */
  941: 		offset = cvtnum(argv[optind]);
  942: 		if (offset < 0) {
  943: 			printf("non-numeric offset argument -- %s\n", argv[optind]);
  944: 			return 0;
  945: 		}
  946: 		optind++;
  947: 
  948: 		if (offset & 0x1ff) {
  949: 			printf("offset %lld is not sector aligned\n",
  950: 				(long long)offset);
  951: 			return 0;
  952: 		}
  953: 
  954:         if (i == 0) {
  955:             first_offset = offset;
  956:         }
  957: 
  958: 		/* Read lengths for qiov entries */
  959: 		for (j = optind; j < argc; j++) {
  960: 			if (!strcmp(argv[j], ";")) {
  961: 				break;
  962: 			}
  963: 		}
  964: 
  965: 		nr_iov = j - optind;
  966: 
  967: 		/* Build request */
  968: 		reqs[i].qiov = &qiovs[i];
  969: 		buf[i] = create_iovec(reqs[i].qiov, &argv[optind], nr_iov, pattern);
  970: 		reqs[i].sector = offset >> 9;
  971: 		reqs[i].nb_sectors = reqs[i].qiov->size >> 9;
  972: 
  973: 		optind = j + 1;
  974: 
  975: 		offset += reqs[i].qiov->size;
  976: 		pattern++;
  977: 	}
  978: 
  979: 	gettimeofday(&t1, NULL);
  980: 	cnt = do_aio_multiwrite(reqs, nr_reqs, &total);
  981: 	gettimeofday(&t2, NULL);
  982: 
  983: 	if (cnt < 0) {
  984: 		printf("aio_multiwrite failed: %s\n", strerror(-cnt));
  985: 		goto out;
  986: 	}
  987: 
  988: 	if (qflag)
  989: 		goto out;
  990: 
  991: 	/* Finally, report back -- -C gives a parsable format */
  992: 	t2 = tsub(t2, t1);
  993: 	print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);
  994: out:
  995: 	for (i = 0; i < nr_reqs; i++) {
  996: 		qemu_io_free(buf[i]);
  997: 		qemu_iovec_destroy(&qiovs[i]);
  998: 	}
  999: 	qemu_free(buf);
 1000: 	qemu_free(reqs);
 1001: 	qemu_free(qiovs);
 1002: 	return 0;
 1003: }
 1004: 
 1005: struct aio_ctx {
 1006: 	QEMUIOVector qiov;
 1007: 	int64_t offset;
 1008: 	char *buf;
 1009: 	int qflag;
 1010: 	int vflag;
 1011: 	int Cflag;
 1012: 	int Pflag;
 1013: 	int pattern;
 1014: 	struct timeval t1;
 1015: };
 1016: 
 1017: static void
 1018: aio_write_done(void *opaque, int ret)
 1019: {
 1020: 	struct aio_ctx *ctx = opaque;
 1021: 	struct timeval t2;
 1022: 
 1023: 	gettimeofday(&t2, NULL);
 1024: 
 1025: 
 1026: 	if (ret < 0) {
 1027: 		printf("aio_write failed: %s\n", strerror(-ret));
 1028: 		goto out;
 1029: 	}
 1030: 
 1031: 	if (ctx->qflag) {
 1032: 		goto out;
 1033: 	}
 1034: 
 1035: 	/* Finally, report back -- -C gives a parsable format */
 1036: 	t2 = tsub(t2, ctx->t1);
 1037: 	print_report("wrote", &t2, ctx->offset, ctx->qiov.size,
 1038: 		     ctx->qiov.size, 1, ctx->Cflag);
 1039: out:
 1040: 	qemu_io_free(ctx->buf);
 1041: 	free(ctx);
 1042: }
 1043: 
 1044: static void
 1045: aio_read_done(void *opaque, int ret)
 1046: {
 1047: 	struct aio_ctx *ctx = opaque;
 1048: 	struct timeval t2;
 1049: 
 1050: 	gettimeofday(&t2, NULL);
 1051: 
 1052: 	if (ret < 0) {
 1053: 		printf("readv failed: %s\n", strerror(-ret));
 1054: 		goto out;
 1055: 	}
 1056: 
 1057: 	if (ctx->Pflag) {
 1058: 		void *cmp_buf = malloc(ctx->qiov.size);
 1059: 
 1060: 		memset(cmp_buf, ctx->pattern, ctx->qiov.size);
 1061: 		if (memcmp(ctx->buf, cmp_buf, ctx->qiov.size)) {
 1062: 			printf("Pattern verification failed at offset %"
 1063:                                PRId64 ", %zd bytes\n",
 1064:                                ctx->offset, ctx->qiov.size);
 1065: 		}
 1066: 		free(cmp_buf);
 1067: 	}
 1068: 
 1069: 	if (ctx->qflag) {
 1070: 		goto out;
 1071: 	}
 1072: 
 1073: 	if (ctx->vflag) {
 1074: 		dump_buffer(ctx->buf, ctx->offset, ctx->qiov.size);
 1075: 	}
 1076: 
 1077: 	/* Finally, report back -- -C gives a parsable format */
 1078: 	t2 = tsub(t2, ctx->t1);
 1079: 	print_report("read", &t2, ctx->offset, ctx->qiov.size,
 1080: 		     ctx->qiov.size, 1, ctx->Cflag);
 1081: out:
 1082: 	qemu_io_free(ctx->buf);
 1083: 	free(ctx);
 1084: }
 1085: 
 1086: static void
 1087: aio_read_help(void)
 1088: {
 1089: 	printf(
 1090: "\n"
 1091: " asynchronously reads a range of bytes from the given offset\n"
 1092: "\n"
 1093: " Example:\n"
 1094: " 'aio_read -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
 1095: "\n"
 1096: " Reads a segment of the currently open file, optionally dumping it to the\n"
 1097: " standard output stream (with -v option) for subsequent inspection.\n"
 1098: " The read is performed asynchronously and the aio_flush command must be\n"
 1099: " used to ensure all outstanding aio requests have been completed\n"
 1100: " -C, -- report statistics in a machine parsable format\n"
 1101: " -P, -- use a pattern to verify read data\n"
 1102: " -v, -- dump buffer to standard output\n"
 1103: " -q, -- quiet mode, do not show I/O statistics\n"
 1104: "\n");
 1105: }
 1106: 
 1107: static int aio_read_f(int argc, char **argv);
 1108: 
 1109: static const cmdinfo_t aio_read_cmd = {
 1110: 	.name		= "aio_read",
 1111: 	.cfunc		= aio_read_f,
 1112: 	.argmin		= 2,
 1113: 	.argmax		= -1,
 1114: 	.args		= "[-Cqv] [-P pattern ] off len [len..]",
 1115: 	.oneline	= "asynchronously reads a number of bytes",
 1116: 	.help		= aio_read_help,
 1117: };
 1118: 
 1119: static int
 1120: aio_read_f(int argc, char **argv)
 1121: {
 1122: 	int nr_iov, c;
 1123: 	struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
 1124: 	BlockDriverAIOCB *acb;
 1125: 
 1126: 	while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
 1127: 		switch (c) {
 1128: 		case 'C':
 1129: 			ctx->Cflag = 1;
 1130: 			break;
 1131: 		case 'P':
 1132: 			ctx->Pflag = 1;
 1133: 			ctx->pattern = parse_pattern(optarg);
 1134: 			if (ctx->pattern < 0) {
 1135:                                 free(ctx);
 1136: 				return 0;
 1137:                         }
 1138: 			break;
 1139: 		case 'q':
 1140: 			ctx->qflag = 1;
 1141: 			break;
 1142: 		case 'v':
 1143: 			ctx->vflag = 1;
 1144: 			break;
 1145: 		default:
 1146: 			free(ctx);
 1147: 			return command_usage(&aio_read_cmd);
 1148: 		}
 1149: 	}
 1150: 
 1151: 	if (optind > argc - 2) {
 1152: 		free(ctx);
 1153: 		return command_usage(&aio_read_cmd);
 1154: 	}
 1155: 
 1156: 	ctx->offset = cvtnum(argv[optind]);
 1157: 	if (ctx->offset < 0) {
 1158: 		printf("non-numeric length argument -- %s\n", argv[optind]);
 1159: 		free(ctx);
 1160: 		return 0;
 1161: 	}
 1162: 	optind++;
 1163: 
 1164: 	if (ctx->offset & 0x1ff) {
 1165: 		printf("offset %" PRId64 " is not sector aligned\n",
 1166:                        ctx->offset);
 1167: 		free(ctx);
 1168: 		return 0;
 1169: 	}
 1170: 
 1171: 	nr_iov = argc - optind;
 1172: 	ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab);
 1173: 
 1174: 	gettimeofday(&ctx->t1, NULL);
 1175: 	acb = bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
 1176: 			      ctx->qiov.size >> 9, aio_read_done, ctx);
 1177: 	if (!acb) {
 1178: 		free(ctx->buf);
 1179: 		free(ctx);
 1180: 		return -EIO;
 1181: 	}
 1182: 
 1183: 	return 0;
 1184: }
 1185: 
 1186: static void
 1187: aio_write_help(void)
 1188: {
 1189: 	printf(
 1190: "\n"
 1191: " asynchronously writes a range of bytes from the given offset source \n"
 1192: " from multiple buffers\n"
 1193: "\n"
 1194: " Example:\n"
 1195: " 'aio_write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
 1196: "\n"
 1197: " Writes into a segment of the currently open file, using a buffer\n"
 1198: " filled with a set pattern (0xcdcdcdcd).\n"
 1199: " The write is performed asynchronously and the aio_flush command must be\n"
 1200: " used to ensure all outstanding aio requests have been completed\n"
 1201: " -P, -- use different pattern to fill file\n"
 1202: " -C, -- report statistics in a machine parsable format\n"
 1203: " -q, -- quiet mode, do not show I/O statistics\n"
 1204: "\n");
 1205: }
 1206: 
 1207: static int aio_write_f(int argc, char **argv);
 1208: 
 1209: static const cmdinfo_t aio_write_cmd = {
 1210: 	.name		= "aio_write",
 1211: 	.cfunc		= aio_write_f,
 1212: 	.argmin		= 2,
 1213: 	.argmax		= -1,
 1214: 	.args		= "[-Cq] [-P pattern ] off len [len..]",
 1215: 	.oneline	= "asynchronously writes a number of bytes",
 1216: 	.help		= aio_write_help,
 1217: };
 1218: 
 1219: static int
 1220: aio_write_f(int argc, char **argv)
 1221: {
 1222: 	int nr_iov, c;
 1223: 	int pattern = 0xcd;
 1224: 	struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
 1225: 	BlockDriverAIOCB *acb;
 1226: 
 1227: 	while ((c = getopt(argc, argv, "CqP:")) != EOF) {
 1228: 		switch (c) {
 1229: 		case 'C':
 1230: 			ctx->Cflag = 1;
 1231: 			break;
 1232: 		case 'q':
 1233: 			ctx->qflag = 1;
 1234: 			break;
 1235: 		case 'P':
 1236: 			pattern = parse_pattern(optarg);
 1237: 			if (pattern < 0)
 1238: 				return 0;
 1239: 			break;
 1240: 		default:
 1241: 			free(ctx);
 1242: 			return command_usage(&aio_write_cmd);
 1243: 		}
 1244: 	}
 1245: 
 1246: 	if (optind > argc - 2) {
 1247: 		free(ctx);
 1248: 		return command_usage(&aio_write_cmd);
 1249: 	}
 1250: 
 1251: 	ctx->offset = cvtnum(argv[optind]);
 1252: 	if (ctx->offset < 0) {
 1253: 		printf("non-numeric length argument -- %s\n", argv[optind]);
 1254: 		free(ctx);
 1255: 		return 0;
 1256: 	}
 1257: 	optind++;
 1258: 
 1259: 	if (ctx->offset & 0x1ff) {
 1260: 		printf("offset %" PRId64 " is not sector aligned\n",
 1261:                        ctx->offset);
 1262: 		free(ctx);
 1263: 		return 0;
 1264: 	}
 1265: 
 1266: 	nr_iov = argc - optind;
 1267: 	ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
 1268: 
 1269: 	gettimeofday(&ctx->t1, NULL);
 1270: 	acb = bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
 1271: 			      ctx->qiov.size >> 9, aio_write_done, ctx);
 1272: 	if (!acb) {
 1273: 		free(ctx->buf);
 1274: 		free(ctx);
 1275: 		return -EIO;
 1276: 	}
 1277: 
 1278: 	return 0;
 1279: }
 1280: 
 1281: static int
 1282: aio_flush_f(int argc, char **argv)
 1283: {
 1284: 	qemu_aio_flush();
 1285: 	return 0;
 1286: }
 1287: 
 1288: static const cmdinfo_t aio_flush_cmd = {
 1289: 	.name		= "aio_flush",
 1290: 	.cfunc		= aio_flush_f,
 1291: 	.oneline	= "completes all outstanding aio requests"
 1292: };
 1293: 
 1294: static int
 1295: flush_f(int argc, char **argv)
 1296: {
 1297: 	bdrv_flush(bs);
 1298: 	return 0;
 1299: }
 1300: 
 1301: static const cmdinfo_t flush_cmd = {
 1302: 	.name		= "flush",
 1303: 	.altname	= "f",
 1304: 	.cfunc		= flush_f,
 1305: 	.oneline	= "flush all in-core file state to disk",
 1306: };
 1307: 
 1308: static int
 1309: truncate_f(int argc, char **argv)
 1310: {
 1311: 	int64_t offset;
 1312: 	int ret;
 1313: 
 1314: 	offset = cvtnum(argv[1]);
 1315: 	if (offset < 0) {
 1316: 		printf("non-numeric truncate argument -- %s\n", argv[1]);
 1317: 		return 0;
 1318: 	}
 1319: 
 1320: 	ret = bdrv_truncate(bs, offset);
 1321: 	if (ret < 0) {
 1322: 		printf("truncate: %s\n", strerror(-ret));
 1323: 		return 0;
 1324: 	}
 1325: 
 1326: 	return 0;
 1327: }
 1328: 
 1329: static const cmdinfo_t truncate_cmd = {
 1330: 	.name		= "truncate",
 1331: 	.altname	= "t",
 1332: 	.cfunc		= truncate_f,
 1333: 	.argmin		= 1,
 1334: 	.argmax		= 1,
 1335: 	.args		= "off",
 1336: 	.oneline	= "truncates the current file at the given offset",
 1337: };
 1338: 
 1339: static int
 1340: length_f(int argc, char **argv)
 1341: {
 1342:         int64_t size;
 1343: 	char s1[64];
 1344: 
 1345: 	size = bdrv_getlength(bs);
 1346: 	if (size < 0) {
 1347: 		printf("getlength: %s\n", strerror(-size));
 1348: 		return 0;
 1349: 	}
 1350: 
 1351: 	cvtstr(size, s1, sizeof(s1));
 1352: 	printf("%s\n", s1);
 1353: 	return 0;
 1354: }
 1355: 
 1356: 
 1357: static const cmdinfo_t length_cmd = {
 1358: 	.name		= "length",
 1359: 	.altname	= "l",
 1360: 	.cfunc		= length_f,
 1361: 	.oneline	= "gets the length of the current file",
 1362: };
 1363: 
 1364: 
 1365: static int
 1366: info_f(int argc, char **argv)
 1367: {
 1368: 	BlockDriverInfo bdi;
 1369: 	char s1[64], s2[64];
 1370: 	int ret;
 1371: 
 1372: 	if (bs->drv && bs->drv->format_name)
 1373: 		printf("format name: %s\n", bs->drv->format_name);
 1374: 	if (bs->drv && bs->drv->protocol_name)
 1375: 		printf("format name: %s\n", bs->drv->protocol_name);
 1376: 
 1377: 	ret = bdrv_get_info(bs, &bdi);
 1378: 	if (ret)
 1379: 		return 0;
 1380: 
 1381: 	cvtstr(bdi.cluster_size, s1, sizeof(s1));
 1382: 	cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
 1383: 
 1384: 	printf("cluster size: %s\n", s1);
 1385: 	printf("vm state offset: %s\n", s2);
 1386: 
 1387: 	return 0;
 1388: }
 1389: 
 1390: 
 1391: 
 1392: static const cmdinfo_t info_cmd = {
 1393: 	.name		= "info",
 1394: 	.altname	= "i",
 1395: 	.cfunc		= info_f,
 1396: 	.oneline	= "prints information about the current file",
 1397: };
 1398: 
 1399: static void
 1400: discard_help(void)
 1401: {
 1402: 	printf(
 1403: "\n"
 1404: " discards a range of bytes from the given offset\n"
 1405: "\n"
 1406: " Example:\n"
 1407: " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
 1408: "\n"
 1409: " Discards a segment of the currently open file.\n"
 1410: " -C, -- report statistics in a machine parsable format\n"
 1411: " -q, -- quiet mode, do not show I/O statistics\n"
 1412: "\n");
 1413: }
 1414: 
 1415: static int discard_f(int argc, char **argv);
 1416: 
 1417: static const cmdinfo_t discard_cmd = {
 1418: 	.name		= "discard",
 1419: 	.altname	= "d",
 1420: 	.cfunc		= discard_f,
 1421: 	.argmin		= 2,
 1422: 	.argmax		= -1,
 1423: 	.args		= "[-Cq] off len",
 1424: 	.oneline	= "discards a number of bytes at a specified offset",
 1425: 	.help		= discard_help,
 1426: };
 1427: 
 1428: static int
 1429: discard_f(int argc, char **argv)
 1430: {
 1431: 	struct timeval t1, t2;
 1432: 	int Cflag = 0, qflag = 0;
 1433: 	int c, ret;
 1434: 	int64_t offset;
 1435: 	int count;
 1436: 
 1437: 	while ((c = getopt(argc, argv, "Cq")) != EOF) {
 1438: 		switch (c) {
 1439: 		case 'C':
 1440: 			Cflag = 1;
 1441: 			break;
 1442: 		case 'q':
 1443: 			qflag = 1;
 1444: 			break;
 1445: 		default:
 1446: 			return command_usage(&discard_cmd);
 1447: 		}
 1448: 	}
 1449: 
 1450: 	if (optind != argc - 2) {
 1451: 		return command_usage(&discard_cmd);
 1452: 	}
 1453: 
 1454: 	offset = cvtnum(argv[optind]);
 1455: 	if (offset < 0) {
 1456: 		printf("non-numeric length argument -- %s\n", argv[optind]);
 1457: 		return 0;
 1458: 	}
 1459: 
 1460: 	optind++;
 1461: 	count = cvtnum(argv[optind]);
 1462: 	if (count < 0) {
 1463: 		printf("non-numeric length argument -- %s\n", argv[optind]);
 1464: 		return 0;
 1465: 	}
 1466: 
 1467: 	gettimeofday(&t1, NULL);
 1468: 	ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS, count >> BDRV_SECTOR_BITS);
 1469: 	gettimeofday(&t2, NULL);
 1470: 
 1471: 	if (ret < 0) {
 1472: 		printf("discard failed: %s\n", strerror(-ret));
 1473: 		goto out;
 1474: 	}
 1475: 
 1476: 	/* Finally, report back -- -C gives a parsable format */
 1477: 	if (!qflag) {
 1478: 		t2 = tsub(t2, t1);
 1479: 		print_report("discard", &t2, offset, count, count, 1, Cflag);
 1480: 	}
 1481: 
 1482: out:
 1483: 	return 0;
 1484: }
 1485: 
 1486: static int
 1487: alloc_f(int argc, char **argv)
 1488: {
 1489: 	int64_t offset;
 1490: 	int nb_sectors, remaining;
 1491: 	char s1[64];
 1492: 	int num, sum_alloc;
 1493: 	int ret;
 1494: 
 1495: 	offset = cvtnum(argv[1]);
 1496: 	if (offset & 0x1ff) {
 1497:                 printf("offset %" PRId64 " is not sector aligned\n",
 1498:                        offset);
 1499: 		return 0;
 1500: 	}
 1501: 
 1502: 	if (argc == 3)
 1503: 		nb_sectors = cvtnum(argv[2]);
 1504: 	else
 1505: 		nb_sectors = 1;
 1506: 
 1507: 	remaining = nb_sectors;
 1508: 	sum_alloc = 0;
 1509: 	while (remaining) {
 1510: 		ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
 1511: 		remaining -= num;
 1512: 		if (ret) {
 1513: 			sum_alloc += num;
 1514: 		}
 1515: 	}
 1516: 
 1517: 	cvtstr(offset, s1, sizeof(s1));
 1518: 
 1519: 	printf("%d/%d sectors allocated at offset %s\n",
 1520: 	       sum_alloc, nb_sectors, s1);
 1521: 	return 0;
 1522: }
 1523: 
 1524: static const cmdinfo_t alloc_cmd = {
 1525: 	.name		= "alloc",
 1526: 	.altname	= "a",
 1527: 	.argmin		= 1,
 1528: 	.argmax		= 2,
 1529: 	.cfunc		= alloc_f,
 1530: 	.args		= "off [sectors]",
 1531: 	.oneline	= "checks if a sector is present in the file",
 1532: };
 1533: 
 1534: static int
 1535: map_f(int argc, char **argv)
 1536: {
 1537: 	int64_t offset;
 1538: 	int64_t nb_sectors;
 1539: 	char s1[64];
 1540: 	int num, num_checked;
 1541: 	int ret;
 1542: 	const char *retstr;
 1543: 
 1544: 	offset = 0;
 1545: 	nb_sectors = bs->total_sectors;
 1546: 
 1547: 	do {
 1548: 		num_checked = MIN(nb_sectors, INT_MAX);
 1549: 		ret = bdrv_is_allocated(bs, offset, num_checked, &num);
 1550: 		retstr = ret ? "    allocated" : "not allocated";
 1551: 		cvtstr(offset << 9ULL, s1, sizeof(s1));
 1552: 		printf("[% 24" PRId64 "] % 8d/% 8d sectors %s at offset %s (%d)\n",
 1553: 				offset << 9ULL, num, num_checked, retstr, s1, ret);
 1554: 
 1555: 		offset += num;
 1556: 		nb_sectors -= num;
 1557: 	} while(offset < bs->total_sectors);
 1558: 
 1559: 	return 0;
 1560: }
 1561: 
 1562: static const cmdinfo_t map_cmd = {
 1563:        .name           = "map",
 1564:        .argmin         = 0,
 1565:        .argmax         = 0,
 1566:        .cfunc          = map_f,
 1567:        .args           = "",
 1568:        .oneline        = "prints the allocated areas of a file",
 1569: };
 1570: 
 1571: 
 1572: static int
 1573: close_f(int argc, char **argv)
 1574: {
 1575: 	bdrv_close(bs);
 1576: 	bs = NULL;
 1577: 	return 0;
 1578: }
 1579: 
 1580: static const cmdinfo_t close_cmd = {
 1581: 	.name		= "close",
 1582: 	.altname	= "c",
 1583: 	.cfunc		= close_f,
 1584: 	.oneline	= "close the current open file",
 1585: };
 1586: 
 1587: static int openfile(char *name, int flags, int growable)
 1588: {
 1589: 	if (bs) {
 1590: 		fprintf(stderr, "file open already, try 'help close'\n");
 1591: 		return 1;
 1592: 	}
 1593: 
 1594: 	if (growable) {
 1595: 		if (bdrv_file_open(&bs, name, flags)) {
 1596: 			fprintf(stderr, "%s: can't open device %s\n", progname, name);
 1597: 			return 1;
 1598: 		}
 1599: 	} else {
 1600: 		bs = bdrv_new("hda");
 1601: 
 1602: 		if (bdrv_open(bs, name, flags, NULL) < 0) {
 1603: 			fprintf(stderr, "%s: can't open device %s\n", progname, name);
 1604: 			bs = NULL;
 1605: 			return 1;
 1606: 		}
 1607: 	}
 1608: 
 1609: 	return 0;
 1610: }
 1611: 
 1612: static void
 1613: open_help(void)
 1614: {
 1615: 	printf(
 1616: "\n"
 1617: " opens a new file in the requested mode\n"
 1618: "\n"
 1619: " Example:\n"
 1620: " 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
 1621: "\n"
 1622: " Opens a file for subsequent use by all of the other qemu-io commands.\n"
 1623: " -r, -- open file read-only\n"
 1624: " -s, -- use snapshot file\n"
 1625: " -n, -- disable host cache\n"
 1626: " -g, -- allow file to grow (only applies to protocols)"
 1627: "\n");
 1628: }
 1629: 
 1630: static int open_f(int argc, char **argv);
 1631: 
 1632: static const cmdinfo_t open_cmd = {
 1633: 	.name		= "open",
 1634: 	.altname	= "o",
 1635: 	.cfunc		= open_f,
 1636: 	.argmin		= 1,
 1637: 	.argmax		= -1,
 1638: 	.flags		= CMD_NOFILE_OK,
 1639: 	.args		= "[-Crsn] [path]",
 1640: 	.oneline	= "open the file specified by path",
 1641: 	.help		= open_help,
 1642: };
 1643: 
 1644: static int
 1645: open_f(int argc, char **argv)
 1646: {
 1647: 	int flags = 0;
 1648: 	int readonly = 0;
 1649: 	int growable = 0;
 1650: 	int c;
 1651: 
 1652: 	while ((c = getopt(argc, argv, "snrg")) != EOF) {
 1653: 		switch (c) {
 1654: 		case 's':
 1655: 			flags |= BDRV_O_SNAPSHOT;
 1656: 			break;
 1657: 		case 'n':
 1658: 			flags |= BDRV_O_NOCACHE;
 1659: 			break;
 1660: 		case 'r':
 1661: 			readonly = 1;
 1662: 			break;
 1663: 		case 'g':
 1664: 			growable = 1;
 1665: 			break;
 1666: 		default:
 1667: 			return command_usage(&open_cmd);
 1668: 		}
 1669: 	}
 1670: 
 1671: 	if (!readonly) {
 1672:             flags |= BDRV_O_RDWR;
 1673:         }
 1674: 
 1675: 	if (optind != argc - 1)
 1676: 		return command_usage(&open_cmd);
 1677: 
 1678: 	return openfile(argv[optind], flags, growable);
 1679: }
 1680: 
 1681: static int
 1682: init_args_command(
 1683:         int     index)
 1684: {
 1685: 	/* only one device allowed so far */
 1686: 	if (index >= 1)
 1687: 		return 0;
 1688: 	return ++index;
 1689: }
 1690: 
 1691: static int
 1692: init_check_command(
 1693: 	const cmdinfo_t *ct)
 1694: {
 1695: 	if (ct->flags & CMD_FLAG_GLOBAL)
 1696: 		return 1;
 1697: 	if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
 1698: 		fprintf(stderr, "no file open, try 'help open'\n");
 1699: 		return 0;
 1700: 	}
 1701: 	return 1;
 1702: }
 1703: 
 1704: static void usage(const char *name)
 1705: {
 1706: 	printf(
 1707: "Usage: %s [-h] [-V] [-rsnm] [-c cmd] ... [file]\n"
 1708: "QEMU Disk exerciser\n"
 1709: "\n"
 1710: "  -c, --cmd            command to execute\n"
 1711: "  -r, --read-only      export read-only\n"
 1712: "  -s, --snapshot       use snapshot file\n"
 1713: "  -n, --nocache        disable host cache\n"
 1714: "  -g, --growable       allow file to grow (only applies to protocols)\n"
 1715: "  -m, --misalign       misalign allocations for O_DIRECT\n"
 1716: "  -k, --native-aio     use kernel AIO implementation (on Linux only)\n"
 1717: "  -h, --help           display this help and exit\n"
 1718: "  -V, --version        output version information and exit\n"
 1719: "\n",
 1720: 	name);
 1721: }
 1722: 
 1723: 
 1724: int main(int argc, char **argv)
 1725: {
 1726: 	int readonly = 0;
 1727: 	int growable = 0;
 1728: 	const char *sopt = "hVc:rsnmgk";
 1729:         const struct option lopt[] = {
 1730: 		{ "help", 0, NULL, 'h' },
 1731: 		{ "version", 0, NULL, 'V' },
 1732: 		{ "offset", 1, NULL, 'o' },
 1733: 		{ "cmd", 1, NULL, 'c' },
 1734: 		{ "read-only", 0, NULL, 'r' },
 1735: 		{ "snapshot", 0, NULL, 's' },
 1736: 		{ "nocache", 0, NULL, 'n' },
 1737: 		{ "misalign", 0, NULL, 'm' },
 1738: 		{ "growable", 0, NULL, 'g' },
 1739: 		{ "native-aio", 0, NULL, 'k' },
 1740: 		{ NULL, 0, NULL, 0 }
 1741: 	};
 1742: 	int c;
 1743: 	int opt_index = 0;
 1744: 	int flags = 0;
 1745: 
 1746: 	progname = basename(argv[0]);
 1747: 
 1748: 	while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
 1749: 		switch (c) {
 1750: 		case 's':
 1751: 			flags |= BDRV_O_SNAPSHOT;
 1752: 			break;
 1753: 		case 'n':
 1754: 			flags |= BDRV_O_NOCACHE;
 1755: 			break;
 1756: 		case 'c':
 1757: 			add_user_command(optarg);
 1758: 			break;
 1759: 		case 'r':
 1760: 			readonly = 1;
 1761: 			break;
 1762: 		case 'm':
 1763: 			misalign = 1;
 1764: 			break;
 1765: 		case 'g':
 1766: 			growable = 1;
 1767: 			break;
 1768: 		case 'k':
 1769: 			flags |= BDRV_O_NATIVE_AIO;
 1770: 			break;
 1771: 		case 'V':
 1772: 			printf("%s version %s\n", progname, VERSION);
 1773: 			exit(0);
 1774: 		case 'h':
 1775: 			usage(progname);
 1776: 			exit(0);
 1777: 		default:
 1778: 			usage(progname);
 1779: 			exit(1);
 1780: 		}
 1781: 	}
 1782: 
 1783: 	if ((argc - optind) > 1) {
 1784: 		usage(progname);
 1785: 		exit(1);
 1786: 	}
 1787: 
 1788: 	bdrv_init();
 1789: 
 1790: 	/* initialize commands */
 1791: 	quit_init();
 1792: 	help_init();
 1793: 	add_command(&open_cmd);
 1794: 	add_command(&close_cmd);
 1795: 	add_command(&read_cmd);
 1796: 	add_command(&readv_cmd);
 1797: 	add_command(&write_cmd);
 1798: 	add_command(&writev_cmd);
 1799: 	add_command(&multiwrite_cmd);
 1800: 	add_command(&aio_read_cmd);
 1801: 	add_command(&aio_write_cmd);
 1802: 	add_command(&aio_flush_cmd);
 1803: 	add_command(&flush_cmd);
 1804: 	add_command(&truncate_cmd);
 1805: 	add_command(&length_cmd);
 1806: 	add_command(&info_cmd);
 1807: 	add_command(&discard_cmd);
 1808: 	add_command(&alloc_cmd);
 1809: 	add_command(&map_cmd);
 1810: 
 1811: 	add_args_command(init_args_command);
 1812: 	add_check_command(init_check_command);
 1813: 
 1814: 	/* open the device */
 1815: 	if (!readonly) {
 1816:             flags |= BDRV_O_RDWR;
 1817:         }
 1818: 
 1819: 	if ((argc - optind) == 1)
 1820: 		openfile(argv[optind], flags, growable);
 1821: 	command_loop();
 1822: 
 1823: 	/*
 1824: 	 * Make sure all outstanding requests get flushed the program exits.
 1825: 	 */
 1826: 	qemu_aio_flush();
 1827: 
 1828: 	if (bs)
 1829: 		bdrv_close(bs);
 1830: 	return 0;
 1831: }

unix.superglobalmegacorp.com