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
qemu_system_killed(int signal,pid_t pid)68 void qemu_system_killed(int signal, pid_t pid)
69 {
70 exit_requested = true;
71 }
72
qmp_quit(Error ** errp)73 void qmp_quit(Error **errp)
74 {
75 exit_requested = true;
76 }
77
help(void)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
init_qmp_commands(void)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
getopt_set_loc(int argc,char ** argv,const char * optstring,const struct option * longopts)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 */
process_options(int argc,char * argv[],bool pre_init_pass)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
pid_file_cleanup(void)366 static void pid_file_cleanup(void)
367 {
368 unlink(pid_file_realpath);
369 }
370
pid_file_init(void)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
main(int argc,char * argv[])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