git.osdn.net Git - qmiga/qemu.git/blob

1 /*

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 */

20 #include "qemu/osdep.h"

21 #include "qapi/error.h"

22 #include "trace.h"

23 #include "nbd-internal.h"

24 #include "qemu/cutils.h"

26 /* Definitions for opaque data types */

28 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);

30 /* That's all folks */

32 /* Basic flow for negotiation

34 Server Client

35 Negotiate

37 or

39 Server Client

40 Negotiate #1

41 Option

42 Negotiate #2

44 ----

46 followed by

48 Server Client

49 Request

50 Response

51 Request

52 Response

53 ...

54 ...

55 Request (type == 2)

57 */

59 /* Send an option request.

60 *

61 * The request is for option @opt, with @data containing @len bytes of

62 * additional payload for the request (@len may be -1 to treat @data as

63 * a C string; and @data may be NULL if @len is 0).

64 * Return 0 if successful, -1 with errp set if it is impossible to

65 * continue. */

66 static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt,

67 uint32_t len, const char *data,

68 Error **errp)

69 {

70 NBDOption req;

71 QEMU_BUILD_BUG_ON(sizeof(req) != 16);

73 if (len == -1) {

74 req.length = len = strlen(data);

75 }

76 trace_nbd_send_option_request(opt, nbd_opt_lookup(opt), len);

78 stq_be_p(&req.magic, NBD_OPTS_MAGIC);

79 stl_be_p(&req.option, opt);

80 stl_be_p(&req.length, len);

82 if (nbd_write(ioc, &req, sizeof(req), errp) < 0) {

83 error_prepend(errp, "Failed to send option request header: ");

84 return -1;

85 }

87 if (len && nbd_write(ioc, (char *) data, len, errp) < 0) {

88 error_prepend(errp, "Failed to send option request data: ");

89 return -1;

90 }

92 return 0;

93 }

95 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are

96 * not going to attempt further negotiation. */

97 static void nbd_send_opt_abort(QIOChannel *ioc)

98 {

99 /* Technically, a compliant server is supposed to reply to us; but

100 * older servers disconnected instead. At any rate, we're allowed

101 * to disconnect without waiting for the server reply, so we don't

102 * even care if the request makes it to the server, let alone

103 * waiting around for whether the server replies. */

104 nbd_send_option_request(ioc, NBD_OPT_ABORT, 0, NULL, NULL);

105 }

106

107

108 /* Receive the header of an option reply, which should match the given

109 * opt. Read through the length field, but NOT the length bytes of

110 * payload. Return 0 if successful, -1 with errp set if it is

111 * impossible to continue. */

112 static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,

113 NBDOptionReply *reply, Error **errp)

114 {

115 QEMU_BUILD_BUG_ON(sizeof(*reply) != 20);

116 if (nbd_read(ioc, reply, sizeof(*reply), "option reply", errp) < 0) {

117 nbd_send_opt_abort(ioc);

118 return -1;

119 }

120 reply->magic = be64_to_cpu(reply->magic);

121 reply->option = be32_to_cpu(reply->option);

122 reply->type = be32_to_cpu(reply->type);

123 reply->length = be32_to_cpu(reply->length);

124

125 trace_nbd_receive_option_reply(reply->option, nbd_opt_lookup(reply->option),

126 reply->type, nbd_rep_lookup(reply->type),

127 reply->length);

128

129 if (reply->magic != NBD_REP_MAGIC) {

130 error_setg(errp, "Unexpected option reply magic");

131 nbd_send_opt_abort(ioc);

132 return -1;

133 }

134 if (reply->option != opt) {

135 error_setg(errp, "Unexpected option type %u (%s), expected %u (%s)",

136 reply->option, nbd_opt_lookup(reply->option),

137 opt, nbd_opt_lookup(opt));

138 nbd_send_opt_abort(ioc);

139 return -1;

140 }

141 return 0;

142 }

143

144 /* If reply represents success, return 1 without further action.

145 * If reply represents an error, consume the optional payload of

146 * the packet on ioc. Then return 0 for unsupported (so the client

147 * can fall back to other approaches), or -1 with errp set for other

148 * errors.

149 */

150 static int nbd_handle_reply_err(QIOChannel *ioc, NBDOptionReply *reply,

151 Error **errp)

152 {

153 char *msg = NULL;

154 int result = -1;

155

156 if (!(reply->type & (1 << 31))) {

157 return 1;

158 }

159

160 if (reply->length) {

161 if (reply->length > NBD_MAX_BUFFER_SIZE) {

162 error_setg(errp, "server error %" PRIu32

163 " (%s) message is too long",

164 reply->type, nbd_rep_lookup(reply->type));

165 goto cleanup;

166 }

167 msg = g_malloc(reply->length + 1);

168 if (nbd_read(ioc, msg, reply->length, NULL, errp) < 0) {

169 error_prepend(errp, "Failed to read option error %" PRIu32

170 " (%s) message: ",

171 reply->type, nbd_rep_lookup(reply->type));

172 goto cleanup;

173 }

174 msg[reply->length] = '\0';

175 trace_nbd_server_error_msg(reply->type,

176 nbd_reply_type_lookup(reply->type), msg);

177 }

178

179 switch (reply->type) {

180 case NBD_REP_ERR_UNSUP:

181 trace_nbd_reply_err_unsup(reply->option, nbd_opt_lookup(reply->option));

182 result = 0;

183 goto cleanup;

184

185 case NBD_REP_ERR_POLICY:

186 error_setg(errp, "Denied by server for option %" PRIu32 " (%s)",

187 reply->option, nbd_opt_lookup(reply->option));

188 break;

189

190 case NBD_REP_ERR_INVALID:

191 error_setg(errp, "Invalid parameters for option %" PRIu32 " (%s)",

192 reply->option, nbd_opt_lookup(reply->option));

193 break;

194

195 case NBD_REP_ERR_PLATFORM:

196 error_setg(errp, "Server lacks support for option %" PRIu32 " (%s)",

197 reply->option, nbd_opt_lookup(reply->option));

198 break;

199

200 case NBD_REP_ERR_TLS_REQD:

201 error_setg(errp, "TLS negotiation required before option %" PRIu32

202 " (%s)", reply->option, nbd_opt_lookup(reply->option));

203 break;

204

205 case NBD_REP_ERR_UNKNOWN:

206 error_setg(errp, "Requested export not available");

207 break;

208

209 case NBD_REP_ERR_SHUTDOWN:

210 error_setg(errp, "Server shutting down before option %" PRIu32 " (%s)",

211 reply->option, nbd_opt_lookup(reply->option));

212 break;

213

214 case NBD_REP_ERR_BLOCK_SIZE_REQD:

215 error_setg(errp, "Server requires INFO_BLOCK_SIZE for option %" PRIu32

216 " (%s)", reply->option, nbd_opt_lookup(reply->option));

217 break;

218

219 default:

220 error_setg(errp, "Unknown error code when asking for option %" PRIu32

221 " (%s)", reply->option, nbd_opt_lookup(reply->option));

222 break;

223 }

224

225 if (msg) {

226 error_append_hint(errp, "server reported: %s\n", msg);

227 }

228

229 cleanup:

230 g_free(msg);

231 if (result < 0) {

232 nbd_send_opt_abort(ioc);

233 }

234 return result;

235 }

