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/help-texts.h"
  46 #include "qemu-version.h"
  47 #include "qemu/cutils.h"
  48 #include "qemu/config-file.h"
  49 #include "qemu/error-report.h"
  50 #include "qemu/help_option.h"
  51 #include "qemu/log.h"
  52 #include "qemu/main-loop.h"
  53 #include "qemu/module.h"
  54 #include "qemu/option.h"
  55 #include "qom/object_interfaces.h"
  56
  57 #include "storage-daemon/qapi/qapi-commands.h"
  58 #include "storage-daemon/qapi/qapi-init-commands.h"
  59
  60 #include "sysemu/runstate.h"
  61 #include "trace/control.h"
  62
  63 static const char *pid_file;
  64 static char *pid_file_realpath;
  65 static volatile bool exit_requested = false;
  66
  67 void qemu_system_killed(int signal, pid_t pid)
  68 {
  69     exit_requested = true;
  70 }
  71
  72 void qmp_quit(Error **errp)
  73 {
  74     exit_requested = true;
  75 }
  76
  77 static void help(void)
  78 {
  79     printf(
  80 "Usage: %s [options]\n"
  81 "QEMU storage daemon\n"
  82 "\n"
  83 "  -h, --help             display this help and exit\n"
  84 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
  85 "                         specify tracing options\n"
  86 "  -V, --version          output version information and exit\n"
  87 "\n"
  88 "  --blockdev [driver=]<driver>[,node-name=<N>][,discard=ignore|unmap]\n"
  89 "             [,cache.direct=on|off][,cache.no-flush=on|off]\n"
  90 "             [,read-only=on|off][,auto-read-only=on|off]\n"
  91 "             [,force-share=on|off][,detect-zeroes=on|off|unmap]\n"
  92 "             [,driver specific parameters...]\n"
  93 "                         configure a block backend\n"
  94 "\n"
  95 "  --chardev <options>    configure a character device backend\n"
  96 "                         (see the qemu(1) man page for possible options)\n"
  97 "\n"
  98 "  --daemonize            daemonize the process, and have the parent exit\n"
  99 "                         once startup is complete\n"
 100 "\n"
 101 "  --export [type=]nbd,id=<id>,node-name=<node-name>[,name=<export-name>]\n"
 102 "           [,writable=on|off][,bitmap=<name>]\n"
 103 "                         export the specified block node over NBD\n"
 104 "                         (requires --nbd-server)\n"
 105 "\n"
 106 #ifdef CONFIG_FUSE
 107 "  --export [type=]fuse,id=<id>,node-name=<node-name>,mountpoint=<file>\n"
 108 "           [,growable=on|off][,writable=on|off][,allow-other=on|off|auto]\n"
 109 "                         export the specified block node over FUSE\n"
 110 "\n"
 111 #endif /* CONFIG_FUSE */
 112 #ifdef CONFIG_VHOST_USER_BLK_SERVER
 113 "  --export [type=]vhost-user-blk,id=<id>,node-name=<node-name>,\n"
 114 "           addr.type=unix,addr.path=<socket-path>[,writable=on|off]\n"
 115 "           [,logical-block-size=<block-size>][,num-queues=<num-queues>]\n"
 116 "                         export the specified block node as a\n"
 117 "                         vhost-user-blk device over UNIX domain socket\n"
 118 "  --export [type=]vhost-user-blk,id=<id>,node-name=<node-name>,\n"
 119 "           addr.type=fd,addr.str=<fd>[,writable=on|off]\n"
 120 "           [,logical-block-size=<block-size>][,num-queues=<num-queues>]\n"
 121 "                         export the specified block node as a\n"
 122 "                         vhost-user-blk device over file descriptor\n"
 123 "\n"
 124 #endif /* CONFIG_VHOST_USER_BLK_SERVER */
 125 #ifdef CONFIG_VDUSE_BLK_EXPORT
 126 "  --export [type=]vduse-blk,id=<id>,node-name=<node-name>\n"
 127 "           ,name=<vduse-name>[,writable=on|off]\n"
 128 "           [,num-queues=<num-queues>][,queue-size=<queue-size>]\n"
 129 "           [,logical-block-size=<logical-block-size>]\n"
 130 "           [,serial=<serial-number>]\n"
 131 "                         export the specified block node as a\n"
 132 "                         vduse-blk device\n"
 133 "\n"
 134 #endif /* CONFIG_VDUSE_BLK_EXPORT */
 135 "  --monitor [chardev=]name[,mode=control][,pretty[=on|off]]\n"
 136 "                         configure a QMP monitor\n"
 137 "\n"
 138 "  --nbd-server addr.type=inet,addr.host=<host>,addr.port=<port>\n"
 139 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
 140 "  --nbd-server addr.type=unix,addr.path=<path>\n"
 141 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
 142 "                         start an NBD server for exporting block nodes\n"
 143 "\n"
 144 "  --object help          list object types that can be added\n"
 145 "  --object <type>,help   list properties for the given object type\n"
 146 "  --object <type>[,<property>=<value>...]\n"
 147 "                         create a new object of type <type>, setting\n"
 148 "                         properties in the order they are specified. Note\n"
 149 "                         that the 'id' property must be set.\n"
 150 "                         See the qemu(1) man page for documentation of the\n"
 151 "                         objects that can be added.\n"
 152 "\n"
 153 "  --pidfile <path>       write process ID to a file after startup\n"
 154 "\n"
 155 QEMU_HELP_BOTTOM "\n",
 156     g_get_prgname());
 157 }
 158
 159 enum {
 160     OPTION_BLOCKDEV = 256,
 161     OPTION_CHARDEV,
 162     OPTION_DAEMONIZE,
 163     OPTION_EXPORT,
 164     OPTION_MONITOR,
 165     OPTION_NBD_SERVER,
 166     OPTION_OBJECT,
 167     OPTION_PIDFILE,
 168 };
 169
 170 extern QemuOptsList qemu_chardev_opts;
 171
 172 static void init_qmp_commands(void)
 173 {
 174     qmp_init_marshal(&qmp_commands);
 175
 176     QTAILQ_INIT(&qmp_cap_negotiation_commands);
 177     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
 178                          qmp_marshal_qmp_capabilities,
 179                          QCO_ALLOW_PRECONFIG, 0);
 180 }
 181
 182 static int getopt_set_loc(int argc, char **argv, const char *optstring,
 183                           const struct option *longopts)
 184 {
 185     int c, save_index;
 186
 187     optarg = NULL;
 188     save_index = optind;
 189     c = getopt_long(argc, argv, optstring, longopts, NULL);
 190     if (optarg) {
 191         loc_set_cmdline(argv, save_index, MAX(1, optind - save_index));
 192     }
 193     return c;
 194 }
 195
 196 /**
 197  * Process QSD command-line arguments.
 198  *
 199  * This is done in two passes:
 200  *
 201  * First (@pre_init_pass is true), we do a pass where all global
 202  * arguments pertaining to the QSD process (like --help or --daemonize)
 203  * are processed.  This pass is done before most of the QEMU-specific
 204  * initialization steps (e.g. initializing the block layer or QMP), and
 205  * so must only process arguments that are not really QEMU-specific.
 206  *
 207  * Second (@pre_init_pass is false), we (sequentially) process all
 208  * QEMU/QSD-specific arguments.  Many of these arguments are effectively
 209  * translated to QMP commands (like --blockdev for blockdev-add, or
 210  * --export for block-export-add).
 211  */
 212 static void process_options(int argc, char *argv[], bool pre_init_pass)
 213 {
 214     int c;
 215
 216     static const struct option long_options[] = {
 217         {"blockdev", required_argument, NULL, OPTION_BLOCKDEV},
 218         {"chardev", required_argument, NULL, OPTION_CHARDEV},
 219         {"daemonize", no_argument, NULL, OPTION_DAEMONIZE},
 220         {"export", required_argument, NULL, OPTION_EXPORT},
 221         {"help", no_argument, NULL, 'h'},
 222         {"monitor", required_argument, NULL, OPTION_MONITOR},
 223         {"nbd-server", required_argument, NULL, OPTION_NBD_SERVER},
 224         {"object", required_argument, NULL, OPTION_OBJECT},
 225         {"pidfile", required_argument, NULL, OPTION_PIDFILE},
 226         {"trace", required_argument, NULL, 'T'},
 227         {"version", no_argument, NULL, 'V'},
 228         {0, 0, 0, 0}
 229     };
 230
 231     /*
 232      * In contrast to the system emulator, QEMU-specific options are processed
 233      * in the order they are given on the command lines. This means that things
 234      * must be defined first before they can be referenced in another option.
 235      */
 236     optind = 1;
 237     while ((c = getopt_set_loc(argc, argv, "-hT:V", long_options)) != -1) {
 238         bool handle_option_pre_init;
 239
 240         /* Should this argument be processed in the pre-init pass? */
 241         handle_option_pre_init =
 242             c == '?' ||
 243             c == 'h' ||
 244             c == 'V' ||
 245             c == OPTION_DAEMONIZE ||
 246             c == OPTION_PIDFILE;
 247
 248         /* Process every option only in its respective pass */
 249         if (pre_init_pass != handle_option_pre_init) {
 250             continue;
 251         }
 252
 253         switch (c) {
 254         case '?':
 255             exit(EXIT_FAILURE);
 256         case 'h':
 257             help();
 258             exit(EXIT_SUCCESS);
 259         case 'T':
 260             trace_opt_parse(optarg);
 261             trace_init_file();
 262             break;
 263         case 'V':
 264             printf("qemu-storage-daemon version "
 265                    QEMU_FULL_VERSION "\n" QEMU_COPYRIGHT "\n");
 266             exit(EXIT_SUCCESS);
 267         case OPTION_BLOCKDEV:
 268             {
 269                 Visitor *v;
 270                 BlockdevOptions *options;
 271
 272                 v = qobject_input_visitor_new_str(optarg, "driver",
 273                                                   &error_fatal);
 274
 275                 visit_type_BlockdevOptions(v, NULL, &options, &error_fatal);
 276                 visit_free(v);
 277
 278                 qmp_blockdev_add(options, &error_fatal);
 279                 qapi_free_BlockdevOptions(options);
 280                 break;
 281             }
 282         case OPTION_CHARDEV:
 283             {
 284                 /* TODO This interface is not stable until we QAPIfy it */
 285                 QemuOpts *opts = qemu_opts_parse_noisily(&qemu_chardev_opts,
 286                                                          optarg, true);
 287                 if (opts == NULL) {
 288                     exit(EXIT_FAILURE);
 289                 }
 290
 291                 if (!qemu_chr_new_from_opts(opts, NULL, &error_fatal)) {
 292                     /* No error, but NULL returned means help was printed */
 293                     exit(EXIT_SUCCESS);
 294                 }
 295                 qemu_opts_del(opts);
 296                 break;
 297             }
 298         case OPTION_DAEMONIZE:
 299             if (os_set_daemonize(true) < 0) {
 300                 /*
 301                  * --daemonize is parsed before monitor_init_globals_core(), so
 302                  * error_report() does not work yet
 303                  */
 304                 fprintf(stderr, "--daemonize not supported in this build\n");
 305                 exit(EXIT_FAILURE);
 306             }
 307             break;
 308         case OPTION_EXPORT:
 309             {
 310                 Visitor *v;
 311                 BlockExportOptions *export;
 312
 313                 v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
 314                 visit_type_BlockExportOptions(v, NULL, &export, &error_fatal);
 315                 visit_free(v);
 316
 317                 qmp_block_export_add(export, &error_fatal);
 318                 qapi_free_BlockExportOptions(export);
 319                 break;
 320             }
 321         case OPTION_MONITOR:
 322             {
 323                 Visitor *v;
 324                 MonitorOptions *monitor;
 325
 326                 v = qobject_input_visitor_new_str(optarg, "chardev",
 327                                                   &error_fatal);
 328                 visit_type_MonitorOptions(v, NULL, &monitor, &error_fatal);
 329                 visit_free(v);
 330
 331                 /* TODO Catch duplicate monitor IDs */
 332                 monitor_init(monitor, false, &error_fatal);
 333                 qapi_free_MonitorOptions(monitor);
 334                 break;
 335             }
 336         case OPTION_NBD_SERVER:
 337             {
 338                 Visitor *v;
 339                 NbdServerOptions *options;
 340
 341                 v = qobject_input_visitor_new_str(optarg, NULL, &error_fatal);
 342                 visit_type_NbdServerOptions(v, NULL, &options, &error_fatal);
 343                 visit_free(v);
 344
 345                 nbd_server_start_options(options, &error_fatal);
 346                 qapi_free_NbdServerOptions(options);
 347                 break;
 348             }
 349         case OPTION_OBJECT:
 350             user_creatable_process_cmdline(optarg);
 351             break;
 352         case OPTION_PIDFILE:
 353             pid_file = optarg;
 354             break;
 355         case 1:
 356             error_report("Unexpected argument");
 357             exit(EXIT_FAILURE);
 358         default:
 359             g_assert_not_reached();
 360         }
 361     }
 362     loc_set_none();
 363 }
 364
 365 static void pid_file_cleanup(void)
 366 {
 367     unlink(pid_file_realpath);
 368 }
 369
 370 static void pid_file_init(void)
 371 {
 372     Error *err = NULL;
 373
 374     if (!pid_file) {
 375         return;
 376     }
 377
 378     if (!qemu_write_pidfile(pid_file, &err)) {
 379         error_reportf_err(err, "cannot create PID file: ");
 380         exit(EXIT_FAILURE);
 381     }
 382
 383     pid_file_realpath = g_malloc(PATH_MAX);
 384     if (!realpath(pid_file, pid_file_realpath)) {
 385         error_report("cannot resolve PID file path: %s: %s",
 386                      pid_file, strerror(errno));
 387         unlink(pid_file);
 388         exit(EXIT_FAILURE);
 389     }
 390
 391     atexit(pid_file_cleanup);
 392 }
 393
 394 int main(int argc, char *argv[])
 395 {
 396 #ifdef CONFIG_POSIX
 397     signal(SIGPIPE, SIG_IGN);
 398 #endif
 399
 400     error_init(argv[0]);
 401     qemu_init_exec_dir(argv[0]);
 402     os_setup_signal_handling();
 403
 404     process_options(argc, argv, true);
 405
 406     os_daemonize();
 407
 408     module_call_init(MODULE_INIT_QOM);
 409     module_call_init(MODULE_INIT_TRACE);
 410     qemu_add_opts(&qemu_trace_opts);
 411     qcrypto_init(&error_fatal);
 412     bdrv_init();
 413     monitor_init_globals_core();
 414     init_qmp_commands();
 415
 416     if (!trace_init_backends()) {
 417         return EXIT_FAILURE;
 418     }
 419     qemu_set_log(LOG_TRACE, &error_fatal);
 420
 421     qemu_init_main_loop(&error_fatal);
 422     process_options(argc, argv, false);
 423
 424     /*
 425      * Write the pid file after creating chardevs, exports, and NBD servers but
 426      * before accepting connections. This ordering is documented. Do not change
 427      * it.
 428      */
 429     pid_file_init();
 430     os_setup_post();
 431
 432     while (!exit_requested) {
 433         main_loop_wait(false);
 434     }
 435
 436     blk_exp_close_all();
 437     bdrv_drain_all_begin();
 438     job_cancel_sync_all();
 439     bdrv_close_all();
 440
 441     monitor_cleanup();
 442     qemu_chr_cleanup();
 443     user_creatable_cleanup();
 444
 445     return EXIT_SUCCESS;
 446 }