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