nbd/client.c

   1 /*
   2  *  Copyright (C) 2016-2019 Red Hat, Inc.
   3  *  Copyright (C) 2005  Anthony Liguori <[email protected]>
   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 "qemu/queue.h"
  23 #include "trace.h"
  24 #include "nbd-internal.h"
  25 #include "qemu/cutils.h"
  26
  27 /* Definitions for opaque data types */
  28
  29 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
  30
  31 /* That's all folks */
  32
  33 /* Basic flow for negotiation
  34
  35    Server         Client
  36    Negotiate
  37
  38    or
  39
  40    Server         Client
  41    Negotiate #1
  42                   Option
  43    Negotiate #2
  44
  45    ----
  46
  47    followed by
  48
  49    Server         Client
  50                   Request
  51    Response
  52                   Request
  53    Response
  54                   ...
  55    ...
  56                   Request (type == 2)
  57
  58 */
  59
  60 /* Send an option request.
  61  *
  62  * The request is for option @opt, with @data containing @len bytes of
  63  * additional payload for the request (@len may be -1 to treat @data as
  64  * a C string; and @data may be NULL if @len is 0).
  65  * Return 0 if successful, -1 with errp set if it is impossible to
  66  * continue. */
  67 static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt,
  68                                    uint32_t len, const char *data,
  69                                    Error **errp)
  70 {
  71     NBDOption req;
  72     QEMU_BUILD_BUG_ON(sizeof(req) != 16);
  73
  74     if (len == -1) {
  75         req.length = len = strlen(data);
  76     }
  77     trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len);
  78
  79     stq_be_p(&req.magic, NBD_OPTS_MAGIC);
  80     stl_be_p(&req.option, opt);
  81     stl_be_p(&req.length, len);
  82
  83     if (nbd_write(ioc, &req, sizeof(req), errp) < 0) {
  84         error_prepend(errp, "Failed to send option request header: ");
  85         return -1;
  86     }
  87
  88     if (len && nbd_write(ioc, (char *) data, len, errp) < 0) {
  89         error_prepend(errp, "Failed to send option request data: ");
  90         return -1;
  91     }
  92
  93     return 0;
  94 }
  95
  96 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
  97  * not going to attempt further negotiation. */
  98 static void nbd_send_opt_abort(QIOChannel *ioc)
  99 {
 100     /* Technically, a compliant server is supposed to reply to us; but
 101      * older servers disconnected instead. At any rate, we're allowed
 102      * to disconnect without waiting for the server reply, so we don't
 103      * even care if the request makes it to the server, let alone
 104      * waiting around for whether the server replies. */
 105     nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL);
 106 }
 107
 108
 109 /* Receive the header of an option reply, which should match the given
 110  * opt.  Read through the length field, but NOT the length bytes of
 111  * payload. Return 0 if successful, -1 with errp set if it is
 112  * impossible to continue. */
 113 static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,
 114                                     NBDOptionReply *reply, Error **errp)
 115 {
 116     QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);
 117     if (nbd_read(ioc, reply, sizeof(*reply), "option reply", errp) < 0) {
 118         nbd_send_opt_abort(ioc);
 119         return -1;
 120     }
 121     reply->magic = be64_to_cpu(reply->magic);
 122     reply->option = be32_to_cpu(reply->option);
 123     reply->type = be32_to_cpu(reply->type);
 124     reply->length = be32_to_cpu(reply->length);
 125
 126     trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option),
 127                                    reply->type, nbd_rep_lookup(reply->type),
 128                                    reply->length);
 129
 130     if (reply->magic != NBD_REP_MAGIC) {
 131         error_setg(errp, "Unexpected option reply magic");
 132         nbd_send_opt_abort(ioc);
 133         return -1;
 134     }
 135     if (reply->option != opt) {
 136         error_setg(errp, "Unexpected option type %u (%s), expected %u (%s)",
 137                    reply->option, nbd_opt_lookup(reply->option),
 138                    opt, nbd_opt_lookup(opt));
 139         nbd_send_opt_abort(ioc);
 140         return -1;
 141     }
 142     return 0;
 143 }
 144
 145 /*
 146  * If reply represents success, return 1 without further action.  If
 147  * reply represents an error, consume the optional payload of the
 148  * packet on ioc.  Then return 0 for unsupported (so the client can
 149  * fall back to other approaches), where @strict determines if only
 150  * ERR_UNSUP or all errors fit that category, or -1 with errp set for
 151  * other errors.
 152  */
 153 static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply,
 154                                 bool strict, Error **errp)
 155 {
 156     g_autofree char *msg = NULL;
 157
 158     if (!(reply->type & (1 << 31))) {
 159         return 1;
 160     }
 161
 162     if (reply->length) {
 163         if (reply->length > NBD_MAX_BUFFER_SIZE) {
 164             error_setg(errp, "server error %" PRIu32
 165                        " (%s) message is too long",
 166                        reply->type, nbd_rep_lookup(reply->type));
 167             goto err;
 168         }
 169         msg = g_malloc(reply->length + 1);
 170         if (nbd_read(ioc, msg, reply->length, NULL, errp) < 0) {
 171             error_prepend(errp, "Failed to read option error %" PRIu32
 172                           " (%s) message: ",
 173                           reply->type, nbd_rep_lookup(reply->type));
 174             goto err;
 175         }
 176         msg[reply->length] = '\0';
 177         trace_nbd_server_error_msg(reply->type,
 178                                    nbd_reply_type_lookup(reply->type), msg);
 179     }
 180
 181     if (reply->type == NBD_REP_ERR_UNSUP || !strict) {
 182         trace_nbd_reply_err_ignored(reply->option,
 183                                     nbd_opt_lookup(reply->option),
 184                                     reply->type, nbd_rep_lookup(reply->type));
 185         return 0;
 186     }
 187
 188     switch (reply->type) {
 189     case NBD_REP_ERR_POLICY:
 190         error_setg(errp, "Denied by server for option %" PRIu32 " (%s)",
 191                    reply->option, nbd_opt_lookup(reply->option));
 192         break;
 193
 194     case NBD_REP_ERR_INVALID:
 195         error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)",
 196                    reply->option, nbd_opt_lookup(reply->option));
 197         break;
 198
 199     case NBD_REP_ERR_PLATFORM:
 200         error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)",
 201                    reply->option, nbd_opt_lookup(reply->option));
 202         break;
 203
 204     case NBD_REP_ERR_TLS_REQD:
 205         error_setg(errp, "TLS negotiation required before option %" PRIu32
 206                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 207         error_append_hint(errp, "Did you forget a valid tls-creds?\n");
 208         break;
 209
 210     case NBD_REP_ERR_UNKNOWN:
 211         error_setg(errp, "Requested export not available");
 212         break;
 213
 214     case NBD_REP_ERR_SHUTDOWN:
 215         error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)",
 216                    reply->option, nbd_opt_lookup(reply->option));
 217         break;
 218
 219     case NBD_REP_ERR_BLOCK_SIZE_REQD:
 220         error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
 221                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 222         break;
 223
 224     default:
 225         error_setg(errp, "Unknown error code when asking for option %" PRIu32
 226                    " (%s)", reply->option, nbd_opt_lookup(reply->option));
 227         break;
 228     }
 229
 230     if (msg) {
 231         error_append_hint(errp, "server reported: %s\n", msg);
 232     }
 233
 234  err:
 235     nbd_send_opt_abort(ioc);
 236     return -1;
 237 }
 238
 239 /* nbd_receive_list:
 240  * Process another portion of the NBD_OPT_LIST reply, populating any
 241  * name received into *@name. If @description is non-NULL, and the
 242  * server provided a description, that is also populated. The caller
 243  * must eventually call g_free() on success.
 244  * Returns 1 if name and description were set and iteration must continue,
 245  *         0 if iteration is complete (including if OPT_LIST unsupported),
 246  *         -1 with @errp set if an unrecoverable error occurred.
 247  */
 248 static int nbd_receive_list(QIOChannel *ioc, char **name, char **description,
 249                             Error **errp)
 250 {
 251     NBDOptionReply reply;
 252     uint32_t len;
 253     uint32_t namelen;
 254     g_autofree char *local_name = NULL;
 255     g_autofree char *local_desc = NULL;
 256     int error;
 257
 258     if (nbd_receive_option_reply(ioc, NBD_OPT_LIST, &reply, errp) < 0) {
 259         return -1;
 260     }
 261     error = nbd_handle_reply_err(ioc, &reply, true, errp);
 262     if (error <= 0) {
 263         return error;
 264     }
 265     len = reply.length;
 266
 267     if (reply.type == NBD_REP_ACK) {
 268         if (len != 0) {
 269             error_setg(errp, "length too long for option end");
 270             nbd_send_opt_abort(ioc);
 271             return -1;
 272         }
 273         return 0;
 274     } else if (reply.type != NBD_REP_SERVER) {
 275         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 276                    reply.type, nbd_rep_lookup(reply.type),
 277                    NBD_REP_SERVER, nbd_rep_lookup(NBD_REP_SERVER));
 278         nbd_send_opt_abort(ioc);
 279         return -1;
 280     }
 281
 282     if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
 283         error_setg(errp, "incorrect option length %" PRIu32, len);
 284         nbd_send_opt_abort(ioc);
 285         return -1;
 286     }
 287     if (nbd_read32(ioc, &namelen, "option name length", errp) < 0) {
 288         nbd_send_opt_abort(ioc);
 289         return -1;
 290     }
 291     len -= sizeof(namelen);
 292     if (len < namelen) {
 293         error_setg(errp, "incorrect option name length");
 294         nbd_send_opt_abort(ioc);
 295         return -1;
 296     }
 297
 298     local_name = g_malloc(namelen + 1);
 299     if (nbd_read(ioc, local_name, namelen, "export name", errp) < 0) {
 300         nbd_send_opt_abort(ioc);
 301         return -1;
 302     }
 303     local_name[namelen] = '\0';
 304     len -= namelen;
 305     if (len) {
 306         local_desc = g_malloc(len + 1);
 307         if (nbd_read(ioc, local_desc, len, "export description", errp) < 0) {
 308             nbd_send_opt_abort(ioc);
 309             return -1;
 310         }
 311         local_desc[len] = '\0';
 312     }
 313
 314     trace_nbd_receive_list(local_name, local_desc ?: "");
 315     *name = g_steal_pointer(&local_name);
 316     if (description) {
 317         *description = g_steal_pointer(&local_desc);
 318     }
 319     return 1;
 320 }
 321
 322
 323 /*
 324  * nbd_opt_info_or_go:
 325  * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.
 326  * Returns -1 if the option proves the export @info->name cannot be
 327  * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and
 328  * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
 329  * go (with the rest of @info populated).
 330  */
 331 static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt,
 332                               NBDExportInfo *info, Error **errp)
 333 {
 334     NBDOptionReply reply;
 335     uint32_t len = strlen(info->name);
 336     uint16_t type;
 337     int error;
 338     char *buf;
 339
 340     /* The protocol requires that the server send NBD_INFO_EXPORT with
 341      * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
 342      * flags still 0 is a witness of a broken server. */
 343     info->flags = 0;
 344
 345     assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO);
 346     trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name);
 347     buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);
 348     stl_be_p(buf, len);
 349     memcpy(buf + 4, info->name, len);
 350     /* At most one request, everything else up to server */
 351     stw_be_p(buf + 4 + len, info->request_sizes);
 352     if (info->request_sizes) {
 353         stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);
 354     }
 355     error = nbd_send_option_request(ioc, opt,
 356                                     4 + len + 2 + 2 * info->request_sizes,
 357                                     buf, errp);
 358     g_free(buf);
 359     if (error < 0) {
 360         return -1;
 361     }
 362
 363     while (1) {
 364         if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 365             return -1;
 366         }
 367         error = nbd_handle_reply_err(ioc, &reply, true, errp);
 368         if (error <= 0) {
 369             return error;
 370         }
 371         len = reply.length;
 372
 373         if (reply.type == NBD_REP_ACK) {
 374             /*
 375              * Server is done sending info, and moved into transmission
 376              * phase for NBD_OPT_GO, but make sure it sent flags
 377              */
 378             if (len) {
 379                 error_setg(errp, "server sent invalid NBD_REP_ACK");
 380                 return -1;
 381             }
 382             if (!info->flags) {
 383                 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");
 384                 return -1;
 385             }
 386             trace_nbd_opt_info_go_success(nbd_opt_lookup(opt));
 387             return 1;
 388         }
 389         if (reply.type != NBD_REP_INFO) {
 390             error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",
 391                        reply.type, nbd_rep_lookup(reply.type),
 392                        NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));
 393             nbd_send_opt_abort(ioc);
 394             return -1;
 395         }
 396         if (len < sizeof(type)) {
 397             error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",
 398                        len);
 399             nbd_send_opt_abort(ioc);
 400             return -1;
 401         }
 402         if (nbd_read16(ioc, &type, "info type", errp) < 0) {
 403             nbd_send_opt_abort(ioc);
 404             return -1;
 405         }
 406         len -= sizeof(type);
 407         switch (type) {
 408         case NBD_INFO_EXPORT:
 409             if (len != sizeof(info->size) + sizeof(info->flags)) {
 410                 error_setg(errp, "remaining export info len %" PRIu32
 411                            " is unexpected size", len);
 412                 nbd_send_opt_abort(ioc);
 413                 return -1;
 414             }
 415             if (nbd_read64(ioc, &info->size, "info size", errp) < 0) {
 416                 nbd_send_opt_abort(ioc);
 417                 return -1;
 418             }
 419             if (nbd_read16(ioc, &info->flags, "info flags", errp) < 0) {
 420                 nbd_send_opt_abort(ioc);
 421                 return -1;
 422             }
 423             if (info->min_block &&
 424                 !QEMU_IS_ALIGNED(info->size, info->min_block)) {
 425                 error_setg(errp, "export size %" PRIu64 " is not multiple of "
 426                            "minimum block size %" PRIu32, info->size,
 427                            info->min_block);
 428                 nbd_send_opt_abort(ioc);
 429                 return -1;
 430             }
 431             trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
 432             break;
 433
 434         case NBD_INFO_BLOCK_SIZE:
 435             if (len != sizeof(info->min_block) * 3) {
 436                 error_setg(errp, "remaining export info len %" PRIu32
 437                            " is unexpected size", len);
 438                 nbd_send_opt_abort(ioc);
 439                 return -1;
 440             }
 441             if (nbd_read32(ioc, &info->min_block, "info minimum block size",
 442                            errp) < 0) {
 443                 nbd_send_opt_abort(ioc);
 444                 return -1;
 445             }
 446             if (!is_power_of_2(info->min_block)) {
 447                 error_setg(errp, "server minimum block size %" PRIu32
 448                            " is not a power of two", info->min_block);
 449                 nbd_send_opt_abort(ioc);
 450                 return -1;
 451             }
 452             if (nbd_read32(ioc, &info->opt_block, "info preferred block size",
 453                            errp) < 0)
 454             {
 455                 nbd_send_opt_abort(ioc);
 456                 return -1;
 457             }
 458             if (!is_power_of_2(info->opt_block) ||
 459                 info->opt_block < info->min_block) {
 460                 error_setg(errp, "server preferred block size %" PRIu32
 461                            " is not valid", info->opt_block);
 462                 nbd_send_opt_abort(ioc);
 463                 return -1;
 464             }
 465             if (nbd_read32(ioc, &info->max_block, "info maximum block size",
 466                            errp) < 0)
 467             {
 468                 nbd_send_opt_abort(ioc);
 469                 return -1;
 470             }
 471             if (info->max_block < info->min_block) {
 472                 error_setg(errp, "server maximum block size %" PRIu32
 473                            " is not valid", info->max_block);
 474                 nbd_send_opt_abort(ioc);
 475                 return -1;
 476             }
 477             trace_nbd_opt_info_block_size(info->min_block, info->opt_block,
 478                                           info->max_block);
 479             break;
 480
 481         default:
 482             trace_nbd_opt_info_unknown(type, nbd_info_lookup(type));
 483             if (nbd_drop(ioc, len, errp) < 0) {
 484                 error_prepend(errp, "Failed to read info payload: ");
 485                 nbd_send_opt_abort(ioc);
 486                 return -1;
 487             }
 488             break;
 489         }
 490     }
 491 }
 492
 493 /* Return -1 on failure, 0 if wantname is an available export. */
 494 static int nbd_receive_query_exports(QIOChannel *ioc,
 495                                      const char *wantname,
 496                                      Error **errp)
 497 {
 498     bool list_empty = true;
 499     bool found_export = false;
 500
 501     trace_nbd_receive_query_exports_start(wantname);
 502     if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
 503         return -1;
 504     }
 505
 506     while (1) {
 507         char *name;
 508         int ret = nbd_receive_list(ioc, &name, NULL, errp);
 509
 510         if (ret < 0) {
 511             /* Server gave unexpected reply */
 512             return -1;
 513         } else if (ret == 0) {
 514             /* Done iterating. */
 515             if (list_empty) {
 516                 /*
 517                  * We don't have enough context to tell a server that
 518                  * sent an empty list apart from a server that does
 519                  * not support the list command; but as this function
 520                  * is just used to trigger a nicer error message
 521                  * before trying NBD_OPT_EXPORT_NAME, assume the
 522                  * export is available.
 523                  */
 524                 return 0;
 525             } else if (!found_export) {
 526                 error_setg(errp, "No export with name '%s' available",
 527                            wantname);
 528                 nbd_send_opt_abort(ioc);
 529                 return -1;
 530             }
 531             trace_nbd_receive_query_exports_success(wantname);
 532             return 0;
 533         }
 534         list_empty = false;
 535         if (!strcmp(name, wantname)) {
 536             found_export = true;
 537         }
 538         g_free(name);
 539     }
 540 }
 541
 542 /*
 543  * nbd_request_simple_option: Send an option request, and parse the reply.
 544  * @strict controls whether ERR_UNSUP or all errors produce 0 status.
 545  * return 1 for successful negotiation,
 546  *        0 if operation is unsupported,
 547  *        -1 with errp set for any other error
 548  */
 549 static int nbd_request_simple_option(QIOChannel *ioc, int opt, bool strict,
 550                                      Error **errp)
 551 {
 552     NBDOptionReply reply;
 553     int error;
 554
 555     if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {
 556         return -1;
 557     }
 558
 559     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 560         return -1;
 561     }
 562     error = nbd_handle_reply_err(ioc, &reply, strict, errp);
 563     if (error <= 0) {
 564         return error;
 565     }
 566
 567     if (reply.type != NBD_REP_ACK) {
 568         error_setg(errp, "Server answered option %d (%s) with unexpected "
 569                    "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),
 570                    reply.type, nbd_rep_lookup(reply.type));
 571         nbd_send_opt_abort(ioc);
 572         return -1;
 573     }
 574
 575     if (reply.length != 0) {
 576         error_setg(errp, "Option %d ('%s') response length is %" PRIu32
 577                    " (it should be zero)", opt, nbd_opt_lookup(opt),
 578                    reply.length);
 579         nbd_send_opt_abort(ioc);
 580         return -1;
 581     }
 582
 583     return 1;
 584 }
 585
 586 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
 587                                         QCryptoTLSCreds *tlscreds,
 588                                         const char *hostname, Error **errp)
 589 {
 590     int ret;
 591     QIOChannelTLS *tioc;
 592     struct NBDTLSHandshakeData data = { 0 };
 593
 594     ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, true, errp);
 595     if (ret <= 0) {
 596         if (ret == 0) {
 597             error_setg(errp, "Server don't support STARTTLS option");
 598             nbd_send_opt_abort(ioc);
 599         }
 600         return NULL;
 601     }
 602
 603     trace_nbd_receive_starttls_new_client();
 604     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
 605     if (!tioc) {
 606         return NULL;
 607     }
 608     qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");
 609     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
 610     trace_nbd_receive_starttls_tls_handshake();
 611     qio_channel_tls_handshake(tioc,
 612                               nbd_tls_handshake,
 613                               &data,
 614                               NULL,
 615                               NULL);
 616
 617     if (!data.complete) {
 618         g_main_loop_run(data.loop);
 619     }
 620     g_main_loop_unref(data.loop);
 621     if (data.error) {
 622         error_propagate(errp, data.error);
 623         object_unref(OBJECT(tioc));
 624         return NULL;
 625     }
 626
 627     return QIO_CHANNEL(tioc);
 628 }
 629
 630 /*
 631  * nbd_send_meta_query:
 632  * Send 0 or 1 set/list meta context queries.
 633  * Return 0 on success, -1 with errp set for any error
 634  */
 635 static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt,
 636                                const char *export, const char *query,
 637                                Error **errp)
 638 {
 639     int ret;
 640     uint32_t export_len = strlen(export);
 641     uint32_t queries = !!query;
 642     uint32_t query_len = 0;
 643     uint32_t data_len;
 644     char *data;
 645     char *p;
 646
 647     data_len = sizeof(export_len) + export_len + sizeof(queries);
 648     if (query) {
 649         query_len = strlen(query);
 650         data_len += sizeof(query_len) + query_len;
 651     } else {
 652         assert(opt == NBD_OPT_LIST_META_CONTEXT);
 653     }
 654     p = data = g_malloc(data_len);
 655
 656     trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export);
 657     stl_be_p(p, export_len);
 658     memcpy(p += sizeof(export_len), export, export_len);
 659     stl_be_p(p += export_len, queries);
 660     if (query) {
 661         stl_be_p(p += sizeof(queries), query_len);
 662         memcpy(p += sizeof(query_len), query, query_len);
 663     }
 664
 665     ret = nbd_send_option_request(ioc, opt, data_len, data, errp);
 666     g_free(data);
 667     return ret;
 668 }
 669
 670 /*
 671  * nbd_receive_one_meta_context:
 672  * Called in a loop to receive and trace one set/list meta context reply.
 673  * Pass non-NULL @name or @id to collect results back to the caller, which
 674  * must eventually call g_free().
 675  * return 1 if name is set and iteration must continue,
 676  *        0 if iteration is complete (including if option is unsupported),
 677  *        -1 with errp set for any error
 678  */
 679 static int nbd_receive_one_meta_context(QIOChannel *ioc,
 680                                         uint32_t opt,
 681                                         char **name,
 682                                         uint32_t *id,
 683                                         Error **errp)
 684 {
 685     int ret;
 686     NBDOptionReply reply;
 687     char *local_name = NULL;
 688     uint32_t local_id;
 689
 690     if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {
 691         return -1;
 692     }
 693
 694     ret = nbd_handle_reply_err(ioc, &reply, false, errp);
 695     if (ret <= 0) {
 696         return ret;
 697     }
 698
 699     if (reply.type == NBD_REP_ACK) {
 700         if (reply.length != 0) {
 701             error_setg(errp, "Unexpected length to ACK response");
 702             nbd_send_opt_abort(ioc);
 703             return -1;
 704         }
 705         return 0;
 706     } else if (reply.type != NBD_REP_META_CONTEXT) {
 707         error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",
 708                    reply.type, nbd_rep_lookup(reply.type),
 709                    NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT));
 710         nbd_send_opt_abort(ioc);
 711         return -1;
 712     }
 713
 714     if (reply.length <= sizeof(local_id) ||
 715         reply.length > NBD_MAX_BUFFER_SIZE) {
 716         error_setg(errp, "Failed to negotiate meta context, server "
 717                    "answered with unexpected length %" PRIu32,
 718                    reply.length);
 719         nbd_send_opt_abort(ioc);
 720         return -1;
 721     }
 722
 723     if (nbd_read32(ioc, &local_id, "context id", errp) < 0) {
 724         return -1;
 725     }
 726
 727     reply.length -= sizeof(local_id);
 728     local_name = g_malloc(reply.length + 1);
 729     if (nbd_read(ioc, local_name, reply.length, "context name", errp) < 0) {
 730         g_free(local_name);
 731         return -1;
 732     }
 733     local_name[reply.length] = '\0';
 734     trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id);
 735
 736     if (name) {
 737         *name = local_name;
 738     } else {
 739         g_free(local_name);
 740     }
 741     if (id) {
 742         *id = local_id;
 743     }
 744     return 1;
 745 }
 746
 747 /*
 748  * nbd_negotiate_simple_meta_context:
 749  * Request the server to set the meta context for export @info->name
 750  * using @info->x_dirty_bitmap with a fallback to "base:allocation",
 751  * setting @info->context_id to the resulting id. Fail if the server
 752  * responds with more than one context or with a context different
 753  * than the query.
 754  * return 1 for successful negotiation,
 755  *        0 if operation is unsupported,
 756  *        -1 with errp set for any other error
 757  */
 758 static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,
 759                                              NBDExportInfo *info,
 760                                              Error **errp)
 761 {
 762     /*
 763      * TODO: Removing the x_dirty_bitmap hack will mean refactoring
 764      * this function to request and store ids for multiple contexts
 765      * (both base:allocation and a dirty bitmap), at which point this
 766      * function should lose the term _simple.
 767      */
 768     int ret;
 769     const char *context = info->x_dirty_bitmap ?: "base:allocation";
 770     bool received = false;
 771     char *name = NULL;
 772
 773     if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT,
 774                             info->name, context, errp) < 0) {
 775         return -1;
 776     }
 777
 778     ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 779                                        &name, &info->context_id, errp);
 780     if (ret < 0) {
 781         return -1;
 782     }
 783     if (ret == 1) {
 784         if (strcmp(context, name)) {
 785             error_setg(errp, "Failed to negotiate meta context '%s', server "
 786                        "answered with different context '%s'", context,
 787                        name);
 788             g_free(name);
 789             nbd_send_opt_abort(ioc);
 790             return -1;
 791         }
 792         g_free(name);
 793         received = true;
 794
 795         ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,
 796                                            NULL, NULL, errp);
 797         if (ret < 0) {
 798             return -1;
 799         }
 800     }
 801     if (ret != 0) {
 802         error_setg(errp, "Server answered with more than one context");
 803         nbd_send_opt_abort(ioc);
 804         return -1;
 805     }
 806     return received;
 807 }
 808
 809 /*
 810  * nbd_list_meta_contexts:
 811  * Request the server to list all meta contexts for export @info->name.
 812  * return 0 if list is complete (even if empty),
 813  *        -1 with errp set for any error
 814  */
 815 static int nbd_list_meta_contexts(QIOChannel *ioc,
 816                                   NBDExportInfo *info,
 817                                   Error **errp)
 818 {
 819     int ret;
 820     int seen_any = false;
 821     int seen_qemu = false;
 822
 823     if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,
 824                             info->name, NULL, errp) < 0) {
 825         return -1;
 826     }
 827
 828     while (1) {
 829         char *context;
 830
 831         ret = nbd_receive_one_meta_context(ioc, NBD_OPT_LIST_META_CONTEXT,
 832                                            &context, NULL, errp);
 833         if (ret == 0 && seen_any && !seen_qemu) {
 834             /*
 835              * Work around qemu 3.0 bug: the server forgot to send
 836              * "qemu:" replies to 0 queries. If we saw at least one
 837              * reply (probably base:allocation), but none of them were
 838              * qemu:, then run a more specific query to make sure.
 839              */
 840             seen_qemu = true;
 841             if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,
 842                                     info->name, "qemu:", errp) < 0) {
 843                 return -1;
 844             }
 845             continue;
 846         }
 847         if (ret <= 0) {
 848             return ret;
 849         }
 850         seen_any = true;
 851         seen_qemu |= strstart(context, "qemu:", NULL);
 852         info->contexts = g_renew(char *, info->contexts, ++info->n_contexts);
 853         info->contexts[info->n_contexts - 1] = context;
 854     }
 855 }
 856
 857 /*
 858  * nbd_start_negotiate:
 859  * Start the handshake to the server.  After a positive return, the server
 860  * is ready to accept additional NBD_OPT requests.
 861  * Returns: negative errno: failure talking to server
 862  *          0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
 863  *          1: server is newstyle, but can only accept EXPORT_NAME
 864  *          2: server is newstyle, but lacks structured replies
 865  *          3: server is newstyle and set up for structured replies
 866  */
 867 static int nbd_start_negotiate(AioContext *aio_context, QIOChannel *ioc,
 868                                QCryptoTLSCreds *tlscreds,
 869                                const char *hostname, QIOChannel **outioc,
 870                                bool structured_reply, bool *zeroes,
 871                                Error **errp)
 872 {
 873     uint64_t magic;
 874
 875     trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>");
 876
 877     if (zeroes) {
 878         *zeroes = true;
 879     }
 880     if (outioc) {
 881         *outioc = NULL;
 882     }
 883     if (tlscreds && !outioc) {
 884         error_setg(errp, "Output I/O channel required for TLS");
 885         return -EINVAL;
 886     }
 887
 888     if (nbd_read64(ioc, &magic, "initial magic", errp) < 0) {
 889         return -EINVAL;
 890     }
 891     trace_nbd_receive_negotiate_magic(magic);
 892
 893     if (magic != NBD_INIT_MAGIC) {
 894         error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);
 895         return -EINVAL;
 896     }
 897
 898     if (nbd_read64(ioc, &magic, "server magic", errp) < 0) {
 899         return -EINVAL;
 900     }
 901     trace_nbd_receive_negotiate_magic(magic);
 902
 903     if (magic == NBD_OPTS_MAGIC) {
 904         uint32_t clientflags = 0;
 905         uint16_t globalflags;
 906         bool fixedNewStyle = false;
 907
 908         if (nbd_read16(ioc, &globalflags, "server flags", errp) < 0) {
 909             return -EINVAL;
 910         }
 911         trace_nbd_receive_negotiate_server_flags(globalflags);
 912         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
 913             fixedNewStyle = true;
 914             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
 915         }
 916         if (globalflags & NBD_FLAG_NO_ZEROES) {
 917             if (zeroes) {
 918                 *zeroes = false;
 919             }
 920             clientflags |= NBD_FLAG_C_NO_ZEROES;
 921         }
 922         /* client requested flags */
 923         clientflags = cpu_to_be32(clientflags);
 924         if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {
 925             error_prepend(errp, "Failed to send clientflags field: ");
 926             return -EINVAL;
 927         }
 928         if (tlscreds) {
 929             if (fixedNewStyle) {
 930                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
 931                 if (!*outioc) {
 932                     return -EINVAL;
 933                 }
 934                 ioc = *outioc;
 935                 if (aio_context) {
 936                     qio_channel_set_blocking(ioc, false, NULL);
 937                     qio_channel_attach_aio_context(ioc, aio_context);
 938                 }
 939             } else {
 940                 error_setg(errp, "Server does not support STARTTLS");
 941                 return -EINVAL;
 942             }
 943         }
 944         if (fixedNewStyle) {
 945             int result = 0;
 946
 947             if (structured_reply) {
 948                 result = nbd_request_simple_option(ioc,
 949                                                    NBD_OPT_STRUCTURED_REPLY,
 950                                                    false, errp);
 951                 if (result < 0) {
 952                     return -EINVAL;
 953                 }
 954             }
 955             return 2 + result;
 956         } else {
 957             return 1;
 958         }
 959     } else if (magic == NBD_CLIENT_MAGIC) {
 960         if (tlscreds) {
 961             error_setg(errp, "Server does not support STARTTLS");
 962             return -EINVAL;
 963         }
 964         return 0;
 965     } else {
 966         error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);
 967         return -EINVAL;
 968     }
 969 }
 970
 971 /*
 972  * nbd_negotiate_finish_oldstyle:
 973  * Populate @info with the size and export flags from an oldstyle server,
 974  * but does not consume 124 bytes of reserved zero padding.
 975  * Returns 0 on success, -1 with @errp set on failure
 976  */
 977 static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info,
 978                                          Error **errp)
 979 {
 980     uint32_t oldflags;
 981
 982     if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {
 983         return -EINVAL;
 984     }
 985
 986     if (nbd_read32(ioc, &oldflags, "export flags", errp) < 0) {
 987         return -EINVAL;
 988     }
 989     if (oldflags & ~0xffff) {
 990         error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
 991         return -EINVAL;
 992     }
 993     info->flags = oldflags;
 994     return 0;
 995 }
 996
 997 /*
 998  * nbd_receive_negotiate:
 999  * Connect to server, complete negotiation, and move into transmission phase.
1000  * Returns: negative errno: failure talking to server
1001  *          0: server is connected
1002  */
1003 int nbd_receive_negotiate(AioContext *aio_context, QIOChannel *ioc,
1004                           QCryptoTLSCreds *tlscreds,
1005                           const char *hostname, QIOChannel **outioc,
1006                           NBDExportInfo *info, Error **errp)
1007 {
1008     int result;
1009     bool zeroes;
1010     bool base_allocation = info->base_allocation;
1011
1012     assert(info->name);
1013     trace_nbd_receive_negotiate_name(info->name);
1014
1015     result = nbd_start_negotiate(aio_context, ioc, tlscreds, hostname, outioc,
1016                                  info->structured_reply, &zeroes, errp);
1017
1018     info->structured_reply = false;
1019     info->base_allocation = false;
1020     if (tlscreds && *outioc) {
1021         ioc = *outioc;
1022     }
1023
1024     switch (result) {
1025     case 3: /* newstyle, with structured replies */
1026         info->structured_reply = true;
1027         if (base_allocation) {
1028             result = nbd_negotiate_simple_meta_context(ioc, info, errp);
1029             if (result < 0) {
1030                 return -EINVAL;
1031             }
1032             info->base_allocation = result == 1;
1033         }
1034         /* fall through */
1035     case 2: /* newstyle, try OPT_GO */
1036         /* Try NBD_OPT_GO first - if it works, we are done (it
1037          * also gives us a good message if the server requires
1038          * TLS).  If it is not available, fall back to
1039          * NBD_OPT_LIST for nicer error messages about a missing
1040          * export, then use NBD_OPT_EXPORT_NAME.  */
1041         result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp);
1042         if (result < 0) {
1043             return -EINVAL;
1044         }
1045         if (result > 0) {
1046             return 0;
1047         }
1048         /* Check our desired export is present in the
1049          * server export list. Since NBD_OPT_EXPORT_NAME
1050          * cannot return an error message, running this
1051          * query gives us better error reporting if the
1052          * export name is not available.
1053          */
1054         if (nbd_receive_query_exports(ioc, info->name, errp) < 0) {
1055             return -EINVAL;
1056         }
1057         /* fall through */
1058     case 1: /* newstyle, but limited to EXPORT_NAME */
1059         /* write the export name request */
1060         if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name,
1061                                     errp) < 0) {
1062             return -EINVAL;
1063         }
1064
1065         /* Read the response */
1066         if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {
1067             return -EINVAL;
1068         }
1069
1070         if (nbd_read16(ioc, &info->flags, "export flags", errp) < 0) {
1071             return -EINVAL;
1072         }
1073         break;
1074     case 0: /* oldstyle, parse length and flags */
1075         if (*info->name) {
1076             error_setg(errp, "Server does not support non-empty export names");
1077             return -EINVAL;
1078         }
1079         if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) {
1080             return -EINVAL;
1081         }
1082         break;
1083     default:
1084         return result;
1085     }
1086
1087     trace_nbd_receive_negotiate_size_flags(info->size, info->flags);
1088     if (zeroes && nbd_drop(ioc, 124, errp) < 0) {
1089         error_prepend(errp, "Failed to read reserved block: ");
1090         return -EINVAL;
1091     }
1092     return 0;
1093 }
1094
1095 /* Clean up result of nbd_receive_export_list */
1096 void nbd_free_export_list(NBDExportInfo *info, int count)
1097 {
1098     int i, j;
1099
1100     if (!info) {
1101         return;
1102     }
1103
1104     for (i = 0; i < count; i++) {
1105         g_free(info[i].name);
1106         g_free(info[i].description);
1107         for (j = 0; j < info[i].n_contexts; j++) {
1108             g_free(info[i].contexts[j]);
1109         }
1110         g_free(info[i].contexts);
1111     }
1112     g_free(info);
1113 }
1114
1115 /*
1116  * nbd_receive_export_list:
1117  * Query details about a server's exports, then disconnect without
1118  * going into transmission phase. Return a count of the exports listed
1119  * in @info by the server, or -1 on error. Caller must free @info using
1120  * nbd_free_export_list().
1121  */
1122 int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,
1123                             const char *hostname, NBDExportInfo **info,
1124                             Error **errp)
1125 {
1126     int result;
1127     int count = 0;
1128     int i;
1129     int rc;
1130     int ret = -1;
1131     NBDExportInfo *array = NULL;
1132     QIOChannel *sioc = NULL;
1133
1134     *info = NULL;
1135     result = nbd_start_negotiate(NULL, ioc, tlscreds, hostname, &sioc, true,
1136                                  NULL, errp);
1137     if (tlscreds && sioc) {
1138         ioc = sioc;
1139     }
1140
1141     switch (result) {
1142     case 2:
1143     case 3:
1144         /* newstyle - use NBD_OPT_LIST to populate array, then try
1145          * NBD_OPT_INFO on each array member. If structured replies
1146          * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */
1147         if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {
1148             goto out;
1149         }
1150         while (1) {
1151             char *name;
1152             char *desc;
1153
1154             rc = nbd_receive_list(ioc, &name, &desc, errp);
1155             if (rc < 0) {
1156                 goto out;
1157             } else if (rc == 0) {
1158                 break;
1159             }
1160             array = g_renew(NBDExportInfo, array, ++count);
1161             memset(&array[count - 1], 0, sizeof(*array));
1162             array[count - 1].name = name;
1163             array[count - 1].description = desc;
1164             array[count - 1].structured_reply = result == 3;
1165         }
1166
1167         for (i = 0; i < count; i++) {
1168             array[i].request_sizes = true;
1169             rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp);
1170             if (rc < 0) {
1171                 goto out;
1172             } else if (rc == 0) {
1173                 /*
1174                  * Pointless to try rest of loop. If OPT_INFO doesn't work,
1175                  * it's unlikely that meta contexts work either
1176                  */
1177                 break;
1178             }
1179
1180             if (result == 3 &&
1181                 nbd_list_meta_contexts(ioc, &array[i], errp) < 0) {
1182                 goto out;
1183             }
1184         }
1185
1186         /* Send NBD_OPT_ABORT as a courtesy before hanging up */
1187         nbd_send_opt_abort(ioc);
1188         break;
1189     case 1: /* newstyle, but limited to EXPORT_NAME */
1190         error_setg(errp, "Server does not support export lists");
1191         /* We can't even send NBD_OPT_ABORT, so merely hang up */
1192         goto out;
1193     case 0: /* oldstyle, parse length and flags */
1194         array = g_new0(NBDExportInfo, 1);
1195         array->name = g_strdup("");
1196         count = 1;
1197
1198         if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) {
1199             goto out;
1200         }
1201
1202         /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all
1203          * errors now that we have the information we wanted. */
1204         if (nbd_drop(ioc, 124, NULL) == 0) {
1205             NBDRequest request = { .type = NBD_CMD_DISC };
1206
1207             nbd_send_request(ioc, &request);
1208         }
1209         break;
1210     default:
1211         goto out;
1212     }
1213
1214     *info = array;
1215     array = NULL;
1216     ret = count;
1217
1218  out:
1219     qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
1220     qio_channel_close(ioc, NULL);
1221     object_unref(OBJECT(sioc));
1222     nbd_free_export_list(array, count);
1223     return ret;
1224 }
1225
1226 #ifdef __linux__
1227 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,
1228              Error **errp)
1229 {
1230     unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);
1231     unsigned long sectors = info->size / sector_size;
1232
1233     /* FIXME: Once the kernel module is patched to honor block sizes,
1234      * and to advertise that fact to user space, we should update the
1235      * hand-off to the kernel to use any block sizes we learned. */
1236     assert(!info->request_sizes);
1237     if (info->size / sector_size != sectors) {
1238         error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",
1239                    info->size);
1240         return -E2BIG;
1241     }
1242
1243     trace_nbd_init_set_socket();
1244
1245     if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
1246         int serrno = errno;
1247         error_setg(errp, "Failed to set NBD socket");
1248         return -serrno;
1249     }
1250
1251     trace_nbd_init_set_block_size(sector_size);
1252
1253     if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {
1254         int serrno = errno;
1255         error_setg(errp, "Failed setting NBD block size");
1256         return -serrno;
1257     }
1258
1259     trace_nbd_init_set_size(sectors);
1260     if (info->size % sector_size) {
1261         trace_nbd_init_trailing_bytes(info->size % sector_size);
1262     }
1263
1264     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
1265         int serrno = errno;
1266         error_setg(errp, "Failed setting size (in blocks)");
1267         return -serrno;
1268     }
1269
1270     if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {
1271         if (errno == ENOTTY) {
1272             int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;
1273             trace_nbd_init_set_readonly();
1274
1275             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
1276                 int serrno = errno;
1277                 error_setg(errp, "Failed setting read-only attribute");
1278                 return -serrno;
1279             }
1280         } else {
1281             int serrno = errno;
1282             error_setg(errp, "Failed setting flags");
1283             return -serrno;
1284         }
1285     }
1286
1287     trace_nbd_init_finish();
1288
1289     return 0;
1290 }
1291
1292 int nbd_client(int fd)
1293 {
1294     int ret;
1295     int serrno;
1296
1297     trace_nbd_client_loop();
1298
1299     ret = ioctl(fd, NBD_DO_IT);
1300     if (ret < 0 && errno == EPIPE) {
1301         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1302          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
1303          * that case.
1304          */
1305         ret = 0;
1306     }
1307     serrno = errno;
1308
1309     trace_nbd_client_loop_ret(ret, strerror(serrno));
1310
1311     trace_nbd_client_clear_queue();
1312     ioctl(fd, NBD_CLEAR_QUE);
1313
1314     trace_nbd_client_clear_socket();
1315     ioctl(fd, NBD_CLEAR_SOCK);
1316
1317     errno = serrno;
1318     return ret;
1319 }
1320
1321 int nbd_disconnect(int fd)
1322 {
1323     ioctl(fd, NBD_CLEAR_QUE);
1324     ioctl(fd, NBD_DISCONNECT);
1325     ioctl(fd, NBD_CLEAR_SOCK);
1326     return 0;
1327 }
1328
1329 #endif /* __linux__ */
1330
1331 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)
1332 {
1333     uint8_t buf[NBD_REQUEST_SIZE];
1334
1335     trace_nbd_send_request(request->from, request->len, request->handle,
1336                            request->flags, request->type,
1337                            nbd_cmd_lookup(request->type));
1338
1339     stl_be_p(buf, NBD_REQUEST_MAGIC);
1340     stw_be_p(buf + 4, request->flags);
1341     stw_be_p(buf + 6, request->type);
1342     stq_be_p(buf + 8, request->handle);
1343     stq_be_p(buf + 16, request->from);
1344     stl_be_p(buf + 24, request->len);
1345
1346     return nbd_write(ioc, buf, sizeof(buf), NULL);
1347 }
1348
1349 /* nbd_receive_simple_reply
1350  * Read simple reply except magic field (which should be already read).
1351  * Payload is not read (payload is possible for CMD_READ, but here we even
1352  * don't know whether it take place or not).
1353  */
1354 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,
1355                                     Error **errp)
1356 {
1357     int ret;
1358
1359     assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);
1360
1361     ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),
1362                    sizeof(*reply) - sizeof(reply->magic), "reply", errp);
1363     if (ret < 0) {
1364         return ret;
1365     }
1366
1367     reply->error = be32_to_cpu(reply->error);
1368     reply->handle = be64_to_cpu(reply->handle);
1369
1370     return 0;
1371 }
1372
1373 /* nbd_receive_structured_reply_chunk
1374  * Read structured reply chunk except magic field (which should be already
1375  * read).
1376  * Payload is not read.
1377  */
1378 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,
1379                                               NBDStructuredReplyChunk *chunk,
1380                                               Error **errp)
1381 {
1382     int ret;
1383
1384     assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);
1385
1386     ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),
1387                    sizeof(*chunk) - sizeof(chunk->magic), "structured chunk",
1388                    errp);
1389     if (ret < 0) {
1390         return ret;
1391     }
1392
1393     chunk->flags = be16_to_cpu(chunk->flags);
1394     chunk->type = be16_to_cpu(chunk->type);
1395     chunk->handle = be64_to_cpu(chunk->handle);
1396     chunk->length = be32_to_cpu(chunk->length);
1397
1398     return 0;
1399 }
1400
1401 /* nbd_read_eof
1402  * Tries to read @size bytes from @ioc.
1403  * Returns 1 on success
1404  *         0 on eof, when no data was read (errp is not set)
1405  *         negative errno on failure (errp is set)
1406  */
1407 static inline int coroutine_fn
1408 nbd_read_eof(BlockDriverState *bs, QIOChannel *ioc, void *buffer, size_t size,
1409              Error **errp)
1410 {
1411     bool partial = false;
1412
1413     assert(size);
1414     while (size > 0) {
1415         struct iovec iov = { .iov_base = buffer, .iov_len = size };
1416         ssize_t len;
1417
1418         len = qio_channel_readv(ioc, &iov, 1, errp);
1419         if (len == QIO_CHANNEL_ERR_BLOCK) {
1420             bdrv_dec_in_flight(bs);
1421             qio_channel_yield(ioc, G_IO_IN);
1422             bdrv_inc_in_flight(bs);
1423             continue;
1424         } else if (len < 0) {
1425             return -EIO;
1426         } else if (len == 0) {
1427             if (partial) {
1428                 error_setg(errp,
1429                            "Unexpected end-of-file before all bytes were read");
1430                 return -EIO;
1431             } else {
1432                 return 0;
1433             }
1434         }
1435
1436         partial = true;
1437         size -= len;
1438         buffer = (uint8_t*) buffer + len;
1439     }
1440     return 1;
1441 }
1442
1443 /* nbd_receive_reply
1444  *
1445  * Decreases bs->in_flight while waiting for a new reply. This yield is where
1446  * we wait indefinitely and the coroutine must be able to be safely reentered
1447  * for nbd_client_attach_aio_context().
1448  *
1449  * Returns 1 on success
1450  *         0 on eof, when no data was read (errp is not set)
1451  *         negative errno on failure (errp is set)
1452  */
1453 int coroutine_fn nbd_receive_reply(BlockDriverState *bs, QIOChannel *ioc,
1454                                    NBDReply *reply, Error **errp)
1455 {
1456     int ret;
1457     const char *type;
1458
1459     ret = nbd_read_eof(bs, ioc, &reply->magic, sizeof(reply->magic), errp);
1460     if (ret <= 0) {
1461         return ret;
1462     }
1463
1464     reply->magic = be32_to_cpu(reply->magic);
1465
1466     switch (reply->magic) {
1467     case NBD_SIMPLE_REPLY_MAGIC:
1468         ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);
1469         if (ret < 0) {
1470             break;
1471         }
1472         trace_nbd_receive_simple_reply(reply->simple.error,
1473                                        nbd_err_lookup(reply->simple.error),
1474                                        reply->handle);
1475         break;
1476     case NBD_STRUCTURED_REPLY_MAGIC:
1477         ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);
1478         if (ret < 0) {
1479             break;
1480         }
1481         type = nbd_reply_type_lookup(reply->structured.type);
1482         trace_nbd_receive_structured_reply_chunk(reply->structured.flags,
1483                                                  reply->structured.type, type,
1484                                                  reply->structured.handle,
1485                                                  reply->structured.length);
1486         break;
1487     default:
1488         error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);
1489         return -EINVAL;
1490     }
1491     if (ret < 0) {
1492         return ret;
1493     }
1494
1495     return 1;
1496 }
1497