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