236

237 /* nbd_receive_list:

238 * Process another portion of the NBD_OPT_LIST reply, populating any

239 * name received into *@name. If @description is non-NULL, and the

240 * server provided a description, that is also populated. The caller

241 * must eventually call g_free() on success.

242 * Returns 1 if name and description were set and iteration must continue,

243 * 0 if iteration is complete (including if OPT_LIST unsupported),

244 * -1 with @errp set if an unrecoverable error occurred.

245 */

246 static int nbd_receive_list(QIOChannel *ioc, char **name, char **description,

247 Error **errp)

248 {

249 int ret = -1;

250 NBDOptionReply reply;

251 uint32_t len;

252 uint32_t namelen;

253 char *local_name = NULL;

254 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, 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 goto out;

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 goto out;

309 }

310 local_desc[len] = '\0';

311 }

312

313 trace_nbd_receive_list(local_name, local_desc ?: "");

314 *name = local_name;

315 local_name = NULL;

316 if (description) {

317 *description = local_desc;

318 local_desc = NULL;

319 }

320 ret = 1;

321

322 out:

323 g_free(local_name);

324 g_free(local_desc);

325 return ret;

326 }

327

328

329 /*

330 * nbd_opt_info_or_go:

331 * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.

332 * Returns -1 if the option proves the export @info->name cannot be

333 * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and

334 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to

335 * go (with the rest of @info populated).

336 */

337 static int nbd_opt_info_or_go(QIOChannel *ioc, uint32_t opt,

338 NBDExportInfo *info, Error **errp)

339 {

340 NBDOptionReply reply;

341 uint32_t len = strlen(info->name);

342 uint16_t type;

343 int error;

344 char *buf;

345

346 /* The protocol requires that the server send NBD_INFO_EXPORT with

347 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so

348 * flags still 0 is a witness of a broken server. */

349 info->flags = 0;

350

351 assert(opt == NBD_OPT_GO || opt == NBD_OPT_INFO);

352 trace_nbd_opt_info_go_start(nbd_opt_lookup(opt), info->name);

353 buf = g_malloc(4 + len + 2 + 2 * info->request_sizes + 1);

354 stl_be_p(buf, len);

355 memcpy(buf + 4, info->name, len);

356 /* At most one request, everything else up to server */

357 stw_be_p(buf + 4 + len, info->request_sizes);

358 if (info->request_sizes) {

359 stw_be_p(buf + 4 + len + 2, NBD_INFO_BLOCK_SIZE);

360 }

361 error = nbd_send_option_request(ioc, opt,

362 4 + len + 2 + 2 * info->request_sizes,

363 buf, errp);

364 g_free(buf);

365 if (error < 0) {

366 return -1;

367 }

368

369 while (1) {

370 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {

371 return -1;

372 }

373 error = nbd_handle_reply_err(ioc, &reply, errp);

374 if (error <= 0) {

375 return error;

376 }

377 len = reply.length;

378

379 if (reply.type == NBD_REP_ACK) {

380 /*

381 * Server is done sending info, and moved into transmission

382 * phase for NBD_OPT_GO, but make sure it sent flags

383 */

384 if (len) {

385 error_setg(errp, "server sent invalid NBD_REP_ACK");

386 return -1;

387 }

388 if (!info->flags) {

389 error_setg(errp, "broken server omitted NBD_INFO_EXPORT");

390 return -1;

391 }

392 trace_nbd_opt_info_go_success(nbd_opt_lookup(opt));

393 return 1;

394 }

395 if (reply.type != NBD_REP_INFO) {

396 error_setg(errp, "unexpected reply type %u (%s), expected %u (%s)",

397 reply.type, nbd_rep_lookup(reply.type),

398 NBD_REP_INFO, nbd_rep_lookup(NBD_REP_INFO));

399 nbd_send_opt_abort(ioc);

400 return -1;

401 }

402 if (len < sizeof(type)) {

403 error_setg(errp, "NBD_REP_INFO length %" PRIu32 " is too short",

404 len);

405 nbd_send_opt_abort(ioc);

406 return -1;

407 }

408 if (nbd_read16(ioc, &type, "info type", errp) < 0) {

409 nbd_send_opt_abort(ioc);

410 return -1;

411 }

412 len -= sizeof(type);

413 switch (type) {

414 case NBD_INFO_EXPORT:

415 if (len != sizeof(info->size) + sizeof(info->flags)) {

416 error_setg(errp, "remaining export info len %" PRIu32

417 " is unexpected size", len);

418 nbd_send_opt_abort(ioc);

419 return -1;

420 }

421 if (nbd_read64(ioc, &info->size, "info size", errp) < 0) {

422 nbd_send_opt_abort(ioc);

423 return -1;

424 }

425 if (nbd_read16(ioc, &info->flags, "info flags", errp) < 0) {

426 nbd_send_opt_abort(ioc);

427 return -1;

428 }

429 if (info->min_block &&

430 !QEMU_IS_ALIGNED(info->size, info->min_block)) {

431 error_setg(errp, "export size %" PRIu64 "is not multiple of "

432 "minimum block size %" PRIu32, info->size,

433 info->min_block);

434 nbd_send_opt_abort(ioc);

435 return -1;

436 }

437 trace_nbd_receive_negotiate_size_flags(info->size, info->flags);

438 break;

439

440 case NBD_INFO_BLOCK_SIZE:

441 if (len != sizeof(info->min_block) * 3) {

442 error_setg(errp, "remaining export info len %" PRIu32

443 " is unexpected size", len);

444 nbd_send_opt_abort(ioc);

445 return -1;

446 }

447 if (nbd_read32(ioc, &info->min_block, "info minimum block size",

448 errp) < 0) {

449 nbd_send_opt_abort(ioc);

450 return -1;

451 }

452 if (!is_power_of_2(info->min_block)) {

453 error_setg(errp, "server minimum block size %" PRIu32

454 " is not a power of two", info->min_block);

455 nbd_send_opt_abort(ioc);

456 return -1;

457 }

458 if (nbd_read32(ioc, &info->opt_block, "info preferred block size",

459 errp) < 0)

460 {

461 nbd_send_opt_abort(ioc);

462 return -1;

463 }

464 if (!is_power_of_2(info->opt_block) ||

465 info->opt_block < info->min_block) {

466 error_setg(errp, "server preferred block size %" PRIu32

467 " is not valid", info->opt_block);

468 nbd_send_opt_abort(ioc);

469 return -1;

470 }

471 if (nbd_read32(ioc, &info->max_block, "info maximum block size",

472 errp) < 0)

473 {

474 nbd_send_opt_abort(ioc);

475 return -1;

476 }

477 if (info->max_block < info->min_block) {

478 error_setg(errp, "server maximum block size %" PRIu32

479 " is not valid", info->max_block);

480 nbd_send_opt_abort(ioc);

481 return -1;

482 }

483 trace_nbd_opt_info_block_size(info->min_block, info->opt_block,

484 info->max_block);

485 break;

486

487 default:

488 trace_nbd_opt_info_unknown(type, nbd_info_lookup(type));

489 if (nbd_drop(ioc, len, errp) < 0) {

490 error_prepend(errp, "Failed to read info payload: ");

491 nbd_send_opt_abort(ioc);

492 return -1;

493 }

494 break;

495 }

496 }

497 }

