util/oslib-posix.c: Avoid warning on NetBSD

[qemu.git] / qemu-io.c

diff --git a/qemu-io.c b/qemu-io.c
index bc129536e4dd6d94d9d9655b92cf304a04fce6ea..4cfa41c8f95291a9d6ed8193f2df0a6208ead15e 100644 (file)
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -18,11 +18,14 @@
 #include "qemu/option.h"
 #include "qemu/config-file.h"
 #include "qemu/readline.h"
 #include "qemu/option.h"
 #include "qemu/config-file.h"
 #include "qemu/readline.h"

+#include "qemu/log.h"

 #include "qapi/qmp/qstring.h"
 #include "qapi/qmp/qstring.h"

+#include "qapi/qmp/qbool.h"

 #include "qom/object_interfaces.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"
 #include "trace/control.h"
 #include "qom/object_interfaces.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"
 #include "trace/control.h"

+#include "crypto/init.h"

 
 #define CMD_NOFILE_OK   0x01
 
 
 #define CMD_NOFILE_OK   0x01
 


@@ -51,10 +54,10 @@ static const cmdinfo_t close_cmd = {
     .oneline    = "close the current open file",
 };
 
     .oneline    = "close the current open file",
 };
 

-static int openfile(char *name, int flags, QDict *opts)
+static int openfile(char *name, int flags, bool writethrough, bool force_share,
+                    QDict *opts)

 {
     Error *local_err = NULL;
 {
     Error *local_err = NULL;

-    BlockDriverState *bs;

 
     if (qemuio_blk) {
         error_report("file open already, try 'help close'");
 
     if (qemuio_blk) {
         error_report("file open already, try 'help close'");


@@ -62,6 +65,18 @@ static int openfile(char *name, int flags, QDict *opts)
         return 1;
     }
 
         return 1;
     }
 

+    if (force_share) {
+        if (!opts) {
+            opts = qdict_new();
+        }
+        if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE)
+            && !qdict_get_bool(opts, BDRV_OPT_FORCE_SHARE)) {
+            error_report("-U conflicts with image options");
+            QDECREF(opts);
+            return 1;
+        }
+        qdict_put_bool(opts, BDRV_OPT_FORCE_SHARE, true);
+    }

     qemuio_blk = blk_new_open(name, NULL, opts, flags, &local_err);
     if (!qemuio_blk) {
         error_reportf_err(local_err, "can't open%s%s: ",
     qemuio_blk = blk_new_open(name, NULL, opts, flags, &local_err);
     if (!qemuio_blk) {
         error_reportf_err(local_err, "can't open%s%s: ",


@@ -69,27 +84,9 @@ static int openfile(char *name, int flags, QDict *opts)
         return 1;
     }
 
         return 1;
     }
 

-    bs = blk_bs(qemuio_blk);
-    if (bdrv_is_encrypted(bs)) {
-        char password[256];
-        printf("Disk image '%s' is encrypted.\n", name);
-        if (qemu_read_password(password, sizeof(password)) < 0) {
-            error_report("No password given");
-            goto error;
-        }
-        if (bdrv_set_key(bs, password) < 0) {
-            error_report("invalid password");
-            goto error;
-        }
-    }
-
+    blk_set_enable_write_cache(qemuio_blk, !writethrough);

 
     return 0;
 
     return 0;

-
- error:
-    blk_unref(qemuio_blk);
-    qemuio_blk = NULL;
-    return 1;

 }
 
 static void open_help(void)
 }
 
 static void open_help(void)


@@ -99,12 +96,16 @@ static void open_help(void)
 " opens a new file in the requested mode\n"
 "\n"
 " Example:\n"
 " opens a new file in the requested mode\n"
 "\n"
 " Example:\n"

-" 'open -Cn /tmp/data' - creates/opens data file read-write and uncached\n"
+" 'open -n -o driver=raw /tmp/data' - opens raw data file read-write, uncached\n"

 "\n"
 " Opens a file for subsequent use by all of the other qemu-io commands.\n"
 " -r, -- open file read-only\n"
 " -s, -- use snapshot file\n"
 "\n"
 " Opens a file for subsequent use by all of the other qemu-io commands.\n"
 " -r, -- open file read-only\n"
 " -s, -- use snapshot file\n"

