qemu-nbd.c 19.4 KB
Newer Older
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15
 *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
 *
 *  Network Block Device
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; under version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  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-common.h"
20 21
#include "block/block.h"
#include "block/nbd.h"
22
#include "qemu/main-loop.h"
23
#include "block/snapshot.h"
24 25 26 27 28

#include <stdarg.h>
#include <stdio.h>
#include <getopt.h>
#include <err.h>
29
#include <sys/types.h>
30 31 32 33
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
34
#include <signal.h>
35
#include <libgen.h>
36
#include <pthread.h>
37

38 39 40 41
#define SOCKET_PATH          "/var/lock/qemu-nbd-%s"
#define QEMU_NBD_OPT_CACHE   1
#define QEMU_NBD_OPT_AIO     2
#define QEMU_NBD_OPT_DISCARD 3
42

43
static NBDExport *exp;
44
static int verbose;
45 46
static char *srcpath;
static char *sockpath;
47 48
static int persistent = 0;
static enum { RUNNING, TERMINATE, TERMINATING, TERMINATED } state;
49 50
static int shared = 1;
static int nb_fds;
51 52 53

static void usage(const char *name)
{
54
    (printf) (
55 56 57
"Usage: %s [OPTIONS] FILE\n"
"QEMU Disk Network Block Device Server\n"
"\n"
58 59 60 61
"  -h, --help           display this help and exit\n"
"  -V, --version        output version information and exit\n"
"\n"
"Connection properties:\n"
62
"  -p, --port=PORT      port to listen on (default `%d')\n"
63
"  -b, --bind=IFACE     interface to bind to (default `0.0.0.0')\n"
64 65
"  -k, --socket=PATH    path to the unix socket\n"
"                       (default '"SOCKET_PATH"')\n"
66
"  -e, --shared=NUM     device can be shared by NUM clients (default '1')\n"
67
"  -t, --persistent     don't exit on the last connection\n"
68 69
"  -v, --verbose        display extra debugging information\n"
"\n"
70 71 72 73 74 75 76 77 78 79 80 81
"Exposing part of the image:\n"
"  -o, --offset=OFFSET  offset into the image\n"
"  -P, --partition=NUM  only expose partition NUM\n"
"\n"
#ifdef __linux__
"Kernel NBD client support:\n"
"  -c, --connect=DEV    connect FILE to the local NBD device DEV\n"
"  -d, --disconnect     disconnect the specified device\n"
"\n"
#endif
"\n"
"Block device options:\n"
82
"  -f, --format=FORMAT  set image format (raw, qcow2, ...)\n"
83
"  -r, --read-only      export read-only\n"
84 85 86 87 88 89 90 91
"  -s, --snapshot       use FILE as an external snapshot, create a temporary\n"
"                       file with backing_file=FILE, redirect the write to\n"
"                       the temporary one\n"
"  -l, --load-snapshot=SNAPSHOT_PARAM\n"
"                       load an internal snapshot inside FILE and export it\n"
"                       as an read-only device, SNAPSHOT_PARAM format is\n"
"                       'snapshot.id=[ID],snapshot.name=[NAME]', or\n"
"                       '[ID_OR_NAME]'\n"
92
"  -n, --nocache        disable host cache\n"
93 94 95 96
"      --cache=MODE     set cache mode (none, writeback, ...)\n"
#ifdef CONFIG_LINUX_AIO
"      --aio=MODE       set AIO mode (native or threads)\n"
#endif
97 98
"\n"
"Report bugs to <qemu-devel@nongnu.org>\n"
99
    , name, NBD_DEFAULT_PORT, "DEVICE");
100 101 102 103 104
}

static void version(const char *name)
{
    printf(
105
"%s version 0.0.1\n"
106 107 108 109 110
"Written by Anthony Liguori.\n"
"\n"
"Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>.\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"
111
    , name);
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
}

struct partition_record
{
    uint8_t bootable;
    uint8_t start_head;
    uint32_t start_cylinder;
    uint8_t start_sector;
    uint8_t system;
    uint8_t end_head;
    uint8_t end_cylinder;
    uint8_t end_sector;
    uint32_t start_sector_abs;
    uint32_t nb_sectors_abs;
};

