+3 -2

MAINTAINERS

··· 1116 1116 Network Block Device (NBD) 1117 1117 M: Paolo Bonzini <pbonzini@redhat.com> 1118 1118 S: Odd Fixes 1119 1119 - F: block/nbd.c 1120 1120 - F: nbd.* 1119 1119 + F: block/nbd* 1120 1120 + F: nbd/ 1121 1121 + F: include/block/nbd* 1121 1122 F: qemu-nbd.c 1122 1123 T: git git://github.com/bonzini/qemu.git nbd-next 1123 1124

+2 -1

Makefile.objs

··· 8 8 # block-obj-y is code used by both qemu system emulation and qemu-img 9 9 10 10 block-obj-y = async.o thread-pool.o 11 11 - block-obj-y += nbd.o block.o blockjob.o 11 11 + block-obj-y += nbd/ 12 12 + block-obj-y += block.o blockjob.o 12 13 block-obj-y += main-loop.o iohandler.o qemu-timer.o 13 14 block-obj-$(CONFIG_POSIX) += aio-posix.o 14 15 block-obj-$(CONFIG_WIN32) += aio-win32.o

+2 -449

nbd.c nbd/server.c

··· 1 1 /* 2 2 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> 3 3 * 4 4 - * Network Block Device 4 4 + * Network Block Device Server Side 5 5 * 6 6 * This program is free software; you can redistribute it and/or modify 7 7 * it under the terms of the GNU General Public License as published by ··· 16 16 * along with this program; if not, see <http://www.gnu.org/licenses/>. 17 17 */ 18 18 19 19 - #include "block/nbd.h" 20 20 - #include "sysemu/block-backend.h" 21 21 - 22 22 - #include "qemu/coroutine.h" 23 23 - 24 24 - #include <errno.h> 25 25 - #include <string.h> 26 26 - #ifndef _WIN32 27 27 - #include <sys/ioctl.h> 28 28 - #endif 29 29 - #if defined(__sun__) || defined(__HAIKU__) 30 30 - #include <sys/ioccom.h> 31 31 - #endif 32 32 - #include <ctype.h> 33 33 - #include <inttypes.h> 34 34 - 35 35 - #ifdef __linux__ 36 36 - #include <linux/fs.h> 37 37 - #endif 38 38 - 39 39 - #include "qemu/sockets.h" 40 40 - #include "qemu/queue.h" 41 41 - #include "qemu/main-loop.h" 42 42 - 43 43 - //#define DEBUG_NBD 44 44 - 45 45 - #ifdef DEBUG_NBD 46 46 - #define TRACE(msg, ...) do { \ 47 47 - LOG(msg, ## __VA_ARGS__); \ 48 48 - } while(0) 49 49 - #else 50 50 - #define TRACE(msg, ...) \ 51 51 - do { } while (0) 52 52 - #endif 53 53 - 54 54 - #define LOG(msg, ...) do { \ 55 55 - fprintf(stderr, "%s:%s():L%d: " msg "\n", \ 56 56 - __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \ 57 57 - } while(0) 58 58 - 59 59 - /* This is all part of the "official" NBD API. 60 60 - * 61 61 - * The most up-to-date documentation is available at: 62 62 - * https://github.com/yoe/nbd/blob/master/doc/proto.txt 63 63 - */ 64 64 - 65 65 - #define NBD_REQUEST_SIZE (4 + 4 + 8 + 8 + 4) 66 66 - #define NBD_REPLY_SIZE (4 + 4 + 8) 67 67 - #define NBD_REQUEST_MAGIC 0x25609513 68 68 - #define NBD_REPLY_MAGIC 0x67446698 69 69 - #define NBD_OPTS_MAGIC 0x49484156454F5054LL 70 70 - #define NBD_CLIENT_MAGIC 0x0000420281861253LL 71 71 - #define NBD_REP_MAGIC 0x3e889045565a9LL 72 72 - 73 73 - #define NBD_SET_SOCK _IO(0xab, 0) 74 74 - #define NBD_SET_BLKSIZE _IO(0xab, 1) 75 75 - #define NBD_SET_SIZE _IO(0xab, 2) 76 76 - #define NBD_DO_IT _IO(0xab, 3) 77 77 - #define NBD_CLEAR_SOCK _IO(0xab, 4) 78 78 - #define NBD_CLEAR_QUE _IO(0xab, 5) 79 79 - #define NBD_PRINT_DEBUG _IO(0xab, 6) 80 80 - #define NBD_SET_SIZE_BLOCKS _IO(0xab, 7) 81 81 - #define NBD_DISCONNECT _IO(0xab, 8) 82 82 - #define NBD_SET_TIMEOUT _IO(0xab, 9) 83 83 - #define NBD_SET_FLAGS _IO(0xab, 10) 84 84 - 85 85 - #define NBD_OPT_EXPORT_NAME (1) 86 86 - #define NBD_OPT_ABORT (2) 87 87 - #define NBD_OPT_LIST (3) 88 88 - 89 89 - /* NBD errors are based on errno numbers, so there is a 1:1 mapping, 90 90 - * but only a limited set of errno values is specified in the protocol. 91 91 - * Everything else is squashed to EINVAL. 92 92 - */ 93 93 - #define NBD_SUCCESS 0 94 94 - #define NBD_EPERM 1 95 95 - #define NBD_EIO 5 96 96 - #define NBD_ENOMEM 12 97 97 - #define NBD_EINVAL 22 98 98 - #define NBD_ENOSPC 28 19 19 + #include "nbd-internal.h" 99 20 100 21 static int system_errno_to_nbd_errno(int err) 101 22 { ··· 120 41 } 121 42 } 122 43 123 123 - static int nbd_errno_to_system_errno(int err) 124 124 - { 125 125 - switch (err) { 126 126 - case NBD_SUCCESS: 127 127 - return 0; 128 128 - case NBD_EPERM: 129 129 - return EPERM; 130 130 - case NBD_EIO: 131 131 - return EIO; 132 132 - case NBD_ENOMEM: 133 133 - return ENOMEM; 134 134 - case NBD_ENOSPC: 135 135 - return ENOSPC; 136 136 - case NBD_EINVAL: 137 137 - default: 138 138 - return EINVAL; 139 139 - } 140 140 - } 141 141 - 142 44 /* Definitions for opaque data types */ 143 45 144 46 typedef struct NBDRequest NBDRequest; ··· 191 93 static void nbd_unset_handlers(NBDClient *client); 192 94 static void nbd_update_can_read(NBDClient *client); 193 95 194 194 - ssize_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read) 195 195 - { 196 196 - size_t offset = 0; 197 197 - int err; 198 198 - 199 199 - if (qemu_in_coroutine()) { 200 200 - if (do_read) { 201 201 - return qemu_co_recv(fd, buffer, size); 202 202 - } else { 203 203 - return qemu_co_send(fd, buffer, size); 204 204 - } 205 205 - } 206 206 - 207 207 - while (offset < size) { 208 208 - ssize_t len; 209 209 - 210 210 - if (do_read) { 211 211 - len = qemu_recv(fd, buffer + offset, size - offset, 0); 212 212 - } else { 213 213 - len = send(fd, buffer + offset, size - offset, 0); 214 214 - } 215 215 - 216 216 - if (len < 0) { 217 217 - err = socket_error(); 218 218 - 219 219 - /* recoverable error */ 220 220 - if (err == EINTR || (offset > 0 && (err == EAGAIN || err == EWOULDBLOCK))) { 221 221 - continue; 222 222 - } 223 223 - 224 224 - /* unrecoverable error */ 225 225 - return -err; 226 226 - } 227 227 - 228 228 - /* eof */ 229 229 - if (len == 0) { 230 230 - break; 231 231 - } 232 232 - 233 233 - offset += len; 234 234 - } 235 235 - 236 236 - return offset; 237 237 - } 238 238 - 239 239 - static ssize_t read_sync(int fd, void *buffer, size_t size) 240 240 - { 241 241 - /* Sockets are kept in blocking mode in the negotiation phase. After 242 242 - * that, a non-readable socket simply means that another thread stole 243 243 - * our request/reply. Synchronization is done with recv_coroutine, so 244 244 - * that this is coroutine-safe. 245 245 - */ 246 246 - return nbd_wr_sync(fd, buffer, size, true); 247 247 - } 248 248 - 249 96 static ssize_t drop_sync(int fd, size_t size) 250 97 { 251 98 ssize_t ret, dropped = size; ··· 264 111 265 112 g_free(buffer); 266 113 return dropped; 267 267 - } 268 268 - 269 269 - static ssize_t write_sync(int fd, void *buffer, size_t size) 270 270 - { 271 271 - int ret; 272 272 - do { 273 273 - /* For writes, we do expect the socket to be writable. */ 274 274 - ret = nbd_wr_sync(fd, buffer, size, false); 275 275 - } while (ret == -EAGAIN); 276 276 - return ret; 277 114 } 278 115 279 116 /* Basic flow for negotiation ··· 579 416 return rc; 580 417 } 581 418 582 582 - int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags, 583 583 - off_t *size, Error **errp) 584 584 - { 585 585 - char buf[256]; 586 586 - uint64_t magic, s; 587 587 - uint16_t tmp; 588 588 - int rc; 589 589 - 590 590 - TRACE("Receiving negotiation."); 591 591 - 592 592 - rc = -EINVAL; 593 593 - 594 594 - if (read_sync(csock, buf, 8) != 8) { 595 595 - error_setg(errp, "Failed to read data"); 596 596 - goto fail; 597 597 - } 598 598 - 599 599 - buf[8] = '\0'; 600 600 - if (strlen(buf) == 0) { 601 601 - error_setg(errp, "Server connection closed unexpectedly"); 602 602 - goto fail; 603 603 - } 604 604 - 605 605 - TRACE("Magic is %c%c%c%c%c%c%c%c", 606 606 - qemu_isprint(buf[0]) ? buf[0] : '.', 607 607 - qemu_isprint(buf[1]) ? buf[1] : '.', 608 608 - qemu_isprint(buf[2]) ? buf[2] : '.', 609 609 - qemu_isprint(buf[3]) ? buf[3] : '.', 610 610 - qemu_isprint(buf[4]) ? buf[4] : '.', 611 611 - qemu_isprint(buf[5]) ? buf[5] : '.', 612 612 - qemu_isprint(buf[6]) ? buf[6] : '.', 613 613 - qemu_isprint(buf[7]) ? buf[7] : '.'); 614 614 - 615 615 - if (memcmp(buf, "NBDMAGIC", 8) != 0) { 616 616 - error_setg(errp, "Invalid magic received"); 617 617 - goto fail; 618 618 - } 619 619 - 620 620 - if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) { 621 621 - error_setg(errp, "Failed to read magic"); 622 622 - goto fail; 623 623 - } 624 624 - magic = be64_to_cpu(magic); 625 625 - TRACE("Magic is 0x%" PRIx64, magic); 626 626 - 627 627 - if (name) { 628 628 - uint32_t reserved = 0; 629 629 - uint32_t opt; 630 630 - uint32_t namesize; 631 631 - 632 632 - TRACE("Checking magic (opts_magic)"); 633 633 - if (magic != NBD_OPTS_MAGIC) { 634 634 - if (magic == NBD_CLIENT_MAGIC) { 635 635 - error_setg(errp, "Server does not support export names"); 636 636 - } else { 637 637 - error_setg(errp, "Bad magic received"); 638 638 - } 639 639 - goto fail; 640 640 - } 641 641 - if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) { 642 642 - error_setg(errp, "Failed to read server flags"); 643 643 - goto fail; 644 644 - } 645 645 - *flags = be16_to_cpu(tmp) << 16; 646 646 - /* reserved for future use */ 647 647 - if (write_sync(csock, &reserved, sizeof(reserved)) != 648 648 - sizeof(reserved)) { 649 649 - error_setg(errp, "Failed to read reserved field"); 650 650 - goto fail; 651 651 - } 652 652 - /* write the export name */ 653 653 - magic = cpu_to_be64(magic); 654 654 - if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) { 655 655 - error_setg(errp, "Failed to send export name magic"); 656 656 - goto fail; 657 657 - } 658 658 - opt = cpu_to_be32(NBD_OPT_EXPORT_NAME); 659 659 - if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) { 660 660 - error_setg(errp, "Failed to send export name option number"); 661 661 - goto fail; 662 662 - } 663 663 - namesize = cpu_to_be32(strlen(name)); 664 664 - if (write_sync(csock, &namesize, sizeof(namesize)) != 665 665 - sizeof(namesize)) { 666 666 - error_setg(errp, "Failed to send export name length"); 667 667 - goto fail; 668 668 - } 669 669 - if (write_sync(csock, (char*)name, strlen(name)) != strlen(name)) { 670 670 - error_setg(errp, "Failed to send export name"); 671 671 - goto fail; 672 672 - } 673 673 - } else { 674 674 - TRACE("Checking magic (cli_magic)"); 675 675 - 676 676 - if (magic != NBD_CLIENT_MAGIC) { 677 677 - if (magic == NBD_OPTS_MAGIC) { 678 678 - error_setg(errp, "Server requires an export name"); 679 679 - } else { 680 680 - error_setg(errp, "Bad magic received"); 681 681 - } 682 682 - goto fail; 683 683 - } 684 684 - } 685 685 - 686 686 - if (read_sync(csock, &s, sizeof(s)) != sizeof(s)) { 687 687 - error_setg(errp, "Failed to read export length"); 688 688 - goto fail; 689 689 - } 690 690 - *size = be64_to_cpu(s); 691 691 - TRACE("Size is %" PRIu64, *size); 692 692 - 693 693 - if (!name) { 694 694 - if (read_sync(csock, flags, sizeof(*flags)) != sizeof(*flags)) { 695 695 - error_setg(errp, "Failed to read export flags"); 696 696 - goto fail; 697 697 - } 698 698 - *flags = be32_to_cpup(flags); 699 699 - } else { 700 700 - if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) { 701 701 - error_setg(errp, "Failed to read export flags"); 702 702 - goto fail; 703 703 - } 704 704 - *flags |= be16_to_cpu(tmp); 705 705 - } 706 706 - if (read_sync(csock, &buf, 124) != 124) { 707 707 - error_setg(errp, "Failed to read reserved block"); 708 708 - goto fail; 709 709 - } 710 710 - rc = 0; 711 711 - 712 712 - fail: 713 713 - return rc; 714 714 - } 715 715 - 716 419 #ifdef __linux__ 717 717 - int nbd_init(int fd, int csock, uint32_t flags, off_t size) 718 718 - { 719 719 - TRACE("Setting NBD socket"); 720 720 - 721 721 - if (ioctl(fd, NBD_SET_SOCK, csock) < 0) { 722 722 - int serrno = errno; 723 723 - LOG("Failed to set NBD socket"); 724 724 - return -serrno; 725 725 - } 726 726 - 727 727 - TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE); 728 728 - 729 729 - if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) { 730 730 - int serrno = errno; 731 731 - LOG("Failed setting NBD block size"); 732 732 - return -serrno; 733 733 - } 734 734 - 735 735 - TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE)); 736 736 - 737 737 - if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) { 738 738 - int serrno = errno; 739 739 - LOG("Failed setting size (in blocks)"); 740 740 - return -serrno; 741 741 - } 742 742 - 743 743 - if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) { 744 744 - if (errno == ENOTTY) { 745 745 - int read_only = (flags & NBD_FLAG_READ_ONLY) != 0; 746 746 - TRACE("Setting readonly attribute"); 747 747 - 748 748 - if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) { 749 749 - int serrno = errno; 750 750 - LOG("Failed setting read-only attribute"); 751 751 - return -serrno; 752 752 - } 753 753 - } else { 754 754 - int serrno = errno; 755 755 - LOG("Failed setting flags"); 756 756 - return -serrno; 757 757 - } 758 758 - } 759 759 - 760 760 - TRACE("Negotiation ended"); 761 761 - 762 762 - return 0; 763 763 - } 764 420 765 421 int nbd_disconnect(int fd) 766 422 { ··· 770 426 return 0; 771 427 } 772 428 773 773 - int nbd_client(int fd) 774 774 - { 775 775 - int ret; 776 776 - int serrno; 777 777 - 778 778 - TRACE("Doing NBD loop"); 779 779 - 780 780 - ret = ioctl(fd, NBD_DO_IT); 781 781 - if (ret < 0 && errno == EPIPE) { 782 782 - /* NBD_DO_IT normally returns EPIPE when someone has disconnected 783 783 - * the socket via NBD_DISCONNECT. We do not want to return 1 in 784 784 - * that case. 785 785 - */ 786 786 - ret = 0; 787 787 - } 788 788 - serrno = errno; 789 789 - 790 790 - TRACE("NBD loop returned %d: %s", ret, strerror(serrno)); 791 791 - 792 792 - TRACE("Clearing NBD queue"); 793 793 - ioctl(fd, NBD_CLEAR_QUE); 794 794 - 795 795 - TRACE("Clearing NBD socket"); 796 796 - ioctl(fd, NBD_CLEAR_SOCK); 797 797 - 798 798 - errno = serrno; 799 799 - return ret; 800 800 - } 801 429 #else 802 802 - int nbd_init(int fd, int csock, uint32_t flags, off_t size) 803 803 - { 804 804 - return -ENOTSUP; 805 805 - } 806 430 807 431 int nbd_disconnect(int fd) 808 432 { 809 433 return -ENOTSUP; 810 434 } 811 811 - 812 812 - int nbd_client(int fd) 813 813 - { 814 814 - return -ENOTSUP; 815 815 - } 816 435 #endif 817 436 818 818 - ssize_t nbd_send_request(int csock, struct nbd_request *request) 819 819 - { 820 820 - uint8_t buf[NBD_REQUEST_SIZE]; 821 821 - ssize_t ret; 822 822 - 823 823 - cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC); 824 824 - cpu_to_be32w((uint32_t*)(buf + 4), request->type); 825 825 - cpu_to_be64w((uint64_t*)(buf + 8), request->handle); 826 826 - cpu_to_be64w((uint64_t*)(buf + 16), request->from); 827 827 - cpu_to_be32w((uint32_t*)(buf + 24), request->len); 828 828 - 829 829 - TRACE("Sending request to client: " 830 830 - "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}", 831 831 - request->from, request->len, request->handle, request->type); 832 832 - 833 833 - ret = write_sync(csock, buf, sizeof(buf)); 834 834 - if (ret < 0) { 835 835 - return ret; 836 836 - } 837 837 - 838 838 - if (ret != sizeof(buf)) { 839 839 - LOG("writing to socket failed"); 840 840 - return -EINVAL; 841 841 - } 842 842 - return 0; 843 843 - } 844 844 - 845 437 static ssize_t nbd_receive_request(int csock, struct nbd_request *request) 846 438 { 847 439 uint8_t buf[NBD_REQUEST_SIZE]; ··· 877 469 magic, request->type, request->from, request->len); 878 470 879 471 if (magic != NBD_REQUEST_MAGIC) { 880 880 - LOG("invalid magic (got 0x%x)", magic); 881 881 - return -EINVAL; 882 882 - } 883 883 - return 0; 884 884 - } 885 885 - 886 886 - ssize_t nbd_receive_reply(int csock, struct nbd_reply *reply) 887 887 - { 888 888 - uint8_t buf[NBD_REPLY_SIZE]; 889 889 - uint32_t magic; 890 890 - ssize_t ret; 891 891 - 892 892 - ret = read_sync(csock, buf, sizeof(buf)); 893 893 - if (ret < 0) { 894 894 - return ret; 895 895 - } 896 896 - 897 897 - if (ret != sizeof(buf)) { 898 898 - LOG("read failed"); 899 899 - return -EINVAL; 900 900 - } 901 901 - 902 902 - /* Reply 903 903 - [ 0 .. 3] magic (NBD_REPLY_MAGIC) 904 904 - [ 4 .. 7] error (0 == no error) 905 905 - [ 7 .. 15] handle 906 906 - */ 907 907 - 908 908 - magic = be32_to_cpup((uint32_t*)buf); 909 909 - reply->error = be32_to_cpup((uint32_t*)(buf + 4)); 910 910 - reply->handle = be64_to_cpup((uint64_t*)(buf + 8)); 911 911 - 912 912 - reply->error = nbd_errno_to_system_errno(reply->error); 913 913 - 914 914 - TRACE("Got reply: " 915 915 - "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }", 916 916 - magic, reply->error, reply->handle); 917 917 - 918 918 - if (magic != NBD_REPLY_MAGIC) { 919 472 LOG("invalid magic (got 0x%x)", magic); 920 473 return -EINVAL; 921 474 }

