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