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