498

499 /* Return -1 on failure, 0 if wantname is an available export. */

500 static int nbd_receive_query_exports(QIOChannel *ioc,

501 const char *wantname,

502 Error **errp)

503 {

504 bool list_empty = true;

505 bool found_export = false;

506

507 trace_nbd_receive_query_exports_start(wantname);

508 if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {

509 return -1;

510 }

511

512 while (1) {

513 char *name;

514 int ret = nbd_receive_list(ioc, &name, NULL, errp);

515

516 if (ret < 0) {

517 /* Server gave unexpected reply */

518 return -1;

519 } else if (ret == 0) {

520 /* Done iterating. */

521 if (list_empty) {

522 /*

523 * We don't have enough context to tell a server that

524 * sent an empty list apart from a server that does

525 * not support the list command; but as this function

526 * is just used to trigger a nicer error message

527 * before trying NBD_OPT_EXPORT_NAME, assume the

528 * export is available.

529 */

530 return 0;

531 } else if (!found_export) {

532 error_setg(errp, "No export with name '%s' available",

533 wantname);

534 nbd_send_opt_abort(ioc);

535 return -1;

536 }

537 trace_nbd_receive_query_exports_success(wantname);

538 return 0;

539 }

540 list_empty = false;

541 if (!strcmp(name, wantname)) {

542 found_export = true;

543 }

544 g_free(name);

545 }

546 }

547

548 /* nbd_request_simple_option: Send an option request, and parse the reply

549 * return 1 for successful negotiation,

550 * 0 if operation is unsupported,

551 * -1 with errp set for any other error

552 */

553 static int nbd_request_simple_option(QIOChannel *ioc, int opt, Error **errp)

554 {

555 NBDOptionReply reply;

556 int error;

557

558 if (nbd_send_option_request(ioc, opt, 0, NULL, errp) < 0) {

559 return -1;

560 }

561

562 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {

563 return -1;

564 }

565 error = nbd_handle_reply_err(ioc, &reply, errp);

566 if (error <= 0) {

567 return error;

568 }

569

570 if (reply.type != NBD_REP_ACK) {

571 error_setg(errp, "Server answered option %d (%s) with unexpected "

572 "reply %" PRIu32 " (%s)", opt, nbd_opt_lookup(opt),

573 reply.type, nbd_rep_lookup(reply.type));

574 nbd_send_opt_abort(ioc);

575 return -1;

576 }

577

578 if (reply.length != 0) {

579 error_setg(errp, "Option %d ('%s') response length is %" PRIu32

580 " (it should be zero)", opt, nbd_opt_lookup(opt),

581 reply.length);

582 nbd_send_opt_abort(ioc);

583 return -1;

584 }

585

586 return 1;

587 }

588

589 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,

590 QCryptoTLSCreds *tlscreds,

591 const char *hostname, Error **errp)

592 {

593 int ret;

594 QIOChannelTLS *tioc;

595 struct NBDTLSHandshakeData data = { 0 };

596

597 ret = nbd_request_simple_option(ioc, NBD_OPT_STARTTLS, errp);

598 if (ret <= 0) {

599 if (ret == 0) {

600 error_setg(errp, "Server don't support STARTTLS option");

601 nbd_send_opt_abort(ioc);

602 }

603 return NULL;

604 }

605

606 trace_nbd_receive_starttls_new_client();

607 tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);

608 if (!tioc) {

609 return NULL;

610 }

611 qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-client-tls");

