target/i386: Don't use x86_cpu_load_def() on "max" CPU model

[qemu.git] / blockdev-nbd.c

diff --git a/blockdev-nbd.c b/blockdev-nbd.c
index b29e456f1fec317e087540cd448f9bf794ce4087..28f551a7b044b2c88128cf1a0630f55ecb83a291 100644 (file)
--- a/blockdev-nbd.c
+++ b/blockdev-nbd.c
@@ -9,76 +9,163 @@
  * later.  See the COPYING file in the top-level directory.
  */
 
  * later.  See the COPYING file in the top-level directory.
  */
 

+#include "qemu/osdep.h"

 #include "sysemu/blockdev.h"
 #include "sysemu/block-backend.h"
 #include "hw/block/block.h"
 #include "sysemu/blockdev.h"
 #include "sysemu/block-backend.h"
 #include "hw/block/block.h"

-#include "monitor/monitor.h"

 #include "qapi/qmp/qerror.h"
 #include "sysemu/sysemu.h"
 #include "qmp-commands.h"
 #include "qapi/qmp/qerror.h"
 #include "sysemu/sysemu.h"
 #include "qmp-commands.h"

-#include "trace.h"

 #include "block/nbd.h"
 #include "block/nbd.h"

-#include "qemu/sockets.h"
+#include "io/channel-socket.h"

 
 

-static int server_fd = -1;
+typedef struct NBDServerData {
+    QIOChannelSocket *listen_ioc;
+    int watch;
+    QCryptoTLSCreds *tlscreds;
+} NBDServerData;

 
 

-static void nbd_accept(void *opaque)
+static NBDServerData *nbd_server;
+
+static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)

 {
 {

-    struct sockaddr_in addr;
-    socklen_t addr_len = sizeof(addr);
+    nbd_client_put(client);
+}

 
 

-    int fd = accept(server_fd, (struct sockaddr *)&addr, &addr_len);
-    if (fd >= 0 && !nbd_client_new(NULL, fd, nbd_client_put)) {
-        shutdown(fd, 2);
-        close(fd);
+static gboolean nbd_accept(QIOChannel *ioc, GIOCondition condition,
+                           gpointer opaque)
+{
+    QIOChannelSocket *cioc;
+
+    if (!nbd_server) {
+        return FALSE;

     }
     }

+
+    cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
+                                     NULL);
+    if (!cioc) {
+        return TRUE;
+    }
+
+    qio_channel_set_name(QIO_CHANNEL(cioc), "nbd-server");
+    nbd_client_new(NULL, cioc,
+                   nbd_server->tlscreds, NULL,
+                   nbd_blockdev_client_closed);
+    object_unref(OBJECT(cioc));
+    return TRUE;

 }
 
 }
 

-void qmp_nbd_server_start(SocketAddress *addr, Error **errp)
+
+static void nbd_server_free(NBDServerData *server)

 {
 {

-    if (server_fd != -1) {
-        error_setg(errp, "NBD server already running");
+    if (!server) {

         return;
     }
 
         return;
     }
 

-    server_fd = socket_listen(addr, errp);
-    if (server_fd != -1) {
-        qemu_set_fd_handler2(server_fd, NULL, nbd_accept, NULL, NULL);
+    if (server->watch != -1) {
+        g_source_remove(server->watch);

     }
     }

+    object_unref(OBJECT(server->listen_ioc));
+    if (server->tlscreds) {
+        object_unref(OBJECT(server->tlscreds));
+    }
+
+    g_free(server);

 }
 
 }
 

-/* Hook into the BlockDriverState notifiers to close the export when
- * the file is closed.
- */
-typedef struct NBDCloseNotifier {
-    Notifier n;
-    NBDExport *exp;
-    QTAILQ_ENTRY(NBDCloseNotifier) next;
-} NBDCloseNotifier;
+static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp)
+{
+    Object *obj;
+    QCryptoTLSCreds *creds;
+
+    obj = object_resolve_path_component(
+        object_get_objects_root(), id);
+    if (!obj) {
+        error_setg(errp, "No TLS credentials with id '%s'",
+                   id);
+        return NULL;
+    }
+    creds = (QCryptoTLSCreds *)
+        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS);
+    if (!creds) {
+        error_setg(errp, "Object with id '%s' is not TLS credentials",
+                   id);
+        return NULL;
+    }
+
+    if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
+        error_setg(errp,
+                   "Expecting TLS credentials with a server endpoint");
+        return NULL;
+    }
+    object_ref(obj);
+    return creds;
+}

 
 

-static QTAILQ_HEAD(, NBDCloseNotifier) close_notifiers =
-    QTAILQ_HEAD_INITIALIZER(close_notifiers);

 
 

