blockdev: convert internal NBD server to QIONetListener

[qemu.git] / qemu-nbd.c

diff --git a/qemu-nbd.c b/qemu-nbd.c
index cca4a983b77add95d2fc103960cea010f52bf7c1..d75ca514820760a6852d9f4983788634a28402a7 100644 (file)
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -17,6 +17,10 @@
  */
 
 #include "qemu/osdep.h"
  */
 
 #include "qemu/osdep.h"

+#include <getopt.h>
+#include <libgen.h>
+#include <pthread.h>
+

 #include "qapi/error.h"
 #include "qemu-common.h"
 #include "qemu/cutils.h"
 #include "qapi/error.h"
 #include "qemu-common.h"
 #include "qemu/cutils.h"


@@ -28,17 +32,14 @@
 #include "qemu/config-file.h"
 #include "qemu/bswap.h"
 #include "qemu/log.h"
 #include "qemu/config-file.h"
 #include "qemu/bswap.h"
 #include "qemu/log.h"

+#include "qemu/systemd.h"

 #include "block/snapshot.h"
 #include "block/snapshot.h"

-#include "qapi/util.h"

 #include "qapi/qmp/qstring.h"
 #include "qom/object_interfaces.h"
 #include "io/channel-socket.h"
 #include "crypto/init.h"
 #include "trace/control.h"
 #include "qapi/qmp/qstring.h"
 #include "qom/object_interfaces.h"
 #include "io/channel-socket.h"
 #include "crypto/init.h"
 #include "trace/control.h"

-
-#include <getopt.h>
-#include <libgen.h>
-#include <pthread.h>
+#include "qemu-version.h"

 
 #define SOCKET_PATH                "/var/lock/qemu-nbd-%s"
 #define QEMU_NBD_OPT_CACHE         256
 
 #define SOCKET_PATH                "/var/lock/qemu-nbd-%s"
 #define QEMU_NBD_OPT_CACHE         256


@@ -48,6 +49,7 @@
 #define QEMU_NBD_OPT_OBJECT        260
 #define QEMU_NBD_OPT_TLSCREDS      261
 #define QEMU_NBD_OPT_IMAGE_OPTS    262
 #define QEMU_NBD_OPT_OBJECT        260
 #define QEMU_NBD_OPT_TLSCREDS      261
 #define QEMU_NBD_OPT_IMAGE_OPTS    262

+#define QEMU_NBD_OPT_FORK          263

 
 #define MBR_SIZE 512
 
 
 #define MBR_SIZE 512
 


@@ -82,6 +84,7 @@ static void usage(const char *name)
 "  -t, --persistent          don't exit on the last connection\n"
 "  -v, --verbose             display extra debugging information\n"
 "  -x, --export-name=NAME    expose export by name\n"
 "  -t, --persistent          don't exit on the last connection\n"
 "  -v, --verbose             display extra debugging information\n"
 "  -x, --export-name=NAME    expose export by name\n"

+"  -D, --description=TEXT    with -x, also export a human-readable description\n"

 "\n"
 "Exposing part of the image:\n"
 "  -o, --offset=OFFSET       offset into the image\n"
 "\n"
 "Exposing part of the image:\n"
 "  -o, --offset=OFFSET       offset into the image\n"


@@ -92,6 +95,8 @@ static void usage(const char *name)
 "                            passwords and/or encryption keys\n"
 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
 "                            specify tracing options\n"
 "                            passwords and/or encryption keys\n"
 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
 "                            specify tracing options\n"

+"  --fork                    fork off the server process and exit the parent\n"
+"                            once the server is running\n"

 #ifdef __linux__
 "Kernel NBD client support:\n"
 "  -c, --connect=DEV         connect FILE to the local NBD device DEV\n"
 #ifdef __linux__
 "Kernel NBD client support:\n"
 "  -c, --connect=DEV         connect FILE to the local NBD device DEV\n"


@@ -117,17 +122,17 @@ static void usage(const char *name)
 "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
 "      --image-opts          treat FILE as a full set of image options\n"
 "\n"
 "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
 "      --image-opts          treat FILE as a full set of image options\n"
 "\n"

