Annotation of qemu/qemu-nbd.c, revision 1.1.1.5

1.1       root        1: /*
                      2:  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
                      3:  *
                      4:  *  Network Block Device
                      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
1.1.1.2   root       16:  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
1.1       root       17:  */
                     18: 
                     19: #include <qemu-common.h>
                     20: #include "block_int.h"
                     21: #include "nbd.h"
                     22: 
                     23: #include <stdarg.h>
                     24: #include <stdio.h>
                     25: #include <getopt.h>
                     26: #include <err.h>
                     27: #include <sys/types.h>
                     28: #include <sys/socket.h>
                     29: #include <netinet/in.h>
                     30: #include <netinet/tcp.h>
                     31: #include <arpa/inet.h>
                     32: #include <signal.h>
1.1.1.4   root       33: #include <libgen.h>
1.1       root       34: 
                     35: #define SOCKET_PATH    "/var/lock/qemu-nbd-%s"
                     36: 
                     37: #define NBD_BUFFER_SIZE (1024*1024)
                     38: 
                     39: static int verbose;
                     40: 
                     41: static void usage(const char *name)
                     42: {
                     43:     printf(
                     44: "Usage: %s [OPTIONS] FILE\n"
                     45: "QEMU Disk Network Block Device Server\n"
                     46: "\n"
1.1.1.5 ! root       47: "  -p, --port=PORT      port to listen on (default `%d')\n"
1.1       root       48: "  -o, --offset=OFFSET  offset into the image\n"
                     49: "  -b, --bind=IFACE     interface to bind to (default `0.0.0.0')\n"
                     50: "  -k, --socket=PATH    path to the unix socket\n"
                     51: "                       (default '"SOCKET_PATH"')\n"
                     52: "  -r, --read-only      export read-only\n"
                     53: "  -P, --partition=NUM  only expose partition NUM\n"
                     54: "  -s, --snapshot       use snapshot file\n"
                     55: "  -n, --nocache        disable host cache\n"
                     56: "  -c, --connect=DEV    connect FILE to the local NBD device DEV\n"
                     57: "  -d, --disconnect     disconnect the specified device\n"
                     58: "  -e, --shared=NUM     device can be shared by NUM clients (default '1')\n"
                     59: "  -t, --persistent     don't exit on the last connection\n"
                     60: "  -v, --verbose        display extra debugging information\n"
                     61: "  -h, --help           display this help and exit\n"
                     62: "  -V, --version        output version information and exit\n"
                     63: "\n"
                     64: "Report bugs to <anthony@codemonkey.ws>\n"
1.1.1.5 ! root       65:     , name, NBD_DEFAULT_PORT, "DEVICE");
1.1       root       66: }
                     67: 
                     68: static void version(const char *name)
                     69: {
                     70:     printf(
                     71: "%s version 0.0.1\n"
                     72: "Written by Anthony Liguori.\n"
                     73: "\n"
                     74: "Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>.\n"
                     75: "This is free software; see the source for copying conditions.  There is NO\n"
                     76: "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
                     77:     , name);
                     78: }
                     79: 
                     80: struct partition_record
                     81: {
                     82:     uint8_t bootable;
                     83:     uint8_t start_head;
                     84:     uint32_t start_cylinder;
                     85:     uint8_t start_sector;
                     86:     uint8_t system;
                     87:     uint8_t end_head;
                     88:     uint8_t end_cylinder;
                     89:     uint8_t end_sector;
                     90:     uint32_t start_sector_abs;
                     91:     uint32_t nb_sectors_abs;
                     92: };
                     93: 
                     94: static void read_partition(uint8_t *p, struct partition_record *r)
                     95: {
                     96:     r->bootable = p[0];
                     97:     r->start_head = p[1];
                     98:     r->start_cylinder = p[3] | ((p[2] << 2) & 0x0300);
                     99:     r->start_sector = p[2] & 0x3f;
                    100:     r->system = p[4];
                    101:     r->end_head = p[5];
                    102:     r->end_cylinder = p[7] | ((p[6] << 2) & 0x300);
                    103:     r->end_sector = p[6] & 0x3f;
                    104:     r->start_sector_abs = p[8] | p[9] << 8 | p[10] << 16 | p[11] << 24;
                    105:     r->nb_sectors_abs = p[12] | p[13] << 8 | p[14] << 16 | p[15] << 24;
                    106: }
                    107: 
                    108: static int find_partition(BlockDriverState *bs, int partition,
                    109:                           off_t *offset, off_t *size)
                    110: {
                    111:     struct partition_record mbr[4];
                    112:     uint8_t data[512];
                    113:     int i;
                    114:     int ext_partnum = 4;
1.1.1.4   root      115:     int ret;
1.1       root      116: 
1.1.1.4   root      117:     if ((ret = bdrv_read(bs, 0, data, 1)) < 0) {
                    118:         errno = -ret;
                    119:         err(EXIT_FAILURE, "error while reading");
                    120:     }
1.1       root      121: 
                    122:     if (data[510] != 0x55 || data[511] != 0xaa) {
                    123:         errno = -EINVAL;
                    124:         return -1;
                    125:     }
                    126: 
                    127:     for (i = 0; i < 4; i++) {
                    128:         read_partition(&data[446 + 16 * i], &mbr[i]);
                    129: 
                    130:         if (!mbr[i].nb_sectors_abs)
                    131:             continue;
                    132: 
                    133:         if (mbr[i].system == 0xF || mbr[i].system == 0x5) {
                    134:             struct partition_record ext[4];
                    135:             uint8_t data1[512];
                    136:             int j;
                    137: 
1.1.1.4   root      138:             if ((ret = bdrv_read(bs, mbr[i].start_sector_abs, data1, 1)) < 0) {
                    139:                 errno = -ret;
                    140:                 err(EXIT_FAILURE, "error while reading");
                    141:             }
1.1       root      142: 
                    143:             for (j = 0; j < 4; j++) {
                    144:                 read_partition(&data1[446 + 16 * j], &ext[j]);
                    145:                 if (!ext[j].nb_sectors_abs)
                    146:                     continue;
                    147: 
                    148:                 if ((ext_partnum + j + 1) == partition) {
                    149:                     *offset = (uint64_t)ext[j].start_sector_abs << 9;
                    150:                     *size = (uint64_t)ext[j].nb_sectors_abs << 9;
                    151:                     return 0;
                    152:                 }
                    153:             }
                    154:             ext_partnum += 4;
                    155:         } else if ((i + 1) == partition) {
                    156:             *offset = (uint64_t)mbr[i].start_sector_abs << 9;
                    157:             *size = (uint64_t)mbr[i].nb_sectors_abs << 9;
                    158:             return 0;
                    159:         }
                    160:     }
                    161: 
                    162:     errno = -ENOENT;
                    163:     return -1;
                    164: }
                    165: 
                    166: static void show_parts(const char *device)
                    167: {
                    168:     if (fork() == 0) {
                    169:         int nbd;
                    170: 
                    171:         /* linux just needs an open() to trigger
                    172:          * the partition table update
                    173:          * but remember to load the module with max_part != 0 :
                    174:          *     modprobe nbd max_part=63
                    175:          */
                    176:         nbd = open(device, O_RDWR);
                    177:         if (nbd != -1)
                    178:               close(nbd);
                    179:         exit(0);
                    180:     }
                    181: }
                    182: 
                    183: int main(int argc, char **argv)
                    184: {
                    185:     BlockDriverState *bs;
                    186:     off_t dev_offset = 0;
                    187:     off_t offset = 0;
                    188:     bool readonly = false;
                    189:     bool disconnect = false;
                    190:     const char *bindto = "0.0.0.0";
1.1.1.5 ! root      191:     int port = NBD_DEFAULT_PORT;
1.1       root      192:     struct sockaddr_in addr;
                    193:     socklen_t addr_len = sizeof(addr);
                    194:     off_t fd_size;
                    195:     char *device = NULL;
                    196:     char *socket = NULL;
                    197:     char sockpath[128];
                    198:     const char *sopt = "hVb:o:p:rsnP:c:dvk:e:t";
                    199:     struct option lopt[] = {
1.1.1.2   root      200:         { "help", 0, NULL, 'h' },
                    201:         { "version", 0, NULL, 'V' },
                    202:         { "bind", 1, NULL, 'b' },
                    203:         { "port", 1, NULL, 'p' },
                    204:         { "socket", 1, NULL, 'k' },
                    205:         { "offset", 1, NULL, 'o' },
                    206:         { "read-only", 0, NULL, 'r' },
                    207:         { "partition", 1, NULL, 'P' },
                    208:         { "connect", 1, NULL, 'c' },
                    209:         { "disconnect", 0, NULL, 'd' },
                    210:         { "snapshot", 0, NULL, 's' },
                    211:         { "nocache", 0, NULL, 'n' },
                    212:         { "shared", 1, NULL, 'e' },
                    213:         { "persistent", 0, NULL, 't' },
                    214:         { "verbose", 0, NULL, 'v' },
                    215:         { NULL, 0, NULL, 0 }
1.1       root      216:     };
                    217:     int ch;
                    218:     int opt_ind = 0;
                    219:     int li;
                    220:     char *end;
1.1.1.4   root      221:     int flags = BDRV_O_RDWR;
1.1       root      222:     int partition = -1;
                    223:     int ret;
                    224:     int shared = 1;
                    225:     uint8_t *data;
                    226:     fd_set fds;
                    227:     int *sharing_fds;
                    228:     int fd;
                    229:     int i;
                    230:     int nb_fds = 0;
                    231:     int max_fd;
                    232:     int persistent = 0;
1.1.1.5 ! root      233:     uint32_t nbdflags;
1.1       root      234: 
                    235:     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
                    236:         switch (ch) {
                    237:         case 's':
                    238:             flags |= BDRV_O_SNAPSHOT;
                    239:             break;
                    240:         case 'n':
                    241:             flags |= BDRV_O_NOCACHE;
                    242:             break;
                    243:         case 'b':
                    244:             bindto = optarg;
                    245:             break;
                    246:         case 'p':
                    247:             li = strtol(optarg, &end, 0);
                    248:             if (*end) {
1.1.1.4   root      249:                 errx(EXIT_FAILURE, "Invalid port `%s'", optarg);
1.1       root      250:             }
                    251:             if (li < 1 || li > 65535) {
1.1.1.4   root      252:                 errx(EXIT_FAILURE, "Port out of range `%s'", optarg);
1.1       root      253:             }
                    254:             port = (uint16_t)li;
                    255:             break;
                    256:         case 'o':
                    257:                 dev_offset = strtoll (optarg, &end, 0);
                    258:             if (*end) {
1.1.1.4   root      259:                 errx(EXIT_FAILURE, "Invalid offset `%s'", optarg);
1.1       root      260:             }
                    261:             if (dev_offset < 0) {
1.1.1.4   root      262:                 errx(EXIT_FAILURE, "Offset must be positive `%s'", optarg);
1.1       root      263:             }
                    264:             break;
                    265:         case 'r':
                    266:             readonly = true;
1.1.1.4   root      267:             flags &= ~BDRV_O_RDWR;
1.1       root      268:             break;
                    269:         case 'P':
                    270:             partition = strtol(optarg, &end, 0);
                    271:             if (*end)
1.1.1.4   root      272:                 errx(EXIT_FAILURE, "Invalid partition `%s'", optarg);
1.1       root      273:             if (partition < 1 || partition > 8)
1.1.1.4   root      274:                 errx(EXIT_FAILURE, "Invalid partition %d", partition);
1.1       root      275:             break;
                    276:         case 'k':
                    277:             socket = optarg;
                    278:             if (socket[0] != '/')
1.1.1.4   root      279:                 errx(EXIT_FAILURE, "socket path must be absolute\n");
1.1       root      280:             break;
                    281:         case 'd':
                    282:             disconnect = true;
                    283:             break;
                    284:         case 'c':
                    285:             device = optarg;
                    286:             break;
                    287:         case 'e':
                    288:             shared = strtol(optarg, &end, 0);
                    289:             if (*end) {
1.1.1.4   root      290:                 errx(EXIT_FAILURE, "Invalid shared device number '%s'", optarg);
1.1       root      291:             }
                    292:             if (shared < 1) {
1.1.1.4   root      293:                 errx(EXIT_FAILURE, "Shared device number must be greater than 0\n");
1.1       root      294:             }
                    295:             break;
                    296:        case 't':
                    297:            persistent = 1;
                    298:            break;
                    299:         case 'v':
                    300:             verbose = 1;
                    301:             break;
                    302:         case 'V':
                    303:             version(argv[0]);
                    304:             exit(0);
                    305:             break;
                    306:         case 'h':
                    307:             usage(argv[0]);
                    308:             exit(0);
                    309:             break;
                    310:         case '?':
1.1.1.4   root      311:             errx(EXIT_FAILURE, "Try `%s --help' for more information.",
1.1       root      312:                  argv[0]);
                    313:         }
                    314:     }
                    315: 
                    316:     if ((argc - optind) != 1) {
1.1.1.4   root      317:         errx(EXIT_FAILURE, "Invalid number of argument.\n"
1.1       root      318:              "Try `%s --help' for more information.",
                    319:              argv[0]);
                    320:     }
                    321: 
                    322:     if (disconnect) {
                    323:         fd = open(argv[optind], O_RDWR);
                    324:         if (fd == -1)
1.1.1.4   root      325:             err(EXIT_FAILURE, "Cannot open %s", argv[optind]);
1.1       root      326: 
                    327:         nbd_disconnect(fd);
                    328: 
                    329:         close(fd);
                    330: 
                    331:         printf("%s disconnected\n", argv[optind]);
                    332: 
                    333:        return 0;
                    334:     }
                    335: 
                    336:     bdrv_init();
                    337: 
                    338:     bs = bdrv_new("hda");
                    339: 