static void read_partition(uint8_t *p, struct partition_record *r)
{
    r->bootable = p[0];
    r->start_head = p[1];
    r->start_cylinder = p[3] | ((p[2] << 2) & 0x0300);
    r->start_sector = p[2] & 0x3f;
    r->system = p[4];
    r->end_head = p[5];
    r->end_cylinder = p[7] | ((p[6] << 2) & 0x300);
    r->end_sector = p[6] & 0x3f;
    r->start_sector_abs = p[8] | p[9] << 8 | p[10] << 16 | p[11] << 24;
    r->nb_sectors_abs = p[12] | p[13] << 8 | p[14] << 16 | p[15] << 24;
}

static int find_partition(BlockDriverState *bs, int partition,
                          off_t *offset, off_t *size)
{
    struct partition_record mbr[4];
    uint8_t data[512];
    int i;
    int ext_partnum = 4;
149
    int ret;
150

151 152 153 154
    if ((ret = bdrv_read(bs, 0, data, 1)) < 0) {
        errno = -ret;
        err(EXIT_FAILURE, "error while reading");
    }
155 156

    if (data[510] != 0x55 || data[511] != 0xaa) {
157
        return -EINVAL;
158 159 160 161 162 163 164 165 166 167 168 169 170
    }

    for (i = 0; i < 4; i++) {
        read_partition(&data[446 + 16 * i], &mbr[i]);

        if (!mbr[i].nb_sectors_abs)
            continue;

        if (mbr[i].system == 0xF || mbr[i].system == 0x5) {
            struct partition_record ext[4];
            uint8_t data1[512];
            int j;

171 172 173 174
            if ((ret = bdrv_read(bs, mbr[i].start_sector_abs, data1, 1)) < 0) {
                errno = -ret;
                err(EXIT_FAILURE, "error while reading");
            }
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194

            for (j = 0; j < 4; j++) {
                read_partition(&data1[446 + 16 * j], &ext[j]);
                if (!ext[j].nb_sectors_abs)
                    continue;

                if ((ext_partnum + j + 1) == partition) {
                    *offset = (uint64_t)ext[j].start_sector_abs << 9;
                    *size = (uint64_t)ext[j].nb_sectors_abs << 9;
                    return 0;
                }
            }
            ext_partnum += 4;
        } else if ((i + 1) == partition) {
            *offset = (uint64_t)mbr[i].start_sector_abs << 9;
            *size = (uint64_t)mbr[i].nb_sectors_abs << 9;
            return 0;
        }
    }

195
    return -ENOENT;
196 197
}

Paolo Bonzini's avatar
Paolo Bonzini committed
198 199
static void termsig_handler(int signum)
{
200
    state = TERMINATE;
201
    qemu_notify_event();
Paolo Bonzini's avatar
Paolo Bonzini committed
202 203
}

204
static void *show_parts(void *arg)
205
{
206
    char *device = arg;
207 208 209 210 211 212 213 214
    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);
215
    if (nbd >= 0) {
216 217 218 219
        close(nbd);
    }
    return NULL;
}
220

221 222
static void *nbd_client_thread(void *arg)
{
223
    char *device = arg;
224 225 226
    off_t size;
    size_t blocksize;
    uint32_t nbdflags;
227
    int fd, sock;
228 229 230
    int ret;
    pthread_t show_parts_thread;

231
    sock = unix_socket_outgoing(sockpath);
232
    if (sock < 0) {
233 234
        goto out;
    }
235 236 237

    ret = nbd_receive_negotiate(sock, NULL, &nbdflags,
                                &size, &blocksize);
238
    if (ret < 0) {
239 240 241
        goto out;
    }

242
    fd = open(device, O_RDWR);
243
    if (fd < 0) {
244 245 246 247 248
        /* Linux-only, we can use %m in printf.  */
        fprintf(stderr, "Failed to open %s: %m", device);
        goto out;
    }

249
    ret = nbd_init(fd, sock, nbdflags, size, blocksize);
250
    if (ret < 0) {
251 252 253 254
        goto out;
    }

    /* update partition table */
255
    pthread_create(&show_parts_thread, NULL, show_parts, device);
256

257 258 259 260 261 262 263
    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);
    }
264 265 266 267

    ret = nbd_client(fd);
    if (ret) {
        goto out;
268
    }
269 270 271 272 273 274 275
    close(fd);
    kill(getpid(), SIGTERM);
    return (void *) EXIT_SUCCESS;