-"Report bugs to <[email protected]>\n"
+QEMU_HELP_BOTTOM "\n"

     , name, NBD_DEFAULT_PORT, "DEVICE");
 }
 
 static void version(const char *name)
 {
     printf(
     , name, NBD_DEFAULT_PORT, "DEVICE");
 }
 
 static void version(const char *name)
 {
     printf(

-"%s version 0.0.1\n"
+"%s " QEMU_VERSION QEMU_PKGVERSION "\n"

 "Written by Anthony Liguori.\n"
 "\n"
 "Written by Anthony Liguori.\n"
 "\n"

-"Copyright (C) 2006 Anthony Liguori <[email protected]>.\n"
+QEMU_COPYRIGHT "\n"

 "This is free software; see the source for copying conditions.  There is NO\n"
 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
     , name);
 "This is free software; see the source for copying conditions.  There is NO\n"
 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
     , name);


@@ -250,8 +255,7 @@ static void *show_parts(void *arg)
 static void *nbd_client_thread(void *arg)
 {
     char *device = arg;
 static void *nbd_client_thread(void *arg)
 {
     char *device = arg;

-    off_t size;
-    uint16_t nbdflags;
+    NBDExportInfo info = { .request_sizes = false, };

     QIOChannelSocket *sioc;
     int fd;
     int ret;
     QIOChannelSocket *sioc;
     int fd;
     int ret;


@@ -266,9 +270,8 @@ static void *nbd_client_thread(void *arg)
         goto out;
     }
 
         goto out;
     }
 

