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