out:
    kill(getpid(), SIGTERM);
    return (void *) EXIT_FAILURE;
276 277
}

278 279 280 281 282
static int nbd_can_accept(void *opaque)
{
    return nb_fds < shared;
}

283 284 285 286 287 288
static void nbd_export_closed(NBDExport *exp)
{
    assert(state == TERMINATING);
    state = TERMINATED;
}

289
static void nbd_client_closed(NBDClient *client)
290
{
291
    nb_fds--;
292 293 294
    if (nb_fds == 0 && !persistent && state == RUNNING) {
        state = TERMINATE;
    }
295
    qemu_notify_event();
296
    nbd_client_put(client);
297 298 299 300 301 302 303 304 305
}

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);
306 307 308 309 310
    if (state >= TERMINATE) {
        close(fd);
        return;
    }

311
    if (fd >= 0 && nbd_client_new(exp, fd, nbd_client_closed)) {
312 313 314 315
        nb_fds++;
    }
}

316 317 318
int main(int argc, char **argv)
{
    BlockDriverState *bs;
319
    BlockDriver *drv;
320
    off_t dev_offset = 0;
321
    uint32_t nbdflags = 0;
322
    bool disconnect = false;
323
    const char *bindto = "0.0.0.0";
324
    char *device = NULL;
325
    int port = NBD_DEFAULT_PORT;
326
    off_t fd_size;
327 328 329
    QemuOpts *sn_opts = NULL;
    const char *sn_id_or_name = NULL;
    const char *sopt = "hVb:o:p:rsnP:c:dvk:e:f:tl:";
330
    struct option lopt[] = {
331 332 333 334 335 336 337 338 339 340 341
        { "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' },
342
        { "load-snapshot", 1, NULL, 'l' },
343
        { "nocache", 0, NULL, 'n' },
344 345 346 347
        { "cache", 1, NULL, QEMU_NBD_OPT_CACHE },
#ifdef CONFIG_LINUX_AIO
        { "aio", 1, NULL, QEMU_NBD_OPT_AIO },
#endif
348
        { "discard", 1, NULL, QEMU_NBD_OPT_DISCARD },
349
        { "shared", 1, NULL, 'e' },
350
        { "format", 1, NULL, 'f' },
351 352 353
        { "persistent", 0, NULL, 't' },
        { "verbose", 0, NULL, 'v' },
        { NULL, 0, NULL, 0 }
354 355 356 357 358
    };
    int ch;
    int opt_ind = 0;
    int li;
    char *end;
359
    int flags = BDRV_O_RDWR;
360
    int partition = -1;
361
    int ret;
362
    int fd;
363
    bool seen_cache = false;
364
    bool seen_discard = false;
365 366 367
#ifdef CONFIG_LINUX_AIO
    bool seen_aio = false;
#endif
368
    pthread_t client_thread;
369
    const char *fmt = NULL;
370
    Error *local_err = NULL;
371

372 373 374
    /* The client thread uses SIGTERM to interrupt the server.  A signal
     * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
     */
Paolo Bonzini's avatar
Paolo Bonzini committed
375 376 377 378 379
    struct sigaction sa_sigterm;
    memset(&sa_sigterm, 0, sizeof(sa_sigterm));
    sa_sigterm.sa_handler = termsig_handler;
    sigaction(SIGTERM, &sa_sigterm, NULL);

380 381 382
    while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
        switch (ch) {
        case 's':
383 384 385
            flags |= BDRV_O_SNAPSHOT;
            break;
        case 'n':
386 387 388 389 390 391 392 393 394 395
            optarg = (char *) "none";
            /* fallthrough */
        case QEMU_NBD_OPT_CACHE:
            if (seen_cache) {
                errx(EXIT_FAILURE, "-n and --cache can only be specified once");
            }
            seen_cache = true;
            if (bdrv_parse_cache_flags(optarg, &flags) == -1) {
                errx(EXIT_FAILURE, "Invalid cache mode `%s'", optarg);
            }
396
            break;
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
#ifdef CONFIG_LINUX_AIO
        case QEMU_NBD_OPT_AIO:
            if (seen_aio) {
                errx(EXIT_FAILURE, "--aio can only be specified once");
            }
            seen_aio = true;
            if (!strcmp(optarg, "native")) {
                flags |= BDRV_O_NATIVE_AIO;
            } else if (!strcmp(optarg, "threads")) {
                /* this is the default */
            } else {
               errx(EXIT_FAILURE, "invalid aio mode `%s'", optarg);
            }
            break;
#endif
412 413 414 415 416 417 418 419 420
        case QEMU_NBD_OPT_DISCARD:
            if (seen_discard) {
                errx(EXIT_FAILURE, "--discard can only be specified once");
            }
            seen_discard = true;
            if (bdrv_parse_discard_flags(optarg, &flags) == -1) {
                errx(EXIT_FAILURE, "Invalid discard mode `%s'", optarg);
            }
            break;
421 422 423 424 425 426
        case 'b':
            bindto = optarg;
            break;
        case 'p':
            li = strtol(optarg, &end, 0);
            if (*end) {
427
                errx(EXIT_FAILURE, "Invalid port `%s'", optarg);
428 429
            }
            if (li < 1 || li > 65535) {
430
                errx(EXIT_FAILURE, "Port out of range `%s'", optarg);
431 432 433 434 435 436
            }
            port = (uint16_t)li;
            break;
        case 'o':
                dev_offset = strtoll (optarg, &end, 0);
            if (*end) {
437
                errx(EXIT_FAILURE, "Invalid offset `%s'", optarg);
438 439
            }
            if (dev_offset < 0) {
440
                errx(EXIT_FAILURE, "Offset must be positive `%s'", optarg);
441 442
            }
            break;
443 444 445 446 447 448 449 450 451 452 453
        case 'l':
            if (strstart(optarg, SNAPSHOT_OPT_BASE, NULL)) {
                sn_opts = qemu_opts_parse(&internal_snapshot_opts, optarg, 0);
                if (!sn_opts) {
                    errx(EXIT_FAILURE, "Failed in parsing snapshot param `%s'",
                         optarg);
                }
            } else {
                sn_id_or_name = optarg;
            }
            /* fall through */
454
        case 'r':
455
            nbdflags |= NBD_FLAG_READ_ONLY;
456
            flags &= ~BDRV_O_RDWR;
457 458 459 460
            break;
        case 'P':
            partition = strtol(optarg, &end, 0);
            if (*end)
461
                errx(EXIT_FAILURE, "Invalid partition `%s'", optarg);
462
            if (partition < 1 || partition > 8)
463
                errx(EXIT_FAILURE, "Invalid partition %d", partition);
464
            break;
465
        case 'k':
466 467
            sockpath = optarg;
            if (sockpath[0] != '/')
468
                errx(EXIT_FAILURE, "socket path must be absolute\n");
469 470 471 472 473 474 475
            break;
        case 'd':
            disconnect = true;
            break;
        case 'c':
            device = optarg;
            break;
476 477 478
        case 'e':
            shared = strtol(optarg, &end, 0);
            if (*end) {
479
                errx(EXIT_FAILURE, "Invalid shared device number '%s'", optarg);
480 481
            }
            if (shared < 1) {
482
                errx(EXIT_FAILURE, "Shared device number must be greater than 0\n");
483 484
            }
            break;
485 486 487
        case 'f':
            fmt = optarg;
            break;
488 489 490
	case 't':
	    persistent = 1;
	    break;
491 492 493 494 495 496 497 498 499 500 501 502
        case 'v':
            verbose = 1;
            break;
        case 'V':
            version(argv[0]);
            exit(0);
            break;
        case 'h':
            usage(argv[0]);
            exit(0);
            break;
        case '?':
503
            errx(EXIT_FAILURE, "Try `%s --help' for more information.",
504 505 506 507 508
                 argv[0]);
        }
    }

    if ((argc - optind) != 1) {
509
        errx(EXIT_FAILURE, "Invalid number of argument.\n"
510 511 512 513
             "Try `%s --help' for more information.",
             argv[0]);
    }

514 515
    if (disconnect) {
        fd = open(argv[optind], O_RDWR);
516
        if (fd < 0) {
517
            err(EXIT_FAILURE, "Cannot open %s", argv[optind]);
518
        }
519 520 521 522 523 524 525 526 527
        nbd_disconnect(fd);

        close(fd);

        printf("%s disconnected\n", argv[optind]);

	return 0;
    }

528 529 530 531 532
    if (device && !verbose) {
        int stderr_fd[2];
        pid_t pid;
        int ret;

533
        if (qemu_pipe(stderr_fd) < 0) {
534 535 536 537 538 539 540 541 542
            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]);
543
            ret = qemu_daemon(1, 0);
544 545 546

            /* Temporarily redirect stderr to the parent's pipe...  */
            dup2(stderr_fd[1], STDERR_FILENO);
547
            if (ret < 0) {
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
                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);
565
                if (ret < 0) {
566 567 568
                    exit(EXIT_FAILURE);
                }
            }
