nbd/client.c

   1 /*
   2  *  Copyright (C) 2016-2017 Red Hat, Inc.
   3  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   4  *
   5  *  Network Block Device Client Side
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; under version 2 of the License.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "qapi/error.h"
  22 #include "trace.h"
  23 #include "nbd-internal.h"
  24
  25 static int nbd_errno_to_system_errno(int err)
  26 {
  27     int ret;
  28     switch (err) {
  29     case NBD_SUCCESS:
  30         ret = 0;
  31         break;
  32     case NBD_EPERM:
  33         ret = EPERM;
  34         break;
  35     case NBD_EIO:
  36         ret = EIO;
  37         break;
  38     case NBD_ENOMEM:
  39         ret = ENOMEM;
  40         break;
  41     case NBD_ENOSPC:
  42         ret = ENOSPC;
  43         break;
  44     case NBD_ESHUTDOWN:
  45         ret = ESHUTDOWN;
  46         break;
  47     default:
  48         trace_nbd_unknown_error(err);
  49         /* fallthrough */
  50     case NBD_EINVAL:
  51         ret = EINVAL;
  52         break;
  53     }
  54     return ret;
  55 }
  56
  57 /* Definitions for opaque data types */
  58
  59 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
  60
  61 /* That's all folks */
  62
  63 /* Basic flow for negotiation
  64
  65    Server         Client
  66    Negotiate
  67
  68    or
  69
  70    Server         Client
  71    Negotiate #1
  72                   Option
  73    Negotiate #2
  74
  75    ----
  76
  77    followed by
  78
  79    Server         Client
  80                   Request
  81    Response
  82                   Request
  83    Response
  84                   ...
  85    ...
  86                   Request (type == 2)
  87
  88 */
  89
  90 /* Send an option request.
  91  *
  92  * The request is for option @opt, with @data containing @len bytes of
  93  * additional payload for the request (@len may be -1 to treat @data as
  94  * a C string; and @data may be NULL if @len is 0).
  95  * Return 0 if successful, -1 with errp set if it is impossible to
  96  * continue. */
  97 static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt,
  98                                    uint32_t len, const char *data,
  99                                    Error **errp)
 100 {
 101     nbd_option req;
 102     QEMU_BUILD_BUG_ON(sizeof(req) != 16);
 103
 104     if (len == -1) {
 105         req.length = len = strlen(data);
 106     }
 107     trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len);
 108
 109     stq_be_p(&req.magic, NBD_OPTS_MAGIC);
 110     stl_be_p(&req.option, opt);
 111     stl_be_p(&req.length, len);
 112
 113     if (nbd_write(ioc, &req, sizeof(req), errp) < 0) {
 114         error_prepend(errp, "Failed to send option request header");
 115         return -1;
 116     }
 117
 118     if (len && nbd_write(ioc, (char *) data, len, errp) < 0) {
 119         error_prepend(errp, "Failed to send option request data");
 120         return -1;
 121     }
 122
 123     return 0;
 124 }
 125
 126 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
 127  * not going to attempt further negotiation. */
 128 static void nbd_send_opt_abort(QIOChannel *ioc)
 129 {
 130     /* Technically, a compliant server is supposed to reply to us; but
 131      * older servers disconnected instead. At any rate, we're allowed
 132      * to disconnect without waiting for the server reply, so we don't
 133      * even care if the request makes it to the server, let alone
 134      * waiting around for whether the server replies. */
 135     nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL);
 136 }
 137
 138
 139 /* Receive the header of an option reply, which should match the given
 140  * opt.  Read through the length field, but NOT the length bytes of
 141  * payload. Return 0 if successful, -1 with errp set if it is
 142  * impossible to continue. */
 143 static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,
 144                                     nbd_opt_reply *reply, Error **errp)
 145 {
 146     QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);
 147     if (nbd_read(ioc, reply, sizeof(*reply), errp) < 0) {
 148         error_prepend(errp, "failed to read option reply");
 149         nbd_send_opt_abort(ioc);
 150         return -1;
 151     }
 152     be64_to_cpus(&reply->magic);
 153     be32_to_cpus(&reply->option);
 154     be32_to_cpus(&reply->type);
 155     be32_to_cpus(&reply->length);
 156
 157     trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option),
 158                                    reply->type, nbd_rep_lookup(reply->type),
 159                                    reply->length);
 160
 161     if (reply->magic != NBD_REP_MAGIC) {
 162         error_setg(errp, "Unexpected option reply magic");
 163         nbd_send_opt_abort(ioc);
 164         return -1;
 165     }
 166     if (reply->option != opt) {
 167         error_setg(errp, "Unexpected option type %x expected %x",
 168                    reply->option, opt);
 169         nbd_send_opt_abort(ioc);
 170         return -1;
 171     }
 172     return 0;
 173 }
 174
 175 /* If reply represents success, return 1 without further action.
 176  * If reply represents an error, consume the optional payload of
 177  * the packet on ioc.  Then return 0 for unsupported (so the client
 178  * can fall back to other approaches), or -1 with errp set for other
 179  * errors.
 180  */
 181 static int nbd_handle_reply_err(QIOChannel *ioc, nbd_opt_reply *reply,
 182                                 Error **errp)
 183 {
 184     char *msg = NULL;
 185     int result = -1;
 186
 187     if (!(reply->type & (1 << 31))) {
 188         return 1;
 189     }
 190
 191     if (reply->length) {
 192         if (reply->length > NBD_MAX_BUFFER_SIZE) {
 193             error_setg(errp, "server error 0x%" PRIx32
 194                        " (%s) message is too long",
 195                        reply->type, nbd_rep_lookup(reply->type));
 196             goto cleanup;
 197         }
 198         msg = g_malloc(reply->length + 1);
 199         if (nbd_read(ioc, msg, reply->length, errp) < 0) {
 200             error_prepend(errp, "failed to read option error 0x%" PRIx32
 201                           " (%s) message",
 202                           reply->type, nbd_rep_lookup(reply->type));
 203             goto cleanup;
 204         }
 205         msg[reply->length] = '\0';
 206     }
 207
 208     switch (reply->type) {
 209     case NBD_REP_ERR_UNSUP:
 210         trace_nbd_reply_err_unsup(reply->option, nbd_opt_lookup(reply->option));
 211         result = 0;
 212         goto cleanup;
 213
 214     case NBD_REP_ERR_POLICY:
 215         error_setg(errp, "Denied by server for option %" PRIx32 " (%s)",
 216                    reply->option, nbd_opt_lookup(reply->option));
 217         break;
 218
 219     case NBD_REP_ERR_INVALID:
 220         error_setg(errp, "Invalid data length for option %" PRIx32 " (%s)",
 221                    reply->option, nbd_opt_lookup(reply->option));
 222         break;
 223
 224     case NBD_REP_ERR_PLATFORM:
 225         error_setg(errp, "Server lacks support for option %" PRIx32 " (%s)",
 226                    reply->option, nbd_opt_lookup(reply->option));
 227         break;
 228
 229     case NBD_REP_ERR_TLS_REQD:
 230         error_setg(errp, "TLS negotiation required before option %" PRIx32
 231                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 232         break;
 233
 234     case NBD_REP_ERR_UNKNOWN:
 235         error_setg(errp, "Requested export not available for option %" PRIx32
 236                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 237         break;
 238
 239     case NBD_REP_ERR_SHUTDOWN:
 240         error_setg(errp, "Server shutting down before option %" PRIx32 " (%s)",
 241                    reply->option, nbd_opt_lookup(reply->option));
 242         break;
 243
 244     case NBD_REP_ERR_BLOCK_SIZE_REQD:
 245         error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIx32
 246                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 247         break;
 248
 249     default:
 250         error_setg(errp, "Unknown error code when asking for option %" PRIx32
 251                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 252         break;
 253     }
 254
 255     if (msg) {
 256         error_append_hint(errp, "%s\n", msg);
 257     }
 258
 259  cleanup:
 260     g_free(msg);
 261     if (result < 0) {
 262         nbd_send_opt_abort(ioc);
 263     }
 264     return result;
 265 }
 266
 267 /* Process another portion of the NBD_OPT_LIST reply.  Set *@match if
 268  * the current reply matches @want or if the server does not support
 269  * NBD_OPT_LIST, otherwise leave @match alone.  Return 0 if iteration
 270  * is complete, positive if more replies are expected, or negative
 271  * with @errp set if an unrecoverable error occurred. */
 272 static int nbd_receive_list(QIOChannel *ioc, const char *want, bool *match,
 273                             Error **errp)
 274 {
 275     nbd_opt_reply reply;
 276     uint32_t len;
 277     uint32_t namelen;
 278     char name[NBD_MAX_NAME_SIZE + 1];
 279     int error;
 280
 281     if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
 282         return -1;
 283     }
 284     error = nbd_handle_reply_err(ioc, &reply, errp);
 285     if (error <= 0) {
 286         /* The server did not support NBD_OPT_LIST, so set *match on
 287          * the assumption that any name will be accepted.  */
 288         *match = true;
 289         return error;
 290     }
 291     len = reply.length;
 292
 293     if (reply.type == NBD_REP_ACK) {
 294         if (len != 0) {
 295             error_setg(errp, "length too long for option end");
 296             nbd_send_opt_abort(ioc);
 297             return -1;
 298         }
 299         return 0;
 300     } else if (reply.type != NBD_REP_SERVER) {
 301         error_setg(errp, "Unexpected reply type %" PRIx32 " expected %x",
 302                    reply.type, NBD_REP_SERVER);
 303         nbd_send_opt_abort(ioc);
 304         return -1;
 305     }
 306
 307     if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
 308         error_setg(errp, "incorrect option length %" PRIu32, len);
 309         nbd_send_opt_abort(ioc);
 310         return -1;
 311     }
 312     if (nbd_read(ioc, &namelen, sizeof(namelen), errp) < 0) {
 313         error_prepend(errp, "failed to read option name length");
 314         nbd_send_opt_abort(ioc);
 315         return -1;
 316     }
 317     namelen = be32_to_cpu(namelen);
 318     len -= sizeof(namelen);
 319     if (len < namelen) {
 320         error_setg(errp, "incorrect option name length");
 321         nbd_send_opt_abort(ioc);
 322         return -1;
 323     }
 324     if (namelen != strlen(want)) {
 325         if (nbd_drop(ioc, len, errp) < 0) {
 326             error_prepend(errp, "failed to skip export name with wrong length");
 327             nbd_send_opt_abort(ioc);
 328             return -1;
 329         }
 330         return 1;
 331     }
 332
 333     assert(namelen < sizeof(name));
 334     if (nbd_read(ioc, name, namelen, errp) < 0) {
 335         error_prepend(errp, "failed to read export name");
 336         nbd_send_opt_abort(ioc);
 337         return -1;
 338     }
 339     name[namelen] = '\0';
 340     len -= namelen;
 341     if (nbd_drop(ioc, len, errp) < 0) {
 342         error_prepend(errp, "failed to read export description");
 343         nbd_send_opt_abort(ioc);
 344         return -1;
 345     }
 346     if (!strcmp(name, want)) {
 347         *match = true;
 348     }
 349     return 1;
 350 }
 351
 352
 353 /* Return -1 on failure, 0 if wantname is an available export. */
 354 static int nbd_receive_query_exports(QIOChannel *ioc,
 355                                      const char *wantname,
 356                                      Error **errp)
 357 {
 358     bool foundExport = false;
 359
 360     trace_nbd_receive_query_exports_start(wantname);
 361     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 362         return -1;
 363     }
 364
 365     while (1) {
 366         int ret = nbd_receive_list(ioc, wantname, &foundExport, errp);
 367
 368         if (ret < 0) {
 369             /* Server gave unexpected reply */
 370             return -1;
 371         } else if (ret == 0) {
 372             /* Done iterating. */
 373             if (!foundExport) {
 374                 error_setg(errp, "No export with name '%s' available",
 375                            wantname);
 376                 nbd_send_opt_abort(ioc);
 377                 return -1;
 378             }
 379             trace_nbd_receive_query_exports_success(wantname);
 380             return 0;
 381         }
 382     }
 383 }
 384
 385 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 386                                         QCryptoTLSCreds *tlscreds,
 387                                         const char *hostname, Error **errp)
 388 {
 389     nbd_opt_reply reply;
 390     QIOChannelTLS *tioc;
 391     struct NBDTLSHandshakeData data = { 0 };
 392
 393     trace_nbd_receive_starttls_request();
 394     if (nbd_send_option_request(ioc, NBD_OPT_STARTTLS, 0, NULL, errp) < 0) {
 395         return NULL;
 396     }
 397
 398     trace_nbd_receive_starttls_reply();
 399     if (nbd_receive_option_reply(ioc, NBD_OPT_STARTTLS, &reply, errp) < 0) {
 400         return NULL;
 401     }
 402
 403     if (reply.type != NBD_REP_ACK) {
 404         error_setg(errp, "Server rejected request to start TLS %" PRIx32,
 405                    reply.type);
 406         nbd_send_opt_abort(ioc);
 407         return NULL;
 408     }
 409
 410     if (reply.length != 0) {
 411         error_setg(errp, "Start TLS response was not zero %" PRIu32,
 412                    reply.length);
 413         nbd_send_opt_abort(ioc);
 414         return NULL;
 415     }
 416
 417     trace_nbd_receive_starttls_new_client();
 418     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 419     if (!tioc) {
 420         return NULL;
 421     }
 422     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 423     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 424     trace_nbd_receive_starttls_tls_handshake();
 425     qio_channel_tls_handshake(tioc,
 426                               nbd_tls_handshake,
 427                               &data,
 428                               NULL);
 429
 430     if (!data.complete) {
 431         g_main_loop_run(data.loop);
 432     }
 433     g_main_loop_unref(data.loop);
 434     if (data.error) {
 435         error_propagate(errp, data.error);
 436         object_unref(OBJECT(tioc));
 437         return NULL;
 438     }
 439
 440     return QIO_CHANNEL(tioc);
 441 }
 442
 443
 444 int nbd_receive_negotiate(QIOChannel *ioc, const char *name,
 445                           QCryptoTLSCreds *tlscreds, const char *hostname,
 446                           QIOChannel **outioc, NBDExportInfo *info,
 447                           Error **errp)
 448 {
 449     char buf[256];
 450     uint64_t magic;
 451     int rc;
 452     bool zeroes = true;
 453
 454     trace_nbd_receive_negotiate(tlscreds, hostname ? hostname : "<null>");
 455
 456     rc = -EINVAL;
 457
 458     if (outioc) {
 459         *outioc = NULL;
 460     }
 461     if (tlscreds && !outioc) {
 462         error_setg(errp, "Output I/O channel required for TLS");
 463         goto fail;
 464     }
 465
 466     if (nbd_read(ioc, buf, 8, errp) < 0) {
 467         error_prepend(errp, "Failed to read data");
 468         goto fail;
 469     }
 470
 471     buf[8] = '\0';
 472     if (strlen(buf) == 0) {
 473         error_setg(errp, "Server connection closed unexpectedly");
 474         goto fail;
 475     }
 476
 477     magic = ldq_be_p(buf);
 478     trace_nbd_receive_negotiate_magic(magic);
 479
 480     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
 481         error_setg(errp, "Invalid magic received");
 482         goto fail;
 483     }
 484
 485     if (nbd_read(ioc, &magic, sizeof(magic), errp) < 0) {
 486         error_prepend(errp, "Failed to read magic");
 487         goto fail;
 488     }
 489     magic = be64_to_cpu(magic);
 490     trace_nbd_receive_negotiate_magic(magic);
 491
 492     if (magic == NBD_OPTS_MAGIC) {
 493         uint32_t clientflags = 0;
 494         uint16_t globalflags;
 495         bool fixedNewStyle = false;
 496
 497         if (nbd_read(ioc, &globalflags, sizeof(globalflags), errp) < 0) {
 498             error_prepend(errp, "Failed to read server flags");
 499             goto fail;
 500         }
 501         globalflags = be16_to_cpu(globalflags);
 502         trace_nbd_receive_negotiate_server_flags(globalflags);
 503         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 504             fixedNewStyle = true;
 505             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 506         }
 507         if (globalflags & NBD_FLAG_NO_ZEROES) {
 508             zeroes = false;
 509             clientflags |= NBD_FLAG_C_NO_ZEROES;
 510         }
 511         /* client requested flags */
 512         clientflags = cpu_to_be32(clientflags);
 513         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 514             error_prepend(errp, "Failed to send clientflags field");
 515             goto fail;
 516         }
 517         if (tlscreds) {
 518             if (fixedNewStyle) {
 519                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 520                 if (!*outioc) {
 521                     goto fail;
 522                 }
 523                 ioc = *outioc;
 524             } else {
 525                 error_setg(errp, "Server does not support STARTTLS");
 526                 goto fail;
 527             }
 528         }
 529         if (!name) {
 530             trace_nbd_receive_negotiate_default_name();
 531             name = "";
 532         }
 533         if (fixedNewStyle) {
 534             /* Check our desired export is present in the
 535              * server export list. Since NBD_OPT_EXPORT_NAME
 536              * cannot return an error message, running this
 537              * query gives us good error reporting if the
 538              * server required TLS
 539              */
 540             if (nbd_receive_query_exports(ioc, name, errp) < 0) {
 541                 goto fail;
 542             }
 543         }
 544         /* write the export name request */
 545         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, name,
 546                                     errp) < 0) {
 547             goto fail;
 548         }
 549
 550         /* Read the response */
 551         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 552             error_prepend(errp, "Failed to read export length");
 553             goto fail;
 554         }
 555         be64_to_cpus(&info->size);
 556
 557         if (nbd_read(ioc, &info->flags, sizeof(info->flags), errp) < 0) {
 558             error_prepend(errp, "Failed to read export flags");
 559             goto fail;
 560         }
 561         be16_to_cpus(&info->flags);
 562     } else if (magic == NBD_CLIENT_MAGIC) {
 563         uint32_t oldflags;
 564
 565         if (name) {
 566             error_setg(errp, "Server does not support export names");
 567             goto fail;
 568         }
 569         if (tlscreds) {
 570             error_setg(errp, "Server does not support STARTTLS");
 571             goto fail;
 572         }
 573
 574         if (nbd_read(ioc, &info->size, sizeof(info->size), errp) < 0) {
 575             error_prepend(errp, "Failed to read export length");
 576             goto fail;
 577         }
 578         be64_to_cpus(&info->size);
 579
 580         if (nbd_read(ioc, &oldflags, sizeof(oldflags), errp) < 0) {
 581             error_prepend(errp, "Failed to read export flags");
 582             goto fail;
 583         }
 584         be32_to_cpus(&oldflags);
 585         if (oldflags & ~0xffff) {
 586             error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 587             goto fail;
 588         }
 589         info->flags = oldflags;
 590     } else {
 591         error_setg(errp, "Bad magic received");
 592         goto fail;
 593     }
 594
 595     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 596     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
 597         error_prepend(errp, "Failed to read reserved block");
 598         goto fail;
 599     }
 600     rc = 0;
 601
 602 fail:
 603     return rc;
 604 }
 605
 606 #ifdef __linux__
 607 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
 608              Error **errp)
 609 {
 610     unsigned long sectors = info->size / BDRV_SECTOR_SIZE;
 611     if (info->size / BDRV_SECTOR_SIZE != sectors) {
 612         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
 613                    info->size);
 614         return -E2BIG;
 615     }
 616
 617     trace_nbd_init_set_socket();
 618
 619     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
 620         int serrno = errno;
 621         error_setg(errp, "Failed to set NBD socket");
 622         return -serrno;
 623     }
 624
 625     trace_nbd_init_set_block_size(BDRV_SECTOR_SIZE);
 626
 627     if (ioctl(fd, NBD_SET_BLKSIZE, (unsigned long)BDRV_SECTOR_SIZE) < 0) {
 628         int serrno = errno;
 629         error_setg(errp, "Failed setting NBD block size");
 630         return -serrno;
 631     }
 632
 633     trace_nbd_init_set_size(sectors);
 634     if (info->size % BDRV_SECTOR_SIZE) {
 635         trace_nbd_init_trailing_bytes(info->size % BDRV_SECTOR_SIZE);
 636     }
 637
 638     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
 639         int serrno = errno;
 640         error_setg(errp, "Failed setting size (in blocks)");
 641         return -serrno;
 642     }
 643
 644     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
 645         if (errno == ENOTTY) {
 646             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
 647             trace_nbd_init_set_readonly();
 648
 649             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
 650                 int serrno = errno;
 651                 error_setg(errp, "Failed setting read-only attribute");
 652                 return -serrno;
 653             }
 654         } else {
 655             int serrno = errno;
 656             error_setg(errp, "Failed setting flags");
 657             return -serrno;
 658         }
 659     }
 660
 661     trace_nbd_init_finish();
 662
 663     return 0;
 664 }
 665
 666 int nbd_client(int fd)
 667 {
 668     int ret;
 669     int serrno;
 670
 671     trace_nbd_client_loop();
 672
 673     ret = ioctl(fd, NBD_DO_IT);
 674     if (ret < 0 && errno == EPIPE) {
 675         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
 676          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
 677          * that case.
 678          */
 679         ret = 0;
 680     }
 681     serrno = errno;
 682
 683     trace_nbd_client_loop_ret(ret, strerror(serrno));
 684
 685     trace_nbd_client_clear_queue();
 686     ioctl(fd, NBD_CLEAR_QUE);
 687
 688     trace_nbd_client_clear_socket();
 689     ioctl(fd, NBD_CLEAR_SOCK);
 690
 691     errno = serrno;
 692     return ret;
 693 }
 694
 695 int nbd_disconnect(int fd)
 696 {
 697     ioctl(fd, NBD_CLEAR_QUE);
 698     ioctl(fd, NBD_DISCONNECT);
 699     ioctl(fd, NBD_CLEAR_SOCK);
 700     return 0;
 701 }
 702
 703 #else
 704 int nbd_init(int fd, QIOChannelSocket *ioc, NBDExportInfo *info,
 705              Error **errp)
 706 {
 707     error_setg(errp, "nbd_init is only supported on Linux");
 708     return -ENOTSUP;
 709 }
 710
 711 int nbd_client(int fd)
 712 {
 713     return -ENOTSUP;
 714 }
 715 int nbd_disconnect(int fd)
 716 {
 717     return -ENOTSUP;
 718 }
 719 #endif
 720
 721 ssize_t nbd_send_request(QIOChannel *ioc, NBDRequest *request)
 722 {
 723     uint8_t buf[NBD_REQUEST_SIZE];
 724
 725     trace_nbd_send_request(request->from, request->len, request->handle,
 726                            request->flags, request->type);
 727
 728     stl_be_p(buf, NBD_REQUEST_MAGIC);
 729     stw_be_p(buf + 4, request->flags);
 730     stw_be_p(buf + 6, request->type);
 731     stq_be_p(buf + 8, request->handle);
 732     stq_be_p(buf + 16, request->from);
 733     stl_be_p(buf + 24, request->len);
 734
 735     return nbd_write(ioc, buf, sizeof(buf), NULL);
 736 }
 737
 738 ssize_t nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
 739 {
 740     uint8_t buf[NBD_REPLY_SIZE];
 741     uint32_t magic;
 742     ssize_t ret;
 743
 744     ret = nbd_read_eof(ioc, buf, sizeof(buf), errp);
 745     if (ret <= 0) {
 746         return ret;
 747     }
 748
 749     if (ret != sizeof(buf)) {
 750         error_setg(errp, "read failed");
 751         return -EINVAL;
 752     }
 753
 754     /* Reply
 755        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
 756        [ 4 ..  7]    error   (0 == no error)
 757        [ 7 .. 15]    handle
 758      */
 759
 760     magic = ldl_be_p(buf);
 761     reply->error  = ldl_be_p(buf + 4);
 762     reply->handle = ldq_be_p(buf + 8);
 763
 764     reply->error = nbd_errno_to_system_errno(reply->error);
 765
 766     if (reply->error == ESHUTDOWN) {
 767         /* This works even on mingw which lacks a native ESHUTDOWN */
 768         error_setg(errp, "server shutting down");
 769         return -EINVAL;
 770     }
 771     trace_nbd_receive_reply(magic, reply->error, reply->handle);
 772
 773     if (magic != NBD_REPLY_MAGIC) {
 774         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", magic);
 775         return -EINVAL;
 776     }
 777     return sizeof(buf);
 778 }
 779