612 data.loop = g_main_loop_new(g_main_context_default(), FALSE);

613 trace_nbd_receive_starttls_tls_handshake();

614 qio_channel_tls_handshake(tioc,

615 nbd_tls_handshake,

616 &data,

617 NULL,

618 NULL);

619

620 if (!data.complete) {

621 g_main_loop_run(data.loop);

622 }

623 g_main_loop_unref(data.loop);

624 if (data.error) {

625 error_propagate(errp, data.error);

626 object_unref(OBJECT(tioc));

627 return NULL;

628 }

629

630 return QIO_CHANNEL(tioc);

631 }

632

633 /*

634 * nbd_send_meta_query:

635 * Send 0 or 1 set/list meta context queries.

636 * Return 0 on success, -1 with errp set for any error

637 */

638 static int nbd_send_meta_query(QIOChannel *ioc, uint32_t opt,

639 const char *export, const char *query,

640 Error **errp)

641 {

642 int ret;

643 uint32_t export_len = strlen(export);

644 uint32_t queries = !!query;

645 uint32_t query_len = 0;

646 uint32_t data_len;

647 char *data;

648 char *p;

649

650 data_len = sizeof(export_len) + export_len + sizeof(queries);

651 if (query) {

652 query_len = strlen(query);

653 data_len += sizeof(query_len) + query_len;

654 } else {

655 assert(opt == NBD_OPT_LIST_META_CONTEXT);

656 }

657 p = data = g_malloc(data_len);

658

659 trace_nbd_opt_meta_request(nbd_opt_lookup(opt), query ?: "(all)", export);

660 stl_be_p(p, export_len);

661 memcpy(p += sizeof(export_len), export, export_len);

662 stl_be_p(p += export_len, queries);

663 if (query) {

664 stl_be_p(p += sizeof(queries), query_len);

665 memcpy(p += sizeof(query_len), query, query_len);

666 }

667

668 ret = nbd_send_option_request(ioc, opt, data_len, data, errp);

669 g_free(data);

670 return ret;

671 }

672

673 /*

674 * nbd_receive_one_meta_context:

675 * Called in a loop to receive and trace one set/list meta context reply.

676 * Pass non-NULL @name or @id to collect results back to the caller, which

677 * must eventually call g_free().

678 * return 1 if name is set and iteration must continue,

679 * 0 if iteration is complete (including if option is unsupported),

680 * -1 with errp set for any error

681 */

682 static int nbd_receive_one_meta_context(QIOChannel *ioc,

683 uint32_t opt,

684 char **name,

685 uint32_t *id,

686 Error **errp)

687 {

688 int ret;

689 NBDOptionReply reply;

690 char *local_name = NULL;

691 uint32_t local_id;

692

693 if (nbd_receive_option_reply(ioc, opt, &reply, errp) < 0) {

694 return -1;

695 }

696

697 ret = nbd_handle_reply_err(ioc, &reply, errp);

698 if (ret <= 0) {

699 return ret;

700 }

701

702 if (reply.type == NBD_REP_ACK) {

703 if (reply.length != 0) {

704 error_setg(errp, "Unexpected length to ACK response");

705 nbd_send_opt_abort(ioc);

706 return -1;

707 }

708 return 0;

709 } else if (reply.type != NBD_REP_META_CONTEXT) {

710 error_setg(errp, "Unexpected reply type %u (%s), expected %u (%s)",

711 reply.type, nbd_rep_lookup(reply.type),

712 NBD_REP_META_CONTEXT, nbd_rep_lookup(NBD_REP_META_CONTEXT));

713 nbd_send_opt_abort(ioc);

714 return -1;

715 }

716

717 if (reply.length <= sizeof(local_id) ||

718 reply.length > NBD_MAX_BUFFER_SIZE) {

719 error_setg(errp, "Failed to negotiate meta context, server "

720 "answered with unexpected length %" PRIu32,

721 reply.length);

722 nbd_send_opt_abort(ioc);

723 return -1;

724 }

725

726 if (nbd_read32(ioc, &local_id, "context id", errp) < 0) {

727 return -1;

728 }

729

730 reply.length -= sizeof(local_id);

731 local_name = g_malloc(reply.length + 1);

732 if (nbd_read(ioc, local_name, reply.length, "context name", errp) < 0) {

733 g_free(local_name);

734 return -1;

735 }

736 local_name[reply.length] = '\0';

737 trace_nbd_opt_meta_reply(nbd_opt_lookup(opt), local_name, local_id);

738

739 if (name) {

740 *name = local_name;

741 } else {

742 g_free(local_name);

743 }

744 if (id) {

745 *id = local_id;

746 }

747 return 1;

748 }

749

750 /*

751 * nbd_negotiate_simple_meta_context:

752 * Request the server to set the meta context for export @info->name

753 * using @info->x_dirty_bitmap with a fallback to "base:allocation",

754 * setting @info->context_id to the resulting id. Fail if the server

755 * responds with more than one context or with a context different

756 * than the query.

757 * return 1 for successful negotiation,

758 * 0 if operation is unsupported,

759 * -1 with errp set for any other error

760 */

761 static int nbd_negotiate_simple_meta_context(QIOChannel *ioc,

762 NBDExportInfo *info,

763 Error **errp)

764 {

765 /*

766 * TODO: Removing the x_dirty_bitmap hack will mean refactoring

767 * this function to request and store ids for multiple contexts

768 * (both base:allocation and a dirty bitmap), at which point this

769 * function should lose the term _simple.

770 */

771 int ret;

772 const char *context = info->x_dirty_bitmap ?: "base:allocation";

773 bool received = false;

774 char *name = NULL;

775

776 if (nbd_send_meta_query(ioc, NBD_OPT_SET_META_CONTEXT,

777 info->name, context, errp) < 0) {

778 return -1;

779 }

780

781 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,

782 &name, &info->context_id, errp);

783 if (ret < 0) {

784 return -1;

785 }

