nbd.c

   1 /*
   2  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   3  *
   4  *  Network Block Device
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; under version 2 of the License.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "block/nbd.h"
  20 #include "sysemu/block-backend.h"
  21
  22 #include "block/coroutine.h"
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #ifndef _WIN32
  27 #include <sys/ioctl.h>
  28 #endif
  29 #if defined(__sun__) || defined(__HAIKU__)
  30 #include <sys/ioccom.h>
  31 #endif
  32 #include <ctype.h>
  33 #include <inttypes.h>
  34
  35 #ifdef __linux__
  36 #include <linux/fs.h>
  37 #endif
  38
  39 #include "qemu/sockets.h"
  40 #include "qemu/queue.h"
  41 #include "qemu/main-loop.h"
  42
  43 //#define DEBUG_NBD
  44
  45 #ifdef DEBUG_NBD
  46 #define TRACE(msg, ...) do { \
  47     LOG(msg, ## __VA_ARGS__); \
  48 } while(0)
  49 #else
  50 #define TRACE(msg, ...) \
  51     do { } while (0)
  52 #endif
  53
  54 #define LOG(msg, ...) do { \
  55     fprintf(stderr, "%s:%s():L%d: " msg "\n", \
  56             __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
  57 } while(0)
  58
  59 /* This is all part of the "official" NBD API.
  60  *
  61  * The most up-to-date documentation is available at:
  62  * https://github.com/yoe/nbd/blob/master/doc/proto.txt
  63  */
  64
  65 #define NBD_REQUEST_SIZE        (4 + 4 + 8 + 8 + 4)
  66 #define NBD_REPLY_SIZE          (4 + 4 + 8)
  67 #define NBD_REQUEST_MAGIC       0x25609513
  68 #define NBD_REPLY_MAGIC         0x67446698
  69 #define NBD_OPTS_MAGIC          0x49484156454F5054LL
  70 #define NBD_CLIENT_MAGIC        0x0000420281861253LL
  71 #define NBD_REP_MAGIC           0x3e889045565a9LL
  72
  73 #define NBD_SET_SOCK            _IO(0xab, 0)
  74 #define NBD_SET_BLKSIZE         _IO(0xab, 1)
  75 #define NBD_SET_SIZE            _IO(0xab, 2)
  76 #define NBD_DO_IT               _IO(0xab, 3)
  77 #define NBD_CLEAR_SOCK          _IO(0xab, 4)
  78 #define NBD_CLEAR_QUE           _IO(0xab, 5)
  79 #define NBD_PRINT_DEBUG         _IO(0xab, 6)
  80 #define NBD_SET_SIZE_BLOCKS     _IO(0xab, 7)
  81 #define NBD_DISCONNECT          _IO(0xab, 8)
  82 #define NBD_SET_TIMEOUT         _IO(0xab, 9)
  83 #define NBD_SET_FLAGS           _IO(0xab, 10)
  84
  85 #define NBD_OPT_EXPORT_NAME     (1)
  86 #define NBD_OPT_ABORT           (2)
  87 #define NBD_OPT_LIST            (3)
  88
  89 /* Definitions for opaque data types */
  90
  91 typedef struct NBDRequest NBDRequest;
  92
  93 struct NBDRequest {
  94     QSIMPLEQ_ENTRY(NBDRequest) entry;
  95     NBDClient *client;
  96     uint8_t *data;
  97 };
  98
  99 struct NBDExport {
 100     int refcount;
 101     void (*close)(NBDExport *exp);
 102
 103     BlockBackend *blk;
 104     char *name;
 105     off_t dev_offset;
 106     off_t size;
 107     uint32_t nbdflags;
 108     QTAILQ_HEAD(, NBDClient) clients;
 109     QTAILQ_ENTRY(NBDExport) next;
 110
 111     AioContext *ctx;
 112 };
 113
 114 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
 115
 116 struct NBDClient {
 117     int refcount;
 118     void (*close)(NBDClient *client);
 119
 120     NBDExport *exp;
 121     int sock;
 122
 123     Coroutine *recv_coroutine;
 124
 125     CoMutex send_lock;
 126     Coroutine *send_coroutine;
 127
 128     bool can_read;
 129
 130     QTAILQ_ENTRY(NBDClient) next;
 131     int nb_requests;
 132     bool closing;
 133 };
 134
 135 /* That's all folks */
 136
 137 static void nbd_set_handlers(NBDClient *client);
 138 static void nbd_unset_handlers(NBDClient *client);
 139 static void nbd_update_can_read(NBDClient *client);
 140
 141 ssize_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read)
 142 {
 143     size_t offset = 0;
 144     int err;
 145
 146     if (qemu_in_coroutine()) {
 147         if (do_read) {
 148             return qemu_co_recv(fd, buffer, size);
 149         } else {
 150             return qemu_co_send(fd, buffer, size);
 151         }
 152     }
 153
 154     while (offset < size) {
 155         ssize_t len;
 156
 157         if (do_read) {
 158             len = qemu_recv(fd, buffer + offset, size - offset, 0);
 159         } else {
 160             len = send(fd, buffer + offset, size - offset, 0);
 161         }
 162
 163         if (len < 0) {
 164             err = socket_error();
 165
 166             /* recoverable error */
 167             if (err == EINTR || (offset > 0 && (err == EAGAIN || err == EWOULDBLOCK))) {
 168                 continue;
 169             }
 170
 171             /* unrecoverable error */
 172             return -err;
 173         }
 174
 175         /* eof */
 176         if (len == 0) {
 177             break;
 178         }
 179
 180         offset += len;
 181     }
 182
 183     return offset;
 184 }
 185
 186 static ssize_t read_sync(int fd, void *buffer, size_t size)
 187 {
 188     /* Sockets are kept in blocking mode in the negotiation phase.  After
 189      * that, a non-readable socket simply means that another thread stole
 190      * our request/reply.  Synchronization is done with recv_coroutine, so
 191      * that this is coroutine-safe.
 192      */
 193     return nbd_wr_sync(fd, buffer, size, true);
 194 }
 195
 196 static ssize_t write_sync(int fd, void *buffer, size_t size)
 197 {
 198     int ret;
 199     do {
 200         /* For writes, we do expect the socket to be writable.  */
 201         ret = nbd_wr_sync(fd, buffer, size, false);
 202     } while (ret == -EAGAIN);
 203     return ret;
 204 }
 205
 206 /* Basic flow for negotiation
 207
 208    Server         Client
 209    Negotiate
 210
 211    or
 212
 213    Server         Client
 214    Negotiate #1
 215                   Option
 216    Negotiate #2
 217
 218    ----
 219
 220    followed by
 221
 222    Server         Client
 223                   Request
 224    Response
 225                   Request
 226    Response
 227                   ...
 228    ...
 229                   Request (type == 2)
 230
 231 */
 232
 233 static int nbd_send_rep(int csock, uint32_t type, uint32_t opt)
 234 {
 235     uint64_t magic;
 236     uint32_t len;
 237
 238     magic = cpu_to_be64(NBD_REP_MAGIC);
 239     if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 240         LOG("write failed (rep magic)");
 241         return -EINVAL;
 242     }
 243     opt = cpu_to_be32(opt);
 244     if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) {
 245         LOG("write failed (rep opt)");
 246         return -EINVAL;
 247     }
 248     type = cpu_to_be32(type);
 249     if (write_sync(csock, &type, sizeof(type)) != sizeof(type)) {
 250         LOG("write failed (rep type)");
 251         return -EINVAL;
 252     }
 253     len = cpu_to_be32(0);
 254     if (write_sync(csock, &len, sizeof(len)) != sizeof(len)) {
 255         LOG("write failed (rep data length)");
 256         return -EINVAL;
 257     }
 258     return 0;
 259 }
 260
 261 static int nbd_send_rep_list(int csock, NBDExport *exp)
 262 {
 263     uint64_t magic, name_len;
 264     uint32_t opt, type, len;
 265
 266     name_len = strlen(exp->name);
 267     magic = cpu_to_be64(NBD_REP_MAGIC);
 268     if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 269         LOG("write failed (magic)");
 270         return -EINVAL;
 271      }
 272     opt = cpu_to_be32(NBD_OPT_LIST);
 273     if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) {
 274         LOG("write failed (opt)");
 275         return -EINVAL;
 276     }
 277     type = cpu_to_be32(NBD_REP_SERVER);
 278     if (write_sync(csock, &type, sizeof(type)) != sizeof(type)) {
 279         LOG("write failed (reply type)");
 280         return -EINVAL;
 281     }
 282     len = cpu_to_be32(name_len + sizeof(len));
 283     if (write_sync(csock, &len, sizeof(len)) != sizeof(len)) {
 284         LOG("write failed (length)");
 285         return -EINVAL;
 286     }
 287     len = cpu_to_be32(name_len);
 288     if (write_sync(csock, &len, sizeof(len)) != sizeof(len)) {
 289         LOG("write failed (length)");
 290         return -EINVAL;
 291     }
 292     if (write_sync(csock, exp->name, name_len) != name_len) {
 293         LOG("write failed (buffer)");
 294         return -EINVAL;
 295     }
 296     return 0;
 297 }
 298
 299 static int nbd_handle_list(NBDClient *client, uint32_t length)
 300 {
 301     int csock;
 302     NBDExport *exp;
 303
 304     csock = client->sock;
 305     if (length) {
 306         return nbd_send_rep(csock, NBD_REP_ERR_INVALID, NBD_OPT_LIST);
 307     }
 308
 309     /* For each export, send a NBD_REP_SERVER reply. */
 310     QTAILQ_FOREACH(exp, &exports, next) {
 311         if (nbd_send_rep_list(csock, exp)) {
 312             return -EINVAL;
 313         }
 314     }
 315     /* Finish with a NBD_REP_ACK. */
 316     return nbd_send_rep(csock, NBD_REP_ACK, NBD_OPT_LIST);
 317 }
 318
 319 static int nbd_handle_export_name(NBDClient *client, uint32_t length)
 320 {
 321     int rc = -EINVAL, csock = client->sock;
 322     char name[256];
 323
 324     /* Client sends:
 325         [20 ..  xx]   export name (length bytes)
 326      */
 327     TRACE("Checking length");
 328     if (length > 255) {
 329         LOG("Bad length received");
 330         goto fail;
 331     }
 332     if (read_sync(csock, name, length) != length) {
 333         LOG("read failed");
 334         goto fail;
 335     }
 336     name[length] = '\0';
 337
 338     client->exp = nbd_export_find(name);
 339     if (!client->exp) {
 340         LOG("export not found");
 341         goto fail;
 342     }
 343
 344     QTAILQ_INSERT_TAIL(&client->exp->clients, client, next);
 345     nbd_export_get(client->exp);
 346     rc = 0;
 347 fail:
 348     return rc;
 349 }
 350
 351 static int nbd_receive_options(NBDClient *client)
 352 {
 353     while (1) {
 354         int csock = client->sock, ret;
 355         uint32_t tmp, length;
 356         uint64_t magic;
 357
 358         /* Client sends:
 359             [ 0 ..   3]   client flags
 360             [ 4 ..  11]   NBD_OPTS_MAGIC
 361             [12 ..  15]   NBD option
 362             [16 ..  19]   length
 363             ...           Rest of request
 364         */
 365
 366         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 367             LOG("read failed");
 368             return -EINVAL;
 369         }
 370         TRACE("Checking client flags");
 371         tmp = be32_to_cpu(tmp);
 372         if (tmp != 0 && tmp != NBD_FLAG_C_FIXED_NEWSTYLE) {
 373             LOG("Bad client flags received");
 374             return -EINVAL;
 375         }
 376
 377         if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 378             LOG("read failed");
 379             return -EINVAL;
 380         }
 381         TRACE("Checking opts magic");
 382         if (magic != be64_to_cpu(NBD_OPTS_MAGIC)) {
 383             LOG("Bad magic received");
 384             return -EINVAL;
 385         }
 386
 387         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 388             LOG("read failed");
 389             return -EINVAL;
 390         }
 391
 392         if (read_sync(csock, &length, sizeof(length)) != sizeof(length)) {
 393             LOG("read failed");
 394             return -EINVAL;
 395         }
 396         length = be32_to_cpu(length);
 397
 398         TRACE("Checking option");
 399         switch (be32_to_cpu(tmp)) {
 400         case NBD_OPT_LIST:
 401             ret = nbd_handle_list(client, length);
 402             if (ret < 0) {
 403                 return ret;
 404             }
 405             break;
 406
 407         case NBD_OPT_ABORT:
 408             return -EINVAL;
 409
 410         case NBD_OPT_EXPORT_NAME:
 411             return nbd_handle_export_name(client, length);
 412
 413         default:
 414             tmp = be32_to_cpu(tmp);
 415             LOG("Unsupported option 0x%x", tmp);
 416             nbd_send_rep(client->sock, NBD_REP_ERR_UNSUP, tmp);
 417             return -EINVAL;
 418         }
 419     }
 420 }
 421
 422 static int nbd_send_negotiate(NBDClient *client)
 423 {
 424     int csock = client->sock;
 425     char buf[8 + 8 + 8 + 128];
 426     int rc;
 427     const int myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM |
 428                          NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA);
 429
 430     /* Negotiation header without options:
 431         [ 0 ..   7]   passwd       ("NBDMAGIC")
 432         [ 8 ..  15]   magic        (NBD_CLIENT_MAGIC)
 433         [16 ..  23]   size
 434         [24 ..  25]   server flags (0)
 435         [26 ..  27]   export flags
 436         [28 .. 151]   reserved     (0)
 437
 438        Negotiation header with options, part 1:
 439         [ 0 ..   7]   passwd       ("NBDMAGIC")
 440         [ 8 ..  15]   magic        (NBD_OPTS_MAGIC)
 441         [16 ..  17]   server flags (0)
 442
 443        part 2 (after options are sent):
 444         [18 ..  25]   size
 445         [26 ..  27]   export flags
 446         [28 .. 151]   reserved     (0)
 447      */
 448
 449     qemu_set_block(csock);
 450     rc = -EINVAL;
 451
 452     TRACE("Beginning negotiation.");
 453     memset(buf, 0, sizeof(buf));
 454     memcpy(buf, "NBDMAGIC", 8);
 455     if (client->exp) {
 456         assert ((client->exp->nbdflags & ~65535) == 0);
 457         cpu_to_be64w((uint64_t*)(buf + 8), NBD_CLIENT_MAGIC);
 458         cpu_to_be64w((uint64_t*)(buf + 16), client->exp->size);
 459         cpu_to_be16w((uint16_t*)(buf + 26), client->exp->nbdflags | myflags);
 460     } else {
 461         cpu_to_be64w((uint64_t*)(buf + 8), NBD_OPTS_MAGIC);
 462         cpu_to_be16w((uint16_t *)(buf + 16), NBD_FLAG_FIXED_NEWSTYLE);
 463     }
 464
 465     if (client->exp) {
 466         if (write_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
 467             LOG("write failed");
 468             goto fail;
 469         }
 470     } else {
 471         if (write_sync(csock, buf, 18) != 18) {
 472             LOG("write failed");
 473             goto fail;
 474         }
 475         rc = nbd_receive_options(client);
 476         if (rc != 0) {
 477             LOG("option negotiation failed");
 478             goto fail;
 479         }
 480
 481         assert ((client->exp->nbdflags & ~65535) == 0);
 482         cpu_to_be64w((uint64_t*)(buf + 18), client->exp->size);
 483         cpu_to_be16w((uint16_t*)(buf + 26), client->exp->nbdflags | myflags);
 484         if (write_sync(csock, buf + 18, sizeof(buf) - 18) != sizeof(buf) - 18) {
 485             LOG("write failed");
 486             goto fail;
 487         }
 488     }
 489
 490     TRACE("Negotiation succeeded.");
 491     rc = 0;
 492 fail:
 493     qemu_set_nonblock(csock);
 494     return rc;
 495 }
 496
 497 int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags,
 498                           off_t *size, Error **errp)
 499 {
 500     char buf[256];
 501     uint64_t magic, s;
 502     uint16_t tmp;
 503     int rc;
 504
 505     TRACE("Receiving negotiation.");
 506
 507     rc = -EINVAL;
 508
 509     if (read_sync(csock, buf, 8) != 8) {
 510         error_setg(errp, "Failed to read data");
 511         goto fail;
 512     }
 513
 514     buf[8] = '\0';
 515     if (strlen(buf) == 0) {
 516         error_setg(errp, "Server connection closed unexpectedly");
 517         goto fail;
 518     }
 519
 520     TRACE("Magic is %c%c%c%c%c%c%c%c",
 521           qemu_isprint(buf[0]) ? buf[0] : '.',
 522           qemu_isprint(buf[1]) ? buf[1] : '.',
 523           qemu_isprint(buf[2]) ? buf[2] : '.',
 524           qemu_isprint(buf[3]) ? buf[3] : '.',
 525           qemu_isprint(buf[4]) ? buf[4] : '.',
 526           qemu_isprint(buf[5]) ? buf[5] : '.',
 527           qemu_isprint(buf[6]) ? buf[6] : '.',
 528           qemu_isprint(buf[7]) ? buf[7] : '.');
 529
 530     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
 531         error_setg(errp, "Invalid magic received");
 532         goto fail;
 533     }
 534
 535     if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 536         error_setg(errp, "Failed to read magic");
 537         goto fail;
 538     }
 539     magic = be64_to_cpu(magic);
 540     TRACE("Magic is 0x%" PRIx64, magic);
 541
 542     if (name) {
 543         uint32_t reserved = 0;
 544         uint32_t opt;
 545         uint32_t namesize;
 546
 547         TRACE("Checking magic (opts_magic)");
 548         if (magic != NBD_OPTS_MAGIC) {
 549             if (magic == NBD_CLIENT_MAGIC) {
 550                 error_setg(errp, "Server does not support export names");
 551             } else {
 552                 error_setg(errp, "Bad magic received");
 553             }
 554             goto fail;
 555         }
 556         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 557             error_setg(errp, "Failed to read server flags");
 558             goto fail;
 559         }
 560         *flags = be16_to_cpu(tmp) << 16;
 561         /* reserved for future use */
 562         if (write_sync(csock, &reserved, sizeof(reserved)) !=
 563             sizeof(reserved)) {
 564             error_setg(errp, "Failed to read reserved field");
 565             goto fail;
 566         }
 567         /* write the export name */
 568         magic = cpu_to_be64(magic);
 569         if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) {
 570             error_setg(errp, "Failed to send export name magic");
 571             goto fail;
 572         }
 573         opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
 574         if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) {
 575             error_setg(errp, "Failed to send export name option number");
 576             goto fail;
 577         }
 578         namesize = cpu_to_be32(strlen(name));
 579         if (write_sync(csock, &namesize, sizeof(namesize)) !=
 580             sizeof(namesize)) {
 581             error_setg(errp, "Failed to send export name length");
 582             goto fail;
 583         }
 584         if (write_sync(csock, (char*)name, strlen(name)) != strlen(name)) {
 585             error_setg(errp, "Failed to send export name");
 586             goto fail;
 587         }
 588     } else {
 589         TRACE("Checking magic (cli_magic)");
 590
 591         if (magic != NBD_CLIENT_MAGIC) {
 592             if (magic == NBD_OPTS_MAGIC) {
 593                 error_setg(errp, "Server requires an export name");
 594             } else {
 595                 error_setg(errp, "Bad magic received");
 596             }
 597             goto fail;
 598         }
 599     }
 600
 601     if (read_sync(csock, &s, sizeof(s)) != sizeof(s)) {
 602         error_setg(errp, "Failed to read export length");
 603         goto fail;
 604     }
 605     *size = be64_to_cpu(s);
 606     TRACE("Size is %" PRIu64, *size);
 607
 608     if (!name) {
 609         if (read_sync(csock, flags, sizeof(*flags)) != sizeof(*flags)) {
 610             error_setg(errp, "Failed to read export flags");
 611             goto fail;
 612         }
 613         *flags = be32_to_cpup(flags);
 614     } else {
 615         if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) {
 616             error_setg(errp, "Failed to read export flags");
 617             goto fail;
 618         }
 619         *flags |= be32_to_cpu(tmp);
 620     }
 621     if (read_sync(csock, &buf, 124) != 124) {
 622         error_setg(errp, "Failed to read reserved block");
 623         goto fail;
 624     }
 625     rc = 0;
 626
 627 fail:
 628     return rc;
 629 }
 630
 631 #ifdef __linux__
 632 int nbd_init(int fd, int csock, uint32_t flags, off_t size)
 633 {
 634     TRACE("Setting NBD socket");
 635
 636     if (ioctl(fd, NBD_SET_SOCK, csock) < 0) {
 637         int serrno = errno;
 638         LOG("Failed to set NBD socket");
 639         return -serrno;
 640     }
 641
 642     TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE);
 643
 644     if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) {
 645         int serrno = errno;
 646         LOG("Failed setting NBD block size");
 647         return -serrno;
 648     }
 649
 650     TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE));
 651
 652     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, size / (size_t)BDRV_SECTOR_SIZE) < 0) {
 653         int serrno = errno;
 654         LOG("Failed setting size (in blocks)");
 655         return -serrno;
 656     }
 657
 658     if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) {
 659         if (errno == ENOTTY) {
 660             int read_only = (flags & NBD_FLAG_READ_ONLY) != 0;
 661             TRACE("Setting readonly attribute");
 662
 663             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 664                 int serrno = errno;
 665                 LOG("Failed setting read-only attribute");
 666                 return -serrno;
 667             }
 668         } else {
 669             int serrno = errno;
 670             LOG("Failed setting flags");
 671             return -serrno;
 672         }
 673     }
 674
 675     TRACE("Negotiation ended");
 676
 677     return 0;
 678 }
 679
 680 int nbd_disconnect(int fd)
 681 {
 682     ioctl(fd, NBD_CLEAR_QUE);
 683     ioctl(fd, NBD_DISCONNECT);
 684     ioctl(fd, NBD_CLEAR_SOCK);
 685     return 0;
 686 }
 687
 688 int nbd_client(int fd)
 689 {
 690     int ret;
 691     int serrno;
 692
 693     TRACE("Doing NBD loop");
 694
 695     ret = ioctl(fd, NBD_DO_IT);
 696     if (ret < 0 && errno == EPIPE) {
 697         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 698          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
 699          * that case.
 700          */
 701         ret = 0;
 702     }
 703     serrno = errno;
 704
 705     TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
 706
 707     TRACE("Clearing NBD queue");
 708     ioctl(fd, NBD_CLEAR_QUE);
 709
 710     TRACE("Clearing NBD socket");
 711     ioctl(fd, NBD_CLEAR_SOCK);
 712
 713     errno = serrno;
 714     return ret;
 715 }
 716 #else
 717 int nbd_init(int fd, int csock, uint32_t flags, off_t size)
 718 {
 719     return -ENOTSUP;
 720 }
 721
 722 int nbd_disconnect(int fd)
 723 {
 724     return -ENOTSUP;
 725 }
 726
 727 int nbd_client(int fd)
 728 {
 729     return -ENOTSUP;
 730 }
 731 #endif
 732
 733 ssize_t nbd_send_request(int csock, struct nbd_request *request)
 734 {
 735     uint8_t buf[NBD_REQUEST_SIZE];
 736     ssize_t ret;
 737
 738     cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
 739     cpu_to_be32w((uint32_t*)(buf + 4), request->type);
 740     cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
 741     cpu_to_be64w((uint64_t*)(buf + 16), request->from);
 742     cpu_to_be32w((uint32_t*)(buf + 24), request->len);
 743
 744     TRACE("Sending request to client: "
 745           "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}",
 746           request->from, request->len, request->handle, request->type);
 747
 748     ret = write_sync(csock, buf, sizeof(buf));
 749     if (ret < 0) {
 750         return ret;
 751     }
 752
 753     if (ret != sizeof(buf)) {
 754         LOG("writing to socket failed");
 755         return -EINVAL;
 756     }
 757     return 0;
 758 }
 759
 760 static ssize_t nbd_receive_request(int csock, struct nbd_request *request)
 761 {
 762     uint8_t buf[NBD_REQUEST_SIZE];
 763     uint32_t magic;
 764     ssize_t ret;
 765
 766     ret = read_sync(csock, buf, sizeof(buf));
 767     if (ret < 0) {
 768         return ret;
 769     }
 770
 771     if (ret != sizeof(buf)) {
 772         LOG("read failed");
 773         return -EINVAL;
 774     }
 775
 776     /* Request
 777        [ 0 ..  3]   magic   (NBD_REQUEST_MAGIC)
 778        [ 4 ..  7]   type    (0 == READ, 1 == WRITE)
 779        [ 8 .. 15]   handle
 780        [16 .. 23]   from
 781        [24 .. 27]   len
 782      */
 783
 784     magic = be32_to_cpup((uint32_t*)buf);
 785     request->type  = be32_to_cpup((uint32_t*)(buf + 4));
 786     request->handle = be64_to_cpup((uint64_t*)(buf + 8));
 787     request->from  = be64_to_cpup((uint64_t*)(buf + 16));
 788     request->len   = be32_to_cpup((uint32_t*)(buf + 24));
 789
 790     TRACE("Got request: "
 791           "{ magic = 0x%x, .type = %d, from = %" PRIu64" , len = %u }",
 792           magic, request->type, request->from, request->len);
 793
 794     if (magic != NBD_REQUEST_MAGIC) {
 795         LOG("invalid magic (got 0x%x)", magic);
 796         return -EINVAL;
 797     }
 798     return 0;
 799 }
 800
 801 ssize_t nbd_receive_reply(int csock, struct nbd_reply *reply)
 802 {
 803     uint8_t buf[NBD_REPLY_SIZE];
 804     uint32_t magic;
 805     ssize_t ret;
 806
 807     ret = read_sync(csock, buf, sizeof(buf));
 808     if (ret < 0) {
 809         return ret;
 810     }
 811
 812     if (ret != sizeof(buf)) {
 813         LOG("read failed");
 814         return -EINVAL;
 815     }
 816
 817     /* Reply
 818        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 819        [ 4 ..  7]    error   (0 == no error)
 820        [ 7 .. 15]    handle
 821      */
 822
 823     magic = be32_to_cpup((uint32_t*)buf);
 824     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
 825     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
 826
 827     TRACE("Got reply: "
 828           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
 829           magic, reply->error, reply->handle);
 830
 831     if (magic != NBD_REPLY_MAGIC) {
 832         LOG("invalid magic (got 0x%x)", magic);
 833         return -EINVAL;
 834     }
 835     return 0;
 836 }
 837
 838 static ssize_t nbd_send_reply(int csock, struct nbd_reply *reply)
 839 {
 840     uint8_t buf[NBD_REPLY_SIZE];
 841     ssize_t ret;
 842
 843     /* Reply
 844        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 845        [ 4 ..  7]    error   (0 == no error)
 846        [ 7 .. 15]    handle
 847      */
 848     cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC);
 849     cpu_to_be32w((uint32_t*)(buf + 4), reply->error);
 850     cpu_to_be64w((uint64_t*)(buf + 8), reply->handle);
 851
 852     TRACE("Sending response to client");
 853
 854     ret = write_sync(csock, buf, sizeof(buf));
 855     if (ret < 0) {
 856         return ret;
 857     }
 858
 859     if (ret != sizeof(buf)) {
 860         LOG("writing to socket failed");
 861         return -EINVAL;
 862     }
 863     return 0;
 864 }
 865
 866 #define MAX_NBD_REQUESTS 16
 867
 868 void nbd_client_get(NBDClient *client)
 869 {
 870     client->refcount++;
 871 }
 872
 873 void nbd_client_put(NBDClient *client)
 874 {
 875     if (--client->refcount == 0) {
 876         /* The last reference should be dropped by client->close,
 877          * which is called by client_close.
 878          */
 879         assert(client->closing);
 880
 881         nbd_unset_handlers(client);
 882         close(client->sock);
 883         client->sock = -1;
 884         if (client->exp) {
 885             QTAILQ_REMOVE(&client->exp->clients, client, next);
 886             nbd_export_put(client->exp);
 887         }
 888         g_free(client);
 889     }
 890 }
 891
 892 static void client_close(NBDClient *client)
 893 {
 894     if (client->closing) {
 895         return;
 896     }
 897
 898     client->closing = true;
 899
 900     /* Force requests to finish.  They will drop their own references,
 901      * then we'll close the socket and free the NBDClient.
 902      */
 903     shutdown(client->sock, 2);
 904
 905     /* Also tell the client, so that they release their reference.  */
 906     if (client->close) {
 907         client->close(client);
 908     }
 909 }
 910
 911 static NBDRequest *nbd_request_get(NBDClient *client)
 912 {
 913     NBDRequest *req;
 914
 915     assert(client->nb_requests <= MAX_NBD_REQUESTS - 1);
 916     client->nb_requests++;
 917     nbd_update_can_read(client);
 918
 919     req = g_slice_new0(NBDRequest);
 920     nbd_client_get(client);
 921     req->client = client;
 922     return req;
 923 }
 924
 925 static void nbd_request_put(NBDRequest *req)
 926 {
 927     NBDClient *client = req->client;
 928
 929     if (req->data) {
 930         qemu_vfree(req->data);
 931     }
 932     g_slice_free(NBDRequest, req);
 933
 934     client->nb_requests--;
 935     nbd_update_can_read(client);
 936     nbd_client_put(client);
 937 }
 938
 939 static void blk_aio_attached(AioContext *ctx, void *opaque)
 940 {
 941     NBDExport *exp = opaque;
 942     NBDClient *client;
 943
 944     TRACE("Export %s: Attaching clients to AIO context %p\n", exp->name, ctx);
 945
 946     exp->ctx = ctx;
 947
 948     QTAILQ_FOREACH(client, &exp->clients, next) {
 949         nbd_set_handlers(client);
 950     }
 951 }
 952
 953 static void blk_aio_detach(void *opaque)
 954 {
 955     NBDExport *exp = opaque;
 956     NBDClient *client;
 957
 958     TRACE("Export %s: Detaching clients from AIO context %p\n", exp->name, exp->ctx);
 959
 960     QTAILQ_FOREACH(client, &exp->clients, next) {
 961         nbd_unset_handlers(client);
 962     }
 963
 964     exp->ctx = NULL;
 965 }
 966
 967 NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
 968                           uint32_t nbdflags, void (*close)(NBDExport *),
 969                           Error **errp)
 970 {
 971     NBDExport *exp = g_malloc0(sizeof(NBDExport));
 972     exp->refcount = 1;
 973     QTAILQ_INIT(&exp->clients);
 974     exp->blk = blk;
 975     exp->dev_offset = dev_offset;
 976     exp->nbdflags = nbdflags;
 977     exp->size = size < 0 ? blk_getlength(blk) : size;
 978     if (exp->size < 0) {
 979         error_setg_errno(errp, -exp->size,
 980                          "Failed to determine the NBD export's length");
 981         goto fail;
 982     }
 983     exp->size -= exp->size % BDRV_SECTOR_SIZE;
 984
 985     exp->close = close;
 986     exp->ctx = blk_get_aio_context(blk);
 987     blk_ref(blk);
 988     blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
 989     /*
 990      * NBD exports are used for non-shared storage migration.  Make sure
 991      * that BDRV_O_INCOMING is cleared and the image is ready for write
 992      * access since the export could be available before migration handover.
 993      */
 994     blk_invalidate_cache(blk, NULL);
 995     return exp;
 996
 997 fail:
 998     g_free(exp);
 999     return NULL;
1000 }
1001
1002 NBDExport *nbd_export_find(const char *name)
1003 {
1004     NBDExport *exp;
1005     QTAILQ_FOREACH(exp, &exports, next) {
1006         if (strcmp(name, exp->name) == 0) {
1007             return exp;
1008         }
1009     }
1010
1011     return NULL;
1012 }
1013
1014 void nbd_export_set_name(NBDExport *exp, const char *name)
1015 {
1016     if (exp->name == name) {
1017         return;
1018     }
1019
1020     nbd_export_get(exp);
1021     if (exp->name != NULL) {
1022         g_free(exp->name);
1023         exp->name = NULL;
1024         QTAILQ_REMOVE(&exports, exp, next);
1025         nbd_export_put(exp);
1026     }
1027     if (name != NULL) {
1028         nbd_export_get(exp);
1029         exp->name = g_strdup(name);
1030         QTAILQ_INSERT_TAIL(&exports, exp, next);
1031     }
1032     nbd_export_put(exp);
1033 }
1034
1035 void nbd_export_close(NBDExport *exp)
1036 {
1037     NBDClient *client, *next;
1038
1039     nbd_export_get(exp);
1040     QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) {
1041         client_close(client);
1042     }
1043     nbd_export_set_name(exp, NULL);
1044     nbd_export_put(exp);
1045     if (exp->blk) {
1046         blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
1047                                         blk_aio_detach, exp);
1048         blk_unref(exp->blk);
1049         exp->blk = NULL;
1050     }
1051 }
1052
1053 void nbd_export_get(NBDExport *exp)
1054 {
1055     assert(exp->refcount > 0);
1056     exp->refcount++;
1057 }
1058
1059 void nbd_export_put(NBDExport *exp)
1060 {
1061     assert(exp->refcount > 0);
1062     if (exp->refcount == 1) {
1063         nbd_export_close(exp);
1064     }
1065
1066     if (--exp->refcount == 0) {
1067         assert(exp->name == NULL);
1068
1069         if (exp->close) {
1070             exp->close(exp);
1071         }
1072
1073         g_free(exp);
1074     }
1075 }
1076
1077 BlockBackend *nbd_export_get_blockdev(NBDExport *exp)
1078 {
1079     return exp->blk;
1080 }
1081
1082 void nbd_export_close_all(void)
1083 {
1084     NBDExport *exp, *next;
1085
1086     QTAILQ_FOREACH_SAFE(exp, &exports, next, next) {
1087         nbd_export_close(exp);
1088     }
1089 }
1090
1091 static ssize_t nbd_co_send_reply(NBDRequest *req, struct nbd_reply *reply,
1092                                  int len)
1093 {
1094     NBDClient *client = req->client;
1095     int csock = client->sock;
1096     ssize_t rc, ret;
1097
1098     qemu_co_mutex_lock(&client->send_lock);
1099     client->send_coroutine = qemu_coroutine_self();
1100     nbd_set_handlers(client);
1101
1102     if (!len) {
1103         rc = nbd_send_reply(csock, reply);
1104     } else {
1105         socket_set_cork(csock, 1);
1106         rc = nbd_send_reply(csock, reply);
1107         if (rc >= 0) {
1108             ret = qemu_co_send(csock, req->data, len);
1109             if (ret != len) {
1110                 rc = -EIO;
1111             }
1112         }
1113         socket_set_cork(csock, 0);
1114     }
1115
1116     client->send_coroutine = NULL;
1117     nbd_set_handlers(client);
1118     qemu_co_mutex_unlock(&client->send_lock);
1119     return rc;
1120 }
1121
1122 static ssize_t nbd_co_receive_request(NBDRequest *req, struct nbd_request *request)
1123 {
1124     NBDClient *client = req->client;
1125     int csock = client->sock;
1126     uint32_t command;
1127     ssize_t rc;
1128
1129     client->recv_coroutine = qemu_coroutine_self();
1130     nbd_update_can_read(client);
1131
1132     rc = nbd_receive_request(csock, request);
1133     if (rc < 0) {
1134         if (rc != -EAGAIN) {
1135             rc = -EIO;
1136         }
1137         goto out;
1138     }
1139
1140     if (request->len > NBD_MAX_BUFFER_SIZE) {
1141         LOG("len (%u) is larger than max len (%u)",
1142             request->len, NBD_MAX_BUFFER_SIZE);
1143         rc = -EINVAL;
1144         goto out;
1145     }
1146
1147     if ((request->from + request->len) < request->from) {
1148         LOG("integer overflow detected! "
1149             "you're probably being attacked");
1150         rc = -EINVAL;
1151         goto out;
1152     }
1153
1154     TRACE("Decoding type");
1155
1156     command = request->type & NBD_CMD_MASK_COMMAND;
1157     if (command == NBD_CMD_READ || command == NBD_CMD_WRITE) {
1158         req->data = blk_blockalign(client->exp->blk, request->len);
1159     }
1160     if (command == NBD_CMD_WRITE) {
1161         TRACE("Reading %u byte(s)", request->len);
1162
1163         if (qemu_co_recv(csock, req->data, request->len) != request->len) {
1164             LOG("reading from socket failed");
1165             rc = -EIO;
1166             goto out;
1167         }
1168     }
1169     rc = 0;
1170
1171 out:
1172     client->recv_coroutine = NULL;
1173     nbd_update_can_read(client);
1174
1175     return rc;
1176 }
1177
1178 static void nbd_trip(void *opaque)
1179 {
1180     NBDClient *client = opaque;
1181     NBDExport *exp = client->exp;
1182     NBDRequest *req;
1183     struct nbd_request request;
1184     struct nbd_reply reply;
1185     ssize_t ret;
1186     uint32_t command;
1187
1188     TRACE("Reading request.");
1189     if (client->closing) {
1190         return;
1191     }
1192
1193     req = nbd_request_get(client);
1194     ret = nbd_co_receive_request(req, &request);
1195     if (ret == -EAGAIN) {
1196         goto done;
1197     }
1198     if (ret == -EIO) {
1199         goto out;
1200     }
1201
1202     reply.handle = request.handle;
1203     reply.error = 0;
1204
1205     if (ret < 0) {
1206         reply.error = -ret;
1207         goto error_reply;
1208     }
1209     command = request.type & NBD_CMD_MASK_COMMAND;
1210     if (command != NBD_CMD_DISC && (request.from + request.len) > exp->size) {
1211             LOG("From: %" PRIu64 ", Len: %u, Size: %" PRIu64
1212             ", Offset: %" PRIu64 "\n",
1213                     request.from, request.len,
1214                     (uint64_t)exp->size, (uint64_t)exp->dev_offset);
1215         LOG("requested operation past EOF--bad client?");
1216         goto invalid_request;
1217     }
1218
1219     switch (command) {
1220     case NBD_CMD_READ:
1221         TRACE("Request type is READ");
1222
1223         if (request.type & NBD_CMD_FLAG_FUA) {
1224             ret = blk_co_flush(exp->blk);
1225             if (ret < 0) {
1226                 LOG("flush failed");
1227                 reply.error = -ret;
1228                 goto error_reply;
1229             }
1230         }
1231
1232         ret = blk_read(exp->blk,
1233                        (request.from + exp->dev_offset) / BDRV_SECTOR_SIZE,
1234                        req->data, request.len / BDRV_SECTOR_SIZE);
1235         if (ret < 0) {
1236             LOG("reading from file failed");
1237             reply.error = -ret;
1238             goto error_reply;
1239         }
1240
1241         TRACE("Read %u byte(s)", request.len);
1242         if (nbd_co_send_reply(req, &reply, request.len) < 0)
1243             goto out;
1244         break;
1245     case NBD_CMD_WRITE:
1246         TRACE("Request type is WRITE");
1247
1248         if (exp->nbdflags & NBD_FLAG_READ_ONLY) {
1249             TRACE("Server is read-only, return error");
1250             reply.error = EROFS;
1251             goto error_reply;
1252         }
1253
1254         TRACE("Writing to device");
1255
1256         ret = blk_write(exp->blk,
1257                         (request.from + exp->dev_offset) / BDRV_SECTOR_SIZE,
1258                         req->data, request.len / BDRV_SECTOR_SIZE);
1259         if (ret < 0) {
1260             LOG("writing to file failed");
1261             reply.error = -ret;
1262             goto error_reply;
1263         }
1264
1265         if (request.type & NBD_CMD_FLAG_FUA) {
1266             ret = blk_co_flush(exp->blk);
1267             if (ret < 0) {
1268                 LOG("flush failed");
1269                 reply.error = -ret;
1270                 goto error_reply;
1271             }
1272         }
1273
1274         if (nbd_co_send_reply(req, &reply, 0) < 0) {
1275             goto out;
1276         }
1277         break;
1278     case NBD_CMD_DISC:
1279         TRACE("Request type is DISCONNECT");
1280         errno = 0;
1281         goto out;
1282     case NBD_CMD_FLUSH:
1283         TRACE("Request type is FLUSH");
1284
1285         ret = blk_co_flush(exp->blk);
1286         if (ret < 0) {
1287             LOG("flush failed");
1288             reply.error = -ret;
1289         }
1290         if (nbd_co_send_reply(req, &reply, 0) < 0) {
1291             goto out;
1292         }
1293         break;
1294     case NBD_CMD_TRIM:
1295         TRACE("Request type is TRIM");
1296         ret = blk_co_discard(exp->blk, (request.from + exp->dev_offset)
1297                                        / BDRV_SECTOR_SIZE,
1298                              request.len / BDRV_SECTOR_SIZE);
1299         if (ret < 0) {
1300             LOG("discard failed");
1301             reply.error = -ret;
1302         }
1303         if (nbd_co_send_reply(req, &reply, 0) < 0) {
1304             goto out;
1305         }
1306         break;
1307     default:
1308         LOG("invalid request type (%u) received", request.type);
1309     invalid_request:
1310         reply.error = EINVAL;
1311     error_reply:
1312         if (nbd_co_send_reply(req, &reply, 0) < 0) {
1313             goto out;
1314         }
1315         break;
1316     }
1317
1318     TRACE("Request/Reply complete");
1319
1320 done:
1321     nbd_request_put(req);
1322     return;
1323
1324 out:
1325     nbd_request_put(req);
1326     client_close(client);
1327 }
1328
1329 static void nbd_read(void *opaque)
1330 {
1331     NBDClient *client = opaque;
1332
1333     if (client->recv_coroutine) {
1334         qemu_coroutine_enter(client->recv_coroutine, NULL);
1335     } else {
1336         qemu_coroutine_enter(qemu_coroutine_create(nbd_trip), client);
1337     }
1338 }
1339
1340 static void nbd_restart_write(void *opaque)
1341 {
1342     NBDClient *client = opaque;
1343
1344     qemu_coroutine_enter(client->send_coroutine, NULL);
1345 }
1346
1347 static void nbd_set_handlers(NBDClient *client)
1348 {
1349     if (client->exp && client->exp->ctx) {
1350         aio_set_fd_handler(client->exp->ctx, client->sock,
1351                            client->can_read ? nbd_read : NULL,
1352                            client->send_coroutine ? nbd_restart_write : NULL,
1353                            client);
1354     }
1355 }
1356
1357 static void nbd_unset_handlers(NBDClient *client)
1358 {
1359     if (client->exp && client->exp->ctx) {
1360         aio_set_fd_handler(client->exp->ctx, client->sock, NULL, NULL, NULL);
1361     }
1362 }
1363
1364 static void nbd_update_can_read(NBDClient *client)
1365 {
1366     bool can_read = client->recv_coroutine ||
1367                     client->nb_requests < MAX_NBD_REQUESTS;
1368
1369     if (can_read != client->can_read) {
1370         client->can_read = can_read;
1371         nbd_set_handlers(client);
1372
1373         /* There is no need to invoke aio_notify(), since aio_set_fd_handler()
1374          * in nbd_set_handlers() will have taken care of that */
1375     }
1376 }
1377
1378 NBDClient *nbd_client_new(NBDExport *exp, int csock,
1379                           void (*close)(NBDClient *))
1380 {
1381     NBDClient *client;
1382     client = g_malloc0(sizeof(NBDClient));
1383     client->refcount = 1;
1384     client->exp = exp;
1385     client->sock = csock;
1386     client->can_read = true;
1387     if (nbd_send_negotiate(client)) {
1388         g_free(client);
1389         return NULL;
1390     }
1391     client->close = close;
1392     qemu_co_mutex_init(&client->send_lock);
1393     nbd_set_handlers(client);
1394
1395     if (exp) {
1396         QTAILQ_INSERT_TAIL(&exp->clients, client, next);
1397         nbd_export_get(exp);
1398     }
1399     return client;
1400 }