xref: /qemu/nbd/client.c (revision 8d86ada2) 
1 /*
2  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
3  *
4  *  Network Block Device Client Side
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; under version 2 of the License.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
17  */
18 
19 #include "qemu/osdep.h"
20 #include "nbd-internal.h"
21 
22 static int nbd_errno_to_system_errno(int err)
23 {
24     switch (err) {
25     case NBD_SUCCESS:
26         return 0;
27     case NBD_EPERM:
28         return EPERM;
29     case NBD_EIO:
30         return EIO;
31     case NBD_ENOMEM:
32         return ENOMEM;
33     case NBD_ENOSPC:
34         return ENOSPC;
35     case NBD_EINVAL:
36     default:
37         return EINVAL;
38     }
39 }
40 
41 /* Definitions for opaque data types */
42 
43 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
44 
45 /* That's all folks */
46 
47 /* Basic flow for negotiation
48 
49    Server         Client
50    Negotiate
51 
52    or
53 
54    Server         Client
55    Negotiate #1
56                   Option
57    Negotiate #2
58 
59    ----
60 
61    followed by
62 
63    Server         Client
64                   Request
65    Response
66                   Request
67    Response
68                   ...
69    ...
70                   Request (type == 2)
71 
72 */
73 
74 
75 static int nbd_handle_reply_err(uint32_t opt, uint32_t type, Error **errp)
76 {
77     if (!(type & (1 << 31))) {
78         return 0;
79     }
80 
81     switch (type) {
82     case NBD_REP_ERR_UNSUP:
83         error_setg(errp, "Unsupported option type %x", opt);
84         break;
85 
86     case NBD_REP_ERR_POLICY:
87         error_setg(errp, "Denied by server for option %x", opt);
88         break;
89 
90     case NBD_REP_ERR_INVALID:
91         error_setg(errp, "Invalid data length for option %x", opt);
92         break;
93 
94     case NBD_REP_ERR_TLS_REQD:
95         error_setg(errp, "TLS negotiation required before option %x", opt);
96         break;
97 
98     default:
99         error_setg(errp, "Unknown error code when asking for option %x", opt);
100         break;
101     }
102 
103     return -1;
104 }
105 
106 static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp)
107 {
108     uint64_t magic;
109     uint32_t opt;
110     uint32_t type;
111     uint32_t len;
112     uint32_t namelen;
113 
114     *name = NULL;
115     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
116         error_setg(errp, "failed to read list option magic");
117         return -1;
118     }
119     magic = be64_to_cpu(magic);
120     if (magic != NBD_REP_MAGIC) {
121         error_setg(errp, "Unexpected option list magic");
122         return -1;
123     }
124     if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
125         error_setg(errp, "failed to read list option");
126         return -1;
127     }
128     opt = be32_to_cpu(opt);
129     if (opt != NBD_OPT_LIST) {
130         error_setg(errp, "Unexpected option type %x expected %x",
131                    opt, NBD_OPT_LIST);
132         return -1;
133     }
134 
135     if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
136         error_setg(errp, "failed to read list option type");
137         return -1;
138     }
139     type = be32_to_cpu(type);
140     if (type == NBD_REP_ERR_UNSUP) {
141         return 0;
142     }
143     if (nbd_handle_reply_err(opt, type, errp) < 0) {
144         return -1;
145     }
146 
147     if (read_sync(ioc, &len, sizeof(len)) != sizeof(len)) {
148         error_setg(errp, "failed to read option length");
149         return -1;
150     }
151     len = be32_to_cpu(len);
152 
153     if (type == NBD_REP_ACK) {
154         if (len != 0) {
155             error_setg(errp, "length too long for option end");
156             return -1;
157         }
158     } else if (type == NBD_REP_SERVER) {
159         if (read_sync(ioc, &namelen, sizeof(namelen)) != sizeof(namelen)) {
160             error_setg(errp, "failed to read option name length");
161             return -1;
162         }
163         namelen = be32_to_cpu(namelen);
164         if (len != (namelen + sizeof(namelen))) {
165             error_setg(errp, "incorrect option mame length");
166             return -1;
167         }
168         if (namelen > 255) {
169             error_setg(errp, "export name length too long %d", namelen);
170             return -1;
171         }
172 
173         *name = g_new0(char, namelen + 1);
174         if (read_sync(ioc, *name, namelen) != namelen) {
175             error_setg(errp, "failed to read export name");
176             g_free(*name);
177             *name = NULL;
178             return -1;
179         }
180         (*name)[namelen] = '\0';
181     } else {
182         error_setg(errp, "Unexpected reply type %x expected %x",
183                    type, NBD_REP_SERVER);
184         return -1;
185     }
186     return 1;
187 }
188 
189 
190 static int nbd_receive_query_exports(QIOChannel *ioc,
191                                      const char *wantname,
192                                      Error **errp)
193 {
194     uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
195     uint32_t opt = cpu_to_be32(NBD_OPT_LIST);
196     uint32_t length = 0;
197     bool foundExport = false;
198 
199     TRACE("Querying export list");
200     if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
201         error_setg(errp, "Failed to send list option magic");
202         return -1;
203     }
204 
205     if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
206         error_setg(errp, "Failed to send list option number");
207         return -1;
208     }
209 
210     if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
211         error_setg(errp, "Failed to send list option length");
212         return -1;
213     }
214 
215     TRACE("Reading available export names");
216     while (1) {
217         char *name = NULL;
218         int ret = nbd_receive_list(ioc, &name, errp);
219 
220         if (ret < 0) {
221             g_free(name);
222             name = NULL;
223             return -1;
224         }
225         if (ret == 0) {
226             /* Server doesn't support export listing, so
227              * we will just assume an export with our
228              * wanted name exists */
229             foundExport = true;
230             break;
231         }
232         if (name == NULL) {
233             TRACE("End of export name list");
234             break;
235         }
236         if (g_str_equal(name, wantname)) {
237             foundExport = true;
238             TRACE("Found desired export name '%s'", name);
239         } else {
240             TRACE("Ignored export name '%s'", name);
241         }
242         g_free(name);
243     }
244 
245     if (!foundExport) {
246         error_setg(errp, "No export with name '%s' available", wantname);
247         return -1;
248     }
249 
250     return 0;
251 }
252 
253 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
254                                         QCryptoTLSCreds *tlscreds,
255                                         const char *hostname, Error **errp)
256 {
257     uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
258     uint32_t opt = cpu_to_be32(NBD_OPT_STARTTLS);
259     uint32_t length = 0;
260     uint32_t type;
261     QIOChannelTLS *tioc;
262     struct NBDTLSHandshakeData data = { 0 };
263 
264     TRACE("Requesting TLS from server");
265     if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
266         error_setg(errp, "Failed to send option magic");
267         return NULL;
268     }
269 
270     if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
271         error_setg(errp, "Failed to send option number");
272         return NULL;
273     }
274 
275     if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
276         error_setg(errp, "Failed to send option length");
277         return NULL;
278     }
279 
280     TRACE("Getting TLS reply from server1");
281     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
282         error_setg(errp, "failed to read option magic");
283         return NULL;
284     }
285     magic = be64_to_cpu(magic);
286     if (magic != NBD_REP_MAGIC) {
287         error_setg(errp, "Unexpected option magic");
288         return NULL;
289     }
290     TRACE("Getting TLS reply from server2");
291     if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
292         error_setg(errp, "failed to read option");
293         return NULL;
294     }
295     opt = be32_to_cpu(opt);
296     if (opt != NBD_OPT_STARTTLS) {
297         error_setg(errp, "Unexpected option type %x expected %x",
298                    opt, NBD_OPT_STARTTLS);
299         return NULL;
300     }
301 
302     TRACE("Getting TLS reply from server");
303     if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
304         error_setg(errp, "failed to read option type");
305         return NULL;
306     }
307     type = be32_to_cpu(type);
308     if (type != NBD_REP_ACK) {
309         error_setg(errp, "Server rejected request to start TLS %x",
310                    type);
311         return NULL;
312     }
313 
314     TRACE("Getting TLS reply from server");
315     if (read_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
316         error_setg(errp, "failed to read option length");
317         return NULL;
318     }
319     length = be32_to_cpu(length);
320     if (length != 0) {
321         error_setg(errp, "Start TLS reponse was not zero %x",
322                    length);
323         return NULL;
324     }
325 
326     TRACE("TLS request approved, setting up TLS");
327     tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
328     if (!tioc) {
329         return NULL;
330     }
331     data.loop = g_main_loop_new(g_main_context_default(), FALSE);
332     TRACE("Starting TLS hanshake");
333     qio_channel_tls_handshake(tioc,
334                               nbd_tls_handshake,
335                               &data,
336                               NULL);
337 
338     if (!data.complete) {
339         g_main_loop_run(data.loop);
340     }
341     g_main_loop_unref(data.loop);
342     if (data.error) {
343         error_propagate(errp, data.error);
344         object_unref(OBJECT(tioc));
345         return NULL;
346     }
347 
348     return QIO_CHANNEL(tioc);
349 }
350 
351 
352 int nbd_receive_negotiate(QIOChannel *ioc, const char *name, uint32_t *flags,
353                           QCryptoTLSCreds *tlscreds, const char *hostname,
354                           QIOChannel **outioc,
355                           off_t *size, Error **errp)
356 {
357     char buf[256];
358     uint64_t magic, s;
359     int rc;
360 
361     TRACE("Receiving negotiation tlscreds=%p hostname=%s.",
362           tlscreds, hostname ? hostname : "<null>");
363 
364     rc = -EINVAL;
365 
366     if (outioc) {
367         *outioc = NULL;
368     }
369     if (tlscreds && !outioc) {
370         error_setg(errp, "Output I/O channel required for TLS");
371         goto fail;
372     }
373 
374     if (read_sync(ioc, buf, 8) != 8) {
375         error_setg(errp, "Failed to read data");
376         goto fail;
377     }
378 
379     buf[8] = '\0';
380     if (strlen(buf) == 0) {
381         error_setg(errp, "Server connection closed unexpectedly");
382         goto fail;
383     }
384 
385     TRACE("Magic is %c%c%c%c%c%c%c%c",
386           qemu_isprint(buf[0]) ? buf[0] : '.',
387           qemu_isprint(buf[1]) ? buf[1] : '.',
388           qemu_isprint(buf[2]) ? buf[2] : '.',
389           qemu_isprint(buf[3]) ? buf[3] : '.',
390           qemu_isprint(buf[4]) ? buf[4] : '.',
391           qemu_isprint(buf[5]) ? buf[5] : '.',
392           qemu_isprint(buf[6]) ? buf[6] : '.',
393           qemu_isprint(buf[7]) ? buf[7] : '.');
394 
395     if (memcmp(buf, "NBDMAGIC", 8) != 0) {
396         error_setg(errp, "Invalid magic received");
397         goto fail;
398     }
399 
400     if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
401         error_setg(errp, "Failed to read magic");
402         goto fail;
403     }
404     magic = be64_to_cpu(magic);
405     TRACE("Magic is 0x%" PRIx64, magic);
406 
407     if (magic == NBD_OPTS_MAGIC) {
408         uint32_t clientflags = 0;
409         uint32_t opt;
410         uint32_t namesize;
411         uint16_t globalflags;
412         uint16_t exportflags;
413         bool fixedNewStyle = false;
414 
415         if (read_sync(ioc, &globalflags, sizeof(globalflags)) !=
416             sizeof(globalflags)) {
417             error_setg(errp, "Failed to read server flags");
418             goto fail;
419         }
420         globalflags = be16_to_cpu(globalflags);
421         *flags = globalflags << 16;
422         TRACE("Global flags are %x", globalflags);
423         if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
424             fixedNewStyle = true;
425             TRACE("Server supports fixed new style");
426             clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
427         }
428         /* client requested flags */
429         clientflags = cpu_to_be32(clientflags);
430         if (write_sync(ioc, &clientflags, sizeof(clientflags)) !=
431             sizeof(clientflags)) {
432             error_setg(errp, "Failed to send clientflags field");
433             goto fail;
434         }
435         if (tlscreds) {
436             if (fixedNewStyle) {
437                 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
438                 if (!*outioc) {
439                     goto fail;
440                 }
441                 ioc = *outioc;
442             } else {
443                 error_setg(errp, "Server does not support STARTTLS");
444                 goto fail;
445             }
446         }
447         if (!name) {
448             TRACE("Using default NBD export name \"\"");
449             name = "";
450         }
451         if (fixedNewStyle) {
452             /* Check our desired export is present in the
453              * server export list. Since NBD_OPT_EXPORT_NAME
454              * cannot return an error message, running this
455              * query gives us good error reporting if the
456              * server required TLS
457              */
458             if (nbd_receive_query_exports(ioc, name, errp) < 0) {
459                 goto fail;
460             }
461         }
462         /* write the export name */
463         magic = cpu_to_be64(magic);
464         if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
465             error_setg(errp, "Failed to send export name magic");
466             goto fail;
467         }
468         opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
469         if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
470             error_setg(errp, "Failed to send export name option number");
471             goto fail;
472         }
473         namesize = cpu_to_be32(strlen(name));
474         if (write_sync(ioc, &namesize, sizeof(namesize)) !=
475             sizeof(namesize)) {
476             error_setg(errp, "Failed to send export name length");
477             goto fail;
478         }
479         if (write_sync(ioc, (char *)name, strlen(name)) != strlen(name)) {
480             error_setg(errp, "Failed to send export name");
481             goto fail;
482         }
483 
484         if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
485             error_setg(errp, "Failed to read export length");
486             goto fail;
487         }
488         *size = be64_to_cpu(s);
489         TRACE("Size is %" PRIu64, *size);
490 
491         if (read_sync(ioc, &exportflags, sizeof(exportflags)) !=
492             sizeof(exportflags)) {
493             error_setg(errp, "Failed to read export flags");
494             goto fail;
495         }
496         exportflags = be16_to_cpu(exportflags);
497         *flags |= exportflags;
498         TRACE("Export flags are %x", exportflags);
499     } else if (magic == NBD_CLIENT_MAGIC) {
500         if (name) {
501             error_setg(errp, "Server does not support export names");
502             goto fail;
503         }
504         if (tlscreds) {
505             error_setg(errp, "Server does not support STARTTLS");
506             goto fail;
507         }
508 
509         if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
510             error_setg(errp, "Failed to read export length");
511             goto fail;
512         }
513         *size = be64_to_cpu(s);
514         TRACE("Size is %" PRIu64, *size);
515 
516         if (read_sync(ioc, flags, sizeof(*flags)) != sizeof(*flags)) {
517             error_setg(errp, "Failed to read export flags");
518             goto fail;
519         }
520         *flags = be32_to_cpup(flags);
521     } else {
522         error_setg(errp, "Bad magic received");
523         goto fail;
524     }
525 
526     if (read_sync(ioc, &buf, 124) != 124) {
527         error_setg(errp, "Failed to read reserved block");
528         goto fail;
529     }
530     rc = 0;
531 
532 fail:
533     return rc;
534 }
535 
536 #ifdef __linux__
537 int nbd_init(int fd, QIOChannelSocket *sioc, uint32_t flags, off_t size)
538 {
539     TRACE("Setting NBD socket");
540 
541     if (ioctl(fd, NBD_SET_SOCK, sioc->fd) < 0) {
542         int serrno = errno;
543         LOG("Failed to set NBD socket");
544         return -serrno;
545     }
546 
547     TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE);
548 
549     if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) {
550         int serrno = errno;
551         LOG("Failed setting NBD block size");
552         return -serrno;
553     }
554 
555     TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE));
556 
557     if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) {
558         int serrno = errno;
559         LOG("Failed setting size (in blocks)");
560         return -serrno;
561     }
562 
563     if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) {
564         if (errno == ENOTTY) {
565             int read_only = (flags & NBD_FLAG_READ_ONLY) != 0;
566             TRACE("Setting readonly attribute");
567 
568             if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
569                 int serrno = errno;
570                 LOG("Failed setting read-only attribute");
571                 return -serrno;
572             }
573         } else {
574             int serrno = errno;
575             LOG("Failed setting flags");
576             return -serrno;
577         }
578     }
579 
580     TRACE("Negotiation ended");
581 
582     return 0;
583 }
584 
585 int nbd_client(int fd)
586 {
587     int ret;
588     int serrno;
589 
590     TRACE("Doing NBD loop");
591 
592     ret = ioctl(fd, NBD_DO_IT);
593     if (ret < 0 && errno == EPIPE) {
594         /* NBD_DO_IT normally returns EPIPE when someone has disconnected
595          * the socket via NBD_DISCONNECT.  We do not want to return 1 in
596          * that case.
597          */
598         ret = 0;
599     }
600     serrno = errno;
601 
602     TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
603 
604     TRACE("Clearing NBD queue");
605     ioctl(fd, NBD_CLEAR_QUE);
606 
607     TRACE("Clearing NBD socket");
608     ioctl(fd, NBD_CLEAR_SOCK);
609 
610     errno = serrno;
611     return ret;
612 }
613 #else
614 int nbd_init(int fd, QIOChannelSocket *ioc, uint32_t flags, off_t size)
615 {
616     return -ENOTSUP;
617 }
618 
619 int nbd_client(int fd)
620 {
621     return -ENOTSUP;
622 }
623 #endif
624 
625 ssize_t nbd_send_request(QIOChannel *ioc, struct nbd_request *request)
626 {
627     uint8_t buf[NBD_REQUEST_SIZE];
628     ssize_t ret;
629 
630     cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC);
631     cpu_to_be32w((uint32_t*)(buf + 4), request->type);
632     cpu_to_be64w((uint64_t*)(buf + 8), request->handle);
633     cpu_to_be64w((uint64_t*)(buf + 16), request->from);
634     cpu_to_be32w((uint32_t*)(buf + 24), request->len);
635 
636     TRACE("Sending request to client: "
637           "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}",
638           request->from, request->len, request->handle, request->type);
639 
640     ret = write_sync(ioc, buf, sizeof(buf));
641     if (ret < 0) {
642         return ret;
643     }
644 
645     if (ret != sizeof(buf)) {
646         LOG("writing to socket failed");
647         return -EINVAL;
648     }
649     return 0;
650 }
651 
652 ssize_t nbd_receive_reply(QIOChannel *ioc, struct nbd_reply *reply)
653 {
654     uint8_t buf[NBD_REPLY_SIZE];
655     uint32_t magic;
656     ssize_t ret;
657 
658     ret = read_sync(ioc, buf, sizeof(buf));
659     if (ret < 0) {
660         return ret;
661     }
662 
663     if (ret != sizeof(buf)) {
664         LOG("read failed");
665         return -EINVAL;
666     }
667 
668     /* Reply
669        [ 0 ..  3]    magic   (NBD_REPLY_MAGIC)
670        [ 4 ..  7]    error   (0 == no error)
671        [ 7 .. 15]    handle
672      */
673 
674     magic = be32_to_cpup((uint32_t*)buf);
675     reply->error  = be32_to_cpup((uint32_t*)(buf + 4));
676     reply->handle = be64_to_cpup((uint64_t*)(buf + 8));
677 
678     reply->error = nbd_errno_to_system_errno(reply->error);
679 
680     TRACE("Got reply: "
681           "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }",
682           magic, reply->error, reply->handle);
683 
684     if (magic != NBD_REPLY_MAGIC) {
685         LOG("invalid magic (got 0x%x)", magic);
686         return -EINVAL;
687     }
688     return 0;
689 }
690 
691