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 const char *pid_file;
63 static volatile bool exit_requested = false;
64 
65 void qemu_system_killed(int signal, pid_t pid)
66 {
67     exit_requested = true;
68 }
69 
70 void qmp_quit(Error **errp)
71 {
72     exit_requested = true;
73 }
74 
75 static void help(void)
76 {
77     printf(
78 "Usage: %s [options]\n"
79 "QEMU storage daemon\n"
80 "\n"
81 "  -h, --help             display this help and exit\n"
82 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
83 "                         specify tracing options\n"
84 "  -V, --version          output version information and exit\n"
85 "\n"
86 "  --blockdev [driver=]<driver>[,node-name=<N>][,discard=ignore|unmap]\n"
87 "             [,cache.direct=on|off][,cache.no-flush=on|off]\n"
88 "             [,read-only=on|off][,auto-read-only=on|off]\n"
89 "             [,force-share=on|off][,detect-zeroes=on|off|unmap]\n"
90 "             [,driver specific parameters...]\n"
91 "                         configure a block backend\n"
92 "\n"
93 "  --chardev <options>    configure a character device backend\n"
94 "                         (see the qemu(1) man page for possible options)\n"
95 "\n"
96 "  --export [type=]nbd,id=<id>,node-name=<node-name>[,name=<export-name>]\n"
97 "           [,writable=on|off][,bitmap=<name>]\n"
98 "                         export the specified block node over NBD\n"
99 "                         (requires --nbd-server)\n"
100 "\n"
101 #ifdef CONFIG_FUSE
102 "  --export [type=]fuse,id=<id>,node-name=<node-name>,mountpoint=<file>\n"
103 "           [,growable=on|off][,writable=on|off][,allow-other=on|off|auto]\n"
104 "                         export the specified block node over FUSE\n"
105 "\n"
106 #endif /* CONFIG_FUSE */
107 #ifdef CONFIG_VHOST_USER_BLK_SERVER
108 "  --export [type=]vhost-user-blk,id=<id>,node-name=<node-name>,\n"
109 "           addr.type=unix,addr.path=<socket-path>[,writable=on|off]\n"
110 "           [,logical-block-size=<block-size>][,num-queues=<num-queues>]\n"
111 "                         export the specified block node as a\n"
112 "                         vhost-user-blk device over UNIX domain socket\n"
113 "  --export [type=]vhost-user-blk,id=<id>,node-name=<node-name>,\n"
114 "           addr.type=fd,addr.str=<fd>[,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 file descriptor\n"
118 "\n"
119 #endif /* CONFIG_VHOST_USER_BLK_SERVER */
120 "  --monitor [chardev=]name[,mode=control][,pretty[=on|off]]\n"
121 "                         configure a QMP monitor\n"
122 "\n"
123 "  --nbd-server addr.type=inet,addr.host=<host>,addr.port=<port>\n"
124 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
125 "  --nbd-server addr.type=unix,addr.path=<path>\n"
126 "               [,tls-creds=<id>][,tls-authz=<id>][,max-connections=<n>]\n"
127 "                         start an NBD server for exporting block nodes\n"
128 "\n"
129 "  --object help          list object types that can be added\n"
130 "  --object <type>,help   list properties for the given object type\n"
131 "  --object <type>[,<property>=<value>...]\n"
132 "                         create a new object of type <type>, setting\n"
133 "                         properties in the order they are specified. Note\n"
134 "                         that the 'id' property must be set.\n"
135 "                         See the qemu(1) man page for documentation of the\n"
136 "                         objects that can be added.\n"
137 "\n"
138 "  --pidfile <path>       write process ID to a file after startup\n"
139 "\n"
140 QEMU_HELP_BOTTOM "\n",
141     error_get_progname());
142 }
143 
144 enum {
145     OPTION_BLOCKDEV = 256,
146     OPTION_CHARDEV,
147     OPTION_EXPORT,
148     OPTION_MONITOR,
149     OPTION_NBD_SERVER,
150     OPTION_OBJECT,
151     OPTION_PIDFILE,
152 };
153 
154 extern QemuOptsList qemu_chardev_opts;
155 
156 static void init_qmp_commands(void)
157 {
158     qmp_init_marshal(&qmp_commands);
159 
160     QTAILQ_INIT(&qmp_cap_negotiation_commands);
161     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
162                          qmp_marshal_qmp_capabilities,
163                          QCO_ALLOW_PRECONFIG, 0);
164 }
165 
166 static int getopt_set_loc(int argc, char **argv, const char *optstring,
167                           const struct option *longopts)
168 {
169     int c, save_index;
170 
171     optarg = NULL;
172     save_index = optind;
173     c = getopt_long(argc, argv, optstring, longopts, NULL);
174     if (optarg) {
175         loc_set_cmdline(argv, save_index, MAX(1, optind - save_index));
176     }
177     return c;
178 }
179 
180 static void process_options(int argc, char *argv[])
181 {
182     int c;
183 
184     static const struct option long_options[] = {
185         {"blockdev", required_argument, NULL, OPTION_BLOCKDEV},
186         {"chardev", required_argument, NULL, OPTION_CHARDEV},
187         {"export", required_argument, NULL, OPTION_EXPORT},
188         {"help", no_argument, NULL, 'h'},
189         {"monitor", required_argument, NULL, OPTION_MONITOR},
190         {"nbd-server", required_argument, NULL, OPTION_NBD_SERVER},
191         {"object", required_argument, NULL, OPTION_OBJECT},
192         {"pidfile", required_argument, NULL, OPTION_PIDFILE},
193         {"trace", required_argument, NULL, 'T'},
194         {"version", no_argument, NULL, 'V'},
195         {0, 0, 0, 0}
196     };
197 
198     /*
199      * In contrast to the system emulator, options are processed in the order
200      * they are given on the command lines. This means that things must be
201      * defined first before they can be referenced in another option.
202      */
203     while ((c = getopt_set_loc(argc, argv, "-hT:V", long_options)) != -1) {
204         switch (c) {
205         case '?':
206             exit(EXIT_FAILURE);
207         case 'h':
208             help();
209             exit(EXIT_SUCCESS);
210         case 'T':
211             trace_opt_parse(optarg);
212             trace_init_file();
213             break;
214         case 'V':
215             printf("qemu-storage-daemon version "
216                    QEMU_FULL_VERSION "\n" QEMU_COPYRIGHT "\n");
217             exit(EXIT_SUCCESS);
218         case OPTION_BLOCKDEV:
219             {
220                 Visitor *v;
221                 BlockdevOptions *options;
222 
223                 v = qobject_input_visitor_new_str(optarg, "driver",
224                                                   &error_fatal);
225 
226                 visit_type_BlockdevOptions(v, NULL, &options, &error_fatal);
227                 visit_free(v);
228 
229                 qmp_blockdev_add(options, &error_fatal);
230                 qapi_free_BlockdevOptions(options);
231                 break;
232             }
233         case OPTION_CHARDEV:
234             {
235                 /* TODO This interface is not stable until we QAPIfy it */
236                 QemuOpts *opts = qemu_opts_parse_noisily(&qemu_chardev_opts,
237                                                          optarg, true);
238                 if (opts == NULL) {
239                     exit(EXIT_FAILURE);
240                 }
241 
242                 if (!qemu_chr_new_from_opts(opts, NULL, &error_fatal)) {
243                     /* No error, but NULL returned means help was printed */
244                     exit(EXIT_SUCCESS);
245                 }
246                 qemu_opts_del(opts);
247                 break;
248             }
249         case OPTION_EXPORT:
250             {
251                 Visitor *v;
252                 BlockExportOptions *export;
253 
254                 v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
255                 visit_type_BlockExportOptions(v, NULL, &export, &error_fatal);
256                 visit_free(v);
257 
258                 qmp_block_export_add(export, &error_fatal);
259                 qapi_free_BlockExportOptions(export);
260                 break;
261             }
262         case OPTION_MONITOR:
263             {
264                 Visitor *v;
265                 MonitorOptions *monitor;
266 
267                 v = qobject_input_visitor_new_str(optarg, "chardev",
268                                                   &error_fatal);
269                 visit_type_MonitorOptions(v, NULL, &monitor, &error_fatal);
270                 visit_free(v);
271 
272                 /* TODO Catch duplicate monitor IDs */
273                 monitor_init(monitor, false, &error_fatal);
274                 qapi_free_MonitorOptions(monitor);
275                 break;
276             }
277         case OPTION_NBD_SERVER:
278             {
279                 Visitor *v;
280                 NbdServerOptions *options;
281 
282                 v = qobject_input_visitor_new_str(optarg, NULL, &error_fatal);
283                 visit_type_NbdServerOptions(v, NULL, &options, &error_fatal);
284                 visit_free(v);
285 
286                 nbd_server_start_options(options, &error_fatal);
287                 qapi_free_NbdServerOptions(options);
288                 break;
289             }
290         case OPTION_OBJECT:
291             user_creatable_process_cmdline(optarg);
292             break;
293         case OPTION_PIDFILE:
294             pid_file = optarg;
295             break;
296         case 1:
297             error_report("Unexpected argument");
298             exit(EXIT_FAILURE);
299         default:
300             g_assert_not_reached();
301         }
302     }
303     loc_set_none();
304 }
305 
306 static void pid_file_cleanup(void)
307 {
308     unlink(pid_file);
309 }
310 
311 static void pid_file_init(void)
312 {
313     Error *err = NULL;
314 
315     if (!pid_file) {
316         return;
317     }
318 
319     if (!qemu_write_pidfile(pid_file, &err)) {
320         error_reportf_err(err, "cannot create PID file: ");
321         exit(EXIT_FAILURE);
322     }
323 
324     atexit(pid_file_cleanup);
325 }
326 
327 int main(int argc, char *argv[])
328 {
329 #ifdef CONFIG_POSIX
330     signal(SIGPIPE, SIG_IGN);
331 #endif
332 
333     error_init(argv[0]);
334     qemu_init_exec_dir(argv[0]);
335     os_setup_signal_handling();
336 
337     module_call_init(MODULE_INIT_QOM);
338     module_call_init(MODULE_INIT_TRACE);
339     qemu_add_opts(&qemu_trace_opts);
340     qcrypto_init(&error_fatal);
341     bdrv_init();
342     monitor_init_globals_core();
343     init_qmp_commands();
344 
345     if (!trace_init_backends()) {
346         return EXIT_FAILURE;
347     }
348     qemu_set_log(LOG_TRACE);
349 
350     qemu_init_main_loop(&error_fatal);
351     process_options(argc, argv);
352 
353     /*
354      * Write the pid file after creating chardevs, exports, and NBD servers but
355      * before accepting connections. This ordering is documented. Do not change
356      * it.
357      */
358     pid_file_init();
359 
360     while (!exit_requested) {
361         main_loop_wait(false);
362     }
363 
364     blk_exp_close_all();
365     bdrv_drain_all_begin();
366     job_cancel_sync_all();
367     bdrv_close_all();
368 
369     monitor_cleanup();
370     qemu_chr_cleanup();
371     user_creatable_cleanup();
372 
373     return EXIT_SUCCESS;
374 }
375