786 if (ret == 1) {

787 if (strcmp(context, name)) {

788 error_setg(errp, "Failed to negotiate meta context '%s', server "

789 "answered with different context '%s'", context,

790 name);

791 g_free(name);

792 nbd_send_opt_abort(ioc);

793 return -1;

794 }

795 g_free(name);

796 received = true;

797

798 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_SET_META_CONTEXT,

799 NULL, NULL, errp);

800 if (ret < 0) {

801 return -1;

802 }

803 }

804 if (ret != 0) {

805 error_setg(errp, "Server answered with more than one context");

806 nbd_send_opt_abort(ioc);

807 return -1;

808 }

809 return received;

810 }

811

812 /*

813 * nbd_list_meta_contexts:

814 * Request the server to list all meta contexts for export @info->name.

815 * return 0 if list is complete (even if empty),

816 * -1 with errp set for any error

817 */

818 static int nbd_list_meta_contexts(QIOChannel *ioc,

819 NBDExportInfo *info,

820 Error **errp)

821 {

822 int ret;

823 int seen_any = false;

824 int seen_qemu = false;

825

826 if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,

827 info->name, NULL, errp) < 0) {

828 return -1;

829 }

830

831 while (1) {

832 char *context;

833

834 ret = nbd_receive_one_meta_context(ioc, NBD_OPT_LIST_META_CONTEXT,

835 &context, NULL, errp);

836 if (ret == 0 && seen_any && !seen_qemu) {

837 /*

838 * Work around qemu 3.0 bug: the server forgot to send

839 * "qemu:" replies to 0 queries. If we saw at least one

840 * reply (probably base:allocation), but none of them were

841 * qemu:, then run a more specific query to make sure.

842 */

843 seen_qemu = true;

844 if (nbd_send_meta_query(ioc, NBD_OPT_LIST_META_CONTEXT,

845 info->name, "qemu:", errp) < 0) {

846 return -1;

847 }

848 continue;

849 }

850 if (ret <= 0) {

851 return ret;

852 }

853 seen_any = true;

854 seen_qemu |= strstart(context, "qemu:", NULL);

855 info->contexts = g_renew(char *, info->contexts, ++info->n_contexts);

856 info->contexts[info->n_contexts - 1] = context;

857 }

858 }

859

860 /*

861 * nbd_start_negotiate:

862 * Start the handshake to the server. After a positive return, the server

863 * is ready to accept additional NBD_OPT requests.

864 * Returns: negative errno: failure talking to server

865 * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle

866 * 1: server is newstyle, but can only accept EXPORT_NAME

867 * 2: server is newstyle, but lacks structured replies

868 * 3: server is newstyle and set up for structured replies

869 */

870 static int nbd_start_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,

871 const char *hostname, QIOChannel **outioc,

872 bool structured_reply, bool *zeroes,

873 Error **errp)

874 {

875 uint64_t magic;

876

877 trace_nbd_start_negotiate(tlscreds, hostname ? hostname : "<null>");

878

879 if (zeroes) {

880 *zeroes = true;

881 }

882 if (outioc) {

883 *outioc = NULL;

884 }

885 if (tlscreds && !outioc) {

886 error_setg(errp, "Output I/O channel required for TLS");

887 return -EINVAL;

888 }

889

890 if (nbd_read64(ioc, &magic, "initial magic", errp) < 0) {

891 return -EINVAL;

892 }

893 trace_nbd_receive_negotiate_magic(magic);

894

895 if (magic != NBD_INIT_MAGIC) {

896 error_setg(errp, "Bad initial magic received: 0x%" PRIx64, magic);

897 return -EINVAL;

898 }

899

900 if (nbd_read64(ioc, &magic, "server magic", errp) < 0) {

901 return -EINVAL;

902 }

903 trace_nbd_receive_negotiate_magic(magic);

904

905 if (magic == NBD_OPTS_MAGIC) {

906 uint32_t clientflags = 0;

907 uint16_t globalflags;

908 bool fixedNewStyle = false;

909

910 if (nbd_read16(ioc, &globalflags, "server flags", errp) < 0) {

911 return -EINVAL;

912 }

913 trace_nbd_receive_negotiate_server_flags(globalflags);

914 if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {

915 fixedNewStyle = true;

916 clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;

917 }

918 if (globalflags & NBD_FLAG_NO_ZEROES) {

919 if (zeroes) {

920 *zeroes = false;

921 }

922 clientflags |= NBD_FLAG_C_NO_ZEROES;

923 }

924 /* client requested flags */

925 clientflags = cpu_to_be32(clientflags);

926 if (nbd_write(ioc, &clientflags, sizeof(clientflags), errp) < 0) {

927 error_prepend(errp, "Failed to send clientflags field: ");

928 return -EINVAL;

929 }

930 if (tlscreds) {

931 if (fixedNewStyle) {

932 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);

933 if (!*outioc) {

934 return -EINVAL;

935 }

936 ioc = *outioc;

937 } else {

938 error_setg(errp, "Server does not support STARTTLS");

939 return -EINVAL;

940 }

941 }

942 if (fixedNewStyle) {

943 int result = 0;

944

945 if (structured_reply) {

946 result = nbd_request_simple_option(ioc,

947 NBD_OPT_STRUCTURED_REPLY,

948 errp);

949 if (result < 0) {

950 return -EINVAL;

951 }

952 }

953 return 2 + result;

954 } else {

955 return 1;

956 }

957 } else if (magic == NBD_CLIENT_MAGIC) {

958 if (tlscreds) {

959 error_setg(errp, "Server does not support STARTTLS");

960 return -EINVAL;

961 }

962 return 0;

963 } else {

964 error_setg(errp, "Bad server magic received: 0x%" PRIx64, magic);

965 return -EINVAL;

966 }

967 }

968

969 /*

970 * nbd_negotiate_finish_oldstyle:

971 * Populate @info with the size and export flags from an oldstyle server,

972 * but does not consume 124 bytes of reserved zero padding.

973 * Returns 0 on success, -1 with @errp set on failure

974 */

975 static int nbd_negotiate_finish_oldstyle(QIOChannel *ioc, NBDExportInfo *info,

976 Error **errp)

