block/nbd-client.c

   1 /*
   2  * QEMU Block driver for  NBD
   3  *
   4  * Copyright (C) 2016 Red Hat, Inc.
   5  * Copyright (C) 2008 Bull S.A.S.
   6  *     Author: Laurent Vivier <Laurent.Vivier@bull.net>
   7  *
   8  * Some parts:
   9  *    Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  24  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  27  * THE SOFTWARE.
  28  */
  29
  30 #include "qemu/osdep.h"
  31 #include "qapi/error.h"
  32 #include "nbd-client.h"
  33
  34 #define HANDLE_TO_INDEX(bs, handle) ((handle) ^ ((uint64_t)(intptr_t)bs))
  35 #define INDEX_TO_HANDLE(bs, index)  ((index)  ^ ((uint64_t)(intptr_t)bs))
  36
  37 static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
  38 {
  39     int i;
  40
  41     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
  42         if (s->recv_coroutine[i]) {
  43             aio_co_wake(s->recv_coroutine[i]);
  44         }
  45     }
  46 }
  47
  48 static void nbd_teardown_connection(BlockDriverState *bs)
  49 {
  50     NBDClientSession *client = nbd_get_client_session(bs);
  51
  52     if (!client->ioc) { /* Already closed */
  53         return;
  54     }
  55
  56     /* finish any pending coroutines */
  57     qio_channel_shutdown(client->ioc,
  58                          QIO_CHANNEL_SHUTDOWN_BOTH,
  59                          NULL);
  60     BDRV_POLL_WHILE(bs, client->read_reply_co);
  61
  62     nbd_client_detach_aio_context(bs);
  63     object_unref(OBJECT(client->sioc));
  64     client->sioc = NULL;
  65     object_unref(OBJECT(client->ioc));
  66     client->ioc = NULL;
  67 }
  68
  69 static coroutine_fn void nbd_read_reply_entry(void *opaque)
  70 {
  71     NBDClientSession *s = opaque;
  72     uint64_t i;
  73     int ret;
  74     Error *local_err = NULL;
  75
  76     for (;;) {
  77         assert(s->reply.handle == 0);
  78         ret = nbd_receive_reply(s->ioc, &s->reply, &local_err);
  79         if (ret < 0) {
  80             error_report_err(local_err);
  81         }
  82         if (ret <= 0) {
  83             break;
  84         }
  85
  86         /* There's no need for a mutex on the receive side, because the
  87          * handler acts as a synchronization point and ensures that only
  88          * one coroutine is called until the reply finishes.
  89          */
  90         i = HANDLE_TO_INDEX(s, s->reply.handle);
  91         if (i >= MAX_NBD_REQUESTS || !s->recv_coroutine[i]) {
  92             break;
  93         }
  94
  95         /* We're woken up by the recv_coroutine itself.  Note that there
  96          * is no race between yielding and reentering read_reply_co.  This
  97          * is because:
  98          *
  99          * - if recv_coroutine[i] runs on the same AioContext, it is only
 100          *   entered after we yield
 101          *
 102          * - if recv_coroutine[i] runs on a different AioContext, reentering
 103          *   read_reply_co happens through a bottom half, which can only
 104          *   run after we yield.
 105          */
 106         aio_co_wake(s->recv_coroutine[i]);
 107         qemu_coroutine_yield();
 108     }
 109
 110     nbd_recv_coroutines_enter_all(s);
 111     s->read_reply_co = NULL;
 112 }
 113
 114 static int nbd_co_send_request(BlockDriverState *bs,
 115                                NBDRequest *request,
 116                                QEMUIOVector *qiov)
 117 {
 118     NBDClientSession *s = nbd_get_client_session(bs);
 119     int rc, ret, i;
 120
 121     qemu_co_mutex_lock(&s->send_mutex);
 122     while (s->in_flight == MAX_NBD_REQUESTS) {
 123         qemu_co_queue_wait(&s->free_sema, &s->send_mutex);
 124     }
 125     s->in_flight++;
 126
 127     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
 128         if (s->recv_coroutine[i] == NULL) {
 129             s->recv_coroutine[i] = qemu_coroutine_self();
 130             break;
 131         }
 132     }
 133
 134     g_assert(qemu_in_coroutine());
 135     assert(i < MAX_NBD_REQUESTS);
 136     request->handle = INDEX_TO_HANDLE(s, i);
 137
 138     if (!s->ioc) {
 139         qemu_co_mutex_unlock(&s->send_mutex);
 140         return -EPIPE;
 141     }
 142
 143     if (qiov) {
 144         qio_channel_set_cork(s->ioc, true);
 145         rc = nbd_send_request(s->ioc, request);
 146         if (rc >= 0) {
 147             ret = nbd_rwv(s->ioc, qiov->iov, qiov->niov, request->len, false,
 148                           NULL);
 149             if (ret != request->len) {
 150                 rc = -EIO;
 151             }
 152         }
 153         qio_channel_set_cork(s->ioc, false);
 154     } else {
 155         rc = nbd_send_request(s->ioc, request);
 156     }
 157     qemu_co_mutex_unlock(&s->send_mutex);
 158     return rc;
 159 }
 160
 161 static void nbd_co_receive_reply(NBDClientSession *s,
 162                                  NBDRequest *request,
 163                                  NBDReply *reply,
 164                                  QEMUIOVector *qiov)
 165 {
 166     int ret;
 167
 168     /* Wait until we're woken up by nbd_read_reply_entry.  */
 169     qemu_coroutine_yield();
 170     *reply = s->reply;
 171     if (reply->handle != request->handle ||
 172         !s->ioc) {
 173         reply->error = EIO;
 174     } else {
 175         if (qiov && reply->error == 0) {
 176             ret = nbd_rwv(s->ioc, qiov->iov, qiov->niov, request->len, true,
 177                           NULL);
 178             if (ret != request->len) {
 179                 reply->error = EIO;
 180             }
 181         }
 182
 183         /* Tell the read handler to read another header.  */
 184         s->reply.handle = 0;
 185     }
 186 }
 187
 188 static void nbd_coroutine_end(BlockDriverState *bs,
 189                               NBDRequest *request)
 190 {
 191     NBDClientSession *s = nbd_get_client_session(bs);
 192     int i = HANDLE_TO_INDEX(s, request->handle);
 193
 194     s->recv_coroutine[i] = NULL;
 195
 196     /* Kick the read_reply_co to get the next reply.  */
 197     if (s->read_reply_co) {
 198         aio_co_wake(s->read_reply_co);
 199     }
 200
 201     qemu_co_mutex_lock(&s->send_mutex);
 202     s->in_flight--;
 203     qemu_co_queue_next(&s->free_sema);
 204     qemu_co_mutex_unlock(&s->send_mutex);
 205 }
 206
 207 int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
 208                          uint64_t bytes, QEMUIOVector *qiov, int flags)
 209 {
 210     NBDClientSession *client = nbd_get_client_session(bs);
 211     NBDRequest request = {
 212         .type = NBD_CMD_READ,
 213         .from = offset,
 214         .len = bytes,
 215     };
 216     NBDReply reply;
 217     ssize_t ret;
 218
 219     assert(bytes <= NBD_MAX_BUFFER_SIZE);
 220     assert(!flags);
 221
 222     ret = nbd_co_send_request(bs, &request, NULL);
 223     if (ret < 0) {
 224         reply.error = -ret;
 225     } else {
 226         nbd_co_receive_reply(client, &request, &reply, qiov);
 227     }
 228     nbd_coroutine_end(bs, &request);
 229     return -reply.error;
 230 }
 231
 232 int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
 233                           uint64_t bytes, QEMUIOVector *qiov, int flags)
 234 {
 235     NBDClientSession *client = nbd_get_client_session(bs);
 236     NBDRequest request = {
 237         .type = NBD_CMD_WRITE,
 238         .from = offset,
 239         .len = bytes,
 240     };
 241     NBDReply reply;
 242     ssize_t ret;
 243
 244     if (flags & BDRV_REQ_FUA) {
 245         assert(client->info.flags & NBD_FLAG_SEND_FUA);
 246         request.flags |= NBD_CMD_FLAG_FUA;
 247     }
 248
 249     assert(bytes <= NBD_MAX_BUFFER_SIZE);
 250
 251     ret = nbd_co_send_request(bs, &request, qiov);
 252     if (ret < 0) {
 253         reply.error = -ret;
 254     } else {
 255         nbd_co_receive_reply(client, &request, &reply, NULL);
 256     }
 257     nbd_coroutine_end(bs, &request);
 258     return -reply.error;
 259 }
 260
 261 int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
 262                                 int bytes, BdrvRequestFlags flags)
 263 {
 264     ssize_t ret;
 265     NBDClientSession *client = nbd_get_client_session(bs);
 266     NBDRequest request = {
 267         .type = NBD_CMD_WRITE_ZEROES,
 268         .from = offset,
 269         .len = bytes,
 270     };
 271     NBDReply reply;
 272
 273     if (!(client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
 274         return -ENOTSUP;
 275     }
 276
 277     if (flags & BDRV_REQ_FUA) {
 278         assert(client->info.flags & NBD_FLAG_SEND_FUA);
 279         request.flags |= NBD_CMD_FLAG_FUA;
 280     }
 281     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
 282         request.flags |= NBD_CMD_FLAG_NO_HOLE;
 283     }
 284
 285     ret = nbd_co_send_request(bs, &request, NULL);
 286     if (ret < 0) {
 287         reply.error = -ret;
 288     } else {
 289         nbd_co_receive_reply(client, &request, &reply, NULL);
 290     }
 291     nbd_coroutine_end(bs, &request);
 292     return -reply.error;
 293 }
 294
 295 int nbd_client_co_flush(BlockDriverState *bs)
 296 {
 297     NBDClientSession *client = nbd_get_client_session(bs);
 298     NBDRequest request = { .type = NBD_CMD_FLUSH };
 299     NBDReply reply;
 300     ssize_t ret;
 301
 302     if (!(client->info.flags & NBD_FLAG_SEND_FLUSH)) {
 303         return 0;
 304     }
 305
 306     request.from = 0;
 307     request.len = 0;
 308
 309     ret = nbd_co_send_request(bs, &request, NULL);
 310     if (ret < 0) {
 311         reply.error = -ret;
 312     } else {
 313         nbd_co_receive_reply(client, &request, &reply, NULL);
 314     }
 315     nbd_coroutine_end(bs, &request);
 316     return -reply.error;
 317 }
 318
 319 int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
 320 {
 321     NBDClientSession *client = nbd_get_client_session(bs);
 322     NBDRequest request = {
 323         .type = NBD_CMD_TRIM,
 324         .from = offset,
 325         .len = bytes,
 326     };
 327     NBDReply reply;
 328     ssize_t ret;
 329
 330     if (!(client->info.flags & NBD_FLAG_SEND_TRIM)) {
 331         return 0;
 332     }
 333
 334     ret = nbd_co_send_request(bs, &request, NULL);
 335     if (ret < 0) {
 336         reply.error = -ret;
 337     } else {
 338         nbd_co_receive_reply(client, &request, &reply, NULL);
 339     }
 340     nbd_coroutine_end(bs, &request);
 341     return -reply.error;
 342
 343 }
 344
 345 void nbd_client_detach_aio_context(BlockDriverState *bs)
 346 {
 347     NBDClientSession *client = nbd_get_client_session(bs);
 348     qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
 349 }
 350
 351 void nbd_client_attach_aio_context(BlockDriverState *bs,
 352                                    AioContext *new_context)
 353 {
 354     NBDClientSession *client = nbd_get_client_session(bs);
 355     qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc), new_context);
 356     aio_co_schedule(new_context, client->read_reply_co);
 357 }
 358
 359 void nbd_client_close(BlockDriverState *bs)
 360 {
 361     NBDClientSession *client = nbd_get_client_session(bs);
 362     NBDRequest request = { .type = NBD_CMD_DISC };
 363
 364     if (client->ioc == NULL) {
 365         return;
 366     }
 367
 368     nbd_send_request(client->ioc, &request);
 369
 370     nbd_teardown_connection(bs);
 371 }
 372
 373 int nbd_client_init(BlockDriverState *bs,
 374                     QIOChannelSocket *sioc,
 375                     const char *export,
 376                     QCryptoTLSCreds *tlscreds,
 377                     const char *hostname,
 378                     Error **errp)
 379 {
 380     NBDClientSession *client = nbd_get_client_session(bs);
 381     int ret;
 382
 383     /* NBD handshake */
 384     logout("session init %s\n", export);
 385     qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
 386
 387     client->info.request_sizes = true;
 388     ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), export,
 389                                 tlscreds, hostname,
 390                                 &client->ioc, &client->info, errp);
 391     if (ret < 0) {
 392         logout("Failed to negotiate with the NBD server\n");
 393         return ret;
 394     }
 395     if (client->info.flags & NBD_FLAG_SEND_FUA) {
 396         bs->supported_write_flags = BDRV_REQ_FUA;
 397         bs->supported_zero_flags |= BDRV_REQ_FUA;
 398     }
 399     if (client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
 400         bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
 401     }
 402     if (client->info.min_block > bs->bl.request_alignment) {
 403         bs->bl.request_alignment = client->info.min_block;
 404     }
 405
 406     qemu_co_mutex_init(&client->send_mutex);
 407     qemu_co_queue_init(&client->free_sema);
 408     client->sioc = sioc;
 409     object_ref(OBJECT(client->sioc));
 410
 411     if (!client->ioc) {
 412         client->ioc = QIO_CHANNEL(sioc);
 413         object_ref(OBJECT(client->ioc));
 414     }
 415
 416     /* Now that we're connected, set the socket to be non-blocking and
 417      * kick the reply mechanism.  */
 418     qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
 419     client->read_reply_co = qemu_coroutine_create(nbd_read_reply_entry, client);
 420     nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
 421
 422     logout("Established connection with NBD server\n");
 423     return 0;
 424 }