1.1.1.4   root      340:     if ((ret = bdrv_open(bs, argv[optind], flags, NULL)) < 0) {
                    341:         errno = -ret;
                    342:         err(EXIT_FAILURE, "Failed to bdrv_open '%s'", argv[optind]);
                    343:     }
1.1       root      344: 
                    345:     fd_size = bs->total_sectors * 512;
                    346: 
                    347:     if (partition != -1 &&
                    348:         find_partition(bs, partition, &dev_offset, &fd_size))
1.1.1.4   root      349:         err(EXIT_FAILURE, "Could not find partition %d", partition);
1.1       root      350: 
                    351:     if (device) {
                    352:         pid_t pid;
                    353:         int sock;
                    354: 
1.1.1.4   root      355:         /* want to fail before daemonizing */
                    356:         if (access(device, R_OK|W_OK) == -1) {
                    357:             err(EXIT_FAILURE, "Could not access '%s'", device);
                    358:         }
                    359: 
1.1.1.2   root      360:         if (!verbose) {
                    361:             /* detach client and server */
                    362:             if (daemon(0, 0) == -1) {
1.1.1.4   root      363:                 err(EXIT_FAILURE, "Failed to daemonize");
1.1.1.2   root      364:             }
                    365:         }
1.1       root      366: 
                    367:         if (socket == NULL) {
1.1.1.4   root      368:             snprintf(sockpath, sizeof(sockpath), SOCKET_PATH,
                    369:                      basename(device));
1.1       root      370:             socket = sockpath;
                    371:         }
                    372: 
                    373:         pid = fork();
                    374:         if (pid < 0)
                    375:             return 1;
                    376:         if (pid != 0) {
                    377:             off_t size;
                    378:             size_t blocksize;
                    379: 
                    380:             ret = 0;
                    381:             bdrv_close(bs);
                    382: 
                    383:             do {
                    384:                 sock = unix_socket_outgoing(socket);
                    385:                 if (sock == -1) {
1.1.1.4   root      386:                     if (errno != ENOENT && errno != ECONNREFUSED) {
                    387:                         ret = 1;
1.1       root      388:                         goto out;
1.1.1.4   root      389:                     }
1.1       root      390:                     sleep(1);  /* wait children */
                    391:                 }
                    392:             } while (sock == -1);
                    393: 
                    394:             fd = open(device, O_RDWR);
                    395:             if (fd == -1) {
                    396:                 ret = 1;
                    397:                 goto out;
                    398:             }
                    399: 
1.1.1.5 ! root      400:             ret = nbd_receive_negotiate(sock, NULL, &nbdflags,
        !           401:                                        &size, &blocksize);
1.1       root      402:             if (ret == -1) {
                    403:                 ret = 1;
                    404:                 goto out;
                    405:             }
                    406: 
                    407:             ret = nbd_init(fd, sock, size, blocksize);
                    408:             if (ret == -1) {
                    409:                 ret = 1;
                    410:                 goto out;
                    411:             }
                    412: 
                    413:             printf("NBD device %s is now connected to file %s\n",
                    414:                     device, argv[optind]);
                    415: 
                    416:            /* update partition table */
                    417: 
                    418:             show_parts(device);
                    419: 
1.1.1.5 ! root      420:             ret = nbd_client(fd);
        !           421:             if (ret) {
        !           422:                 ret = 1;
        !           423:             }
1.1       root      424:             close(fd);
                    425:  out:
                    426:             kill(pid, SIGTERM);
                    427:             unlink(socket);
                    428: 
                    429:             return ret;
                    430:         }
                    431:         /* children */
                    432:     }
                    433: 
                    434:     sharing_fds = qemu_malloc((shared + 1) * sizeof(int));
                    435: 
                    436:     if (socket) {
                    437:         sharing_fds[0] = unix_socket_incoming(socket);
                    438:     } else {
                    439:         sharing_fds[0] = tcp_socket_incoming(bindto, port);
                    440:     }
                    441: 
                    442:     if (sharing_fds[0] == -1)
                    443:         return 1;
                    444:     max_fd = sharing_fds[0];
                    445:     nb_fds++;
                    446: 
