Merge tag 'v7.1.0-rc1'
[qemu/ar7.git] / qemu-nbd.c
blob0cd5aa6f02bc2c0b4d8deb6257cbb6a7469daf8b
1 /*
2  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
3  *
4  *  Network Block Device
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; under version 2 of the License.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
17  */
19 #include "qemu/osdep.h"
20 #include <getopt.h>
21 #include <libgen.h>
22 #include <pthread.h>
24 #include "qemu/help-texts.h"
25 #include "qapi/error.h"
26 #include "qemu/cutils.h"
27 #include "sysemu/block-backend.h"
28 #include "sysemu/runstate.h" /* for qemu_system_killed() prototype */
29 #include "block/block_int.h"
30 #include "block/nbd.h"
31 #include "qemu/main-loop.h"
32 #include "qemu/module.h"
33 #include "qemu/option.h"
34 #include "qemu/error-report.h"
35 #include "qemu/config-file.h"
36 #include "qemu/bswap.h"
37 #include "qemu/log.h"
38 #include "qemu/systemd.h"
39 #include "block/snapshot.h"
40 #include "qapi/qmp/qdict.h"
41 #include "qapi/qmp/qstring.h"
42 #include "qom/object_interfaces.h"
43 #include "io/channel-socket.h"
44 #include "io/net-listener.h"
45 #include "crypto/init.h"
46 #include "crypto/tlscreds.h"
47 #include "trace/control.h"
48 #include "qemu-version.h"
50 #ifdef CONFIG_SELINUX
51 #include <selinux/selinux.h>
52 #endif
54 #ifdef __linux__
55 #define HAVE_NBD_DEVICE 1
56 #else
57 #define HAVE_NBD_DEVICE 0
58 #endif
60 #define SOCKET_PATH                "/var/lock/qemu-nbd-%s"
61 #define QEMU_NBD_OPT_CACHE         256
62 #define QEMU_NBD_OPT_AIO           257
63 #define QEMU_NBD_OPT_DISCARD       258
64 #define QEMU_NBD_OPT_DETECT_ZEROES 259
65 #define QEMU_NBD_OPT_OBJECT        260
66 #define QEMU_NBD_OPT_TLSCREDS      261
67 #define QEMU_NBD_OPT_IMAGE_OPTS    262
68 #define QEMU_NBD_OPT_FORK          263
69 #define QEMU_NBD_OPT_TLSAUTHZ      264
70 #define QEMU_NBD_OPT_PID_FILE      265
71 #define QEMU_NBD_OPT_SELINUX_LABEL 266
72 #define QEMU_NBD_OPT_TLSHOSTNAME   267
74 #define MBR_SIZE 512
76 static int verbose;
77 static char *srcpath;
78 static SocketAddress *saddr;
79 static int persistent = 0;
80 static enum { RUNNING, TERMINATE, TERMINATED } state;
81 static int shared = 1;
82 static int nb_fds;
83 static QIONetListener *server;
84 static QCryptoTLSCreds *tlscreds;
85 static const char *tlsauthz;
87 static void usage(const char *name)
89     (printf) (
90 "Usage: %s [OPTIONS] FILE\n"
91 "  or:  %s -L [OPTIONS]\n"
92 "QEMU Disk Network Block Device Utility\n"
93 "\n"
94 "  -h, --help                display this help and exit\n"
95 "  -V, --version             output version information and exit\n"
96 "\n"
97 "Connection properties:\n"
98 "  -p, --port=PORT           port to listen on (default `%d')\n"
99 "  -b, --bind=IFACE          interface to bind to (default `0.0.0.0')\n"
100 "  -k, --socket=PATH         path to the unix socket\n"
101 "                            (default '"SOCKET_PATH"')\n"
102 "  -e, --shared=NUM          device can be shared by NUM clients (default '1')\n"
103 "  -t, --persistent          don't exit on the last connection\n"
104 "  -v, --verbose             display extra debugging information\n"
105 "  -x, --export-name=NAME    expose export by name (default is empty string)\n"
106 "  -D, --description=TEXT    export a human-readable description\n"
107 "\n"
108 "Exposing part of the image:\n"
109 "  -o, --offset=OFFSET       offset into the image\n"
110 "  -A, --allocation-depth    expose the allocation depth\n"
111 "  -B, --bitmap=NAME         expose a persistent dirty bitmap\n"
112 "\n"
113 "General purpose options:\n"
114 "  -L, --list                list exports available from another NBD server\n"
115 "  --object type,id=ID,...   define an object such as 'secret' for providing\n"
116 "                            passwords and/or encryption keys\n"
117 "  --tls-creds=ID            use id of an earlier --object to provide TLS\n"
118 "  --tls-authz=ID            use id of an earlier --object to provide\n"
119 "                            authorization\n"
120 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
121 "                            specify tracing options\n"
122 "  --fork                    fork off the server process and exit the parent\n"
123 "                            once the server is running\n"
124 "  --pid-file=PATH           store the server's process ID in the given file\n"
125 #ifdef CONFIG_SELINUX
126 "  --selinux-label=LABEL     set SELinux process label on listening socket\n"
127 #endif
128 #if HAVE_NBD_DEVICE
129 "\n"
130 "Kernel NBD client support:\n"
131 "  -c, --connect=DEV         connect FILE to the local NBD device DEV\n"
132 "  -d, --disconnect          disconnect the specified device\n"
133 #endif
134 "\n"
135 "Block device options:\n"
136 "  -f, --format=FORMAT       set image format (raw, qcow2, ...)\n"
137 "  -r, --read-only           export read-only\n"
138 "  -s, --snapshot            use FILE as an external snapshot, create a temporary\n"
139 "                            file with backing_file=FILE, redirect the write to\n"
140 "                            the temporary one\n"
141 "  -l, --load-snapshot=SNAPSHOT_PARAM\n"
142 "                            load an internal snapshot inside FILE and export it\n"
143 "                            as an read-only device, SNAPSHOT_PARAM format is\n"
144 "                            'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
145 "                            '[ID_OR_NAME]'\n"
146 "  -n, --nocache             disable host cache\n"
147 "      --cache=MODE          set cache mode used to access the disk image, the\n"
148 "                            valid options are: 'none', 'writeback' (default),\n"
149 "                            'writethrough', 'directsync' and 'unsafe'\n"
150 "      --aio=MODE            set AIO mode (native, io_uring or threads)\n"
151 "      --discard=MODE        set discard mode (ignore, unmap)\n"
152 "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
153 "      --image-opts          treat FILE as a full set of image options\n"
154 "\n"
155 QEMU_HELP_BOTTOM "\n"
156     , name, name, NBD_DEFAULT_PORT, "DEVICE");
159 static void version(const char *name)
161     printf(
162 "%s " QEMU_FULL_VERSION "\n"
163 "Written by Anthony Liguori.\n"
164 "\n"
165 QEMU_COPYRIGHT "\n"
166 "This is free software; see the source for copying conditions.  There is NO\n"
167 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
168     , name);
171 #ifdef CONFIG_POSIX
173  * The client thread uses SIGTERM to interrupt the server.  A signal
174  * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
175  */
176 void qemu_system_killed(int signum, pid_t pid)
178     qatomic_cmpxchg(&state, RUNNING, TERMINATE);
179     qemu_notify_event();
181 #endif /* CONFIG_POSIX */
183 static int qemu_nbd_client_list(SocketAddress *saddr, QCryptoTLSCreds *tls,
184                                 const char *hostname)
186     int ret = EXIT_FAILURE;
187     int rc;
188     Error *err = NULL;
189     QIOChannelSocket *sioc;
190     NBDExportInfo *list;
191     int i, j;
193     sioc = qio_channel_socket_new();
194     if (qio_channel_socket_connect_sync(sioc, saddr, &err) < 0) {
195         error_report_err(err);
196         goto out;
197     }
198     rc = nbd_receive_export_list(QIO_CHANNEL(sioc), tls, hostname, &list,
199                                  &err);
200     if (rc < 0) {
201         if (err) {
202             error_report_err(err);
203         }
204         goto out;
205     }
206     printf("exports available: %d\n", rc);
207     for (i = 0; i < rc; i++) {
208         printf(" export: '%s'\n", list[i].name);
209         if (list[i].description && *list[i].description) {
210             printf("  description: %s\n", list[i].description);
211         }
212         if (list[i].flags & NBD_FLAG_HAS_FLAGS) {
213             static const char *const flag_names[] = {
214                 [NBD_FLAG_READ_ONLY_BIT]            = "readonly",
215                 [NBD_FLAG_SEND_FLUSH_BIT]           = "flush",
216                 [NBD_FLAG_SEND_FUA_BIT]             = "fua",
217                 [NBD_FLAG_ROTATIONAL_BIT]           = "rotational",
218                 [NBD_FLAG_SEND_TRIM_BIT]            = "trim",
219                 [NBD_FLAG_SEND_WRITE_ZEROES_BIT]    = "zeroes",
220                 [NBD_FLAG_SEND_DF_BIT]              = "df",
221                 [NBD_FLAG_CAN_MULTI_CONN_BIT]       = "multi",
222                 [NBD_FLAG_SEND_RESIZE_BIT]          = "resize",
223                 [NBD_FLAG_SEND_CACHE_BIT]           = "cache",
224                 [NBD_FLAG_SEND_FAST_ZERO_BIT]       = "fast-zero",
225             };
227             printf("  size:  %" PRIu64 "\n", list[i].size);
228             printf("  flags: 0x%x (", list[i].flags);
229             for (size_t bit = 0; bit < ARRAY_SIZE(flag_names); bit++) {
230                 if (flag_names[bit] && (list[i].flags & (1 << bit))) {
231                     printf(" %s", flag_names[bit]);
232                 }
233             }
234             printf(" )\n");
235         }
236         if (list[i].min_block) {
237             printf("  min block: %u\n", list[i].min_block);
238             printf("  opt block: %u\n", list[i].opt_block);
239             printf("  max block: %u\n", list[i].max_block);
240         }
241         if (list[i].n_contexts) {
242             printf("  available meta contexts: %d\n", list[i].n_contexts);
243             for (j = 0; j < list[i].n_contexts; j++) {
244                 printf("   %s\n", list[i].contexts[j]);
245             }
246         }
247     }
248     nbd_free_export_list(list, rc);
250     ret = EXIT_SUCCESS;
251  out:
252     object_unref(OBJECT(sioc));
253     return ret;
257 #if HAVE_NBD_DEVICE
258 static void *show_parts(void *arg)
260     char *device = arg;
261     int nbd;
263     /* linux just needs an open() to trigger
264      * the partition table update
265      * but remember to load the module with max_part != 0 :
266      *     modprobe nbd max_part=63
267      */
268     nbd = open(device, O_RDWR);
269     if (nbd >= 0) {
270         close(nbd);
271     }
272     return NULL;
275 static void *nbd_client_thread(void *arg)
277     char *device = arg;
278     NBDExportInfo info = { .request_sizes = false, .name = g_strdup("") };
279     QIOChannelSocket *sioc;
280     int fd = -1;
281     int ret = EXIT_FAILURE;
282     pthread_t show_parts_thread;
283     Error *local_error = NULL;
285     sioc = qio_channel_socket_new();
286     if (qio_channel_socket_connect_sync(sioc,
287                                         saddr,
288                                         &local_error) < 0) {
289         error_report_err(local_error);
290         goto out;
291     }
293     if (nbd_receive_negotiate(NULL, QIO_CHANNEL(sioc),
294                               NULL, NULL, NULL, &info, &local_error) < 0) {
295         if (local_error) {
296             error_report_err(local_error);
297         }
298         goto out;
299     }
301     fd = open(device, O_RDWR);
302     if (fd < 0) {
303         /* Linux-only, we can use %m in printf.  */
304         error_report("Failed to open %s: %m", device);
305         goto out;
306     }
308     if (nbd_init(fd, sioc, &info, &local_error) < 0) {
309         error_report_err(local_error);
310         goto out;
311     }
313     /* update partition table */
314     pthread_create(&show_parts_thread, NULL, show_parts, device);
316     if (verbose) {
317         fprintf(stderr, "NBD device %s is now connected to %s\n",
318                 device, srcpath);
319     } else {
320         /* Close stderr so that the qemu-nbd process exits.  */
321         dup2(STDOUT_FILENO, STDERR_FILENO);
322     }
324     if (nbd_client(fd) < 0) {
325         goto out;
326     }
328     ret = EXIT_SUCCESS;
330  out:
331     if (fd >= 0) {
332         close(fd);
333     }
334     object_unref(OBJECT(sioc));
335     g_free(info.name);
336     kill(getpid(), SIGTERM);
337     return (void *) (intptr_t) ret;
339 #endif /* HAVE_NBD_DEVICE */
341 static int nbd_can_accept(void)
343     return state == RUNNING && (shared == 0 || nb_fds < shared);
346 static void nbd_update_server_watch(void);
348 static void nbd_client_closed(NBDClient *client, bool negotiated)
350     nb_fds--;
351     if (negotiated && nb_fds == 0 && !persistent && state == RUNNING) {
352         state = TERMINATE;
353     }
354     nbd_update_server_watch();
355     nbd_client_put(client);
358 static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc,
359                        gpointer opaque)
361     if (state >= TERMINATE) {
362         return;
363     }
365     nb_fds++;
366     nbd_update_server_watch();
367     nbd_client_new(cioc, tlscreds, tlsauthz, nbd_client_closed);
370 static void nbd_update_server_watch(void)
372     if (nbd_can_accept()) {
373         qio_net_listener_set_client_func(server, nbd_accept, NULL, NULL);
374     } else {
375         qio_net_listener_set_client_func(server, NULL, NULL, NULL);
376     }
380 static SocketAddress *nbd_build_socket_address(const char *sockpath,
381                                                const char *bindto,
382                                                const char *port)
384     SocketAddress *saddr;
386     saddr = g_new0(SocketAddress, 1);
387     if (sockpath) {
388         saddr->type = SOCKET_ADDRESS_TYPE_UNIX;
389         saddr->u.q_unix.path = g_strdup(sockpath);
390     } else {
391         InetSocketAddress *inet;
392         saddr->type = SOCKET_ADDRESS_TYPE_INET;
393         inet = &saddr->u.inet;
394         inet->host = g_strdup(bindto);
395         if (port) {
396             inet->port = g_strdup(port);
397         } else  {
398             inet->port = g_strdup_printf("%d", NBD_DEFAULT_PORT);
399         }
400     }
402     return saddr;
406 static QemuOptsList file_opts = {
407     .name = "file",
408     .implied_opt_name = "file",
409     .head = QTAILQ_HEAD_INITIALIZER(file_opts.head),
410     .desc = {
411         /* no elements => accept any params */
412         { /* end of list */ }
413     },
416 static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, bool list,
417                                           Error **errp)
419     Object *obj;
420     QCryptoTLSCreds *creds;
422     obj = object_resolve_path_component(
423         object_get_objects_root(), id);
424     if (!obj) {
425         error_setg(errp, "No TLS credentials with id '%s'",
426                    id);
427         return NULL;
428     }
429     creds = (QCryptoTLSCreds *)
430         object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS);
431     if (!creds) {
432         error_setg(errp, "Object with id '%s' is not TLS credentials",
433                    id);
434         return NULL;
435     }
437     if (!qcrypto_tls_creds_check_endpoint(creds,
438                                           list
439                                           ? QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT
440                                           : QCRYPTO_TLS_CREDS_ENDPOINT_SERVER,
441                                           errp)) {
442         return NULL;
443     }
444     object_ref(obj);
445     return creds;
448 static void setup_address_and_port(const char **address, const char **port)
450     if (*address == NULL) {
451         *address = "0.0.0.0";
452     }
454     if (*port == NULL) {
455         *port = stringify(NBD_DEFAULT_PORT);
456     }
460  * Check socket parameters compatibility when socket activation is used.
461  */
462 static const char *socket_activation_validate_opts(const char *device,
463                                                    const char *sockpath,
464                                                    const char *address,
465                                                    const char *port,
466                                                    const char *selinux,
467                                                    bool list)
469     if (device != NULL) {
470         return "NBD device can't be set when using socket activation";
471     }
473     if (sockpath != NULL) {
474         return "Unix socket can't be set when using socket activation";
475     }
477     if (address != NULL) {
478         return "The interface can't be set when using socket activation";
479     }
481     if (port != NULL) {
482         return "TCP port number can't be set when using socket activation";
483     }
485     if (selinux != NULL) {
486         return "SELinux label can't be set when using socket activation";
487     }
489     if (list) {
490         return "List mode is incompatible with socket activation";
491     }
493     return NULL;
496 static void qemu_nbd_shutdown(void)
498     job_cancel_sync_all();
499     blk_exp_close_all();
500     bdrv_close_all();
503 int main(int argc, char **argv)
505     BlockBackend *blk;
506     BlockDriverState *bs;
507     uint64_t dev_offset = 0;
508     bool readonly = false;
509     bool disconnect = false;
510     const char *bindto = NULL;
511     const char *port = NULL;
512     char *sockpath = NULL;
513     char *device = NULL;
514     QemuOpts *sn_opts = NULL;
515     const char *sn_id_or_name = NULL;
516     const char *sopt = "hVb:o:p:rsnc:dvk:e:f:tl:x:T:D:AB:L";
517     struct option lopt[] = {
518         { "help", no_argument, NULL, 'h' },
519         { "version", no_argument, NULL, 'V' },
520         { "bind", required_argument, NULL, 'b' },
521         { "port", required_argument, NULL, 'p' },
522         { "socket", required_argument, NULL, 'k' },
523         { "offset", required_argument, NULL, 'o' },
524         { "read-only", no_argument, NULL, 'r' },
525         { "allocation-depth", no_argument, NULL, 'A' },
526         { "bitmap", required_argument, NULL, 'B' },
527         { "connect", required_argument, NULL, 'c' },
528         { "disconnect", no_argument, NULL, 'd' },
529         { "list", no_argument, NULL, 'L' },
530         { "snapshot", no_argument, NULL, 's' },
531         { "load-snapshot", required_argument, NULL, 'l' },
532         { "nocache", no_argument, NULL, 'n' },
533         { "cache", required_argument, NULL, QEMU_NBD_OPT_CACHE },
534         { "aio", required_argument, NULL, QEMU_NBD_OPT_AIO },
535         { "discard", required_argument, NULL, QEMU_NBD_OPT_DISCARD },
536         { "detect-zeroes", required_argument, NULL,
537           QEMU_NBD_OPT_DETECT_ZEROES },
538         { "shared", required_argument, NULL, 'e' },
539         { "format", required_argument, NULL, 'f' },
540         { "persistent", no_argument, NULL, 't' },
541         { "verbose", no_argument, NULL, 'v' },
542         { "object", required_argument, NULL, QEMU_NBD_OPT_OBJECT },
543         { "export-name", required_argument, NULL, 'x' },
544         { "description", required_argument, NULL, 'D' },
545         { "tls-creds", required_argument, NULL, QEMU_NBD_OPT_TLSCREDS },
546         { "tls-hostname", required_argument, NULL, QEMU_NBD_OPT_TLSHOSTNAME },
547         { "tls-authz", required_argument, NULL, QEMU_NBD_OPT_TLSAUTHZ },
548         { "image-opts", no_argument, NULL, QEMU_NBD_OPT_IMAGE_OPTS },
549         { "trace", required_argument, NULL, 'T' },
550         { "fork", no_argument, NULL, QEMU_NBD_OPT_FORK },
551         { "pid-file", required_argument, NULL, QEMU_NBD_OPT_PID_FILE },
552         { "selinux-label", required_argument, NULL,
553           QEMU_NBD_OPT_SELINUX_LABEL },
554         { NULL, 0, NULL, 0 }
555     };
556     int ch;
557     int opt_ind = 0;
558     int flags = BDRV_O_RDWR;
559     int ret = 0;
560     bool seen_cache = false;
561     bool seen_discard = false;
562     bool seen_aio = false;
563     pthread_t client_thread;
564     const char *fmt = NULL;
565     Error *local_err = NULL;
566     BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
567     QDict *options = NULL;
568     const char *export_name = NULL; /* defaults to "" later for server mode */
569     const char *export_description = NULL;
570     BlockDirtyBitmapOrStrList *bitmaps = NULL;
571     bool alloc_depth = false;
572     const char *tlscredsid = NULL;
573     const char *tlshostname = NULL;
574     bool imageOpts = false;
575     bool writethrough = false; /* Client will flush as needed. */
576     bool fork_process = false;
577     bool list = false;
578     int old_stderr = -1;
579     unsigned socket_activation;
580     const char *pid_file_name = NULL;
581     const char *selinux_label = NULL;
582     BlockExportOptions *export_opts;
584 #ifdef CONFIG_POSIX
585     os_setup_early_signal_handling();
586     os_setup_signal_handling();
587 #endif
589     socket_init();
590     error_init(argv[0]);
591     module_call_init(MODULE_INIT_TRACE);
592     qcrypto_init(&error_fatal);
594     module_call_init(MODULE_INIT_QOM);
595     qemu_add_opts(&qemu_trace_opts);
596     qemu_init_exec_dir(argv[0]);
598     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
599         switch (ch) {
600         case 's':
601             flags |= BDRV_O_SNAPSHOT;
602             break;
603         case 'n':
604             optarg = (char *) "none";
605             /* fallthrough */
606         case QEMU_NBD_OPT_CACHE:
607             if (seen_cache) {
608                 error_report("-n and --cache can only be specified once");
609                 exit(EXIT_FAILURE);
610             }
611             seen_cache = true;
612             if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) == -1) {
613                 error_report("Invalid cache mode `%s'", optarg);
614                 exit(EXIT_FAILURE);
615             }
616             break;
617         case QEMU_NBD_OPT_AIO:
618             if (seen_aio) {
619                 error_report("--aio can only be specified once");
620                 exit(EXIT_FAILURE);
621             }
622             seen_aio = true;
623             if (bdrv_parse_aio(optarg, &flags) < 0) {
624                 error_report("Invalid aio mode '%s'", optarg);
625                 exit(EXIT_FAILURE);
626             }
627             break;
628         case QEMU_NBD_OPT_DISCARD:
629             if (seen_discard) {
630                 error_report("--discard can only be specified once");
631                 exit(EXIT_FAILURE);
632             }
633             seen_discard = true;
634             if (bdrv_parse_discard_flags(optarg, &flags) == -1) {
635                 error_report("Invalid discard mode `%s'", optarg);
636                 exit(EXIT_FAILURE);
637             }
638             break;
639         case QEMU_NBD_OPT_DETECT_ZEROES:
640             detect_zeroes =
641                 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
642                                 optarg,
643                                 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
644                                 &local_err);
645             if (local_err) {
646                 error_reportf_err(local_err,
647                                   "Failed to parse detect_zeroes mode: ");
648                 exit(EXIT_FAILURE);
649             }
650             if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
651                 !(flags & BDRV_O_UNMAP)) {
652                 error_report("setting detect-zeroes to unmap is not allowed "
653                              "without setting discard operation to unmap");
654                 exit(EXIT_FAILURE);
655             }
656             break;
657         case 'b':
658             bindto = optarg;
659             break;
660         case 'p':
661             port = optarg;
662             break;
663         case 'o':
664             if (qemu_strtou64(optarg, NULL, 0, &dev_offset) < 0) {
665                 error_report("Invalid offset '%s'", optarg);
666                 exit(EXIT_FAILURE);
667             }
668             break;
669         case 'l':
670             if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
671                 sn_opts = qemu_opts_parse_noisily(&internal_snapshot_opts,
672                                                   optarg, false);
673                 if (!sn_opts) {
674                     error_report("Failed in parsing snapshot param `%s'",
675                                  optarg);
676                     exit(EXIT_FAILURE);
677                 }
678             } else {
679                 sn_id_or_name = optarg;
680             }
681             /* fall through */
682         case 'r':
683             readonly = true;
684             flags &= ~BDRV_O_RDWR;
685             break;
686         case 'A':
687             alloc_depth = true;
688             break;
689         case 'B':
690             {
691                 BlockDirtyBitmapOrStr *el = g_new(BlockDirtyBitmapOrStr, 1);
692                 *el = (BlockDirtyBitmapOrStr) {
693                     .type = QTYPE_QSTRING,
694                     .u.local = g_strdup(optarg),
695                 };
696                 QAPI_LIST_PREPEND(bitmaps, el);
697             }
698             break;
699         case 'k':
700             sockpath = optarg;
701             if (sockpath[0] != '/') {
702                 error_report("socket path must be absolute");
703                 exit(EXIT_FAILURE);
704             }
705             break;
706         case 'd':
707             disconnect = true;
708             break;
709         case 'c':
710             device = optarg;
711             break;
712         case 'e':
713             if (qemu_strtoi(optarg, NULL, 0, &shared) < 0 ||
714                 shared < 0) {
715                 error_report("Invalid shared device number '%s'", optarg);
716                 exit(EXIT_FAILURE);
717             }
718             break;
719         case 'f':
720             fmt = optarg;
721             break;
722         case 't':
723             persistent = 1;
724             break;
725         case 'x':
726             export_name = optarg;
727             if (strlen(export_name) > NBD_MAX_STRING_SIZE) {
728                 error_report("export name '%s' too long", export_name);
729                 exit(EXIT_FAILURE);
730             }
731             break;
732         case 'D':
733             export_description = optarg;
734             if (strlen(export_description) > NBD_MAX_STRING_SIZE) {
735                 error_report("export description '%s' too long",
736                              export_description);
737                 exit(EXIT_FAILURE);
738             }
739             break;
740         case 'v':
741             verbose = 1;
742             break;
743         case 'V':
744             version(argv[0]);
745             exit(0);
746             break;
747         case 'h':
748             usage(argv[0]);
749             exit(0);
750             break;
751         case '?':
752             error_report("Try `%s --help' for more information.", argv[0]);
753             exit(EXIT_FAILURE);
754         case QEMU_NBD_OPT_OBJECT:
755             user_creatable_process_cmdline(optarg);
756             break;
757         case QEMU_NBD_OPT_TLSCREDS:
758             tlscredsid = optarg;
759             break;
760         case QEMU_NBD_OPT_TLSHOSTNAME:
761             tlshostname = optarg;
762             break;
763         case QEMU_NBD_OPT_IMAGE_OPTS:
764             imageOpts = true;
765             break;
766         case 'T':
767             trace_opt_parse(optarg);
768             break;
769         case QEMU_NBD_OPT_TLSAUTHZ:
770             tlsauthz = optarg;
771             break;
772         case QEMU_NBD_OPT_FORK:
773             fork_process = true;
774             break;
775         case 'L':
776             list = true;
777             break;
778         case QEMU_NBD_OPT_PID_FILE:
779             pid_file_name = optarg;
780             break;
781         case QEMU_NBD_OPT_SELINUX_LABEL:
782             selinux_label = optarg;
783             break;
784         }
785     }
787     if (list) {
788         if (argc != optind) {
789             error_report("List mode is incompatible with a file name");
790             exit(EXIT_FAILURE);
791         }
792         if (export_name || export_description || dev_offset ||
793             device || disconnect || fmt || sn_id_or_name || bitmaps ||
794             alloc_depth || seen_aio || seen_discard || seen_cache) {
795             error_report("List mode is incompatible with per-device settings");
796             exit(EXIT_FAILURE);
797         }
798         if (fork_process) {
799             error_report("List mode is incompatible with forking");
800             exit(EXIT_FAILURE);
801         }
802     } else if ((argc - optind) != 1) {
803         error_report("Invalid number of arguments");
804         error_printf("Try `%s --help' for more information.\n", argv[0]);
805         exit(EXIT_FAILURE);
806     } else if (!export_name) {
807         export_name = "";
808     }
810     if (!trace_init_backends()) {
811         exit(1);
812     }
813     trace_init_file();
814     qemu_set_log(LOG_TRACE, &error_fatal);
816     socket_activation = check_socket_activation();
817     if (socket_activation == 0) {
818         if (!sockpath) {
819             setup_address_and_port(&bindto, &port);
820         }
821     } else {
822         /* Using socket activation - check user didn't use -p etc. */
823         const char *err_msg = socket_activation_validate_opts(device, sockpath,
824                                                               bindto, port,
825                                                               selinux_label,
826                                                               list);
827         if (err_msg != NULL) {
828             error_report("%s", err_msg);
829             exit(EXIT_FAILURE);
830         }
832         /* qemu-nbd can only listen on a single socket.  */
833         if (socket_activation > 1) {
834             error_report("qemu-nbd does not support socket activation with %s > 1",
835                          "LISTEN_FDS");
836             exit(EXIT_FAILURE);
837         }
838     }
840     if (tlscredsid) {
841         if (device) {
842             error_report("TLS is not supported with a host device");
843             exit(EXIT_FAILURE);
844         }
845         if (tlsauthz && list) {
846             error_report("TLS authorization is incompatible with export list");
847             exit(EXIT_FAILURE);
848         }
849         if (tlshostname && !list) {
850             error_report("TLS hostname is only supported with export list");
851             exit(EXIT_FAILURE);
852         }
853         tlscreds = nbd_get_tls_creds(tlscredsid, list, &local_err);
854         if (local_err) {
855             error_reportf_err(local_err, "Failed to get TLS creds: ");
856             exit(EXIT_FAILURE);
857         }
858     } else {
859         if (tlsauthz) {
860             error_report("--tls-authz is not permitted without --tls-creds");
861             exit(EXIT_FAILURE);
862         }
863         if (tlshostname) {
864             error_report("--tls-hostname is not permitted without --tls-creds");
865             exit(EXIT_FAILURE);
866         }
867     }
869     if (selinux_label) {
870 #ifdef CONFIG_SELINUX
871         if (sockpath == NULL && device == NULL) {
872             error_report("--selinux-label is not permitted without --socket");
873             exit(EXIT_FAILURE);
874         }
875 #else
876         error_report("SELinux support not enabled in this binary");
877         exit(EXIT_FAILURE);
878 #endif
879     }
881     if (list) {
882         saddr = nbd_build_socket_address(sockpath, bindto, port);
883         return qemu_nbd_client_list(saddr, tlscreds,
884                                     tlshostname ? tlshostname : bindto);
885     }
887 #if !HAVE_NBD_DEVICE
888     if (disconnect || device) {
889         error_report("Kernel /dev/nbdN support not available");
890         exit(EXIT_FAILURE);
891     }
892 #else /* HAVE_NBD_DEVICE */
893     if (disconnect) {
894         int nbdfd = open(argv[optind], O_RDWR);
895         if (nbdfd < 0) {
896             error_report("Cannot open %s: %s", argv[optind],
897                          strerror(errno));
898             exit(EXIT_FAILURE);
899         }
900         nbd_disconnect(nbdfd);
902         close(nbdfd);
904         printf("%s disconnected\n", argv[optind]);
906         return 0;
907     }
908 #endif
910     if ((device && !verbose) || fork_process) {
911 #ifndef WIN32
912         g_autoptr(GError) err = NULL;
913         int stderr_fd[2];
914         pid_t pid;
915         int ret;
917         if (!g_unix_open_pipe(stderr_fd, FD_CLOEXEC, &err)) {
918             error_report("Error setting up communication pipe: %s",
919                          err->message);
920             exit(EXIT_FAILURE);
921         }
923         /* Now daemonize, but keep a communication channel open to
924          * print errors and exit with the proper status code.
925          */
926         pid = fork();
927         if (pid < 0) {
928             error_report("Failed to fork: %s", strerror(errno));
929             exit(EXIT_FAILURE);
930         } else if (pid == 0) {
931             close(stderr_fd[0]);
933             /* Remember parent's stderr if we will be restoring it. */
934             if (fork_process) {
935                 old_stderr = dup(STDERR_FILENO);
936             }
938             ret = qemu_daemon(1, 0);
940             /* Temporarily redirect stderr to the parent's pipe...  */
941             dup2(stderr_fd[1], STDERR_FILENO);
942             if (ret < 0) {
943                 error_report("Failed to daemonize: %s", strerror(errno));
944                 exit(EXIT_FAILURE);
945             }
947             /* ... close the descriptor we inherited and go on.  */
948             close(stderr_fd[1]);
949         } else {
950             bool errors = false;
951             char *buf;
953             /* In the parent.  Print error messages from the child until
954              * it closes the pipe.
955              */
956             close(stderr_fd[1]);
957             buf = g_malloc(1024);
958             while ((ret = read(stderr_fd[0], buf, 1024)) > 0) {
959                 errors = true;
960                 ret = qemu_write_full(STDERR_FILENO, buf, ret);
961                 if (ret < 0) {
962                     exit(EXIT_FAILURE);
963                 }
964             }
965             if (ret < 0) {
966                 error_report("Cannot read from daemon: %s",
967                              strerror(errno));
968                 exit(EXIT_FAILURE);
969             }
971             /* Usually the daemon should not print any message.
972              * Exit with zero status in that case.
973              */
974             exit(errors);
975         }
976 #else /* WIN32 */
977         error_report("Unable to fork into background on Windows hosts");
978         exit(EXIT_FAILURE);
979 #endif /* WIN32 */
980     }
982     if (device != NULL && sockpath == NULL) {
983         sockpath = g_malloc(128);
984         snprintf(sockpath, 128, SOCKET_PATH, basename(device));
985     }
987     server = qio_net_listener_new();
988     if (socket_activation == 0) {
989         int backlog;
991         if (persistent || shared == 0) {
992             backlog = SOMAXCONN;
993         } else {
994             backlog = MIN(shared, SOMAXCONN);
995         }
996 #ifdef CONFIG_SELINUX
997         if (selinux_label && setsockcreatecon_raw(selinux_label) == -1) {
998             error_report("Cannot set SELinux socket create context to %s: %s",
999                          selinux_label, strerror(errno));
1000             exit(EXIT_FAILURE);
1001         }
1002 #endif
1003         saddr = nbd_build_socket_address(sockpath, bindto, port);
1004         if (qio_net_listener_open_sync(server, saddr, backlog,
1005                                        &local_err) < 0) {
1006             object_unref(OBJECT(server));
1007             error_report_err(local_err);
1008             exit(EXIT_FAILURE);
1009         }
1010 #ifdef CONFIG_SELINUX
1011         if (selinux_label && setsockcreatecon_raw(NULL) == -1) {
1012             error_report("Cannot clear SELinux socket create context: %s",
1013                          strerror(errno));
1014             exit(EXIT_FAILURE);
1015         }
1016 #endif
1017     } else {
1018         size_t i;
1019         /* See comment in check_socket_activation above. */
1020         for (i = 0; i < socket_activation; i++) {
1021             QIOChannelSocket *sioc;
1022             sioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD + i,
1023                                              &local_err);
1024             if (sioc == NULL) {
1025                 object_unref(OBJECT(server));
1026                 error_reportf_err(local_err,
1027                                   "Failed to use socket activation: ");
1028                 exit(EXIT_FAILURE);
1029             }
1030             qio_net_listener_add(server, sioc);
1031             object_unref(OBJECT(sioc));
1032         }
1033     }
1035     qemu_init_main_loop(&error_fatal);
1036     bdrv_init();
1037     atexit(qemu_nbd_shutdown);
1039     srcpath = argv[optind];
1040     if (imageOpts) {
1041         QemuOpts *opts;
1042         if (fmt) {
1043             error_report("--image-opts and -f are mutually exclusive");
1044             exit(EXIT_FAILURE);
1045         }
1046         opts = qemu_opts_parse_noisily(&file_opts, srcpath, true);
1047         if (!opts) {
1048             qemu_opts_reset(&file_opts);
1049             exit(EXIT_FAILURE);
1050         }
1051         options = qemu_opts_to_qdict(opts, NULL);
1052         qemu_opts_reset(&file_opts);
1053         blk = blk_new_open(NULL, NULL, options, flags, &local_err);
1054     } else {
1055         if (fmt) {
1056             options = qdict_new();
1057             qdict_put_str(options, "driver", fmt);
1058         }
1059         blk = blk_new_open(srcpath, NULL, options, flags, &local_err);
1060     }
1062     if (!blk) {
1063         error_reportf_err(local_err, "Failed to blk_new_open '%s': ",
1064                           argv[optind]);
1065         exit(EXIT_FAILURE);
1066     }
1067     bs = blk_bs(blk);
1069     if (dev_offset) {
1070         QDict *raw_opts = qdict_new();
1071         qdict_put_str(raw_opts, "driver", "raw");
1072         qdict_put_str(raw_opts, "file", bs->node_name);
1073         qdict_put_int(raw_opts, "offset", dev_offset);
1074         bs = bdrv_open(NULL, NULL, raw_opts, flags, &error_fatal);
1075         blk_remove_bs(blk);
1076         blk_insert_bs(blk, bs, &error_fatal);
1077         bdrv_unref(bs);
1078     }
1080     blk_set_enable_write_cache(blk, !writethrough);
1082     if (sn_opts) {
1083         ret = bdrv_snapshot_load_tmp(bs,
1084                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
1085                                      qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
1086                                      &local_err);
1087     } else if (sn_id_or_name) {
1088         ret = bdrv_snapshot_load_tmp_by_id_or_name(bs, sn_id_or_name,
1089                                                    &local_err);
1090     }
1091     if (ret < 0) {
1092         error_reportf_err(local_err, "Failed to load snapshot: ");
1093         exit(EXIT_FAILURE);
1094     }
1096     bs->detect_zeroes = detect_zeroes;
1098     nbd_server_is_qemu_nbd(shared);
1100     export_opts = g_new(BlockExportOptions, 1);
1101     *export_opts = (BlockExportOptions) {
1102         .type               = BLOCK_EXPORT_TYPE_NBD,
1103         .id                 = g_strdup("qemu-nbd-export"),
1104         .node_name          = g_strdup(bdrv_get_node_name(bs)),
1105         .has_writethrough   = true,
1106         .writethrough       = writethrough,
1107         .has_writable       = true,
1108         .writable           = !readonly,
1109         .u.nbd = {
1110             .has_name             = true,
1111             .name                 = g_strdup(export_name),
1112             .has_description      = !!export_description,
1113             .description          = g_strdup(export_description),
1114             .has_bitmaps          = !!bitmaps,
1115             .bitmaps              = bitmaps,
1116             .has_allocation_depth = alloc_depth,
1117             .allocation_depth     = alloc_depth,
1118         },
1119     };
1120     blk_exp_add(export_opts, &error_fatal);
1121     qapi_free_BlockExportOptions(export_opts);
1123     if (device) {
1124 #if HAVE_NBD_DEVICE
1125         int ret;
1127         ret = pthread_create(&client_thread, NULL, nbd_client_thread, device);
1128         if (ret != 0) {
1129             error_report("Failed to create client thread: %s", strerror(ret));
1130             exit(EXIT_FAILURE);
1131         }
1132 #endif
1133     } else {
1134         /* Shut up GCC warnings.  */
1135         memset(&client_thread, 0, sizeof(client_thread));
1136     }
1138     nbd_update_server_watch();
1140     if (pid_file_name) {
1141         qemu_write_pidfile(pid_file_name, &error_fatal);
1142     }
1144     /* now when the initialization is (almost) complete, chdir("/")
1145      * to free any busy filesystems */
1146     if (chdir("/") < 0) {
1147         error_report("Could not chdir to root directory: %s",
1148                      strerror(errno));
1149         exit(EXIT_FAILURE);
1150     }
1152     if (fork_process) {
1153         dup2(old_stderr, STDERR_FILENO);
1154         close(old_stderr);
1155     }
1157     state = RUNNING;
1158     do {
1159         main_loop_wait(false);
1160         if (state == TERMINATE) {
1161             blk_exp_close_all();
1162             state = TERMINATED;
1163         }
1164     } while (state != TERMINATED);
1166     blk_unref(blk);
1167     if (sockpath) {
1168         unlink(sockpath);
1169     }
1171     qemu_opts_del(sn_opts);
1173     if (device) {
1174         void *ret;
1175         pthread_join(client_thread, &ret);
1176         exit(ret != NULL);
1177     } else {
1178         exit(EXIT_SUCCESS);
1179     }