X-Git-Url: https://repo.jachan.dev/qemu.git/blobdiff_plain/975b092bd908029fb32e7372d8ae4de0d7412754..dc10e8b3c556b582eb7919c92d0997b5f9a9d136:/qemu-nbd.c diff --git a/qemu-nbd.c b/qemu-nbd.c index 0feafca088..eb61c33acd 100644 --- a/qemu-nbd.c +++ b/qemu-nbd.c @@ -1,4 +1,4 @@ -/*\ +/* * Copyright (C) 2005 Anthony Liguori * * Network Block Device @@ -13,11 +13,10 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * along with this program; if not, see . */ -#include +#include "qemu-common.h" #include "block_int.h" #include "nbd.h" @@ -25,12 +24,26 @@ #include #include #include +#include #include #include #include #include +#include +#include +#include -int verbose; +#define SOCKET_PATH "/var/lock/qemu-nbd-%s" + +static NBDExport *exp; +static int verbose; +static char *device; +static char *srcpath; +static char *sockpath; +static bool sigterm_reported; +static bool nbd_started; +static int shared = 1; +static int nb_fds; static void usage(const char *name) { @@ -38,29 +51,37 @@ static void usage(const char *name) "Usage: %s [OPTIONS] FILE\n" "QEMU Disk Network Block Device Server\n" "\n" -" -p, --port=PORT port to listen on (default `1024')\n" +" -p, --port=PORT port to listen on (default `%d')\n" " -o, --offset=OFFSET offset into the image\n" " -b, --bind=IFACE interface to bind to (default `0.0.0.0')\n" +" -k, --socket=PATH path to the unix socket\n" +" (default '"SOCKET_PATH"')\n" " -r, --read-only export read-only\n" " -P, --partition=NUM only expose partition NUM\n" +" -s, --snapshot use snapshot file\n" +" -n, --nocache disable host cache\n" +" -c, --connect=DEV connect FILE to the local NBD device DEV\n" +" -d, --disconnect disconnect the specified device\n" +" -e, --shared=NUM device can be shared by NUM clients (default '1')\n" +" -t, --persistent don't exit on the last connection\n" " -v, --verbose display extra debugging information\n" " -h, --help display this help and exit\n" " -V, --version output version information and exit\n" "\n" "Report bugs to \n" - , name); + , name, NBD_DEFAULT_PORT, "DEVICE"); } static void version(const char *name) { printf( -"qemu-nbd version 0.0.1\n" +"%s version 0.0.1\n" "Written by Anthony Liguori.\n" "\n" "Copyright (C) 2006 Anthony Liguori .\n" "This is free software; see the source for copying conditions. There is NO\n" "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" - ); + , name); } struct partition_record @@ -98,9 +119,12 @@ static int find_partition(BlockDriverState *bs, int partition, uint8_t data[512]; int i; int ext_partnum = 4; + int ret; - if (bdrv_read(bs, 0, data, 1)) - errx(EINVAL, "error while reading"); + if ((ret = bdrv_read(bs, 0, data, 1)) < 0) { + errno = -ret; + err(EXIT_FAILURE, "error while reading"); + } if (data[510] != 0x55 || data[511] != 0xaa) { errno = -EINVAL; @@ -118,8 +142,10 @@ static int find_partition(BlockDriverState *bs, int partition, uint8_t data1[512]; int j; - if (bdrv_read(bs, mbr[i].start_sector_abs, data1, 1)) - errx(EINVAL, "error while reading"); + if ((ret = bdrv_read(bs, mbr[i].start_sector_abs, data1, 1)) < 0) { + errno = -ret; + err(EXIT_FAILURE, "error while reading"); + } for (j = 0; j < 4; j++) { read_partition(&data1[446 + 16 * j], &ext[j]); @@ -144,42 +170,156 @@ static int find_partition(BlockDriverState *bs, int partition, return -1; } +static void termsig_handler(int signum) +{ + sigterm_reported = true; + qemu_notify_event(); +} + +static void *show_parts(void *arg) +{ + int nbd; + + /* linux just needs an open() to trigger + * the partition table update + * but remember to load the module with max_part != 0 : + * modprobe nbd max_part=63 + */ + nbd = open(device, O_RDWR); + if (nbd != -1) { + close(nbd); + } + return NULL; +} + +static void *nbd_client_thread(void *arg) +{ + int fd = *(int *)arg; + off_t size; + size_t blocksize; + uint32_t nbdflags; + int sock; + int ret; + pthread_t show_parts_thread; + + sock = unix_socket_outgoing(sockpath); + if (sock == -1) { + goto out; + } + + ret = nbd_receive_negotiate(sock, NULL, &nbdflags, + &size, &blocksize); + if (ret == -1) { + goto out; + } + + ret = nbd_init(fd, sock, nbdflags, size, blocksize); + if (ret == -1) { + goto out; + } + + /* update partition table */ + pthread_create(&show_parts_thread, NULL, show_parts, NULL); + + if (verbose) { + fprintf(stderr, "NBD device %s is now connected to %s\n", + device, srcpath); + } else { + /* Close stderr so that the qemu-nbd process exits. */ + dup2(STDOUT_FILENO, STDERR_FILENO); + } + + ret = nbd_client(fd); + if (ret) { + goto out; + } + close(fd); + kill(getpid(), SIGTERM); + return (void *) EXIT_SUCCESS; + +out: + kill(getpid(), SIGTERM); + return (void *) EXIT_FAILURE; +} + +static int nbd_can_accept(void *opaque) +{ + return nb_fds < shared; +} + +static void nbd_client_closed(NBDClient *client) +{ + nb_fds--; + qemu_notify_event(); +} + +static void nbd_accept(void *opaque) +{ + int server_fd = (uintptr_t) opaque; + struct sockaddr_in addr; + socklen_t addr_len = sizeof(addr); + + int fd = accept(server_fd, (struct sockaddr *)&addr, &addr_len); + nbd_started = true; + if (fd != -1 && nbd_client_new(exp, fd, nbd_client_closed)) { + nb_fds++; + } +} + int main(int argc, char **argv) { BlockDriverState *bs; off_t dev_offset = 0; - off_t offset = 0; - bool readonly = false; + uint32_t nbdflags = 0; + bool disconnect = false; const char *bindto = "0.0.0.0"; - int port = 1024; - int sock, csock; - struct sockaddr_in addr; - socklen_t addr_len = sizeof(addr); + int port = NBD_DEFAULT_PORT; off_t fd_size; - const char *sopt = "hVbo:p:rsP:v"; + const char *sopt = "hVb:o:p:rsnP:c:dvk:e:t"; struct option lopt[] = { - { "help", 0, 0, 'h' }, - { "version", 0, 0, 'V' }, - { "bind", 1, 0, 'b' }, - { "port", 1, 0, 'p' }, - { "offset", 1, 0, 'o' }, - { "read-only", 0, 0, 'r' }, - { "partition", 1, 0, 'P' }, - { "snapshot", 0, 0, 's' }, - { "verbose", 0, 0, 'v' }, - { NULL, 0, 0, 0 } + { "help", 0, NULL, 'h' }, + { "version", 0, NULL, 'V' }, + { "bind", 1, NULL, 'b' }, + { "port", 1, NULL, 'p' }, + { "socket", 1, NULL, 'k' }, + { "offset", 1, NULL, 'o' }, + { "read-only", 0, NULL, 'r' }, + { "partition", 1, NULL, 'P' }, + { "connect", 1, NULL, 'c' }, + { "disconnect", 0, NULL, 'd' }, + { "snapshot", 0, NULL, 's' }, + { "nocache", 0, NULL, 'n' }, + { "shared", 1, NULL, 'e' }, + { "persistent", 0, NULL, 't' }, + { "verbose", 0, NULL, 'v' }, + { NULL, 0, NULL, 0 } }; int ch; int opt_ind = 0; int li; char *end; - bool snapshot = false; + int flags = BDRV_O_RDWR; int partition = -1; + int ret; + int fd; + int persistent = 0; + pthread_t client_thread; + + /* The client thread uses SIGTERM to interrupt the server. A signal + * handler ensures that "qemu-nbd -v -c" exits with a nice status code. + */ + struct sigaction sa_sigterm; + memset(&sa_sigterm, 0, sizeof(sa_sigterm)); + sa_sigterm.sa_handler = termsig_handler; + sigaction(SIGTERM, &sa_sigterm, NULL); while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { switch (ch) { case 's': - snapshot = true; + flags |= BDRV_O_SNAPSHOT; + break; + case 'n': + flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; break; case 'b': bindto = optarg; @@ -187,32 +327,56 @@ int main(int argc, char **argv) case 'p': li = strtol(optarg, &end, 0); if (*end) { - errx(EINVAL, "Invalid port `%s'", optarg); + errx(EXIT_FAILURE, "Invalid port `%s'", optarg); } if (li < 1 || li > 65535) { - errx(EINVAL, "Port out of range `%s'", optarg); + errx(EXIT_FAILURE, "Port out of range `%s'", optarg); } port = (uint16_t)li; break; case 'o': dev_offset = strtoll (optarg, &end, 0); if (*end) { - errx(EINVAL, "Invalid offset `%s'", optarg); + errx(EXIT_FAILURE, "Invalid offset `%s'", optarg); } if (dev_offset < 0) { - errx(EINVAL, "Offset must be positive `%s'", optarg); + errx(EXIT_FAILURE, "Offset must be positive `%s'", optarg); } break; case 'r': - readonly = true; + nbdflags |= NBD_FLAG_READ_ONLY; + flags &= ~BDRV_O_RDWR; break; case 'P': partition = strtol(optarg, &end, 0); if (*end) - errx(EINVAL, "Invalid partition `%s'", optarg); + errx(EXIT_FAILURE, "Invalid partition `%s'", optarg); if (partition < 1 || partition > 8) - errx(EINVAL, "Invalid partition %d", partition); + errx(EXIT_FAILURE, "Invalid partition %d", partition); + break; + case 'k': + sockpath = optarg; + if (sockpath[0] != '/') + errx(EXIT_FAILURE, "socket path must be absolute\n"); + break; + case 'd': + disconnect = true; break; + case 'c': + device = optarg; + break; + case 'e': + shared = strtol(optarg, &end, 0); + if (*end) { + errx(EXIT_FAILURE, "Invalid shared device number '%s'", optarg); + } + if (shared < 1) { + errx(EXIT_FAILURE, "Shared device number must be greater than 0\n"); + } + break; + case 't': + persistent = 1; + break; case 'v': verbose = 1; break; @@ -225,51 +389,158 @@ int main(int argc, char **argv) exit(0); break; case '?': - errx(EINVAL, "Try `%s --help' for more information.", + errx(EXIT_FAILURE, "Try `%s --help' for more information.", argv[0]); } } if ((argc - optind) != 1) { - errx(EINVAL, "Invalid number of argument.\n" + errx(EXIT_FAILURE, "Invalid number of argument.\n" "Try `%s --help' for more information.", argv[0]); } + if (disconnect) { + fd = open(argv[optind], O_RDWR); + if (fd == -1) + err(EXIT_FAILURE, "Cannot open %s", argv[optind]); + + nbd_disconnect(fd); + + close(fd); + + printf("%s disconnected\n", argv[optind]); + + return 0; + } + + if (device && !verbose) { + int stderr_fd[2]; + pid_t pid; + int ret; + + if (qemu_pipe(stderr_fd) == -1) { + err(EXIT_FAILURE, "Error setting up communication pipe"); + } + + /* Now daemonize, but keep a communication channel open to + * print errors and exit with the proper status code. + */ + pid = fork(); + if (pid == 0) { + close(stderr_fd[0]); + ret = qemu_daemon(0, 0); + + /* Temporarily redirect stderr to the parent's pipe... */ + dup2(stderr_fd[1], STDERR_FILENO); + if (ret == -1) { + err(EXIT_FAILURE, "Failed to daemonize"); + } + + /* ... close the descriptor we inherited and go on. */ + close(stderr_fd[1]); + } else { + bool errors = false; + char *buf; + + /* In the parent. Print error messages from the child until + * it closes the pipe. + */ + close(stderr_fd[1]); + buf = g_malloc(1024); + while ((ret = read(stderr_fd[0], buf, 1024)) > 0) { + errors = true; + ret = qemu_write_full(STDERR_FILENO, buf, ret); + if (ret == -1) { + exit(EXIT_FAILURE); + } + } + if (ret == -1) { + err(EXIT_FAILURE, "Cannot read from daemon"); + } + + /* Usually the daemon should not print any message. + * Exit with zero status in that case. + */ + exit(errors); + } + } + + if (device) { + /* Open before spawning new threads. In the future, we may + * drop privileges after opening. + */ + fd = open(device, O_RDWR); + if (fd == -1) { + err(EXIT_FAILURE, "Failed to open %s", device); + } + + if (sockpath == NULL) { + sockpath = g_malloc(128); + snprintf(sockpath, 128, SOCKET_PATH, basename(device)); + } + } + bdrv_init(); + atexit(bdrv_close_all); bs = bdrv_new("hda"); - if (bs == NULL) - return 1; - - if (bdrv_open(bs, argv[optind], snapshot) == -1) - return 1; + srcpath = argv[optind]; + if ((ret = bdrv_open(bs, srcpath, flags, NULL)) < 0) { + errno = -ret; + err(EXIT_FAILURE, "Failed to bdrv_open '%s'", argv[optind]); + } fd_size = bs->total_sectors * 512; if (partition != -1 && - find_partition(bs, partition, &dev_offset, &fd_size)) - errx(errno, "Could not find partition %d", partition); + find_partition(bs, partition, &dev_offset, &fd_size)) { + err(EXIT_FAILURE, "Could not find partition %d", partition); + } - sock = tcp_socket_incoming(bindto, port); - if (sock == -1) - return 1; + exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags); - csock = accept(sock, - (struct sockaddr *)&addr, - &addr_len); - if (csock == -1) - return 1; + if (sockpath) { + fd = unix_socket_incoming(sockpath); + } else { + fd = tcp_socket_incoming(bindto, port); + } - /* new fd_size is calculated by find_partition */ - if (nbd_negotiate(bs, csock, fd_size) == -1) + if (fd == -1) { return 1; + } - while (nbd_trip(bs, csock, fd_size, dev_offset, &offset, readonly) == 0); + if (device) { + int ret; - close(csock); - close(sock); - bdrv_close(bs); + ret = pthread_create(&client_thread, NULL, nbd_client_thread, &fd); + if (ret != 0) { + errx(EXIT_FAILURE, "Failed to create client thread: %s", + strerror(ret)); + } + } else { + /* Shut up GCC warnings. */ + memset(&client_thread, 0, sizeof(client_thread)); + } - return 0; + qemu_init_main_loop(); + qemu_set_fd_handler2(fd, nbd_can_accept, nbd_accept, NULL, + (void *)(uintptr_t)fd); + + do { + main_loop_wait(false); + } while (!sigterm_reported && (persistent || !nbd_started || nb_fds > 0)); + + nbd_export_close(exp); + if (sockpath) { + unlink(sockpath); + } + + if (device) { + void *ret; + pthread_join(client_thread, &ret); + exit(ret != NULL); + } else { + exit(EXIT_SUCCESS); + } }