569
            if (ret < 0) {
570 571 572 573 574 575 576 577 578 579
                err(EXIT_FAILURE, "Cannot read from daemon");
            }

            /* Usually the daemon should not print any message.
             * Exit with zero status in that case.
             */
            exit(errors);
        }
    }

580 581 582
    if (device != NULL && sockpath == NULL) {
        sockpath = g_malloc(128);
        snprintf(sockpath, 128, SOCKET_PATH, basename(device));
583 584
    }

585
    qemu_init_main_loop();
586 587 588
    bdrv_init();
    atexit(bdrv_close_all);

589 590 591 592 593 594 595 596 597
    if (fmt) {
        drv = bdrv_find_format(fmt);
        if (!drv) {
            errx(EXIT_FAILURE, "Unknown file format '%s'", fmt);
        }
    } else {
        drv = NULL;
    }

598 599
    bs = bdrv_new("hda");
    srcpath = argv[optind];
600
    ret = bdrv_open(bs, srcpath, NULL, flags, drv, &local_err);
601
    if (ret < 0) {
602
        errno = -ret;
603 604
        err(EXIT_FAILURE, "Failed to bdrv_open '%s': %s", argv[optind],
            error_get_pretty(local_err));
605 606
    }

607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
    if (sn_opts) {
        ret = bdrv_snapshot_load_tmp(bs,
                                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
                                     qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
                                     &local_err);
    } else if (sn_id_or_name) {
        ret = bdrv_snapshot_load_tmp_by_id_or_name(bs, sn_id_or_name,
                                                   &local_err);
    }
    if (ret < 0) {
        errno = -ret;
        err(EXIT_FAILURE,
            "Failed to load snapshot: %s",
            error_get_pretty(local_err));
    }