+1

nbd/Makefile.objs

··· 1 1 + block-obj-y += server.o client.o common.o

+361

nbd/client.c

··· 1 1 + /* 2 2 + * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> 3 3 + * 4 4 + * Network Block Device Client Side 5 5 + * 6 6 + * This program is free software; you can redistribute it and/or modify 7 7 + * it under the terms of the GNU General Public License as published by 8 8 + * the Free Software Foundation; under version 2 of the License. 9 9 + * 10 10 + * This program is distributed in the hope that it will be useful, 11 11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 13 + * GNU General Public License for more details. 14 14 + * 15 15 + * You should have received a copy of the GNU General Public License 16 16 + * along with this program; if not, see <http://www.gnu.org/licenses/>. 17 17 + */ 18 18 + 19 19 + #include "nbd-internal.h" 20 20 + 21 21 + static int nbd_errno_to_system_errno(int err) 22 22 + { 23 23 + switch (err) { 24 24 + case NBD_SUCCESS: 25 25 + return 0; 26 26 + case NBD_EPERM: 27 27 + return EPERM; 28 28 + case NBD_EIO: 29 29 + return EIO; 30 30 + case NBD_ENOMEM: 31 31 + return ENOMEM; 32 32 + case NBD_ENOSPC: 33 33 + return ENOSPC; 34 34 + case NBD_EINVAL: 35 35 + default: 36 36 + return EINVAL; 37 37 + } 38 38 + } 39 39 + 40 40 + /* Definitions for opaque data types */ 41 41 + 42 42 + static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); 43 43 + 44 44 + /* That's all folks */ 45 45 + 46 46 + /* Basic flow for negotiation 47 47 + 48 48 + Server Client 49 49 + Negotiate 50 50 + 51 51 + or 52 52 + 53 53 + Server Client 54 54 + Negotiate #1 55 55 + Option 56 56 + Negotiate #2 57 57 + 58 58 + ---- 59 59 + 60 60 + followed by 61 61 + 62 62 + Server Client 63 63 + Request 64 64 + Response 65 65 + Request 66 66 + Response 67 67 + ... 68 68 + ... 69 69 + Request (type == 2) 70 70 + 71 71 + */ 72 72 + 73 73 + int nbd_receive_negotiate(int csock, const char *name, uint32_t *flags, 74 74 + off_t *size, Error **errp) 75 75 + { 76 76 + char buf[256]; 77 77 + uint64_t magic, s; 78 78 + uint16_t tmp; 79 79 + int rc; 80 80 + 81 81 + TRACE("Receiving negotiation."); 82 82 + 83 83 + rc = -EINVAL; 84 84 + 85 85 + if (read_sync(csock, buf, 8) != 8) { 86 86 + error_setg(errp, "Failed to read data"); 87 87 + goto fail; 88 88 + } 89 89 + 90 90 + buf[8] = '\0'; 91 91 + if (strlen(buf) == 0) { 92 92 + error_setg(errp, "Server connection closed unexpectedly"); 93 93 + goto fail; 94 94 + } 95 95 + 96 96 + TRACE("Magic is %c%c%c%c%c%c%c%c", 97 97 + qemu_isprint(buf[0]) ? buf[0] : '.', 98 98 + qemu_isprint(buf[1]) ? buf[1] : '.', 99 99 + qemu_isprint(buf[2]) ? buf[2] : '.', 100 100 + qemu_isprint(buf[3]) ? buf[3] : '.', 101 101 + qemu_isprint(buf[4]) ? buf[4] : '.', 102 102 + qemu_isprint(buf[5]) ? buf[5] : '.', 103 103 + qemu_isprint(buf[6]) ? buf[6] : '.', 104 104 + qemu_isprint(buf[7]) ? buf[7] : '.'); 105 105 + 106 106 + if (memcmp(buf, "NBDMAGIC", 8) != 0) { 107 107 + error_setg(errp, "Invalid magic received"); 108 108 + goto fail; 109 109 + } 110 110 + 111 111 + if (read_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) { 112 112 + error_setg(errp, "Failed to read magic"); 113 113 + goto fail; 114 114 + } 115 115 + magic = be64_to_cpu(magic); 116 116 + TRACE("Magic is 0x%" PRIx64, magic); 117 117 + 118 118 + if (name) { 119 119 + uint32_t reserved = 0; 120 120 + uint32_t opt; 121 121 + uint32_t namesize; 122 122 + 123 123 + TRACE("Checking magic (opts_magic)"); 124 124 + if (magic != NBD_OPTS_MAGIC) { 125 125 + if (magic == NBD_CLIENT_MAGIC) { 126 126 + error_setg(errp, "Server does not support export names"); 127 127 + } else { 128 128 + error_setg(errp, "Bad magic received"); 129 129 + } 130 130 + goto fail; 131 131 + } 132 132 + if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) { 133 133 + error_setg(errp, "Failed to read server flags"); 134 134 + goto fail; 135 135 + } 136 136 + *flags = be16_to_cpu(tmp) << 16; 137 137 + /* reserved for future use */ 138 138 + if (write_sync(csock, &reserved, sizeof(reserved)) != 139 139 + sizeof(reserved)) { 140 140 + error_setg(errp, "Failed to read reserved field"); 141 141 + goto fail; 142 142 + } 143 143 + /* write the export name */ 144 144 + magic = cpu_to_be64(magic); 145 145 + if (write_sync(csock, &magic, sizeof(magic)) != sizeof(magic)) { 146 146 + error_setg(errp, "Failed to send export name magic"); 147 147 + goto fail; 148 148 + } 149 149 + opt = cpu_to_be32(NBD_OPT_EXPORT_NAME); 150 150 + if (write_sync(csock, &opt, sizeof(opt)) != sizeof(opt)) { 151 151 + error_setg(errp, "Failed to send export name option number"); 152 152 + goto fail; 153 153 + } 154 154 + namesize = cpu_to_be32(strlen(name)); 155 155 + if (write_sync(csock, &namesize, sizeof(namesize)) != 156 156 + sizeof(namesize)) { 157 157 + error_setg(errp, "Failed to send export name length"); 158 158 + goto fail; 159 159 + } 160 160 + if (write_sync(csock, (char*)name, strlen(name)) != strlen(name)) { 161 161 + error_setg(errp, "Failed to send export name"); 162 162 + goto fail; 163 163 + } 164 164 + } else { 165 165 + TRACE("Checking magic (cli_magic)"); 166 166 + 167 167 + if (magic != NBD_CLIENT_MAGIC) { 168 168 + if (magic == NBD_OPTS_MAGIC) { 169 169 + error_setg(errp, "Server requires an export name"); 170 170 + } else { 171 171 + error_setg(errp, "Bad magic received"); 172 172 + } 173 173 + goto fail; 174 174 + } 175 175 + } 176 176 + 177 177 + if (read_sync(csock, &s, sizeof(s)) != sizeof(s)) { 178 178 + error_setg(errp, "Failed to read export length"); 179 179 + goto fail; 180 180 + } 181 181 + *size = be64_to_cpu(s); 182 182 + TRACE("Size is %" PRIu64, *size); 183 183 + 184 184 + if (!name) { 185 185 + if (read_sync(csock, flags, sizeof(*flags)) != sizeof(*flags)) { 186 186 + error_setg(errp, "Failed to read export flags"); 187 187 + goto fail; 188 188 + } 189 189 + *flags = be32_to_cpup(flags); 190 190 + } else { 191 191 + if (read_sync(csock, &tmp, sizeof(tmp)) != sizeof(tmp)) { 192 192 + error_setg(errp, "Failed to read export flags"); 193 193 + goto fail; 194 194 + } 195 195 + *flags |= be16_to_cpu(tmp); 196 196 + } 197 197 + if (read_sync(csock, &buf, 124) != 124) { 198 198 + error_setg(errp, "Failed to read reserved block"); 199 199 + goto fail; 200 200 + } 201 201 + rc = 0; 202 202 + 203 203 + fail: 204 204 + return rc; 205 205 + } 206 206 + 207 207 + #ifdef __linux__ 208 208 + int nbd_init(int fd, int csock, uint32_t flags, off_t size) 209 209 + { 210 210 + TRACE("Setting NBD socket"); 211 211 + 212 212 + if (ioctl(fd, NBD_SET_SOCK, csock) < 0) { 213 213 + int serrno = errno; 214 214 + LOG("Failed to set NBD socket"); 215 215 + return -serrno; 216 216 + } 217 217 + 218 218 + TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE); 219 219 + 220 220 + if (ioctl(fd, NBD_SET_BLKSIZE, (size_t)BDRV_SECTOR_SIZE) < 0) { 221 221 + int serrno = errno; 222 222 + LOG("Failed setting NBD block size"); 223 223 + return -serrno; 224 224 + } 225 225 + 226 226 + TRACE("Setting size to %zd block(s)", (size_t)(size / BDRV_SECTOR_SIZE)); 227 227 + 228 228 + if (ioctl(fd, NBD_SET_SIZE_BLOCKS, (size_t)(size / BDRV_SECTOR_SIZE)) < 0) { 229 229 + int serrno = errno; 230 230 + LOG("Failed setting size (in blocks)"); 231 231 + return -serrno; 232 232 + } 233 233 + 234 234 + if (ioctl(fd, NBD_SET_FLAGS, flags) < 0) { 235 235 + if (errno == ENOTTY) { 236 236 + int read_only = (flags & NBD_FLAG_READ_ONLY) != 0; 237 237 + TRACE("Setting readonly attribute"); 238 238 + 239 239 + if (ioctl(fd, BLKROSET, (unsigned long) &read_only) < 0) { 240 240 + int serrno = errno; 241 241 + LOG("Failed setting read-only attribute"); 242 242 + return -serrno; 243 243 + } 244 244 + } else { 245 245 + int serrno = errno; 246 246 + LOG("Failed setting flags"); 247 247 + return -serrno; 248 248 + } 249 249 + } 250 250 + 251 251 + TRACE("Negotiation ended"); 252 252 + 253 253 + return 0; 254 254 + } 255 255 + 256 256 + int nbd_client(int fd) 257 257 + { 258 258 + int ret; 259 259 + int serrno; 260 260 + 261 261 + TRACE("Doing NBD loop"); 262 262 + 263 263 + ret = ioctl(fd, NBD_DO_IT); 264 264 + if (ret < 0 && errno == EPIPE) { 265 265 + /* NBD_DO_IT normally returns EPIPE when someone has disconnected 266 266 + * the socket via NBD_DISCONNECT. We do not want to return 1 in 267 267 + * that case. 268 268 + */ 269 269 + ret = 0; 270 270 + } 271 271 + serrno = errno; 272 272 + 273 273 + TRACE("NBD loop returned %d: %s", ret, strerror(serrno)); 274 274 + 275 275 + TRACE("Clearing NBD queue"); 276 276 + ioctl(fd, NBD_CLEAR_QUE); 277 277 + 278 278 + TRACE("Clearing NBD socket"); 279 279 + ioctl(fd, NBD_CLEAR_SOCK); 280 280 + 281 281 + errno = serrno; 282 282 + return ret; 283 283 + } 284 284 + #else 285 285 + int nbd_init(int fd, int csock, uint32_t flags, off_t size) 286 286 + { 287 287 + return -ENOTSUP; 288 288 + } 289 289 + 290 290 + int nbd_client(int fd) 291 291 + { 292 292 + return -ENOTSUP; 293 293 + } 294 294 + #endif 295 295 + 296 296 + ssize_t nbd_send_request(int csock, struct nbd_request *request) 297 297 + { 298 298 + uint8_t buf[NBD_REQUEST_SIZE]; 299 299 + ssize_t ret; 300 300 + 301 301 + cpu_to_be32w((uint32_t*)buf, NBD_REQUEST_MAGIC); 302 302 + cpu_to_be32w((uint32_t*)(buf + 4), request->type); 303 303 + cpu_to_be64w((uint64_t*)(buf + 8), request->handle); 304 304 + cpu_to_be64w((uint64_t*)(buf + 16), request->from); 305 305 + cpu_to_be32w((uint32_t*)(buf + 24), request->len); 306 306 + 307 307 + TRACE("Sending request to client: " 308 308 + "{ .from = %" PRIu64", .len = %u, .handle = %" PRIu64", .type=%i}", 309 309 + request->from, request->len, request->handle, request->type); 310 310 + 311 311 + ret = write_sync(csock, buf, sizeof(buf)); 312 312 + if (ret < 0) { 313 313 + return ret; 314 314 + } 315 315 + 316 316 + if (ret != sizeof(buf)) { 317 317 + LOG("writing to socket failed"); 318 318 + return -EINVAL; 319 319 + } 320 320 + return 0; 321 321 + } 322 322 + 323 323 + ssize_t nbd_receive_reply(int csock, struct nbd_reply *reply) 324 324 + { 325 325 + uint8_t buf[NBD_REPLY_SIZE]; 326 326 + uint32_t magic; 327 327 + ssize_t ret; 328 328 + 329 329 + ret = read_sync(csock, buf, sizeof(buf)); 330 330 + if (ret < 0) { 331 331 + return ret; 332 332 + } 333 333 + 334 334 + if (ret != sizeof(buf)) { 335 335 + LOG("read failed"); 336 336 + return -EINVAL; 337 337 + } 338 338 + 339 339 + /* Reply 340 340 + [ 0 .. 3] magic (NBD_REPLY_MAGIC) 341 341 + [ 4 .. 7] error (0 == no error) 342 342 + [ 7 .. 15] handle 343 343 + */ 344 344 + 345 345 + magic = be32_to_cpup((uint32_t*)buf); 346 346 + reply->error = be32_to_cpup((uint32_t*)(buf + 4)); 347 347 + reply->handle = be64_to_cpup((uint64_t*)(buf + 8)); 348 348 + 349 349 + reply->error = nbd_errno_to_system_errno(reply->error); 350 350 + 351 351 + TRACE("Got reply: " 352 352 + "{ magic = 0x%x, .error = %d, handle = %" PRIu64" }", 353 353 + magic, reply->error, reply->handle); 354 354 + 355 355 + if (magic != NBD_REPLY_MAGIC) { 356 356 + LOG("invalid magic (got 0x%x)", magic); 357 357 + return -EINVAL; 358 358 + } 359 359 + return 0; 360 360 + } 361 361 +

