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