]> git.proxmox.com Git - mirror_qemu.git/blame - qemu-io.c
crypto: Make QCryptoTLSCreds* structures private
[mirror_qemu.git] / qemu-io.c
CommitLineData
e3aff4f6
AL
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 */
452fcdbc 10
80c71a24 11#include "qemu/osdep.h"
e3aff4f6 12#include <getopt.h>
c32d766a 13#include <libgen.h>
0e448a05
DB
14#ifndef _WIN32
15#include <termios.h>
16#endif
e3aff4f6 17
a8d25326 18#include "qemu-common.h"
da34e65c 19#include "qapi/error.h"
3d21994f 20#include "qemu-io.h"
d49b6836 21#include "qemu/error-report.h"
1de7afc9 22#include "qemu/main-loop.h"
0b8fa32f 23#include "qemu/module.h"
b543c5cd
HR
24#include "qemu/option.h"
25#include "qemu/config-file.h"
0cf17e18 26#include "qemu/readline.h"
e9a80859 27#include "qemu/log.h"
98c5d2e7 28#include "qemu/sockets.h"
d49b6836 29#include "qapi/qmp/qstring.h"
452fcdbc 30#include "qapi/qmp/qdict.h"
9ba371b6 31#include "qom/object_interfaces.h"
26f54e9a 32#include "sysemu/block-backend.h"
737e150e 33#include "block/block_int.h"
d7bb72c8 34#include "trace/control.h"
c2297088 35#include "crypto/init.h"
4face32a 36#include "qemu-version.h"
e3aff4f6 37
43642b38 38#define CMD_NOFILE_OK 0x01
e3aff4f6 39
26f54e9a 40static BlockBackend *qemuio_blk;
b444d0e9 41static bool quit_qemu_io;
191c2890 42
d1174f13
KW
43/* qemu-io commands passed using -c */
44static int ncmdline;
45static char **cmdline;
499afa25 46static bool imageOpts;
d1174f13 47
0cf17e18
SH
48static ReadLineState *readline_state;
49
0e448a05
DB
50static int ttyEOF;
51
52static int get_eof_char(void)
53{
54#ifdef _WIN32
55 return 0x4; /* Ctrl-D */
56#else
57 struct termios tty;
58 if (tcgetattr(STDIN_FILENO, &tty) != 0) {
59 if (errno == ENOTTY) {
60 return 0x0; /* just expect read() == 0 */
61 } else {
62 return 0x4; /* Ctrl-D */
63 }
64 }
65
66 return tty.c_cc[VEOF];
67#endif
68}
69
b32d7a39 70static int close_f(BlockBackend *blk, int argc, char **argv)
e3aff4f6 71{
26f54e9a 72 blk_unref(qemuio_blk);
26f54e9a 73 qemuio_blk = NULL;
b32d7a39 74 return 0;
e3aff4f6
AL
75}
76
77static const cmdinfo_t close_cmd = {
43642b38
DN
78 .name = "close",
79 .altname = "c",
80 .cfunc = close_f,
81 .oneline = "close the current open file",
e3aff4f6
AL
82};
83
459571f7
FZ
84static int openfile(char *name, int flags, bool writethrough, bool force_share,
85 QDict *opts)
e3aff4f6 86{
34b5d2c6
HR
87 Error *local_err = NULL;
88
1b58b438 89 if (qemuio_blk) {
b9884681 90 error_report("file open already, try 'help close'");
cb3e7f08 91 qobject_unref(opts);
43642b38
DN
92 return 1;
93 }
94
459571f7
FZ
95 if (force_share) {
96 if (!opts) {
97 opts = qdict_new();
98 }
99 if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE)
2a01c01f 100 && strcmp(qdict_get_str(opts, BDRV_OPT_FORCE_SHARE), "on")) {
459571f7 101 error_report("-U conflicts with image options");
cb3e7f08 102 qobject_unref(opts);
459571f7
FZ
103 return 1;
104 }
2a01c01f 105 qdict_put_str(opts, BDRV_OPT_FORCE_SHARE, "on");
459571f7 106 }
efaa7c4e 107 qemuio_blk = blk_new_open(name, NULL, opts, flags, &local_err);
1b58b438 108 if (!qemuio_blk) {
b9884681
MA
109 error_reportf_err(local_err, "can't open%s%s: ",
110 name ? " device " : "", name ?: "");
dbb651c4 111 return 1;
43642b38
DN
112 }
113
e151fc16 114 blk_set_enable_write_cache(qemuio_blk, !writethrough);
8caf0212 115
43642b38 116 return 0;
e3aff4f6
AL
117}
118
43642b38 119static void open_help(void)
e3aff4f6 120{
43642b38 121 printf(
e3aff4f6
AL
122"\n"
123" opens a new file in the requested mode\n"
124"\n"
125" Example:\n"
e4e12bb2 126" 'open -n -o driver=raw /tmp/data' - opens raw data file read-write, uncached\n"
e3aff4f6
AL
127"\n"
128" Opens a file for subsequent use by all of the other qemu-io commands.\n"
e3aff4f6
AL
129" -r, -- open file read-only\n"
130" -s, -- use snapshot file\n"
0f40444c 131" -C, -- use copy-on-read\n"
b8d970f1 132" -n, -- disable host cache, short for -t none\n"
459571f7 133" -U, -- force shared permissions\n"
1c5a2aec
AM
134" -k, -- use kernel AIO implementation (Linux only, prefer use of -i)\n"
135" -i, -- use AIO mode (threads, native or io_uring)\n"
b8d970f1
EB
136" -t, -- use the given cache mode for the image\n"
137" -d, -- use the given discard mode for the image\n"
b543c5cd 138" -o, -- options to be given to the block driver"
e3aff4f6
AL
139"\n");
140}
141
b32d7a39 142static int open_f(BlockBackend *blk, int argc, char **argv);
22a2bdcb
BS
143
144static const cmdinfo_t open_cmd = {
43642b38
DN
145 .name = "open",
146 .altname = "o",
147 .cfunc = open_f,
148 .argmin = 1,
149 .argmax = -1,
150 .flags = CMD_NOFILE_OK,
0f40444c 151 .args = "[-rsCnkU] [-t cache] [-d discard] [-o options] [path]",
43642b38
DN
152 .oneline = "open the file specified by path",
153 .help = open_help,
22a2bdcb 154};
e3aff4f6 155
b543c5cd
HR
156static QemuOptsList empty_opts = {
157 .name = "drive",
443422fd 158 .merge_lists = true,
b543c5cd
HR
159 .head = QTAILQ_HEAD_INITIALIZER(empty_opts.head),
160 .desc = {
161 /* no elements => accept any params */
162 { /* end of list */ }
163 },
164};
165
b32d7a39 166static int open_f(BlockBackend *blk, int argc, char **argv)
e3aff4f6 167{
b8d970f1 168 int flags = BDRV_O_UNMAP;
43642b38 169 int readonly = 0;
e151fc16 170 bool writethrough = true;
43642b38 171 int c;
b32d7a39 172 int ret;
b543c5cd 173 QemuOpts *qopts;
443422fd 174 QDict *opts;
459571f7 175 bool force_share = false;
43642b38 176
1c5a2aec 177 while ((c = getopt(argc, argv, "snCro:ki:t:d:U")) != -1) {
43642b38
DN
178 switch (c) {
179 case 's':
180 flags |= BDRV_O_SNAPSHOT;
181 break;
182 case 'n':
e151fc16
KW
183 flags |= BDRV_O_NOCACHE;
184 writethrough = false;
43642b38 185 break;
0f40444c
EB
186 case 'C':
187 flags |= BDRV_O_COPY_ON_READ;
188 break;
43642b38
DN
189 case 'r':
190 readonly = 1;
191 break;
b8d970f1
EB
192 case 'k':
193 flags |= BDRV_O_NATIVE_AIO;
194 break;
195 case 't':
196 if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
197 error_report("Invalid cache option: %s", optarg);
198 qemu_opts_reset(&empty_opts);
b32d7a39 199 return -EINVAL;
b8d970f1
EB
200 }
201 break;
202 case 'd':
203 if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
204 error_report("Invalid discard option: %s", optarg);
205 qemu_opts_reset(&empty_opts);
b32d7a39 206 return -EINVAL;
b8d970f1
EB
207 }
208 break;
1c5a2aec
AM
209 case 'i':
210 if (bdrv_parse_aio(optarg, &flags) < 0) {
211 error_report("Invalid aio option: %s", optarg);
212 qemu_opts_reset(&empty_opts);
213 return -EINVAL;
214 }
215 break;
b543c5cd 216 case 'o':
499afa25
DB
217 if (imageOpts) {
218 printf("--image-opts and 'open -o' are mutually exclusive\n");
b8d970f1 219 qemu_opts_reset(&empty_opts);
b32d7a39 220 return -EINVAL;
499afa25 221 }
70b94331 222 if (!qemu_opts_parse_noisily(&empty_opts, optarg, false)) {
443422fd 223 qemu_opts_reset(&empty_opts);
b32d7a39 224 return -EINVAL;
b543c5cd 225 }
b543c5cd 226 break;
459571f7
FZ
227 case 'U':
228 force_share = true;
229 break;
43642b38 230 default:
443422fd 231 qemu_opts_reset(&empty_opts);
b444d0e9 232 qemuio_command_usage(&open_cmd);
b32d7a39 233 return -EINVAL;
f5edb014 234 }
43642b38
DN
235 }
236
237 if (!readonly) {
238 flags |= BDRV_O_RDWR;
239 }
e3aff4f6 240
499afa25
DB
241 if (imageOpts && (optind == argc - 1)) {
242 if (!qemu_opts_parse_noisily(&empty_opts, argv[optind], false)) {
243 qemu_opts_reset(&empty_opts);
b32d7a39 244 return -EINVAL;
499afa25
DB
245 }
246 optind++;
247 }
248
443422fd
MA
249 qopts = qemu_opts_find(&empty_opts, NULL);
250 opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
251 qemu_opts_reset(&empty_opts);
252
fd0fee34 253 if (optind == argc - 1) {
b32d7a39 254 ret = openfile(argv[optind], flags, writethrough, force_share, opts);
fd0fee34 255 } else if (optind == argc) {
b32d7a39 256 ret = openfile(NULL, flags, writethrough, force_share, opts);
fd0fee34 257 } else {
cb3e7f08 258 qobject_unref(opts);
64ebf556 259 qemuio_command_usage(&open_cmd);
b32d7a39
HR
260 return -EINVAL;
261 }
262
263 if (ret) {
264 return -EINVAL;
43642b38 265 }
b32d7a39
HR
266
267 return 0;
e3aff4f6
AL
268}
269
b32d7a39 270static int quit_f(BlockBackend *blk, int argc, char **argv)
e681be7e 271{
b444d0e9 272 quit_qemu_io = true;
b32d7a39 273 return 0;
e681be7e
KW
274}
275
276static const cmdinfo_t quit_cmd = {
277 .name = "quit",
278 .altname = "q",
279 .cfunc = quit_f,
280 .argmin = -1,
281 .argmax = -1,
282 .flags = CMD_FLAG_GLOBAL,
283 .oneline = "exit the program",
284};
285
e3aff4f6
AL
286static void usage(const char *name)
287{
43642b38 288 printf(
e4e12bb2 289"Usage: %s [OPTIONS]... [-c STRING]... [file]\n"
84844a20 290"QEMU Disk exerciser\n"
e3aff4f6 291"\n"
9ba371b6
DB
292" --object OBJECTDEF define an object such as 'secret' for\n"
293" passwords and/or encryption keys\n"
e4e12bb2 294" --image-opts treat file as option string\n"
d208cc35
MK
295" -c, --cmd STRING execute command with its arguments\n"
296" from the given string\n"
be6273da 297" -f, --format FMT specifies the block driver to use\n"
e3aff4f6
AL
298" -r, --read-only export read-only\n"
299" -s, --snapshot use snapshot file\n"
e4e12bb2 300" -n, --nocache disable host cache, short for -t none\n"
0f40444c 301" -C, --copy-on-read enable copy-on-read\n"
e3aff4f6 302" -m, --misalign misalign allocations for O_DIRECT\n"
1c5a2aec
AM
303" -k, --native-aio use kernel AIO implementation\n"
304" (Linux only, prefer use of -i)\n"
305" -i, --aio=MODE use AIO mode (threads, native or io_uring)\n"
592fa070 306" -t, --cache=MODE use the given cache mode for the image\n"
e4e12bb2 307" -d, --discard=MODE use the given discard mode for the image\n"
e9a80859
DL
308" -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
309" specify tracing options\n"
310" see qemu-img(1) man page for full description\n"
459571f7 311" -U, --force-share force shared permissions\n"
e3aff4f6
AL
312" -h, --help display this help and exit\n"
313" -V, --version output version information and exit\n"
d208cc35 314"\n"
f5048cb7
EB
315"See '%s -c help' for information on available commands.\n"
316"\n"
317QEMU_HELP_BOTTOM "\n",
d208cc35 318 name, name);
e3aff4f6
AL
319}
320
d1174f13
KW
321static char *get_prompt(void)
322{
323 static char prompt[FILENAME_MAX + 2 /*"> "*/ + 1 /*"\0"*/ ];
324
325 if (!prompt[0]) {
99e98d7c 326 snprintf(prompt, sizeof(prompt), "%s> ", error_get_progname());
d1174f13
KW
327 }
328
329 return prompt;
330}
331
d5d1507b
SW
332static void GCC_FMT_ATTR(2, 3) readline_printf_func(void *opaque,
333 const char *fmt, ...)
d1174f13 334{
0cf17e18
SH
335 va_list ap;
336 va_start(ap, fmt);
337 vprintf(fmt, ap);
338 va_end(ap);
d1174f13 339}
0cf17e18
SH
340
341static void readline_flush_func(void *opaque)
d1174f13 342{
0cf17e18 343 fflush(stdout);
d1174f13
KW
344}
345
0cf17e18 346static void readline_func(void *opaque, const char *str, void *readline_opaque)
d1174f13 347{
0cf17e18
SH
348 char **line = readline_opaque;
349 *line = g_strdup(str);
350}
351
4694020d
SH
352static void completion_match(const char *cmd, void *opaque)
353{
354 readline_add_completion(readline_state, cmd);
355}
356
0cf17e18
SH
357static void readline_completion_func(void *opaque, const char *str)
358{
4694020d
SH
359 readline_set_completion_index(readline_state, strlen(str));
360 qemuio_complete_command(str, completion_match, NULL);
0cf17e18
SH
361}
362
363static char *fetchline_readline(void)
364{
365 char *line = NULL;
366
367 readline_start(readline_state, get_prompt(), 0, readline_func, &line);
368 while (!line) {
369 int ch = getchar();
0e448a05
DB
370 if (ttyEOF != 0x0 && ch == ttyEOF) {
371 printf("\n");
0cf17e18 372 break;
d1174f13 373 }
0cf17e18 374 readline_handle_byte(readline_state, ch);
d1174f13
KW
375 }
376 return line;
377}
0cf17e18
SH
378
379#define MAXREADLINESZ 1024
380static char *fetchline_fgets(void)
d1174f13
KW
381{
382 char *p, *line = g_malloc(MAXREADLINESZ);
383
384 if (!fgets(line, MAXREADLINESZ, stdin)) {
385 g_free(line);
386 return NULL;
387 }
388
389 p = line + strlen(line);
390 if (p != line && p[-1] == '\n') {
391 p[-1] = '\0';
392 }
393
394 return line;
395}
0cf17e18
SH
396
397static char *fetchline(void)
398{
399 if (readline_state) {
400 return fetchline_readline();
401 } else {
402 return fetchline_fgets();
403 }
404}
d1174f13
KW
405
406static void prep_fetchline(void *opaque)
407{
408 int *fetchable = opaque;
409
410 qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
411 *fetchable= 1;
412}
413
78632a3d
VSO
414static int do_qemuio_command(const char *cmd)
415{
416 int ret;
417 AioContext *ctx =
418 qemuio_blk ? blk_get_aio_context(qemuio_blk) : qemu_get_aio_context();
419
420 aio_context_acquire(ctx);
421 ret = qemuio_command(qemuio_blk, cmd);
422 aio_context_release(ctx);
423
424 return ret;
425}
426
6b3aa848 427static int command_loop(void)
d1174f13 428{
b444d0e9 429 int i, fetchable = 0, prompted = 0;
6b3aa848 430 int ret, last_error = 0;
d1174f13
KW
431 char *input;
432
b444d0e9 433 for (i = 0; !quit_qemu_io && i < ncmdline; i++) {
78632a3d 434 ret = do_qemuio_command(cmdline[i]);
6b3aa848
HR
435 if (ret < 0) {
436 last_error = ret;
437 }
d1174f13
KW
438 }
439 if (cmdline) {
440 g_free(cmdline);
6b3aa848 441 return last_error;
d1174f13
KW
442 }
443
b444d0e9 444 while (!quit_qemu_io) {
d1174f13
KW
445 if (!prompted) {
446 printf("%s", get_prompt());
447 fflush(stdout);
448 qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
449 prompted = 1;
450 }
451
452 main_loop_wait(false);
453
454 if (!fetchable) {
455 continue;
456 }
457
458 input = fetchline();
459 if (input == NULL) {
460 break;
461 }
78632a3d 462 ret = do_qemuio_command(input);
d1174f13
KW
463 g_free(input);
464
6b3aa848
HR
465 if (ret < 0) {
466 last_error = ret;
467 }
468
d1174f13
KW
469 prompted = 0;
470 fetchable = 0;
471 }
472 qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
6b3aa848
HR
473
474 return last_error;
d1174f13
KW
475}
476
477static void add_user_command(char *optarg)
478{
5839e53b 479 cmdline = g_renew(char *, cmdline, ++ncmdline);
d1174f13
KW
480 cmdline[ncmdline-1] = optarg;
481}
482
0cf17e18
SH
483static void reenable_tty_echo(void)
484{
485 qemu_set_tty_echo(STDIN_FILENO, true);
486}
487
9ba371b6
DB
488enum {
489 OPTION_OBJECT = 256,
499afa25 490 OPTION_IMAGE_OPTS = 257,
9ba371b6
DB
491};
492
499afa25
DB
493static QemuOptsList file_opts = {
494 .name = "file",
495 .implied_opt_name = "file",
496 .head = QTAILQ_HEAD_INITIALIZER(file_opts.head),
497 .desc = {
498 /* no elements => accept any params */
499 { /* end of list */ }
500 },
501};
502
e3aff4f6
AL
503int main(int argc, char **argv)
504{
43642b38 505 int readonly = 0;
1c5a2aec 506 const char *sopt = "hVc:d:f:rsnCmki:t:T:U";
43642b38 507 const struct option lopt[] = {
a513416e
DB
508 { "help", no_argument, NULL, 'h' },
509 { "version", no_argument, NULL, 'V' },
a513416e
DB
510 { "cmd", required_argument, NULL, 'c' },
511 { "format", required_argument, NULL, 'f' },
512 { "read-only", no_argument, NULL, 'r' },
513 { "snapshot", no_argument, NULL, 's' },
514 { "nocache", no_argument, NULL, 'n' },
0f40444c 515 { "copy-on-read", no_argument, NULL, 'C' },
a513416e
DB
516 { "misalign", no_argument, NULL, 'm' },
517 { "native-aio", no_argument, NULL, 'k' },
1c5a2aec 518 { "aio", required_argument, NULL, 'i' },
a513416e
DB
519 { "discard", required_argument, NULL, 'd' },
520 { "cache", required_argument, NULL, 't' },
521 { "trace", required_argument, NULL, 'T' },
522 { "object", required_argument, NULL, OPTION_OBJECT },
523 { "image-opts", no_argument, NULL, OPTION_IMAGE_OPTS },
459571f7 524 { "force-share", no_argument, 0, 'U'},
43642b38
DN
525 { NULL, 0, NULL, 0 }
526 };
527 int c;
528 int opt_index = 0;
9e8f1835 529 int flags = BDRV_O_UNMAP;
6b3aa848 530 int ret;
e151fc16 531 bool writethrough = true;
2f78e491 532 Error *local_error = NULL;
1b58b438 533 QDict *opts = NULL;
499afa25 534 const char *format = NULL;
459571f7 535 bool force_share = false;
43642b38 536
526eda14
MK
537#ifdef CONFIG_POSIX
538 signal(SIGPIPE, SIG_IGN);
539#endif
540
98c5d2e7 541 socket_init();
f5852efa 542 error_init(argv[0]);
fe4db84d 543 module_call_init(MODULE_INIT_TRACE);
10f5bff6 544 qemu_init_exec_dir(argv[0]);
43642b38 545
e8f2d272 546 qcrypto_init(&error_fatal);
c2297088 547
064097d9 548 module_call_init(MODULE_INIT_QOM);
e9a80859 549 qemu_add_opts(&qemu_trace_opts);
be6273da
KW
550 bdrv_init();
551
43642b38
DN
552 while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
553 switch (c) {
554 case 's':
555 flags |= BDRV_O_SNAPSHOT;
556 break;
557 case 'n':
e151fc16
KW
558 flags |= BDRV_O_NOCACHE;
559 writethrough = false;
43642b38 560 break;
0f40444c
EB
561 case 'C':
562 flags |= BDRV_O_COPY_ON_READ;
563 break;
9e8f1835
PB
564 case 'd':
565 if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
566 error_report("Invalid discard option: %s", optarg);
567 exit(1);
568 }
569 break;
be6273da 570 case 'f':
499afa25 571 format = optarg;
be6273da 572 break;
43642b38
DN
573 case 'c':
574 add_user_command(optarg);
575 break;
576 case 'r':
577 readonly = 1;
578 break;
579 case 'm':
f9883880 580 qemuio_misalign = true;
43642b38 581 break;
43642b38
DN
582 case 'k':
583 flags |= BDRV_O_NATIVE_AIO;
584 break;
1c5a2aec
AM
585 case 'i':
586 if (bdrv_parse_aio(optarg, &flags) < 0) {
587 error_report("Invalid aio option: %s", optarg);
588 exit(1);
589 }
590 break;
592fa070 591 case 't':
e151fc16 592 if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
592fa070
KW
593 error_report("Invalid cache option: %s", optarg);
594 exit(1);
595 }
596 break;
d7bb72c8 597 case 'T':
92eecfff 598 trace_opt_parse(optarg);
d7bb72c8 599 break;
43642b38 600 case 'V':
7e563bfb 601 printf("%s version " QEMU_FULL_VERSION "\n"
99e98d7c 602 QEMU_COPYRIGHT "\n", error_get_progname());
43642b38
DN
603 exit(0);
604 case 'h':
99e98d7c 605 usage(error_get_progname());
43642b38 606 exit(0);
459571f7
FZ
607 case 'U':
608 force_share = true;
609 break;
b3e79bc6
KW
610 case OPTION_OBJECT:
611 user_creatable_process_cmdline(optarg);
612 break;
499afa25
DB
613 case OPTION_IMAGE_OPTS:
614 imageOpts = true;
615 break;
43642b38 616 default:
99e98d7c 617 usage(error_get_progname());
43642b38 618 exit(1);
f5edb014 619 }
43642b38
DN
620 }
621
622 if ((argc - optind) > 1) {
99e98d7c 623 usage(error_get_progname());
43642b38
DN
624 exit(1);
625 }
e3aff4f6 626
499afa25
DB
627 if (format && imageOpts) {
628 error_report("--image-opts and -f are mutually exclusive");
629 exit(1);
630 }
631
2f78e491 632 if (qemu_init_main_loop(&local_error)) {
565f65d2 633 error_report_err(local_error);
2f78e491
CN
634 exit(1);
635 }
a57d1143 636
e9a80859
DL
637 if (!trace_init_backends()) {
638 exit(1);
639 }
92eecfff 640 trace_init_file();
e9a80859
DL
641 qemu_set_log(LOG_TRACE);
642
43642b38 643 /* initialize commands */
c2cdf5c5
KW
644 qemuio_add_command(&quit_cmd);
645 qemuio_add_command(&open_cmd);
646 qemuio_add_command(&close_cmd);
43642b38 647
0cf17e18 648 if (isatty(STDIN_FILENO)) {
0e448a05 649 ttyEOF = get_eof_char();
0cf17e18
SH
650 readline_state = readline_init(readline_printf_func,
651 readline_flush_func,
652 NULL,
653 readline_completion_func);
654 qemu_set_tty_echo(STDIN_FILENO, false);
655 atexit(reenable_tty_echo);
656 }
657
43642b38
DN
658 /* open the device */
659 if (!readonly) {
660 flags |= BDRV_O_RDWR;
661 }
662
663 if ((argc - optind) == 1) {
499afa25
DB
664 if (imageOpts) {
665 QemuOpts *qopts = NULL;
666 qopts = qemu_opts_parse_noisily(&file_opts, argv[optind], false);
667 if (!qopts) {
668 exit(1);
669 }
670 opts = qemu_opts_to_qdict(qopts, NULL);
459571f7 671 if (openfile(NULL, flags, writethrough, force_share, opts)) {
b7aa1315
NS
672 exit(1);
673 }
499afa25
DB
674 } else {
675 if (format) {
676 opts = qdict_new();
46f5ac20 677 qdict_put_str(opts, "driver", format);
499afa25 678 }
459571f7
FZ
679 if (openfile(argv[optind], flags, writethrough,
680 force_share, opts)) {
b7aa1315
NS
681 exit(1);
682 }
499afa25 683 }
43642b38 684 }
6b3aa848 685 ret = command_loop();
e3aff4f6 686
43642b38 687 /*
922453bc 688 * Make sure all outstanding requests complete before the program exits.
43642b38 689 */
922453bc 690 bdrv_drain_all();
95533d5f 691
26f54e9a 692 blk_unref(qemuio_blk);
0cf17e18 693 g_free(readline_state);
6b3aa848
HR
694
695 if (ret < 0) {
696 return 1;
697 } else {
698 return 0;
699 }
e3aff4f6 700}