Merge remote-tracking branch 'remotes/ehabkost/tags/x86-pull-request' into staging
[qemu/kevin.git] / nbd / client.c
bloba92f1e227535eb4404bb5681adab13856591910a
1 /*
2 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
4 * Network Block Device Client Side
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.
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.
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/>.
19 #include "qemu/osdep.h"
20 #include "qapi/error.h"
21 #include "nbd-internal.h"
23 static int nbd_errno_to_system_errno(int err)
25 switch (err) {
26 case NBD_SUCCESS:
27 return 0;
28 case NBD_EPERM:
29 return EPERM;
30 case NBD_EIO:
31 return EIO;
32 case NBD_ENOMEM:
33 return ENOMEM;
34 case NBD_ENOSPC:
35 return ENOSPC;
36 default:
37 TRACE("Squashing unexpected error %d to EINVAL", err);
38 /* fallthrough */
39 case NBD_EINVAL:
40 return EINVAL;
44 /* Definitions for opaque data types */
46 static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
48 /* That's all folks */
50 /* Basic flow for negotiation
52 Server Client
53 Negotiate
57 Server Client
58 Negotiate #1
59 Option
60 Negotiate #2
62 ----
64 followed by
66 Server Client
67 Request
68 Response
69 Request
70 Response
71 ...
72 ...
73 Request (type == 2)
78 /* If type represents success, return 1 without further action.
79 * If type represents an error reply, consume the rest of the packet on ioc.
80 * Then return 0 for unsupported (so the client can fall back to
81 * other approaches), or -1 with errp set for other errors.
83 static int nbd_handle_reply_err(QIOChannel *ioc, uint32_t opt, uint32_t type,
84 Error **errp)
86 uint32_t len;
87 char *msg = NULL;
88 int result = -1;
90 if (!(type & (1 << 31))) {
91 return 1;
94 if (read_sync(ioc, &len, sizeof(len)) != sizeof(len)) {
95 error_setg(errp, "failed to read option length");
96 return -1;
98 len = be32_to_cpu(len);
99 if (len) {
100 if (len > NBD_MAX_BUFFER_SIZE) {
101 error_setg(errp, "server's error message is too long");
102 goto cleanup;
104 msg = g_malloc(len + 1);
105 if (read_sync(ioc, msg, len) != len) {
106 error_setg(errp, "failed to read option error message");
107 goto cleanup;
109 msg[len] = '\0';
112 switch (type) {
113 case NBD_REP_ERR_UNSUP:
114 TRACE("server doesn't understand request %" PRIx32
115 ", attempting fallback", opt);
116 result = 0;
117 goto cleanup;
119 case NBD_REP_ERR_POLICY:
120 error_setg(errp, "Denied by server for option %" PRIx32, opt);
121 break;
123 case NBD_REP_ERR_INVALID:
124 error_setg(errp, "Invalid data length for option %" PRIx32, opt);
125 break;
127 case NBD_REP_ERR_TLS_REQD:
128 error_setg(errp, "TLS negotiation required before option %" PRIx32,
129 opt);
130 break;
132 default:
133 error_setg(errp, "Unknown error code when asking for option %" PRIx32,
134 opt);
135 break;
138 if (msg) {
139 error_append_hint(errp, "%s\n", msg);
142 cleanup:
143 g_free(msg);
144 return result;
147 static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp)
149 uint64_t magic;
150 uint32_t opt;
151 uint32_t type;
152 uint32_t len;
153 uint32_t namelen;
154 int error;
156 *name = NULL;
157 if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
158 error_setg(errp, "failed to read list option magic");
159 return -1;
161 magic = be64_to_cpu(magic);
162 if (magic != NBD_REP_MAGIC) {
163 error_setg(errp, "Unexpected option list magic");
164 return -1;
166 if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
167 error_setg(errp, "failed to read list option");
168 return -1;
170 opt = be32_to_cpu(opt);
171 if (opt != NBD_OPT_LIST) {
172 error_setg(errp, "Unexpected option type %" PRIx32 " expected %x",
173 opt, NBD_OPT_LIST);
174 return -1;
177 if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
178 error_setg(errp, "failed to read list option type");
179 return -1;
181 type = be32_to_cpu(type);
182 error = nbd_handle_reply_err(ioc, opt, type, errp);
183 if (error <= 0) {
184 return error;
187 if (read_sync(ioc, &len, sizeof(len)) != sizeof(len)) {
188 error_setg(errp, "failed to read option length");
189 return -1;
191 len = be32_to_cpu(len);
193 if (type == NBD_REP_ACK) {
194 if (len != 0) {
195 error_setg(errp, "length too long for option end");
196 return -1;
198 } else if (type == NBD_REP_SERVER) {
199 if (len < sizeof(namelen) || len > NBD_MAX_BUFFER_SIZE) {
200 error_setg(errp, "incorrect option length");
201 return -1;
203 if (read_sync(ioc, &namelen, sizeof(namelen)) != sizeof(namelen)) {
204 error_setg(errp, "failed to read option name length");
205 return -1;
207 namelen = be32_to_cpu(namelen);
208 len -= sizeof(namelen);
209 if (len < namelen) {
210 error_setg(errp, "incorrect option name length");
211 return -1;
213 if (namelen > NBD_MAX_NAME_SIZE) {
214 error_setg(errp, "export name length too long %" PRIu32, namelen);
215 return -1;
218 *name = g_new0(char, namelen + 1);
219 if (read_sync(ioc, *name, namelen) != namelen) {
220 error_setg(errp, "failed to read export name");
221 g_free(*name);
222 *name = NULL;
223 return -1;
225 (*name)[namelen] = '\0';
226 len -= namelen;
227 if (len) {
228 char *buf = g_malloc(len + 1);
229 if (read_sync(ioc, buf, len) != len) {
230 error_setg(errp, "failed to read export description");
231 g_free(*name);
232 g_free(buf);
233 *name = NULL;
234 return -1;
236 buf[len] = '\0';
237 TRACE("Ignoring export description: %s", buf);
238 g_free(buf);
240 } else {
241 error_setg(errp, "Unexpected reply type %" PRIx32 " expected %x",
242 type, NBD_REP_SERVER);
243 return -1;
245 return 1;
249 static int nbd_receive_query_exports(QIOChannel *ioc,
250 const char *wantname,
251 Error **errp)
253 uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
254 uint32_t opt = cpu_to_be32(NBD_OPT_LIST);
255 uint32_t length = 0;
256 bool foundExport = false;
258 TRACE("Querying export list");
259 if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
260 error_setg(errp, "Failed to send list option magic");
261 return -1;
264 if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
265 error_setg(errp, "Failed to send list option number");
266 return -1;
269 if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
270 error_setg(errp, "Failed to send list option length");
271 return -1;
274 TRACE("Reading available export names");
275 while (1) {
276 char *name = NULL;
277 int ret = nbd_receive_list(ioc, &name, errp);
279 if (ret < 0) {
280 g_free(name);
281 name = NULL;
282 return -1;
284 if (ret == 0) {
285 /* Server doesn't support export listing, so
286 * we will just assume an export with our
287 * wanted name exists */
288 foundExport = true;
289 break;
291 if (name == NULL) {
292 TRACE("End of export name list");
293 break;
295 if (g_str_equal(name, wantname)) {
296 foundExport = true;
297 TRACE("Found desired export name '%s'", name);
298 } else {
299 TRACE("Ignored export name '%s'", name);
301 g_free(name);
304 if (!foundExport) {
305 error_setg(errp, "No export with name '%s' available", wantname);
306 return -1;
309 return 0;
312 static QIOChannel *nbd_receive_starttls(QIOChannel *ioc,
313 QCryptoTLSCreds *tlscreds,
314 const char *hostname, Error **errp)
316 uint64_t magic = cpu_to_be64(NBD_OPTS_MAGIC);
317 uint32_t opt = cpu_to_be32(NBD_OPT_STARTTLS);
318 uint32_t length = 0;
319 uint32_t type;
320 QIOChannelTLS *tioc;
321 struct NBDTLSHandshakeData data = { 0 };
323 TRACE("Requesting TLS from server");
324 if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
325 error_setg(errp, "Failed to send option magic");
326 return NULL;
329 if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
330 error_setg(errp, "Failed to send option number");
331 return NULL;
334 if (write_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
335 error_setg(errp, "Failed to send option length");
336 return NULL;
339 TRACE("Getting TLS reply from server1");
340 if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
341 error_setg(errp, "failed to read option magic");
342 return NULL;
344 magic = be64_to_cpu(magic);
345 if (magic != NBD_REP_MAGIC) {
346 error_setg(errp, "Unexpected option magic");
347 return NULL;
349 TRACE("Getting TLS reply from server2");
350 if (read_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
351 error_setg(errp, "failed to read option");
352 return NULL;
354 opt = be32_to_cpu(opt);
355 if (opt != NBD_OPT_STARTTLS) {
356 error_setg(errp, "Unexpected option type %" PRIx32 " expected %x",
357 opt, NBD_OPT_STARTTLS);
358 return NULL;
361 TRACE("Getting TLS reply from server");
362 if (read_sync(ioc, &type, sizeof(type)) != sizeof(type)) {
363 error_setg(errp, "failed to read option type");
364 return NULL;
366 type = be32_to_cpu(type);
367 if (type != NBD_REP_ACK) {
368 error_setg(errp, "Server rejected request to start TLS %" PRIx32,
369 type);
370 return NULL;
373 TRACE("Getting TLS reply from server");
374 if (read_sync(ioc, &length, sizeof(length)) != sizeof(length)) {
375 error_setg(errp, "failed to read option length");
376 return NULL;
378 length = be32_to_cpu(length);
379 if (length != 0) {
380 error_setg(errp, "Start TLS response was not zero %" PRIu32,
381 length);
382 return NULL;
385 TRACE("TLS request approved, setting up TLS");
386 tioc = qio_channel_tls_new_client(ioc, tlscreds, hostname, errp);
387 if (!tioc) {
388 return NULL;
390 data.loop = g_main_loop_new(g_main_context_default(), FALSE);
391 TRACE("Starting TLS handshake");
392 qio_channel_tls_handshake(tioc,
393 nbd_tls_handshake,
394 &data,
395 NULL);
397 if (!data.complete) {
398 g_main_loop_run(data.loop);
400 g_main_loop_unref(data.loop);
401 if (data.error) {
402 error_propagate(errp, data.error);
403 object_unref(OBJECT(tioc));
404 return NULL;
407 return QIO_CHANNEL(tioc);
411 int nbd_receive_negotiate(QIOChannel *ioc, const char *name, uint16_t *flags,
412 QCryptoTLSCreds *tlscreds, const char *hostname,
413 QIOChannel **outioc,
414 off_t *size, Error **errp)
416 char buf[256];
417 uint64_t magic, s;
418 int rc;
420 TRACE("Receiving negotiation tlscreds=%p hostname=%s.",
421 tlscreds, hostname ? hostname : "<null>");
423 rc = -EINVAL;
425 if (outioc) {
426 *outioc = NULL;
428 if (tlscreds && !outioc) {
429 error_setg(errp, "Output I/O channel required for TLS");
430 goto fail;
433 if (read_sync(ioc, buf, 8) != 8) {
434 error_setg(errp, "Failed to read data");
435 goto fail;
438 buf[8] = '\0';
439 if (strlen(buf) == 0) {
440 error_setg(errp, "Server connection closed unexpectedly");
441 goto fail;
444 TRACE("Magic is %c%c%c%c%c%c%c%c",
445 qemu_isprint(buf[0]) ? buf[0] : '.',
446 qemu_isprint(buf[1]) ? buf[1] : '.',
447 qemu_isprint(buf[2]) ? buf[2] : '.',
448 qemu_isprint(buf[3]) ? buf[3] : '.',
449 qemu_isprint(buf[4]) ? buf[4] : '.',
450 qemu_isprint(buf[5]) ? buf[5] : '.',
451 qemu_isprint(buf[6]) ? buf[6] : '.',
452 qemu_isprint(buf[7]) ? buf[7] : '.');
454 if (memcmp(buf, "NBDMAGIC", 8) != 0) {
455 error_setg(errp, "Invalid magic received");
456 goto fail;
459 if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
460 error_setg(errp, "Failed to read magic");
461 goto fail;
463 magic = be64_to_cpu(magic);
464 TRACE("Magic is 0x%" PRIx64, magic);
466 if (magic == NBD_OPTS_MAGIC) {
467 uint32_t clientflags = 0;
468 uint32_t opt;
469 uint32_t namesize;
470 uint16_t globalflags;
471 bool fixedNewStyle = false;
473 if (read_sync(ioc, &globalflags, sizeof(globalflags)) !=
474 sizeof(globalflags)) {
475 error_setg(errp, "Failed to read server flags");
476 goto fail;
478 globalflags = be16_to_cpu(globalflags);
479 TRACE("Global flags are %" PRIx32, globalflags);
480 if (globalflags & NBD_FLAG_FIXED_NEWSTYLE) {
481 fixedNewStyle = true;
482 TRACE("Server supports fixed new style");
483 clientflags |= NBD_FLAG_C_FIXED_NEWSTYLE;
485 /* client requested flags */
486 clientflags = cpu_to_be32(clientflags);
487 if (write_sync(ioc, &clientflags, sizeof(clientflags)) !=
488 sizeof(clientflags)) {
489 error_setg(errp, "Failed to send clientflags field");
490 goto fail;
492 if (tlscreds) {
493 if (fixedNewStyle) {
494 *outioc = nbd_receive_starttls(ioc, tlscreds, hostname, errp);
495 if (!*outioc) {
496 goto fail;
498 ioc = *outioc;
499 } else {
500 error_setg(errp, "Server does not support STARTTLS");
501 goto fail;
504 if (!name) {
505 TRACE("Using default NBD export name \"\"");
506 name = "";
508 if (fixedNewStyle) {
509 /* Check our desired export is present in the
510 * server export list. Since NBD_OPT_EXPORT_NAME
511 * cannot return an error message, running this
512 * query gives us good error reporting if the
513 * server required TLS
515 if (nbd_receive_query_exports(ioc, name, errp) < 0) {
516 goto fail;
519 /* write the export name */
520 magic = cpu_to_be64(magic);
521 if (write_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
522 error_setg(errp, "Failed to send export name magic");
523 goto fail;
525 opt = cpu_to_be32(NBD_OPT_EXPORT_NAME);
526 if (write_sync(ioc, &opt, sizeof(opt)) != sizeof(opt)) {
527 error_setg(errp, "Failed to send export name option number");
528 goto fail;
530 namesize = cpu_to_be32(strlen(name));
531 if (write_sync(ioc, &namesize, sizeof(namesize)) !=
532 sizeof(namesize)) {
533 error_setg(errp, "Failed to send export name length");
534 goto fail;
536 if (write_sync(ioc, (char *)name, strlen(name)) != strlen(name)) {
537 error_setg(errp, "Failed to send export name");
538 goto fail;
541 if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
542 error_setg(errp, "Failed to read export length");
543 goto fail;
545 *size = be64_to_cpu(s);
547 if (read_sync(ioc, flags, sizeof(*flags)) != sizeof(*flags)) {
548 error_setg(errp, "Failed to read export flags");
549 goto fail;
551 be16_to_cpus(flags);
552 } else if (magic == NBD_CLIENT_MAGIC) {
553 uint32_t oldflags;
555 if (name) {
556 error_setg(errp, "Server does not support export names");
557 goto fail;
559 if (tlscreds) {
560 error_setg(errp, "Server does not support STARTTLS");
561 goto fail;
564 if (read_sync(ioc, &s, sizeof(s)) != sizeof(s)) {
565 error_setg(errp, "Failed to read export length");
566 goto fail;
568 *size = be64_to_cpu(s);
569 TRACE("Size is %" PRIu64, *size);
571 if (read_sync(ioc, &oldflags, sizeof(oldflags)) != sizeof(oldflags)) {
572 error_setg(errp, "Failed to read export flags");
573 goto fail;
575 be32_to_cpus(&oldflags);
576 if (oldflags & ~0xffff) {
577 error_setg(errp, "Unexpected export flags %0x" PRIx32, oldflags);
578 goto fail;
580 *flags = oldflags;
581 } else {
582 error_setg(errp, "Bad magic received");
583 goto fail;
586 TRACE("Size is %" PRIu64 ", export flags %" PRIx16, *size, *flags);
587 if (read_sync(ioc, &buf, 124) != 124) {
588 error_setg(errp, "Failed to read reserved block");
589 goto fail;
591 rc = 0;
593 fail:
594 return rc;
597 #ifdef __linux__
598 int nbd_init(int fd, QIOChannelSocket *sioc, uint16_t flags, off_t size)
600 unsigned long sectors = size / BDRV_SECTOR_SIZE;
601 if (size / BDRV_SECTOR_SIZE != sectors) {
602 LOG("Export size %lld too large for 32-bit kernel", (long long) size);
603 return -E2BIG;
606 TRACE("Setting NBD socket");
608 if (ioctl(fd, NBD_SET_SOCK, (unsigned long) sioc->fd) < 0) {
609 int serrno = errno;
610 LOG("Failed to set NBD socket");
611 return -serrno;
614 TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE);
616 if (ioctl(fd, NBD_SET_BLKSIZE, (unsigned long)BDRV_SECTOR_SIZE) < 0) {
617 int serrno = errno;
618 LOG("Failed setting NBD block size");
619 return -serrno;
622 TRACE("Setting size to %lu block(s)", sectors);
623 if (size % BDRV_SECTOR_SIZE) {
624 TRACE("Ignoring trailing %d bytes of export",
625 (int) (size % BDRV_SECTOR_SIZE));
628 if (ioctl(fd, NBD_SET_SIZE_BLOCKS, sectors) < 0) {
629 int serrno = errno;
630 LOG("Failed setting size (in blocks)");
631 return -serrno;
634 if (ioctl(fd, NBD_SET_FLAGS, (unsigned long) flags) < 0) {
635 if (errno == ENOTTY) {
636 int read_only = (flags & NBD_FLAG_READ_ONLY) != 0;
637 TRACE("Setting readonly attribute");
639 if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) {
640 int serrno = errno;
641 LOG("Failed setting read-only attribute");
642 return -serrno;
644 } else {
645 int serrno = errno;
646 LOG("Failed setting flags");
647 return -serrno;
651 TRACE("Negotiation ended");
653 return 0;
656 int nbd_client(int fd)
658 int ret;
659 int serrno;
661 TRACE("Doing NBD loop");
663 ret = ioctl(fd, NBD_DO_IT);
664 if (ret < 0 && errno == EPIPE) {
665 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
666 * the socket via NBD_DISCONNECT. We do not want to return 1 in
667 * that case.
669 ret = 0;
671 serrno = errno;
673 TRACE("NBD loop returned %d: %s", ret, strerror(serrno));
675 TRACE("Clearing NBD queue");
676 ioctl(fd, NBD_CLEAR_QUE);
678 TRACE("Clearing NBD socket");
679 ioctl(fd, NBD_CLEAR_SOCK);
681 errno = serrno;
682 return ret;
685 int nbd_disconnect(int fd)
687 ioctl(fd, NBD_CLEAR_QUE);
688 ioctl(fd, NBD_DISCONNECT);
689 ioctl(fd, NBD_CLEAR_SOCK);
690 return 0;
693 #else
694 int nbd_init(int fd, QIOChannelSocket *ioc, uint16_t flags, off_t size)
696 return -ENOTSUP;
699 int nbd_client(int fd)
701 return -ENOTSUP;
703 int nbd_disconnect(int fd)
705 return -ENOTSUP;
707 #endif
709 ssize_t nbd_send_request(QIOChannel *ioc, struct nbd_request *request)
711 uint8_t buf[NBD_REQUEST_SIZE];
712 ssize_t ret;
714 TRACE("Sending request to server: "
715 "{ .from = %" PRIu64", .len = %" PRIu32 ", .handle = %" PRIu64
716 ", .type=%" PRIu32 " }",
717 request->from, request->len, request->handle, request->type);
719 stl_be_p(buf, NBD_REQUEST_MAGIC);
720 stl_be_p(buf + 4, request->type);
721 stq_be_p(buf + 8, request->handle);
722 stq_be_p(buf + 16, request->from);
723 stl_be_p(buf + 24, request->len);
725 ret = write_sync(ioc, buf, sizeof(buf));
726 if (ret < 0) {
727 return ret;
730 if (ret != sizeof(buf)) {
731 LOG("writing to socket failed");
732 return -EINVAL;
734 return 0;
737 ssize_t nbd_receive_reply(QIOChannel *ioc, struct nbd_reply *reply)
739 uint8_t buf[NBD_REPLY_SIZE];
740 uint32_t magic;
741 ssize_t ret;
743 ret = read_sync(ioc, buf, sizeof(buf));
744 if (ret < 0) {
745 return ret;
748 if (ret != sizeof(buf)) {
749 LOG("read failed");
750 return -EINVAL;
753 /* Reply
754 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
755 [ 4 .. 7] error (0 == no error)
756 [ 7 .. 15] handle
759 magic = ldl_be_p(buf);
760 reply->error = ldl_be_p(buf + 4);
761 reply->handle = ldq_be_p(buf + 8);
763 reply->error = nbd_errno_to_system_errno(reply->error);
765 TRACE("Got reply: { magic = 0x%" PRIx32 ", .error = % " PRId32
766 ", handle = %" PRIu64" }",
767 magic, reply->error, reply->handle);
769 if (magic != NBD_REPLY_MAGIC) {
770 LOG("invalid magic (got 0x%" PRIx32 ")", magic);
771 return -EINVAL;
773 return 0;