xref: /openbmc/qemu/block/nbd.c (revision ac132d05)
1 /*
2  * QEMU Block driver for NBD
3  *
4  * Copyright (c) 2019 Virtuozzo International GmbH.
5  * Copyright Red Hat
6  * Copyright (C) 2008 Bull S.A.S.
7  *     Author: Laurent Vivier <Laurent.Vivier@bull.net>
8  *
9  * Some parts:
10  *    Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
11  *
12  * Permission is hereby granted, free of charge, to any person obtaining a copy
13  * of this software and associated documentation files (the "Software"), to deal
14  * in the Software without restriction, including without limitation the rights
15  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16  * copies of the Software, and to permit persons to whom the Software is
17  * furnished to do so, subject to the following conditions:
18  *
19  * The above copyright notice and this permission notice shall be included in
20  * all copies or substantial portions of the Software.
21  *
22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28  * THE SOFTWARE.
29  */
30 
31 #include "qemu/osdep.h"
32 
33 #include "trace.h"
34 #include "qemu/uri.h"
35 #include "qemu/option.h"
36 #include "qemu/cutils.h"
37 #include "qemu/main-loop.h"
38 
39 #include "qapi/qapi-visit-sockets.h"
40 #include "qapi/qmp/qstring.h"
41 #include "qapi/clone-visitor.h"
42 
43 #include "block/qdict.h"
44 #include "block/nbd.h"
45 #include "block/block_int.h"
46 #include "block/coroutines.h"
47 
48 #include "qemu/yank.h"
49 
50 #define EN_OPTSTR ":exportname="
51 #define MAX_NBD_REQUESTS    16
52 
53 #define COOKIE_TO_INDEX(cookie) ((cookie) - 1)
54 #define INDEX_TO_COOKIE(index)  ((index) + 1)
55 
56 typedef struct {
57     Coroutine *coroutine;
58     uint64_t offset;        /* original offset of the request */
59     bool receiving;         /* sleeping in the yield in nbd_receive_replies */
60 } NBDClientRequest;
61 
62 typedef enum NBDClientState {
63     NBD_CLIENT_CONNECTING_WAIT,
64     NBD_CLIENT_CONNECTING_NOWAIT,
65     NBD_CLIENT_CONNECTED,
66     NBD_CLIENT_QUIT
67 } NBDClientState;
68 
69 typedef struct BDRVNBDState {
70     QIOChannel *ioc; /* The current I/O channel */
71     NBDExportInfo info;
72 
73     /*
74      * Protects state, free_sema, in_flight, requests[].coroutine,
75      * reconnect_delay_timer.
76      */
77     QemuMutex requests_lock;
78     NBDClientState state;
79     CoQueue free_sema;
80     unsigned in_flight;
81     NBDClientRequest requests[MAX_NBD_REQUESTS];
82     QEMUTimer *reconnect_delay_timer;
83 
84     /* Protects sending data on the socket.  */
85     CoMutex send_mutex;
86 
87     /*
88      * Protects receiving reply headers from the socket, as well as the
89      * fields reply and requests[].receiving
90      */
91     CoMutex receive_mutex;
92     NBDReply reply;
93 
94     QEMUTimer *open_timer;
95 
96     BlockDriverState *bs;
97 
98     /* Connection parameters */
99     uint32_t reconnect_delay;
100     uint32_t open_timeout;
101     SocketAddress *saddr;
102     char *export;
103     char *tlscredsid;
104     QCryptoTLSCreds *tlscreds;
105     char *tlshostname;
106     char *x_dirty_bitmap;
107     bool alloc_depth;
108 
109     NBDClientConnection *conn;
110 } BDRVNBDState;
111 
112 static void nbd_yank(void *opaque);
113 
114 static void nbd_clear_bdrvstate(BlockDriverState *bs)
115 {
116     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
117 
118     nbd_client_connection_release(s->conn);
119     s->conn = NULL;
120 
121     yank_unregister_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name));
122 
123     /* Must not leave timers behind that would access freed data */
124     assert(!s->reconnect_delay_timer);
125     assert(!s->open_timer);
126 
127     object_unref(OBJECT(s->tlscreds));
128     qapi_free_SocketAddress(s->saddr);
129     s->saddr = NULL;
130     g_free(s->export);
131     s->export = NULL;
132     g_free(s->tlscredsid);
133     s->tlscredsid = NULL;
134     g_free(s->tlshostname);
135     s->tlshostname = NULL;
136     g_free(s->x_dirty_bitmap);
137     s->x_dirty_bitmap = NULL;
138 }
139 
140 /* Called with s->receive_mutex taken.  */
141 static bool coroutine_fn nbd_recv_coroutine_wake_one(NBDClientRequest *req)
142 {
143     if (req->receiving) {
144         req->receiving = false;
145         aio_co_wake(req->coroutine);
146         return true;
147     }
148 
149     return false;
150 }
151 
152 static void coroutine_fn nbd_recv_coroutines_wake(BDRVNBDState *s)
153 {
154     int i;
155 
156     QEMU_LOCK_GUARD(&s->receive_mutex);
157     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
158         if (nbd_recv_coroutine_wake_one(&s->requests[i])) {
159             return;
160         }
161     }
162 }
163 
164 /* Called with s->requests_lock held.  */
165 static void coroutine_fn nbd_channel_error_locked(BDRVNBDState *s, int ret)
166 {
167     if (s->state == NBD_CLIENT_CONNECTED) {
168         qio_channel_shutdown(s->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
169     }
170 
171     if (ret == -EIO) {
172         if (s->state == NBD_CLIENT_CONNECTED) {
173             s->state = s->reconnect_delay ? NBD_CLIENT_CONNECTING_WAIT :
174                                             NBD_CLIENT_CONNECTING_NOWAIT;
175         }
176     } else {
177         s->state = NBD_CLIENT_QUIT;
178     }
179 }
180 
181 static void coroutine_fn nbd_channel_error(BDRVNBDState *s, int ret)
182 {
183     QEMU_LOCK_GUARD(&s->requests_lock);
184     nbd_channel_error_locked(s, ret);
185 }
186 
187 static void reconnect_delay_timer_del(BDRVNBDState *s)
188 {
189     if (s->reconnect_delay_timer) {
190         timer_free(s->reconnect_delay_timer);
191         s->reconnect_delay_timer = NULL;
192     }
193 }
194 
195 static void reconnect_delay_timer_cb(void *opaque)
196 {
197     BDRVNBDState *s = opaque;
198 
199     reconnect_delay_timer_del(s);
200     WITH_QEMU_LOCK_GUARD(&s->requests_lock) {
201         if (s->state != NBD_CLIENT_CONNECTING_WAIT) {
202             return;
203         }
204         s->state = NBD_CLIENT_CONNECTING_NOWAIT;
205     }
206     nbd_co_establish_connection_cancel(s->conn);
207 }
208 
209 static void reconnect_delay_timer_init(BDRVNBDState *s, uint64_t expire_time_ns)
210 {
211     assert(!s->reconnect_delay_timer);
212     s->reconnect_delay_timer = aio_timer_new(bdrv_get_aio_context(s->bs),
213                                              QEMU_CLOCK_REALTIME,
214                                              SCALE_NS,
215                                              reconnect_delay_timer_cb, s);
216     timer_mod(s->reconnect_delay_timer, expire_time_ns);
217 }
218 
219 static void nbd_teardown_connection(BlockDriverState *bs)
220 {
221     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
222 
223     assert(!s->in_flight);
224 
225     if (s->ioc) {
226         qio_channel_shutdown(s->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
227         yank_unregister_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name),
228                                  nbd_yank, s->bs);
229         object_unref(OBJECT(s->ioc));
230         s->ioc = NULL;
231     }
232 
233     WITH_QEMU_LOCK_GUARD(&s->requests_lock) {
234         s->state = NBD_CLIENT_QUIT;
235     }
236 }
237 
238 static void open_timer_del(BDRVNBDState *s)
239 {
240     if (s->open_timer) {
241         timer_free(s->open_timer);
242         s->open_timer = NULL;
243     }
244 }
245 
246 static void open_timer_cb(void *opaque)
247 {
248     BDRVNBDState *s = opaque;
249 
250     nbd_co_establish_connection_cancel(s->conn);
251     open_timer_del(s);
252 }
253 
254 static void open_timer_init(BDRVNBDState *s, uint64_t expire_time_ns)
255 {
256     assert(!s->open_timer);
257     s->open_timer = aio_timer_new(bdrv_get_aio_context(s->bs),
258                                   QEMU_CLOCK_REALTIME,
259                                   SCALE_NS,
260                                   open_timer_cb, s);
261     timer_mod(s->open_timer, expire_time_ns);
262 }
263 
264 static bool nbd_client_will_reconnect(BDRVNBDState *s)
265 {
266     /*
267      * Called only after a socket error, so this is not performance sensitive.
268      */
269     QEMU_LOCK_GUARD(&s->requests_lock);
270     return s->state == NBD_CLIENT_CONNECTING_WAIT;
271 }
272 
273 /*
274  * Update @bs with information learned during a completed negotiation process.
275  * Return failure if the server's advertised options are incompatible with the
276  * client's needs.
277  */
278 static int nbd_handle_updated_info(BlockDriverState *bs, Error **errp)
279 {
280     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
281     int ret;
282 
283     if (s->x_dirty_bitmap) {
284         if (!s->info.base_allocation) {
285             error_setg(errp, "requested x-dirty-bitmap %s not found",
286                        s->x_dirty_bitmap);
287             return -EINVAL;
288         }
289         if (strcmp(s->x_dirty_bitmap, "qemu:allocation-depth") == 0) {
290             s->alloc_depth = true;
291         }
292     }
293 
294     if (s->info.flags & NBD_FLAG_READ_ONLY) {
295         ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp);
296         if (ret < 0) {
297             return ret;
298         }
299     }
300 
301     if (s->info.flags & NBD_FLAG_SEND_FUA) {
302         bs->supported_write_flags = BDRV_REQ_FUA;
303         bs->supported_zero_flags |= BDRV_REQ_FUA;
304     }
305 
306     if (s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
307         bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
308         if (s->info.flags & NBD_FLAG_SEND_FAST_ZERO) {
309             bs->supported_zero_flags |= BDRV_REQ_NO_FALLBACK;
310         }
311     }
312 
313     trace_nbd_client_handshake_success(s->export);
314 
315     return 0;
316 }
317 
318 int coroutine_fn nbd_co_do_establish_connection(BlockDriverState *bs,
319                                                 bool blocking, Error **errp)
320 {
321     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
322     int ret;
323     IO_CODE();
324 
325     assert_bdrv_graph_readable();
326     assert(!s->ioc);
327 
328     s->ioc = nbd_co_establish_connection(s->conn, &s->info, blocking, errp);
329     if (!s->ioc) {
330         return -ECONNREFUSED;
331     }
332 
333     yank_register_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name), nbd_yank,
334                            bs);
335 
336     ret = nbd_handle_updated_info(s->bs, NULL);
337     if (ret < 0) {
338         /*
339          * We have connected, but must fail for other reasons.
340          * Send NBD_CMD_DISC as a courtesy to the server.
341          */
342         NBDRequest request = { .type = NBD_CMD_DISC };
343 
344         nbd_send_request(s->ioc, &request);
345 
346         yank_unregister_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name),
347                                  nbd_yank, bs);
348         object_unref(OBJECT(s->ioc));
349         s->ioc = NULL;
350 
351         return ret;
352     }
353 
354     qio_channel_set_blocking(s->ioc, false, NULL);
355     qio_channel_set_follow_coroutine_ctx(s->ioc, true);
356 
357     /* successfully connected */
358     WITH_QEMU_LOCK_GUARD(&s->requests_lock) {
359         s->state = NBD_CLIENT_CONNECTED;
360     }
361 
362     return 0;
363 }
364 
365 /* Called with s->requests_lock held.  */
366 static bool nbd_client_connecting(BDRVNBDState *s)
367 {
368     return s->state == NBD_CLIENT_CONNECTING_WAIT ||
369         s->state == NBD_CLIENT_CONNECTING_NOWAIT;
370 }
371 
372 /* Called with s->requests_lock taken.  */
373 static void coroutine_fn GRAPH_RDLOCK nbd_reconnect_attempt(BDRVNBDState *s)
374 {
375     int ret;
376     bool blocking = s->state == NBD_CLIENT_CONNECTING_WAIT;
377 
378     /*
379      * Now we are sure that nobody is accessing the channel, and no one will
380      * try until we set the state to CONNECTED.
381      */
382     assert(nbd_client_connecting(s));
383     assert(s->in_flight == 1);
384 
385     trace_nbd_reconnect_attempt(s->bs->in_flight);
386 
387     if (blocking && !s->reconnect_delay_timer) {
388         /*
389          * It's the first reconnect attempt after switching to
390          * NBD_CLIENT_CONNECTING_WAIT
391          */
392         g_assert(s->reconnect_delay);
393         reconnect_delay_timer_init(s,
394             qemu_clock_get_ns(QEMU_CLOCK_REALTIME) +
395             s->reconnect_delay * NANOSECONDS_PER_SECOND);
396     }
397 
398     /* Finalize previous connection if any */
399     if (s->ioc) {
400         yank_unregister_function(BLOCKDEV_YANK_INSTANCE(s->bs->node_name),
401                                  nbd_yank, s->bs);
402         object_unref(OBJECT(s->ioc));
403         s->ioc = NULL;
404     }
405 
406     qemu_mutex_unlock(&s->requests_lock);
407     ret = nbd_co_do_establish_connection(s->bs, blocking, NULL);
408     trace_nbd_reconnect_attempt_result(ret, s->bs->in_flight);
409     qemu_mutex_lock(&s->requests_lock);
410 
411     /*
412      * The reconnect attempt is done (maybe successfully, maybe not), so
413      * we no longer need this timer.  Delete it so it will not outlive
414      * this I/O request (so draining removes all timers).
415      */
416     reconnect_delay_timer_del(s);
417 }
418 
419 static coroutine_fn int nbd_receive_replies(BDRVNBDState *s, uint64_t cookie)
420 {
421     int ret;
422     uint64_t ind = COOKIE_TO_INDEX(cookie), ind2;
423     QEMU_LOCK_GUARD(&s->receive_mutex);
424 
425     while (true) {
426         if (s->reply.cookie == cookie) {
427             /* We are done */
428             return 0;
429         }
430 
431         if (s->reply.cookie != 0) {
432             /*
433              * Some other request is being handled now. It should already be
434              * woken by whoever set s->reply.cookie (or never wait in this
435              * yield). So, we should not wake it here.
436              */
437             ind2 = COOKIE_TO_INDEX(s->reply.cookie);
438             assert(!s->requests[ind2].receiving);
439 
440             s->requests[ind].receiving = true;
441             qemu_co_mutex_unlock(&s->receive_mutex);
442 
443             qemu_coroutine_yield();
444             /*
445              * We may be woken for 2 reasons:
446              * 1. From this function, executing in parallel coroutine, when our
447              *    cookie is received.
448              * 2. From nbd_co_receive_one_chunk(), when previous request is
449              *    finished and s->reply.cookie set to 0.
450              * Anyway, it's OK to lock the mutex and go to the next iteration.
451              */
452 
453             qemu_co_mutex_lock(&s->receive_mutex);
454             assert(!s->requests[ind].receiving);
455             continue;
456         }
457 
458         /* We are under mutex and cookie is 0. We have to do the dirty work. */
459         assert(s->reply.cookie == 0);
460         ret = nbd_receive_reply(s->bs, s->ioc, &s->reply, NULL);
461         if (ret <= 0) {
462             ret = ret ? ret : -EIO;
463             nbd_channel_error(s, ret);
464             return ret;
465         }
466         if (nbd_reply_is_structured(&s->reply) &&
467             s->info.mode < NBD_MODE_STRUCTURED) {
468             nbd_channel_error(s, -EINVAL);
469             return -EINVAL;
470         }
471         ind2 = COOKIE_TO_INDEX(s->reply.cookie);
472         if (ind2 >= MAX_NBD_REQUESTS || !s->requests[ind2].coroutine) {
473             nbd_channel_error(s, -EINVAL);
474             return -EINVAL;
475         }
476         if (s->reply.cookie == cookie) {
477             /* We are done */
478             return 0;
479         }
480         nbd_recv_coroutine_wake_one(&s->requests[ind2]);
481     }
482 }
483 
484 static int coroutine_fn GRAPH_RDLOCK
485 nbd_co_send_request(BlockDriverState *bs, NBDRequest *request,
486                     QEMUIOVector *qiov)
487 {
488     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
489     int rc, i = -1;
490 
491     qemu_mutex_lock(&s->requests_lock);
492     while (s->in_flight == MAX_NBD_REQUESTS ||
493            (s->state != NBD_CLIENT_CONNECTED && s->in_flight > 0)) {
494         qemu_co_queue_wait(&s->free_sema, &s->requests_lock);
495     }
496 
497     s->in_flight++;
498     if (s->state != NBD_CLIENT_CONNECTED) {
499         if (nbd_client_connecting(s)) {
500             nbd_reconnect_attempt(s);
501             qemu_co_queue_restart_all(&s->free_sema);
502         }
503         if (s->state != NBD_CLIENT_CONNECTED) {
504             rc = -EIO;
505             goto err;
506         }
507     }
508 
509     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
510         if (s->requests[i].coroutine == NULL) {
511             break;
512         }
513     }
514 
515     assert(i < MAX_NBD_REQUESTS);
516     s->requests[i].coroutine = qemu_coroutine_self();
517     s->requests[i].offset = request->from;
518     s->requests[i].receiving = false;
519     qemu_mutex_unlock(&s->requests_lock);
520 
521     qemu_co_mutex_lock(&s->send_mutex);
522     request->cookie = INDEX_TO_COOKIE(i);
523 
524     assert(s->ioc);
525 
526     if (qiov) {
527         qio_channel_set_cork(s->ioc, true);
528         rc = nbd_send_request(s->ioc, request);
529         if (rc >= 0 && qio_channel_writev_all(s->ioc, qiov->iov, qiov->niov,
530                                               NULL) < 0) {
531             rc = -EIO;
532         }
533         qio_channel_set_cork(s->ioc, false);
534     } else {
535         rc = nbd_send_request(s->ioc, request);
536     }
537     qemu_co_mutex_unlock(&s->send_mutex);
538 
539     if (rc < 0) {
540         qemu_mutex_lock(&s->requests_lock);
541 err:
542         nbd_channel_error_locked(s, rc);
543         if (i != -1) {
544             s->requests[i].coroutine = NULL;
545         }
546         s->in_flight--;
547         qemu_co_queue_next(&s->free_sema);
548         qemu_mutex_unlock(&s->requests_lock);
549     }
550     return rc;
551 }
552 
553 static inline uint16_t payload_advance16(uint8_t **payload)
554 {
555     *payload += 2;
556     return lduw_be_p(*payload - 2);
557 }
558 
559 static inline uint32_t payload_advance32(uint8_t **payload)
560 {
561     *payload += 4;
562     return ldl_be_p(*payload - 4);
563 }
564 
565 static inline uint64_t payload_advance64(uint8_t **payload)
566 {
567     *payload += 8;
568     return ldq_be_p(*payload - 8);
569 }
570 
571 static int nbd_parse_offset_hole_payload(BDRVNBDState *s,
572                                          NBDStructuredReplyChunk *chunk,
573                                          uint8_t *payload, uint64_t orig_offset,
574                                          QEMUIOVector *qiov, Error **errp)
575 {
576     uint64_t offset;
577     uint32_t hole_size;
578 
579     if (chunk->length != sizeof(offset) + sizeof(hole_size)) {
580         error_setg(errp, "Protocol error: invalid payload for "
581                          "NBD_REPLY_TYPE_OFFSET_HOLE");
582         return -EINVAL;
583     }
584 
585     offset = payload_advance64(&payload);
586     hole_size = payload_advance32(&payload);
587 
588     if (!hole_size || offset < orig_offset || hole_size > qiov->size ||
589         offset > orig_offset + qiov->size - hole_size) {
590         error_setg(errp, "Protocol error: server sent chunk exceeding requested"
591                          " region");
592         return -EINVAL;
593     }
594     if (s->info.min_block &&
595         !QEMU_IS_ALIGNED(hole_size, s->info.min_block)) {
596         trace_nbd_structured_read_compliance("hole");
597     }
598 
599     qemu_iovec_memset(qiov, offset - orig_offset, 0, hole_size);
600 
601     return 0;
602 }
603 
604 /*
605  * nbd_parse_blockstatus_payload
606  * Based on our request, we expect only one extent in reply, for the
607  * base:allocation context.
608  */
609 static int nbd_parse_blockstatus_payload(BDRVNBDState *s,
610                                          NBDStructuredReplyChunk *chunk,
611                                          uint8_t *payload, uint64_t orig_length,
612                                          NBDExtent *extent, Error **errp)
613 {
614     uint32_t context_id;
615 
616     /* The server succeeded, so it must have sent [at least] one extent */
617     if (chunk->length < sizeof(context_id) + sizeof(*extent)) {
618         error_setg(errp, "Protocol error: invalid payload for "
619                          "NBD_REPLY_TYPE_BLOCK_STATUS");
620         return -EINVAL;
621     }
622 
623     context_id = payload_advance32(&payload);
624     if (s->info.context_id != context_id) {
625         error_setg(errp, "Protocol error: unexpected context id %d for "
626                          "NBD_REPLY_TYPE_BLOCK_STATUS, when negotiated context "
627                          "id is %d", context_id,
628                          s->info.context_id);
629         return -EINVAL;
630     }
631 
632     extent->length = payload_advance32(&payload);
633     extent->flags = payload_advance32(&payload);
634 
635     if (extent->length == 0) {
636         error_setg(errp, "Protocol error: server sent status chunk with "
637                    "zero length");
638         return -EINVAL;
639     }
640 
641     /*
642      * A server sending unaligned block status is in violation of the
643      * protocol, but as qemu-nbd 3.1 is such a server (at least for
644      * POSIX files that are not a multiple of 512 bytes, since qemu
645      * rounds files up to 512-byte multiples but lseek(SEEK_HOLE)
646      * still sees an implicit hole beyond the real EOF), it's nicer to
647      * work around the misbehaving server. If the request included
648      * more than the final unaligned block, truncate it back to an
649      * aligned result; if the request was only the final block, round
650      * up to the full block and change the status to fully-allocated
651      * (always a safe status, even if it loses information).
652      */
653     if (s->info.min_block && !QEMU_IS_ALIGNED(extent->length,
654                                                    s->info.min_block)) {
655         trace_nbd_parse_blockstatus_compliance("extent length is unaligned");
656         if (extent->length > s->info.min_block) {
657             extent->length = QEMU_ALIGN_DOWN(extent->length,
658                                              s->info.min_block);
659         } else {
660             extent->length = s->info.min_block;
661             extent->flags = 0;
662         }
663     }
664 
665     /*
666      * We used NBD_CMD_FLAG_REQ_ONE, so the server should not have
667      * sent us any more than one extent, nor should it have included
668      * status beyond our request in that extent. However, it's easy
669      * enough to ignore the server's noncompliance without killing the
670      * connection; just ignore trailing extents, and clamp things to
671      * the length of our request.
672      */
673     if (chunk->length > sizeof(context_id) + sizeof(*extent)) {
674         trace_nbd_parse_blockstatus_compliance("more than one extent");
675     }
676     if (extent->length > orig_length) {
677         extent->length = orig_length;
678         trace_nbd_parse_blockstatus_compliance("extent length too large");
679     }
680 
681     /*
682      * HACK: if we are using x-dirty-bitmaps to access
683      * qemu:allocation-depth, treat all depths > 2 the same as 2,
684      * since nbd_client_co_block_status is only expecting the low two
685      * bits to be set.
686      */
687     if (s->alloc_depth && extent->flags > 2) {
688         extent->flags = 2;
689     }
690 
691     return 0;
692 }
693 
694 /*
695  * nbd_parse_error_payload
696  * on success @errp contains message describing nbd error reply
697  */
698 static int nbd_parse_error_payload(NBDStructuredReplyChunk *chunk,
699                                    uint8_t *payload, int *request_ret,
700                                    Error **errp)
701 {
702     uint32_t error;
703     uint16_t message_size;
704 
705     assert(chunk->type & (1 << 15));
706 
707     if (chunk->length < sizeof(error) + sizeof(message_size)) {
708         error_setg(errp,
709                    "Protocol error: invalid payload for structured error");
710         return -EINVAL;
711     }
712 
713     error = nbd_errno_to_system_errno(payload_advance32(&payload));
714     if (error == 0) {
715         error_setg(errp, "Protocol error: server sent structured error chunk "
716                          "with error = 0");
717         return -EINVAL;
718     }
719 
720     *request_ret = -error;
721     message_size = payload_advance16(&payload);
722 
723     if (message_size > chunk->length - sizeof(error) - sizeof(message_size)) {
724         error_setg(errp, "Protocol error: server sent structured error chunk "
725                          "with incorrect message size");
726         return -EINVAL;
727     }
728 
729     /* TODO: Add a trace point to mention the server complaint */
730 
731     /* TODO handle ERROR_OFFSET */
732 
733     return 0;
734 }
735 
736 static int coroutine_fn
737 nbd_co_receive_offset_data_payload(BDRVNBDState *s, uint64_t orig_offset,
738                                    QEMUIOVector *qiov, Error **errp)
739 {
740     QEMUIOVector sub_qiov;
741     uint64_t offset;
742     size_t data_size;
743     int ret;
744     NBDStructuredReplyChunk *chunk = &s->reply.structured;
745 
746     assert(nbd_reply_is_structured(&s->reply));
747 
748     /* The NBD spec requires at least one byte of payload */
749     if (chunk->length <= sizeof(offset)) {
750         error_setg(errp, "Protocol error: invalid payload for "
751                          "NBD_REPLY_TYPE_OFFSET_DATA");
752         return -EINVAL;
753     }
754 
755     if (nbd_read64(s->ioc, &offset, "OFFSET_DATA offset", errp) < 0) {
756         return -EIO;
757     }
758 
759     data_size = chunk->length - sizeof(offset);
760     assert(data_size);
761     if (offset < orig_offset || data_size > qiov->size ||
762         offset > orig_offset + qiov->size - data_size) {
763         error_setg(errp, "Protocol error: server sent chunk exceeding requested"
764                          " region");
765         return -EINVAL;
766     }
767     if (s->info.min_block && !QEMU_IS_ALIGNED(data_size, s->info.min_block)) {
768         trace_nbd_structured_read_compliance("data");
769     }
770 
771     qemu_iovec_init(&sub_qiov, qiov->niov);
772     qemu_iovec_concat(&sub_qiov, qiov, offset - orig_offset, data_size);
773     ret = qio_channel_readv_all(s->ioc, sub_qiov.iov, sub_qiov.niov, errp);
774     qemu_iovec_destroy(&sub_qiov);
775 
776     return ret < 0 ? -EIO : 0;
777 }
778 
779 #define NBD_MAX_MALLOC_PAYLOAD 1000
780 static coroutine_fn int nbd_co_receive_structured_payload(
781         BDRVNBDState *s, void **payload, Error **errp)
782 {
783     int ret;
784     uint32_t len;
785 
786     assert(nbd_reply_is_structured(&s->reply));
787 
788     len = s->reply.structured.length;
789 
790     if (len == 0) {
791         return 0;
792     }
793 
794     if (payload == NULL) {
795         error_setg(errp, "Unexpected structured payload");
796         return -EINVAL;
797     }
798 
799     if (len > NBD_MAX_MALLOC_PAYLOAD) {
800         error_setg(errp, "Payload too large");
801         return -EINVAL;
802     }
803 
804     *payload = g_new(char, len);
805     ret = nbd_read(s->ioc, *payload, len, "structured payload", errp);
806     if (ret < 0) {
807         g_free(*payload);
808         *payload = NULL;
809         return ret;
810     }
811 
812     return 0;
813 }
814 
815 /*
816  * nbd_co_do_receive_one_chunk
817  * for simple reply:
818  *   set request_ret to received reply error
819  *   if qiov is not NULL: read payload to @qiov
820  * for structured reply chunk:
821  *   if error chunk: read payload, set @request_ret, do not set @payload
822  *   else if offset_data chunk: read payload data to @qiov, do not set @payload
823  *   else: read payload to @payload
824  *
825  * If function fails, @errp contains corresponding error message, and the
826  * connection with the server is suspect.  If it returns 0, then the
827  * transaction succeeded (although @request_ret may be a negative errno
828  * corresponding to the server's error reply), and errp is unchanged.
829  */
830 static coroutine_fn int nbd_co_do_receive_one_chunk(
831         BDRVNBDState *s, uint64_t cookie, bool only_structured,
832         int *request_ret, QEMUIOVector *qiov, void **payload, Error **errp)
833 {
834     int ret;
835     int i = COOKIE_TO_INDEX(cookie);
836     void *local_payload = NULL;
837     NBDStructuredReplyChunk *chunk;
838 
839     if (payload) {
840         *payload = NULL;
841     }
842     *request_ret = 0;
843 
844     ret = nbd_receive_replies(s, cookie);
845     if (ret < 0) {
846         error_setg(errp, "Connection closed");
847         return -EIO;
848     }
849     assert(s->ioc);
850 
851     assert(s->reply.cookie == cookie);
852 
853     if (nbd_reply_is_simple(&s->reply)) {
854         if (only_structured) {
855             error_setg(errp, "Protocol error: simple reply when structured "
856                              "reply chunk was expected");
857             return -EINVAL;
858         }
859 
860         *request_ret = -nbd_errno_to_system_errno(s->reply.simple.error);
861         if (*request_ret < 0 || !qiov) {
862             return 0;
863         }
864 
865         return qio_channel_readv_all(s->ioc, qiov->iov, qiov->niov,
866                                      errp) < 0 ? -EIO : 0;
867     }
868 
869     /* handle structured reply chunk */
870     assert(s->info.mode >= NBD_MODE_STRUCTURED);
871     chunk = &s->reply.structured;
872 
873     if (chunk->type == NBD_REPLY_TYPE_NONE) {
874         if (!(chunk->flags & NBD_REPLY_FLAG_DONE)) {
875             error_setg(errp, "Protocol error: NBD_REPLY_TYPE_NONE chunk without"
876                        " NBD_REPLY_FLAG_DONE flag set");
877             return -EINVAL;
878         }
879         if (chunk->length) {
880             error_setg(errp, "Protocol error: NBD_REPLY_TYPE_NONE chunk with"
881                        " nonzero length");
882             return -EINVAL;
883         }
884         return 0;
885     }
886 
887     if (chunk->type == NBD_REPLY_TYPE_OFFSET_DATA) {
888         if (!qiov) {
889             error_setg(errp, "Unexpected NBD_REPLY_TYPE_OFFSET_DATA chunk");
890             return -EINVAL;
891         }
892 
893         return nbd_co_receive_offset_data_payload(s, s->requests[i].offset,
894                                                   qiov, errp);
895     }
896 
897     if (nbd_reply_type_is_error(chunk->type)) {
898         payload = &local_payload;
899     }
900 
901     ret = nbd_co_receive_structured_payload(s, payload, errp);
902     if (ret < 0) {
903         return ret;
904     }
905 
906     if (nbd_reply_type_is_error(chunk->type)) {
907         ret = nbd_parse_error_payload(chunk, local_payload, request_ret, errp);
908         g_free(local_payload);
909         return ret;
910     }
911 
912     return 0;
913 }
914 
915 /*
916  * nbd_co_receive_one_chunk
917  * Read reply, wake up connection_co and set s->quit if needed.
918  * Return value is a fatal error code or normal nbd reply error code
919  */
920 static coroutine_fn int nbd_co_receive_one_chunk(
921         BDRVNBDState *s, uint64_t cookie, bool only_structured,
922         int *request_ret, QEMUIOVector *qiov, NBDReply *reply, void **payload,
923         Error **errp)
924 {
925     int ret = nbd_co_do_receive_one_chunk(s, cookie, only_structured,
926                                           request_ret, qiov, payload, errp);
927 
928     if (ret < 0) {
929         memset(reply, 0, sizeof(*reply));
930         nbd_channel_error(s, ret);
931     } else {
932         /* For assert at loop start in nbd_connection_entry */
933         *reply = s->reply;
934     }
935     s->reply.cookie = 0;
936 
937     nbd_recv_coroutines_wake(s);
938 
939     return ret;
940 }
941 
942 typedef struct NBDReplyChunkIter {
943     int ret;
944     int request_ret;
945     Error *err;
946     bool done, only_structured;
947 } NBDReplyChunkIter;
948 
949 static void nbd_iter_channel_error(NBDReplyChunkIter *iter,
950                                    int ret, Error **local_err)
951 {
952     assert(local_err && *local_err);
953     assert(ret < 0);
954 
955     if (!iter->ret) {
956         iter->ret = ret;
957         error_propagate(&iter->err, *local_err);
958     } else {
959         error_free(*local_err);
960     }
961 
962     *local_err = NULL;
963 }
964 
965 static void nbd_iter_request_error(NBDReplyChunkIter *iter, int ret)
966 {
967     assert(ret < 0);
968 
969     if (!iter->request_ret) {
970         iter->request_ret = ret;
971     }
972 }
973 
974 /*
975  * NBD_FOREACH_REPLY_CHUNK
976  * The pointer stored in @payload requires g_free() to free it.
977  */
978 #define NBD_FOREACH_REPLY_CHUNK(s, iter, cookie, structured, \
979                                 qiov, reply, payload) \
980     for (iter = (NBDReplyChunkIter) { .only_structured = structured }; \
981          nbd_reply_chunk_iter_receive(s, &iter, cookie, qiov, reply, payload);)
982 
983 /*
984  * nbd_reply_chunk_iter_receive
985  * The pointer stored in @payload requires g_free() to free it.
986  */
987 static bool coroutine_fn nbd_reply_chunk_iter_receive(BDRVNBDState *s,
988                                                       NBDReplyChunkIter *iter,
989                                                       uint64_t cookie,
990                                                       QEMUIOVector *qiov,
991                                                       NBDReply *reply,
992                                                       void **payload)
993 {
994     int ret, request_ret;
995     NBDReply local_reply;
996     NBDStructuredReplyChunk *chunk;
997     Error *local_err = NULL;
998 
999     if (iter->done) {
1000         /* Previous iteration was last. */
1001         goto break_loop;
1002     }
1003 
1004     if (reply == NULL) {
1005         reply = &local_reply;
1006     }
1007 
1008     ret = nbd_co_receive_one_chunk(s, cookie, iter->only_structured,
1009                                    &request_ret, qiov, reply, payload,
1010                                    &local_err);
1011     if (ret < 0) {
1012         nbd_iter_channel_error(iter, ret, &local_err);
1013     } else if (request_ret < 0) {
1014         nbd_iter_request_error(iter, request_ret);
1015     }
1016 
1017     /* Do not execute the body of NBD_FOREACH_REPLY_CHUNK for simple reply. */
1018     if (nbd_reply_is_simple(reply) || iter->ret < 0) {
1019         goto break_loop;
1020     }
1021 
1022     chunk = &reply->structured;
1023     iter->only_structured = true;
1024 
1025     if (chunk->type == NBD_REPLY_TYPE_NONE) {
1026         /* NBD_REPLY_FLAG_DONE is already checked in nbd_co_receive_one_chunk */
1027         assert(chunk->flags & NBD_REPLY_FLAG_DONE);
1028         goto break_loop;
1029     }
1030 
1031     if (chunk->flags & NBD_REPLY_FLAG_DONE) {
1032         /* This iteration is last. */
1033         iter->done = true;
1034     }
1035 
1036     /* Execute the loop body */
1037     return true;
1038 
1039 break_loop:
1040     qemu_mutex_lock(&s->requests_lock);
1041     s->requests[COOKIE_TO_INDEX(cookie)].coroutine = NULL;
1042     s->in_flight--;
1043     qemu_co_queue_next(&s->free_sema);
1044     qemu_mutex_unlock(&s->requests_lock);
1045 
1046     return false;
1047 }
1048 
1049 static int coroutine_fn
1050 nbd_co_receive_return_code(BDRVNBDState *s, uint64_t cookie,
1051                            int *request_ret, Error **errp)
1052 {
1053     NBDReplyChunkIter iter;
1054 
1055     NBD_FOREACH_REPLY_CHUNK(s, iter, cookie, false, NULL, NULL, NULL) {
1056         /* nbd_reply_chunk_iter_receive does all the work */
1057     }
1058 
1059     error_propagate(errp, iter.err);
1060     *request_ret = iter.request_ret;
1061     return iter.ret;
1062 }
1063 
1064 static int coroutine_fn
1065 nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
1066                              uint64_t offset, QEMUIOVector *qiov,
1067                              int *request_ret, Error **errp)
1068 {
1069     NBDReplyChunkIter iter;
1070     NBDReply reply;
1071     void *payload = NULL;
1072     Error *local_err = NULL;
1073 
1074     NBD_FOREACH_REPLY_CHUNK(s, iter, cookie,
1075                             s->info.mode >= NBD_MODE_STRUCTURED,
1076                             qiov, &reply, &payload)
1077     {
1078         int ret;
1079         NBDStructuredReplyChunk *chunk = &reply.structured;
1080 
1081         assert(nbd_reply_is_structured(&reply));
1082 
1083         switch (chunk->type) {
1084         case NBD_REPLY_TYPE_OFFSET_DATA:
1085             /*
1086              * special cased in nbd_co_receive_one_chunk, data is already
1087              * in qiov
1088              */
1089             break;
1090         case NBD_REPLY_TYPE_OFFSET_HOLE:
1091             ret = nbd_parse_offset_hole_payload(s, &reply.structured, payload,
1092                                                 offset, qiov, &local_err);
1093             if (ret < 0) {
1094                 nbd_channel_error(s, ret);
1095                 nbd_iter_channel_error(&iter, ret, &local_err);
1096             }
1097             break;
1098         default:
1099             if (!nbd_reply_type_is_error(chunk->type)) {
1100                 /* not allowed reply type */
1101                 nbd_channel_error(s, -EINVAL);
1102                 error_setg(&local_err,
1103                            "Unexpected reply type: %d (%s) for CMD_READ",
1104                            chunk->type, nbd_reply_type_lookup(chunk->type));
1105                 nbd_iter_channel_error(&iter, -EINVAL, &local_err);
1106             }
1107         }
1108 
1109         g_free(payload);
1110         payload = NULL;
1111     }
1112 
1113     error_propagate(errp, iter.err);
1114     *request_ret = iter.request_ret;
1115     return iter.ret;
1116 }
1117 
1118 static int coroutine_fn
1119 nbd_co_receive_blockstatus_reply(BDRVNBDState *s, uint64_t cookie,
1120                                  uint64_t length, NBDExtent *extent,
1121                                  int *request_ret, Error **errp)
1122 {
1123     NBDReplyChunkIter iter;
1124     NBDReply reply;
1125     void *payload = NULL;
1126     Error *local_err = NULL;
1127     bool received = false;
1128 
1129     assert(!extent->length);
1130     NBD_FOREACH_REPLY_CHUNK(s, iter, cookie, false, NULL, &reply, &payload) {
1131         int ret;
1132         NBDStructuredReplyChunk *chunk = &reply.structured;
1133 
1134         assert(nbd_reply_is_structured(&reply));
1135 
1136         switch (chunk->type) {
1137         case NBD_REPLY_TYPE_BLOCK_STATUS:
1138             if (received) {
1139                 nbd_channel_error(s, -EINVAL);
1140                 error_setg(&local_err, "Several BLOCK_STATUS chunks in reply");
1141                 nbd_iter_channel_error(&iter, -EINVAL, &local_err);
1142             }
1143             received = true;
1144 
1145             ret = nbd_parse_blockstatus_payload(s, &reply.structured,
1146                                                 payload, length, extent,
1147                                                 &local_err);
1148             if (ret < 0) {
1149                 nbd_channel_error(s, ret);
1150                 nbd_iter_channel_error(&iter, ret, &local_err);
1151             }
1152             break;
1153         default:
1154             if (!nbd_reply_type_is_error(chunk->type)) {
1155                 nbd_channel_error(s, -EINVAL);
1156                 error_setg(&local_err,
1157                            "Unexpected reply type: %d (%s) "
1158                            "for CMD_BLOCK_STATUS",
1159                            chunk->type, nbd_reply_type_lookup(chunk->type));
1160                 nbd_iter_channel_error(&iter, -EINVAL, &local_err);
1161             }
1162         }
1163 
1164         g_free(payload);
1165         payload = NULL;
1166     }
1167 
1168     if (!extent->length && !iter.request_ret) {
1169         error_setg(&local_err, "Server did not reply with any status extents");
1170         nbd_iter_channel_error(&iter, -EIO, &local_err);
1171     }
1172 
1173     error_propagate(errp, iter.err);
1174     *request_ret = iter.request_ret;
1175     return iter.ret;
1176 }
1177 
1178 static int coroutine_fn GRAPH_RDLOCK
1179 nbd_co_request(BlockDriverState *bs, NBDRequest *request,
1180                QEMUIOVector *write_qiov)
1181 {
1182     int ret, request_ret;
1183     Error *local_err = NULL;
1184     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1185 
1186     assert(request->type != NBD_CMD_READ);
1187     if (write_qiov) {
1188         assert(request->type == NBD_CMD_WRITE);
1189         assert(request->len == iov_size(write_qiov->iov, write_qiov->niov));
1190     } else {
1191         assert(request->type != NBD_CMD_WRITE);
1192     }
1193 
1194     do {
1195         ret = nbd_co_send_request(bs, request, write_qiov);
1196         if (ret < 0) {
1197             continue;
1198         }
1199 
1200         ret = nbd_co_receive_return_code(s, request->cookie,
1201                                          &request_ret, &local_err);
1202         if (local_err) {
1203             trace_nbd_co_request_fail(request->from, request->len,
1204                                       request->cookie, request->flags,
1205                                       request->type,
1206                                       nbd_cmd_lookup(request->type),
1207                                       ret, error_get_pretty(local_err));
1208             error_free(local_err);
1209             local_err = NULL;
1210         }
1211     } while (ret < 0 && nbd_client_will_reconnect(s));
1212 
1213     return ret ? ret : request_ret;
1214 }
1215 
1216 static int coroutine_fn GRAPH_RDLOCK
1217 nbd_client_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
1218                      QEMUIOVector *qiov, BdrvRequestFlags flags)
1219 {
1220     int ret, request_ret;
1221     Error *local_err = NULL;
1222     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1223     NBDRequest request = {
1224         .type = NBD_CMD_READ,
1225         .from = offset,
1226         .len = bytes,
1227     };
1228 
1229     assert(bytes <= NBD_MAX_BUFFER_SIZE);
1230 
1231     if (!bytes) {
1232         return 0;
1233     }
1234     /*
1235      * Work around the fact that the block layer doesn't do
1236      * byte-accurate sizing yet - if the read exceeds the server's
1237      * advertised size because the block layer rounded size up, then
1238      * truncate the request to the server and tail-pad with zero.
1239      */
1240     if (offset >= s->info.size) {
1241         assert(bytes < BDRV_SECTOR_SIZE);
1242         qemu_iovec_memset(qiov, 0, 0, bytes);
1243         return 0;
1244     }
1245     if (offset + bytes > s->info.size) {
1246         uint64_t slop = offset + bytes - s->info.size;
1247 
1248         assert(slop < BDRV_SECTOR_SIZE);
1249         qemu_iovec_memset(qiov, bytes - slop, 0, slop);
1250         request.len -= slop;
1251     }
1252 
1253     do {
1254         ret = nbd_co_send_request(bs, &request, NULL);
1255         if (ret < 0) {
1256             continue;
1257         }
1258 
1259         ret = nbd_co_receive_cmdread_reply(s, request.cookie, offset, qiov,
1260                                            &request_ret, &local_err);
1261         if (local_err) {
1262             trace_nbd_co_request_fail(request.from, request.len, request.cookie,
1263                                       request.flags, request.type,
1264                                       nbd_cmd_lookup(request.type),
1265                                       ret, error_get_pretty(local_err));
1266             error_free(local_err);
1267             local_err = NULL;
1268         }
1269     } while (ret < 0 && nbd_client_will_reconnect(s));
1270 
1271     return ret ? ret : request_ret;
1272 }
1273 
1274 static int coroutine_fn GRAPH_RDLOCK
1275 nbd_client_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
1276                       QEMUIOVector *qiov, BdrvRequestFlags flags)
1277 {
1278     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1279     NBDRequest request = {
1280         .type = NBD_CMD_WRITE,
1281         .from = offset,
1282         .len = bytes,
1283     };
1284 
1285     assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
1286     if (flags & BDRV_REQ_FUA) {
1287         assert(s->info.flags & NBD_FLAG_SEND_FUA);
1288         request.flags |= NBD_CMD_FLAG_FUA;
1289     }
1290 
1291     assert(bytes <= NBD_MAX_BUFFER_SIZE);
1292 
1293     if (!bytes) {
1294         return 0;
1295     }
1296     return nbd_co_request(bs, &request, qiov);
1297 }
1298 
1299 static int coroutine_fn GRAPH_RDLOCK
1300 nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
1301                             BdrvRequestFlags flags)
1302 {
1303     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1304     NBDRequest request = {
1305         .type = NBD_CMD_WRITE_ZEROES,
1306         .from = offset,
1307         .len = bytes,  /* .len is uint32_t actually */
1308     };
1309 
1310     assert(bytes <= UINT32_MAX); /* rely on max_pwrite_zeroes */
1311 
1312     assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
1313     if (!(s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
1314         return -ENOTSUP;
1315     }
1316 
1317     if (flags & BDRV_REQ_FUA) {
1318         assert(s->info.flags & NBD_FLAG_SEND_FUA);
1319         request.flags |= NBD_CMD_FLAG_FUA;
1320     }
1321     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1322         request.flags |= NBD_CMD_FLAG_NO_HOLE;
1323     }
1324     if (flags & BDRV_REQ_NO_FALLBACK) {
1325         assert(s->info.flags & NBD_FLAG_SEND_FAST_ZERO);
1326         request.flags |= NBD_CMD_FLAG_FAST_ZERO;
1327     }
1328 
1329     if (!bytes) {
1330         return 0;
1331     }
1332     return nbd_co_request(bs, &request, NULL);
1333 }
1334 
1335 static int coroutine_fn GRAPH_RDLOCK nbd_client_co_flush(BlockDriverState *bs)
1336 {
1337     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1338     NBDRequest request = { .type = NBD_CMD_FLUSH };
1339 
1340     if (!(s->info.flags & NBD_FLAG_SEND_FLUSH)) {
1341         return 0;
1342     }
1343 
1344     request.from = 0;
1345     request.len = 0;
1346 
1347     return nbd_co_request(bs, &request, NULL);
1348 }
1349 
1350 static int coroutine_fn GRAPH_RDLOCK
1351 nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
1352 {
1353     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1354     NBDRequest request = {
1355         .type = NBD_CMD_TRIM,
1356         .from = offset,
1357         .len = bytes, /* len is uint32_t */
1358     };
1359 
1360     assert(bytes <= UINT32_MAX); /* rely on max_pdiscard */
1361 
1362     assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
1363     if (!(s->info.flags & NBD_FLAG_SEND_TRIM) || !bytes) {
1364         return 0;
1365     }
1366 
1367     return nbd_co_request(bs, &request, NULL);
1368 }
1369 
1370 static int coroutine_fn GRAPH_RDLOCK nbd_client_co_block_status(
1371         BlockDriverState *bs, bool want_zero, int64_t offset, int64_t bytes,
1372         int64_t *pnum, int64_t *map, BlockDriverState **file)
1373 {
1374     int ret, request_ret;
1375     NBDExtent extent = { 0 };
1376     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1377     Error *local_err = NULL;
1378 
1379     NBDRequest request = {
1380         .type = NBD_CMD_BLOCK_STATUS,
1381         .from = offset,
1382         .len = MIN(QEMU_ALIGN_DOWN(INT_MAX, bs->bl.request_alignment),
1383                    MIN(bytes, s->info.size - offset)),
1384         .flags = NBD_CMD_FLAG_REQ_ONE,
1385     };
1386 
1387     if (!s->info.base_allocation) {
1388         *pnum = bytes;
1389         *map = offset;
1390         *file = bs;
1391         return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
1392     }
1393 
1394     /*
1395      * Work around the fact that the block layer doesn't do
1396      * byte-accurate sizing yet - if the status request exceeds the
1397      * server's advertised size because the block layer rounded size
1398      * up, we truncated the request to the server (above), or are
1399      * called on just the hole.
1400      */
1401     if (offset >= s->info.size) {
1402         *pnum = bytes;
1403         assert(bytes < BDRV_SECTOR_SIZE);
1404         /* Intentionally don't report offset_valid for the hole */
1405         return BDRV_BLOCK_ZERO;
1406     }
1407 
1408     if (s->info.min_block) {
1409         assert(QEMU_IS_ALIGNED(request.len, s->info.min_block));
1410     }
1411     do {
1412         ret = nbd_co_send_request(bs, &request, NULL);
1413         if (ret < 0) {
1414             continue;
1415         }
1416 
1417         ret = nbd_co_receive_blockstatus_reply(s, request.cookie, bytes,
1418                                                &extent, &request_ret,
1419                                                &local_err);
1420         if (local_err) {
1421             trace_nbd_co_request_fail(request.from, request.len, request.cookie,
1422                                       request.flags, request.type,
1423                                       nbd_cmd_lookup(request.type),
1424                                       ret, error_get_pretty(local_err));
1425             error_free(local_err);
1426             local_err = NULL;
1427         }
1428     } while (ret < 0 && nbd_client_will_reconnect(s));
1429 
1430     if (ret < 0 || request_ret < 0) {
1431         return ret ? ret : request_ret;
1432     }
1433 
1434     assert(extent.length);
1435     *pnum = extent.length;
1436     *map = offset;
1437     *file = bs;
1438     return (extent.flags & NBD_STATE_HOLE ? 0 : BDRV_BLOCK_DATA) |
1439         (extent.flags & NBD_STATE_ZERO ? BDRV_BLOCK_ZERO : 0) |
1440         BDRV_BLOCK_OFFSET_VALID;
1441 }
1442 
1443 static int nbd_client_reopen_prepare(BDRVReopenState *state,
1444                                      BlockReopenQueue *queue, Error **errp)
1445 {
1446     BDRVNBDState *s = (BDRVNBDState *)state->bs->opaque;
1447 
1448     if ((state->flags & BDRV_O_RDWR) && (s->info.flags & NBD_FLAG_READ_ONLY)) {
1449         error_setg(errp, "Can't reopen read-only NBD mount as read/write");
1450         return -EACCES;
1451     }
1452     return 0;
1453 }
1454 
1455 static void nbd_yank(void *opaque)
1456 {
1457     BlockDriverState *bs = opaque;
1458     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1459 
1460     QEMU_LOCK_GUARD(&s->requests_lock);
1461     qio_channel_shutdown(s->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
1462     s->state = NBD_CLIENT_QUIT;
1463 }
1464 
1465 static void nbd_client_close(BlockDriverState *bs)
1466 {
1467     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1468     NBDRequest request = { .type = NBD_CMD_DISC };
1469 
1470     if (s->ioc) {
1471         nbd_send_request(s->ioc, &request);
1472     }
1473 
1474     nbd_teardown_connection(bs);
1475 }
1476 
1477 
1478 /*
1479  * Parse nbd_open options
1480  */
1481 
1482 static int nbd_parse_uri(const char *filename, QDict *options)
1483 {
1484     URI *uri;
1485     const char *p;
1486     QueryParams *qp = NULL;
1487     int ret = 0;
1488     bool is_unix;
1489 
1490     uri = uri_parse(filename);
1491     if (!uri) {
1492         return -EINVAL;
1493     }
1494 
1495     /* transport */
1496     if (!g_strcmp0(uri->scheme, "nbd")) {
1497         is_unix = false;
1498     } else if (!g_strcmp0(uri->scheme, "nbd+tcp")) {
1499         is_unix = false;
1500     } else if (!g_strcmp0(uri->scheme, "nbd+unix")) {
1501         is_unix = true;
1502     } else {
1503         ret = -EINVAL;
1504         goto out;
1505     }
1506 
1507     p = uri->path ? uri->path : "";
1508     if (p[0] == '/') {
1509         p++;
1510     }
1511     if (p[0]) {
1512         qdict_put_str(options, "export", p);
1513     }
1514 
1515     qp = query_params_parse(uri->query);
1516     if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) {
1517         ret = -EINVAL;
1518         goto out;
1519     }
1520 
1521     if (is_unix) {
1522         /* nbd+unix:///export?socket=path */
1523         if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
1524             ret = -EINVAL;
1525             goto out;
1526         }
1527         qdict_put_str(options, "server.type", "unix");
1528         qdict_put_str(options, "server.path", qp->p[0].value);
1529     } else {
1530         QString *host;
1531         char *port_str;
1532 
1533         /* nbd[+tcp]://host[:port]/export */
1534         if (!uri->server) {
1535             ret = -EINVAL;
1536             goto out;
1537         }
1538 
1539         /* strip braces from literal IPv6 address */
1540         if (uri->server[0] == '[') {
1541             host = qstring_from_substr(uri->server, 1,
1542                                        strlen(uri->server) - 1);
1543         } else {
1544             host = qstring_from_str(uri->server);
1545         }
1546 
1547         qdict_put_str(options, "server.type", "inet");
1548         qdict_put(options, "server.host", host);
1549 
1550         port_str = g_strdup_printf("%d", uri->port ?: NBD_DEFAULT_PORT);
1551         qdict_put_str(options, "server.port", port_str);
1552         g_free(port_str);
1553     }
1554 
1555 out:
1556     if (qp) {
1557         query_params_free(qp);
1558     }
1559     uri_free(uri);
1560     return ret;
1561 }
1562 
1563 static bool nbd_has_filename_options_conflict(QDict *options, Error **errp)
1564 {
1565     const QDictEntry *e;
1566 
1567     for (e = qdict_first(options); e; e = qdict_next(options, e)) {
1568         if (!strcmp(e->key, "host") ||
1569             !strcmp(e->key, "port") ||
1570             !strcmp(e->key, "path") ||
1571             !strcmp(e->key, "export") ||
1572             strstart(e->key, "server.", NULL))
1573         {
1574             error_setg(errp, "Option '%s' cannot be used with a file name",
1575                        e->key);
1576             return true;
1577         }
1578     }
1579 
1580     return false;
1581 }
1582 
1583 static void nbd_parse_filename(const char *filename, QDict *options,
1584                                Error **errp)
1585 {
1586     g_autofree char *file = NULL;
1587     char *export_name;
1588     const char *host_spec;
1589     const char *unixpath;
1590 
1591     if (nbd_has_filename_options_conflict(options, errp)) {
1592         return;
1593     }
1594 
1595     if (strstr(filename, "://")) {
1596         int ret = nbd_parse_uri(filename, options);
1597         if (ret < 0) {
1598             error_setg(errp, "No valid URL specified");
1599         }
1600         return;
1601     }
1602 
1603     file = g_strdup(filename);
1604 
1605     export_name = strstr(file, EN_OPTSTR);
1606     if (export_name) {
1607         if (export_name[strlen(EN_OPTSTR)] == 0) {
1608             return;
1609         }
1610         export_name[0] = 0; /* truncate 'file' */
1611         export_name += strlen(EN_OPTSTR);
1612 
1613         qdict_put_str(options, "export", export_name);
1614     }
1615 
1616     /* extract the host_spec - fail if it's not nbd:... */
1617     if (!strstart(file, "nbd:", &host_spec)) {
1618         error_setg(errp, "File name string for NBD must start with 'nbd:'");
1619         return;
1620     }
1621 
1622     if (!*host_spec) {
1623         return;
1624     }
1625 
1626     /* are we a UNIX or TCP socket? */
1627     if (strstart(host_spec, "unix:", &unixpath)) {
1628         qdict_put_str(options, "server.type", "unix");
1629         qdict_put_str(options, "server.path", unixpath);
1630     } else {
1631         InetSocketAddress *addr = g_new(InetSocketAddress, 1);
1632 
1633         if (inet_parse(addr, host_spec, errp)) {
1634             goto out_inet;
1635         }
1636 
1637         qdict_put_str(options, "server.type", "inet");
1638         qdict_put_str(options, "server.host", addr->host);
1639         qdict_put_str(options, "server.port", addr->port);
1640     out_inet:
1641         qapi_free_InetSocketAddress(addr);
1642     }
1643 }
1644 
1645 static bool nbd_process_legacy_socket_options(QDict *output_options,
1646                                               QemuOpts *legacy_opts,
1647                                               Error **errp)
1648 {
1649     const char *path = qemu_opt_get(legacy_opts, "path");
1650     const char *host = qemu_opt_get(legacy_opts, "host");
1651     const char *port = qemu_opt_get(legacy_opts, "port");
1652     const QDictEntry *e;
1653 
1654     if (!path && !host && !port) {
1655         return true;
1656     }
1657 
1658     for (e = qdict_first(output_options); e; e = qdict_next(output_options, e))
1659     {
1660         if (strstart(e->key, "server.", NULL)) {
1661             error_setg(errp, "Cannot use 'server' and path/host/port at the "
1662                        "same time");
1663             return false;
1664         }
1665     }
1666 
1667     if (path && host) {
1668         error_setg(errp, "path and host may not be used at the same time");
1669         return false;
1670     } else if (path) {
1671         if (port) {
1672             error_setg(errp, "port may not be used without host");
1673             return false;
1674         }
1675 
1676         qdict_put_str(output_options, "server.type", "unix");
1677         qdict_put_str(output_options, "server.path", path);
1678     } else if (host) {
1679         qdict_put_str(output_options, "server.type", "inet");
1680         qdict_put_str(output_options, "server.host", host);
1681         qdict_put_str(output_options, "server.port",
1682                       port ?: stringify(NBD_DEFAULT_PORT));
1683     }
1684 
1685     return true;
1686 }
1687 
1688 static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
1689                                  Error **errp)
1690 {
1691     SocketAddress *saddr = NULL;
1692     QDict *addr = NULL;
1693     Visitor *iv = NULL;
1694 
1695     qdict_extract_subqdict(options, &addr, "server.");
1696     if (!qdict_size(addr)) {
1697         error_setg(errp, "NBD server address missing");
1698         goto done;
1699     }
1700 
1701     iv = qobject_input_visitor_new_flat_confused(addr, errp);
1702     if (!iv) {
1703         goto done;
1704     }
1705 
1706     if (!visit_type_SocketAddress(iv, NULL, &saddr, errp)) {
1707         goto done;
1708     }
1709 
1710     if (socket_address_parse_named_fd(saddr, errp) < 0) {
1711         qapi_free_SocketAddress(saddr);
1712         saddr = NULL;
1713         goto done;
1714     }
1715 
1716 done:
1717     qobject_unref(addr);
1718     visit_free(iv);
1719     return saddr;
1720 }
1721 
1722 static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp)
1723 {
1724     Object *obj;
1725     QCryptoTLSCreds *creds;
1726 
1727     obj = object_resolve_path_component(
1728         object_get_objects_root(), id);
1729     if (!obj) {
1730         error_setg(errp, "No TLS credentials with id '%s'",
1731                    id);
1732         return NULL;
1733     }
1734     creds = (QCryptoTLSCreds *)
1735         object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS);
1736     if (!creds) {
1737         error_setg(errp, "Object with id '%s' is not TLS credentials",
1738                    id);
1739         return NULL;
1740     }
1741 
1742     if (!qcrypto_tls_creds_check_endpoint(creds,
1743                                           QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT,
1744                                           errp)) {
1745         return NULL;
1746     }
1747     object_ref(obj);
1748     return creds;
1749 }
1750 
1751 
1752 static QemuOptsList nbd_runtime_opts = {
1753     .name = "nbd",
1754     .head = QTAILQ_HEAD_INITIALIZER(nbd_runtime_opts.head),
1755     .desc = {
1756         {
1757             .name = "host",
1758             .type = QEMU_OPT_STRING,
1759             .help = "TCP host to connect to",
1760         },
1761         {
1762             .name = "port",
1763             .type = QEMU_OPT_STRING,
1764             .help = "TCP port to connect to",
1765         },
1766         {
1767             .name = "path",
1768             .type = QEMU_OPT_STRING,
1769             .help = "Unix socket path to connect to",
1770         },
1771         {
1772             .name = "export",
1773             .type = QEMU_OPT_STRING,
1774             .help = "Name of the NBD export to open",
1775         },
1776         {
1777             .name = "tls-creds",
1778             .type = QEMU_OPT_STRING,
1779             .help = "ID of the TLS credentials to use",
1780         },
1781         {
1782             .name = "tls-hostname",
1783             .type = QEMU_OPT_STRING,
1784             .help = "Override hostname for validating TLS x509 certificate",
1785         },
1786         {
1787             .name = "x-dirty-bitmap",
1788             .type = QEMU_OPT_STRING,
1789             .help = "experimental: expose named dirty bitmap in place of "
1790                     "block status",
1791         },
1792         {
1793             .name = "reconnect-delay",
1794             .type = QEMU_OPT_NUMBER,
1795             .help = "On an unexpected disconnect, the nbd client tries to "
1796                     "connect again until succeeding or encountering a serious "
1797                     "error.  During the first @reconnect-delay seconds, all "
1798                     "requests are paused and will be rerun on a successful "
1799                     "reconnect. After that time, any delayed requests and all "
1800                     "future requests before a successful reconnect will "
1801                     "immediately fail. Default 0",
1802         },
1803         {
1804             .name = "open-timeout",
1805             .type = QEMU_OPT_NUMBER,
1806             .help = "In seconds. If zero, the nbd driver tries the connection "
1807                     "only once, and fails to open if the connection fails. "
1808                     "If non-zero, the nbd driver will repeat connection "
1809                     "attempts until successful or until @open-timeout seconds "
1810                     "have elapsed. Default 0",
1811         },
1812         { /* end of list */ }
1813     },
1814 };
1815 
1816 static int nbd_process_options(BlockDriverState *bs, QDict *options,
1817                                Error **errp)
1818 {
1819     BDRVNBDState *s = bs->opaque;
1820     QemuOpts *opts;
1821     int ret = -EINVAL;
1822 
1823     opts = qemu_opts_create(&nbd_runtime_opts, NULL, 0, &error_abort);
1824     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
1825         goto error;
1826     }
1827 
1828     /* Translate @host, @port, and @path to a SocketAddress */
1829     if (!nbd_process_legacy_socket_options(options, opts, errp)) {
1830         goto error;
1831     }
1832 
1833     /* Pop the config into our state object. Exit if invalid. */
1834     s->saddr = nbd_config(s, options, errp);
1835     if (!s->saddr) {
1836         goto error;
1837     }
1838 
1839     s->export = g_strdup(qemu_opt_get(opts, "export"));
1840     if (s->export && strlen(s->export) > NBD_MAX_STRING_SIZE) {
1841         error_setg(errp, "export name too long to send to server");
1842         goto error;
1843     }
1844 
1845     s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
1846     if (s->tlscredsid) {
1847         s->tlscreds = nbd_get_tls_creds(s->tlscredsid, errp);
1848         if (!s->tlscreds) {
1849             goto error;
1850         }
1851 
1852         s->tlshostname = g_strdup(qemu_opt_get(opts, "tls-hostname"));
1853         if (!s->tlshostname &&
1854             s->saddr->type == SOCKET_ADDRESS_TYPE_INET) {
1855             s->tlshostname = g_strdup(s->saddr->u.inet.host);
1856         }
1857     }
1858 
1859     s->x_dirty_bitmap = g_strdup(qemu_opt_get(opts, "x-dirty-bitmap"));
1860     if (s->x_dirty_bitmap && strlen(s->x_dirty_bitmap) > NBD_MAX_STRING_SIZE) {
1861         error_setg(errp, "x-dirty-bitmap query too long to send to server");
1862         goto error;
1863     }
1864 
1865     s->reconnect_delay = qemu_opt_get_number(opts, "reconnect-delay", 0);
1866     s->open_timeout = qemu_opt_get_number(opts, "open-timeout", 0);
1867 
1868     ret = 0;
1869 
1870  error:
1871     qemu_opts_del(opts);
1872     return ret;
1873 }
1874 
1875 static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
1876                     Error **errp)
1877 {
1878     int ret;
1879     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1880 
1881     s->bs = bs;
1882     qemu_mutex_init(&s->requests_lock);
1883     qemu_co_queue_init(&s->free_sema);
1884     qemu_co_mutex_init(&s->send_mutex);
1885     qemu_co_mutex_init(&s->receive_mutex);
1886 
1887     if (!yank_register_instance(BLOCKDEV_YANK_INSTANCE(bs->node_name), errp)) {
1888         return -EEXIST;
1889     }
1890 
1891     ret = nbd_process_options(bs, options, errp);
1892     if (ret < 0) {
1893         goto fail;
1894     }
1895 
1896     s->conn = nbd_client_connection_new(s->saddr, true, s->export,
1897                                         s->x_dirty_bitmap, s->tlscreds,
1898                                         s->tlshostname);
1899 
1900     if (s->open_timeout) {
1901         nbd_client_connection_enable_retry(s->conn);
1902         open_timer_init(s, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) +
1903                         s->open_timeout * NANOSECONDS_PER_SECOND);
1904     }
1905 
1906     s->state = NBD_CLIENT_CONNECTING_WAIT;
1907     ret = nbd_do_establish_connection(bs, true, errp);
1908     if (ret < 0) {
1909         goto fail;
1910     }
1911 
1912     /*
1913      * The connect attempt is done, so we no longer need this timer.
1914      * Delete it, because we do not want it to be around when this node
1915      * is drained or closed.
1916      */
1917     open_timer_del(s);
1918 
1919     nbd_client_connection_enable_retry(s->conn);
1920 
1921     return 0;
1922 
1923 fail:
1924     open_timer_del(s);
1925     nbd_clear_bdrvstate(bs);
1926     return ret;
1927 }
1928 
1929 static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)
1930 {
1931     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
1932     uint32_t min = s->info.min_block;
1933     uint32_t max = MIN_NON_ZERO(NBD_MAX_BUFFER_SIZE, s->info.max_block);
1934 
1935     /*
1936      * If the server did not advertise an alignment:
1937      * - a size that is not sector-aligned implies that an alignment
1938      *   of 1 can be used to access those tail bytes
1939      * - advertisement of block status requires an alignment of 1, so
1940      *   that we don't violate block layer constraints that block
1941      *   status is always aligned (as we can't control whether the
1942      *   server will report sub-sector extents, such as a hole at EOF
1943      *   on an unaligned POSIX file)
1944      * - otherwise, assume the server is so old that we are safer avoiding
1945      *   sub-sector requests
1946      */
1947     if (!min) {
1948         min = (!QEMU_IS_ALIGNED(s->info.size, BDRV_SECTOR_SIZE) ||
1949                s->info.base_allocation) ? 1 : BDRV_SECTOR_SIZE;
1950     }
1951 
1952     bs->bl.request_alignment = min;
1953     bs->bl.max_pdiscard = QEMU_ALIGN_DOWN(INT_MAX, min);
1954     bs->bl.max_pwrite_zeroes = max;
1955     bs->bl.max_transfer = max;
1956 
1957     if (s->info.opt_block &&
1958         s->info.opt_block > bs->bl.opt_transfer) {
1959         bs->bl.opt_transfer = s->info.opt_block;
1960     }
1961 }
1962 
1963 static void nbd_close(BlockDriverState *bs)
1964 {
1965     nbd_client_close(bs);
1966     nbd_clear_bdrvstate(bs);
1967 }
1968 
1969 /*
1970  * NBD cannot truncate, but if the caller asks to truncate to the same size, or
1971  * to a smaller size with exact=false, there is no reason to fail the
1972  * operation.
1973  *
1974  * Preallocation mode is ignored since it does not seems useful to fail when
1975  * we never change anything.
1976  */
1977 static int coroutine_fn nbd_co_truncate(BlockDriverState *bs, int64_t offset,
1978                                         bool exact, PreallocMode prealloc,
1979                                         BdrvRequestFlags flags, Error **errp)
1980 {
1981     BDRVNBDState *s = bs->opaque;
1982 
1983     if (offset != s->info.size && exact) {
1984         error_setg(errp, "Cannot resize NBD nodes");
1985         return -ENOTSUP;
1986     }
1987 
1988     if (offset > s->info.size) {
1989         error_setg(errp, "Cannot grow NBD nodes");
1990         return -EINVAL;
1991     }
1992 
1993     return 0;
1994 }
1995 
1996 static int64_t coroutine_fn nbd_co_getlength(BlockDriverState *bs)
1997 {
1998     BDRVNBDState *s = bs->opaque;
1999 
2000     return s->info.size;
2001 }
2002 
2003 static void nbd_refresh_filename(BlockDriverState *bs)
2004 {
2005     BDRVNBDState *s = bs->opaque;
2006     const char *host = NULL, *port = NULL, *path = NULL;
2007     size_t len = 0;
2008 
2009     if (s->saddr->type == SOCKET_ADDRESS_TYPE_INET) {
2010         const InetSocketAddress *inet = &s->saddr->u.inet;
2011         if (!inet->has_ipv4 && !inet->has_ipv6 && !inet->has_to) {
2012             host = inet->host;
2013             port = inet->port;
2014         }
2015     } else if (s->saddr->type == SOCKET_ADDRESS_TYPE_UNIX) {
2016         path = s->saddr->u.q_unix.path;
2017     } /* else can't represent as pseudo-filename */
2018 
2019     if (path && s->export) {
2020         len = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
2021                        "nbd+unix:///%s?socket=%s", s->export, path);
2022     } else if (path && !s->export) {
2023         len = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
2024                        "nbd+unix://?socket=%s", path);
2025     } else if (host && s->export) {
2026         len = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
2027                        "nbd://%s:%s/%s", host, port, s->export);
2028     } else if (host && !s->export) {
2029         len = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
2030                        "nbd://%s:%s", host, port);
2031     }
2032     if (len >= sizeof(bs->exact_filename)) {
2033         /* Name is too long to represent exactly, so leave it empty. */
2034         bs->exact_filename[0] = '\0';
2035     }
2036 }
2037 
2038 static char *nbd_dirname(BlockDriverState *bs, Error **errp)
2039 {
2040     /* The generic bdrv_dirname() implementation is able to work out some
2041      * directory name for NBD nodes, but that would be wrong. So far there is no
2042      * specification for how "export paths" would work, so NBD does not have
2043      * directory names. */
2044     error_setg(errp, "Cannot generate a base directory for NBD nodes");
2045     return NULL;
2046 }
2047 
2048 static const char *const nbd_strong_runtime_opts[] = {
2049     "path",
2050     "host",
2051     "port",
2052     "export",
2053     "tls-creds",
2054     "tls-hostname",
2055     "server.",
2056 
2057     NULL
2058 };
2059 
2060 static void nbd_cancel_in_flight(BlockDriverState *bs)
2061 {
2062     BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
2063 
2064     reconnect_delay_timer_del(s);
2065 
2066     qemu_mutex_lock(&s->requests_lock);
2067     if (s->state == NBD_CLIENT_CONNECTING_WAIT) {
2068         s->state = NBD_CLIENT_CONNECTING_NOWAIT;
2069     }
2070     qemu_mutex_unlock(&s->requests_lock);
2071 
2072     nbd_co_establish_connection_cancel(s->conn);
2073 }
2074 
2075 static void nbd_attach_aio_context(BlockDriverState *bs,
2076                                    AioContext *new_context)
2077 {
2078     BDRVNBDState *s = bs->opaque;
2079 
2080     /* The open_timer is used only during nbd_open() */
2081     assert(!s->open_timer);
2082 
2083     /*
2084      * The reconnect_delay_timer is scheduled in I/O paths when the
2085      * connection is lost, to cancel the reconnection attempt after a
2086      * given time.  Once this attempt is done (successfully or not),
2087      * nbd_reconnect_attempt() ensures the timer is deleted before the
2088      * respective I/O request is resumed.
2089      * Since the AioContext can only be changed when a node is drained,
2090      * the reconnect_delay_timer cannot be active here.
2091      */
2092     assert(!s->reconnect_delay_timer);
2093 }
2094 
2095 static void nbd_detach_aio_context(BlockDriverState *bs)
2096 {
2097     BDRVNBDState *s = bs->opaque;
2098 
2099     assert(!s->open_timer);
2100     assert(!s->reconnect_delay_timer);
2101 }
2102 
2103 static BlockDriver bdrv_nbd = {
2104     .format_name                = "nbd",
2105     .protocol_name              = "nbd",
2106     .instance_size              = sizeof(BDRVNBDState),
2107     .bdrv_parse_filename        = nbd_parse_filename,
2108     .bdrv_co_create_opts        = bdrv_co_create_opts_simple,
2109     .create_opts                = &bdrv_create_opts_simple,
2110     .bdrv_file_open             = nbd_open,
2111     .bdrv_reopen_prepare        = nbd_client_reopen_prepare,
2112     .bdrv_co_preadv             = nbd_client_co_preadv,
2113     .bdrv_co_pwritev            = nbd_client_co_pwritev,
2114     .bdrv_co_pwrite_zeroes      = nbd_client_co_pwrite_zeroes,
2115     .bdrv_close                 = nbd_close,
2116     .bdrv_co_flush_to_os        = nbd_client_co_flush,
2117     .bdrv_co_pdiscard           = nbd_client_co_pdiscard,
2118     .bdrv_refresh_limits        = nbd_refresh_limits,
2119     .bdrv_co_truncate           = nbd_co_truncate,
2120     .bdrv_co_getlength          = nbd_co_getlength,
2121     .bdrv_refresh_filename      = nbd_refresh_filename,
2122     .bdrv_co_block_status       = nbd_client_co_block_status,
2123     .bdrv_dirname               = nbd_dirname,
2124     .strong_runtime_opts        = nbd_strong_runtime_opts,
2125     .bdrv_cancel_in_flight      = nbd_cancel_in_flight,
2126 
2127     .bdrv_attach_aio_context    = nbd_attach_aio_context,
2128     .bdrv_detach_aio_context    = nbd_detach_aio_context,
2129 };
2130 
2131 static BlockDriver bdrv_nbd_tcp = {
2132     .format_name                = "nbd",
2133     .protocol_name              = "nbd+tcp",
2134     .instance_size              = sizeof(BDRVNBDState),
2135     .bdrv_parse_filename        = nbd_parse_filename,
2136     .bdrv_co_create_opts        = bdrv_co_create_opts_simple,
2137     .create_opts                = &bdrv_create_opts_simple,
2138     .bdrv_file_open             = nbd_open,
2139     .bdrv_reopen_prepare        = nbd_client_reopen_prepare,
2140     .bdrv_co_preadv             = nbd_client_co_preadv,
2141     .bdrv_co_pwritev            = nbd_client_co_pwritev,
2142     .bdrv_co_pwrite_zeroes      = nbd_client_co_pwrite_zeroes,
2143     .bdrv_close                 = nbd_close,
2144     .bdrv_co_flush_to_os        = nbd_client_co_flush,
2145     .bdrv_co_pdiscard           = nbd_client_co_pdiscard,
2146     .bdrv_refresh_limits        = nbd_refresh_limits,
2147     .bdrv_co_truncate           = nbd_co_truncate,
2148     .bdrv_co_getlength          = nbd_co_getlength,
2149     .bdrv_refresh_filename      = nbd_refresh_filename,
2150     .bdrv_co_block_status       = nbd_client_co_block_status,
2151     .bdrv_dirname               = nbd_dirname,
2152     .strong_runtime_opts        = nbd_strong_runtime_opts,
2153     .bdrv_cancel_in_flight      = nbd_cancel_in_flight,
2154 
2155     .bdrv_attach_aio_context    = nbd_attach_aio_context,
2156     .bdrv_detach_aio_context    = nbd_detach_aio_context,
2157 };
2158 
2159 static BlockDriver bdrv_nbd_unix = {
2160     .format_name                = "nbd",
2161     .protocol_name              = "nbd+unix",
2162     .instance_size              = sizeof(BDRVNBDState),
2163     .bdrv_parse_filename        = nbd_parse_filename,
2164     .bdrv_co_create_opts        = bdrv_co_create_opts_simple,
2165     .create_opts                = &bdrv_create_opts_simple,
2166     .bdrv_file_open             = nbd_open,
2167     .bdrv_reopen_prepare        = nbd_client_reopen_prepare,
2168     .bdrv_co_preadv             = nbd_client_co_preadv,
2169     .bdrv_co_pwritev            = nbd_client_co_pwritev,
2170     .bdrv_co_pwrite_zeroes      = nbd_client_co_pwrite_zeroes,
2171     .bdrv_close                 = nbd_close,
2172     .bdrv_co_flush_to_os        = nbd_client_co_flush,
2173     .bdrv_co_pdiscard           = nbd_client_co_pdiscard,
2174     .bdrv_refresh_limits        = nbd_refresh_limits,
2175     .bdrv_co_truncate           = nbd_co_truncate,
2176     .bdrv_co_getlength          = nbd_co_getlength,
2177     .bdrv_refresh_filename      = nbd_refresh_filename,
2178     .bdrv_co_block_status       = nbd_client_co_block_status,
2179     .bdrv_dirname               = nbd_dirname,
2180     .strong_runtime_opts        = nbd_strong_runtime_opts,
2181     .bdrv_cancel_in_flight      = nbd_cancel_in_flight,
2182 
2183     .bdrv_attach_aio_context    = nbd_attach_aio_context,
2184     .bdrv_detach_aio_context    = nbd_detach_aio_context,
2185 };
2186 
2187 static void bdrv_nbd_init(void)
2188 {
2189     bdrv_register(&bdrv_nbd);
2190     bdrv_register(&bdrv_nbd_tcp);
2191     bdrv_register(&bdrv_nbd_unix);
2192 }
2193 
2194 block_init(bdrv_nbd_init);
2195