977 {

978 uint32_t oldflags;

979

980 if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {

981 return -EINVAL;

982 }

983

984 if (nbd_read32(ioc, &oldflags, "export flags", errp) < 0) {

985 return -EINVAL;

986 }

987 if (oldflags & ~0xffff) {

988 error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);

989 return -EINVAL;

990 }

991 info->flags = oldflags;

992 return 0;

993 }

994

995 /*

996 * nbd_receive_negotiate:

997 * Connect to server, complete negotiation, and move into transmission phase.

998 * Returns: negative errno: failure talking to server

999 * 0: server is connected

1000 */

1001 int nbd_receive_negotiate(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,

1002 const char *hostname, QIOChannel **outioc,

1003 NBDExportInfo *info, Error **errp)

1004 {

1005 int result;

1006 bool zeroes;

1007 bool base_allocation = info->base_allocation;

1008

1009 assert(info->name);

1010 trace_nbd_receive_negotiate_name(info->name);

1011

1012 result = nbd_start_negotiate(ioc, tlscreds, hostname, outioc,

1013 info->structured_reply, &zeroes, errp);

1014

1015 info->structured_reply = false;

1016 info->base_allocation = false;

1017 if (tlscreds && *outioc) {

1018 ioc = *outioc;

1019 }

1020

1021 switch (result) {

1022 case 3: /* newstyle, with structured replies */

1023 info->structured_reply = true;

1024 if (base_allocation) {

1025 result = nbd_negotiate_simple_meta_context(ioc, info, errp);

1026 if (result < 0) {

1027 return -EINVAL;

1028 }

1029 info->base_allocation = result == 1;

1030 }

1031 /* fall through */

1032 case 2: /* newstyle, try OPT_GO */

1033 /* Try NBD_OPT_GO first - if it works, we are done (it

1034 * also gives us a good message if the server requires

1035 * TLS). If it is not available, fall back to

1036 * NBD_OPT_LIST for nicer error messages about a missing

1037 * export, then use NBD_OPT_EXPORT_NAME. */

1038 result = nbd_opt_info_or_go(ioc, NBD_OPT_GO, info, errp);

1039 if (result < 0) {

1040 return -EINVAL;

1041 }

1042 if (result > 0) {

1043 return 0;

1044 }

1045 /* Check our desired export is present in the

1046 * server export list. Since NBD_OPT_EXPORT_NAME

1047 * cannot return an error message, running this

1048 * query gives us better error reporting if the

1049 * export name is not available.

1050 */

1051 if (nbd_receive_query_exports(ioc, info->name, errp) < 0) {

1052 return -EINVAL;

1053 }

1054 /* fall through */

1055 case 1: /* newstyle, but limited to EXPORT_NAME */

1056 /* write the export name request */

1057 if (nbd_send_option_request(ioc, NBD_OPT_EXPORT_NAME, -1, info->name,

1058 errp) < 0) {

1059 return -EINVAL;

1060 }

1061

1062 /* Read the response */

1063 if (nbd_read64(ioc, &info->size, "export length", errp) < 0) {

1064 return -EINVAL;

1065 }

1066

1067 if (nbd_read16(ioc, &info->flags, "export flags", errp) < 0) {

1068 return -EINVAL;

1069 }

1070 break;

1071 case 0: /* oldstyle, parse length and flags */

1072 if (*info->name) {

1073 error_setg(errp, "Server does not support non-empty export names");

1074 return -EINVAL;

1075 }

1076 if (nbd_negotiate_finish_oldstyle(ioc, info, errp) < 0) {

1077 return -EINVAL;

1078 }

1079 break;

1080 default:

1081 return result;

1082 }

1083

1084 trace_nbd_receive_negotiate_size_flags(info->size, info->flags);

1085 if (zeroes && nbd_drop(ioc, 124, errp) < 0) {

1086 error_prepend(errp, "Failed to read reserved block: ");

1087 return -EINVAL;

1088 }

1089 return 0;

1090 }

1091

1092 /* Clean up result of nbd_receive_export_list */

1093 void nbd_free_export_list(NBDExportInfo *info, int count)

1094 {

1095 int i, j;

1096

1097 if (!info) {

1098 return;

1099 }

1100

1101 for (i = 0; i < count; i++) {

1102 g_free(info[i].name);

1103 g_free(info[i].description);

1104 for (j = 0; j < info[i].n_contexts; j++) {

1105 g_free(info[i].contexts[j]);

1106 }

1107 g_free(info[i].contexts);

1108 }

1109 g_free(info);

1110 }

1111

1112 /*

1113 * nbd_receive_export_list:

1114 * Query details about a server's exports, then disconnect without

1115 * going into transmission phase. Return a count of the exports listed

1116 * in @info by the server, or -1 on error. Caller must free @info using

1117 * nbd_free_export_list().

1118 */

1119 int nbd_receive_export_list(QIOChannel *ioc, QCryptoTLSCreds *tlscreds,

1120 const char *hostname, NBDExportInfo **info,

1121 Error **errp)

