storage-daemon/qemu-storage-daemon.c

   1 /*
   2  * QEMU storage daemon
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  * Copyright (c) 2019 Kevin Wolf <kwolf@redhat.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "qemu/osdep.h"
  27
  28 #include <getopt.h>
  29
  30 #include "block/block.h"
  31 #include "block/nbd.h"
  32 #include "chardev/char.h"
  33 #include "crypto/init.h"
  34 #include "monitor/monitor.h"
  35 #include "monitor/monitor-internal.h"
  36
  37 #include "qapi/error.h"
  38 #include "qapi/qapi-visit-block-core.h"
  39 #include "qapi/qapi-visit-block-export.h"
  40 #include "qapi/qapi-visit-control.h"
  41 #include "qapi/qmp/qdict.h"
  42 #include "qapi/qmp/qstring.h"
  43 #include "qapi/qobject-input-visitor.h"
  44
  45 #include "qemu-common.h"
  46 #include "qemu-version.h"
  47 #include "qemu/config-file.h"
  48 #include "qemu/error-report.h"
  49 #include "qemu/help_option.h"
  50 #include "qemu/log.h"
  51 #include "qemu/main-loop.h"
  52 #include "qemu/module.h"
  53 #include "qemu/option.h"
  54 #include "qom/object_interfaces.h"
  55
  56 #include "storage-daemon/qapi/qapi-commands.h"
  57 #include "storage-daemon/qapi/qapi-init-commands.h"
  58
  59 #include "sysemu/runstate.h"
  60 #include "trace/control.h"
  61
  62 static volatile bool exit_requested = false;
  63
  64 void qemu_system_killed(int signal, pid_t pid)
  65 {
  66     exit_requested = true;
  67 }
  68
  69 void qmp_quit(Error **errp)
  70 {
  71     exit_requested = true;
  72 }
  73
  74 static void help(void)
  75 {
  76     printf(
  77 "Usage: %s [options]\n"
  78 "QEMU storage daemon\n"
  79 "\n"
  80 "  -h, --help             display this help and exit\n"
  81 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
  82 "                         specify tracing options\n"
  83 "  -V, --version          output version information and exit\n"
  84 "\n"
  85 "  --blockdev [driver=]<driver>[,node-name=<N>][,discard=ignore|unmap]\n"
  86 "             [,cache.direct=on|off][,cache.no-flush=on|off]\n"
  87 "             [,read-only=on|off][,auto-read-only=on|off]\n"
  88 "             [,force-share=on|off][,detect-zeroes=on|off|unmap]\n"
  89 "             [,driver specific parameters...]\n"
  90 "                         configure a block backend\n"
  91 "\n"
  92 "  --chardev <options>    configure a character device backend\n"
  93 "                         (see the qemu(1) man page for possible options)\n"
  94 "\n"
  95 "  --export [type=]nbd,id=<id>,node-name=<node-name>[,name=<export-name>]\n"
  96 "           [,writable=on|off][,bitmap=<name>]\n"
  97 "                         export the specified block node over NBD\n"
  98 "                         (requires --nbd-server)\n"
  99 "\n"
 100 "  --monitor [chardev=]name[,mode=control][,pretty[=on|off]]\n"
 101 "                         configure a QMP monitor\n"
 102 "\n"
 103 "  --nbd-server addr.type=inet,addr.host=<host>,addr.port=<port>\n"
 104 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
 105 "  --nbd-server addr.type=unix,addr.path=<path>\n"
 106 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
 107 "                         start an NBD server for exporting block nodes\n"
 108 "\n"
 109 "  --object help          list object types that can be added\n"
 110 "  --object <type>,help   list properties for the given object type\n"
 111 "  --object <type>[,<property>=<value>...]\n"
 112 "                         create a new object of type <type>, setting\n"
 113 "                         properties in the order they are specified. Note\n"
 114 "                         that the 'id' property must be set.\n"
 115 "                         See the qemu(1) man page for documentation of the\n"
 116 "                         objects that can be added.\n"
 117 "\n"
 118 QEMU_HELP_BOTTOM "\n",
 119     error_get_progname());
 120 }
 121
 122 enum {
 123     OPTION_BLOCKDEV = 256,
 124     OPTION_CHARDEV,
 125     OPTION_EXPORT,
 126     OPTION_MONITOR,
 127     OPTION_NBD_SERVER,
 128     OPTION_OBJECT,
 129 };
 130
 131 extern QemuOptsList qemu_chardev_opts;
 132
 133 static QemuOptsList qemu_object_opts = {
 134     .name = "object",
 135     .implied_opt_name = "qom-type",
 136     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
 137     .desc = {
 138         { }
 139     },
 140 };
 141
 142 static void init_qmp_commands(void)
 143 {
 144     qmp_init_marshal(&qmp_commands);
 145     qmp_register_command(&qmp_commands, "query-qmp-schema",
 146                          qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
 147     qmp_register_command(&qmp_commands, "object-add", qmp_object_add,
 148                          QCO_NO_OPTIONS);
 149
 150     QTAILQ_INIT(&qmp_cap_negotiation_commands);
 151     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
 152                          qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
 153 }
 154
 155 static int getopt_set_loc(int argc, char **argv, const char *optstring,
 156                           const struct option *longopts)
 157 {
 158     int c, save_index;
 159
 160     optarg = NULL;
 161     save_index = optind;
 162     c = getopt_long(argc, argv, optstring, longopts, NULL);
 163     if (optarg) {
 164         loc_set_cmdline(argv, save_index, MAX(1, optind - save_index));
 165     }
 166     return c;
 167 }
 168
 169 static void process_options(int argc, char *argv[])
 170 {
 171     int c;
 172
 173     static const struct option long_options[] = {
 174         {"blockdev", required_argument, NULL, OPTION_BLOCKDEV},
 175         {"chardev", required_argument, NULL, OPTION_CHARDEV},
 176         {"export", required_argument, NULL, OPTION_EXPORT},
 177         {"help", no_argument, NULL, 'h'},
 178         {"monitor", required_argument, NULL, OPTION_MONITOR},
 179         {"nbd-server", required_argument, NULL, OPTION_NBD_SERVER},
 180         {"object", required_argument, NULL, OPTION_OBJECT},
 181         {"trace", required_argument, NULL, 'T'},
 182         {"version", no_argument, NULL, 'V'},
 183         {0, 0, 0, 0}
 184     };
 185
 186     /*
 187      * In contrast to the system emulator, options are processed in the order
 188      * they are given on the command lines. This means that things must be
 189      * defined first before they can be referenced in another option.
 190      */
 191     while ((c = getopt_set_loc(argc, argv, "-hT:V", long_options)) != -1) {
 192         switch (c) {
 193         case '?':
 194             exit(EXIT_FAILURE);
 195         case 'h':
 196             help();
 197             exit(EXIT_SUCCESS);
 198         case 'T':
 199             trace_opt_parse(optarg);
 200             trace_init_file();
 201             break;
 202         case 'V':
 203             printf("qemu-storage-daemon version "
 204                    QEMU_FULL_VERSION "\n" QEMU_COPYRIGHT "\n");
 205             exit(EXIT_SUCCESS);
 206         case OPTION_BLOCKDEV:
 207             {
 208                 Visitor *v;
 209                 BlockdevOptions *options;
 210
 211                 v = qobject_input_visitor_new_str(optarg, "driver",
 212                                                   &error_fatal);
 213
 214                 visit_type_BlockdevOptions(v, NULL, &options, &error_fatal);
 215                 visit_free(v);
 216
 217                 qmp_blockdev_add(options, &error_fatal);
 218                 qapi_free_BlockdevOptions(options);
 219                 break;
 220             }
 221         case OPTION_CHARDEV:
 222             {
 223                 /* TODO This interface is not stable until we QAPIfy it */
 224                 QemuOpts *opts = qemu_opts_parse_noisily(&qemu_chardev_opts,
 225                                                          optarg, true);
 226                 if (opts == NULL) {
 227                     exit(EXIT_FAILURE);
 228                 }
 229
 230                 if (!qemu_chr_new_from_opts(opts, NULL, &error_fatal)) {
 231                     /* No error, but NULL returned means help was printed */
 232                     exit(EXIT_SUCCESS);
 233                 }
 234                 qemu_opts_del(opts);
 235                 break;
 236             }
 237         case OPTION_EXPORT:
 238             {
 239                 Visitor *v;
 240                 BlockExportOptions *export;
 241
 242                 v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
 243                 visit_type_BlockExportOptions(v, NULL, &export, &error_fatal);
 244                 visit_free(v);
 245
 246                 qmp_block_export_add(export, &error_fatal);
 247                 qapi_free_BlockExportOptions(export);
 248                 break;
 249             }
 250         case OPTION_MONITOR:
 251             {
 252                 Visitor *v;
 253                 MonitorOptions *monitor;
 254
 255                 v = qobject_input_visitor_new_str(optarg, "chardev",
 256                                                   &error_fatal);
 257                 visit_type_MonitorOptions(v, NULL, &monitor, &error_fatal);
 258                 visit_free(v);
 259
 260                 /* TODO Catch duplicate monitor IDs */
 261                 monitor_init(monitor, false, &error_fatal);
 262                 qapi_free_MonitorOptions(monitor);
 263                 break;
 264             }
 265         case OPTION_NBD_SERVER:
 266             {
 267                 Visitor *v;
 268                 NbdServerOptions *options;
 269
 270                 v = qobject_input_visitor_new_str(optarg, NULL, &error_fatal);
 271                 visit_type_NbdServerOptions(v, NULL, &options, &error_fatal);
 272                 visit_free(v);
 273
 274                 nbd_server_start_options(options, &error_fatal);
 275                 qapi_free_NbdServerOptions(options);
 276                 break;
 277             }
 278         case OPTION_OBJECT:
 279             {
 280                 QDict *args;
 281                 bool help;
 282
 283                 args = keyval_parse(optarg, "qom-type", &help, &error_fatal);
 284                 if (help) {
 285                     user_creatable_print_help_from_qdict(args);
 286                     exit(EXIT_SUCCESS);
 287                 }
 288                 user_creatable_add_dict(args, true, &error_fatal);
 289                 qobject_unref(args);
 290                 break;
 291             }
 292         case 1:
 293             error_report("Unexpected argument");
 294             exit(EXIT_FAILURE);
 295         default:
 296             g_assert_not_reached();
 297         }
 298     }
 299     loc_set_none();
 300 }
 301
 302 int main(int argc, char *argv[])
 303 {
 304 #ifdef CONFIG_POSIX
 305     signal(SIGPIPE, SIG_IGN);
 306 #endif
 307
 308     error_init(argv[0]);
 309     qemu_init_exec_dir(argv[0]);
 310     os_setup_signal_handling();
 311
 312     module_call_init(MODULE_INIT_QOM);
 313     module_call_init(MODULE_INIT_TRACE);
 314     qemu_add_opts(&qemu_object_opts);
 315     qemu_add_opts(&qemu_trace_opts);
 316     qcrypto_init(&error_fatal);
 317     bdrv_init();
 318     monitor_init_globals_core();
 319     init_qmp_commands();
 320
 321     if (!trace_init_backends()) {
 322         return EXIT_FAILURE;
 323     }
 324     qemu_set_log(LOG_TRACE);
 325
 326     qemu_init_main_loop(&error_fatal);
 327     process_options(argc, argv);
 328
 329     while (!exit_requested) {
 330         main_loop_wait(false);
 331     }
 332
 333     blk_exp_close_all();
 334     bdrv_drain_all_begin();
 335     bdrv_close_all();
 336
 337     monitor_cleanup();
 338     qemu_chr_cleanup();
 339     user_creatable_cleanup();
 340
 341     return EXIT_SUCCESS;
 342 }