nbd/client-connection.c

   1 /*
   2  * QEMU Block driver for  NBD
   3  *
   4  * Copyright (c) 2021 Virtuozzo International GmbH.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26
  27 #include "block/nbd.h"
  28
  29 #include "qapi/qapi-visit-sockets.h"
  30 #include "qapi/clone-visitor.h"
  31
  32 struct NBDClientConnection {
  33     /* Initialization constants */
  34     SocketAddress *saddr; /* address to connect to */
  35
  36     QemuMutex mutex;
  37
  38     /*
  39      * @sioc and @err represent a connection attempt.  While running
  40      * is true, they are only used by the connection thread, and mutex
  41      * locking is not needed.  Once the thread finishes,
  42      * nbd_co_establish_connection then steals these pointers while
  43      * under the mutex.
  44      */
  45     QIOChannelSocket *sioc;
  46     Error *err;
  47
  48     /* All further fields are accessed only under mutex */
  49     bool running; /* thread is running now */
  50     bool detached; /* thread is detached and should cleanup the state */
  51
  52     /*
  53      * wait_co: if non-NULL, which coroutine to wake in
  54      * nbd_co_establish_connection() after yield()
  55      */
  56     Coroutine *wait_co;
  57 };
  58
  59 NBDClientConnection *nbd_client_connection_new(const SocketAddress *saddr)
  60 {
  61     NBDClientConnection *conn = g_new(NBDClientConnection, 1);
  62
  63     *conn = (NBDClientConnection) {
  64         .saddr = QAPI_CLONE(SocketAddress, saddr),
  65     };
  66
  67     qemu_mutex_init(&conn->mutex);
  68
  69     return conn;
  70 }
  71
  72 static void nbd_client_connection_do_free(NBDClientConnection *conn)
  73 {
  74     if (conn->sioc) {
  75         qio_channel_close(QIO_CHANNEL(conn->sioc), NULL);
  76         object_unref(OBJECT(conn->sioc));
  77     }
  78     error_free(conn->err);
  79     qapi_free_SocketAddress(conn->saddr);
  80     g_free(conn);
  81 }
  82
  83 static void *connect_thread_func(void *opaque)
  84 {
  85     NBDClientConnection *conn = opaque;
  86     int ret;
  87     bool do_free;
  88
  89     conn->sioc = qio_channel_socket_new();
  90
  91     error_free(conn->err);
  92     conn->err = NULL;
  93     ret = qio_channel_socket_connect_sync(conn->sioc, conn->saddr, &conn->err);
  94     if (ret < 0) {
  95         object_unref(OBJECT(conn->sioc));
  96         conn->sioc = NULL;
  97     }
  98
  99     qio_channel_set_delay(QIO_CHANNEL(conn->sioc), false);
 100
 101     qemu_mutex_lock(&conn->mutex);
 102
 103     assert(conn->running);
 104     conn->running = false;
 105     if (conn->wait_co) {
 106         aio_co_wake(conn->wait_co);
 107         conn->wait_co = NULL;
 108     }
 109     do_free = conn->detached;
 110
 111     qemu_mutex_unlock(&conn->mutex);
 112
 113     if (do_free) {
 114         nbd_client_connection_do_free(conn);
 115     }
 116
 117     return NULL;
 118 }
 119
 120 void nbd_client_connection_release(NBDClientConnection *conn)
 121 {
 122     bool do_free = false;
 123
 124     if (!conn) {
 125         return;
 126     }
 127
 128     WITH_QEMU_LOCK_GUARD(&conn->mutex) {
 129         assert(!conn->detached);
 130         if (conn->running) {
 131             conn->detached = true;
 132         } else {
 133             do_free = true;
 134         }
 135     }
 136
 137     if (do_free) {
 138         nbd_client_connection_do_free(conn);
 139     }
 140 }
 141
 142 /*
 143  * Get a new connection in context of @conn:
 144  *   if the thread is running, wait for completion
 145  *   if the thread already succeeded in the background, and user didn't get the
 146  *     result, just return it now
 147  *   otherwise the thread is not running, so start a thread and wait for
 148  *     completion
 149  */
 150 QIOChannelSocket *coroutine_fn
 151 nbd_co_establish_connection(NBDClientConnection *conn, Error **errp)
 152 {
 153     QemuThread thread;
 154
 155     WITH_QEMU_LOCK_GUARD(&conn->mutex) {
 156         /*
 157          * Don't call nbd_co_establish_connection() in several coroutines in
 158          * parallel. Only one call at once is supported.
 159          */
 160         assert(!conn->wait_co);
 161
 162         if (!conn->running) {
 163             if (conn->sioc) {
 164                 /* Previous attempt finally succeeded in background */
 165                 return g_steal_pointer(&conn->sioc);
 166             }
 167
 168             conn->running = true;
 169             error_free(conn->err);
 170             conn->err = NULL;
 171             qemu_thread_create(&thread, "nbd-connect",
 172                                connect_thread_func, conn, QEMU_THREAD_DETACHED);
 173         }
 174
 175         conn->wait_co = qemu_coroutine_self();
 176     }
 177
 178     /*
 179      * We are going to wait for connect-thread finish, but
 180      * nbd_co_establish_connection_cancel() can interrupt.
 181      */
 182     qemu_coroutine_yield();
 183
 184     WITH_QEMU_LOCK_GUARD(&conn->mutex) {
 185         if (conn->running) {
 186             /*
 187              * The connection attempt was canceled and the coroutine resumed
 188              * before the connection thread finished its job.  Report the
 189              * attempt as failed, but leave the connection thread running,
 190              * to reuse it for the next connection attempt.
 191              */
 192             error_setg(errp, "Connection attempt cancelled by other operation");
 193             return NULL;
 194         } else {
 195             error_propagate(errp, conn->err);
 196             conn->err = NULL;
 197             return g_steal_pointer(&conn->sioc);
 198         }
 199     }
 200
 201     abort(); /* unreachable */
 202 }
 203
 204 /*
 205  * nbd_co_establish_connection_cancel
 206  * Cancel nbd_co_establish_connection() asynchronously.
 207  *
 208  * Note that this function neither directly stops the thread nor closes the
 209  * socket, but rather safely wakes nbd_co_establish_connection() which is
 210  * sleeping in yield()
 211  */
 212 void nbd_co_establish_connection_cancel(NBDClientConnection *conn)
 213 {
 214     Coroutine *wait_co;
 215
 216     WITH_QEMU_LOCK_GUARD(&conn->mutex) {
 217         wait_co = g_steal_pointer(&conn->wait_co);
 218     }
 219
 220     if (wait_co) {
 221         aio_co_wake(wait_co);
 222     }
 223 }