gwj / at91sam9263 · Commits

Commit e3aff4f611bd920768f616e8275945a2adecb6d5

Authored by aliguori
1 parent 178e08a5

Add files not included in previous commit. 

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6995 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 3 changed files with 1717 additions and 0 deletions
cmd.c 0 → 100644
  View file @e3aff4f
  1 +/*
  2 + * Copyright (c) 2003-2005 Silicon Graphics, Inc.
  3 + * All Rights Reserved.
  4 + *
  5 + * This program is free software; you can redistribute it and/or
  6 + * modify it under the terms of the GNU General Public License as
  7 + * published by the Free Software Foundation.
  8 + *
  9 + * This program is distributed in the hope that it would be useful,
  10 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12 + * GNU General Public License for more details.
  13 + *
  14 + * You should have received a copy of the GNU General Public License
  15 + * along with this program; if not, write the Free Software Foundation,
  16 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17 + */
  18 +
  19 +#include <stdio.h>
  20 +#include <stdlib.h>
  21 +#include <string.h>
  22 +#include <ctype.h>
  23 +#include <errno.h>
  24 +
  25 +#include "cmd.h"
  26 +
  27 +#define _(x) x /* not gettext support yet */
  28 +
  29 +extern int optind;
  30 +
  31 +/* from libxcmd/command.c */
  32 +
  33 +cmdinfo_t *cmdtab;
  34 +int ncmds;
  35 +
  36 +static argsfunc_t args_func;
  37 +static checkfunc_t check_func;
  38 +static int ncmdline;
  39 +static char **cmdline;
  40 +
  41 +static int
  42 +compare(const void *a, const void *b)
  43 +{
  44 + return strcmp(((const cmdinfo_t *)a)->name,
  45 + ((const cmdinfo_t *)b)->name);
  46 +}
  47 +
  48 +void
  49 +add_command(
  50 + const cmdinfo_t *ci)
  51 +{
  52 + cmdtab = realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));
  53 + cmdtab[ncmds - 1] = *ci;
  54 + qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
  55 +}
  56 +
  57 +static int
  58 +check_command(
  59 + const cmdinfo_t *ci)
  60 +{
  61 + if (check_func)
  62 + return check_func(ci);
  63 + return 1;
  64 +}
  65 +
  66 +void
  67 +add_check_command(
  68 + checkfunc_t cf)
  69 +{
  70 + check_func = cf;
  71 +}
  72 +
  73 +int
  74 +command_usage(
  75 + const cmdinfo_t *ci)
  76 +{
  77 + printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);
  78 + return 0;
  79 +}
  80 +
  81 +int
  82 +command(
  83 + const cmdinfo_t *ct,
  84 + int argc,
  85 + char **argv)
  86 +{
  87 + char *cmd = argv[0];
  88 +
  89 + if (!check_command(ct))
  90 + return 0;
  91 +
  92 + if (argc-1 < ct->argmin || (ct->argmax != -1 && argc-1 > ct->argmax)) {
  93 + if (ct->argmax == -1)
  94 + fprintf(stderr,
  95 + _("bad argument count %d to %s, expected at least %d arguments\n"),
  96 + argc-1, cmd, ct->argmin);
  97 + else if (ct->argmin == ct->argmax)
  98 + fprintf(stderr,
  99 + _("bad argument count %d to %s, expected %d arguments\n"),
  100 + argc-1, cmd, ct->argmin);
  101 + else
  102 + fprintf(stderr,
  103 + _("bad argument count %d to %s, expected between %d and %d arguments\n"),
  104 + argc-1, cmd, ct->argmin, ct->argmax);
  105 + return 0;
  106 + }
  107 + optind = 0;
  108 + return ct->cfunc(argc, argv);
  109 +}
  110 +
  111 +const cmdinfo_t *
  112 +find_command(
  113 + const char *cmd)
  114 +{
  115 + cmdinfo_t *ct;
  116 +
  117 + for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++) {
  118 + if (strcmp(ct->name, cmd) == 0 ||
  119 + (ct->altname && strcmp(ct->altname, cmd) == 0))
  120 + return (const cmdinfo_t *)ct;
  121 + }
  122 + return NULL;
  123 +}
  124 +
  125 +void
  126 +add_user_command(char *optarg)
  127 +{
  128 + ncmdline++;
  129 + cmdline = realloc(cmdline, sizeof(char*) * (ncmdline));
  130 + if (!cmdline) {
  131 + perror("realloc");
  132 + exit(1);
  133 + }
  134 + cmdline[ncmdline-1] = optarg;
  135 +}
  136 +
  137 +static int
  138 +args_command(
  139 + int index)
  140 +{
  141 + if (args_func)
  142 + return args_func(index);
  143 + return 0;
  144 +}
  145 +
  146 +void
  147 +add_args_command(
  148 + argsfunc_t af)
  149 +{
  150 + args_func = af;
  151 +}
  152 +
  153 +void
  154 +command_loop(void)
  155 +{
  156 + int c, i, j = 0, done = 0;
  157 + char *input;
  158 + char **v;
  159 + const cmdinfo_t *ct;
  160 +
  161 + for (i = 0; !done && i < ncmdline; i++) {
  162 + input = strdup(cmdline[i]);
  163 + if (!input) {
  164 + fprintf(stderr,
  165 + _("cannot strdup command '%s': %s\n"),
  166 + cmdline[i], strerror(errno));
  167 + exit(1);
  168 + }
  169 + v = breakline(input, &c);
  170 + if (c) {
  171 + ct = find_command(v[0]);
  172 + if (ct) {
  173 + if (ct->flags & CMD_FLAG_GLOBAL)
  174 + done = command(ct, c, v);
  175 + else {
  176 + j = 0;
  177 + while (!done && (j = args_command(j)))
  178 + done = command(ct, c, v);
  179 + }
  180 + } else
  181 + fprintf(stderr, _("command \"%s\" not found\n"),
  182 + v[0]);
  183 + }
  184 + doneline(input, v);
  185 + }
  186 + if (cmdline) {
  187 + free(cmdline);
  188 + return;
  189 + }
  190 + while (!done) {
  191 + if ((input = fetchline()) == NULL)
  192 + break;
  193 + v = breakline(input, &c);
  194 + if (c) {
  195 + ct = find_command(v[0]);
  196 + if (ct)
  197 + done = command(ct, c, v);
  198 + else
  199 + fprintf(stderr, _("command \"%s\" not found\n"),
  200 + v[0]);
  201 + }
  202 + doneline(input, v);
  203 + }
  204 +}
  205 +
  206 +/* from libxcmd/input.c */
  207 +
  208 +#if defined(ENABLE_READLINE)
  209 +# include <readline/history.h>
  210 +# include <readline/readline.h>
  211 +#elif defined(ENABLE_EDITLINE)
  212 +# include <histedit.h>
  213 +#endif
  214 +
  215 +extern char *progname;
  216 +
  217 +static char *
  218 +get_prompt(void)
  219 +{
  220 + static char prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];
  221 +
  222 + if (!prompt[0])
  223 + snprintf(prompt, sizeof(prompt), "%s> ", progname);
  224 + return prompt;
  225 +}
  226 +
  227 +#if defined(ENABLE_READLINE)
  228 +char *
  229 +fetchline(void)
  230 +{
  231 + char *line;
  232 +
  233 + line = readline(get_prompt());
  234 + if (line && *line)
  235 + add_history(line);
  236 + return line;
  237 +}
  238 +#elif defined(ENABLE_EDITLINE)
  239 +static char *el_get_prompt(EditLine *e) { return get_prompt(); }
  240 +char *
  241 +fetchline(void)
  242 +{
  243 + static EditLine *el;
  244 + static History *hist;
  245 + HistEvent hevent;
  246 + char *line;
  247 + int count;
  248 +
  249 + if (!el) {
  250 + hist = history_init();
  251 + history(hist, &hevent, H_SETSIZE, 100);
  252 + el = el_init(progname, stdin, stdout, stderr);
  253 + el_source(el, NULL);
  254 + el_set(el, EL_SIGNAL, 1);
  255 + el_set(el, EL_PROMPT, el_get_prompt);
  256 + el_set(el, EL_HIST, history, (const char *)hist);
  257 + }
  258 + line = strdup(el_gets(el, &count));
  259 + if (line) {
  260 + if (count > 0)
  261 + line[count-1] = '\0';
  262 + if (*line)
  263 + history(hist, &hevent, H_ENTER, line);
  264 + }
  265 + return line;
  266 +}
  267 +#else
  268 +# define MAXREADLINESZ 1024
  269 +char *
  270 +fetchline(void)
  271 +{
  272 + char *p, *line = malloc(MAXREADLINESZ);
  273 +
  274 + if (!line)
  275 + return NULL;
  276 + printf("%s", get_prompt());
  277 + fflush(stdout);
  278 + if (!fgets(line, MAXREADLINESZ, stdin)) {
  279 + free(line);
  280 + return NULL;
  281 + }
  282 + p = line + strlen(line);
  283 + if (p != line && p[-1] == '\n')
  284 + p[-1] = '\0';
  285 + return line;
  286 +}
  287 +#endif
  288 +
  289 +char **
  290 +breakline(
  291 + char *input,
  292 + int *count)
  293 +{
  294 + int c = 0;
  295 + char *p;
  296 + char **rval = calloc(sizeof(char *), 1);
  297 +
  298 + while (rval && (p = strsep(&input, " ")) != NULL) {
  299 + if (!*p)
  300 + continue;
  301 + c++;
  302 + rval = realloc(rval, sizeof(*rval) * (c + 1));
  303 + if (!rval) {
  304 + c = 0;
  305 + break;
  306 + }
  307 + rval[c - 1] = p;
  308 + rval[c] = NULL;
  309 + }
  310 + *count = c;
  311 + return rval;
  312 +}
  313 +
  314 +void
  315 +doneline(
  316 + char *input,
  317 + char **vec)
  318 +{
  319 + free(input);
  320 + free(vec);
  321 +}
  322 +
  323 +#define EXABYTES(x) ((long long)(x) << 60)
  324 +#define PETABYTES(x) ((long long)(x) << 50)
  325 +#define TERABYTES(x) ((long long)(x) << 40)
  326 +#define GIGABYTES(x) ((long long)(x) << 30)
  327 +#define MEGABYTES(x) ((long long)(x) << 20)
  328 +#define KILOBYTES(x) ((long long)(x) << 10)
  329 +
  330 +long long
  331 +cvtnum(
  332 + char *s)
  333 +{
  334 + long long i;
  335 + char *sp;
  336 + int c;
  337 +
  338 + i = strtoll(s, &sp, 0);
  339 + if (i == 0 && sp == s)
  340 + return -1LL;
  341 + if (*sp == '\0')
  342 + return i;
  343 +
  344 + if (sp[1] != '\0')
  345 + return -1LL;
  346 +
  347 + c = tolower(*sp);
  348 + switch (c) {
  349 + default:
  350 + return i;
  351 + case 'k':
  352 + return KILOBYTES(i);
  353 + case 'm':
  354 + return MEGABYTES(i);
  355 + case 'g':
  356 + return GIGABYTES(i);
  357 + case 't':
  358 + return TERABYTES(i);
  359 + case 'p':
  360 + return PETABYTES(i);
  361 + case 'e':
  362 + return EXABYTES(i);
  363 + }
  364 + return -1LL;
  365 +}
  366 +
  367 +#define TO_EXABYTES(x) ((x) / EXABYTES(1))
  368 +#define TO_PETABYTES(x) ((x) / PETABYTES(1))
  369 +#define TO_TERABYTES(x) ((x) / TERABYTES(1))
  370 +#define TO_GIGABYTES(x) ((x) / GIGABYTES(1))
  371 +#define TO_MEGABYTES(x) ((x) / MEGABYTES(1))
  372 +#define TO_KILOBYTES(x) ((x) / KILOBYTES(1))
  373 +
  374 +void
  375 +cvtstr(
  376 + double value,
  377 + char *str,
  378 + size_t size)
  379 +{
  380 + const char *fmt;
  381 + int precise;
  382 +
  383 + precise = ((double)value * 1000 == (double)(int)value * 1000);
  384 +
  385 + if (value >= EXABYTES(1)) {
  386 + fmt = precise ? "%.f EiB" : "%.3f EiB";
  387 + snprintf(str, size, fmt, TO_EXABYTES(value));
  388 + } else if (value >= PETABYTES(1)) {
  389 + fmt = precise ? "%.f PiB" : "%.3f PiB";
  390 + snprintf(str, size, fmt, TO_PETABYTES(value));
  391 + } else if (value >= TERABYTES(1)) {
  392 + fmt = precise ? "%.f TiB" : "%.3f TiB";
  393 + snprintf(str, size, fmt, TO_TERABYTES(value));
  394 + } else if (value >= GIGABYTES(1)) {
  395 + fmt = precise ? "%.f GiB" : "%.3f GiB";
  396 + snprintf(str, size, fmt, TO_GIGABYTES(value));
  397 + } else if (value >= MEGABYTES(1)) {
  398 + fmt = precise ? "%.f MiB" : "%.3f MiB";
  399 + snprintf(str, size, fmt, TO_MEGABYTES(value));
  400 + } else if (value >= KILOBYTES(1)) {
  401 + fmt = precise ? "%.f KiB" : "%.3f KiB";
  402 + snprintf(str, size, fmt, TO_KILOBYTES(value));
  403 + } else {
  404 + snprintf(str, size, "%f bytes", value);
  405 + }
  406 +}
  407 +
  408 +struct timeval
  409 +tsub(struct timeval t1, struct timeval t2)
  410 +{
  411 + t1.tv_usec -= t2.tv_usec;
  412 + if (t1.tv_usec < 0) {
  413 + t1.tv_usec += 1000000;
  414 + t1.tv_sec--;
  415 + }
  416 + t1.tv_sec -= t2.tv_sec;
  417 + return t1;
  418 +}
  419 +
  420 +double
  421 +tdiv(double value, struct timeval tv)
  422 +{
  423 + return value / ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
  424 +}
  425 +
  426 +#define HOURS(sec) ((sec) / (60 * 60))
  427 +#define MINUTES(sec) (((sec) % (60 * 60)) / 60)
  428 +#define SECONDS(sec) ((sec) % 60)
  429 +
  430 +void
  431 +timestr(
  432 + struct timeval *tv,
  433 + char *ts,
  434 + size_t size,
  435 + int format)
  436 +{
  437 + double usec = (double)tv->tv_usec / 1000000.0;
  438 +
  439 + if (format & TERSE_FIXED_TIME) {
  440 + if (!HOURS(tv->tv_sec)) {
  441 + snprintf(ts, size, "%u:%02u.%02u",
  442 + (unsigned int) MINUTES(tv->tv_sec),
  443 + (unsigned int) SECONDS(tv->tv_sec),
  444 + (unsigned int) usec * 100);
  445 + return;
  446 + }
  447 + format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */
  448 + }
  449 +
  450 + if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) {
  451 + snprintf(ts, size, "%u:%02u:%02u.%02u",
  452 + (unsigned int) HOURS(tv->tv_sec),
  453 + (unsigned int) MINUTES(tv->tv_sec),
  454 + (unsigned int) SECONDS(tv->tv_sec),
  455 + (unsigned int) usec * 100);
  456 + } else {
  457 + snprintf(ts, size, "0.%04u sec", (unsigned int) usec * 10000);
  458 + }
  459 +}
  460 +
  461 +
  462 +/* from libxcmd/quit.c */
  463 +
  464 +static cmdinfo_t quit_cmd;
  465 +
  466 +/* ARGSUSED */
  467 +static int
  468 +quit_f(
  469 + int argc,
  470 + char **argv)
  471 +{
  472 + return 1;
  473 +}
  474 +
  475 +void
  476 +quit_init(void)
  477 +{
  478 + quit_cmd.name = _("quit");
  479 + quit_cmd.altname = _("q");
  480 + quit_cmd.cfunc = quit_f;
  481 + quit_cmd.argmin = -1;
  482 + quit_cmd.argmax = -1;
  483 + quit_cmd.flags = CMD_FLAG_GLOBAL;
  484 + quit_cmd.oneline = _("exit the program");
  485 +
  486 + add_command(&quit_cmd);
  487 +}
  488 +
  489 +/* from libxcmd/help.c */
  490 +
  491 +static cmdinfo_t help_cmd;
  492 +static void help_onecmd(const char *cmd, const cmdinfo_t *ct);
  493 +static void help_oneline(const char *cmd, const cmdinfo_t *ct);
  494 +
  495 +static void
  496 +help_all(void)
  497 +{
  498 + const cmdinfo_t *ct;
  499 +
  500 + for (ct = cmdtab; ct < &cmdtab[ncmds]; ct++)
  501 + help_oneline(ct->name, ct);
  502 + printf(_("\nUse 'help commandname' for extended help.\n"));
  503 +}
  504 +
  505 +static int
  506 +help_f(
  507 + int argc,
  508 + char **argv)
  509 +{
  510 + const cmdinfo_t *ct;
  511 +
  512 + if (argc == 1) {
  513 + help_all();
  514 + return 0;
  515 + }
  516 + ct = find_command(argv[1]);
  517 + if (ct == NULL) {
  518 + printf(_("command %s not found\n"), argv[1]);
  519 + return 0;
  520 + }
  521 + help_onecmd(argv[1], ct);
  522 + return 0;
  523 +}
  524 +
  525 +static void
  526 +help_onecmd(
  527 + const char *cmd,
  528 + const cmdinfo_t *ct)
  529 +{
  530 + help_oneline(cmd, ct);
  531 + if (ct->help)
  532 + ct->help();
  533 +}
  534 +
  535 +static void
  536 +help_oneline(
  537 + const char *cmd,
  538 + const cmdinfo_t *ct)
  539 +{
  540 + if (cmd)
  541 + printf("%s ", cmd);
  542 + else {
  543 + printf("%s ", ct->name);
  544 + if (ct->altname)
  545 + printf("(or %s) ", ct->altname);
  546 + }
  547 + if (ct->args)
  548 + printf("%s ", ct->args);
  549 + printf("-- %s\n", ct->oneline);
  550 +}
  551 +
  552 +void
  553 +help_init(void)
  554 +{
  555 + help_cmd.name = _("help");
  556 + help_cmd.altname = _("?");
  557 + help_cmd.cfunc = help_f;
  558 + help_cmd.argmin = 0;
  559 + help_cmd.argmax = 1;
  560 + help_cmd.flags = CMD_FLAG_GLOBAL;
  561 + help_cmd.args = _("[command]");
  562 + help_cmd.oneline = _("help for one or all commands");
  563 +
  564 + add_command(&help_cmd);
  565 +}
