aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 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 | */ |
Stefan Weil | c32d766 | 2009-08-31 22:16:16 +0200 | [diff] [blame] | 10 | #include <sys/time.h> |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 11 | #include <sys/types.h> |
| 12 | #include <stdarg.h> |
| 13 | #include <stdio.h> |
| 14 | #include <getopt.h> |
Stefan Weil | c32d766 | 2009-08-31 22:16:16 +0200 | [diff] [blame] | 15 | #include <libgen.h> |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 16 | |
Kevin Wolf | 3d21994 | 2013-06-05 14:19:39 +0200 | [diff] [blame] | 17 | #include "qemu-io.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 18 | #include "qemu/main-loop.h" |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 19 | #include "qemu/option.h" |
| 20 | #include "qemu/config-file.h" |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 21 | #include "qemu/readline.h" |
Paolo Bonzini | 737e150 | 2012-12-17 18:19:44 +0100 | [diff] [blame] | 22 | #include "block/block_int.h" |
Stefan Hajnoczi | d7bb72c | 2012-03-12 16:36:07 +0000 | [diff] [blame] | 23 | #include "trace/control.h" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 24 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 25 | #define CMD_NOFILE_OK 0x01 |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 26 | |
Stefan Weil | f988388 | 2014-03-05 22:23:00 +0100 | [diff] [blame] | 27 | static char *progname; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 28 | |
Stefan Weil | f988388 | 2014-03-05 22:23:00 +0100 | [diff] [blame] | 29 | static BlockDriverState *qemuio_bs; |
Kevin Wolf | 191c289 | 2010-09-16 13:18:08 +0200 | [diff] [blame] | 30 | |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 31 | /* qemu-io commands passed using -c */ |
| 32 | static int ncmdline; |
| 33 | static char **cmdline; |
| 34 | |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 35 | static ReadLineState *readline_state; |
| 36 | |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 37 | static int close_f(BlockDriverState *bs, int argc, char **argv) |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 38 | { |
Fam Zheng | 4f6fd34 | 2013-08-23 09:14:47 +0800 | [diff] [blame] | 39 | bdrv_unref(bs); |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 40 | qemuio_bs = NULL; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 41 | return 0; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | static const cmdinfo_t close_cmd = { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 45 | .name = "close", |
| 46 | .altname = "c", |
| 47 | .cfunc = close_f, |
| 48 | .oneline = "close the current open file", |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 49 | }; |
| 50 | |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 51 | static int openfile(char *name, int flags, int growable, QDict *opts) |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 52 | { |
Max Reitz | 34b5d2c | 2013-09-05 14:45:29 +0200 | [diff] [blame] | 53 | Error *local_err = NULL; |
| 54 | |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 55 | if (qemuio_bs) { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 56 | fprintf(stderr, "file open already, try 'help close'\n"); |
Markus Armbruster | 29f2601 | 2014-05-28 11:16:59 +0200 | [diff] [blame] | 57 | QDECREF(opts); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 58 | return 1; |
| 59 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 60 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 61 | if (growable) { |
Max Reitz | 2e40134 | 2014-02-18 18:33:07 +0100 | [diff] [blame] | 62 | if (bdrv_open(&qemuio_bs, name, NULL, opts, flags | BDRV_O_PROTOCOL, |
| 63 | NULL, &local_err)) |
| 64 | { |
Markus Armbruster | 543f7be | 2014-05-28 11:17:00 +0200 | [diff] [blame] | 65 | fprintf(stderr, "%s: can't open%s%s: %s\n", progname, |
| 66 | name ? " device " : "", name ?: "", |
Max Reitz | 34b5d2c | 2013-09-05 14:45:29 +0200 | [diff] [blame] | 67 | error_get_pretty(local_err)); |
| 68 | error_free(local_err); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 69 | return 1; |
| 70 | } |
| 71 | } else { |
Kevin Wolf | 98522f6 | 2014-04-17 13:16:01 +0200 | [diff] [blame] | 72 | qemuio_bs = bdrv_new("hda", &error_abort); |
Christoph Hellwig | 6db9560 | 2010-04-05 16:53:57 +0200 | [diff] [blame] | 73 | |
Max Reitz | ddf5636 | 2014-02-18 18:33:06 +0100 | [diff] [blame] | 74 | if (bdrv_open(&qemuio_bs, name, NULL, opts, flags, NULL, &local_err) |
| 75 | < 0) |
| 76 | { |
Markus Armbruster | 543f7be | 2014-05-28 11:17:00 +0200 | [diff] [blame] | 77 | fprintf(stderr, "%s: can't open%s%s: %s\n", progname, |
| 78 | name ? " device " : "", name ?: "", |
Max Reitz | 34b5d2c | 2013-09-05 14:45:29 +0200 | [diff] [blame] | 79 | error_get_pretty(local_err)); |
| 80 | error_free(local_err); |
Fam Zheng | 4f6fd34 | 2013-08-23 09:14:47 +0800 | [diff] [blame] | 81 | bdrv_unref(qemuio_bs); |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 82 | qemuio_bs = NULL; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 83 | return 1; |
| 84 | } |
| 85 | } |
Christoph Hellwig | 1db6947 | 2009-07-15 23:11:21 +0200 | [diff] [blame] | 86 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 87 | return 0; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 88 | } |
| 89 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 90 | static void open_help(void) |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 91 | { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 92 | printf( |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 93 | "\n" |
| 94 | " opens a new file in the requested mode\n" |
| 95 | "\n" |
| 96 | " Example:\n" |
| 97 | " 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n" |
| 98 | "\n" |
| 99 | " Opens a file for subsequent use by all of the other qemu-io commands.\n" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 100 | " -r, -- open file read-only\n" |
| 101 | " -s, -- use snapshot file\n" |
| 102 | " -n, -- disable host cache\n" |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 103 | " -g, -- allow file to grow (only applies to protocols)\n" |
| 104 | " -o, -- options to be given to the block driver" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 105 | "\n"); |
| 106 | } |
| 107 | |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 108 | static int open_f(BlockDriverState *bs, int argc, char **argv); |
Blue Swirl | 22a2bdc | 2009-11-21 09:06:46 +0000 | [diff] [blame] | 109 | |
| 110 | static const cmdinfo_t open_cmd = { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 111 | .name = "open", |
| 112 | .altname = "o", |
| 113 | .cfunc = open_f, |
| 114 | .argmin = 1, |
| 115 | .argmax = -1, |
| 116 | .flags = CMD_NOFILE_OK, |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 117 | .args = "[-Crsn] [-o options] [path]", |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 118 | .oneline = "open the file specified by path", |
| 119 | .help = open_help, |
Blue Swirl | 22a2bdc | 2009-11-21 09:06:46 +0000 | [diff] [blame] | 120 | }; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 121 | |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 122 | static QemuOptsList empty_opts = { |
| 123 | .name = "drive", |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 124 | .merge_lists = true, |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 125 | .head = QTAILQ_HEAD_INITIALIZER(empty_opts.head), |
| 126 | .desc = { |
| 127 | /* no elements => accept any params */ |
| 128 | { /* end of list */ } |
| 129 | }, |
| 130 | }; |
| 131 | |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 132 | static int open_f(BlockDriverState *bs, int argc, char **argv) |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 133 | { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 134 | int flags = 0; |
| 135 | int readonly = 0; |
| 136 | int growable = 0; |
| 137 | int c; |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 138 | QemuOpts *qopts; |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 139 | QDict *opts; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 140 | |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 141 | while ((c = getopt(argc, argv, "snrgo:")) != EOF) { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 142 | switch (c) { |
| 143 | case 's': |
| 144 | flags |= BDRV_O_SNAPSHOT; |
| 145 | break; |
| 146 | case 'n': |
| 147 | flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; |
| 148 | break; |
| 149 | case 'r': |
| 150 | readonly = 1; |
| 151 | break; |
| 152 | case 'g': |
| 153 | growable = 1; |
| 154 | break; |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 155 | case 'o': |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 156 | if (!qemu_opts_parse(&empty_opts, optarg, 0)) { |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 157 | printf("could not parse option list -- %s\n", optarg); |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 158 | qemu_opts_reset(&empty_opts); |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 159 | return 0; |
| 160 | } |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 161 | break; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 162 | default: |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 163 | qemu_opts_reset(&empty_opts); |
Kevin Wolf | c2cdf5c | 2013-06-05 14:19:36 +0200 | [diff] [blame] | 164 | return qemuio_command_usage(&open_cmd); |
Naphtali Sprei | f5edb01 | 2010-01-17 16:48:13 +0200 | [diff] [blame] | 165 | } |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 166 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 167 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 168 | if (!readonly) { |
| 169 | flags |= BDRV_O_RDWR; |
| 170 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 171 | |
Markus Armbruster | 443422f | 2014-05-28 11:16:58 +0200 | [diff] [blame] | 172 | qopts = qemu_opts_find(&empty_opts, NULL); |
| 173 | opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL; |
| 174 | qemu_opts_reset(&empty_opts); |
| 175 | |
Max Reitz | fd0fee3 | 2013-12-20 19:28:20 +0100 | [diff] [blame] | 176 | if (optind == argc - 1) { |
| 177 | return openfile(argv[optind], flags, growable, opts); |
| 178 | } else if (optind == argc) { |
| 179 | return openfile(NULL, flags, growable, opts); |
| 180 | } else { |
Markus Armbruster | 29f2601 | 2014-05-28 11:16:59 +0200 | [diff] [blame] | 181 | QDECREF(opts); |
Kevin Wolf | c2cdf5c | 2013-06-05 14:19:36 +0200 | [diff] [blame] | 182 | return qemuio_command_usage(&open_cmd); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 183 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 184 | } |
| 185 | |
Kevin Wolf | e681be7 | 2013-06-05 14:19:34 +0200 | [diff] [blame] | 186 | static int quit_f(BlockDriverState *bs, int argc, char **argv) |
| 187 | { |
| 188 | return 1; |
| 189 | } |
| 190 | |
| 191 | static const cmdinfo_t quit_cmd = { |
| 192 | .name = "quit", |
| 193 | .altname = "q", |
| 194 | .cfunc = quit_f, |
| 195 | .argmin = -1, |
| 196 | .argmax = -1, |
| 197 | .flags = CMD_FLAG_GLOBAL, |
| 198 | .oneline = "exit the program", |
| 199 | }; |
| 200 | |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 201 | static void usage(const char *name) |
| 202 | { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 203 | printf( |
Maria Kustova | d208cc3 | 2014-03-18 09:59:19 +0400 | [diff] [blame] | 204 | "Usage: %s [-h] [-V] [-rsnm] [-c STRING] ... [file]\n" |
Stefan Weil | 84844a2 | 2009-06-22 15:08:47 +0200 | [diff] [blame] | 205 | "QEMU Disk exerciser\n" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 206 | "\n" |
Maria Kustova | d208cc3 | 2014-03-18 09:59:19 +0400 | [diff] [blame] | 207 | " -c, --cmd STRING execute command with its arguments\n" |
| 208 | " from the given string\n" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 209 | " -r, --read-only export read-only\n" |
| 210 | " -s, --snapshot use snapshot file\n" |
| 211 | " -n, --nocache disable host cache\n" |
Christoph Hellwig | 1db6947 | 2009-07-15 23:11:21 +0200 | [diff] [blame] | 212 | " -g, --growable allow file to grow (only applies to protocols)\n" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 213 | " -m, --misalign misalign allocations for O_DIRECT\n" |
Christoph Hellwig | 5c6c3a6 | 2009-08-20 16:58:35 +0200 | [diff] [blame] | 214 | " -k, --native-aio use kernel AIO implementation (on Linux only)\n" |
Kevin Wolf | 592fa07 | 2012-04-18 12:07:39 +0200 | [diff] [blame] | 215 | " -t, --cache=MODE use the given cache mode for the image\n" |
Stefan Hajnoczi | d7bb72c | 2012-03-12 16:36:07 +0000 | [diff] [blame] | 216 | " -T, --trace FILE enable trace events listed in the given file\n" |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 217 | " -h, --help display this help and exit\n" |
| 218 | " -V, --version output version information and exit\n" |
Maria Kustova | d208cc3 | 2014-03-18 09:59:19 +0400 | [diff] [blame] | 219 | "\n" |
| 220 | "See '%s -c help' for information on available commands." |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 221 | "\n", |
Maria Kustova | d208cc3 | 2014-03-18 09:59:19 +0400 | [diff] [blame] | 222 | name, name); |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 223 | } |
| 224 | |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 225 | static char *get_prompt(void) |
| 226 | { |
| 227 | static char prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ]; |
| 228 | |
| 229 | if (!prompt[0]) { |
| 230 | snprintf(prompt, sizeof(prompt), "%s> ", progname); |
| 231 | } |
| 232 | |
| 233 | return prompt; |
| 234 | } |
| 235 | |
Stefan Weil | d5d1507 | 2014-01-25 18:18:23 +0100 | [diff] [blame] | 236 | static void GCC_FMT_ATTR(2, 3) readline_printf_func(void *opaque, |
| 237 | const char *fmt, ...) |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 238 | { |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 239 | va_list ap; |
| 240 | va_start(ap, fmt); |
| 241 | vprintf(fmt, ap); |
| 242 | va_end(ap); |
| 243 | } |
| 244 | |
| 245 | static void readline_flush_func(void *opaque) |
| 246 | { |
| 247 | fflush(stdout); |
| 248 | } |
| 249 | |
| 250 | static void readline_func(void *opaque, const char *str, void *readline_opaque) |
| 251 | { |
| 252 | char **line = readline_opaque; |
| 253 | *line = g_strdup(str); |
| 254 | } |
| 255 | |
Stefan Hajnoczi | 4694020 | 2013-11-14 11:54:18 +0100 | [diff] [blame] | 256 | static void completion_match(const char *cmd, void *opaque) |
| 257 | { |
| 258 | readline_add_completion(readline_state, cmd); |
| 259 | } |
| 260 | |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 261 | static void readline_completion_func(void *opaque, const char *str) |
| 262 | { |
Stefan Hajnoczi | 4694020 | 2013-11-14 11:54:18 +0100 | [diff] [blame] | 263 | readline_set_completion_index(readline_state, strlen(str)); |
| 264 | qemuio_complete_command(str, completion_match, NULL); |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | static char *fetchline_readline(void) |
| 268 | { |
| 269 | char *line = NULL; |
| 270 | |
| 271 | readline_start(readline_state, get_prompt(), 0, readline_func, &line); |
| 272 | while (!line) { |
| 273 | int ch = getchar(); |
| 274 | if (ch == EOF) { |
| 275 | break; |
| 276 | } |
| 277 | readline_handle_byte(readline_state, ch); |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 278 | } |
| 279 | return line; |
| 280 | } |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 281 | |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 282 | #define MAXREADLINESZ 1024 |
| 283 | static char *fetchline_fgets(void) |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 284 | { |
| 285 | char *p, *line = g_malloc(MAXREADLINESZ); |
| 286 | |
| 287 | if (!fgets(line, MAXREADLINESZ, stdin)) { |
| 288 | g_free(line); |
| 289 | return NULL; |
| 290 | } |
| 291 | |
| 292 | p = line + strlen(line); |
| 293 | if (p != line && p[-1] == '\n') { |
| 294 | p[-1] = '\0'; |
| 295 | } |
| 296 | |
| 297 | return line; |
| 298 | } |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 299 | |
| 300 | static char *fetchline(void) |
| 301 | { |
| 302 | if (readline_state) { |
| 303 | return fetchline_readline(); |
| 304 | } else { |
| 305 | return fetchline_fgets(); |
| 306 | } |
| 307 | } |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 308 | |
| 309 | static void prep_fetchline(void *opaque) |
| 310 | { |
| 311 | int *fetchable = opaque; |
| 312 | |
| 313 | qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL); |
| 314 | *fetchable= 1; |
| 315 | } |
| 316 | |
| 317 | static void command_loop(void) |
| 318 | { |
| 319 | int i, done = 0, fetchable = 0, prompted = 0; |
| 320 | char *input; |
| 321 | |
| 322 | for (i = 0; !done && i < ncmdline; i++) { |
Kevin Wolf | 3d21994 | 2013-06-05 14:19:39 +0200 | [diff] [blame] | 323 | done = qemuio_command(qemuio_bs, cmdline[i]); |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 324 | } |
| 325 | if (cmdline) { |
| 326 | g_free(cmdline); |
| 327 | return; |
| 328 | } |
| 329 | |
| 330 | while (!done) { |
| 331 | if (!prompted) { |
| 332 | printf("%s", get_prompt()); |
| 333 | fflush(stdout); |
| 334 | qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable); |
| 335 | prompted = 1; |
| 336 | } |
| 337 | |
| 338 | main_loop_wait(false); |
| 339 | |
| 340 | if (!fetchable) { |
| 341 | continue; |
| 342 | } |
| 343 | |
| 344 | input = fetchline(); |
| 345 | if (input == NULL) { |
| 346 | break; |
| 347 | } |
Kevin Wolf | 3d21994 | 2013-06-05 14:19:39 +0200 | [diff] [blame] | 348 | done = qemuio_command(qemuio_bs, input); |
Kevin Wolf | d1174f1 | 2013-06-05 14:19:37 +0200 | [diff] [blame] | 349 | g_free(input); |
| 350 | |
| 351 | prompted = 0; |
| 352 | fetchable = 0; |
| 353 | } |
| 354 | qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL); |
| 355 | } |
| 356 | |
| 357 | static void add_user_command(char *optarg) |
| 358 | { |
| 359 | cmdline = g_realloc(cmdline, ++ncmdline * sizeof(char *)); |
| 360 | cmdline[ncmdline-1] = optarg; |
| 361 | } |
| 362 | |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 363 | static void reenable_tty_echo(void) |
| 364 | { |
| 365 | qemu_set_tty_echo(STDIN_FILENO, true); |
| 366 | } |
| 367 | |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 368 | int main(int argc, char **argv) |
| 369 | { |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 370 | int readonly = 0; |
| 371 | int growable = 0; |
Paolo Bonzini | 9e8f183 | 2013-02-08 14:06:11 +0100 | [diff] [blame] | 372 | const char *sopt = "hVc:d:rsnmgkt:T:"; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 373 | const struct option lopt[] = { |
| 374 | { "help", 0, NULL, 'h' }, |
| 375 | { "version", 0, NULL, 'V' }, |
| 376 | { "offset", 1, NULL, 'o' }, |
| 377 | { "cmd", 1, NULL, 'c' }, |
| 378 | { "read-only", 0, NULL, 'r' }, |
| 379 | { "snapshot", 0, NULL, 's' }, |
| 380 | { "nocache", 0, NULL, 'n' }, |
| 381 | { "misalign", 0, NULL, 'm' }, |
| 382 | { "growable", 0, NULL, 'g' }, |
| 383 | { "native-aio", 0, NULL, 'k' }, |
Paolo Bonzini | 9e8f183 | 2013-02-08 14:06:11 +0100 | [diff] [blame] | 384 | { "discard", 1, NULL, 'd' }, |
Kevin Wolf | 592fa07 | 2012-04-18 12:07:39 +0200 | [diff] [blame] | 385 | { "cache", 1, NULL, 't' }, |
Stefan Hajnoczi | d7bb72c | 2012-03-12 16:36:07 +0000 | [diff] [blame] | 386 | { "trace", 1, NULL, 'T' }, |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 387 | { NULL, 0, NULL, 0 } |
| 388 | }; |
| 389 | int c; |
| 390 | int opt_index = 0; |
Paolo Bonzini | 9e8f183 | 2013-02-08 14:06:11 +0100 | [diff] [blame] | 391 | int flags = BDRV_O_UNMAP; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 392 | |
MORITA Kazutaka | 526eda1 | 2013-07-23 17:30:11 +0900 | [diff] [blame] | 393 | #ifdef CONFIG_POSIX |
| 394 | signal(SIGPIPE, SIG_IGN); |
| 395 | #endif |
| 396 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 397 | progname = basename(argv[0]); |
Fam Zheng | 10f5bff | 2014-02-10 14:48:51 +0800 | [diff] [blame] | 398 | qemu_init_exec_dir(argv[0]); |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 399 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 400 | while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) { |
| 401 | switch (c) { |
| 402 | case 's': |
| 403 | flags |= BDRV_O_SNAPSHOT; |
| 404 | break; |
| 405 | case 'n': |
| 406 | flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; |
| 407 | break; |
Paolo Bonzini | 9e8f183 | 2013-02-08 14:06:11 +0100 | [diff] [blame] | 408 | case 'd': |
| 409 | if (bdrv_parse_discard_flags(optarg, &flags) < 0) { |
| 410 | error_report("Invalid discard option: %s", optarg); |
| 411 | exit(1); |
| 412 | } |
| 413 | break; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 414 | case 'c': |
| 415 | add_user_command(optarg); |
| 416 | break; |
| 417 | case 'r': |
| 418 | readonly = 1; |
| 419 | break; |
| 420 | case 'm': |
Stefan Weil | f988388 | 2014-03-05 22:23:00 +0100 | [diff] [blame] | 421 | qemuio_misalign = true; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 422 | break; |
| 423 | case 'g': |
| 424 | growable = 1; |
| 425 | break; |
| 426 | case 'k': |
| 427 | flags |= BDRV_O_NATIVE_AIO; |
| 428 | break; |
Kevin Wolf | 592fa07 | 2012-04-18 12:07:39 +0200 | [diff] [blame] | 429 | case 't': |
| 430 | if (bdrv_parse_cache_flags(optarg, &flags) < 0) { |
| 431 | error_report("Invalid cache option: %s", optarg); |
| 432 | exit(1); |
| 433 | } |
| 434 | break; |
Stefan Hajnoczi | d7bb72c | 2012-03-12 16:36:07 +0000 | [diff] [blame] | 435 | case 'T': |
LluĂs Vilanova | 5b80827 | 2014-05-27 15:02:14 +0200 | [diff] [blame] | 436 | if (!trace_init_backends(optarg, NULL)) { |
Stefan Hajnoczi | d7bb72c | 2012-03-12 16:36:07 +0000 | [diff] [blame] | 437 | exit(1); /* error message will have been printed */ |
| 438 | } |
| 439 | break; |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 440 | case 'V': |
Kevin Wolf | 02da386 | 2013-06-05 14:19:40 +0200 | [diff] [blame] | 441 | printf("%s version %s\n", progname, QEMU_VERSION); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 442 | exit(0); |
| 443 | case 'h': |
| 444 | usage(progname); |
| 445 | exit(0); |
| 446 | default: |
| 447 | usage(progname); |
| 448 | exit(1); |
Naphtali Sprei | f5edb01 | 2010-01-17 16:48:13 +0200 | [diff] [blame] | 449 | } |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 450 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 451 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 452 | if ((argc - optind) > 1) { |
| 453 | usage(progname); |
| 454 | exit(1); |
| 455 | } |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 456 | |
Zhi Yong Wu | a57d114 | 2012-02-19 22:24:59 +0800 | [diff] [blame] | 457 | qemu_init_main_loop(); |
Paolo Bonzini | 2592c59 | 2012-11-03 18:10:17 +0100 | [diff] [blame] | 458 | bdrv_init(); |
Zhi Yong Wu | a57d114 | 2012-02-19 22:24:59 +0800 | [diff] [blame] | 459 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 460 | /* initialize commands */ |
Kevin Wolf | c2cdf5c | 2013-06-05 14:19:36 +0200 | [diff] [blame] | 461 | qemuio_add_command(&quit_cmd); |
| 462 | qemuio_add_command(&open_cmd); |
| 463 | qemuio_add_command(&close_cmd); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 464 | |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 465 | if (isatty(STDIN_FILENO)) { |
| 466 | readline_state = readline_init(readline_printf_func, |
| 467 | readline_flush_func, |
| 468 | NULL, |
| 469 | readline_completion_func); |
| 470 | qemu_set_tty_echo(STDIN_FILENO, false); |
| 471 | atexit(reenable_tty_echo); |
| 472 | } |
| 473 | |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 474 | /* open the device */ |
| 475 | if (!readonly) { |
| 476 | flags |= BDRV_O_RDWR; |
| 477 | } |
| 478 | |
| 479 | if ((argc - optind) == 1) { |
Max Reitz | b543c5c | 2013-10-11 14:02:10 +0200 | [diff] [blame] | 480 | openfile(argv[optind], flags, growable, NULL); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 481 | } |
| 482 | command_loop(); |
| 483 | |
| 484 | /* |
Stefan Hajnoczi | 922453b | 2011-11-30 12:23:43 +0000 | [diff] [blame] | 485 | * Make sure all outstanding requests complete before the program exits. |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 486 | */ |
Stefan Hajnoczi | 922453b | 2011-11-30 12:23:43 +0000 | [diff] [blame] | 487 | bdrv_drain_all(); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 488 | |
Kevin Wolf | 734c3b8 | 2013-06-05 14:19:30 +0200 | [diff] [blame] | 489 | if (qemuio_bs) { |
Fam Zheng | 4f6fd34 | 2013-08-23 09:14:47 +0800 | [diff] [blame] | 490 | bdrv_unref(qemuio_bs); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 491 | } |
Stefan Hajnoczi | 0cf17e1 | 2013-11-14 11:54:17 +0100 | [diff] [blame] | 492 | g_free(readline_state); |
Devin Nakamura | 43642b3 | 2011-07-11 11:22:16 -0400 | [diff] [blame] | 493 | return 0; |
aliguori | e3aff4f | 2009-04-05 19:14:04 +0000 | [diff] [blame] | 494 | } |