+64

nbd/common.c

··· 1 1 + /* 2 2 + * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws> 3 3 + * 4 4 + * Network Block Device Common Code 5 5 + * 6 6 + * This program is free software; you can redistribute it and/or modify 7 7 + * it under the terms of the GNU General Public License as published by 8 8 + * the Free Software Foundation; under version 2 of the License. 9 9 + * 10 10 + * This program is distributed in the hope that it will be useful, 11 11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 13 + * GNU General Public License for more details. 14 14 + * 15 15 + * You should have received a copy of the GNU General Public License 16 16 + * along with this program; if not, see <http://www.gnu.org/licenses/>. 17 17 + */ 18 18 + 19 19 + #include "nbd-internal.h" 20 20 + 21 21 + ssize_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read) 22 22 + { 23 23 + size_t offset = 0; 24 24 + int err; 25 25 + 26 26 + if (qemu_in_coroutine()) { 27 27 + if (do_read) { 28 28 + return qemu_co_recv(fd, buffer, size); 29 29 + } else { 30 30 + return qemu_co_send(fd, buffer, size); 31 31 + } 32 32 + } 33 33 + 34 34 + while (offset < size) { 35 35 + ssize_t len; 36 36 + 37 37 + if (do_read) { 38 38 + len = qemu_recv(fd, buffer + offset, size - offset, 0); 39 39 + } else { 40 40 + len = send(fd, buffer + offset, size - offset, 0); 41 41 + } 42 42 + 43 43 + if (len < 0) { 44 44 + err = socket_error(); 45 45 + 46 46 + /* recoverable error */ 47 47 + if (err == EINTR || (offset > 0 && (err == EAGAIN || err == EWOULDBLOCK))) { 48 48 + continue; 49 49 + } 50 50 + 51 51 + /* unrecoverable error */ 52 52 + return -err; 53 53 + } 54 54 + 55 55 + /* eof */ 56 56 + if (len == 0) { 57 57 + break; 58 58 + } 59 59 + 60 60 + offset += len; 61 61 + } 62 62 + 63 63 + return offset; 64 64 + }