1122 {

1123 int result;

1124 int count = 0;

1125 int i;

1126 int rc;

1127 int ret = -1;

1128 NBDExportInfo *array = NULL;

1129 QIOChannel *sioc = NULL;

1130

1131 *info = NULL;

1132 result = nbd_start_negotiate(ioc, tlscreds, hostname, &sioc, true, NULL,

1133 errp);

1134 if (tlscreds && sioc) {

1135 ioc = sioc;

1136 }

1137

1138 switch (result) {

1139 case 2:

1140 case 3:

1141 /* newstyle - use NBD_OPT_LIST to populate array, then try

1142 * NBD_OPT_INFO on each array member. If structured replies

1143 * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */

1144 if (nbd_send_option_request(ioc, NBD_OPT_LIST, 0, NULL, errp) < 0) {

1145 goto out;

1146 }

1147 while (1) {

1148 char *name;

1149 char *desc;

1150

1151 rc = nbd_receive_list(ioc, &name, &desc, errp);

1152 if (rc < 0) {

1153 goto out;

1154 } else if (rc == 0) {

1155 break;

1156 }

1157 array = g_renew(NBDExportInfo, array, ++count);

1158 memset(&array[count - 1], 0, sizeof(*array));

1159 array[count - 1].name = name;

1160 array[count - 1].description = desc;

1161 array[count - 1].structured_reply = result == 3;

1162 }

1163

1164 for (i = 0; i < count; i++) {

1165 array[i].request_sizes = true;

1166 rc = nbd_opt_info_or_go(ioc, NBD_OPT_INFO, &array[i], errp);

1167 if (rc < 0) {

1168 goto out;

1169 } else if (rc == 0) {

1170 /*

1171 * Pointless to try rest of loop. If OPT_INFO doesn't work,

1172 * it's unlikely that meta contexts work either

1173 */

1174 break;

1175 }

1176

1177 if (result == 3 &&

1178 nbd_list_meta_contexts(ioc, &array[i], errp) < 0) {

1179 goto out;

1180 }

1181 }

1182

1183 /* Send NBD_OPT_ABORT as a courtesy before hanging up */

1184 nbd_send_opt_abort(ioc);

1185 break;

1186 case 1: /* newstyle, but limited to EXPORT_NAME */

1187 error_setg(errp, "Server does not support export lists");

1188 /* We can't even send NBD_OPT_ABORT, so merely hang up */

1189 goto out;

1190 case 0: /* oldstyle, parse length and flags */

1191 array = g_new0(NBDExportInfo, 1);

1192 array->name = g_strdup("");

1193 count = 1;

1194

1195 if (nbd_negotiate_finish_oldstyle(ioc, array, errp) < 0) {

1196 goto out;

1197 }

1198

1199 /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all

1200 * errors now that we have the information we wanted. */

1201 if (nbd_drop(ioc, 124, NULL) == 0) {

1202 NBDRequest request = { .type = NBD_CMD_DISC };

1203

1204 nbd_send_request(ioc, &request);

1205 }

1206 break;

1207 default:

1208 goto out;

1209 }

1210

1211 *info = array;

1212 array = NULL;

1213 ret = count;

1214

1215 out:

1216 qio_channel_shutdown(ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);

1217 qio_channel_close(ioc, NULL);

1218 object_unref(OBJECT(sioc));

1219 nbd_free_export_list(array, count);

1220 return ret;

1221 }

1222

1223 #ifdef __linux__

1224 int nbd_init(int fd, QIOChannelSocket *sioc, NBDExportInfo *info,

1225 Error **errp)

1226 {

1227 unsigned long sector_size = MAX(BDRV_SECTOR_SIZE, info->min_block);

1228 unsigned long sectors = info->size / sector_size;

1229

1230 /* FIXME: Once the kernel module is patched to honor block sizes,

1231 * and to advertise that fact to user space, we should update the

1232 * hand-off to the kernel to use any block sizes we learned. */

1233 assert(!info->request_sizes);

1234 if (info->size / sector_size != sectors) {

1235 error_setg(errp, "Export size %" PRIu64 " too large for 32-bit kernel",

1236 info->size);

1237 return -E2BIG;

1238 }

1239

1240 trace_nbd_init_set_socket();

1241

1242 if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {

1243 int serrno = errno;

1244 error_setg(errp, "Failed to set NBD socket");

1245 return -serrno;

1246 }

1247

1248 trace_nbd_init_set_block_size(sector_size);

1249

1250 if (ioctl(fd, NBD_SET_BLKSIZE, sector_size) < 0) {

1251 int serrno = errno;

1252 error_setg(errp, "Failed setting NBD block size");

1253 return -serrno;

1254 }

1255

1256 trace_nbd_init_set_size(sectors);

1257 if (info->size % sector_size) {

1258 trace_nbd_init_trailing_bytes(info->size % sector_size);

1259 }

1260

1261 if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {

1262 int serrno = errno;

1263 error_setg(errp, "Failed setting size (in blocks)");

1264 return -serrno;

1265 }

1266

1267 if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) info->flags) < 0) {

1268 if (errno == ENOTTY) {

1269 int read_only = (info->flags & NBD_FLAG_READ_ONLY) != 0;

1270 trace_nbd_init_set_readonly();

1271

1272 if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {

1273 int serrno = errno;

1274 error_setg(errp, "Failed setting read-only attribute");

1275 return -serrno;

1276 }

1277 } else {

1278 int serrno = errno;

1279 error_setg(errp, "Failed setting flags");

1280 return -serrno;

1281 }

1282 }

1283

1284 trace_nbd_init_finish();

1285

1286 return 0;

1287 }

1288

1289 int nbd_client(int fd)

1290 {

1291 int ret;

1292 int serrno;

1293

1294 trace_nbd_client_loop();

1295

1296 ret = ioctl(fd, NBD_DO_IT);

1297 if (ret < 0 && errno == EPIPE) {

1298 /* NBD_DO_IT normally returns EPIPE when someone has disconnected

1299 * the socket via NBD_DISCONNECT. We do not want to return 1 in

1300 * that case.

1301 */

1302 ret = 0;

1303 }

1304 serrno = errno;

1305

1306 trace_nbd_client_loop_ret(ret, strerror(serrno));

1307

1308 trace_nbd_client_clear_queue();

1309 ioctl(fd, NBD_CLEAR_QUE);

1310

1311 trace_nbd_client_clear_socket();

1312 ioctl(fd, NBD_CLEAR_SOCK);

1313

1314 errno = serrno;

1315 return ret;

1316 }

1317

1318 int nbd_disconnect(int fd)

1319 {

1320 ioctl(fd, NBD_CLEAR_QUE);

1321 ioctl(fd, NBD_DISCONNECT);

1322 ioctl(fd, NBD_CLEAR_SOCK);

1323 return 0;

1324 }

1325

1326 #endif /* __linux__ */

1327

1328 int nbd_send_request(QIOChannel *ioc, NBDRequest *request)

