contrib/vhost-user-blk/vhost-user-blk.c

   1 /*
   2  * vhost-user-blk sample application
   3  *
   4  * Copyright (c) 2017 Intel Corporation. All rights reserved.
   5  *
   6  * Author:
   7  *  Changpeng Liu <changpeng.liu@intel.com>
   8  *
   9  * This work is based on the "vhost-user-scsi" sample and "virtio-blk" driver
  10  * implementation by:
  11  *  Felipe Franciosi <felipe@nutanix.com>
  12  *  Anthony Liguori <aliguori@us.ibm.com>
  13  *
  14  * This work is licensed under the terms of the GNU GPL, version 2 only.
  15  * See the COPYING file in the top-level directory.
  16  */
  17
  18 #include "qemu/osdep.h"
  19 #include "qemu/bswap.h"
  20 #include "standard-headers/linux/virtio_blk.h"
  21 #include "libvhost-user-glib.h"
  22
  23 #if defined(__linux__)
  24 #include <linux/fs.h>
  25 #include <sys/ioctl.h>
  26 #endif
  27
  28 enum {
  29     VHOST_USER_BLK_MAX_QUEUES = 8,
  30 };
  31
  32 struct virtio_blk_inhdr {
  33     unsigned char status;
  34 };
  35
  36 /* vhost user block device */
  37 typedef struct VubDev {
  38     VugDev parent;
  39     int blk_fd;
  40     struct virtio_blk_config blkcfg;
  41     bool enable_ro;
  42     char *blk_name;
  43     GMainLoop *loop;
  44 } VubDev;
  45
  46 typedef struct VubReq {
  47     VuVirtqElement *elem;
  48     int64_t sector_num;
  49     size_t size;
  50     struct virtio_blk_inhdr *in;
  51     struct virtio_blk_outhdr *out;
  52     VubDev *vdev_blk;
  53     struct VuVirtq *vq;
  54 } VubReq;
  55
  56 /* refer util/iov.c */
  57 static size_t vub_iov_size(const struct iovec *iov,
  58                               const unsigned int iov_cnt)
  59 {
  60     size_t len;
  61     unsigned int i;
  62
  63     len = 0;
  64     for (i = 0; i < iov_cnt; i++) {
  65         len += iov[i].iov_len;
  66     }
  67     return len;
  68 }
  69
  70 static size_t vub_iov_to_buf(const struct iovec *iov,
  71                              const unsigned int iov_cnt, void *buf)
  72 {
  73     size_t len;
  74     unsigned int i;
  75
  76     len = 0;
  77     for (i = 0; i < iov_cnt; i++) {
  78         memcpy(buf + len,  iov[i].iov_base, iov[i].iov_len);
  79         len += iov[i].iov_len;
  80     }
  81     return len;
  82 }
  83
  84 static void vub_panic_cb(VuDev *vu_dev, const char *buf)
  85 {
  86     VugDev *gdev;
  87     VubDev *vdev_blk;
  88
  89     assert(vu_dev);
  90
  91     gdev = container_of(vu_dev, VugDev, parent);
  92     vdev_blk = container_of(gdev, VubDev, parent);
  93     if (buf) {
  94         g_warning("vu_panic: %s", buf);
  95     }
  96
  97     g_main_loop_quit(vdev_blk->loop);
  98 }
  99
 100 static void vub_req_complete(VubReq *req)
 101 {
 102     VugDev *gdev = &req->vdev_blk->parent;
 103     VuDev *vu_dev = &gdev->parent;
 104
 105     /* IO size with 1 extra status byte */
 106     vu_queue_push(vu_dev, req->vq, req->elem,
 107                   req->size + 1);
 108     vu_queue_notify(vu_dev, req->vq);
 109
 110     g_free(req->elem);
 111     g_free(req);
 112 }
 113
 114 static int vub_open(const char *file_name, bool wce)
 115 {
 116     int fd;
 117     int flags = O_RDWR;
 118
 119     if (!wce) {
 120         flags |= O_DIRECT;
 121     }
 122
 123     fd = open(file_name, flags);
 124     if (fd < 0) {
 125         fprintf(stderr, "Cannot open file %s, %s\n", file_name,
 126                 strerror(errno));
 127         return -1;
 128     }
 129
 130     return fd;
 131 }
 132
 133 static ssize_t
 134 vub_readv(VubReq *req, struct iovec *iov, uint32_t iovcnt)
 135 {
 136     VubDev *vdev_blk = req->vdev_blk;
 137     ssize_t rc;
 138
 139     if (!iovcnt) {
 140         fprintf(stderr, "Invalid Read IOV count\n");
 141         return -1;
 142     }
 143
 144     req->size = vub_iov_size(iov, iovcnt);
 145     rc = preadv(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512);
 146     if (rc < 0) {
 147         fprintf(stderr, "%s, Sector %"PRIu64", Size %zu failed with %s\n",
 148                 vdev_blk->blk_name, req->sector_num, req->size,
 149                 strerror(errno));
 150         return -1;
 151     }
 152
 153     return rc;
 154 }
 155
 156 static ssize_t
 157 vub_writev(VubReq *req, struct iovec *iov, uint32_t iovcnt)
 158 {
 159     VubDev *vdev_blk = req->vdev_blk;
 160     ssize_t rc;
 161
 162     if (!iovcnt) {
 163         fprintf(stderr, "Invalid Write IOV count\n");
 164         return -1;
 165     }
 166
 167     req->size = vub_iov_size(iov, iovcnt);
 168     rc = pwritev(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512);
 169     if (rc < 0) {
 170         fprintf(stderr, "%s, Sector %"PRIu64", Size %zu failed with %s\n",
 171                 vdev_blk->blk_name, req->sector_num, req->size,
 172                 strerror(errno));
 173         return -1;
 174     }
 175
 176     return rc;
 177 }
 178
 179 static int
 180 vub_discard_write_zeroes(VubReq *req, struct iovec *iov, uint32_t iovcnt,
 181                          uint32_t type)
 182 {
 183     struct virtio_blk_discard_write_zeroes *desc;
 184     ssize_t size;
 185     void *buf;
 186
 187     size = vub_iov_size(iov, iovcnt);
 188     if (size != sizeof(*desc)) {
 189         fprintf(stderr, "Invalid size %zd, expect %zd\n", size, sizeof(*desc));
 190         return -1;
 191     }
 192     buf = g_new0(char, size);
 193     vub_iov_to_buf(iov, iovcnt, buf);
 194
 195     #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
 196     VubDev *vdev_blk = req->vdev_blk;
 197     desc = buf;
 198     uint64_t range[2] = { le64_to_cpu(desc->sector) << 9,
 199                           (uint64_t)le32_to_cpu(desc->num_sectors) << 9 };
 200     if (type == VIRTIO_BLK_T_DISCARD) {
 201         if (ioctl(vdev_blk->blk_fd, BLKDISCARD, range) == 0) {
 202             g_free(buf);
 203             return 0;
 204         }
 205     } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
 206         if (ioctl(vdev_blk->blk_fd, BLKZEROOUT, range) == 0) {
 207             g_free(buf);
 208             return 0;
 209         }
 210     }
 211     #endif
 212
 213     g_free(buf);
 214     return -1;
 215 }
 216
 217 static void
 218 vub_flush(VubReq *req)
 219 {
 220     VubDev *vdev_blk = req->vdev_blk;
 221
 222     fdatasync(vdev_blk->blk_fd);
 223 }
 224
 225 static int vub_virtio_process_req(VubDev *vdev_blk,
 226                                      VuVirtq *vq)
 227 {
 228     VugDev *gdev = &vdev_blk->parent;
 229     VuDev *vu_dev = &gdev->parent;
 230     VuVirtqElement *elem;
 231     uint32_t type;
 232     unsigned in_num;
 233     unsigned out_num;
 234     VubReq *req;
 235
 236     elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + sizeof(VubReq));
 237     if (!elem) {
 238         return -1;
 239     }
 240
 241     /* refer to hw/block/virtio_blk.c */
 242     if (elem->out_num < 1 || elem->in_num < 1) {
 243         fprintf(stderr, "virtio-blk request missing headers\n");
 244         g_free(elem);
 245         return -1;
 246     }
 247
 248     req = g_new0(VubReq, 1);
 249     req->vdev_blk = vdev_blk;
 250     req->vq = vq;
 251     req->elem = elem;
 252
 253     in_num = elem->in_num;
 254     out_num = elem->out_num;
 255
 256     /* don't support VIRTIO_F_ANY_LAYOUT and virtio 1.0 only */
 257     if (elem->out_sg[0].iov_len < sizeof(struct virtio_blk_outhdr)) {
 258         fprintf(stderr, "Invalid outhdr size\n");
 259         goto err;
 260     }
 261     req->out = (struct virtio_blk_outhdr *)elem->out_sg[0].iov_base;
 262     out_num--;
 263
 264     if (elem->in_sg[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
 265         fprintf(stderr, "Invalid inhdr size\n");
 266         goto err;
 267     }
 268     req->in = (struct virtio_blk_inhdr *)elem->in_sg[in_num - 1].iov_base;
 269     in_num--;
 270
 271     type = le32_to_cpu(req->out->type);
 272     switch (type & ~VIRTIO_BLK_T_BARRIER) {
 273     case VIRTIO_BLK_T_IN:
 274     case VIRTIO_BLK_T_OUT: {
 275         ssize_t ret = 0;
 276         bool is_write = type & VIRTIO_BLK_T_OUT;
 277         req->sector_num = le64_to_cpu(req->out->sector);
 278         if (is_write) {
 279             ret  = vub_writev(req, &elem->out_sg[1], out_num);
 280         } else {
 281             ret = vub_readv(req, &elem->in_sg[0], in_num);
 282         }
 283         if (ret >= 0) {
 284             req->in->status = VIRTIO_BLK_S_OK;
 285         } else {
 286             req->in->status = VIRTIO_BLK_S_IOERR;
 287         }
 288         vub_req_complete(req);
 289         break;
 290     }
 291     case VIRTIO_BLK_T_FLUSH:
 292         vub_flush(req);
 293         req->in->status = VIRTIO_BLK_S_OK;
 294         vub_req_complete(req);
 295         break;
 296     case VIRTIO_BLK_T_GET_ID: {
 297         size_t size = MIN(vub_iov_size(&elem->in_sg[0], in_num),
 298                           VIRTIO_BLK_ID_BYTES);
 299         snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
 300         req->in->status = VIRTIO_BLK_S_OK;
 301         req->size = elem->in_sg[0].iov_len;
 302         vub_req_complete(req);
 303         break;
 304     }
 305     case VIRTIO_BLK_T_DISCARD:
 306     case VIRTIO_BLK_T_WRITE_ZEROES: {
 307         int rc;
 308         rc = vub_discard_write_zeroes(req, &elem->out_sg[1], out_num, type);
 309         if (rc == 0) {
 310             req->in->status = VIRTIO_BLK_S_OK;
 311         } else {
 312             req->in->status = VIRTIO_BLK_S_IOERR;
 313         }
 314         vub_req_complete(req);
 315         break;
 316     }
 317     default:
 318         req->in->status = VIRTIO_BLK_S_UNSUPP;
 319         vub_req_complete(req);
 320         break;
 321     }
 322
 323     return 0;
 324
 325 err:
 326     g_free(elem);
 327     g_free(req);
 328     return -1;
 329 }
 330
 331 static void vub_process_vq(VuDev *vu_dev, int idx)
 332 {
 333     VugDev *gdev;
 334     VubDev *vdev_blk;
 335     VuVirtq *vq;
 336     int ret;
 337
 338     gdev = container_of(vu_dev, VugDev, parent);
 339     vdev_blk = container_of(gdev, VubDev, parent);
 340     assert(vdev_blk);
 341
 342     vq = vu_get_queue(vu_dev, idx);
 343     assert(vq);
 344
 345     while (1) {
 346         ret = vub_virtio_process_req(vdev_blk, vq);
 347         if (ret) {
 348             break;
 349         }
 350     }
 351 }
 352
 353 static void vub_queue_set_started(VuDev *vu_dev, int idx, bool started)
 354 {
 355     VuVirtq *vq;
 356
 357     assert(vu_dev);
 358
 359     vq = vu_get_queue(vu_dev, idx);
 360     vu_set_queue_handler(vu_dev, vq, started ? vub_process_vq : NULL);
 361 }
 362
 363 static uint64_t
 364 vub_get_features(VuDev *dev)
 365 {
 366     uint64_t features;
 367     VugDev *gdev;
 368     VubDev *vdev_blk;
 369
 370     gdev = container_of(dev, VugDev, parent);
 371     vdev_blk = container_of(gdev, VubDev, parent);
 372
 373     features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
 374                1ull << VIRTIO_BLK_F_SEG_MAX |
 375                1ull << VIRTIO_BLK_F_TOPOLOGY |
 376                1ull << VIRTIO_BLK_F_BLK_SIZE |
 377                1ull << VIRTIO_BLK_F_FLUSH |
 378                #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
 379                1ull << VIRTIO_BLK_F_DISCARD |
 380                1ull << VIRTIO_BLK_F_WRITE_ZEROES |
 381                #endif
 382                1ull << VIRTIO_BLK_F_CONFIG_WCE;
 383
 384     if (vdev_blk->enable_ro) {
 385         features |= 1ull << VIRTIO_BLK_F_RO;
 386     }
 387
 388     return features;
 389 }
 390
 391 static uint64_t
 392 vub_get_protocol_features(VuDev *dev)
 393 {
 394     return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
 395            1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
 396 }
 397
 398 static int
 399 vub_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 400 {
 401     VugDev *gdev;
 402     VubDev *vdev_blk;
 403
 404     if (len > sizeof(struct virtio_blk_config)) {
 405         return -1;
 406     }
 407
 408     gdev = container_of(vu_dev, VugDev, parent);
 409     vdev_blk = container_of(gdev, VubDev, parent);
 410     memcpy(config, &vdev_blk->blkcfg, len);
 411
 412     return 0;
 413 }
 414
 415 static int
 416 vub_set_config(VuDev *vu_dev, const uint8_t *data,
 417                uint32_t offset, uint32_t size, uint32_t flags)
 418 {
 419     VugDev *gdev;
 420     VubDev *vdev_blk;
 421     uint8_t wce;
 422     int fd;
 423
 424     /* don't support live migration */
 425     if (flags != VHOST_SET_CONFIG_TYPE_FRONTEND) {
 426         return -1;
 427     }
 428
 429     gdev = container_of(vu_dev, VugDev, parent);
 430     vdev_blk = container_of(gdev, VubDev, parent);
 431
 432     if (offset != offsetof(struct virtio_blk_config, wce) ||
 433         size != 1) {
 434         return -1;
 435     }
 436
 437     wce = *data;
 438     if (wce == vdev_blk->blkcfg.wce) {
 439         /* Do nothing as same with old configuration */
 440         return 0;
 441     }
 442
 443     vdev_blk->blkcfg.wce = wce;
 444     fprintf(stdout, "Write Cache Policy Changed\n");
 445     if (vdev_blk->blk_fd >= 0) {
 446         close(vdev_blk->blk_fd);
 447         vdev_blk->blk_fd = -1;
 448     }
 449
 450     fd = vub_open(vdev_blk->blk_name, wce);
 451     if (fd < 0) {
 452         fprintf(stderr, "Error to open block device %s\n", vdev_blk->blk_name);
 453         vdev_blk->blk_fd = -1;
 454         return -1;
 455     }
 456     vdev_blk->blk_fd = fd;
 457
 458     return 0;
 459 }
 460
 461 static const VuDevIface vub_iface = {
 462     .get_features = vub_get_features,
 463     .queue_set_started = vub_queue_set_started,
 464     .get_protocol_features = vub_get_protocol_features,
 465     .get_config = vub_get_config,
 466     .set_config = vub_set_config,
 467 };
 468
 469 static int unix_sock_new(char *unix_fn)
 470 {
 471     int sock;
 472     struct sockaddr_un un;
 473
 474     assert(unix_fn);
 475
 476     sock = socket(AF_UNIX, SOCK_STREAM, 0);
 477     if (sock < 0) {
 478         perror("socket");
 479         return -1;
 480     }
 481
 482     un.sun_family = AF_UNIX;
 483     (void)snprintf(un.sun_path, sizeof(un.sun_path), "%s", unix_fn);
 484
 485     (void)unlink(unix_fn);
 486     if (bind(sock, (struct sockaddr *)&un, sizeof(un)) < 0) {
 487         perror("bind");
 488         goto fail;
 489     }
 490
 491     if (listen(sock, 1) < 0) {
 492         perror("listen");
 493         goto fail;
 494     }
 495
 496     return sock;
 497
 498 fail:
 499     (void)close(sock);
 500
 501     return -1;
 502 }
 503
 504 static void vub_free(struct VubDev *vdev_blk)
 505 {
 506     if (!vdev_blk) {
 507         return;
 508     }
 509
 510     g_main_loop_unref(vdev_blk->loop);
 511     if (vdev_blk->blk_fd >= 0) {
 512         close(vdev_blk->blk_fd);
 513     }
 514     g_free(vdev_blk);
 515 }
 516
 517 static uint32_t
 518 vub_get_blocksize(int fd)
 519 {
 520     uint32_t blocksize = 512;
 521
 522 #if defined(__linux__) && defined(BLKSSZGET)
 523     if (ioctl(fd, BLKSSZGET, &blocksize) == 0) {
 524         return blocksize;
 525     }
 526 #endif
 527
 528     return blocksize;
 529 }
 530
 531 static void
 532 vub_initialize_config(int fd, struct virtio_blk_config *config)
 533 {
 534     off_t capacity;
 535
 536     capacity = lseek(fd, 0, SEEK_END);
 537     config->capacity = capacity >> 9;
 538     config->blk_size = vub_get_blocksize(fd);
 539     config->size_max = 65536;
 540     config->seg_max = 128 - 2;
 541     config->min_io_size = 1;
 542     config->opt_io_size = 1;
 543     config->num_queues = 1;
 544     #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
 545     config->max_discard_sectors = 32768;
 546     config->max_discard_seg = 1;
 547     config->discard_sector_alignment = config->blk_size >> 9;
 548     config->max_write_zeroes_sectors = 32768;
 549     config->max_write_zeroes_seg = 1;
 550     #endif
 551 }
 552
 553 static VubDev *
 554 vub_new(char *blk_file)
 555 {
 556     VubDev *vdev_blk;
 557
 558     vdev_blk = g_new0(VubDev, 1);
 559     vdev_blk->loop = g_main_loop_new(NULL, FALSE);
 560     vdev_blk->blk_fd = vub_open(blk_file, 0);
 561     if (vdev_blk->blk_fd  < 0) {
 562         fprintf(stderr, "Error to open block device %s\n", blk_file);
 563         vub_free(vdev_blk);
 564         return NULL;
 565     }
 566     vdev_blk->enable_ro = false;
 567     vdev_blk->blkcfg.wce = 0;
 568     vdev_blk->blk_name = blk_file;
 569
 570     /* fill virtio_blk_config with block parameters */
 571     vub_initialize_config(vdev_blk->blk_fd, &vdev_blk->blkcfg);
 572
 573     return vdev_blk;
 574 }
 575
 576 static int opt_fdnum = -1;
 577 static char *opt_socket_path;
 578 static char *opt_blk_file;
 579 static gboolean opt_print_caps;
 580 static gboolean opt_read_only;
 581
 582 static GOptionEntry entries[] = {
 583     { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps,
 584       "Print capabilities", NULL },
 585     { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum,
 586       "Use inherited fd socket", "FDNUM" },
 587     { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path,
 588       "Use UNIX socket path", "PATH" },
 589     {"blk-file", 'b', 0, G_OPTION_ARG_FILENAME, &opt_blk_file,
 590      "block device or file path", "PATH"},
 591     { "read-only", 'r', 0, G_OPTION_ARG_NONE, &opt_read_only,
 592       "Enable read-only", NULL },
 593     { NULL, },
 594 };
 595
 596 int main(int argc, char **argv)
 597 {
 598     int lsock = -1, csock = -1;
 599     VubDev *vdev_blk = NULL;
 600     GError *error = NULL;
 601     GOptionContext *context;
 602
 603     context = g_option_context_new(NULL);
 604     g_option_context_add_main_entries(context, entries, NULL);
 605     if (!g_option_context_parse(context, &argc, &argv, &error)) {
 606         g_printerr("Option parsing failed: %s\n", error->message);
 607         exit(EXIT_FAILURE);
 608     }
 609     if (opt_print_caps) {
 610         g_print("{\n");
 611         g_print("  \"type\": \"block\",\n");
 612         g_print("  \"features\": [\n");
 613         g_print("    \"read-only\",\n");
 614         g_print("    \"blk-file\"\n");
 615         g_print("  ]\n");
 616         g_print("}\n");
 617         exit(EXIT_SUCCESS);
 618     }
 619
 620     if (!opt_blk_file) {
 621         g_print("%s\n", g_option_context_get_help(context, true, NULL));
 622         exit(EXIT_FAILURE);
 623     }
 624
 625     if (opt_socket_path) {
 626         lsock = unix_sock_new(opt_socket_path);
 627         if (lsock < 0) {
 628             exit(EXIT_FAILURE);
 629         }
 630     } else if (opt_fdnum < 0) {
 631         g_print("%s\n", g_option_context_get_help(context, true, NULL));
 632         exit(EXIT_FAILURE);
 633     } else {
 634         lsock = opt_fdnum;
 635     }
 636
 637     csock = accept(lsock, NULL, NULL);
 638     if (csock < 0) {
 639         g_printerr("Accept error %s\n", strerror(errno));
 640         exit(EXIT_FAILURE);
 641     }
 642
 643     vdev_blk = vub_new(opt_blk_file);
 644     if (!vdev_blk) {
 645         exit(EXIT_FAILURE);
 646     }
 647     if (opt_read_only) {
 648         vdev_blk->enable_ro = true;
 649     }
 650
 651     if (!vug_init(&vdev_blk->parent, VHOST_USER_BLK_MAX_QUEUES, csock,
 652                   vub_panic_cb, &vub_iface)) {
 653         g_printerr("Failed to initialize libvhost-user-glib\n");
 654         exit(EXIT_FAILURE);
 655     }
 656
 657     g_main_loop_run(vdev_blk->loop);
 658     g_main_loop_unref(vdev_blk->loop);
 659     g_option_context_free(context);
 660     vug_deinit(&vdev_blk->parent);
 661     vub_free(vdev_blk);
 662     if (csock >= 0) {
 663         close(csock);
 664     }
 665     if (lsock >= 0) {
 666         close(lsock);
 667     }
 668     g_free(opt_socket_path);
 669     g_free(opt_blk_file);
 670
 671     return 0;
 672 }