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 } 447