-" -n, -- disable host cache\n"
+" -n, -- disable host cache, short for -t none\n"
+" -U, -- force shared permissions\n"
+" -k, -- use kernel AIO implementation (on Linux only)\n"
+" -t, -- use the given cache mode for the image\n"
+" -d, -- use the given discard mode for the image\n"

 " -o, -- options to be given to the block driver"
 "\n");
 }
 " -o, -- options to be given to the block driver"
 "\n");
 }


@@ -118,7 +119,7 @@ static const cmdinfo_t open_cmd = {
     .argmin     = 1,
     .argmax     = -1,
     .flags      = CMD_NOFILE_OK,
     .argmin     = 1,
     .argmax     = -1,
     .flags      = CMD_NOFILE_OK,

-    .args       = "[-Crsn] [-o options] [path]",
+    .args       = "[-rsnkU] [-t cache] [-d discard] [-o options] [path]",

     .oneline    = "open the file specified by path",
     .help       = open_help,
 };
     .oneline    = "open the file specified by path",
     .help       = open_help,
 };


@@ -135,26 +136,47 @@ static QemuOptsList empty_opts = {
 
 static int open_f(BlockBackend *blk, int argc, char **argv)
 {
 
 static int open_f(BlockBackend *blk, int argc, char **argv)
 {

-    int flags = 0;
+    int flags = BDRV_O_UNMAP;

     int readonly = 0;
     int readonly = 0;

+    bool writethrough = true;

     int c;
     QemuOpts *qopts;
     QDict *opts;
     int c;
     QemuOpts *qopts;
     QDict *opts;

+    bool force_share = false;

 
 

-    while ((c = getopt(argc, argv, "snrgo:")) != -1) {
+    while ((c = getopt(argc, argv, "snro:kt:d:U")) != -1) {

         switch (c) {
         case 's':
             flags |= BDRV_O_SNAPSHOT;
             break;
         case 'n':
         switch (c) {
         case 's':
             flags |= BDRV_O_SNAPSHOT;
             break;
         case 'n':

-            flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
+            flags |= BDRV_O_NOCACHE;
+            writethrough = false;

             break;
         case 'r':
             readonly = 1;
             break;
             break;
         case 'r':
             readonly = 1;
             break;

+        case 'k':
+            flags |= BDRV_O_NATIVE_AIO;
+            break;
+        case 't':
+            if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
+                error_report("Invalid cache option: %s", optarg);
+                qemu_opts_reset(&empty_opts);
+                return 0;
+            }
+            break;
+        case 'd':
+            if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
+                error_report("Invalid discard option: %s", optarg);
+                qemu_opts_reset(&empty_opts);
+                return 0;
+            }
+            break;

         case 'o':
             if (imageOpts) {
                 printf("--image-opts and 'open -o' are mutually exclusive\n");
         case 'o':
             if (imageOpts) {
                 printf("--image-opts and 'open -o' are mutually exclusive\n");

+                qemu_opts_reset(&empty_opts);

                 return 0;
             }
             if (!qemu_opts_parse_noisily(&empty_opts, optarg, false)) {
                 return 0;
             }
             if (!qemu_opts_parse_noisily(&empty_opts, optarg, false)) {


@@ -162,6 +184,9 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
                 return 0;
             }
             break;
                 return 0;
             }
             break;

+        case 'U':
+            force_share = true;
+            break;

         default:
             qemu_opts_reset(&empty_opts);
             return qemuio_command_usage(&open_cmd);
         default:
             qemu_opts_reset(&empty_opts);
             return qemuio_command_usage(&open_cmd);


@@ -185,13 +210,14 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
     qemu_opts_reset(&empty_opts);
 
     if (optind == argc - 1) {
     qemu_opts_reset(&empty_opts);
 
     if (optind == argc - 1) {

-        return openfile(argv[optind], flags, opts);
+        openfile(argv[optind], flags, writethrough, force_share, opts);

     } else if (optind == argc) {
     } else if (optind == argc) {

-        return openfile(NULL, flags, opts);
+        openfile(NULL, flags, writethrough, force_share, opts);

     } else {
         QDECREF(opts);
     } else {
         QDECREF(opts);

-        return qemuio_command_usage(&open_cmd);
+        qemuio_command_usage(&open_cmd);

     }
     }

+    return 0;

 }
 
 static int quit_f(BlockBackend *blk, int argc, char **argv)
 }
 
 static int quit_f(BlockBackend *blk, int argc, char **argv)


@@ -212,21 +238,26 @@ static const cmdinfo_t quit_cmd = {
 static void usage(const char *name)
 {
     printf(
 static void usage(const char *name)
 {
     printf(

-"Usage: %s [-h] [-V] [-rsnm] [-f FMT] [-c STRING] ... [file]\n"
+"Usage: %s [OPTIONS]... [-c STRING]... [file]\n"

 "QEMU Disk exerciser\n"
 "\n"
 "  --object OBJECTDEF   define an object such as 'secret' for\n"
 "                       passwords and/or encryption keys\n"
 "QEMU Disk exerciser\n"
 "\n"
 "  --object OBJECTDEF   define an object such as 'secret' for\n"
 "                       passwords and/or encryption keys\n"

+"  --image-opts         treat file as option string\n"

 "  -c, --cmd STRING     execute command with its arguments\n"
 "                       from the given string\n"
 "  -f, --format FMT     specifies the block driver to use\n"
 "  -r, --read-only      export read-only\n"
 "  -s, --snapshot       use snapshot file\n"
 "  -c, --cmd STRING     execute command with its arguments\n"
 "                       from the given string\n"
 "  -f, --format FMT     specifies the block driver to use\n"
 "  -r, --read-only      export read-only\n"
 "  -s, --snapshot       use snapshot file\n"

-"  -n, --nocache        disable host cache\n"
+"  -n, --nocache        disable host cache, short for -t none\n"

 "  -m, --misalign       misalign allocations for O_DIRECT\n"
 "  -k, --native-aio     use kernel AIO implementation (on Linux only)\n"
 "  -t, --cache=MODE     use the given cache mode for the image\n"
 "  -m, --misalign       misalign allocations for O_DIRECT\n"
 "  -k, --native-aio     use kernel AIO implementation (on Linux only)\n"
 "  -t, --cache=MODE     use the given cache mode for the image\n"

-"  -T, --trace FILE     enable trace events listed in the given file\n"
+"  -d, --discard=MODE   use the given discard mode for the image\n"
+"  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
+"                       specify tracing options\n"
+"                       see qemu-img(1) man page for full description\n"
+"  -U, --force-share    force shared permissions\n"

 "  -h, --help           display this help and exit\n"
 "  -V, --version        output version information and exit\n"
 "\n"
 "  -h, --help           display this help and exit\n"
 "  -V, --version        output version information and exit\n"
 "\n"


@@ -406,11 +437,10 @@ static QemuOptsList file_opts = {
 int main(int argc, char **argv)
 {
     int readonly = 0;
 int main(int argc, char **argv)
 {
     int readonly = 0;

-    const char *sopt = "hVc:d:f:rsnmgkt:T:";
+    const char *sopt = "hVc:d:f:rsnmkt:T:U";

     const struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },
     const struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },

-        { "offset", required_argument, NULL, 'o' },

         { "cmd", required_argument, NULL, 'c' },
         { "format", required_argument, NULL, 'f' },
         { "read-only", no_argument, NULL, 'r' },
         { "cmd", required_argument, NULL, 'c' },
         { "format", required_argument, NULL, 'f' },
         { "read-only", no_argument, NULL, 'r' },


@@ -423,24 +453,32 @@ int main(int argc, char **argv)
         { "trace", required_argument, NULL, 'T' },
         { "object", required_argument, NULL, OPTION_OBJECT },
         { "image-opts", no_argument, NULL, OPTION_IMAGE_OPTS },
         { "trace", required_argument, NULL, 'T' },
         { "object", required_argument, NULL, OPTION_OBJECT },
         { "image-opts", no_argument, NULL, OPTION_IMAGE_OPTS },

+        { "force-share", no_argument, 0, 'U'},

         { NULL, 0, NULL, 0 }
     };
     int c;
     int opt_index = 0;
     int flags = BDRV_O_UNMAP;
         { NULL, 0, NULL, 0 }
     };
     int c;
     int opt_index = 0;
     int flags = BDRV_O_UNMAP;

+    bool writethrough = true;

     Error *local_error = NULL;
     QDict *opts = NULL;
     const char *format = NULL;
     Error *local_error = NULL;
     QDict *opts = NULL;
     const char *format = NULL;

+    char *trace_file = NULL;
+    bool force_share = false;

 
 #ifdef CONFIG_POSIX
     signal(SIGPIPE, SIG_IGN);
 #endif
 
 
 #ifdef CONFIG_POSIX
     signal(SIGPIPE, SIG_IGN);
 #endif
 

+    module_call_init(MODULE_INIT_TRACE);

     progname = basename(argv[0]);
     qemu_init_exec_dir(argv[0]);
 
     progname = basename(argv[0]);
     qemu_init_exec_dir(argv[0]);
 

+    qcrypto_init(&error_fatal);
+

     module_call_init(MODULE_INIT_QOM);
     qemu_add_opts(&qemu_object_opts);
     module_call_init(MODULE_INIT_QOM);
     qemu_add_opts(&qemu_object_opts);

+    qemu_add_opts(&qemu_trace_opts);

     bdrv_init();
 
     while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {
     bdrv_init();
 
     while ((c = getopt_long(argc, argv, sopt, lopt, &opt_index)) != -1) {


@@ -449,7 +487,8 @@ int main(int argc, char **argv)
             flags |= BDRV_O_SNAPSHOT;
             break;
         case 'n':
             flags |= BDRV_O_SNAPSHOT;
             break;
         case 'n':

-            flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
+            flags |= BDRV_O_NOCACHE;
+            writethrough = false;

             break;
         case 'd':
             if (bdrv_parse_discard_flags(optarg, &flags) < 0) {
             break;
         case 'd':
             if (bdrv_parse_discard_flags(optarg, &flags) < 0) {


@@ -473,15 +512,14 @@ int main(int argc, char **argv)
             flags |= BDRV_O_NATIVE_AIO;
             break;
         case 't':
             flags |= BDRV_O_NATIVE_AIO;
             break;
         case 't':

-            if (bdrv_parse_cache_flags(optarg, &flags) < 0) {
+            if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {

                 error_report("Invalid cache option: %s", optarg);
                 exit(1);
             }
             break;
         case 'T':
                 error_report("Invalid cache option: %s", optarg);
                 exit(1);
             }
             break;
         case 'T':

-            if (!trace_init_backends()) {
-                exit(1); /* error message will have been printed */
-            }
+            g_free(trace_file);
+            trace_file = trace_opt_parse(optarg);

             break;
         case 'V':
             printf("%s version %s\n", progname, QEMU_VERSION);
             break;
         case 'V':
             printf("%s version %s\n", progname, QEMU_VERSION);


@@ -489,6 +527,9 @@ int main(int argc, char **argv)
         case 'h':
             usage(progname);
             exit(0);
         case 'h':
             usage(progname);
             exit(0);

+        case 'U':
+            force_share = true;
+            break;

         case OPTION_OBJECT: {
             QemuOpts *qopts;
             qopts = qemu_opts_parse_noisily(&qemu_object_opts,
         case OPTION_OBJECT: {
             QemuOpts *qopts;
             qopts = qemu_opts_parse_noisily(&qemu_object_opts,


@@ -523,10 +564,15 @@ int main(int argc, char **argv)
 
     if (qemu_opts_foreach(&qemu_object_opts,
                           user_creatable_add_opts_foreach,
 
     if (qemu_opts_foreach(&qemu_object_opts,
                           user_creatable_add_opts_foreach,

-                          NULL, &local_error)) {
-        error_report_err(local_error);
+                          NULL, NULL)) {
+        exit(1);
+    }
+
+    if (!trace_init_backends()) {

         exit(1);
     }
         exit(1);
     }

+    trace_init_file(trace_file);
+    qemu_set_log(LOG_TRACE);

 
     /* initialize commands */
     qemuio_add_command(&quit_cmd);
 
     /* initialize commands */
     qemuio_add_command(&quit_cmd);


@@ -555,13 +601,18 @@ int main(int argc, char **argv)
                 exit(1);
             }
             opts = qemu_opts_to_qdict(qopts, NULL);
                 exit(1);
             }
             opts = qemu_opts_to_qdict(qopts, NULL);

-            openfile(NULL, flags, opts);
+            if (openfile(NULL, flags, writethrough, force_share, opts)) {
+                exit(1);
+            }

         } else {
             if (format) {
                 opts = qdict_new();
         } else {
             if (format) {
                 opts = qdict_new();

-                qdict_put(opts, "driver", qstring_from_str(format));
+                qdict_put_str(opts, "driver", format);
+            }
+            if (openfile(argv[optind], flags, writethrough,
+                         force_share, opts)) {
+                exit(1);

             }
             }

-            openfile(argv[optind], flags, opts);

         }
     }
     command_loop();
         }
     }
     command_loop();