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 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 1498