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