-static void nbd_close_notifier(Notifier *n, void *data)
+void nbd_server_start(SocketAddress *addr, const char *tls_creds,
+                      Error **errp)

 {
 {

-    NBDCloseNotifier *cn = DO_UPCAST(NBDCloseNotifier, n, n);
+    if (nbd_server) {
+        error_setg(errp, "NBD server already running");
+        return;
+    }
+
+    nbd_server = g_new0(NBDServerData, 1);
+    nbd_server->watch = -1;
+    nbd_server->listen_ioc = qio_channel_socket_new();
+    qio_channel_set_name(QIO_CHANNEL(nbd_server->listen_ioc),
+                         "nbd-listener");
+    if (qio_channel_socket_listen_sync(
+            nbd_server->listen_ioc, addr, errp) < 0) {
+        goto error;
+    }
+
+    if (tls_creds) {
+        nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp);
+        if (!nbd_server->tlscreds) {
+            goto error;
+        }
+
+        /* TODO SOCKET_ADDRESS_TYPE_FD where fd has AF_INET or AF_INET6 */
+        if (addr->type != SOCKET_ADDRESS_TYPE_INET) {
+            error_setg(errp, "TLS is only supported with IPv4/IPv6");
+            goto error;
+        }
+    }
+
+    nbd_server->watch = qio_channel_add_watch(
+        QIO_CHANNEL(nbd_server->listen_ioc),
+        G_IO_IN,
+        nbd_accept,
+        NULL,
+        NULL);

 
 

-    notifier_remove(&cn->n);
-    QTAILQ_REMOVE(&close_notifiers, cn, next);
+    return;

 
 

-    nbd_export_close(cn->exp);
-    nbd_export_put(cn->exp);
-    g_free(cn);
+ error:
+    nbd_server_free(nbd_server);
+    nbd_server = NULL;
+}
+
+void qmp_nbd_server_start(SocketAddressLegacy *addr,
+                          bool has_tls_creds, const char *tls_creds,
+                          Error **errp)
+{
+    SocketAddress *addr_flat = socket_address_flatten(addr);
+
+    nbd_server_start(addr_flat, tls_creds, errp);
+    qapi_free_SocketAddress(addr_flat);

 }
 
 void qmp_nbd_server_add(const char *device, bool has_writable, bool writable,
                         Error **errp)
 {
 }
 
 void qmp_nbd_server_add(const char *device, bool has_writable, bool writable,
                         Error **errp)
 {

-    BlockBackend *blk;
+    BlockDriverState *bs = NULL;
+    BlockBackend *on_eject_blk;

     NBDExport *exp;
     NBDExport *exp;

-    NBDCloseNotifier *n;

 
 

-    if (server_fd == -1) {
+    if (!nbd_server) {

         error_setg(errp, "NBD server not running");
         return;
     }
         error_setg(errp, "NBD server not running");
         return;
     }


@@ -88,48 +175,38 @@ void qmp_nbd_server_add(const char *device, bool has_writable, bool writable,
         return;
     }
 
         return;
     }
 

-    blk = blk_by_name(device);
-    if (!blk) {
-        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
-        return;
-    }
-    if (!blk_is_inserted(blk)) {
-        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
+    on_eject_blk = blk_by_name(device);
+
+    bs = bdrv_lookup_bs(device, device, errp);
+    if (!bs) {

         return;
     }
 
     if (!has_writable) {
         writable = false;
     }
         return;
     }
 
     if (!has_writable) {
         writable = false;
     }

-    if (blk_is_read_only(blk)) {
+    if (bdrv_is_read_only(bs)) {

         writable = false;
     }
 
         writable = false;
     }
 

-    exp = nbd_export_new(blk, 0, -1, writable ? 0 : NBD_FLAG_READ_ONLY, NULL,
-                         errp);
+    exp = nbd_export_new(bs, 0, -1, writable ? 0 : NBD_FLAG_READ_ONLY,
+                         NULL, false, on_eject_blk, errp);

     if (!exp) {
         return;
     }
 
     nbd_export_set_name(exp, device);
 
     if (!exp) {
         return;
     }
 
     nbd_export_set_name(exp, device);
 

-    n = g_new0(NBDCloseNotifier, 1);
-    n->n.notify = nbd_close_notifier;
-    n->exp = exp;
-    blk_add_close_notifier(blk, &n->n);
-    QTAILQ_INSERT_TAIL(&close_notifiers, n, next);
+    /* The list of named exports has a strong reference to this export now and
+     * our only way of accessing it is through nbd_export_find(), so we can drop
+     * the strong reference that is @exp. */
+    nbd_export_put(exp);

 }
 
 void qmp_nbd_server_stop(Error **errp)
 {
 }
 
 void qmp_nbd_server_stop(Error **errp)
 {

-    while (!QTAILQ_EMPTY(&close_notifiers)) {
-        NBDCloseNotifier *cn = QTAILQ_FIRST(&close_notifiers);
-        nbd_close_notifier(&cn->n, nbd_export_get_blockdev(cn->exp));
-    }
+    nbd_export_close_all();

 
 

-    if (server_fd != -1) {
-        qemu_set_fd_handler2(server_fd, NULL, NULL, NULL, NULL);
-        close(server_fd);
-        server_fd = -1;
-    }
+    nbd_server_free(nbd_server);
+    nbd_server = NULL;

 }
 }