block/export/vhost-user-blk-server.c

   1 /*
   2  * Sharing QEMU block devices via vhost-user protocal
   3  *
   4  * Parts of the code based on nbd/server.c.
   5  *
   6  * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
   7  * Copyright (c) 2020 Red Hat, Inc.
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or
  10  * later.  See the COPYING file in the top-level directory.
  11  */
  12 #include "qemu/osdep.h"
  13 #include "block/block.h"
  14 #include "subprojects/libvhost-user/libvhost-user.h" /* only for the type definitions */
  15 #include "standard-headers/linux/virtio_blk.h"
  16 #include "qemu/vhost-user-server.h"
  17 #include "vhost-user-blk-server.h"
  18 #include "qapi/error.h"
  19 #include "qom/object_interfaces.h"
  20 #include "sysemu/block-backend.h"
  21 #include "util/block-helpers.h"
  22
  23 /*
  24  * Sector units are 512 bytes regardless of the
  25  * virtio_blk_config->blk_size value.
  26  */
  27 #define VIRTIO_BLK_SECTOR_BITS 9
  28 #define VIRTIO_BLK_SECTOR_SIZE (1ull << VIRTIO_BLK_SECTOR_BITS)
  29
  30 enum {
  31     VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
  32     VHOST_USER_BLK_MAX_DISCARD_SECTORS = 32768,
  33     VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS = 32768,
  34 };
  35 struct virtio_blk_inhdr {
  36     unsigned char status;
  37 };
  38
  39 typedef struct VuBlkReq {
  40     VuVirtqElement elem;
  41     int64_t sector_num;
  42     size_t size;
  43     struct virtio_blk_inhdr *in;
  44     struct virtio_blk_outhdr out;
  45     VuServer *server;
  46     struct VuVirtq *vq;
  47 } VuBlkReq;
  48
  49 /* vhost user block device */
  50 typedef struct {
  51     BlockExport export;
  52     VuServer vu_server;
  53     uint32_t blk_size;
  54     QIOChannelSocket *sioc;
  55     struct virtio_blk_config blkcfg;
  56     bool writable;
  57 } VuBlkExport;
  58
  59 static void vu_blk_req_complete(VuBlkReq *req)
  60 {
  61     VuDev *vu_dev = &req->server->vu_dev;
  62
  63     /* IO size with 1 extra status byte */
  64     vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
  65     vu_queue_notify(vu_dev, req->vq);
  66
  67     free(req);
  68 }
  69
  70 static bool vu_blk_sect_range_ok(VuBlkExport *vexp, uint64_t sector,
  71                                  size_t size)
  72 {
  73     uint64_t nb_sectors;
  74     uint64_t total_sectors;
  75
  76     if (size % VIRTIO_BLK_SECTOR_SIZE) {
  77         return false;
  78     }
  79
  80     nb_sectors = size >> VIRTIO_BLK_SECTOR_BITS;
  81
  82     QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != VIRTIO_BLK_SECTOR_SIZE);
  83     if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
  84         return false;
  85     }
  86     if ((sector << VIRTIO_BLK_SECTOR_BITS) % vexp->blk_size) {
  87         return false;
  88     }
  89     blk_get_geometry(vexp->export.blk, &total_sectors);
  90     if (sector > total_sectors || nb_sectors > total_sectors - sector) {
  91         return false;
  92     }
  93     return true;
  94 }
  95
  96 static int coroutine_fn
  97 vu_blk_discard_write_zeroes(VuBlkExport *vexp, struct iovec *iov,
  98                             uint32_t iovcnt, uint32_t type)
  99 {
 100     BlockBackend *blk = vexp->export.blk;
 101     struct virtio_blk_discard_write_zeroes desc;
 102     ssize_t size;
 103     uint64_t sector;
 104     uint32_t num_sectors;
 105     uint32_t max_sectors;
 106     uint32_t flags;
 107     int bytes;
 108
 109     /* Only one desc is currently supported */
 110     if (unlikely(iov_size(iov, iovcnt) > sizeof(desc))) {
 111         return VIRTIO_BLK_S_UNSUPP;
 112     }
 113
 114     size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
 115     if (unlikely(size != sizeof(desc))) {
 116         error_report("Invalid size %zd, expected %zu", size, sizeof(desc));
 117         return VIRTIO_BLK_S_IOERR;
 118     }
 119
 120     sector = le64_to_cpu(desc.sector);
 121     num_sectors = le32_to_cpu(desc.num_sectors);
 122     flags = le32_to_cpu(desc.flags);
 123     max_sectors = (type == VIRTIO_BLK_T_WRITE_ZEROES) ?
 124                   VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS :
 125                   VHOST_USER_BLK_MAX_DISCARD_SECTORS;
 126
 127     /* This check ensures that 'bytes' fits in an int */
 128     if (unlikely(num_sectors > max_sectors)) {
 129         return VIRTIO_BLK_S_IOERR;
 130     }
 131
 132     bytes = num_sectors << VIRTIO_BLK_SECTOR_BITS;
 133
 134     if (unlikely(!vu_blk_sect_range_ok(vexp, sector, bytes))) {
 135         return VIRTIO_BLK_S_IOERR;
 136     }
 137
 138     /*
 139      * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard
 140      * and write zeroes commands if any unknown flag is set.
 141      */
 142     if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
 143         return VIRTIO_BLK_S_UNSUPP;
 144     }
 145
 146     if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
 147         int blk_flags = 0;
 148
 149         if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
 150             blk_flags |= BDRV_REQ_MAY_UNMAP;
 151         }
 152
 153         if (blk_co_pwrite_zeroes(blk, sector << VIRTIO_BLK_SECTOR_BITS,
 154                                  bytes, blk_flags) == 0) {
 155             return VIRTIO_BLK_S_OK;
 156         }
 157     } else if (type == VIRTIO_BLK_T_DISCARD) {
 158         /*
 159          * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for
 160          * discard commands if the unmap flag is set.
 161          */
 162         if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
 163             return VIRTIO_BLK_S_UNSUPP;
 164         }
 165
 166         if (blk_co_pdiscard(blk, sector << VIRTIO_BLK_SECTOR_BITS,
 167                             bytes) == 0) {
 168             return VIRTIO_BLK_S_OK;
 169         }
 170     }
 171
 172     return VIRTIO_BLK_S_IOERR;
 173 }
 174
 175 /* Called with server refcount increased, must decrease before returning */
 176 static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
 177 {
 178     VuBlkReq *req = opaque;
 179     VuServer *server = req->server;
 180     VuVirtqElement *elem = &req->elem;
 181     uint32_t type;
 182
 183     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 184     BlockBackend *blk = vexp->export.blk;
 185
 186     struct iovec *in_iov = elem->in_sg;
 187     struct iovec *out_iov = elem->out_sg;
 188     unsigned in_num = elem->in_num;
 189     unsigned out_num = elem->out_num;
 190
 191     /* refer to hw/block/virtio_blk.c */
 192     if (elem->out_num < 1 || elem->in_num < 1) {
 193         error_report("virtio-blk request missing headers");
 194         goto err;
 195     }
 196
 197     if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
 198                             sizeof(req->out)) != sizeof(req->out))) {
 199         error_report("virtio-blk request outhdr too short");
 200         goto err;
 201     }
 202
 203     iov_discard_front(&out_iov, &out_num, sizeof(req->out));
 204
 205     if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
 206         error_report("virtio-blk request inhdr too short");
 207         goto err;
 208     }
 209
 210     /* We always touch the last byte, so just see how big in_iov is.  */
 211     req->in = (void *)in_iov[in_num - 1].iov_base
 212               + in_iov[in_num - 1].iov_len
 213               - sizeof(struct virtio_blk_inhdr);
 214     iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
 215
 216     type = le32_to_cpu(req->out.type);
 217     switch (type & ~VIRTIO_BLK_T_BARRIER) {
 218     case VIRTIO_BLK_T_IN:
 219     case VIRTIO_BLK_T_OUT: {
 220         QEMUIOVector qiov;
 221         int64_t offset;
 222         ssize_t ret = 0;
 223         bool is_write = type & VIRTIO_BLK_T_OUT;
 224         req->sector_num = le64_to_cpu(req->out.sector);
 225
 226         if (is_write && !vexp->writable) {
 227             req->in->status = VIRTIO_BLK_S_IOERR;
 228             break;
 229         }
 230
 231         if (is_write) {
 232             qemu_iovec_init_external(&qiov, out_iov, out_num);
 233         } else {
 234             qemu_iovec_init_external(&qiov, in_iov, in_num);
 235         }
 236
 237         if (unlikely(!vu_blk_sect_range_ok(vexp,
 238                                            req->sector_num,
 239                                            qiov.size))) {
 240             req->in->status = VIRTIO_BLK_S_IOERR;
 241             break;
 242         }
 243
 244         offset = req->sector_num << VIRTIO_BLK_SECTOR_BITS;
 245
 246         if (is_write) {
 247             ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
 248         } else {
 249             ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
 250         }
 251         if (ret >= 0) {
 252             req->in->status = VIRTIO_BLK_S_OK;
 253         } else {
 254             req->in->status = VIRTIO_BLK_S_IOERR;
 255         }
 256         break;
 257     }
 258     case VIRTIO_BLK_T_FLUSH:
 259         if (blk_co_flush(blk) == 0) {
 260             req->in->status = VIRTIO_BLK_S_OK;
 261         } else {
 262             req->in->status = VIRTIO_BLK_S_IOERR;
 263         }
 264         break;
 265     case VIRTIO_BLK_T_GET_ID: {
 266         size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
 267                           VIRTIO_BLK_ID_BYTES);
 268         snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
 269         req->in->status = VIRTIO_BLK_S_OK;
 270         req->size = elem->in_sg[0].iov_len;
 271         break;
 272     }
 273     case VIRTIO_BLK_T_DISCARD:
 274     case VIRTIO_BLK_T_WRITE_ZEROES: {
 275         if (!vexp->writable) {
 276             req->in->status = VIRTIO_BLK_S_IOERR;
 277             break;
 278         }
 279
 280         req->in->status = vu_blk_discard_write_zeroes(vexp, out_iov, out_num,
 281                                                       type);
 282         break;
 283     }
 284     default:
 285         req->in->status = VIRTIO_BLK_S_UNSUPP;
 286         break;
 287     }
 288
 289     vu_blk_req_complete(req);
 290     vhost_user_server_unref(server);
 291     return;
 292
 293 err:
 294     free(req);
 295     vhost_user_server_unref(server);
 296 }
 297
 298 static void vu_blk_process_vq(VuDev *vu_dev, int idx)
 299 {
 300     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 301     VuVirtq *vq = vu_get_queue(vu_dev, idx);
 302
 303     while (1) {
 304         VuBlkReq *req;
 305
 306         req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
 307         if (!req) {
 308             break;
 309         }
 310
 311         req->server = server;
 312         req->vq = vq;
 313
 314         Coroutine *co =
 315             qemu_coroutine_create(vu_blk_virtio_process_req, req);
 316
 317         vhost_user_server_ref(server);
 318         qemu_coroutine_enter(co);
 319     }
 320 }
 321
 322 static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
 323 {
 324     VuVirtq *vq;
 325
 326     assert(vu_dev);
 327
 328     vq = vu_get_queue(vu_dev, idx);
 329     vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
 330 }
 331
 332 static uint64_t vu_blk_get_features(VuDev *dev)
 333 {
 334     uint64_t features;
 335     VuServer *server = container_of(dev, VuServer, vu_dev);
 336     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 337     features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
 338                1ull << VIRTIO_BLK_F_SEG_MAX |
 339                1ull << VIRTIO_BLK_F_TOPOLOGY |
 340                1ull << VIRTIO_BLK_F_BLK_SIZE |
 341                1ull << VIRTIO_BLK_F_FLUSH |
 342                1ull << VIRTIO_BLK_F_DISCARD |
 343                1ull << VIRTIO_BLK_F_WRITE_ZEROES |
 344                1ull << VIRTIO_BLK_F_CONFIG_WCE |
 345                1ull << VIRTIO_BLK_F_MQ |
 346                1ull << VIRTIO_F_VERSION_1 |
 347                1ull << VIRTIO_RING_F_INDIRECT_DESC |
 348                1ull << VIRTIO_RING_F_EVENT_IDX |
 349                1ull << VHOST_USER_F_PROTOCOL_FEATURES;
 350
 351     if (!vexp->writable) {
 352         features |= 1ull << VIRTIO_BLK_F_RO;
 353     }
 354
 355     return features;
 356 }
 357
 358 static uint64_t vu_blk_get_protocol_features(VuDev *dev)
 359 {
 360     return 1ull << VHOST_USER_PROTOCOL_F_CONFIG;
 361 }
 362
 363 static int
 364 vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 365 {
 366     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 367     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 368
 369     if (len > sizeof(struct virtio_blk_config)) {
 370         return -1;
 371     }
 372
 373     memcpy(config, &vexp->blkcfg, len);
 374     return 0;
 375 }
 376
 377 static int
 378 vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
 379                     uint32_t offset, uint32_t size, uint32_t flags)
 380 {
 381     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 382     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 383     uint8_t wce;
 384
 385     /* don't support live migration */
 386     if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
 387         return -EINVAL;
 388     }
 389
 390     if (offset != offsetof(struct virtio_blk_config, wce) ||
 391         size != 1) {
 392         return -EINVAL;
 393     }
 394
 395     wce = *data;
 396     vexp->blkcfg.wce = wce;
 397     blk_set_enable_write_cache(vexp->export.blk, wce);
 398     return 0;
 399 }
 400
 401 /*
 402  * When the client disconnects, it sends a VHOST_USER_NONE request
 403  * and vu_process_message will simple call exit which cause the VM
 404  * to exit abruptly.
 405  * To avoid this issue,  process VHOST_USER_NONE request ahead
 406  * of vu_process_message.
 407  *
 408  */
 409 static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 410 {
 411     if (vmsg->request == VHOST_USER_NONE) {
 412         dev->panic(dev, "disconnect");
 413         return true;
 414     }
 415     return false;
 416 }
 417
 418 static const VuDevIface vu_blk_iface = {
 419     .get_features          = vu_blk_get_features,
 420     .queue_set_started     = vu_blk_queue_set_started,
 421     .get_protocol_features = vu_blk_get_protocol_features,
 422     .get_config            = vu_blk_get_config,
 423     .set_config            = vu_blk_set_config,
 424     .process_msg           = vu_blk_process_msg,
 425 };
 426
 427 static void blk_aio_attached(AioContext *ctx, void *opaque)
 428 {
 429     VuBlkExport *vexp = opaque;
 430
 431     vexp->export.ctx = ctx;
 432     vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
 433 }
 434
 435 static void blk_aio_detach(void *opaque)
 436 {
 437     VuBlkExport *vexp = opaque;
 438
 439     vhost_user_server_detach_aio_context(&vexp->vu_server);
 440     vexp->export.ctx = NULL;
 441 }
 442
 443 static void
 444 vu_blk_initialize_config(BlockDriverState *bs,
 445                          struct virtio_blk_config *config,
 446                          uint32_t blk_size,
 447                          uint16_t num_queues)
 448 {
 449     config->capacity =
 450         cpu_to_le64(bdrv_getlength(bs) >> VIRTIO_BLK_SECTOR_BITS);
 451     config->blk_size = cpu_to_le32(blk_size);
 452     config->size_max = cpu_to_le32(0);
 453     config->seg_max = cpu_to_le32(128 - 2);
 454     config->min_io_size = cpu_to_le16(1);
 455     config->opt_io_size = cpu_to_le32(1);
 456     config->num_queues = cpu_to_le16(num_queues);
 457     config->max_discard_sectors =
 458         cpu_to_le32(VHOST_USER_BLK_MAX_DISCARD_SECTORS);
 459     config->max_discard_seg = cpu_to_le32(1);
 460     config->discard_sector_alignment =
 461         cpu_to_le32(blk_size >> VIRTIO_BLK_SECTOR_BITS);
 462     config->max_write_zeroes_sectors
 463         = cpu_to_le32(VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS);
 464     config->max_write_zeroes_seg = cpu_to_le32(1);
 465 }
 466
 467 static void vu_blk_exp_request_shutdown(BlockExport *exp)
 468 {
 469     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 470
 471     vhost_user_server_stop(&vexp->vu_server);
 472 }
 473
 474 static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
 475                              Error **errp)
 476 {
 477     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 478     BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
 479     Error *local_err = NULL;
 480     uint64_t logical_block_size;
 481     uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
 482
 483     vexp->writable = opts->writable;
 484     vexp->blkcfg.wce = 0;
 485
 486     if (vu_opts->has_logical_block_size) {
 487         logical_block_size = vu_opts->logical_block_size;
 488     } else {
 489         logical_block_size = VIRTIO_BLK_SECTOR_SIZE;
 490     }
 491     check_block_size(exp->id, "logical-block-size", logical_block_size,
 492                      &local_err);
 493     if (local_err) {
 494         error_propagate(errp, local_err);
 495         return -EINVAL;
 496     }
 497     vexp->blk_size = logical_block_size;
 498     blk_set_guest_block_size(exp->blk, logical_block_size);
 499
 500     if (vu_opts->has_num_queues) {
 501         num_queues = vu_opts->num_queues;
 502     }
 503     if (num_queues == 0) {
 504         error_setg(errp, "num-queues must be greater than 0");
 505         return -EINVAL;
 506     }
 507
 508     vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
 509                              logical_block_size, num_queues);
 510
 511     blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 512                                  vexp);
 513
 514     if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
 515                                  num_queues, &vu_blk_iface, errp)) {
 516         blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
 517                                         blk_aio_detach, vexp);
 518         return -EADDRNOTAVAIL;
 519     }
 520
 521     return 0;
 522 }
 523
 524 static void vu_blk_exp_delete(BlockExport *exp)
 525 {
 526     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 527
 528     blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 529                                     vexp);
 530 }
 531
 532 const BlockExportDriver blk_exp_vhost_user_blk = {
 533     .type               = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
 534     .instance_size      = sizeof(VuBlkExport),
 535     .create             = vu_blk_exp_create,
 536     .delete             = vu_blk_exp_delete,
 537     .request_shutdown   = vu_blk_exp_request_shutdown,
 538 };