623
    fd_size = bdrv_getlength(bs);
624

625 626 627 628 629 630
    if (partition != -1) {
        ret = find_partition(bs, partition, &dev_offset, &fd_size);
        if (ret < 0) {
            errno = -ret;
            err(EXIT_FAILURE, "Could not find partition %d", partition);
        }
631 632
    }

633
    exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags, nbd_export_closed);
634

635
    if (sockpath) {
636
        fd = unix_socket_incoming(sockpath);
637
    } else {
638
        fd = tcp_socket_incoming(bindto, port);
639 640
    }

641
    if (fd < 0) {
642
        return 1;
643
    }
644 645 646 647

    if (device) {
        int ret;

648
        ret = pthread_create(&client_thread, NULL, nbd_client_thread, device);
649 650 651 652 653 654 655 656 657
        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));
    }

658 659
    qemu_set_fd_handler2(fd, nbd_can_accept, nbd_accept, NULL,
                         (void *)(uintptr_t)fd);
660

661 662 663 664 665 666
    /* now when the initialization is (almost) complete, chdir("/")
     * to free any busy filesystems */
    if (chdir("/") < 0) {
        err(EXIT_FAILURE, "Could not chdir to root directory");
    }

667
    state = RUNNING;
668
    do {
669
        main_loop_wait(false);
670 671 672 673 674 675 676
        if (state == TERMINATE) {
            state = TERMINATING;
            nbd_export_close(exp);
            nbd_export_put(exp);
            exp = NULL;
        }
    } while (state != TERMINATED);
677

678
    bdrv_close(bs);
679 680 681
    if (sockpath) {
        unlink(sockpath);
    }
682

683 684 685 686
    if (sn_opts) {
        qemu_opts_del(sn_opts);
    }

687 688 689 690 691 692 693
    if (device) {
        void *ret;
        pthread_join(client_thread, &ret);
        exit(ret != NULL);
    } else {
        exit(EXIT_SUCCESS);
    }
694
}