1329 {

1330 uint8_t buf[NBD_REQUEST_SIZE];

1331

1332 trace_nbd_send_request(request->from, request->len, request->handle,

1333 request->flags, request->type,

1334 nbd_cmd_lookup(request->type));

1335

1336 stl_be_p(buf, NBD_REQUEST_MAGIC);

1337 stw_be_p(buf + 4, request->flags);

1338 stw_be_p(buf + 6, request->type);

1339 stq_be_p(buf + 8, request->handle);

1340 stq_be_p(buf + 16, request->from);

1341 stl_be_p(buf + 24, request->len);

1342

1343 return nbd_write(ioc, buf, sizeof(buf), NULL);

1344 }

1345

1346 /* nbd_receive_simple_reply

1347 * Read simple reply except magic field (which should be already read).

1348 * Payload is not read (payload is possible for CMD_READ, but here we even

1349 * don't know whether it take place or not).

1350 */

1351 static int nbd_receive_simple_reply(QIOChannel *ioc, NBDSimpleReply *reply,

1352 Error **errp)

1353 {

1354 int ret;

1355

1356 assert(reply->magic == NBD_SIMPLE_REPLY_MAGIC);

1357

1358 ret = nbd_read(ioc, (uint8_t *)reply + sizeof(reply->magic),

1359 sizeof(*reply) - sizeof(reply->magic), "reply", errp);

1360 if (ret < 0) {

1361 return ret;

1362 }

1363

1364 reply->error = be32_to_cpu(reply->error);

1365 reply->handle = be64_to_cpu(reply->handle);

1366

1367 return 0;

1368 }

1369

1370 /* nbd_receive_structured_reply_chunk

1371 * Read structured reply chunk except magic field (which should be already

1372 * read).

1373 * Payload is not read.

1374 */

1375 static int nbd_receive_structured_reply_chunk(QIOChannel *ioc,

1376 NBDStructuredReplyChunk *chunk,

1377 Error **errp)

1378 {

1379 int ret;

1380

1381 assert(chunk->magic == NBD_STRUCTURED_REPLY_MAGIC);

1382

1383 ret = nbd_read(ioc, (uint8_t *)chunk + sizeof(chunk->magic),

1384 sizeof(*chunk) - sizeof(chunk->magic), "structured chunk",

1385 errp);

1386 if (ret < 0) {

1387 return ret;

1388 }

1389

1390 chunk->flags = be16_to_cpu(chunk->flags);

1391 chunk->type = be16_to_cpu(chunk->type);

1392 chunk->handle = be64_to_cpu(chunk->handle);

1393 chunk->length = be32_to_cpu(chunk->length);

1394

1395 return 0;

1396 }

1397

1398 /* nbd_read_eof

1399 * Tries to read @size bytes from @ioc.

1400 * Returns 1 on success

1401 * 0 on eof, when no data was read (errp is not set)

1402 * negative errno on failure (errp is set)

1403 */

1404 static inline int coroutine_fn

1405 nbd_read_eof(BlockDriverState *bs, QIOChannel *ioc, void *buffer, size_t size,

1406 Error **errp)

1407 {

1408 bool partial = false;

1409

1410 assert(size);

1411 while (size > 0) {

1412 struct iovec iov = { .iov_base = buffer, .iov_len = size };

1413 ssize_t len;

1414

1415 len = qio_channel_readv(ioc, &iov, 1, errp);

1416 if (len == QIO_CHANNEL_ERR_BLOCK) {

1417 bdrv_dec_in_flight(bs);

1418 qio_channel_yield(ioc, G_IO_IN);

1419 bdrv_inc_in_flight(bs);

1420 continue;

1421 } else if (len < 0) {

1422 return -EIO;

1423 } else if (len == 0) {

1424 if (partial) {

1425 error_setg(errp,

1426 "Unexpected end-of-file before all bytes were read");

1427 return -EIO;

1428 } else {

1429 return 0;

1430 }

1431 }

1432

1433 partial = true;

1434 size -= len;

1435 buffer = (uint8_t*) buffer + len;

1436 }

1437 return 1;

1438 }

1439

1440 /* nbd_receive_reply

1441 *

1442 * Decreases bs->in_flight while waiting for a new reply. This yield is where

1443 * we wait indefinitely and the coroutine must be able to be safely reentered

1444 * for nbd_client_attach_aio_context().

1445 *

1446 * Returns 1 on success

1447 * 0 on eof, when no data was read (errp is not set)

1448 * negative errno on failure (errp is set)

1449 */

1450 int coroutine_fn nbd_receive_reply(BlockDriverState *bs, QIOChannel *ioc,

1451 NBDReply *reply, Error **errp)

1452 {

1453 int ret;

1454 const char *type;

1455

1456 ret = nbd_read_eof(bs, ioc, &reply->magic, sizeof(reply->magic), errp);

1457 if (ret <= 0) {

1458 return ret;

1459 }

1460

1461 reply->magic = be32_to_cpu(reply->magic);

1462

1463 switch (reply->magic) {

1464 case NBD_SIMPLE_REPLY_MAGIC:

1465 ret = nbd_receive_simple_reply(ioc, &reply->simple, errp);

1466 if (ret < 0) {

1467 break;

1468 }

1469 trace_nbd_receive_simple_reply(reply->simple.error,

1470 nbd_err_lookup(reply->simple.error),

1471 reply->handle);

1472 break;

1473 case NBD_STRUCTURED_REPLY_MAGIC:

1474 ret = nbd_receive_structured_reply_chunk(ioc, &reply->structured, errp);

1475 if (ret < 0) {

1476 break;

1477 }

1478 type = nbd_reply_type_lookup(reply->structured.type);

1479 trace_nbd_receive_structured_reply_chunk(reply->structured.flags,

1480 reply->structured.type, type,

1481 reply->structured.handle,

1482 reply->structured.length);

1483 break;

1484 default:

1485 error_setg(errp, "invalid magic (got 0x%" PRIx32 ")", reply->magic);

1486 return -EINVAL;

1487 }

1488 if (ret < 0) {

1489 return ret;

1490 }

1491

1492 return 1;

1493 }

1494