monitor: Use address_space_read() to read memory

[qemu.git] / qemu-nbd.c

diff --git a/qemu-nbd.c b/qemu-nbd.c
index b7ab86bfa70e03487b48ae2371f95e78f9905d56..ca7109652e56aea874706ae934bd071aa64026e9 100644 (file)
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -17,29 +17,31 @@
  */
 
 #include "qemu/osdep.h"
  */
 
 #include "qemu/osdep.h"

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

 #include "qapi/error.h"
 #include "qapi/error.h"

-#include "qemu-common.h"

 #include "qemu/cutils.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"
 #include "block/nbd.h"
 #include "qemu/main-loop.h"
 #include "qemu/cutils.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"
 #include "block/nbd.h"
 #include "qemu/main-loop.h"

+#include "qemu/option.h"

 #include "qemu/error-report.h"
 #include "qemu/config-file.h"
 #include "qemu/bswap.h"
 #include "qemu/log.h"
 #include "qemu/systemd.h"
 #include "block/snapshot.h"
 #include "qemu/error-report.h"
 #include "qemu/config-file.h"
 #include "qemu/bswap.h"
 #include "qemu/log.h"
 #include "qemu/systemd.h"
 #include "block/snapshot.h"

-#include "qapi/util.h"
+#include "qapi/qmp/qdict.h"

 #include "qapi/qmp/qstring.h"
 #include "qom/object_interfaces.h"
 #include "io/channel-socket.h"
 #include "qapi/qmp/qstring.h"
 #include "qom/object_interfaces.h"
 #include "io/channel-socket.h"

+#include "io/net-listener.h"

 #include "crypto/init.h"
 #include "trace/control.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


@@ -54,7 +56,6 @@
 #define MBR_SIZE 512
 
 static NBDExport *exp;
 #define MBR_SIZE 512
 
 static NBDExport *exp;

-static bool newproto;

 static int verbose;
 static char *srcpath;
 static SocketAddress *saddr;
 static int verbose;
 static char *srcpath;
 static SocketAddress *saddr;


@@ -62,8 +63,7 @@ static int persistent = 0;
 static enum { RUNNING, TERMINATE, TERMINATING, TERMINATED } state;
 static int shared = 1;
 static int nb_fds;
 static enum { RUNNING, TERMINATE, TERMINATING, TERMINATED } state;
 static int shared = 1;
 static int nb_fds;

-static QIOChannelSocket *server_ioc;
-static int server_watch = -1;
+static QIONetListener *server;

 static QCryptoTLSCreds *tlscreds;
 
 static void usage(const char *name)
 static QCryptoTLSCreds *tlscreds;
 
 static void usage(const char *name)


@@ -83,8 +83,8 @@ static void usage(const char *name)
 "  -e, --shared=NUM          device can be shared by NUM clients (default '1')\n"
 "  -t, --persistent          don't exit on the last connection\n"
 "  -v, --verbose             display extra debugging information\n"
 "  -e, --shared=NUM          device can be shared by NUM clients (default '1')\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"
+"  -x, --export-name=NAME    expose export by name (default is empty string)\n"
+"  -D, --description=TEXT    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"


@@ -93,6 +93,7 @@ static void usage(const char *name)
 "General purpose options:\n"
 "  --object type,id=ID,...   define an object such as 'secret' for providing\n"
 "                            passwords and/or encryption keys\n"
 "General purpose options:\n"
 "  --object type,id=ID,...   define an object such as 'secret' for providing\n"
 "                            passwords and/or encryption keys\n"

+"  --tls-creds=ID            use id of an earlier --object to provide TLS\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"
 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
 "                            specify tracing options\n"
 "  --fork                    fork off the server process and exit the parent\n"


@@ -122,17 +123,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_FULL_VERSION "\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);


@@ -255,8 +256,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;


@@ -271,9 +271,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);


@@ -288,8 +287,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;
     }
 


@@ -324,7 +324,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)


@@ -335,54 +335,34 @@ 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();
     nbd_client_put(client);
 }
 
         state = TERMINATE;
     }
     nbd_update_server_watch();
     nbd_client_put(client);
 }
 

-static gboolean nbd_accept(QIOChannel *ioc, GIOCondition cond, gpointer opaque)
+static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc,
+                       gpointer opaque)

 {
 {

-    QIOChannelSocket *cioc;
-
-    cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
-                                     NULL);
-    if (!cioc) {
-        return TRUE;
-    }
-

     if (state >= TERMINATE) {
     if (state >= TERMINATE) {

-        object_unref(OBJECT(cioc));
-        return TRUE;
+        return;

     }
 
     nb_fds++;
     nbd_update_server_watch();
     }
 
     nb_fds++;
     nbd_update_server_watch();

-    nbd_client_new(newproto ? NULL : exp, cioc,
-                   tlscreds, NULL, nbd_client_closed);
-    object_unref(OBJECT(cioc));
-
-    return TRUE;
+    nbd_client_new(cioc, tlscreds, NULL, nbd_client_closed);

 }
 
 static void nbd_update_server_watch(void)
 {
     if (nbd_can_accept()) {
 }
 
 static void nbd_update_server_watch(void)
 {
     if (nbd_can_accept()) {

-        if (server_watch == -1) {
-            server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc),
-                                                 G_IO_IN,
-                                                 nbd_accept,
-                                                 NULL, NULL);
-        }
+        qio_net_listener_set_client_func(server, nbd_accept, NULL, NULL);

     } else {
     } else {

-        if (server_watch != -1) {
-            g_source_remove(server_watch);
-            server_watch = -1;
-        }
+        qio_net_listener_set_client_func(server, NULL, NULL, NULL);

     }
 }
 
     }
 }
 