1.1.1.5 ! root      447:     data = qemu_blockalign(bs, NBD_BUFFER_SIZE);
1.1       root      448:     if (data == NULL)
1.1.1.4   root      449:         errx(EXIT_FAILURE, "Cannot allocate data buffer");
1.1       root      450: 
                    451:     do {
                    452: 
                    453:         FD_ZERO(&fds);
                    454:         for (i = 0; i < nb_fds; i++)
                    455:             FD_SET(sharing_fds[i], &fds);
                    456: 
                    457:         ret = select(max_fd + 1, &fds, NULL, NULL, NULL);
                    458:         if (ret == -1)
                    459:             break;
                    460: 
                    461:         if (FD_ISSET(sharing_fds[0], &fds))
                    462:             ret--;
                    463:         for (i = 1; i < nb_fds && ret; i++) {
                    464:             if (FD_ISSET(sharing_fds[i], &fds)) {
                    465:                 if (nbd_trip(bs, sharing_fds[i], fd_size, dev_offset,
                    466:                     &offset, readonly, data, NBD_BUFFER_SIZE) != 0) {
                    467:                     close(sharing_fds[i]);
                    468:                     nb_fds--;
                    469:                     sharing_fds[i] = sharing_fds[nb_fds];
                    470:                     i--;
                    471:                 }
                    472:                 ret--;
                    473:             }
                    474:         }
                    475:         /* new connection ? */
                    476:         if (FD_ISSET(sharing_fds[0], &fds)) {
                    477:             if (nb_fds < shared + 1) {
                    478:                 sharing_fds[nb_fds] = accept(sharing_fds[0],
                    479:                                              (struct sockaddr *)&addr,
                    480:                                              &addr_len);
                    481:                 if (sharing_fds[nb_fds] != -1 &&
                    482:                     nbd_negotiate(sharing_fds[nb_fds], fd_size) != -1) {
                    483:                         if (sharing_fds[nb_fds] > max_fd)
                    484:                             max_fd = sharing_fds[nb_fds];
                    485:                         nb_fds++;
                    486:                 }
                    487:             }
                    488:         }
                    489:     } while (persistent || nb_fds > 1);
1.1.1.3   root      490:     qemu_vfree(data);
1.1       root      491: 
                    492:     close(sharing_fds[0]);
                    493:     bdrv_close(bs);
                    494:     qemu_free(sharing_fds);
                    495:     if (socket)
                    496:         unlink(socket);
                    497: 
                    498:     return 0;
                    499: }

unix.superglobalmegacorp.com