cmd.h 0 → 100644
  View file @e3aff4f
  1 +/*
  2 + * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3 + * All Rights Reserved.
  4 + *
  5 + * This program is free software; you can redistribute it and/or
  6 + * modify it under the terms of the GNU General Public License as
  7 + * published by the Free Software Foundation.
  8 + *
  9 + * This program is distributed in the hope that it would be useful,
  10 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12 + * GNU General Public License for more details.
  13 + *
  14 + * You should have received a copy of the GNU General Public License
  15 + * along with this program; if not, write the Free Software Foundation,
  16 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17 + */
  18 +#ifndef __COMMAND_H__
  19 +#define __COMMAND_H__
  20 +
  21 +#define CMD_FLAG_GLOBAL ((int)0x80000000) /* don't iterate "args" */
  22 +
  23 +typedef int (*cfunc_t)(int argc, char **argv);
  24 +typedef void (*helpfunc_t)(void);
  25 +
  26 +typedef struct cmdinfo {
  27 + const char *name;
  28 + const char *altname;
  29 + cfunc_t cfunc;
  30 + int argmin;
  31 + int argmax;
  32 + int canpush;
  33 + int flags;
  34 + const char *args;
  35 + const char *oneline;
  36 + helpfunc_t help;
  37 +} cmdinfo_t;
  38 +
  39 +extern cmdinfo_t *cmdtab;
  40 +extern int ncmds;
  41 +
  42 +extern void help_init(void);
  43 +extern void quit_init(void);
  44 +
  45 +typedef int (*argsfunc_t)(int index);
  46 +typedef int (*checkfunc_t)(const cmdinfo_t *ci);
  47 +
  48 +extern void add_command(const cmdinfo_t *ci);
  49 +extern void add_user_command(char *optarg);
  50 +extern void add_args_command(argsfunc_t af);
  51 +extern void add_check_command(checkfunc_t cf);
  52 +
  53 +extern const cmdinfo_t *find_command(const char *cmd);
  54 +
  55 +extern void command_loop(void);
  56 +extern int command_usage(const cmdinfo_t *ci);
  57 +extern int command(const cmdinfo_t *ci, int argc, char **argv);
  58 +
  59 +/* from input.h */
  60 +extern char **breakline(char *input, int *count);
  61 +extern void doneline(char *input, char **vec);
  62 +extern char *fetchline(void);
  63 +
  64 +extern long long cvtnum(char *s);
  65 +extern void cvtstr(double value, char *str, size_t sz);
  66 +
  67 +extern struct timeval tsub(struct timeval t1, struct timeval t2);
  68 +extern double tdiv(double value, struct timeval tv);
  69 +
  70 +enum {
  71 + DEFAULT_TIME = 0x0,
  72 + TERSE_FIXED_TIME = 0x1,
  73 + VERBOSE_FIXED_TIME = 0x2
  74 +};
  75 +
  76 +extern void timestr(struct timeval *tv, char *str, size_t sz, int flags);
  77 +
  78 +#endif /* __COMMAND_H__ */