@@ -501,6 +481,12 @@ static const char *socket_activation_validate_opts(const char *device,
     return NULL;
 }
 
     return NULL;
 }
 

+static void qemu_nbd_shutdown(void)
+{
+    job_cancel_sync_all();
+    bdrv_close_all();
+}
+

 int main(int argc, char **argv)
 {
     BlockBackend *blk;
 int main(int argc, char **argv)
 {
     BlockBackend *blk;


@@ -562,7 +548,7 @@ int main(int argc, char **argv)
     Error *local_err = NULL;
     BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     QDict *options = NULL;
     Error *local_err = NULL;
     BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     QDict *options = NULL;

-    const char *export_name = NULL;
+    const char *export_name = ""; /* Default export name */

     const char *export_description = NULL;
     const char *tlscredsid = NULL;
     bool imageOpts = false;
     const char *export_description = NULL;
     const char *tlscredsid = NULL;
     bool imageOpts = false;


@@ -580,6 +566,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);
 


@@ -635,9 +625,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) {


@@ -777,11 +766,9 @@ int main(int argc, char **argv)
         exit(EXIT_FAILURE);
     }
 
         exit(EXIT_FAILURE);
     }
 

-    if (qemu_opts_foreach(&qemu_object_opts,
-                          user_creatable_add_opts_foreach,
-                          NULL, NULL)) {
-        exit(EXIT_FAILURE);
-    }
+    qemu_opts_foreach(&qemu_object_opts,
+                      user_creatable_add_opts_foreach,
+                      NULL, &error_fatal);

 
     if (!trace_init_backends()) {
         exit(1);
 
     if (!trace_init_backends()) {
         exit(1);


@@ -818,11 +805,6 @@ int main(int argc, char **argv)
             error_report("TLS is not supported with a host device");
             exit(EXIT_FAILURE);
         }
             error_report("TLS is not supported with a host device");
             exit(EXIT_FAILURE);
         }

-        if (!export_name) {
-            /* Set the default NBD protocol export name, since
-             * we *must* use new style protocol for TLS */
-            export_name = "";
-        }

         tlscreds = nbd_get_tls_creds(tlscredsid, &local_err);
         if (local_err) {
             error_report("Failed to get TLS creds %s",
         tlscreds = nbd_get_tls_creds(tlscredsid, &local_err);
         if (local_err) {
             error_report("Failed to get TLS creds %s",


@@ -913,23 +895,29 @@ int main(int argc, char **argv)
         snprintf(sockpath, 128, SOCKET_PATH, basename(device));
     }
 
         snprintf(sockpath, 128, SOCKET_PATH, basename(device));
     }
 

+    server = qio_net_listener_new();

     if (socket_activation == 0) {
     if (socket_activation == 0) {

-        server_ioc = qio_channel_socket_new();

         saddr = nbd_build_socket_address(sockpath, bindto, port);
         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));
+        if (qio_net_listener_open_sync(server, saddr, &local_err) < 0) {
+            object_unref(OBJECT(server));

             error_report_err(local_err);
             error_report_err(local_err);

-            return 1;
+            exit(EXIT_FAILURE);

         }
     } else {
         }
     } else {

+        size_t i;

         /* See comment in check_socket_activation above. */
         /* 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);
+        for (i = 0; i < socket_activation; i++) {
+            QIOChannelSocket *sioc;
+            sioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD + i,
+                                             &local_err);
+            if (sioc == NULL) {
+                object_unref(OBJECT(server));
+                error_report("Failed to use socket activation: %s",
+                             error_get_pretty(local_err));
+                exit(EXIT_FAILURE);
+            }
+            qio_net_listener_add(server, sioc);
+            object_unref(OBJECT(sioc));

         }
     }
 
         }
     }
 


@@ -938,7 +926,7 @@ int main(int argc, char **argv)
         exit(EXIT_FAILURE);
     }
     bdrv_init();
         exit(EXIT_FAILURE);
     }
     bdrv_init();

-    atexit(bdrv_close_all);
+    atexit(qemu_nbd_shutdown);

 
     srcpath = argv[optind];
     if (imageOpts) {
 
     srcpath = argv[optind];
     if (imageOpts) {


@@ -1012,19 +1000,9 @@ int main(int argc, char **argv)
     }
 
     exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags, nbd_export_closed,
     }
 
     exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags, nbd_export_closed,

-                         writethrough, NULL, &local_err);
-    if (!exp) {
-        error_report_err(local_err);
-        exit(EXIT_FAILURE);
-    }
-    if (export_name) {
-        nbd_export_set_name(exp, export_name);
-        nbd_export_set_description(exp, export_description);
-        newproto = true;
-    } else if (export_description) {
-        error_report("Export description requires an export name");
-        exit(EXIT_FAILURE);
-    }
+                         writethrough, NULL, &error_fatal);
+    nbd_export_set_name(exp, export_name);
+    nbd_export_set_description(exp, export_description);

 
     if (device) {
         int ret;
 
     if (device) {
         int ret;