?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add virtio-sound-pci device
[qemu/armbru.git] / nbd / server.c
blob859c163d19f05c43adf7ed6b09a4f93f9eae21f8
1 /*
2 * Copyright Red Hat
3 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
4 *
5 * Network Block Device Server 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
22 #include "block/block_int.h"
23 #include "block/export.h"
24 #include "block/dirty-bitmap.h"
25 #include "qapi/error.h"
26 #include "qemu/queue.h"
27 #include "trace.h"
28 #include "nbd-internal.h"
29 #include "qemu/units.h"
30 #include "qemu/memalign.h"
31
32 #define NBD_META_ID_BASE_ALLOCATION 0
33 #define NBD_META_ID_ALLOCATION_DEPTH 1
34 /* Dirty bitmaps use 'NBD_META_ID_DIRTY_BITMAP + i', so keep this id last. */
35 #define NBD_META_ID_DIRTY_BITMAP 2
36
37 /*
38 * NBD_MAX_BLOCK_STATUS_EXTENTS: 1 MiB of extents data. An empirical
39 * constant. If an increase is needed, note that the NBD protocol
40 * recommends no larger than 32 mb, so that the client won't consider
41 * the reply as a denial of service attack.
42 */
43 #define NBD_MAX_BLOCK_STATUS_EXTENTS (1 * MiB / 8)
44
45 static int system_errno_to_nbd_errno(int err)
46 {
47 switch (err) {
48 case 0:
49 return NBD_SUCCESS;
50 case EPERM:
51 case EROFS:
52 return NBD_EPERM;
53 case EIO:
54 return NBD_EIO;
55 case ENOMEM:
56 return NBD_ENOMEM;
57 #ifdef EDQUOT
58 case EDQUOT:
59 #endif
60 case EFBIG:
61 case ENOSPC:
62 return NBD_ENOSPC;
63 case EOVERFLOW:
64 return NBD_EOVERFLOW;
65 case ENOTSUP:
66 #if ENOTSUP != EOPNOTSUPP
67 case EOPNOTSUPP:
68 #endif
69 return NBD_ENOTSUP;
70 case ESHUTDOWN:
71 return NBD_ESHUTDOWN;
72 case EINVAL:
73 default:
74 return NBD_EINVAL;
75 }
76 }
77
78 /* Definitions for opaque data types */
79
80 typedef struct NBDRequestData NBDRequestData;
81
82 struct NBDRequestData {
83 NBDClient *client;
84 uint8_t *data;
85 bool complete;
86 };
87
88 struct NBDExport {
89 BlockExport common;
90
91 char *name;
92 char *description;
93 uint64_t size;
94 uint16_t nbdflags;
95 QTAILQ_HEAD(, NBDClient) clients;
96 QTAILQ_ENTRY(NBDExport) next;
97
98 BlockBackend *eject_notifier_blk;
99 Notifier eject_notifier;
100
101 bool allocation_depth;
102 BdrvDirtyBitmap **export_bitmaps;
103 size_t nr_export_bitmaps;
104 };
105
106 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
107
108 /*
109 * NBDMetaContexts represents a list of meta contexts in use,
110 * as selected by NBD_OPT_SET_META_CONTEXT. Also used for
111 * NBD_OPT_LIST_META_CONTEXT.
112 */
113 struct NBDMetaContexts {
114 const NBDExport *exp; /* associated export */
115 size_t count; /* number of negotiated contexts */
116 bool base_allocation; /* export base:allocation context (block status) */
117 bool allocation_depth; /* export qemu:allocation-depth */
118 bool *bitmaps; /*
119 * export qemu:dirty-bitmap:<export bitmap name>,
120 * sized by exp->nr_export_bitmaps
121 */
122 };
123
124 struct NBDClient {
125 int refcount;
126 void (*close_fn)(NBDClient *client, bool negotiated);
127
128 NBDExport *exp;
129 QCryptoTLSCreds *tlscreds;
130 char *tlsauthz;
131 QIOChannelSocket *sioc; /* The underlying data channel */
132 QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */
133
134 Coroutine *recv_coroutine;
135
136 CoMutex send_lock;
137 Coroutine *send_coroutine;
138
139 bool read_yielding;
140 bool quiescing;
141
142 QTAILQ_ENTRY(NBDClient) next;
143 int nb_requests;
144 bool closing;
145
146 uint32_t check_align; /* If non-zero, check for aligned client requests */
147
148 NBDMode mode;
149 NBDMetaContexts contexts; /* Negotiated meta contexts */
150
151 uint32_t opt; /* Current option being negotiated */
152 uint32_t optlen; /* remaining length of data in ioc for the option being
153 negotiated now */
154 };
155
156 static void nbd_client_receive_next_request(NBDClient *client);
157
158 /* Basic flow for negotiation
159
160 Server Client
161 Negotiate
162
163 or
164
165 Server Client
166 Negotiate #1
167 Option
168 Negotiate #2
169
170 ----
171
172 followed by
173
174 Server Client
175 Request
176 Response
177 Request
178 Response
179 ...
180 ...
181 Request (type == 2)
182
183 */
184
185 static inline void set_be_option_rep(NBDOptionReply *rep, uint32_t option,
186 uint32_t type, uint32_t length)
187 {
188 stq_be_p(&rep->magic, NBD_REP_MAGIC);
189 stl_be_p(&rep->option, option);
190 stl_be_p(&rep->type, type);
191 stl_be_p(&rep->length, length);
192 }
193
194 /* Send a reply header, including length, but no payload.
195 * Return -errno on error, 0 on success. */
196 static int nbd_negotiate_send_rep_len(NBDClient *client, uint32_t type,
197 uint32_t len, Error **errp)
198 {
199 NBDOptionReply rep;
200
201 trace_nbd_negotiate_send_rep_len(client->opt, nbd_opt_lookup(client->opt),
202 type, nbd_rep_lookup(type), len);
203
204 assert(len < NBD_MAX_BUFFER_SIZE);
205
206 set_be_option_rep(&rep, client->opt, type, len);
207 return nbd_write(client->ioc, &rep, sizeof(rep), errp);
208 }
209
210 /* Send a reply header with default 0 length.
211 * Return -errno on error, 0 on success. */
212 static int nbd_negotiate_send_rep(NBDClient *client, uint32_t type,
213 Error **errp)
214 {
215 return nbd_negotiate_send_rep_len(client, type, 0, errp);
216 }
217
218 /* Send an error reply.
219 * Return -errno on error, 0 on success. */
220 static int G_GNUC_PRINTF(4, 0)
221 nbd_negotiate_send_rep_verr(NBDClient *client, uint32_t type,
222 Error **errp, const char *fmt, va_list va)
223 {
224 ERRP_GUARD();
225 g_autofree char *msg = NULL;
226 int ret;
227 size_t len;
228
229 msg = g_strdup_vprintf(fmt, va);
230 len = strlen(msg);
231 assert(len < NBD_MAX_STRING_SIZE);
232 trace_nbd_negotiate_send_rep_err(msg);
233 ret = nbd_negotiate_send_rep_len(client, type, len, errp);
234 if (ret < 0) {
235 return ret;
236 }
237 if (nbd_write(client->ioc, msg, len, errp) < 0) {
238 error_prepend(errp, "write failed (error message): ");
239 return -EIO;
240 }
241
242 return 0;
243 }
244
245 /*
246 * Return a malloc'd copy of @name suitable for use in an error reply.
247 */
248 static char *
249 nbd_sanitize_name(const char *name)
250 {
251 if (strnlen(name, 80) < 80) {
252 return g_strdup(name);
253 }
254 /* XXX Should we also try to sanitize any control characters? */
255 return g_strdup_printf("%.80s...", name);
256 }
257
258 /* Send an error reply.
259 * Return -errno on error, 0 on success. */
260 static int G_GNUC_PRINTF(4, 5)
261 nbd_negotiate_send_rep_err(NBDClient *client, uint32_t type,
262 Error **errp, const char *fmt, ...)
263 {
264 va_list va;
265 int ret;
266
267 va_start(va, fmt);
268 ret = nbd_negotiate_send_rep_verr(client, type, errp, fmt, va);
269 va_end(va);
270 return ret;
271 }
272
273 /* Drop remainder of the current option, and send a reply with the
274 * given error type and message. Return -errno on read or write
275 * failure; or 0 if connection is still live. */
276 static int G_GNUC_PRINTF(4, 0)
277 nbd_opt_vdrop(NBDClient *client, uint32_t type, Error **errp,
278 const char *fmt, va_list va)
279 {
280 int ret = nbd_drop(client->ioc, client->optlen, errp);
281
282 client->optlen = 0;
283 if (!ret) {
284 ret = nbd_negotiate_send_rep_verr(client, type, errp, fmt, va);
285 }
286 return ret;
287 }
288
289 static int G_GNUC_PRINTF(4, 5)
290 nbd_opt_drop(NBDClient *client, uint32_t type, Error **errp,
291 const char *fmt, ...)
292 {
293 int ret;
294 va_list va;
295
296 va_start(va, fmt);
297 ret = nbd_opt_vdrop(client, type, errp, fmt, va);
298 va_end(va);
299
300 return ret;
301 }
302
303 static int G_GNUC_PRINTF(3, 4)
304 nbd_opt_invalid(NBDClient *client, Error **errp, const char *fmt, ...)
305 {
306 int ret;
307 va_list va;
308
309 va_start(va, fmt);
310 ret = nbd_opt_vdrop(client, NBD_REP_ERR_INVALID, errp, fmt, va);
311 va_end(va);
312
313 return ret;
314 }
315
316 /* Read size bytes from the unparsed payload of the current option.
317 * If @check_nul, require that no NUL bytes appear in buffer.
318 * Return -errno on I/O error, 0 if option was completely handled by
319 * sending a reply about inconsistent lengths, or 1 on success. */
320 static int nbd_opt_read(NBDClient *client, void *buffer, size_t size,
321 bool check_nul, Error **errp)
322 {
323 if (size > client->optlen) {
324 return nbd_opt_invalid(client, errp,
325 "Inconsistent lengths in option %s",
326 nbd_opt_lookup(client->opt));
327 }
328 client->optlen -= size;
329 if (qio_channel_read_all(client->ioc, buffer, size, errp) < 0) {
330 return -EIO;
331 }
332
333 if (check_nul && strnlen(buffer, size) != size) {
334 return nbd_opt_invalid(client, errp,
335 "Unexpected embedded NUL in option %s",
336 nbd_opt_lookup(client->opt));
337 }
338 return 1;
339 }
340
341 /* Drop size bytes from the unparsed payload of the current option.
342 * Return -errno on I/O error, 0 if option was completely handled by
343 * sending a reply about inconsistent lengths, or 1 on success. */
344 static int nbd_opt_skip(NBDClient *client, size_t size, Error **errp)
345 {
346 if (size > client->optlen) {
347 return nbd_opt_invalid(client, errp,
348 "Inconsistent lengths in option %s",
349 nbd_opt_lookup(client->opt));
350 }
351 client->optlen -= size;
352 return nbd_drop(client->ioc, size, errp) < 0 ? -EIO : 1;
353 }
354
355 /* nbd_opt_read_name
356 *
357 * Read a string with the format:
358 * uint32_t len (<= NBD_MAX_STRING_SIZE)
359 * len bytes string (not 0-terminated)
360 *
361 * On success, @name will be allocated.
362 * If @length is non-null, it will be set to the actual string length.
363 *
364 * Return -errno on I/O error, 0 if option was completely handled by
365 * sending a reply about inconsistent lengths, or 1 on success.
366 */
367 static int nbd_opt_read_name(NBDClient *client, char **name, uint32_t *length,
368 Error **errp)
369 {
370 int ret;
371 uint32_t len;
372 g_autofree char *local_name = NULL;
373
374 *name = NULL;
375 ret = nbd_opt_read(client, &len, sizeof(len), false, errp);
376 if (ret <= 0) {
377 return ret;
378 }
379 len = cpu_to_be32(len);
380
381 if (len > NBD_MAX_STRING_SIZE) {
382 return nbd_opt_invalid(client, errp,
383 "Invalid name length: %" PRIu32, len);
384 }
385
386 local_name = g_malloc(len + 1);
387 ret = nbd_opt_read(client, local_name, len, true, errp);
388 if (ret <= 0) {
389 return ret;
390 }
391 local_name[len] = '\0';
392
393 if (length) {
394 *length = len;
395 }
396 *name = g_steal_pointer(&local_name);
397
398 return 1;
399 }
400
401 /* Send a single NBD_REP_SERVER reply to NBD_OPT_LIST, including payload.
402 * Return -errno on error, 0 on success. */
403 static int nbd_negotiate_send_rep_list(NBDClient *client, NBDExport *exp,
404 Error **errp)
405 {
406 ERRP_GUARD();
407 size_t name_len, desc_len;
408 uint32_t len;
409 const char *name = exp->name ? exp->name : "";
410 const char *desc = exp->description ? exp->description : "";
411 QIOChannel *ioc = client->ioc;
412 int ret;
413
414 trace_nbd_negotiate_send_rep_list(name, desc);
415 name_len = strlen(name);
416 desc_len = strlen(desc);
417 assert(name_len <= NBD_MAX_STRING_SIZE && desc_len <= NBD_MAX_STRING_SIZE);
418 len = name_len + desc_len + sizeof(len);
419 ret = nbd_negotiate_send_rep_len(client, NBD_REP_SERVER, len, errp);
420 if (ret < 0) {
421 return ret;
422 }
423
424 len = cpu_to_be32(name_len);
425 if (nbd_write(ioc, &len, sizeof(len), errp) < 0) {
426 error_prepend(errp, "write failed (name length): ");
427 return -EINVAL;
428 }
429
430 if (nbd_write(ioc, name, name_len, errp) < 0) {
431 error_prepend(errp, "write failed (name buffer): ");
432 return -EINVAL;
433 }
434
435 if (nbd_write(ioc, desc, desc_len, errp) < 0) {
436 error_prepend(errp, "write failed (description buffer): ");
437 return -EINVAL;
438 }
439
440 return 0;
441 }
442
443 /* Process the NBD_OPT_LIST command, with a potential series of replies.
444 * Return -errno on error, 0 on success. */
445 static int nbd_negotiate_handle_list(NBDClient *client, Error **errp)
446 {
447 NBDExport *exp;
448 assert(client->opt == NBD_OPT_LIST);
449
450 /* For each export, send a NBD_REP_SERVER reply. */
451 QTAILQ_FOREACH(exp, &exports, next) {
452 if (nbd_negotiate_send_rep_list(client, exp, errp)) {
453 return -EINVAL;
454 }
455 }
456 /* Finish with a NBD_REP_ACK. */
457 return nbd_negotiate_send_rep(client, NBD_REP_ACK, errp);
458 }
459
460 static void nbd_check_meta_export(NBDClient *client, NBDExport *exp)
461 {
462 if (exp != client->contexts.exp) {
463 client->contexts.count = 0;
464 }
465 }
466
467 /* Send a reply to NBD_OPT_EXPORT_NAME.
468 * Return -errno on error, 0 on success. */
469 static int nbd_negotiate_handle_export_name(NBDClient *client, bool no_zeroes,
470 Error **errp)
471 {
472 ERRP_GUARD();
473 g_autofree char *name = NULL;
474 char buf[NBD_REPLY_EXPORT_NAME_SIZE] = "";
475 size_t len;
476 int ret;
477 uint16_t myflags;
478
479 /* Client sends:
480 [20 .. xx] export name (length bytes)
481 Server replies:
482 [ 0 .. 7] size
483 [ 8 .. 9] export flags
484 [10 .. 133] reserved (0) [unless no_zeroes]
485 */
486 trace_nbd_negotiate_handle_export_name();
487 if (client->mode >= NBD_MODE_EXTENDED) {
488 error_setg(errp, "Extended headers already negotiated");
489 return -EINVAL;
490 }
491 if (client->optlen > NBD_MAX_STRING_SIZE) {
492 error_setg(errp, "Bad length received");
493 return -EINVAL;
494 }
495 name = g_malloc(client->optlen + 1);
496 if (nbd_read(client->ioc, name, client->optlen, "export name", errp) < 0) {
497 return -EIO;
498 }
499 name[client->optlen] = '\0';
500 client->optlen = 0;
501
502 trace_nbd_negotiate_handle_export_name_request(name);
503
504 client->exp = nbd_export_find(name);
505 if (!client->exp) {
506 error_setg(errp, "export not found");
507 return -EINVAL;
508 }
509 nbd_check_meta_export(client, client->exp);
510
511 myflags = client->exp->nbdflags;
512 if (client->mode >= NBD_MODE_STRUCTURED) {
513 myflags |= NBD_FLAG_SEND_DF;
514 }
515 if (client->mode >= NBD_MODE_EXTENDED && client->contexts.count) {
516 myflags |= NBD_FLAG_BLOCK_STAT_PAYLOAD;
517 }
518 trace_nbd_negotiate_new_style_size_flags(client->exp->size, myflags);
519 stq_be_p(buf, client->exp->size);
520 stw_be_p(buf + 8, myflags);
521 len = no_zeroes ? 10 : sizeof(buf);
522 ret = nbd_write(client->ioc, buf, len, errp);
523 if (ret < 0) {
524 error_prepend(errp, "write failed: ");
525 return ret;
526 }
527
528 QTAILQ_INSERT_TAIL(&client->exp->clients, client, next);
529 blk_exp_ref(&client->exp->common);
530
531 return 0;
532 }
533
534 /* Send a single NBD_REP_INFO, with a buffer @buf of @length bytes.
535 * The buffer does NOT include the info type prefix.
536 * Return -errno on error, 0 if ready to send more. */
537 static int nbd_negotiate_send_info(NBDClient *client,
538 uint16_t info, uint32_t length, void *buf,
539 Error **errp)
540 {
541 int rc;
542
543 trace_nbd_negotiate_send_info(info, nbd_info_lookup(info), length);
544 rc = nbd_negotiate_send_rep_len(client, NBD_REP_INFO,
545 sizeof(info) + length, errp);
546 if (rc < 0) {
547 return rc;
548 }
549 info = cpu_to_be16(info);
550 if (nbd_write(client->ioc, &info, sizeof(info), errp) < 0) {
551 return -EIO;
552 }
553 if (nbd_write(client->ioc, buf, length, errp) < 0) {
554 return -EIO;
555 }
556 return 0;
557 }
558
559 /* nbd_reject_length: Handle any unexpected payload.
560 * @fatal requests that we quit talking to the client, even if we are able
561 * to successfully send an error reply.
562 * Return:
563 * -errno transmission error occurred or @fatal was requested, errp is set
564 * 0 error message successfully sent to client, errp is not set
565 */
566 static int nbd_reject_length(NBDClient *client, bool fatal, Error **errp)
567 {
568 int ret;
569
570 assert(client->optlen);
571 ret = nbd_opt_invalid(client, errp, "option '%s' has unexpected length",
572 nbd_opt_lookup(client->opt));
573 if (fatal && !ret) {
574 error_setg(errp, "option '%s' has unexpected length",
575 nbd_opt_lookup(client->opt));
576 return -EINVAL;
577 }
578 return ret;
579 }
580
581 /* Handle NBD_OPT_INFO and NBD_OPT_GO.
582 * Return -errno on error, 0 if ready for next option, and 1 to move
583 * into transmission phase. */
584 static int nbd_negotiate_handle_info(NBDClient *client, Error **errp)
585 {
586 int rc;
587 g_autofree char *name = NULL;
588 NBDExport *exp;
589 uint16_t requests;
590 uint16_t request;
591 uint32_t namelen = 0;
592 bool sendname = false;
593 bool blocksize = false;
594 uint32_t sizes[3];
595 char buf[sizeof(uint64_t) + sizeof(uint16_t)];
596 uint32_t check_align = 0;
597 uint16_t myflags;
598
599 /* Client sends:
600 4 bytes: L, name length (can be 0)
601 L bytes: export name
602 2 bytes: N, number of requests (can be 0)
603 N * 2 bytes: N requests
604 */
605 rc = nbd_opt_read_name(client, &name, &namelen, errp);
606 if (rc <= 0) {
607 return rc;
608 }
609 trace_nbd_negotiate_handle_export_name_request(name);
610
611 rc = nbd_opt_read(client, &requests, sizeof(requests), false, errp);
612 if (rc <= 0) {
613 return rc;
614 }
615 requests = be16_to_cpu(requests);
616 trace_nbd_negotiate_handle_info_requests(requests);
617 while (requests--) {
618 rc = nbd_opt_read(client, &request, sizeof(request), false, errp);
619 if (rc <= 0) {
620 return rc;
621 }
622 request = be16_to_cpu(request);
623 trace_nbd_negotiate_handle_info_request(request,
624 nbd_info_lookup(request));
625 /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE;
626 * everything else is either a request we don't know or
627 * something we send regardless of request */
628 switch (request) {
629 case NBD_INFO_NAME:
630 sendname = true;
631 break;
632 case NBD_INFO_BLOCK_SIZE:
633 blocksize = true;
634 break;
635 }
636 }
637 if (client->optlen) {
638 return nbd_reject_length(client, false, errp);
639 }
640
641 exp = nbd_export_find(name);
642 if (!exp) {
643 g_autofree char *sane_name = nbd_sanitize_name(name);
644
645 return nbd_negotiate_send_rep_err(client, NBD_REP_ERR_UNKNOWN,
646 errp, "export '%s' not present",
647 sane_name);
648 }
649 if (client->opt == NBD_OPT_GO) {
650 nbd_check_meta_export(client, exp);
651 }
652
653 /* Don't bother sending NBD_INFO_NAME unless client requested it */
654 if (sendname) {
655 rc = nbd_negotiate_send_info(client, NBD_INFO_NAME, namelen, name,
656 errp);
657 if (rc < 0) {
658 return rc;
659 }
660 }
661
662 /* Send NBD_INFO_DESCRIPTION only if available, regardless of
663 * client request */
664 if (exp->description) {
665 size_t len = strlen(exp->description);
666
667 assert(len <= NBD_MAX_STRING_SIZE);
668 rc = nbd_negotiate_send_info(client, NBD_INFO_DESCRIPTION,
669 len, exp->description, errp);
670 if (rc < 0) {
671 return rc;
672 }
673 }
674
675 /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size
676 * according to whether the client requested it, and according to
677 * whether this is OPT_INFO or OPT_GO. */
678 /* minimum - 1 for back-compat, or actual if client will obey it. */
679 if (client->opt == NBD_OPT_INFO || blocksize) {
680 check_align = sizes[0] = blk_get_request_alignment(exp->common.blk);
681 } else {
682 sizes[0] = 1;
683 }
684 assert(sizes[0] <= NBD_MAX_BUFFER_SIZE);
685 /* preferred - Hard-code to 4096 for now.
686 * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */
687 sizes[1] = MAX(4096, sizes[0]);
688 /* maximum - At most 32M, but smaller as appropriate. */
689 sizes[2] = MIN(blk_get_max_transfer(exp->common.blk), NBD_MAX_BUFFER_SIZE);
690 trace_nbd_negotiate_handle_info_block_size(sizes[0], sizes[1], sizes[2]);
691 sizes[0] = cpu_to_be32(sizes[0]);
692 sizes[1] = cpu_to_be32(sizes[1]);
693 sizes[2] = cpu_to_be32(sizes[2]);
694 rc = nbd_negotiate_send_info(client, NBD_INFO_BLOCK_SIZE,
695 sizeof(sizes), sizes, errp);
696 if (rc < 0) {
697 return rc;
698 }
699
700 /* Send NBD_INFO_EXPORT always */
701 myflags = exp->nbdflags;
702 if (client->mode >= NBD_MODE_STRUCTURED) {
703 myflags |= NBD_FLAG_SEND_DF;
704 }
705 if (client->mode >= NBD_MODE_EXTENDED &&
706 (client->contexts.count || client->opt == NBD_OPT_INFO)) {
707 myflags |= NBD_FLAG_BLOCK_STAT_PAYLOAD;
708 }
709 trace_nbd_negotiate_new_style_size_flags(exp->size, myflags);
710 stq_be_p(buf, exp->size);
711 stw_be_p(buf + 8, myflags);
712 rc = nbd_negotiate_send_info(client, NBD_INFO_EXPORT,
713 sizeof(buf), buf, errp);
714 if (rc < 0) {
715 return rc;
716 }
717
718 /*
719 * If the client is just asking for NBD_OPT_INFO, but forgot to
720 * request block sizes in a situation that would impact
721 * performance, then return an error. But for NBD_OPT_GO, we
722 * tolerate all clients, regardless of alignments.
723 */
724 if (client->opt == NBD_OPT_INFO && !blocksize &&
725 blk_get_request_alignment(exp->common.blk) > 1) {
726 return nbd_negotiate_send_rep_err(client,
727 NBD_REP_ERR_BLOCK_SIZE_REQD,
728 errp,
729 "request NBD_INFO_BLOCK_SIZE to "
730 "use this export");
731 }
732
733 /* Final reply */
734 rc = nbd_negotiate_send_rep(client, NBD_REP_ACK, errp);
735 if (rc < 0) {
736 return rc;
737 }
738
739 if (client->opt == NBD_OPT_GO) {
740 client->exp = exp;
741 client->check_align = check_align;
742 QTAILQ_INSERT_TAIL(&client->exp->clients, client, next);
743 blk_exp_ref(&client->exp->common);
744 rc = 1;
745 }
746 return rc;
747 }
748
749
750 /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the
751 * new channel for all further (now-encrypted) communication. */
752 static QIOChannel *nbd_negotiate_handle_starttls(NBDClient *client,
753 Error **errp)
754 {
755 QIOChannel *ioc;
756 QIOChannelTLS *tioc;
757 struct NBDTLSHandshakeData data = { 0 };
758
759 assert(client->opt == NBD_OPT_STARTTLS);
760
761 trace_nbd_negotiate_handle_starttls();
762 ioc = client->ioc;
763
764 if (nbd_negotiate_send_rep(client, NBD_REP_ACK, errp) < 0) {
765 return NULL;
766 }
767
768 tioc = qio_channel_tls_new_server(ioc,
769 client->tlscreds,
770 client->tlsauthz,
771 errp);
772 if (!tioc) {
773 return NULL;
774 }
775
776 qio_channel_set_name(QIO_CHANNEL(tioc), "nbd-server-tls");
777 trace_nbd_negotiate_handle_starttls_handshake();
778 data.loop = g_main_loop_new(g_main_context_default(), FALSE);
779 qio_channel_tls_handshake(tioc,
780 nbd_tls_handshake,
781 &data,
782 NULL,
783 NULL);
784
785 if (!data.complete) {
786 g_main_loop_run(data.loop);
787 }
788 g_main_loop_unref(data.loop);
789 if (data.error) {
790 object_unref(OBJECT(tioc));
791 error_propagate(errp, data.error);
792 return NULL;
793 }
794
795 return QIO_CHANNEL(tioc);
796 }
797
798 /* nbd_negotiate_send_meta_context
799 *
800 * Send one chunk of reply to NBD_OPT_{LIST,SET}_META_CONTEXT
801 *
802 * For NBD_OPT_LIST_META_CONTEXT @context_id is ignored, 0 is used instead.
803 */
804 static int nbd_negotiate_send_meta_context(NBDClient *client,
805 const char *context,
806 uint32_t context_id,
807 Error **errp)
808 {
809 NBDOptionReplyMetaContext opt;
810 struct iovec iov[] = {
811 {.iov_base = &opt, .iov_len = sizeof(opt)},
812 {.iov_base = (void *)context, .iov_len = strlen(context)}
813 };
814
815 assert(iov[1].iov_len <= NBD_MAX_STRING_SIZE);
816 if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
817 context_id = 0;
818 }
819
820 trace_nbd_negotiate_meta_query_reply(context, context_id);
821 set_be_option_rep(&opt.h, client->opt, NBD_REP_META_CONTEXT,
822 sizeof(opt) - sizeof(opt.h) + iov[1].iov_len);
823 stl_be_p(&opt.context_id, context_id);
824
825 return qio_channel_writev_all(client->ioc, iov, 2, errp) < 0 ? -EIO : 0;
826 }
827
828 /*
829 * Return true if @query matches @pattern, or if @query is empty when
830 * the @client is performing _LIST_.
831 */
832 static bool nbd_meta_empty_or_pattern(NBDClient *client, const char *pattern,
833 const char *query)
834 {
835 if (!*query) {
836 trace_nbd_negotiate_meta_query_parse("empty");
837 return client->opt == NBD_OPT_LIST_META_CONTEXT;
838 }
839 if (strcmp(query, pattern) == 0) {
840 trace_nbd_negotiate_meta_query_parse(pattern);
841 return true;
842 }
843 trace_nbd_negotiate_meta_query_skip("pattern not matched");
844 return false;
845 }
846
847 /*
848 * Return true and adjust @str in place if it begins with @prefix.
849 */
850 static bool nbd_strshift(const char **str, const char *prefix)
851 {
852 size_t len = strlen(prefix);
853
854 if (strncmp(*str, prefix, len) == 0) {
855 *str += len;
856 return true;
857 }
858 return false;
859 }
860
861 /* nbd_meta_base_query
862 *
863 * Handle queries to 'base' namespace. For now, only the base:allocation
864 * context is available. Return true if @query has been handled.
865 */
866 static bool nbd_meta_base_query(NBDClient *client, NBDMetaContexts *meta,
867 const char *query)
868 {
869 if (!nbd_strshift(&query, "base:")) {
870 return false;
871 }
872 trace_nbd_negotiate_meta_query_parse("base:");
873
874 if (nbd_meta_empty_or_pattern(client, "allocation", query)) {
875 meta->base_allocation = true;
876 }
877 return true;
878 }
879
880 /* nbd_meta_qemu_query
881 *
882 * Handle queries to 'qemu' namespace. For now, only the qemu:dirty-bitmap:
883 * and qemu:allocation-depth contexts are available. Return true if @query
884 * has been handled.
885 */
886 static bool nbd_meta_qemu_query(NBDClient *client, NBDMetaContexts *meta,
887 const char *query)
888 {
889 size_t i;
890
891 if (!nbd_strshift(&query, "qemu:")) {
892 return false;
893 }
894 trace_nbd_negotiate_meta_query_parse("qemu:");
895
896 if (!*query) {
897 if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
898 meta->allocation_depth = meta->exp->allocation_depth;
899 if (meta->exp->nr_export_bitmaps) {
900 memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
901 }
902 }
903 trace_nbd_negotiate_meta_query_parse("empty");
904 return true;
905 }
906
907 if (strcmp(query, "allocation-depth") == 0) {
908 trace_nbd_negotiate_meta_query_parse("allocation-depth");
909 meta->allocation_depth = meta->exp->allocation_depth;
910 return true;
911 }
912
913 if (nbd_strshift(&query, "dirty-bitmap:")) {
914 trace_nbd_negotiate_meta_query_parse("dirty-bitmap:");
915 if (!*query) {
916 if (client->opt == NBD_OPT_LIST_META_CONTEXT &&
917 meta->exp->nr_export_bitmaps) {
918 memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
919 }
920 trace_nbd_negotiate_meta_query_parse("empty");
921 return true;
922 }
923
924 for (i = 0; i < meta->exp->nr_export_bitmaps; i++) {
925 const char *bm_name;
926
927 bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmaps[i]);
928 if (strcmp(bm_name, query) == 0) {
929 meta->bitmaps[i] = true;
930 trace_nbd_negotiate_meta_query_parse(query);
931 return true;
932 }
933 }
934 trace_nbd_negotiate_meta_query_skip("no dirty-bitmap match");
935 return true;
936 }
937
938 trace_nbd_negotiate_meta_query_skip("unknown qemu context");
939 return true;
940 }
941
942 /* nbd_negotiate_meta_query
943 *
944 * Parse namespace name and call corresponding function to parse body of the
945 * query.
946 *
947 * The only supported namespaces are 'base' and 'qemu'.
948 *
949 * Return -errno on I/O error, 0 if option was completely handled by
950 * sending a reply about inconsistent lengths, or 1 on success. */
951 static int nbd_negotiate_meta_query(NBDClient *client,
952 NBDMetaContexts *meta, Error **errp)
953 {
954 int ret;
955 g_autofree char *query = NULL;
956 uint32_t len;
957
958 ret = nbd_opt_read(client, &len, sizeof(len), false, errp);
959 if (ret <= 0) {
960 return ret;
961 }
962 len = cpu_to_be32(len);
963
964 if (len > NBD_MAX_STRING_SIZE) {
965 trace_nbd_negotiate_meta_query_skip("length too long");
966 return nbd_opt_skip(client, len, errp);
967 }
968
969 query = g_malloc(len + 1);
970 ret = nbd_opt_read(client, query, len, true, errp);
971 if (ret <= 0) {
972 return ret;
973 }
974 query[len] = '\0';
975
976 if (nbd_meta_base_query(client, meta, query)) {
977 return 1;
978 }
979 if (nbd_meta_qemu_query(client, meta, query)) {
980 return 1;
981 }
982
983 trace_nbd_negotiate_meta_query_skip("unknown namespace");
984 return 1;
985 }
986
987 /* nbd_negotiate_meta_queries
988 * Handle NBD_OPT_LIST_META_CONTEXT and NBD_OPT_SET_META_CONTEXT
989 *
990 * Return -errno on I/O error, or 0 if option was completely handled. */
991 static int nbd_negotiate_meta_queries(NBDClient *client, Error **errp)
992 {
993 int ret;
994 g_autofree char *export_name = NULL;
995 /* Mark unused to work around https://bugs.llvm.org/show_bug.cgi?id=3888 */
996 g_autofree G_GNUC_UNUSED bool *bitmaps = NULL;
997 NBDMetaContexts local_meta = {0};
998 NBDMetaContexts *meta;
999 uint32_t nb_queries;
1000 size_t i;
1001 size_t count = 0;
1002
1003 if (client->opt == NBD_OPT_SET_META_CONTEXT &&
1004 client->mode < NBD_MODE_STRUCTURED) {
1005 return nbd_opt_invalid(client, errp,
1006 "request option '%s' when structured reply "
1007 "is not negotiated",
1008 nbd_opt_lookup(client->opt));
1009 }
1010
1011 if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
1012 /* Only change the caller's meta on SET. */
1013 meta = &local_meta;
1014 } else {
1015 meta = &client->contexts;
1016 }
1017
1018 g_free(meta->bitmaps);
1019 memset(meta, 0, sizeof(*meta));
1020
1021 ret = nbd_opt_read_name(client, &export_name, NULL, errp);
1022 if (ret <= 0) {
1023 return ret;
1024 }
1025
1026 meta->exp = nbd_export_find(export_name);
1027 if (meta->exp == NULL) {
1028 g_autofree char *sane_name = nbd_sanitize_name(export_name);
1029
1030 return nbd_opt_drop(client, NBD_REP_ERR_UNKNOWN, errp,
1031 "export '%s' not present", sane_name);
1032 }
1033 meta->bitmaps = g_new0(bool, meta->exp->nr_export_bitmaps);
1034 if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
1035 bitmaps = meta->bitmaps;
1036 }
1037
1038 ret = nbd_opt_read(client, &nb_queries, sizeof(nb_queries), false, errp);
1039 if (ret <= 0) {
1040 return ret;
1041 }
1042 nb_queries = cpu_to_be32(nb_queries);
1043 trace_nbd_negotiate_meta_context(nbd_opt_lookup(client->opt),
1044 export_name, nb_queries);
1045
1046 if (client->opt == NBD_OPT_LIST_META_CONTEXT && !nb_queries) {
1047 /* enable all known contexts */
1048 meta->base_allocation = true;
1049 meta->allocation_depth = meta->exp->allocation_depth;
1050 if (meta->exp->nr_export_bitmaps) {
1051 memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
1052 }
1053 } else {
1054 for (i = 0; i < nb_queries; ++i) {
1055 ret = nbd_negotiate_meta_query(client, meta, errp);
1056 if (ret <= 0) {
1057 return ret;
1058 }
1059 }
1060 }
1061
1062 if (meta->base_allocation) {
1063 ret = nbd_negotiate_send_meta_context(client, "base:allocation",
1064 NBD_META_ID_BASE_ALLOCATION,
1065 errp);
1066 if (ret < 0) {
1067 return ret;
1068 }
1069 count++;
1070 }
1071
1072 if (meta->allocation_depth) {
1073 ret = nbd_negotiate_send_meta_context(client, "qemu:allocation-depth",
1074 NBD_META_ID_ALLOCATION_DEPTH,
1075 errp);
1076 if (ret < 0) {
1077 return ret;
1078 }
1079 count++;
1080 }
1081
1082 for (i = 0; i < meta->exp->nr_export_bitmaps; i++) {
1083 const char *bm_name;
1084 g_autofree char *context = NULL;
1085
1086 if (!meta->bitmaps[i]) {
1087 continue;
1088 }
1089
1090 bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmaps[i]);
1091 context = g_strdup_printf("qemu:dirty-bitmap:%s", bm_name);
1092
1093 ret = nbd_negotiate_send_meta_context(client, context,
1094 NBD_META_ID_DIRTY_BITMAP + i,
1095 errp);
1096 if (ret < 0) {
1097 return ret;
1098 }
1099 count++;
1100 }
1101
1102 ret = nbd_negotiate_send_rep(client, NBD_REP_ACK, errp);
1103 if (ret == 0) {
1104 meta->count = count;
1105 }
1106
1107 return ret;
1108 }
1109
1110 /* nbd_negotiate_options
1111 * Process all NBD_OPT_* client option commands, during fixed newstyle
1112 * negotiation.
1113 * Return:
1114 * -errno on error, errp is set
1115 * 0 on successful negotiation, errp is not set
1116 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
1117 * errp is not set
1118 */
1119 static int nbd_negotiate_options(NBDClient *client, Error **errp)
1120 {
1121 uint32_t flags;
1122 bool fixedNewstyle = false;
1123 bool no_zeroes = false;
1124
1125 /* Client sends:
1126 [ 0 .. 3] client flags
1127
1128 Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO:
1129 [ 0 .. 7] NBD_OPTS_MAGIC
1130 [ 8 .. 11] NBD option
1131 [12 .. 15] Data length
1132 ... Rest of request
1133
1134 [ 0 .. 7] NBD_OPTS_MAGIC
1135 [ 8 .. 11] Second NBD option
1136 [12 .. 15] Data length
1137 ... Rest of request
1138 */
1139
1140 if (nbd_read32(client->ioc, &flags, "flags", errp) < 0) {
1141 return -EIO;
1142 }
1143 client->mode = NBD_MODE_EXPORT_NAME;
1144 trace_nbd_negotiate_options_flags(flags);
1145 if (flags & NBD_FLAG_C_FIXED_NEWSTYLE) {
1146 fixedNewstyle = true;
1147 flags &= ~NBD_FLAG_C_FIXED_NEWSTYLE;
1148 client->mode = NBD_MODE_SIMPLE;
1149 }
1150 if (flags & NBD_FLAG_C_NO_ZEROES) {
1151 no_zeroes = true;
1152 flags &= ~NBD_FLAG_C_NO_ZEROES;
1153 }
1154 if (flags != 0) {
1155 error_setg(errp, "Unknown client flags 0x%" PRIx32 " received", flags);
1156 return -EINVAL;
1157 }
1158
1159 while (1) {
1160 int ret;
1161 uint32_t option, length;
1162 uint64_t magic;
1163
1164 if (nbd_read64(client->ioc, &magic, "opts magic", errp) < 0) {
1165 return -EINVAL;
1166 }
1167 trace_nbd_negotiate_options_check_magic(magic);
1168 if (magic != NBD_OPTS_MAGIC) {
1169 error_setg(errp, "Bad magic received");
1170 return -EINVAL;
1171 }
1172
1173 if (nbd_read32(client->ioc, &option, "option", errp) < 0) {
1174 return -EINVAL;
1175 }
1176 client->opt = option;
1177
1178 if (nbd_read32(client->ioc, &length, "option length", errp) < 0) {
1179 return -EINVAL;
1180 }
1181 assert(!client->optlen);
1182 client->optlen = length;
1183
1184 if (length > NBD_MAX_BUFFER_SIZE) {
1185 error_setg(errp, "len (%" PRIu32 ") is larger than max len (%u)",
1186 length, NBD_MAX_BUFFER_SIZE);
1187 return -EINVAL;
1188 }
1189
1190 trace_nbd_negotiate_options_check_option(option,
1191 nbd_opt_lookup(option));
1192 if (client->tlscreds &&
1193 client->ioc == (QIOChannel *)client->sioc) {
1194 QIOChannel *tioc;
1195 if (!fixedNewstyle) {
1196 error_setg(errp, "Unsupported option 0x%" PRIx32, option);
1197 return -EINVAL;
1198 }
1199 switch (option) {
1200 case NBD_OPT_STARTTLS:
1201 if (length) {
1202 /* Unconditionally drop the connection if the client
1203 * can't start a TLS negotiation correctly */
1204 return nbd_reject_length(client, true, errp);
1205 }
1206 tioc = nbd_negotiate_handle_starttls(client, errp);
1207 if (!tioc) {
1208 return -EIO;
1209 }
1210 ret = 0;
1211 object_unref(OBJECT(client->ioc));
1212 client->ioc = tioc;
1213 break;
1214
1215 case NBD_OPT_EXPORT_NAME:
1216 /* No way to return an error to client, so drop connection */
1217 error_setg(errp, "Option 0x%x not permitted before TLS",
1218 option);
1219 return -EINVAL;
1220
1221 default:
1222 /* Let the client keep trying, unless they asked to
1223 * quit. Always try to give an error back to the
1224 * client; but when replying to OPT_ABORT, be aware
1225 * that the client may hang up before receiving the
1226 * error, in which case we are fine ignoring the
1227 * resulting EPIPE. */
1228 ret = nbd_opt_drop(client, NBD_REP_ERR_TLS_REQD,
1229 option == NBD_OPT_ABORT ? NULL : errp,
1230 "Option 0x%" PRIx32
1231 " not permitted before TLS", option);
1232 if (option == NBD_OPT_ABORT) {
1233 return 1;
1234 }
1235 break;
1236 }
1237 } else if (fixedNewstyle) {
1238 switch (option) {
1239 case NBD_OPT_LIST:
1240 if (length) {
1241 ret = nbd_reject_length(client, false, errp);
1242 } else {
1243 ret = nbd_negotiate_handle_list(client, errp);
1244 }
1245 break;
1246
1247 case NBD_OPT_ABORT:
1248 /* NBD spec says we must try to reply before
1249 * disconnecting, but that we must also tolerate
1250 * guests that don't wait for our reply. */
1251 nbd_negotiate_send_rep(client, NBD_REP_ACK, NULL);
1252 return 1;
1253
1254 case NBD_OPT_EXPORT_NAME:
1255 return nbd_negotiate_handle_export_name(client, no_zeroes,
1256 errp);
1257
1258 case NBD_OPT_INFO:
1259 case NBD_OPT_GO:
1260 ret = nbd_negotiate_handle_info(client, errp);
1261 if (ret == 1) {
1262 assert(option == NBD_OPT_GO);
1263 return 0;
1264 }
1265 break;
1266
1267 case NBD_OPT_STARTTLS:
1268 if (length) {
1269 ret = nbd_reject_length(client, false, errp);
1270 } else if (client->tlscreds) {
1271 ret = nbd_negotiate_send_rep_err(client,
1272 NBD_REP_ERR_INVALID, errp,
1273 "TLS already enabled");
1274 } else {
1275 ret = nbd_negotiate_send_rep_err(client,
1276 NBD_REP_ERR_POLICY, errp,
1277 "TLS not configured");
1278 }
1279 break;
1280
1281 case NBD_OPT_STRUCTURED_REPLY:
1282 if (length) {
1283 ret = nbd_reject_length(client, false, errp);
1284 } else if (client->mode >= NBD_MODE_EXTENDED) {
1285 ret = nbd_negotiate_send_rep_err(
1286 client, NBD_REP_ERR_EXT_HEADER_REQD, errp,
1287 "extended headers already negotiated");
1288 } else if (client->mode >= NBD_MODE_STRUCTURED) {
1289 ret = nbd_negotiate_send_rep_err(
1290 client, NBD_REP_ERR_INVALID, errp,
1291 "structured reply already negotiated");
1292 } else {
1293 ret = nbd_negotiate_send_rep(client, NBD_REP_ACK, errp);
1294 client->mode = NBD_MODE_STRUCTURED;
1295 }
1296 break;
1297
1298 case NBD_OPT_LIST_META_CONTEXT:
1299 case NBD_OPT_SET_META_CONTEXT:
1300 ret = nbd_negotiate_meta_queries(client, errp);
1301 break;
1302
1303 case NBD_OPT_EXTENDED_HEADERS:
1304 if (length) {
1305 ret = nbd_reject_length(client, false, errp);
1306 } else if (client->mode >= NBD_MODE_EXTENDED) {
1307 ret = nbd_negotiate_send_rep_err(
1308 client, NBD_REP_ERR_INVALID, errp,
1309 "extended headers already negotiated");
1310 } else {
1311 ret = nbd_negotiate_send_rep(client, NBD_REP_ACK, errp);
1312 client->mode = NBD_MODE_EXTENDED;
1313 }
1314 break;
1315
1316 default:
1317 ret = nbd_opt_drop(client, NBD_REP_ERR_UNSUP, errp,
1318 "Unsupported option %" PRIu32 " (%s)",
1319 option, nbd_opt_lookup(option));
1320 break;
1321 }
1322 } else {
1323 /*
1324 * If broken new-style we should drop the connection
1325 * for anything except NBD_OPT_EXPORT_NAME
1326 */
1327 switch (option) {
1328 case NBD_OPT_EXPORT_NAME:
1329 return nbd_negotiate_handle_export_name(client, no_zeroes,
1330 errp);
1331
1332 default:
1333 error_setg(errp, "Unsupported option %" PRIu32 " (%s)",
1334 option, nbd_opt_lookup(option));
1335 return -EINVAL;
1336 }
1337 }
1338 if (ret < 0) {
1339 return ret;
1340 }
1341 }
1342 }
1343
1344 /* nbd_negotiate
1345 * Return:
1346 * -errno on error, errp is set
1347 * 0 on successful negotiation, errp is not set
1348 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
1349 * errp is not set
1350 */
1351 static coroutine_fn int nbd_negotiate(NBDClient *client, Error **errp)
1352 {
1353 ERRP_GUARD();
1354 char buf[NBD_OLDSTYLE_NEGOTIATE_SIZE] = "";
1355 int ret;
1356
1357 /* Old style negotiation header, no room for options
1358 [ 0 .. 7] passwd ("NBDMAGIC")
1359 [ 8 .. 15] magic (NBD_CLIENT_MAGIC)
1360 [16 .. 23] size
1361 [24 .. 27] export flags (zero-extended)
1362 [28 .. 151] reserved (0)
1363
1364 New style negotiation header, client can send options
1365 [ 0 .. 7] passwd ("NBDMAGIC")
1366 [ 8 .. 15] magic (NBD_OPTS_MAGIC)
1367 [16 .. 17] server flags (0)
1368 ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO....
1369 */
1370
1371 qio_channel_set_blocking(client->ioc, false, NULL);
1372 qio_channel_set_follow_coroutine_ctx(client->ioc, true);
1373
1374 trace_nbd_negotiate_begin();
1375 memcpy(buf, "NBDMAGIC", 8);
1376
1377 stq_be_p(buf + 8, NBD_OPTS_MAGIC);
1378 stw_be_p(buf + 16, NBD_FLAG_FIXED_NEWSTYLE | NBD_FLAG_NO_ZEROES);
1379
1380 if (nbd_write(client->ioc, buf, 18, errp) < 0) {
1381 error_prepend(errp, "write failed: ");
1382 return -EINVAL;
1383 }
1384 ret = nbd_negotiate_options(client, errp);
1385 if (ret != 0) {
1386 if (ret < 0) {
1387 error_prepend(errp, "option negotiation failed: ");
1388 }
1389 return ret;
1390 }
1391
1392 assert(!client->optlen);
1393 trace_nbd_negotiate_success();
1394
1395 return 0;
1396 }
1397
1398 /* nbd_read_eof
1399 * Tries to read @size bytes from @ioc. This is a local implementation of
1400 * qio_channel_readv_all_eof. We have it here because we need it to be
1401 * interruptible and to know when the coroutine is yielding.
1402 * Returns 1 on success
1403 * 0 on eof, when no data was read (errp is not set)
1404 * negative errno on failure (errp is set)
1405 */
1406 static inline int coroutine_fn
1407 nbd_read_eof(NBDClient *client, void *buffer, size_t size, Error **errp)
1408 {
1409 bool partial = false;
1410
1411 assert(size);
1412 while (size > 0) {
1413 struct iovec iov = { .iov_base = buffer, .iov_len = size };
1414 ssize_t len;
1415
1416 len = qio_channel_readv(client->ioc, &iov, 1, errp);
1417 if (len == QIO_CHANNEL_ERR_BLOCK) {
1418 client->read_yielding = true;
1419 qio_channel_yield(client->ioc, G_IO_IN);
1420 client->read_yielding = false;
1421 if (client->quiescing) {
1422 return -EAGAIN;
1423 }
1424 continue;
1425 } else if (len < 0) {
1426 return -EIO;
1427 } else if (len == 0) {
1428 if (partial) {
1429 error_setg(errp,
1430 "Unexpected end-of-file before all bytes were read");
1431 return -EIO;
1432 } else {
1433 return 0;
1434 }
1435 }
1436
1437 partial = true;
1438 size -= len;
1439 buffer = (uint8_t *) buffer + len;
1440 }
1441 return 1;
1442 }
1443
1444 static int coroutine_fn nbd_receive_request(NBDClient *client, NBDRequest *request,
1445 Error **errp)
1446 {
1447 uint8_t buf[NBD_EXTENDED_REQUEST_SIZE];
1448 uint32_t magic, expect;
1449 int ret;
1450 size_t size = client->mode >= NBD_MODE_EXTENDED ?
1451 NBD_EXTENDED_REQUEST_SIZE : NBD_REQUEST_SIZE;
1452
1453 ret = nbd_read_eof(client, buf, size, errp);
1454 if (ret < 0) {
1455 return ret;
1456 }
1457 if (ret == 0) {
1458 return -EIO;
1459 }
1460
1461 /*
1462 * Compact request
1463 * [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
1464 * [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...)
1465 * [ 6 .. 7] type (NBD_CMD_READ, ...)
1466 * [ 8 .. 15] cookie
1467 * [16 .. 23] from
1468 * [24 .. 27] len
1469 * Extended request
1470 * [ 0 .. 3] magic (NBD_EXTENDED_REQUEST_MAGIC)
1471 * [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, NBD_CMD_FLAG_PAYLOAD_LEN, ...)
1472 * [ 6 .. 7] type (NBD_CMD_READ, ...)
1473 * [ 8 .. 15] cookie
1474 * [16 .. 23] from
1475 * [24 .. 31] len
1476 */
1477
1478 magic = ldl_be_p(buf);
1479 request->flags = lduw_be_p(buf + 4);
1480 request->type = lduw_be_p(buf + 6);
1481 request->cookie = ldq_be_p(buf + 8);
1482 request->from = ldq_be_p(buf + 16);
1483 if (client->mode >= NBD_MODE_EXTENDED) {
1484 request->len = ldq_be_p(buf + 24);
1485 expect = NBD_EXTENDED_REQUEST_MAGIC;
1486 } else {
1487 request->len = (uint32_t)ldl_be_p(buf + 24); /* widen 32 to 64 bits */
1488 expect = NBD_REQUEST_MAGIC;
1489 }
1490
1491 trace_nbd_receive_request(magic, request->flags, request->type,
1492 request->from, request->len);
1493
1494 if (magic != expect) {
1495 error_setg(errp, "invalid magic (got 0x%" PRIx32 ", expected 0x%"
1496 PRIx32 ")", magic, expect);
1497 return -EINVAL;
1498 }
1499 return 0;
1500 }
1501
1502 #define MAX_NBD_REQUESTS 16
1503
1504 void nbd_client_get(NBDClient *client)
1505 {
1506 client->refcount++;
1507 }
1508
1509 void nbd_client_put(NBDClient *client)
1510 {
1511 if (--client->refcount == 0) {
1512 /* The last reference should be dropped by client->close,
1513 * which is called by client_close.
1514 */
1515 assert(client->closing);
1516
1517 object_unref(OBJECT(client->sioc));
1518 object_unref(OBJECT(client->ioc));
1519 if (client->tlscreds) {
1520 object_unref(OBJECT(client->tlscreds));
1521 }
1522 g_free(client->tlsauthz);
1523 if (client->exp) {
1524 QTAILQ_REMOVE(&client->exp->clients, client, next);
1525 blk_exp_unref(&client->exp->common);
1526 }
1527 g_free(client->contexts.bitmaps);
1528 g_free(client);
1529 }
1530 }
1531
1532 static void client_close(NBDClient *client, bool negotiated)
1533 {
1534 if (client->closing) {
1535 return;
1536 }
1537
1538 client->closing = true;
1539
1540 /* Force requests to finish. They will drop their own references,
1541 * then we'll close the socket and free the NBDClient.
1542 */
1543 qio_channel_shutdown(client->ioc, QIO_CHANNEL_SHUTDOWN_BOTH,
1544 NULL);
1545
1546 /* Also tell the client, so that they release their reference. */
1547 if (client->close_fn) {
1548 client->close_fn(client, negotiated);
1549 }
1550 }
1551
1552 static NBDRequestData *nbd_request_get(NBDClient *client)
1553 {
1554 NBDRequestData *req;
1555
1556 assert(client->nb_requests <= MAX_NBD_REQUESTS - 1);
1557 client->nb_requests++;
1558
1559 req = g_new0(NBDRequestData, 1);
1560 nbd_client_get(client);
1561 req->client = client;
1562 return req;
1563 }
1564
1565 static void nbd_request_put(NBDRequestData *req)
1566 {
1567 NBDClient *client = req->client;
1568
1569 if (req->data) {
1570 qemu_vfree(req->data);
1571 }
1572 g_free(req);
1573
1574 client->nb_requests--;
1575
1576 if (client->quiescing && client->nb_requests == 0) {
1577 aio_wait_kick();
1578 }
1579
1580 nbd_client_receive_next_request(client);
1581
1582 nbd_client_put(client);
1583 }
1584
1585 static void blk_aio_attached(AioContext *ctx, void *opaque)
1586 {
1587 NBDExport *exp = opaque;
1588 NBDClient *client;
1589
1590 trace_nbd_blk_aio_attached(exp->name, ctx);
1591
1592 exp->common.ctx = ctx;
1593
1594 QTAILQ_FOREACH(client, &exp->clients, next) {
1595 assert(client->nb_requests == 0);
1596 assert(client->recv_coroutine == NULL);
1597 assert(client->send_coroutine == NULL);
1598 }
1599 }
1600
1601 static void blk_aio_detach(void *opaque)
1602 {
1603 NBDExport *exp = opaque;
1604
1605 trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
1606
1607 exp->common.ctx = NULL;
1608 }
1609
1610 static void nbd_drained_begin(void *opaque)
1611 {
1612 NBDExport *exp = opaque;
1613 NBDClient *client;
1614
1615 QTAILQ_FOREACH(client, &exp->clients, next) {
1616 client->quiescing = true;
1617 }
1618 }
1619
1620 static void nbd_drained_end(void *opaque)
1621 {
1622 NBDExport *exp = opaque;
1623 NBDClient *client;
1624
1625 QTAILQ_FOREACH(client, &exp->clients, next) {
1626 client->quiescing = false;
1627 nbd_client_receive_next_request(client);
1628 }
1629 }
1630
1631 static bool nbd_drained_poll(void *opaque)
1632 {
1633 NBDExport *exp = opaque;
1634 NBDClient *client;
1635
1636 QTAILQ_FOREACH(client, &exp->clients, next) {
1637 if (client->nb_requests != 0) {
1638 /*
1639 * If there's a coroutine waiting for a request on nbd_read_eof()
1640 * enter it here so we don't depend on the client to wake it up.
1641 */
1642 if (client->recv_coroutine != NULL && client->read_yielding) {
1643 qio_channel_wake_read(client->ioc);
1644 }
1645
1646 return true;
1647 }
1648 }
1649
1650 return false;
1651 }
1652
1653 static void nbd_eject_notifier(Notifier *n, void *data)
1654 {
1655 NBDExport *exp = container_of(n, NBDExport, eject_notifier);
1656
1657 blk_exp_request_shutdown(&exp->common);
1658 }
1659
1660 void nbd_export_set_on_eject_blk(BlockExport *exp, BlockBackend *blk)
1661 {
1662 NBDExport *nbd_exp = container_of(exp, NBDExport, common);
1663 assert(exp->drv == &blk_exp_nbd);
1664 assert(nbd_exp->eject_notifier_blk == NULL);
1665
1666 blk_ref(blk);
1667 nbd_exp->eject_notifier_blk = blk;
1668 nbd_exp->eject_notifier.notify = nbd_eject_notifier;
1669 blk_add_remove_bs_notifier(blk, &nbd_exp->eject_notifier);
1670 }
1671
1672 static const BlockDevOps nbd_block_ops = {
1673 .drained_begin = nbd_drained_begin,
1674 .drained_end = nbd_drained_end,
1675 .drained_poll = nbd_drained_poll,
1676 };
1677
1678 static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
1679 Error **errp)
1680 {
1681 NBDExport *exp = container_of(blk_exp, NBDExport, common);
1682 BlockExportOptionsNbd *arg = &exp_args->u.nbd;
1683 const char *name = arg->name ?: exp_args->node_name;
1684 BlockBackend *blk = blk_exp->blk;
1685 int64_t size;
1686 uint64_t perm, shared_perm;
1687 bool readonly = !exp_args->writable;
1688 BlockDirtyBitmapOrStrList *bitmaps;
1689 size_t i;
1690 int ret;
1691
1692 assert(exp_args->type == BLOCK_EXPORT_TYPE_NBD);
1693
1694 if (!nbd_server_is_running()) {
1695 error_setg(errp, "NBD server not running");
1696 return -EINVAL;
1697 }
1698
1699 if (strlen(name) > NBD_MAX_STRING_SIZE) {
1700 error_setg(errp, "export name '%s' too long", name);
1701 return -EINVAL;
1702 }
1703
1704 if (arg->description && strlen(arg->description) > NBD_MAX_STRING_SIZE) {
1705 error_setg(errp, "description '%s' too long", arg->description);
1706 return -EINVAL;
1707 }
1708
1709 if (nbd_export_find(name)) {
1710 error_setg(errp, "NBD server already has export named '%s'", name);
1711 return -EEXIST;
1712 }
1713
1714 size = blk_getlength(blk);
1715 if (size < 0) {
1716 error_setg_errno(errp, -size,
1717 "Failed to determine the NBD export's length");
1718 return size;
1719 }
1720
1721 /* Don't allow resize while the NBD server is running, otherwise we don't
1722 * care what happens with the node. */
1723 blk_get_perm(blk, &perm, &shared_perm);
1724 ret = blk_set_perm(blk, perm, shared_perm & ~BLK_PERM_RESIZE, errp);
1725 if (ret < 0) {
1726 return ret;
1727 }
1728
1729 QTAILQ_INIT(&exp->clients);
1730 exp->name = g_strdup(name);
1731 exp->description = g_strdup(arg->description);
1732 exp->nbdflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH |
1733 NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_CACHE);
1734
1735 if (nbd_server_max_connections() != 1) {
1736 exp->nbdflags |= NBD_FLAG_CAN_MULTI_CONN;
1737 }
1738 if (readonly) {
1739 exp->nbdflags |= NBD_FLAG_READ_ONLY;
1740 } else {
1741 exp->nbdflags |= (NBD_FLAG_SEND_TRIM | NBD_FLAG_SEND_WRITE_ZEROES |
1742 NBD_FLAG_SEND_FAST_ZERO);
1743 }
1744 exp->size = QEMU_ALIGN_DOWN(size, BDRV_SECTOR_SIZE);
1745
1746 for (bitmaps = arg->bitmaps; bitmaps; bitmaps = bitmaps->next) {
1747 exp->nr_export_bitmaps++;
1748 }
1749 exp->export_bitmaps = g_new0(BdrvDirtyBitmap *, exp->nr_export_bitmaps);
1750 for (i = 0, bitmaps = arg->bitmaps; bitmaps;
1751 i++, bitmaps = bitmaps->next)
1752 {
1753 const char *bitmap;
1754 BlockDriverState *bs = blk_bs(blk);
1755 BdrvDirtyBitmap *bm = NULL;
1756
1757 switch (bitmaps->value->type) {
1758 case QTYPE_QSTRING:
1759 bitmap = bitmaps->value->u.local;
1760 while (bs) {
1761 bm = bdrv_find_dirty_bitmap(bs, bitmap);
1762 if (bm != NULL) {
1763 break;
1764 }
1765
1766 bs = bdrv_filter_or_cow_bs(bs);
1767 }
1768
1769 if (bm == NULL) {
1770 ret = -ENOENT;
1771 error_setg(errp, "Bitmap '%s' is not found",
1772 bitmaps->value->u.local);
1773 goto fail;
1774 }
1775
1776 if (readonly && bdrv_is_writable(bs) &&
1777 bdrv_dirty_bitmap_enabled(bm)) {
1778 ret = -EINVAL;
1779 error_setg(errp, "Enabled bitmap '%s' incompatible with "
1780 "readonly export", bitmap);
1781 goto fail;
1782 }
1783 break;
1784 case QTYPE_QDICT:
1785 bitmap = bitmaps->value->u.external.name;
1786 bm = block_dirty_bitmap_lookup(bitmaps->value->u.external.node,
1787 bitmap, NULL, errp);
1788 if (!bm) {
1789 ret = -ENOENT;
1790 goto fail;
1791 }
1792 break;
1793 default:
1794 abort();
1795 }
1796
1797 assert(bm);
1798
1799 if (bdrv_dirty_bitmap_check(bm, BDRV_BITMAP_ALLOW_RO, errp)) {
1800 ret = -EINVAL;
1801 goto fail;
1802 }
1803
1804 exp->export_bitmaps[i] = bm;
1805 assert(strlen(bitmap) <= BDRV_BITMAP_MAX_NAME_SIZE);
1806 }
1807
1808 /* Mark bitmaps busy in a separate loop, to simplify roll-back concerns. */
1809 for (i = 0; i < exp->nr_export_bitmaps; i++) {
1810 bdrv_dirty_bitmap_set_busy(exp->export_bitmaps[i], true);
1811 }
1812
1813 exp->allocation_depth = arg->allocation_depth;
1814
1815 /*
1816 * We need to inhibit request queuing in the block layer to ensure we can
1817 * be properly quiesced when entering a drained section, as our coroutines
1818 * servicing pending requests might enter blk_pread().
1819 */
1820 blk_set_disable_request_queuing(blk, true);
1821
1822 blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
1823
1824 blk_set_dev_ops(blk, &nbd_block_ops, exp);
1825
1826 QTAILQ_INSERT_TAIL(&exports, exp, next);
1827
1828 return 0;
1829
1830 fail:
1831 g_free(exp->export_bitmaps);
1832 g_free(exp->name);
1833 g_free(exp->description);
1834 return ret;
1835 }
1836
1837 NBDExport *nbd_export_find(const char *name)
1838 {
1839 NBDExport *exp;
1840 QTAILQ_FOREACH(exp, &exports, next) {
1841 if (strcmp(name, exp->name) == 0) {
1842 return exp;
1843 }
1844 }
1845
1846 return NULL;
1847 }
1848
1849 AioContext *
1850 nbd_export_aio_context(NBDExport *exp)
1851 {
1852 return exp->common.ctx;
1853 }
1854
1855 static void nbd_export_request_shutdown(BlockExport *blk_exp)
1856 {
1857 NBDExport *exp = container_of(blk_exp, NBDExport, common);
1858 NBDClient *client, *next;
1859
1860 blk_exp_ref(&exp->common);
1861 /*
1862 * TODO: Should we expand QMP NbdServerRemoveNode enum to allow a
1863 * close mode that stops advertising the export to new clients but
1864 * still permits existing clients to run to completion? Because of
1865 * that possibility, nbd_export_close() can be called more than
1866 * once on an export.
1867 */
1868 QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) {
1869 client_close(client, true);
1870 }
1871 if (exp->name) {
1872 g_free(exp->name);
1873 exp->name = NULL;
1874 QTAILQ_REMOVE(&exports, exp, next);
1875 }
1876 blk_exp_unref(&exp->common);
1877 }
1878
1879 static void nbd_export_delete(BlockExport *blk_exp)
1880 {
1881 size_t i;
1882 NBDExport *exp = container_of(blk_exp, NBDExport, common);
1883
1884 assert(exp->name == NULL);
1885 assert(QTAILQ_EMPTY(&exp->clients));
1886
1887 g_free(exp->description);
1888 exp->description = NULL;
1889
1890 if (exp->eject_notifier_blk) {
1891 notifier_remove(&exp->eject_notifier);
1892 blk_unref(exp->eject_notifier_blk);
1893 }
1894 blk_remove_aio_context_notifier(exp->common.blk, blk_aio_attached,
1895 blk_aio_detach, exp);
1896 blk_set_disable_request_queuing(exp->common.blk, false);
1897
1898 for (i = 0; i < exp->nr_export_bitmaps; i++) {
1899 bdrv_dirty_bitmap_set_busy(exp->export_bitmaps[i], false);
1900 }
1901 }
1902
1903 const BlockExportDriver blk_exp_nbd = {
1904 .type = BLOCK_EXPORT_TYPE_NBD,
1905 .instance_size = sizeof(NBDExport),
1906 .create = nbd_export_create,
1907 .delete = nbd_export_delete,
1908 .request_shutdown = nbd_export_request_shutdown,
1909 };
1910
1911 static int coroutine_fn nbd_co_send_iov(NBDClient *client, struct iovec *iov,
1912 unsigned niov, Error **errp)
1913 {
1914 int ret;
1915
1916 g_assert(qemu_in_coroutine());
1917 qemu_co_mutex_lock(&client->send_lock);
1918 client->send_coroutine = qemu_coroutine_self();
1919
1920 ret = qio_channel_writev_all(client->ioc, iov, niov, errp) < 0 ? -EIO : 0;
1921
1922 client->send_coroutine = NULL;
1923 qemu_co_mutex_unlock(&client->send_lock);
1924
1925 return ret;
1926 }
1927
1928 static inline void set_be_simple_reply(NBDSimpleReply *reply, uint64_t error,
1929 uint64_t cookie)
1930 {
1931 stl_be_p(&reply->magic, NBD_SIMPLE_REPLY_MAGIC);
1932 stl_be_p(&reply->error, error);
1933 stq_be_p(&reply->cookie, cookie);
1934 }
1935
1936 static int coroutine_fn nbd_co_send_simple_reply(NBDClient *client,
1937 NBDRequest *request,
1938 uint32_t error,
1939 void *data,
1940 uint64_t len,
1941 Error **errp)
1942 {
1943 NBDSimpleReply reply;
1944 int nbd_err = system_errno_to_nbd_errno(error);
1945 struct iovec iov[] = {
1946 {.iov_base = &reply, .iov_len = sizeof(reply)},
1947 {.iov_base = data, .iov_len = len}
1948 };
1949
1950 assert(!len || !nbd_err);
1951 assert(len <= NBD_MAX_BUFFER_SIZE);
1952 assert(client->mode < NBD_MODE_STRUCTURED ||
1953 (client->mode == NBD_MODE_STRUCTURED &&
1954 request->type != NBD_CMD_READ));
1955 trace_nbd_co_send_simple_reply(request->cookie, nbd_err,
1956 nbd_err_lookup(nbd_err), len);
1957 set_be_simple_reply(&reply, nbd_err, request->cookie);
1958
1959 return nbd_co_send_iov(client, iov, 2, errp);
1960 }
1961
1962 /*
1963 * Prepare the header of a reply chunk for network transmission.
1964 *
1965 * On input, @iov is partially initialized: iov[0].iov_base must point
1966 * to an uninitialized NBDReply, while the remaining @niov elements
1967 * (if any) must be ready for transmission. This function then
1968 * populates iov[0] for transmission.
1969 */
1970 static inline void set_be_chunk(NBDClient *client, struct iovec *iov,
1971 size_t niov, uint16_t flags, uint16_t type,
1972 NBDRequest *request)
1973 {
1974 size_t i, length = 0;
1975
1976 for (i = 1; i < niov; i++) {
1977 length += iov[i].iov_len;
1978 }
1979 assert(length <= NBD_MAX_BUFFER_SIZE + sizeof(NBDStructuredReadData));
1980
1981 if (client->mode >= NBD_MODE_EXTENDED) {
1982 NBDExtendedReplyChunk *chunk = iov->iov_base;
1983
1984 iov[0].iov_len = sizeof(*chunk);
1985 stl_be_p(&chunk->magic, NBD_EXTENDED_REPLY_MAGIC);
1986 stw_be_p(&chunk->flags, flags);
1987 stw_be_p(&chunk->type, type);
1988 stq_be_p(&chunk->cookie, request->cookie);
1989 stq_be_p(&chunk->offset, request->from);
1990 stq_be_p(&chunk->length, length);
1991 } else {
1992 NBDStructuredReplyChunk *chunk = iov->iov_base;
1993
1994 iov[0].iov_len = sizeof(*chunk);
1995 stl_be_p(&chunk->magic, NBD_STRUCTURED_REPLY_MAGIC);
1996 stw_be_p(&chunk->flags, flags);
1997 stw_be_p(&chunk->type, type);
1998 stq_be_p(&chunk->cookie, request->cookie);
1999 stl_be_p(&chunk->length, length);
2000 }
2001 }
2002
2003 static int coroutine_fn nbd_co_send_chunk_done(NBDClient *client,
2004 NBDRequest *request,
2005 Error **errp)
2006 {
2007 NBDReply hdr;
2008 struct iovec iov[] = {
2009 {.iov_base = &hdr},
2010 };
2011
2012 trace_nbd_co_send_chunk_done(request->cookie);
2013 set_be_chunk(client, iov, 1, NBD_REPLY_FLAG_DONE,
2014 NBD_REPLY_TYPE_NONE, request);
2015 return nbd_co_send_iov(client, iov, 1, errp);
2016 }
2017
2018 static int coroutine_fn nbd_co_send_chunk_read(NBDClient *client,
2019 NBDRequest *request,
2020 uint64_t offset,
2021 void *data,
2022 uint64_t size,
2023 bool final,
2024 Error **errp)
2025 {
2026 NBDReply hdr;
2027 NBDStructuredReadData chunk;
2028 struct iovec iov[] = {
2029 {.iov_base = &hdr},
2030 {.iov_base = &chunk, .iov_len = sizeof(chunk)},
2031 {.iov_base = data, .iov_len = size}
2032 };
2033
2034 assert(size && size <= NBD_MAX_BUFFER_SIZE);
2035 trace_nbd_co_send_chunk_read(request->cookie, offset, data, size);
2036 set_be_chunk(client, iov, 3, final ? NBD_REPLY_FLAG_DONE : 0,
2037 NBD_REPLY_TYPE_OFFSET_DATA, request);
2038 stq_be_p(&chunk.offset, offset);
2039
2040 return nbd_co_send_iov(client, iov, 3, errp);
2041 }
2042
2043 static int coroutine_fn nbd_co_send_chunk_error(NBDClient *client,
2044 NBDRequest *request,
2045 uint32_t error,
2046 const char *msg,
2047 Error **errp)
2048 {
2049 NBDReply hdr;
2050 NBDStructuredError chunk;
2051 int nbd_err = system_errno_to_nbd_errno(error);
2052 struct iovec iov[] = {
2053 {.iov_base = &hdr},
2054 {.iov_base = &chunk, .iov_len = sizeof(chunk)},
2055 {.iov_base = (char *)msg, .iov_len = msg ? strlen(msg) : 0},
2056 };
2057
2058 assert(nbd_err);
2059 trace_nbd_co_send_chunk_error(request->cookie, nbd_err,
2060 nbd_err_lookup(nbd_err), msg ? msg : "");
2061 set_be_chunk(client, iov, 3, NBD_REPLY_FLAG_DONE,
2062 NBD_REPLY_TYPE_ERROR, request);
2063 stl_be_p(&chunk.error, nbd_err);
2064 stw_be_p(&chunk.message_length, iov[2].iov_len);
2065
2066 return nbd_co_send_iov(client, iov, 3, errp);
2067 }
2068
2069 /* Do a sparse read and send the structured reply to the client.
2070 * Returns -errno if sending fails. blk_co_block_status_above() failure is
2071 * reported to the client, at which point this function succeeds.
2072 */
2073 static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client,
2074 NBDRequest *request,
2075 uint64_t offset,
2076 uint8_t *data,
2077 uint64_t size,
2078 Error **errp)
2079 {
2080 int ret = 0;
2081 NBDExport *exp = client->exp;
2082 size_t progress = 0;
2083
2084 assert(size <= NBD_MAX_BUFFER_SIZE);
2085 while (progress < size) {
2086 int64_t pnum;
2087 int status = blk_co_block_status_above(exp->common.blk, NULL,
2088 offset + progress,
2089 size - progress, &pnum, NULL,
2090 NULL);
2091 bool final;
2092
2093 if (status < 0) {
2094 char *msg = g_strdup_printf("unable to check for holes: %s",
2095 strerror(-status));
2096
2097 ret = nbd_co_send_chunk_error(client, request, -status, msg, errp);
2098 g_free(msg);
2099 return ret;
2100 }
2101 assert(pnum && pnum <= size - progress);
2102 final = progress + pnum == size;
2103 if (status & BDRV_BLOCK_ZERO) {
2104 NBDReply hdr;
2105 NBDStructuredReadHole chunk;
2106 struct iovec iov[] = {
2107 {.iov_base = &hdr},
2108 {.iov_base = &chunk, .iov_len = sizeof(chunk)},
2109 };
2110
2111 trace_nbd_co_send_chunk_read_hole(request->cookie,
2112 offset + progress, pnum);
2113 set_be_chunk(client, iov, 2,
2114 final ? NBD_REPLY_FLAG_DONE : 0,
2115 NBD_REPLY_TYPE_OFFSET_HOLE, request);
2116 stq_be_p(&chunk.offset, offset + progress);
2117 stl_be_p(&chunk.length, pnum);
2118 ret = nbd_co_send_iov(client, iov, 2, errp);
2119 } else {
2120 ret = blk_co_pread(exp->common.blk, offset + progress, pnum,
2121 data + progress, 0);
2122 if (ret < 0) {
2123 error_setg_errno(errp, -ret, "reading from file failed");
2124 break;
2125 }
2126 ret = nbd_co_send_chunk_read(client, request, offset + progress,
2127 data + progress, pnum, final, errp);
2128 }
2129
2130 if (ret < 0) {
2131 break;
2132 }
2133 progress += pnum;
2134 }
2135 return ret;
2136 }
2137
2138 typedef struct NBDExtentArray {
2139 NBDExtent64 *extents;
2140 unsigned int nb_alloc;
2141 unsigned int count;
2142 uint64_t total_length;
2143 bool extended;
2144 bool can_add;
2145 bool converted_to_be;
2146 } NBDExtentArray;
2147
2148 static NBDExtentArray *nbd_extent_array_new(unsigned int nb_alloc,
2149 NBDMode mode)
2150 {
2151 NBDExtentArray *ea = g_new0(NBDExtentArray, 1);
2152
2153 assert(mode >= NBD_MODE_STRUCTURED);
2154 ea->nb_alloc = nb_alloc;
2155 ea->extents = g_new(NBDExtent64, nb_alloc);
2156 ea->extended = mode >= NBD_MODE_EXTENDED;
2157 ea->can_add = true;
2158
2159 return ea;
2160 }
2161
2162 static void nbd_extent_array_free(NBDExtentArray *ea)
2163 {
2164 g_free(ea->extents);
2165 g_free(ea);
2166 }
2167 G_DEFINE_AUTOPTR_CLEANUP_FUNC(NBDExtentArray, nbd_extent_array_free)
2168
2169 /* Further modifications of the array after conversion are abandoned */
2170 static void nbd_extent_array_convert_to_be(NBDExtentArray *ea)
2171 {
2172 int i;
2173
2174 assert(!ea->converted_to_be);
2175 assert(ea->extended);
2176 ea->can_add = false;
2177 ea->converted_to_be = true;
2178
2179 for (i = 0; i < ea->count; i++) {
2180 ea->extents[i].length = cpu_to_be64(ea->extents[i].length);
2181 ea->extents[i].flags = cpu_to_be64(ea->extents[i].flags);
2182 }
2183 }
2184
2185 /* Further modifications of the array after conversion are abandoned */
2186 static NBDExtent32 *nbd_extent_array_convert_to_narrow(NBDExtentArray *ea)
2187 {
2188 int i;
2189 NBDExtent32 *extents = g_new(NBDExtent32, ea->count);
2190
2191 assert(!ea->converted_to_be);
2192 assert(!ea->extended);
2193 ea->can_add = false;
2194 ea->converted_to_be = true;
2195
2196 for (i = 0; i < ea->count; i++) {
2197 assert((ea->extents[i].length | ea->extents[i].flags) <= UINT32_MAX);
2198 extents[i].length = cpu_to_be32(ea->extents[i].length);
2199 extents[i].flags = cpu_to_be32(ea->extents[i].flags);
2200 }
2201
2202 return extents;
2203 }
2204
2205 /*
2206 * Add extent to NBDExtentArray. If extent can't be added (no available space),
2207 * return -1.
2208 * For safety, when returning -1 for the first time, .can_add is set to false,
2209 * and further calls to nbd_extent_array_add() will crash.
2210 * (this avoids the situation where a caller ignores failure to add one extent,
2211 * where adding another extent that would squash into the last array entry
2212 * would result in an incorrect range reported to the client)
2213 */
2214 static int nbd_extent_array_add(NBDExtentArray *ea,
2215 uint64_t length, uint32_t flags)
2216 {
2217 assert(ea->can_add);
2218
2219 if (!length) {
2220 return 0;
2221 }
2222 if (!ea->extended) {
2223 assert(length <= UINT32_MAX);
2224 }
2225
2226 /* Extend previous extent if flags are the same */
2227 if (ea->count > 0 && flags == ea->extents[ea->count - 1].flags) {
2228 uint64_t sum = length + ea->extents[ea->count - 1].length;
2229
2230 /*
2231 * sum cannot overflow: the block layer bounds image size at
2232 * 2^63, and ea->extents[].length comes from the block layer.
2233 */
2234 assert(sum >= length);
2235 if (sum <= UINT32_MAX || ea->extended) {
2236 ea->extents[ea->count - 1].length = sum;
2237 ea->total_length += length;
2238 return 0;
2239 }
2240 }
2241
2242 if (ea->count >= ea->nb_alloc) {
2243 ea->can_add = false;
2244 return -1;
2245 }
2246
2247 ea->total_length += length;
2248 ea->extents[ea->count] = (NBDExtent64) {.length = length, .flags = flags};
2249 ea->count++;
2250
2251 return 0;
2252 }
2253
2254 static int coroutine_fn blockstatus_to_extents(BlockBackend *blk,
2255 uint64_t offset, uint64_t bytes,
2256 NBDExtentArray *ea)
2257 {
2258 while (bytes) {
2259 uint32_t flags;
2260 int64_t num;
2261 int ret = blk_co_block_status_above(blk, NULL, offset, bytes, &num,
2262 NULL, NULL);
2263
2264 if (ret < 0) {
2265 return ret;
2266 }
2267
2268 flags = (ret & BDRV_BLOCK_DATA ? 0 : NBD_STATE_HOLE) |
2269 (ret & BDRV_BLOCK_ZERO ? NBD_STATE_ZERO : 0);
2270
2271 if (nbd_extent_array_add(ea, num, flags) < 0) {
2272 return 0;
2273 }
2274
2275 offset += num;
2276 bytes -= num;
2277 }
2278
2279 return 0;
2280 }
2281
2282 static int coroutine_fn blockalloc_to_extents(BlockBackend *blk,
2283 uint64_t offset, uint64_t bytes,
2284 NBDExtentArray *ea)
2285 {
2286 while (bytes) {
2287 int64_t num;
2288 int ret = blk_co_is_allocated_above(blk, NULL, false, offset, bytes,
2289 &num);
2290
2291 if (ret < 0) {
2292 return ret;
2293 }
2294
2295 if (nbd_extent_array_add(ea, num, ret) < 0) {
2296 return 0;
2297 }
2298
2299 offset += num;
2300 bytes -= num;
2301 }
2302
2303 return 0;
2304 }
2305
2306 /*
2307 * nbd_co_send_extents
2308 *
2309 * @ea is converted to BE by the function
2310 * @last controls whether NBD_REPLY_FLAG_DONE is sent.
2311 */
2312 static int coroutine_fn
2313 nbd_co_send_extents(NBDClient *client, NBDRequest *request, NBDExtentArray *ea,
2314 bool last, uint32_t context_id, Error **errp)
2315 {
2316 NBDReply hdr;
2317 NBDStructuredMeta meta;
2318 NBDExtendedMeta meta_ext;
2319 g_autofree NBDExtent32 *extents = NULL;
2320 uint16_t type;
2321 struct iovec iov[] = { {.iov_base = &hdr}, {0}, {0} };
2322
2323 if (client->mode >= NBD_MODE_EXTENDED) {
2324 type = NBD_REPLY_TYPE_BLOCK_STATUS_EXT;
2325
2326 iov[1].iov_base = &meta_ext;
2327 iov[1].iov_len = sizeof(meta_ext);
2328 stl_be_p(&meta_ext.context_id, context_id);
2329 stl_be_p(&meta_ext.count, ea->count);
2330
2331 nbd_extent_array_convert_to_be(ea);
2332 iov[2].iov_base = ea->extents;
2333 iov[2].iov_len = ea->count * sizeof(ea->extents[0]);
2334 } else {
2335 type = NBD_REPLY_TYPE_BLOCK_STATUS;
2336
2337 iov[1].iov_base = &meta;
2338 iov[1].iov_len = sizeof(meta);
2339 stl_be_p(&meta.context_id, context_id);
2340
2341 extents = nbd_extent_array_convert_to_narrow(ea);
2342 iov[2].iov_base = extents;
2343 iov[2].iov_len = ea->count * sizeof(extents[0]);
2344 }
2345
2346 trace_nbd_co_send_extents(request->cookie, ea->count, context_id,
2347 ea->total_length, last);
2348 set_be_chunk(client, iov, 3, last ? NBD_REPLY_FLAG_DONE : 0, type,
2349 request);
2350
2351 return nbd_co_send_iov(client, iov, 3, errp);
2352 }
2353
2354 /* Get block status from the exported device and send it to the client */
2355 static int
2356 coroutine_fn nbd_co_send_block_status(NBDClient *client, NBDRequest *request,
2357 BlockBackend *blk, uint64_t offset,
2358 uint64_t length, bool dont_fragment,
2359 bool last, uint32_t context_id,
2360 Error **errp)
2361 {
2362 int ret;
2363 unsigned int nb_extents = dont_fragment ? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS;
2364 g_autoptr(NBDExtentArray) ea =
2365 nbd_extent_array_new(nb_extents, client->mode);
2366
2367 if (context_id == NBD_META_ID_BASE_ALLOCATION) {
2368 ret = blockstatus_to_extents(blk, offset, length, ea);
2369 } else {
2370 ret = blockalloc_to_extents(blk, offset, length, ea);
2371 }
2372 if (ret < 0) {
2373 return nbd_co_send_chunk_error(client, request, -ret,
2374 "can't get block status", errp);
2375 }
2376
2377 return nbd_co_send_extents(client, request, ea, last, context_id, errp);
2378 }
2379
2380 /* Populate @ea from a dirty bitmap. */
2381 static void bitmap_to_extents(BdrvDirtyBitmap *bitmap,
2382 uint64_t offset, uint64_t length,
2383 NBDExtentArray *es)
2384 {
2385 int64_t start, dirty_start, dirty_count;
2386 int64_t end = offset + length;
2387 bool full = false;
2388 int64_t bound = es->extended ? INT64_MAX : INT32_MAX;
2389
2390 bdrv_dirty_bitmap_lock(bitmap);
2391
2392 for (start = offset;
2393 bdrv_dirty_bitmap_next_dirty_area(bitmap, start, end, bound,
2394 &dirty_start, &dirty_count);
2395 start = dirty_start + dirty_count)
2396 {
2397 if ((nbd_extent_array_add(es, dirty_start - start, 0) < 0) ||
2398 (nbd_extent_array_add(es, dirty_count, NBD_STATE_DIRTY) < 0))
2399 {
2400 full = true;
2401 break;
2402 }
2403 }
2404
2405 if (!full) {
2406 /* last non dirty extent, nothing to do if array is now full */
2407 (void) nbd_extent_array_add(es, end - start, 0);
2408 }
2409
2410 bdrv_dirty_bitmap_unlock(bitmap);
2411 }
2412
2413 static int coroutine_fn nbd_co_send_bitmap(NBDClient *client,
2414 NBDRequest *request,
2415 BdrvDirtyBitmap *bitmap,
2416 uint64_t offset,
2417 uint64_t length, bool dont_fragment,
2418 bool last, uint32_t context_id,
2419 Error **errp)
2420 {
2421 unsigned int nb_extents = dont_fragment ? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS;
2422 g_autoptr(NBDExtentArray) ea =
2423 nbd_extent_array_new(nb_extents, client->mode);
2424
2425 bitmap_to_extents(bitmap, offset, length, ea);
2426
2427 return nbd_co_send_extents(client, request, ea, last, context_id, errp);
2428 }
2429
2430 /*
2431 * nbd_co_block_status_payload_read
2432 * Called when a client wants a subset of negotiated contexts via a
2433 * BLOCK_STATUS payload. Check the payload for valid length and
2434 * contents. On success, return 0 with request updated to effective
2435 * length. If request was invalid but all payload consumed, return 0
2436 * with request->len and request->contexts->count set to 0 (which will
2437 * trigger an appropriate NBD_EINVAL response later on). Return
2438 * negative errno if the payload was not fully consumed.
2439 */
2440 static int
2441 nbd_co_block_status_payload_read(NBDClient *client, NBDRequest *request,
2442 Error **errp)
2443 {
2444 uint64_t payload_len = request->len;
2445 g_autofree char *buf = NULL;
2446 size_t count, i, nr_bitmaps;
2447 uint32_t id;
2448
2449 if (payload_len > NBD_MAX_BUFFER_SIZE) {
2450 error_setg(errp, "len (%" PRIu64 ") is larger than max len (%u)",
2451 request->len, NBD_MAX_BUFFER_SIZE);
2452 return -EINVAL;
2453 }
2454
2455 assert(client->contexts.exp == client->exp);
2456 nr_bitmaps = client->exp->nr_export_bitmaps;
2457 request->contexts = g_new0(NBDMetaContexts, 1);
2458 request->contexts->exp = client->exp;
2459
2460 if (payload_len % sizeof(uint32_t) ||
2461 payload_len < sizeof(NBDBlockStatusPayload) ||
2462 payload_len > (sizeof(NBDBlockStatusPayload) +
2463 sizeof(id) * client->contexts.count)) {
2464 goto skip;
2465 }
2466
2467 buf = g_malloc(payload_len);
2468 if (nbd_read(client->ioc, buf, payload_len,
2469 "CMD_BLOCK_STATUS data", errp) < 0) {
2470 return -EIO;
2471 }
2472 trace_nbd_co_receive_request_payload_received(request->cookie,
2473 payload_len);
2474 request->contexts->bitmaps = g_new0(bool, nr_bitmaps);
2475 count = (payload_len - sizeof(NBDBlockStatusPayload)) / sizeof(id);
2476 payload_len = 0;
2477
2478 for (i = 0; i < count; i++) {
2479 id = ldl_be_p(buf + sizeof(NBDBlockStatusPayload) + sizeof(id) * i);
2480 if (id == NBD_META_ID_BASE_ALLOCATION) {
2481 if (!client->contexts.base_allocation ||
2482 request->contexts->base_allocation) {
2483 goto skip;
2484 }
2485 request->contexts->base_allocation = true;
2486 } else if (id == NBD_META_ID_ALLOCATION_DEPTH) {
2487 if (!client->contexts.allocation_depth ||
2488 request->contexts->allocation_depth) {
2489 goto skip;
2490 }
2491 request->contexts->allocation_depth = true;
2492 } else {
2493 unsigned idx = id - NBD_META_ID_DIRTY_BITMAP;
2494
2495 if (idx >= nr_bitmaps || !client->contexts.bitmaps[idx] ||
2496 request->contexts->bitmaps[idx]) {
2497 goto skip;
2498 }
2499 request->contexts->bitmaps[idx] = true;
2500 }
2501 }
2502
2503 request->len = ldq_be_p(buf);
2504 request->contexts->count = count;
2505 return 0;
2506
2507 skip:
2508 trace_nbd_co_receive_block_status_payload_compliance(request->from,
2509 request->len);
2510 request->len = request->contexts->count = 0;
2511 return nbd_drop(client->ioc, payload_len, errp);
2512 }
2513
2514 /* nbd_co_receive_request
2515 * Collect a client request. Return 0 if request looks valid, -EIO to drop
2516 * connection right away, -EAGAIN to indicate we were interrupted and the
2517 * channel should be quiesced, and any other negative value to report an error
2518 * to the client (although the caller may still need to disconnect after
2519 * reporting the error).
2520 */
2521 static int coroutine_fn nbd_co_receive_request(NBDRequestData *req,
2522 NBDRequest *request,
2523 Error **errp)
2524 {
2525 NBDClient *client = req->client;
2526 bool extended_with_payload;
2527 bool check_length = false;
2528 bool check_rofs = false;
2529 bool allocate_buffer = false;
2530 bool payload_okay = false;
2531 uint64_t payload_len = 0;
2532 int valid_flags = NBD_CMD_FLAG_FUA;
2533 int ret;
2534
2535 g_assert(qemu_in_coroutine());
2536 assert(client->recv_coroutine == qemu_coroutine_self());
2537 ret = nbd_receive_request(client, request, errp);
2538 if (ret < 0) {
2539 return ret;
2540 }
2541
2542 trace_nbd_co_receive_request_decode_type(request->cookie, request->type,
2543 nbd_cmd_lookup(request->type));
2544 extended_with_payload = client->mode >= NBD_MODE_EXTENDED &&
2545 request->flags & NBD_CMD_FLAG_PAYLOAD_LEN;
2546 if (extended_with_payload) {
2547 payload_len = request->len;
2548 check_length = true;
2549 }
2550
2551 switch (request->type) {
2552 case NBD_CMD_DISC:
2553 /* Special case: we're going to disconnect without a reply,
2554 * whether or not flags, from, or len are bogus */
2555 req->complete = true;
2556 return -EIO;
2557
2558 case NBD_CMD_READ:
2559 if (client->mode >= NBD_MODE_STRUCTURED) {
2560 valid_flags |= NBD_CMD_FLAG_DF;
2561 }
2562 check_length = true;
2563 allocate_buffer = true;
2564 break;
2565
2566 case NBD_CMD_WRITE:
2567 if (client->mode >= NBD_MODE_EXTENDED) {
2568 if (!extended_with_payload) {
2569 /* The client is noncompliant. Trace it, but proceed. */
2570 trace_nbd_co_receive_ext_payload_compliance(request->from,
2571 request->len);
2572 }
2573 valid_flags |= NBD_CMD_FLAG_PAYLOAD_LEN;
2574 }
2575 payload_okay = true;
2576 payload_len = request->len;
2577 check_length = true;
2578 allocate_buffer = true;
2579 check_rofs = true;
2580 break;
2581
2582 case NBD_CMD_FLUSH:
2583 break;
2584
2585 case NBD_CMD_TRIM:
2586 check_rofs = true;
2587 break;
2588
2589 case NBD_CMD_CACHE:
2590 check_length = true;
2591 break;
2592
2593 case NBD_CMD_WRITE_ZEROES:
2594 valid_flags |= NBD_CMD_FLAG_NO_HOLE | NBD_CMD_FLAG_FAST_ZERO;
2595 check_rofs = true;
2596 break;
2597
2598 case NBD_CMD_BLOCK_STATUS:
2599 if (extended_with_payload) {
2600 ret = nbd_co_block_status_payload_read(client, request, errp);
2601 if (ret < 0) {
2602 return ret;
2603 }
2604 /* payload now consumed */
2605 check_length = false;
2606 payload_len = 0;
2607 valid_flags |= NBD_CMD_FLAG_PAYLOAD_LEN;
2608 } else {
2609 request->contexts = &client->contexts;
2610 }
2611 valid_flags |= NBD_CMD_FLAG_REQ_ONE;
2612 break;
2613
2614 default:
2615 /* Unrecognized, will fail later */
2616 ;
2617 }
2618
2619 /* Payload and buffer handling. */
2620 if (!payload_len) {
2621 req->complete = true;
2622 }
2623 if (check_length && request->len > NBD_MAX_BUFFER_SIZE) {
2624 /* READ, WRITE, CACHE */
2625 error_setg(errp, "len (%" PRIu64 ") is larger than max len (%u)",
2626 request->len, NBD_MAX_BUFFER_SIZE);
2627 return -EINVAL;
2628 }
2629 if (payload_len && !payload_okay) {
2630 /*
2631 * For now, we don't support payloads on other commands; but
2632 * we can keep the connection alive by ignoring the payload.
2633 * We will fail the command later with NBD_EINVAL for the use
2634 * of an unsupported flag (and not for access beyond bounds).
2635 */
2636 assert(request->type != NBD_CMD_WRITE);
2637 request->len = 0;
2638 }
2639 if (allocate_buffer) {
2640 /* READ, WRITE */
2641 req->data = blk_try_blockalign(client->exp->common.blk,
2642 request->len);
2643 if (req->data == NULL) {
2644 error_setg(errp, "No memory");
2645 return -ENOMEM;
2646 }
2647 }
2648 if (payload_len) {
2649 if (payload_okay) {
2650 /* WRITE */
2651 assert(req->data);
2652 ret = nbd_read(client->ioc, req->data, payload_len,
2653 "CMD_WRITE data", errp);
2654 } else {
2655 ret = nbd_drop(client->ioc, payload_len, errp);
2656 }
2657 if (ret < 0) {
2658 return -EIO;
2659 }
2660 req->complete = true;
2661 trace_nbd_co_receive_request_payload_received(request->cookie,
2662 payload_len);
2663 }
2664
2665 /* Sanity checks. */
2666 if (client->exp->nbdflags & NBD_FLAG_READ_ONLY && check_rofs) {
2667 /* WRITE, TRIM, WRITE_ZEROES */
2668 error_setg(errp, "Export is read-only");
2669 return -EROFS;
2670 }
2671 if (request->from > client->exp->size ||
2672 request->len > client->exp->size - request->from) {
2673 error_setg(errp, "operation past EOF; From: %" PRIu64 ", Len: %" PRIu64
2674 ", Size: %" PRIu64, request->from, request->len,
2675 client->exp->size);
2676 return (request->type == NBD_CMD_WRITE ||
2677 request->type == NBD_CMD_WRITE_ZEROES) ? -ENOSPC : -EINVAL;
2678 }
2679 if (client->check_align && !QEMU_IS_ALIGNED(request->from | request->len,
2680 client->check_align)) {
2681 /*
2682 * The block layer gracefully handles unaligned requests, but
2683 * it's still worth tracing client non-compliance
2684 */
2685 trace_nbd_co_receive_align_compliance(nbd_cmd_lookup(request->type),
2686 request->from,
2687 request->len,
2688 client->check_align);
2689 }
2690 if (request->flags & ~valid_flags) {
2691 error_setg(errp, "unsupported flags for command %s (got 0x%x)",
2692 nbd_cmd_lookup(request->type), request->flags);
2693 return -EINVAL;
2694 }
2695
2696 return 0;
2697 }
2698
2699 /* Send simple reply without a payload, or a structured error
2700 * @error_msg is ignored if @ret >= 0
2701 * Returns 0 if connection is still live, -errno on failure to talk to client
2702 */
2703 static coroutine_fn int nbd_send_generic_reply(NBDClient *client,
2704 NBDRequest *request,
2705 int ret,
2706 const char *error_msg,
2707 Error **errp)
2708 {
2709 if (client->mode >= NBD_MODE_STRUCTURED && ret < 0) {
2710 return nbd_co_send_chunk_error(client, request, -ret, error_msg, errp);
2711 } else if (client->mode >= NBD_MODE_EXTENDED) {
2712 return nbd_co_send_chunk_done(client, request, errp);
2713 } else {
2714 return nbd_co_send_simple_reply(client, request, ret < 0 ? -ret : 0,
2715 NULL, 0, errp);
2716 }
2717 }
2718
2719 /* Handle NBD_CMD_READ request.
2720 * Return -errno if sending fails. Other errors are reported directly to the
2721 * client as an error reply. */
2722 static coroutine_fn int nbd_do_cmd_read(NBDClient *client, NBDRequest *request,
2723 uint8_t *data, Error **errp)
2724 {
2725 int ret;
2726 NBDExport *exp = client->exp;
2727
2728 assert(request->type == NBD_CMD_READ);
2729 assert(request->len <= NBD_MAX_BUFFER_SIZE);
2730
2731 /* XXX: NBD Protocol only documents use of FUA with WRITE */
2732 if (request->flags & NBD_CMD_FLAG_FUA) {
2733 ret = blk_co_flush(exp->common.blk);
2734 if (ret < 0) {
2735 return nbd_send_generic_reply(client, request, ret,
2736 "flush failed", errp);
2737 }
2738 }
2739
2740 if (client->mode >= NBD_MODE_STRUCTURED &&
2741 !(request->flags & NBD_CMD_FLAG_DF) && request->len)
2742 {
2743 return nbd_co_send_sparse_read(client, request, request->from,
2744 data, request->len, errp);
2745 }
2746
2747 ret = blk_co_pread(exp->common.blk, request->from, request->len, data, 0);
2748 if (ret < 0) {
2749 return nbd_send_generic_reply(client, request, ret,
2750 "reading from file failed", errp);
2751 }
2752
2753 if (client->mode >= NBD_MODE_STRUCTURED) {
2754 if (request->len) {
2755 return nbd_co_send_chunk_read(client, request, request->from, data,
2756 request->len, true, errp);
2757 } else {
2758 return nbd_co_send_chunk_done(client, request, errp);
2759 }
2760 } else {
2761 return nbd_co_send_simple_reply(client, request, 0,
2762 data, request->len, errp);
2763 }
2764 }
2765
2766 /*
2767 * nbd_do_cmd_cache
2768 *
2769 * Handle NBD_CMD_CACHE request.
2770 * Return -errno if sending fails. Other errors are reported directly to the
2771 * client as an error reply.
2772 */
2773 static coroutine_fn int nbd_do_cmd_cache(NBDClient *client, NBDRequest *request,
2774 Error **errp)
2775 {
2776 int ret;
2777 NBDExport *exp = client->exp;
2778
2779 assert(request->type == NBD_CMD_CACHE);
2780 assert(request->len <= NBD_MAX_BUFFER_SIZE);
2781
2782 ret = blk_co_preadv(exp->common.blk, request->from, request->len,
2783 NULL, BDRV_REQ_COPY_ON_READ | BDRV_REQ_PREFETCH);
2784
2785 return nbd_send_generic_reply(client, request, ret,
2786 "caching data failed", errp);
2787 }
2788
2789 /* Handle NBD request.
2790 * Return -errno if sending fails. Other errors are reported directly to the
2791 * client as an error reply. */
2792 static coroutine_fn int nbd_handle_request(NBDClient *client,
2793 NBDRequest *request,
2794 uint8_t *data, Error **errp)
2795 {
2796 int ret;
2797 int flags;
2798 NBDExport *exp = client->exp;
2799 char *msg;
2800 size_t i;
2801
2802 switch (request->type) {
2803 case NBD_CMD_CACHE:
2804 return nbd_do_cmd_cache(client, request, errp);
2805
2806 case NBD_CMD_READ:
2807 return nbd_do_cmd_read(client, request, data, errp);
2808
2809 case NBD_CMD_WRITE:
2810 flags = 0;
2811 if (request->flags & NBD_CMD_FLAG_FUA) {
2812 flags |= BDRV_REQ_FUA;
2813 }
2814 assert(request->len <= NBD_MAX_BUFFER_SIZE);
2815 ret = blk_co_pwrite(exp->common.blk, request->from, request->len, data,
2816 flags);
2817 return nbd_send_generic_reply(client, request, ret,
2818 "writing to file failed", errp);
2819
2820 case NBD_CMD_WRITE_ZEROES:
2821 flags = 0;
2822 if (request->flags & NBD_CMD_FLAG_FUA) {
2823 flags |= BDRV_REQ_FUA;
2824 }
2825 if (!(request->flags & NBD_CMD_FLAG_NO_HOLE)) {
2826 flags |= BDRV_REQ_MAY_UNMAP;
2827 }
2828 if (request->flags & NBD_CMD_FLAG_FAST_ZERO) {
2829 flags |= BDRV_REQ_NO_FALLBACK;
2830 }
2831 ret = blk_co_pwrite_zeroes(exp->common.blk, request->from, request->len,
2832 flags);
2833 return nbd_send_generic_reply(client, request, ret,
2834 "writing to file failed", errp);
2835
2836 case NBD_CMD_DISC:
2837 /* unreachable, thanks to special case in nbd_co_receive_request() */
2838 abort();
2839
2840 case NBD_CMD_FLUSH:
2841 ret = blk_co_flush(exp->common.blk);
2842 return nbd_send_generic_reply(client, request, ret,
2843 "flush failed", errp);
2844
2845 case NBD_CMD_TRIM:
2846 ret = blk_co_pdiscard(exp->common.blk, request->from, request->len);
2847 if (ret >= 0 && request->flags & NBD_CMD_FLAG_FUA) {
2848 ret = blk_co_flush(exp->common.blk);
2849 }
2850 return nbd_send_generic_reply(client, request, ret,
2851 "discard failed", errp);
2852
2853 case NBD_CMD_BLOCK_STATUS:
2854 assert(request->contexts);
2855 assert(client->mode >= NBD_MODE_EXTENDED ||
2856 request->len <= UINT32_MAX);
2857 if (request->contexts->count) {
2858 bool dont_fragment = request->flags & NBD_CMD_FLAG_REQ_ONE;
2859 int contexts_remaining = request->contexts->count;
2860
2861 if (!request->len) {
2862 return nbd_send_generic_reply(client, request, -EINVAL,
2863 "need non-zero length", errp);
2864 }
2865 if (request->contexts->base_allocation) {
2866 ret = nbd_co_send_block_status(client, request,
2867 exp->common.blk,
2868 request->from,
2869 request->len, dont_fragment,
2870 !--contexts_remaining,
2871 NBD_META_ID_BASE_ALLOCATION,
2872 errp);
2873 if (ret < 0) {
2874 return ret;
2875 }
2876 }
2877
2878 if (request->contexts->allocation_depth) {
2879 ret = nbd_co_send_block_status(client, request,
2880 exp->common.blk,
2881 request->from, request->len,
2882 dont_fragment,
2883 !--contexts_remaining,
2884 NBD_META_ID_ALLOCATION_DEPTH,
2885 errp);
2886 if (ret < 0) {
2887 return ret;
2888 }
2889 }
2890
2891 assert(request->contexts->exp == client->exp);
2892 for (i = 0; i < client->exp->nr_export_bitmaps; i++) {
2893 if (!request->contexts->bitmaps[i]) {
2894 continue;
2895 }
2896 ret = nbd_co_send_bitmap(client, request,
2897 client->exp->export_bitmaps[i],
2898 request->from, request->len,
2899 dont_fragment, !--contexts_remaining,
2900 NBD_META_ID_DIRTY_BITMAP + i, errp);
2901 if (ret < 0) {
2902 return ret;
2903 }
2904 }
2905
2906 assert(!contexts_remaining);
2907
2908 return 0;
2909 } else if (client->contexts.count) {
2910 return nbd_send_generic_reply(client, request, -EINVAL,
2911 "CMD_BLOCK_STATUS payload not valid",
2912 errp);
2913 } else {
2914 return nbd_send_generic_reply(client, request, -EINVAL,
2915 "CMD_BLOCK_STATUS not negotiated",
2916 errp);
2917 }
2918
2919 default:
2920 msg = g_strdup_printf("invalid request type (%" PRIu32 ") received",
2921 request->type);
2922 ret = nbd_send_generic_reply(client, request, -EINVAL, msg,
2923 errp);
2924 g_free(msg);
2925 return ret;
2926 }
2927 }
2928
2929 /* Owns a reference to the NBDClient passed as opaque. */
2930 static coroutine_fn void nbd_trip(void *opaque)
2931 {
2932 NBDClient *client = opaque;
2933 NBDRequestData *req;
2934 NBDRequest request = { 0 }; /* GCC thinks it can be used uninitialized */
2935 int ret;
2936 Error *local_err = NULL;
2937
2938 trace_nbd_trip();
2939 if (client->closing) {
2940 nbd_client_put(client);
2941 return;
2942 }
2943
2944 if (client->quiescing) {
2945 /*
2946 * We're switching between AIO contexts. Don't attempt to receive a new
2947 * request and kick the main context which may be waiting for us.
2948 */
2949 nbd_client_put(client);
2950 client->recv_coroutine = NULL;
2951 aio_wait_kick();
2952 return;
2953 }
2954
2955 req = nbd_request_get(client);
2956 ret = nbd_co_receive_request(req, &request, &local_err);
2957 client->recv_coroutine = NULL;
2958
2959 if (client->closing) {
2960 /*
2961 * The client may be closed when we are blocked in
2962 * nbd_co_receive_request()
2963 */
2964 goto done;
2965 }
2966
2967 if (ret == -EAGAIN) {
2968 assert(client->quiescing);
2969 goto done;
2970 }
2971
2972 nbd_client_receive_next_request(client);
2973 if (ret == -EIO) {
2974 goto disconnect;
2975 }
2976
2977 qio_channel_set_cork(client->ioc, true);
2978
2979 if (ret < 0) {
2980 /* It wasn't -EIO, so, according to nbd_co_receive_request()
2981 * semantics, we should return the error to the client. */
2982 Error *export_err = local_err;
2983
2984 local_err = NULL;
2985 ret = nbd_send_generic_reply(client, &request, -EINVAL,
2986 error_get_pretty(export_err), &local_err);
2987 error_free(export_err);
2988 } else {
2989 ret = nbd_handle_request(client, &request, req->data, &local_err);
2990 }
2991 if (request.contexts && request.contexts != &client->contexts) {
2992 assert(request.type == NBD_CMD_BLOCK_STATUS);
2993 g_free(request.contexts->bitmaps);
2994 g_free(request.contexts);
2995 }
2996 if (ret < 0) {
2997 error_prepend(&local_err, "Failed to send reply: ");
2998 goto disconnect;
2999 }
3000
3001 /*
3002 * We must disconnect after NBD_CMD_WRITE or BLOCK_STATUS with
3003 * payload if we did not read the payload.
3004 */
3005 if (!req->complete) {
3006 error_setg(&local_err, "Request handling failed in intermediate state");
3007 goto disconnect;
3008 }
3009
3010 qio_channel_set_cork(client->ioc, false);
3011 done:
3012 nbd_request_put(req);
3013 nbd_client_put(client);
3014 return;
3015
3016 disconnect:
3017 if (local_err) {
3018 error_reportf_err(local_err, "Disconnect client, due to: ");
3019 }
3020 nbd_request_put(req);
3021 client_close(client, true);
3022 nbd_client_put(client);
3023 }
3024
3025 static void nbd_client_receive_next_request(NBDClient *client)
3026 {
3027 if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS &&
3028 !client->quiescing) {
3029 nbd_client_get(client);
3030 client->recv_coroutine = qemu_coroutine_create(nbd_trip, client);
3031 aio_co_schedule(client->exp->common.ctx, client->recv_coroutine);
3032 }
3033 }
3034
3035 static coroutine_fn void nbd_co_client_start(void *opaque)
3036 {
3037 NBDClient *client = opaque;
3038 Error *local_err = NULL;
3039
3040 qemu_co_mutex_init(&client->send_lock);
3041
3042 if (nbd_negotiate(client, &local_err)) {
3043 if (local_err) {
3044 error_report_err(local_err);
3045 }
3046 client_close(client, false);
3047 return;
3048 }
3049
3050 nbd_client_receive_next_request(client);
3051 }
3052
3053 /*
3054 * Create a new client listener using the given channel @sioc.
3055 * Begin servicing it in a coroutine. When the connection closes, call
3056 * @close_fn with an indication of whether the client completed negotiation.
3057 */
3058 void nbd_client_new(QIOChannelSocket *sioc,
3059 QCryptoTLSCreds *tlscreds,
3060 const char *tlsauthz,
3061 void (*close_fn)(NBDClient *, bool))
3062 {
3063 NBDClient *client;
3064 Coroutine *co;
3065
3066 client = g_new0(NBDClient, 1);
3067 client->refcount = 1;
3068 client->tlscreds = tlscreds;
3069 if (tlscreds) {
3070 object_ref(OBJECT(client->tlscreds));
3071 }
3072 client->tlsauthz = g_strdup(tlsauthz);
3073 client->sioc = sioc;
3074 qio_channel_set_delay(QIO_CHANNEL(sioc), false);
3075 object_ref(OBJECT(client->sioc));
3076 client->ioc = QIO_CHANNEL(sioc);
3077 object_ref(OBJECT(client->ioc));
3078 client->close_fn = close_fn;
3079
3080 co = qemu_coroutine_create(nbd_co_client_start, client);
3081 qemu_coroutine_enter(co);
3082 }
armbru's QEMU hackery