* THE SOFTWARE.
*/
#include "qemu/osdep.h"
+#include "qemu-version.h"
#include "qapi/error.h"
#include "qapi-visit.h"
#include "qapi/qmp-output-visitor.h"
#include "qemu/config-file.h"
#include "qemu/option.h"
#include "qemu/error-report.h"
+#include "qemu/log.h"
#include "qom/object_interfaces.h"
#include "sysemu/sysemu.h"
#include "sysemu/block-backend.h"
#include "block/blockjob.h"
#include "block/qapi.h"
#include "crypto/init.h"
+#include "trace/control.h"
#include <getopt.h>
#define QEMU_IMG_VERSION "qemu-img version " QEMU_VERSION QEMU_PKGVERSION \
OPTION_BACKING_CHAIN = 257,
OPTION_OBJECT = 258,
OPTION_IMAGE_OPTS = 259,
+ OPTION_PATTERN = 260,
+ OPTION_FLUSH_INTERVAL = 261,
+ OPTION_NO_DRAIN = 262,
};
typedef enum OutputFormat {
{
const char *help_msg =
QEMU_IMG_VERSION
- "usage: qemu-img command [command options]\n"
+ "usage: qemu-img [standard options] command [command options]\n"
"QEMU disk image utility\n"
"\n"
+ " '-h', '--help' display this help and exit\n"
+ " '-V', '--version' output version information and exit\n"
+ " '-T', '--trace' [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
+ " specify tracing options\n"
+ "\n"
"Command syntax:\n"
#define DEF(option, callback, arg_string) \
" " arg_string "\n"
typedef struct BenchData {
BlockBackend *blk;
uint64_t image_size;
+ bool write;
int bufsize;
+ int step;
int nrreq;
int n;
+ int flush_interval;
+ bool drain_on_flush;
uint8_t *buf;
QEMUIOVector *qiov;
int in_flight;
+ bool in_flush;
uint64_t offset;
} BenchData;
+static void bench_undrained_flush_cb(void *opaque, int ret)
+{
+ if (ret < 0) {
+ error_report("Failed flush request: %s\n", strerror(-ret));
+ exit(EXIT_FAILURE);
+ }
+}
+
static void bench_cb(void *opaque, int ret)
{
BenchData *b = opaque;
error_report("Failed request: %s\n", strerror(-ret));
exit(EXIT_FAILURE);
}
- if (b->in_flight > 0) {
+
+ if (b->in_flush) {
+ /* Just finished a flush with drained queue: Start next requests */
+ assert(b->in_flight == 0);
+ b->in_flush = false;
+ } else if (b->in_flight > 0) {
+ int remaining = b->n - b->in_flight;
+
b->n--;
b->in_flight--;
+
+ /* Time for flush? Drain queue if requested, then flush */
+ if (b->flush_interval && remaining % b->flush_interval == 0) {
+ if (!b->in_flight || !b->drain_on_flush) {
+ BlockCompletionFunc *cb;
+
+ if (b->drain_on_flush) {
+ b->in_flush = true;
+ cb = bench_cb;
+ } else {
+ cb = bench_undrained_flush_cb;
+ }
+
+ acb = blk_aio_flush(b->blk, cb, b);
+ if (!acb) {
+ error_report("Failed to issue flush request");
+ exit(EXIT_FAILURE);
+ }
+ }
+ if (b->drain_on_flush) {
+ return;
+ }
+ }
}
while (b->n > b->in_flight && b->in_flight < b->nrreq) {
- acb = blk_aio_preadv(b->blk, b->offset, b->qiov, 0,
- bench_cb, b);
+ if (b->write) {
+ acb = blk_aio_pwritev(b->blk, b->offset, b->qiov, 0,
+ bench_cb, b);
+ } else {
+ acb = blk_aio_preadv(b->blk, b->offset, b->qiov, 0,
+ bench_cb, b);
+ }
if (!acb) {
error_report("Failed to issue request");
exit(EXIT_FAILURE);
}
b->in_flight++;
- b->offset += b->bufsize;
+ b->offset += b->step;
b->offset %= b->image_size;
}
}
const char *fmt = NULL, *filename;
bool quiet = false;
bool image_opts = false;
+ bool is_write = false;
int count = 75000;
int depth = 64;
+ int64_t offset = 0;
size_t bufsize = 4096;
+ int pattern = 0;
+ size_t step = 0;
+ int flush_interval = 0;
+ bool drain_on_flush = true;
int64_t image_size;
BlockBackend *blk = NULL;
BenchData data = {};
int flags = 0;
- bool writethrough;
+ bool writethrough = false;
struct timeval t1, t2;
int i;
for (;;) {
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
+ {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},
{"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
+ {"pattern", required_argument, 0, OPTION_PATTERN},
+ {"no-drain", no_argument, 0, OPTION_NO_DRAIN},
{0, 0, 0, 0}
};
- c = getopt_long(argc, argv, "hc:d:f:nqs:t:", long_options, NULL);
+ c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);
if (c == -1) {
break;
}
case 'n':
flags |= BDRV_O_NATIVE_AIO;
break;
+ case 'o':
+ {
+ char *end;
+ errno = 0;
+ offset = qemu_strtosz_suffix(optarg, &end,
+ QEMU_STRTOSZ_DEFSUFFIX_B);
+ if (offset < 0|| *end) {
+ error_report("Invalid offset specified");
+ return 1;
+ }
+ break;
+ }
+ break;
case 'q':
quiet = true;
break;
bufsize = sval;
break;
}
+ case 'S':
+ {
+ int64_t sval;
+ char *end;
+
+ sval = qemu_strtosz_suffix(optarg, &end, QEMU_STRTOSZ_DEFSUFFIX_B);
+ if (sval < 0 || sval > INT_MAX || *end) {
+ error_report("Invalid step size specified");
+ return 1;
+ }
+
+ step = sval;
+ break;
+ }
case 't':
ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);
if (ret < 0) {
goto out;
}
break;
+ case 'w':
+ flags |= BDRV_O_RDWR;
+ is_write = true;
+ break;
+ case OPTION_PATTERN:
+ {
+ char *end;
+ errno = 0;
+ pattern = strtoul(optarg, &end, 0);
+ if (errno || *end || pattern > 0xff) {
+ error_report("Invalid pattern byte specified");
+ return 1;
+ }
+ break;
+ }
+ case OPTION_FLUSH_INTERVAL:
+ {
+ char *end;
+ errno = 0;
+ flush_interval = strtoul(optarg, &end, 0);
+ if (errno || *end || flush_interval > INT_MAX) {
+ error_report("Invalid flush interval specified");
+ return 1;
+ }
+ break;
+ }
+ case OPTION_NO_DRAIN:
+ drain_on_flush = false;
+ break;
case OPTION_IMAGE_OPTS:
image_opts = true;
break;
}
filename = argv[argc - 1];
+ if (!is_write && flush_interval) {
+ error_report("--flush-interval is only available in write tests");
+ ret = -1;
+ goto out;
+ }
+ if (flush_interval && flush_interval < depth) {
+ error_report("Flush interval can't be smaller than depth");
+ ret = -1;
+ goto out;
+ }
+
blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);
if (!blk) {
ret = -1;
}
data = (BenchData) {
- .blk = blk,
- .image_size = image_size,
- .bufsize = bufsize,
- .nrreq = depth,
- .n = count,
+ .blk = blk,
+ .image_size = image_size,
+ .bufsize = bufsize,
+ .step = step ?: bufsize,
+ .nrreq = depth,
+ .n = count,
+ .offset = offset,
+ .write = is_write,
+ .flush_interval = flush_interval,
+ .drain_on_flush = drain_on_flush,
};
- printf("Sending %d requests, %d bytes each, %d in parallel\n",
- data.n, data.bufsize, data.nrreq);
+ printf("Sending %d %s requests, %d bytes each, %d in parallel "
+ "(starting at offset %" PRId64 ", step size %d)\n",
+ data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
+ data.offset, data.step);
+ if (flush_interval) {
+ printf("Sending flush every %d requests\n", flush_interval);
+ }
data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);
+ memset(data.buf, pattern, data.nrreq * data.bufsize);
+
data.qiov = g_new(QEMUIOVector, data.nrreq);
for (i = 0; i < data.nrreq; i++) {
qemu_iovec_init(&data.qiov[i], 1);
const img_cmd_t *cmd;
const char *cmdname;
Error *local_error = NULL;
+ char *trace_file = NULL;
int c;
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'v'},
+ {"version", no_argument, 0, 'V'},
+ {"trace", required_argument, NULL, 'T'},
{0, 0, 0, 0}
};
if (argc < 2) {
error_exit("Not enough arguments");
}
- cmdname = argv[1];
qemu_add_opts(&qemu_object_opts);
qemu_add_opts(&qemu_source_opts);
+ qemu_add_opts(&qemu_trace_opts);
- /* find the command */
- for (cmd = img_cmds; cmd->name != NULL; cmd++) {
- if (!strcmp(cmdname, cmd->name)) {
- return cmd->handler(argc - 1, argv + 1);
+ while ((c = getopt_long(argc, argv, "+hVT:", long_options, NULL)) != -1) {
+ switch (c) {
+ case 'h':
+ help();
+ return 0;
+ case 'V':
+ printf(QEMU_IMG_VERSION);
+ return 0;
+ case 'T':
+ g_free(trace_file);
+ trace_file = trace_opt_parse(optarg);
+ break;
}
}
- c = getopt_long(argc, argv, "h", long_options, NULL);
+ cmdname = argv[optind];
- if (c == 'h') {
- help();
- }
- if (c == 'v') {
- printf(QEMU_IMG_VERSION);
+ /* reset getopt_long scanning */
+ argc -= optind;
+ if (argc < 1) {
return 0;
}
+ argv += optind;
+ optind = 1;
+
+ if (!trace_init_backends()) {
+ exit(1);
+ }
+ trace_init_file(trace_file);
+ qemu_set_log(LOG_TRACE);
+
+ /* find the command */
+ for (cmd = img_cmds; cmd->name != NULL; cmd++) {
+ if (!strcmp(cmdname, cmd->name)) {
+ return cmd->handler(argc, argv);
+ }
+ }
/* not found */
error_exit("Command not found: %s", cmdname);
projects / qemu.git / blobdiff