qemu-io.c 0 → 100644
  View file @e3aff4f
  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/types.h>
  11 +#include <stdarg.h>
  12 +#include <stdio.h>
  13 +#include <getopt.h>
  14 +
  15 +#include "qemu-common.h"
  16 +#include "block_int.h"
  17 +#include "cmd.h"
  18 +
  19 +#define VERSION "0.0.1"
  20 +
  21 +#define CMD_NOFILE_OK 0x01
  22 +
  23 +char *progname;
  24 +static BlockDriverState *bs;
  25 +
  26 +static int misalign;
  27 +
  28 +/*
  29 + * Memory allocation helpers.
  30 + *
  31 + * Make sure memory is aligned by default, or purposefully misaligned if
  32 + * that is specified on the command line.
  33 + */
  34 +
  35 +#define MISALIGN_OFFSET 16
  36 +static void *qemu_io_alloc(size_t len, int pattern)
  37 +{
  38 + void *buf;
  39 +
  40 + if (misalign)
  41 + len += MISALIGN_OFFSET;
  42 + buf = qemu_memalign(512, len);
  43 + memset(buf, pattern, len);
  44 + if (misalign)
  45 + buf += MISALIGN_OFFSET;
  46 + return buf;
  47 +}
  48 +
  49 +static void qemu_io_free(void *p)
  50 +{
  51 + if (misalign)
  52 + p -= MISALIGN_OFFSET;
  53 + qemu_vfree(p);
  54 +}
  55 +
  56 +static void
  57 +dump_buffer(char *buffer, int64_t offset, int len)
  58 +{
  59 + int i, j;
  60 + char *p;
  61 +
  62 + for (i = 0, p = buffer; i < len; i += 16) {
  63 + char *s = p;
  64 +
  65 + printf("%08llx: ", (unsigned long long)offset + i);
  66 + for (j = 0; j < 16 && i + j < len; j++, p++)
  67 + printf("%02x ", *p);
  68 + printf(" ");
  69 + for (j = 0; j < 16 && i + j < len; j++, s++) {
  70 + if (isalnum((int)*s))
  71 + printf("%c", *s);
  72 + else
  73 + printf(".");
  74 + }
  75 + printf("\n");
  76 + }
  77 +}
  78 +
  79 +static void
  80 +print_report(const char *op, struct timeval *t, int64_t offset,
  81 + int count, int total, int cnt, int Cflag)
  82 +{
  83 + char s1[64], s2[64], ts[64];
  84 +
  85 + timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
  86 + if (!Cflag) {
  87 + cvtstr((double)total, s1, sizeof(s1));
  88 + cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
  89 + printf("%s %d/%d bytes at offset %lld\n",
  90 + op, total, count, (long long)offset);
  91 + printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
  92 + s1, cnt, ts, s2, tdiv((double)cnt, *t));
  93 + } else {/* bytes,ops,time,bytes/sec,ops/sec */
  94 + printf("%d,%d,%s,%.3f,%.3f\n",
  95 + total, cnt, ts,
  96 + tdiv((double)total, *t),
  97 + tdiv((double)cnt, *t));
  98 + }
  99 +}
  100 +
  101 +static int do_read(char *buf, int64_t offset, int count, int *total)
  102 +{
  103 + int ret;
  104 +
  105 + ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
  106 + if (ret < 0)
  107 + return ret;
  108 + *total = count;
  109 + return 1;
  110 +}
  111 +
  112 +static int do_write(char *buf, int64_t offset, int count, int *total)
  113 +{
  114 + int ret;
  115 +
  116 + ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
  117 + if (ret < 0)
  118 + return ret;
  119 + *total = count;
  120 + return 1;
  121 +}
  122 +
  123 +static int do_pread(char *buf, int64_t offset, int count, int *total)
  124 +{
  125 + *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
  126 + if (*total < 0)
  127 + return *total;
  128 + return 1;
  129 +}
  130 +
  131 +static int do_pwrite(char *buf, int64_t offset, int count, int *total)
  132 +{
  133 + *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
  134 + if (*total < 0)
  135 + return *total;
  136 + return 1;
  137 +}
  138 +
  139 +#define NOT_DONE 0x7fffffff
  140 +static void aio_rw_done(void *opaque, int ret)
  141 +{
  142 + *(int *)opaque = ret;
  143 +}
  144 +
  145 +static int do_aio_readv(QEMUIOVector *qiov, int64_t offset, int *total)
  146 +{
  147 + BlockDriverAIOCB *acb;
  148 + int async_ret = NOT_DONE;
  149 +
  150 + acb = bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
  151 + aio_rw_done, &async_ret);
  152 + if (!acb)
  153 + return -EIO;
  154 +
  155 + while (async_ret == NOT_DONE)
  156 + qemu_aio_wait();
  157 +
  158 + *total = qiov->size;
  159 + return async_ret < 0 ? async_ret : 1;
  160 +}
  161 +
  162 +static int do_aio_writev(QEMUIOVector *qiov, int64_t offset, int *total)
  163 +{
  164 + BlockDriverAIOCB *acb;
  165 + int async_ret = NOT_DONE;
  166 +
  167 + acb = bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
  168 + aio_rw_done, &async_ret);
  169 + if (!acb)
  170 + return -EIO;
  171 +
  172 + while (async_ret == NOT_DONE)
  173 + qemu_aio_wait();
  174 +
  175 + *total = qiov->size >> 9;
  176 + return async_ret < 0 ? async_ret : 1;
  177 +}
  178 +
  179 +
  180 +static const cmdinfo_t read_cmd;
  181 +
  182 +static void
  183 +read_help(void)
  184 +{
  185 + printf(
  186 +"\n"
  187 +" reads a range of bytes from the given offset\n"
  188 +"\n"
  189 +" Example:\n"
  190 +" 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"
  191 +"\n"
  192 +" Reads a segment of the currently open file, optionally dumping it to the\n"
  193 +" standard output stream (with -v option) for subsequent inspection.\n"
  194 +" -p, -- use bdrv_pread to read the file\n"
  195 +" -C, -- report statistics in a machine parsable format\n"
  196 +" -v, -- dump buffer to standard output\n"
  197 +" -q, -- quite mode, do not show I/O statistics\n"
  198 +"\n");
  199 +}
  200 +
  201 +static int
  202 +read_f(int argc, char **argv)
  203 +{
  204 + struct timeval t1, t2;
  205 + int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
  206 + int c, cnt;
  207 + char *buf;
  208 + int64_t offset;
  209 + int count, total;
  210 +
  211 + while ((c = getopt(argc, argv, "Cpqv")) != EOF) {
  212 + switch (c) {
  213 + case 'C':
  214 + Cflag = 1;
  215 + break;
  216 + case 'p':
  217 + pflag = 1;
  218 + break;
  219 + case 'q':
  220 + qflag = 1;
  221 + break;
  222 + case 'v':
  223 + vflag = 1;
  224 + break;
  225 + default:
  226 + return command_usage(&read_cmd);
  227 + }
  228 + }
  229 +
  230 + if (optind != argc - 2)
  231 + return command_usage(&read_cmd);
  232 +
  233 + offset = cvtnum(argv[optind]);
  234 + if (offset < 0) {
  235 + printf("non-numeric length argument -- %s\n", argv[optind]);
  236 + return 0;
  237 + }
  238 +
  239 + optind++;
  240 + count = cvtnum(argv[optind]);
  241 + if (count < 0) {
  242 + printf("non-numeric length argument -- %s\n", argv[optind]);
  243 + return 0;
  244 + }
  245 +
  246 + if (!pflag)
  247 + if (offset & 0x1ff) {
  248 + printf("offset %lld is not sector aligned\n",
  249 + (long long)offset);
  250 + return 0;
  251 +
  252 + if (count & 0x1ff) {
  253 + printf("count %d is not sector aligned\n",
  254 + count);
  255 + return 0;
  256 + }
  257 + }
  258 +
  259 + buf = qemu_io_alloc(count, 0xab);
  260 +
  261 + gettimeofday(&t1, NULL);
  262 + if (pflag)
  263 + cnt = do_pread(buf, offset, count, &total);
  264 + else
  265 + cnt = do_read(buf, offset, count, &total);
  266 + gettimeofday(&t2, NULL);
  267 +
  268 + if (cnt < 0) {
  269 + printf("read failed: %s\n", strerror(-cnt));
  270 + return 0;
  271 + }
  272 +
  273 + if (qflag)
  274 + return 0;
  275 +
  276 + if (vflag)
  277 + dump_buffer(buf, offset, count);
  278 +
  279 + /* Finally, report back -- -C gives a parsable format */
  280 + t2 = tsub(t2, t1);
  281 + print_report("read", &t2, offset, count, total, cnt, Cflag);
  282 +
  283 + qemu_io_free(buf);
  284 +
  285 + return 0;
  286 +}
  287 +
  288 +static const cmdinfo_t read_cmd = {
  289 + .name = "read",
  290 + .altname = "r",
  291 + .cfunc = read_f,
  292 + .argmin = 2,
  293 + .argmax = -1,
  294 + .args = "[-aCpqv] off len",
  295 + .oneline = "reads a number of bytes at a specified offset",
  296 + .help = read_help,
  297 +};
  298 +
  299 +static const cmdinfo_t readv_cmd;
  300 +
  301 +static void
  302 +readv_help(void)
  303 +{
  304 + printf(
  305 +"\n"
  306 +" reads a range of bytes from the given offset into multiple buffers\n"
  307 +"\n"
  308 +" Example:\n"
  309 +" 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"
  310 +"\n"
  311 +" Reads a segment of the currently open file, optionally dumping it to the\n"
  312 +" standard output stream (with -v option) for subsequent inspection.\n"
  313 +" Uses multiple iovec buffers if more than one byte range is specified.\n"
  314 +" -C, -- report statistics in a machine parsable format\n"
  315 +" -v, -- dump buffer to standard output\n"
  316 +" -q, -- quite mode, do not show I/O statistics\n"
  317 +"\n");
  318 +}
  319 +
  320 +static int
  321 +readv_f(int argc, char **argv)
  322 +{
  323 + struct timeval t1, t2;
  324 + int Cflag = 0, qflag = 0, vflag = 0;
  325 + int c, cnt;
  326 + char *buf, *p;
  327 + int64_t offset;
  328 + int count = 0, total;
  329 + int nr_iov, i;
  330 + QEMUIOVector qiov;
  331 +
  332 + while ((c = getopt(argc, argv, "Cqv")) != EOF) {
  333 + switch (c) {
  334 + case 'C':
  335 + Cflag = 1;
  336 + break;
  337 + case 'q':
  338 + qflag = 1;
  339 + break;
  340 + case 'v':
  341 + vflag = 1;
  342 + break;
  343 + default:
  344 + return command_usage(&readv_cmd);
  345 + }
  346 + }
  347 +
  348 + if (optind > argc - 2)
  349 + return command_usage(&readv_cmd);
  350 +
  351 +
  352 + offset = cvtnum(argv[optind]);
  353 + if (offset < 0) {
  354 + printf("non-numeric length argument -- %s\n", argv[optind]);
  355 + return 0;
  356 + }
  357 + optind++;
  358 +
  359 + if (offset & 0x1ff) {
  360 + printf("offset %lld is not sector aligned\n",
  361 + (long long)offset);
  362 + return 0;
  363 + }
  364 +
  365 + if (count & 0x1ff) {
  366 + printf("count %d is not sector aligned\n",
  367 + count);
  368 + return 0;
  369 + }
  370 +
  371 + for (i = optind; i < argc; i++) {
  372 + size_t len;
  373 +
  374 + len = cvtnum(argv[i]);
  375 + if (len < 0) {
  376 + printf("non-numeric length argument -- %s\n", argv[i]);
  377 + return 0;
  378 + }
  379 + count += len;
  380 + }
  381 +
  382 + nr_iov = argc - optind;
  383 + qemu_iovec_init(&qiov, nr_iov);
  384 + buf = p = qemu_io_alloc(count, 0xab);
  385 + for (i = 0; i < nr_iov; i++) {
  386 + size_t len;
  387 +
  388 + len = cvtnum(argv[optind]);
  389 + if (len < 0) {
  390 + printf("non-numeric length argument -- %s\n",
  391 + argv[optind]);
  392 + return 0;
  393 + }
  394 +
  395 + qemu_iovec_add(&qiov, p, len);
  396 + p += len;
  397 + optind++;
  398 + }
  399 +
  400 + gettimeofday(&t1, NULL);
  401 + cnt = do_aio_readv(&qiov, offset, &total);
  402 + gettimeofday(&t2, NULL);
  403 +
  404 + if (cnt < 0) {
  405 + printf("readv failed: %s\n", strerror(-cnt));
  406 + return 0;
  407 + }
  408 +
  409 + if (qflag)
  410 + return 0;
  411 +
  412 + if (vflag)
  413 + dump_buffer(buf, offset, qiov.size);
  414 +
  415 + /* Finally, report back -- -C gives a parsable format */
  416 + t2 = tsub(t2, t1);
  417 + print_report("read", &t2, offset, qiov.size, total, cnt, Cflag);
  418 +
  419 + qemu_io_free(buf);
  420 +
  421 + return 0;
  422 +}
  423 +
  424 +static const cmdinfo_t readv_cmd = {
  425 + .name = "readv",
  426 + .cfunc = readv_f,
  427 + .argmin = 2,
  428 + .argmax = -1,
  429 + .args = "[-Cqv] off len [len..]",
  430 + .oneline = "reads a number of bytes at a specified offset",
  431 + .help = readv_help,
  432 +};
  433 +
  434 +static const cmdinfo_t write_cmd;
  435 +
  436 +static void
  437 +write_help(void)
  438 +{
  439 + printf(
  440 +"\n"
  441 +" writes a range of bytes from the given offset\n"
  442 +"\n"
  443 +" Example:\n"
  444 +" 'write 512 1k' - writes 1 kilobyte at 512 bytes into the open file\n"
  445 +"\n"
  446 +" Writes into a segment of the currently open file, using a buffer\n"
  447 +" filled with a set pattern (0xcdcdcdcd).\n"
  448 +" -p, -- use bdrv_pwrite to write the file\n"
  449 +" -P, -- use different pattern to fill file\n"
  450 +" -C, -- report statistics in a machine parsable format\n"
  451 +" -q, -- quite mode, do not show I/O statistics\n"
  452 +"\n");
  453 +}
  454 +
  455 +static int
  456 +write_f(int argc, char **argv)
  457 +{
  458 + struct timeval t1, t2;
  459 + int Cflag = 0, pflag = 0, qflag = 0;
  460 + int c, cnt;
  461 + char *buf;
  462 + int64_t offset;
  463 + int count, total;
  464 + int pattern = 0xcd;
  465 +
  466 + while ((c = getopt(argc, argv, "CpP:q")) != EOF) {
  467 + switch (c) {
  468 + case 'C':
  469 + Cflag = 1;
  470 + break;
  471 + case 'p':
  472 + pflag = 1;
  473 + break;
  474 + case 'P':
  475 + pattern = atoi(optarg);
  476 + break;
  477 + case 'q':
  478 + qflag = 1;
  479 + break;
  480 + default:
  481 + return command_usage(&write_cmd);
  482 + }
  483 + }
  484 +
  485 + if (optind != argc - 2)
  486 + return command_usage(&write_cmd);
  487 +
  488 + offset = cvtnum(argv[optind]);
  489 + if (offset < 0) {
  490 + printf("non-numeric length argument -- %s\n", argv[optind]);
  491 + return 0;
  492 + }
  493 +
  494 + optind++;
  495 + count = cvtnum(argv[optind]);
  496 + if (count < 0) {
  497 + printf("non-numeric length argument -- %s\n", argv[optind]);
  498 + return 0;
  499 + }
  500 +
  501 + if (!pflag) {
  502 + if (offset & 0x1ff) {
  503 + printf("offset %lld is not sector aligned\n",
  504 + (long long)offset);
  505 + return 0;
  506 + }
  507 +
  508 + if (count & 0x1ff) {
  509 + printf("count %d is not sector aligned\n",
  510 + count);
  511 + return 0;
  512 + }
  513 + }
  514 +
  515 + buf = qemu_io_alloc(count, pattern);
  516 +
  517 + gettimeofday(&t1, NULL);
  518 + if (pflag)
  519 + cnt = do_pwrite(buf, offset, count, &total);
  520 + else
  521 + cnt = do_write(buf, offset, count, &total);
  522 + gettimeofday(&t2, NULL);
  523 +
  524 + if (cnt < 0) {
  525 + printf("write failed: %s\n", strerror(-cnt));
  526 + return 0;
  527 + }
  528 +
  529 + if (qflag)
  530 + return 0;
  531 +
  532 + /* Finally, report back -- -C gives a parsable format */
  533 + t2 = tsub(t2, t1);
  534 + print_report("wrote", &t2, offset, count, total, cnt, Cflag);
  535 +
  536 + qemu_io_free(buf);
  537 +
  538 + return 0;
  539 +}
  540 +
  541 +static const cmdinfo_t write_cmd = {
  542 + .name = "write",
  543 + .altname = "w",
  544 + .cfunc = write_f,
  545 + .argmin = 2,
  546 + .argmax = -1,
  547 + .args = "[-aCpq] [-P pattern ] off len",
  548 + .oneline = "writes a number of bytes at a specified offset",
  549 + .help = write_help,
  550 +};
  551 +
  552 +static const cmdinfo_t writev_cmd;
  553 +
  554 +static void
  555 +writev_help(void)
  556 +{
  557 + printf(
  558 +"\n"
  559 +" writes a range of bytes from the given offset source from multiple buffers\n"
  560 +"\n"
  561 +" Example:\n"
  562 +" 'write 512 1k 1k' - writes 2 kilobytes at 512 bytes into the open file\n"
  563 +"\n"
  564 +" Writes into a segment of the currently open file, using a buffer\n"
  565 +" filled with a set pattern (0xcdcdcdcd).\n"
  566 +" -P, -- use different pattern to fill file\n"
  567 +" -C, -- report statistics in a machine parsable format\n"
  568 +" -q, -- quite mode, do not show I/O statistics\n"
  569 +"\n");
  570 +}
  571 +
  572 +static int
  573 +writev_f(int argc, char **argv)
  574 +{
  575 + struct timeval t1, t2;
  576 + int Cflag = 0, qflag = 0;
  577 + int c, cnt;
  578 + char *buf, *p;
  579 + int64_t offset;
  580 + int count = 0, total;
  581 + int nr_iov, i;
  582 + int pattern = 0xcd;
  583 + QEMUIOVector qiov;
  584 +
  585 + while ((c = getopt(argc, argv, "CqP:")) != EOF) {
  586 + switch (c) {
  587 + case 'C':
  588 + Cflag = 1;
  589 + break;
  590 + case 'q':
  591 + qflag = 1;
  592 + break;
  593 + case 'P':
  594 + pattern = atoi(optarg);
  595 + break;
  596 + default:
  597 + return command_usage(&writev_cmd);
  598 + }
  599 + }
  600 +
  601 + if (optind > argc - 2)
  602 + return command_usage(&writev_cmd);
  603 +
  604 + offset = cvtnum(argv[optind]);
  605 + if (offset < 0) {
  606 + printf("non-numeric length argument -- %s\n", argv[optind]);
  607 + return 0;
  608 + }
  609 + optind++;
  610 +
  611 + if (offset & 0x1ff) {
  612 + printf("offset %lld is not sector aligned\n",
  613 + (long long)offset);
  614 + return 0;
  615 + }
  616 +
  617 + if (count & 0x1ff) {
  618 + printf("count %d is not sector aligned\n",
  619 + count);
  620 + return 0;
  621 + }
  622 +
  623 +
  624 + for (i = optind; i < argc; i++) {
  625 + size_t len;
  626 +
  627 + len = cvtnum(argv[optind]);
  628 + if (len < 0) {
  629 + printf("non-numeric length argument -- %s\n", argv[i]);
  630 + return 0;
  631 + }
  632 + count += len;
  633 + }
  634 +
  635 + nr_iov = argc - optind;
  636 + qemu_iovec_init(&qiov, nr_iov);
  637 + buf = p = qemu_io_alloc(count, 0xab);
  638 + for (i = 0; i < nr_iov; i++) {
  639 + size_t len;
  640 +
  641 + len = cvtnum(argv[optind]);
  642 + if (len < 0) {
  643 + printf("non-numeric length argument -- %s\n",
  644 + argv[optind]);
  645 + return 0;
  646 + }
  647 +
  648 + qemu_iovec_add(&qiov, p, len);
  649 + p += len;
  650 + optind++;
  651 + }
  652 +
  653 + gettimeofday(&t1, NULL);
  654 + cnt = do_aio_writev(&qiov, offset, &total);
  655 + gettimeofday(&t2, NULL);
  656 +
  657 + if (cnt < 0) {
  658 + printf("writev failed: %s\n", strerror(-cnt));
  659 + return 0;
  660 + }
  661 +
  662 + if (qflag)
  663 + return 0;
  664 +
  665 + /* Finally, report back -- -C gives a parsable format */
  666 + t2 = tsub(t2, t1);
  667 + print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag);
  668 +
  669 + qemu_io_free(buf);
  670 +
  671 + return 0;
  672 +}
  673 +
  674 +static const cmdinfo_t writev_cmd = {
  675 + .name = "writev",
  676 + .cfunc = writev_f,
  677 + .argmin = 2,
  678 + .argmax = -1,
  679 + .args = "[-Cq] [-P pattern ] off len [len..]",
  680 + .oneline = "writes a number of bytes at a specified offset",
  681 + .help = writev_help,
  682 +};
  683 +
  684 +static int
  685 +flush_f(int argc, char **argv)
  686 +{
  687 + bdrv_flush(bs);
  688 + return 0;
  689 +}
  690 +
  691 +static const cmdinfo_t flush_cmd = {
  692 + .name = "flush",
  693 + .altname = "f",
  694 + .cfunc = flush_f,
  695 + .oneline = "flush all in-core file state to disk",
  696 +};
  697 +
  698 +static int
  699 +truncate_f(int argc, char **argv)
  700 +{
  701 + int64_t offset;
  702 + int ret;
  703 +
  704 + offset = cvtnum(argv[1]);
  705 + if (offset < 0) {
  706 + printf("non-numeric truncate argument -- %s\n", argv[1]);
  707 + return 0;
  708 + }
  709 +
  710 + ret = bdrv_truncate(bs, offset);
  711 + if (ret < 0) {
  712 + printf("truncate: %s", strerror(ret));
  713 + return 0;
  714 + }
  715 +
  716 + return 0;
  717 +}
  718 +
  719 +static const cmdinfo_t truncate_cmd = {
  720 + .name = "truncate",
  721 + .altname = "t",
  722 + .cfunc = truncate_f,
  723 + .argmin = 1,
  724 + .argmax = 1,
  725 + .args = "off",
  726 + .oneline = "truncates the current file at the given offset",
  727 +};
  728 +
  729 +static int
  730 +length_f(int argc, char **argv)
  731 +{
  732 + int64_t size;
  733 + char s1[64];
  734 +
  735 + size = bdrv_getlength(bs);
  736 + if (size < 0) {
  737 + printf("getlength: %s", strerror(size));
  738 + return 0;
  739 + }
  740 +
  741 + cvtstr(size, s1, sizeof(s1));
  742 + printf("%s\n", s1);
  743 + return 0;
  744 +}
  745 +
  746 +
  747 +static const cmdinfo_t length_cmd = {
  748 + .name = "length",
  749 + .altname = "l",
  750 + .cfunc = length_f,
  751 + .oneline = "gets the length of the current file",
  752 +};
  753 +
  754 +
  755 +static int
  756 +info_f(int argc, char **argv)
  757 +{
  758 + BlockDriverInfo bdi;
  759 + char s1[64], s2[64];
  760 + int ret;
  761 +
  762 + if (bs->drv && bs->drv->format_name)
  763 + printf("format name: %s\n", bs->drv->format_name);
  764 + if (bs->drv && bs->drv->protocol_name)
  765 + printf("format name: %s\n", bs->drv->protocol_name);
  766 +
  767 + ret = bdrv_get_info(bs, &bdi);
  768 + if (ret)
  769 + return 0;
  770 +
  771 + cvtstr(bdi.cluster_size, s1, sizeof(s1));
  772 + cvtstr(bdi.vm_state_offset, s2, sizeof(s2));
  773 +
  774 + printf("cluster size: %s\n", s1);
  775 + printf("vm state offset: %s\n", s2);
  776 +
  777 + return 0;
  778 +}
  779 +
  780 +
  781 +
  782 +static const cmdinfo_t info_cmd = {
  783 + .name = "info",
  784 + .altname = "i",
  785 + .cfunc = info_f,
  786 + .oneline = "prints information about the current file",
  787 +};
  788 +
  789 +static int
  790 +alloc_f(int argc, char **argv)
  791 +{
  792 + int64_t offset;
  793 + int nb_sectors;
  794 + char s1[64];
  795 + int num;
  796 + int ret;
  797 +
  798 + offset = cvtnum(argv[1]);
  799 + if (offset & 0x1ff) {
  800 + printf("offset %lld is not sector aligned\n",
  801 + (long long)offset);
  802 + return 0;
  803 + }
  804 +
  805 + if (argc == 3)
  806 + nb_sectors = cvtnum(argv[2]);
  807 + else
  808 + nb_sectors = 1;
  809 +
  810 + ret = bdrv_is_allocated(bs, offset >> 9, nb_sectors, &num);
  811 + if (ret) {
  812 + printf("is_allocated: %s", strerror(ret));
  813 + return 0;
  814 + }
  815 +
  816 + cvtstr(offset, s1, sizeof(s1));
  817 +
  818 + if (nb_sectors == 1)
  819 + printf("sector allocated at offset %s\n", s1);
  820 + else
  821 + printf("%d/%d sectors allocated at offset %s\n",
  822 + num, nb_sectors, s1);
  823 + return 0;
  824 +}
  825 +
  826 +static const cmdinfo_t alloc_cmd = {
  827 + .name = "alloc",
  828 + .altname = "a",
  829 + .argmin = 1,
  830 + .argmax = 2,
  831 + .cfunc = alloc_f,
  832 + .args = "off [sectors]",
  833 + .oneline = "checks if a sector is present in the file",
  834 +};
  835 +
  836 +static int
  837 +close_f(int argc, char **argv)
  838 +{
  839 + bdrv_close(bs);
  840 + bs = NULL;
  841 + return 0;
  842 +}
  843 +
  844 +static const cmdinfo_t close_cmd = {
  845 + .name = "close",
  846 + .altname = "c",
  847 + .cfunc = close_f,
  848 + .oneline = "close the current open file",
  849 +};
  850 +
  851 +static int openfile(char *name, int flags)
  852 +{
  853 + if (bs) {
  854 + fprintf(stderr, "file open already, try 'help close'\n");
  855 + return 1;
  856 + }
  857 +
  858 + bs = bdrv_new("hda");
  859 + if (!bs)
  860 + return 1;
  861 +
  862 + if (bdrv_open(bs, name, flags) == -1) {
  863 + fprintf(stderr, "%s: can't open device %s\n", progname, name);
  864 + bs = NULL;
  865 + return 1;
  866 + }
  867 +
  868 + return 0;
  869 +}
  870 +
  871 +static void
  872 +open_help(void)
  873 +{
  874 + printf(
  875 +"\n"
  876 +" opens a new file in the requested mode\n"
  877 +"\n"
  878 +" Example:\n"
  879 +" 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
  880 +"\n"
  881 +" Opens a file for subsequent use by all of the other qemu-io commands.\n"
  882 +" -C, -- create new file if it doesn't exist\n"
  883 +" -r, -- open file read-only\n"
  884 +" -s, -- use snapshot file\n"
  885 +" -n, -- disable host cache\n"
  886 +"\n");
  887 +}
  888 +
  889 +static const cmdinfo_t open_cmd;
  890 +
  891 +static int
  892 +open_f(int argc, char **argv)
  893 +{
  894 + int flags = 0;
  895 + int readonly = 0;
  896 + int c;
  897 +
  898 + while ((c = getopt(argc, argv, "snCr")) != EOF) {
  899 + switch (c) {
  900 + case 's':
  901 + flags |= BDRV_O_SNAPSHOT;
  902 + break;
  903 + case 'n':
  904 + flags |= BDRV_O_NOCACHE;
  905 + break;
  906 + case 'C':
  907 + flags |= BDRV_O_CREAT;
  908 + break;
  909 + case 'r':
  910 + readonly = 1;
  911 + break;
  912 + default:
  913 + return command_usage(&open_cmd);
  914 + }
  915 + }
  916 +
  917 + if (readonly)
  918 + flags |= BDRV_O_RDONLY;
  919 + else
  920 + flags |= BDRV_O_RDWR;
  921 +
  922 + if (optind != argc - 1)
  923 + return command_usage(&open_cmd);
  924 +
  925 + return openfile(argv[optind], flags);
  926 +}
  927 +
  928 +static const cmdinfo_t open_cmd = {
  929 + .name = "open",
  930 + .altname = "o",
  931 + .cfunc = open_f,
  932 + .argmin = 1,
  933 + .argmax = -1,
  934 + .flags = CMD_NOFILE_OK,
  935 + .args = "[-Crsn] [path]",
  936 + .oneline = "open the file specified by path",
  937 + .help = open_help,
  938 +};
  939 +
  940 +static int
  941 +init_args_command(
  942 + int index)
  943 +{
  944 + /* only one device allowed so far */
  945 + if (index >= 1)
  946 + return 0;
  947 + return ++index;
  948 +}
  949 +
  950 +static int
  951 +init_check_command(
  952 + const cmdinfo_t *ct)
  953 +{
  954 + if (ct->flags & CMD_FLAG_GLOBAL)
  955 + return 1;
  956 + if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
  957 + fprintf(stderr, "no file open, try 'help open'\n");
  958 + return 0;
  959 + }
  960 + return 1;
  961 +}
  962 +
  963 +static void usage(const char *name)
  964 +{
  965 + printf(
  966 +"Usage: %s [-h] [-V] [-Crsnm] [-c cmd] ... [file]\n"
  967 +"QEMU Disk excerciser\n"
  968 +"\n"
  969 +" -C, --create create new file if it doesn't exist\n"
  970 +" -c, --cmd command to execute\n"
  971 +" -r, --read-only export read-only\n"
  972 +" -s, --snapshot use snapshot file\n"
  973 +" -n, --nocache disable host cache\n"
  974 +" -m, --misalign misalign allocations for O_DIRECT\n"
  975 +" -h, --help display this help and exit\n"
  976 +" -V, --version output version information and exit\n"
  977 +"\n",
  978 + name);
  979 +}
  980 +
  981 +
  982 +int main(int argc, char **argv)
  983 +{
  984 + int readonly = 0;
  985 + const char *sopt = "hVc:Crsnm";
  986 + struct option lopt[] = {
  987 + { "help", 0, 0, 'h' },
  988 + { "version", 0, 0, 'V' },
  989 + { "offset", 1, 0, 'o' },
  990 + { "cmd", 1, 0, 'c' },
  991 + { "create", 0, 0, 'C' },
  992 + { "read-only", 0, 0, 'r' },
  993 + { "snapshot", 0, 0, 's' },
  994 + { "nocache", 0, 0, 'n' },
  995 + { "misalign", 0, 0, 'm' },
  996 + { NULL, 0, 0, 0 }
  997 + };
  998 + int c;
  999 + int opt_index = 0;
  1000 + int flags = 0;
  1001 +
  1002 + progname = basename(argv[0]);
  1003 +
  1004 + while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
  1005 + switch (c) {
  1006 + case 's':
  1007 + flags |= BDRV_O_SNAPSHOT;
  1008 + break;
  1009 + case 'n':
  1010 + flags |= BDRV_O_NOCACHE;
  1011 + break;
  1012 + case 'c':
  1013 + add_user_command(optarg);
  1014 + break;
  1015 + case 'C':
  1016 + flags |= BDRV_O_CREAT;
  1017 + break;
  1018 + case 'r':
  1019 + readonly = 1;
  1020 + break;
  1021 + case 'm':
  1022 + misalign = 1;
  1023 + break;
  1024 + case 'V':
  1025 + printf("%s version %s\n", progname, VERSION);
  1026 + exit(0);
  1027 + case 'h':
  1028 + usage(progname);
  1029 + exit(0);
  1030 + default:
  1031 + usage(progname);
  1032 + exit(1);
  1033 + }
  1034 + }
  1035 +
  1036 + if ((argc - optind) > 1) {
  1037 + usage(progname);
  1038 + exit(1);
  1039 + }
  1040 +
  1041 + bdrv_init();
  1042 +
  1043 + /* initialize commands */
  1044 + quit_init();
  1045 + help_init();
  1046 + add_command(&open_cmd);
  1047 + add_command(&close_cmd);
  1048 + add_command(&read_cmd);
  1049 + add_command(&readv_cmd);
  1050 + add_command(&write_cmd);
  1051 + add_command(&writev_cmd);
  1052 + add_command(&flush_cmd);
  1053 + add_command(&truncate_cmd);
  1054 + add_command(&length_cmd);
  1055 + add_command(&info_cmd);
  1056 + add_command(&alloc_cmd);
  1057 +
  1058 + add_args_command(init_args_command);
  1059 + add_check_command(init_check_command);
  1060 +
  1061 + /* open the device */
  1062 + if (readonly)
  1063 + flags |= BDRV_O_RDONLY;
  1064 + else
  1065 + flags |= BDRV_O_RDWR;
  1066 +
  1067 + if ((argc - optind) == 1)
  1068 + openfile(argv[optind], flags);
  1069 + command_loop();
  1070 +
  1071 + if (bs)
  1072 + bdrv_close(bs);
  1073 + return 0;
  1074 +}