+113

nbd/nbd-internal.h

··· 1 1 + /* 2 2 + * NBD Internal Declarations 3 3 + * 4 4 + * Copyright (C) 2016 Red Hat, Inc. 5 5 + * 6 6 + * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 7 + * See the COPYING file in the top-level directory. 8 8 + */ 9 9 + 10 10 + #ifndef NBD_INTERNAL_H 11 11 + #define NBD_INTERNAL_H 12 12 + #include "block/nbd.h" 13 13 + #include "sysemu/block-backend.h" 14 14 + 15 15 + #include "qemu/coroutine.h" 16 16 + 17 17 + #include <errno.h> 18 18 + #include <string.h> 19 19 + #ifndef _WIN32 20 20 + #include <sys/ioctl.h> 21 21 + #endif 22 22 + #if defined(__sun__) || defined(__HAIKU__) 23 23 + #include <sys/ioccom.h> 24 24 + #endif 25 25 + #include <ctype.h> 26 26 + #include <inttypes.h> 27 27 + 28 28 + #ifdef __linux__ 29 29 + #include <linux/fs.h> 30 30 + #endif 31 31 + 32 32 + #include "qemu/sockets.h" 33 33 + #include "qemu/queue.h" 34 34 + #include "qemu/main-loop.h" 35 35 + 36 36 + /* #define DEBUG_NBD */ 37 37 + 38 38 + #ifdef DEBUG_NBD 39 39 + #define TRACE(msg, ...) do { \ 40 40 + LOG(msg, ## __VA_ARGS__); \ 41 41 + } while(0) 42 42 + #else 43 43 + #define TRACE(msg, ...) \ 44 44 + do { } while (0) 45 45 + #endif 46 46 + 47 47 + #define LOG(msg, ...) do { \ 48 48 + fprintf(stderr, "%s:%s():L%d: " msg "\n", \ 49 49 + __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \ 50 50 + } while(0) 51 51 + 52 52 + /* This is all part of the "official" NBD API. 53 53 + * 54 54 + * The most up-to-date documentation is available at: 55 55 + * https://github.com/yoe/nbd/blob/master/doc/proto.txt 56 56 + */ 57 57 + 58 58 + #define NBD_REQUEST_SIZE (4 + 4 + 8 + 8 + 4) 59 59 + #define NBD_REPLY_SIZE (4 + 4 + 8) 60 60 + #define NBD_REQUEST_MAGIC 0x25609513 61 61 + #define NBD_REPLY_MAGIC 0x67446698 62 62 + #define NBD_OPTS_MAGIC 0x49484156454F5054LL 63 63 + #define NBD_CLIENT_MAGIC 0x0000420281861253LL 64 64 + #define NBD_REP_MAGIC 0x3e889045565a9LL 65 65 + 66 66 + #define NBD_SET_SOCK _IO(0xab, 0) 67 67 + #define NBD_SET_BLKSIZE _IO(0xab, 1) 68 68 + #define NBD_SET_SIZE _IO(0xab, 2) 69 69 + #define NBD_DO_IT _IO(0xab, 3) 70 70 + #define NBD_CLEAR_SOCK _IO(0xab, 4) 71 71 + #define NBD_CLEAR_QUE _IO(0xab, 5) 72 72 + #define NBD_PRINT_DEBUG _IO(0xab, 6) 73 73 + #define NBD_SET_SIZE_BLOCKS _IO(0xab, 7) 74 74 + #define NBD_DISCONNECT _IO(0xab, 8) 75 75 + #define NBD_SET_TIMEOUT _IO(0xab, 9) 76 76 + #define NBD_SET_FLAGS _IO(0xab, 10) 77 77 + 78 78 + #define NBD_OPT_EXPORT_NAME (1) 79 79 + #define NBD_OPT_ABORT (2) 80 80 + #define NBD_OPT_LIST (3) 81 81 + 82 82 + /* NBD errors are based on errno numbers, so there is a 1:1 mapping, 83 83 + * but only a limited set of errno values is specified in the protocol. 84 84 + * Everything else is squashed to EINVAL. 85 85 + */ 86 86 + #define NBD_SUCCESS 0 87 87 + #define NBD_EPERM 1 88 88 + #define NBD_EIO 5 89 89 + #define NBD_ENOMEM 12 90 90 + #define NBD_EINVAL 22 91 91 + #define NBD_ENOSPC 28 92 92 + 93 93 + static inline ssize_t read_sync(int fd, void *buffer, size_t size) 94 94 + { 95 95 + /* Sockets are kept in blocking mode in the negotiation phase. After 96 96 + * that, a non-readable socket simply means that another thread stole 97 97 + * our request/reply. Synchronization is done with recv_coroutine, so 98 98 + * that this is coroutine-safe. 99 99 + */ 100 100 + return nbd_wr_sync(fd, buffer, size, true); 101 101 + } 102 102 + 103 103 + static inline ssize_t write_sync(int fd, void *buffer, size_t size) 104 104 + { 105 105 + int ret; 106 106 + do { 107 107 + /* For writes, we do expect the socket to be writable. */ 108 108 + ret = nbd_wr_sync(fd, buffer, size, false); 109 109 + } while (ret == -EAGAIN); 110 110 + return ret; 111 111 + } 112 112 + 113 113 + #endif

+1 -1

tests/qemu-iotests/083

··· 55 55 # callbacks sometimes, making them unreliable. 56 56 # 57 57 # Filter out the TCP port number since this changes between runs. 58 58 - sed -e 's#^.*nbd\.c:.*##g' \ 58 58 + sed -e 's#^.*nbd/.*\.c:.*##g' \ 59 59 -e 's#nbd:127\.0\.0\.1:[^:]*:#nbd:127\.0\.0\.1:PORT:#g' \ 60 60 -e 's#\(exportname=foo\|PORT\): Failed to .*$#\1#' 61 61 }