-    ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), NULL, &nbdflags,
-                                NULL, NULL, NULL,
-                                &size, &local_error);
+    ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), NULL,
+                                NULL, NULL, NULL, &info, &local_error);

     if (ret < 0) {
         if (local_error) {
             error_report_err(local_error);
     if (ret < 0) {
         if (local_error) {
             error_report_err(local_error);


@@ -283,8 +286,9 @@ static void *nbd_client_thread(void *arg)
         goto out_socket;
     }
 
         goto out_socket;
     }
 

-    ret = nbd_init(fd, sioc, nbdflags, size);
+    ret = nbd_init(fd, sioc, &info, &local_error);

     if (ret < 0) {
     if (ret < 0) {

+        error_report_err(local_error);

         goto out_fd;
     }
 
         goto out_fd;
     }
 


@@ -319,7 +323,7 @@ out:
 
 static int nbd_can_accept(void)
 {
 
 static int nbd_can_accept(void)
 {

-    return nb_fds < shared;
+    return state == RUNNING && nb_fds < shared;

 }
 
 static void nbd_export_closed(NBDExport *exp)
 }
 
 static void nbd_export_closed(NBDExport *exp)


@@ -330,10 +334,10 @@ static void nbd_export_closed(NBDExport *exp)
 
 static void nbd_update_server_watch(void);
 
 
 static void nbd_update_server_watch(void);
 

-static void nbd_client_closed(NBDClient *client)
+static void nbd_client_closed(NBDClient *client, bool negotiated)

 {
     nb_fds--;
 {
     nb_fds--;

-    if (nb_fds == 0 && !persistent && state == RUNNING) {
+    if (negotiated && nb_fds == 0 && !persistent && state == RUNNING) {

         state = TERMINATE;
     }
     nbd_update_server_watch();
         state = TERMINATE;
     }
     nbd_update_server_watch();


@@ -390,13 +394,12 @@ static SocketAddress *nbd_build_socket_address(const char *sockpath,
 
     saddr = g_new0(SocketAddress, 1);
     if (sockpath) {
 
     saddr = g_new0(SocketAddress, 1);
     if (sockpath) {

-        saddr->type = SOCKET_ADDRESS_KIND_UNIX;
-        saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
-        saddr->u.q_unix.data->path = g_strdup(sockpath);
+        saddr->type = SOCKET_ADDRESS_TYPE_UNIX;
+        saddr->u.q_unix.path = g_strdup(sockpath);

     } else {
         InetSocketAddress *inet;
     } else {
         InetSocketAddress *inet;

-        saddr->type = SOCKET_ADDRESS_KIND_INET;
-        inet = saddr->u.inet.data = g_new0(InetSocketAddress, 1);
+        saddr->type = SOCKET_ADDRESS_TYPE_INET;
+        inet = &saddr->u.inet;

         inet->host = g_strdup(bindto);
         if (port) {
             inet->port = g_strdup(port);
         inet->host = g_strdup(bindto);
         if (port) {
             inet->port = g_strdup(port);


@@ -459,6 +462,43 @@ static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp)
     return creds;
 }
 
     return creds;
 }
 

+static void setup_address_and_port(const char **address, const char **port)
+{
+    if (*address == NULL) {
+        *address = "0.0.0.0";
+    }
+
+    if (*port == NULL) {
+        *port = stringify(NBD_DEFAULT_PORT);
+    }
+}
+
+/*
+ * Check socket parameters compatibility when socket activation is used.
+ */
+static const char *socket_activation_validate_opts(const char *device,
+                                                   const char *sockpath,
+                                                   const char *address,
+                                                   const char *port)
+{
+    if (device != NULL) {
+        return "NBD device can't be set when using socket activation";
+    }
+
+    if (sockpath != NULL) {
+        return "Unix socket can't be set when using socket activation";
+    }
+
+    if (address != NULL) {
+        return "The interface can't be set when using socket activation";
+    }
+
+    if (port != NULL) {
+        return "TCP port number can't be set when using socket activation";
+    }
+
+    return NULL;
+}

 
 int main(int argc, char **argv)
 {
 
 int main(int argc, char **argv)
 {


@@ -467,14 +507,14 @@ int main(int argc, char **argv)
     off_t dev_offset = 0;
     uint16_t nbdflags = 0;
     bool disconnect = false;
     off_t dev_offset = 0;
     uint16_t nbdflags = 0;
     bool disconnect = false;

-    const char *bindto = "0.0.0.0";
+    const char *bindto = NULL;

     const char *port = NULL;
     char *sockpath = NULL;
     char *device = NULL;
     off_t fd_size;
     QemuOpts *sn_opts = NULL;
     const char *sn_id_or_name = NULL;
     const char *port = NULL;
     char *sockpath = NULL;
     char *device = NULL;
     off_t fd_size;
     QemuOpts *sn_opts = NULL;
     const char *sn_id_or_name = NULL;

-    const char *sopt = "hVb:o:p:rsnP:c:dvk:e:f:tl:x:T:";
+    const char *sopt = "hVb:o:p:rsnP:c:dvk:e:f:tl:x:T:D:";

     struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },
     struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },


@@ -500,9 +540,11 @@ int main(int argc, char **argv)
         { "verbose", no_argument, NULL, 'v' },
         { "object", required_argument, NULL, QEMU_NBD_OPT_OBJECT },
         { "export-name", required_argument, NULL, 'x' },
         { "verbose", no_argument, NULL, 'v' },
         { "object", required_argument, NULL, QEMU_NBD_OPT_OBJECT },
         { "export-name", required_argument, NULL, 'x' },

+        { "description", required_argument, NULL, 'D' },

         { "tls-creds", required_argument, NULL, QEMU_NBD_OPT_TLSCREDS },
         { "image-opts", no_argument, NULL, QEMU_NBD_OPT_IMAGE_OPTS },
         { "trace", required_argument, NULL, 'T' },
         { "tls-creds", required_argument, NULL, QEMU_NBD_OPT_TLSCREDS },
         { "image-opts", no_argument, NULL, QEMU_NBD_OPT_IMAGE_OPTS },
         { "trace", required_argument, NULL, 'T' },

+        { "fork", no_argument, NULL, QEMU_NBD_OPT_FORK },

         { NULL, 0, NULL, 0 }
     };
     int ch;
         { NULL, 0, NULL, 0 }
     };
     int ch;


@@ -520,10 +562,14 @@ int main(int argc, char **argv)
     BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     QDict *options = NULL;
     const char *export_name = NULL;
     BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     QDict *options = NULL;
     const char *export_name = NULL;

+    const char *export_description = NULL;

     const char *tlscredsid = NULL;
     bool imageOpts = false;
     bool writethrough = true;
     char *trace_file = NULL;
     const char *tlscredsid = NULL;
     bool imageOpts = false;
     bool writethrough = true;
     char *trace_file = NULL;

+    bool fork_process = false;
+    int old_stderr = -1;
+    unsigned socket_activation;

 
     /* The client thread uses SIGTERM to interrupt the server.  A signal
      * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
 
     /* The client thread uses SIGTERM to interrupt the server.  A signal
      * handler ensures that "qemu-nbd -v -c" exits with a nice status code.


@@ -533,6 +579,10 @@ int main(int argc, char **argv)
     sa_sigterm.sa_handler = termsig_handler;
     sigaction(SIGTERM, &sa_sigterm, NULL);
 
     sa_sigterm.sa_handler = termsig_handler;
     sigaction(SIGTERM, &sa_sigterm, NULL);
 

+#ifdef CONFIG_POSIX
+    signal(SIGPIPE, SIG_IGN);
+#endif
+

     module_call_init(MODULE_INIT_TRACE);
     qcrypto_init(&error_fatal);
 
     module_call_init(MODULE_INIT_TRACE);
     qcrypto_init(&error_fatal);
 


@@ -588,9 +638,8 @@ int main(int argc, char **argv)
             break;
         case QEMU_NBD_OPT_DETECT_ZEROES:
             detect_zeroes =
             break;
         case QEMU_NBD_OPT_DETECT_ZEROES:
             detect_zeroes =

-                qapi_enum_parse(BlockdevDetectZeroesOptions_lookup,
+                qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,

                                 optarg,
                                 optarg,

-                                BLOCKDEV_DETECT_ZEROES_OPTIONS__MAX,

                                 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
                                 &local_err);
             if (local_err) {
                                 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
                                 &local_err);
             if (local_err) {


@@ -683,6 +732,9 @@ int main(int argc, char **argv)
         case 'x':
             export_name = optarg;
             break;
         case 'x':
             export_name = optarg;
             break;

+        case 'D':
+            export_description = optarg;
+            break;

         case 'v':
             verbose = 1;
             break;
         case 'v':
             verbose = 1;
             break;


@@ -715,6 +767,9 @@ int main(int argc, char **argv)
             g_free(trace_file);
             trace_file = trace_opt_parse(optarg);
             break;
             g_free(trace_file);
             trace_file = trace_opt_parse(optarg);
             break;

+        case QEMU_NBD_OPT_FORK:
+            fork_process = true;
+            break;

         }
     }
 
         }
     }
 


@@ -736,6 +791,26 @@ int main(int argc, char **argv)
     trace_init_file(trace_file);
     qemu_set_log(LOG_TRACE);
 
     trace_init_file(trace_file);
     qemu_set_log(LOG_TRACE);
 

+    socket_activation = check_socket_activation();
+    if (socket_activation == 0) {
+        setup_address_and_port(&bindto, &port);
+    } else {
+        /* Using socket activation - check user didn't use -p etc. */
+        const char *err_msg = socket_activation_validate_opts(device, sockpath,
+                                                              bindto, port);
+        if (err_msg != NULL) {
+            error_report("%s", err_msg);
+            exit(EXIT_FAILURE);
+        }
+
+        /* qemu-nbd can only listen on a single socket.  */
+        if (socket_activation > 1) {
+            error_report("qemu-nbd does not support socket activation with %s > 1",
+                         "LISTEN_FDS");
+            exit(EXIT_FAILURE);
+        }
+    }
+

     if (tlscredsid) {
         if (sockpath) {
             error_report("TLS is only supported with IPv4/IPv6");
     if (tlscredsid) {
         if (sockpath) {
             error_report("TLS is only supported with IPv4/IPv6");


@@ -774,7 +849,7 @@ int main(int argc, char **argv)
         return 0;
     }
 
         return 0;
     }
 

-    if (device && !verbose) {
+    if ((device && !verbose) || fork_process) {

         int stderr_fd[2];
         pid_t pid;
         int ret;
         int stderr_fd[2];
         pid_t pid;
         int ret;


@@ -797,6 +872,7 @@ int main(int argc, char **argv)
             ret = qemu_daemon(1, 0);
 
             /* Temporarily redirect stderr to the parent's pipe...  */
             ret = qemu_daemon(1, 0);
 
             /* Temporarily redirect stderr to the parent's pipe...  */

+            old_stderr = dup(STDERR_FILENO);

             dup2(stderr_fd[1], STDERR_FILENO);
             if (ret < 0) {
                 error_report("Failed to daemonize: %s", strerror(errno));
             dup2(stderr_fd[1], STDERR_FILENO);
             if (ret < 0) {
                 error_report("Failed to daemonize: %s", strerror(errno));


@@ -839,7 +915,25 @@ int main(int argc, char **argv)
         snprintf(sockpath, 128, SOCKET_PATH, basename(device));
     }
 
         snprintf(sockpath, 128, SOCKET_PATH, basename(device));
     }
 

-    saddr = nbd_build_socket_address(sockpath, bindto, port);
+    if (socket_activation == 0) {
+        server_ioc = qio_channel_socket_new();
+        saddr = nbd_build_socket_address(sockpath, bindto, port);
+        if (qio_channel_socket_listen_sync(server_ioc, saddr, &local_err) < 0) {
+            object_unref(OBJECT(server_ioc));
+            error_report_err(local_err);
+            return 1;
+        }
+    } else {
+        /* See comment in check_socket_activation above. */
+        assert(socket_activation == 1);
+        server_ioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD,
+                                               &local_err);
+        if (server_ioc == NULL) {
+            error_report("Failed to use socket activation: %s",
+                         error_get_pretty(local_err));
+            exit(EXIT_FAILURE);
+        }
+    }

 
     if (qemu_init_main_loop(&local_err)) {
         error_report_err(local_err);
 
     if (qemu_init_main_loop(&local_err)) {
         error_report_err(local_err);


@@ -866,7 +960,7 @@ int main(int argc, char **argv)
     } else {
         if (fmt) {
             options = qdict_new();
     } else {
         if (fmt) {
             options = qdict_new();

-            qdict_put(options, "driver", qstring_from_str(fmt));
+            qdict_put_str(options, "driver", fmt);

         }
         blk = blk_new_open(srcpath, NULL, options, flags, &local_err);
     }
         }
         blk = blk_new_open(srcpath, NULL, options, flags, &local_err);
     }


@@ -927,14 +1021,11 @@ int main(int argc, char **argv)
     }
     if (export_name) {
         nbd_export_set_name(exp, export_name);
     }
     if (export_name) {
         nbd_export_set_name(exp, export_name);

+        nbd_export_set_description(exp, export_description);

         newproto = true;
         newproto = true;

-    }
-
-    server_ioc = qio_channel_socket_new();
-    if (qio_channel_socket_listen_sync(server_ioc, saddr, &local_err) < 0) {
-        object_unref(OBJECT(server_ioc));
-        error_report_err(local_err);
-        return 1;
+    } else if (export_description) {
+        error_report("Export description requires an export name");
+        exit(EXIT_FAILURE);

     }
 
     if (device) {
     }
 
     if (device) {


@@ -960,6 +1051,11 @@ int main(int argc, char **argv)
         exit(EXIT_FAILURE);
     }
 
         exit(EXIT_FAILURE);
     }
 

+    if (fork_process) {
+        dup2(old_stderr, STDERR_FILENO);
+        close(old_stderr);
+    }
+

     state = RUNNING;
     do {
         main_loop_wait(false);
     state = RUNNING;
     do {
         main_loop_wait(false);