X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=blockdev-nbd.c;h=66eebab31875dfab1d18a898ca9b18a186c10f91;hb=23e1d054112cec1e9d3a29eb27b89335f42d3479;hp=4a758ac31431af9ad6ba592f336b8199c2859e89;hpb=0b0571dd246871f18b7d64b5279511e91e2a7bf6;p=mirror_qemu.git diff --git a/blockdev-nbd.c b/blockdev-nbd.c index 4a758ac314..66eebab318 100644 --- a/blockdev-nbd.c +++ b/blockdev-nbd.c @@ -9,127 +9,231 @@ * 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 "qapi/qmp/qerror.h" +#include "qapi/error.h" +#include "qapi/qapi-commands-block.h" #include "sysemu/sysemu.h" -#include "qmp-commands.h" -#include "trace.h" #include "block/nbd.h" -#include "qemu/sockets.h" +#include "io/channel-socket.h" +#include "io/net-listener.h" -static int server_fd = -1; +typedef struct NBDServerData { + QIONetListener *listener; + QCryptoTLSCreds *tlscreds; + char *tlsauthz; +} 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); - } +static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc, + gpointer opaque) +{ + qio_channel_set_name(QIO_CHANNEL(cioc), "nbd-server"); + nbd_client_new(cioc, nbd_server->tlscreds, nbd_server->tlsauthz, + nbd_blockdev_client_closed); } -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; } - server_fd = socket_listen(addr, errp); - if (server_fd != -1) { - qemu_set_fd_handler(server_fd, nbd_accept, NULL, NULL); + qio_net_listener_disconnect(server->listener); + object_unref(OBJECT(server->listener)); + if (server->tlscreds) { + object_unref(OBJECT(server->tlscreds)); } + g_free(server->tlsauthz); + + g_free(server); } -/* - * Hook into the BlockBackend notifiers to close the export when the - * backend 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; + } -static QTAILQ_HEAD(, NBDCloseNotifier) close_notifiers = - QTAILQ_HEAD_INITIALIZER(close_notifiers); + 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 void nbd_close_notifier(Notifier *n, void *data) + +void nbd_server_start(SocketAddress *addr, const char *tls_creds, + const char *tls_authz, 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->listener = qio_net_listener_new(); + + qio_net_listener_set_name(nbd_server->listener, + "nbd-listener"); + + if (qio_net_listener_open_sync(nbd_server->listener, 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->tlsauthz = g_strdup(tls_authz); - notifier_remove(&cn->n); - QTAILQ_REMOVE(&close_notifiers, cn, next); + qio_net_listener_set_client_func(nbd_server->listener, + nbd_accept, + NULL, + NULL); - nbd_export_close(cn->exp); - nbd_export_put(cn->exp); - g_free(cn); + return; + + error: + nbd_server_free(nbd_server); + nbd_server = NULL; } -void qmp_nbd_server_add(const char *device, bool has_writable, bool writable, - Error **errp) +void qmp_nbd_server_start(SocketAddressLegacy *addr, + bool has_tls_creds, const char *tls_creds, + bool has_tls_authz, const char *tls_authz, + Error **errp) { - BlockBackend *blk; + SocketAddress *addr_flat = socket_address_flatten(addr); + + nbd_server_start(addr_flat, tls_creds, tls_authz, errp); + qapi_free_SocketAddress(addr_flat); +} + +void qmp_nbd_server_add(const char *device, bool has_name, const char *name, + bool has_writable, bool writable, + bool has_bitmap, const char *bitmap, Error **errp) +{ + BlockDriverState *bs = NULL; + BlockBackend *on_eject_blk; NBDExport *exp; - NBDCloseNotifier *n; + int64_t len; - if (server_fd == -1) { + if (!nbd_server) { error_setg(errp, "NBD server not running"); return; } - if (nbd_export_find(device)) { - error_setg(errp, "NBD server already exporting device '%s'", device); + if (!has_name) { + name = device; + } + + if (nbd_export_find(name)) { + error_setg(errp, "NBD server already has export named '%s'", name); return; } - blk = blk_by_name(device); - if (!blk) { - error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, - "Device '%s' not found", device); + on_eject_blk = blk_by_name(device); + + bs = bdrv_lookup_bs(device, device, errp); + if (!bs) { return; } - if (!blk_is_inserted(blk)) { - error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); + + len = bdrv_getlength(bs); + if (len < 0) { + error_setg_errno(errp, -len, + "Failed to determine the NBD export's length"); return; } if (!has_writable) { writable = false; } - if (blk_is_read_only(blk)) { + if (bdrv_is_read_only(bs)) { writable = false; } - exp = nbd_export_new(blk, 0, -1, writable ? 0 : NBD_FLAG_READ_ONLY, NULL, - errp); + exp = nbd_export_new(bs, 0, len, name, NULL, bitmap, + writable ? 0 : NBD_FLAG_READ_ONLY, + NULL, false, on_eject_blk, errp); if (!exp) { return; } - nbd_export_set_name(exp, device); + /* 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_remove(const char *name, + bool has_mode, NbdServerRemoveMode mode, + Error **errp) +{ + NBDExport *exp; + + if (!nbd_server) { + error_setg(errp, "NBD server not running"); + return; + } + + exp = nbd_export_find(name); + if (exp == NULL) { + error_setg(errp, "Export '%s' is not found", name); + return; + } - 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); + if (!has_mode) { + mode = NBD_SERVER_REMOVE_MODE_SAFE; + } + + nbd_export_remove(exp, mode, 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)); + if (!nbd_server) { + error_setg(errp, "NBD server not running"); + return; } - if (server_fd != -1) { - qemu_set_fd_handler(server_fd, NULL, NULL, NULL); - close(server_fd); - server_fd = -1; - } + nbd_export_close_all(); + + nbd_server_free(nbd_server); + nbd_server = NULL; }