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 enum {
  24     VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
  25 };
  26 struct virtio_blk_inhdr {
  27     unsigned char status;
  28 };
  29
  30 typedef struct VuBlkReq {
  31     VuVirtqElement elem;
  32     int64_t sector_num;
  33     size_t size;
  34     struct virtio_blk_inhdr *in;
  35     struct virtio_blk_outhdr out;
  36     VuServer *server;
  37     struct VuVirtq *vq;
  38 } VuBlkReq;
  39
  40 /* vhost user block device */
  41 typedef struct {
  42     BlockExport export;
  43     VuServer vu_server;
  44     uint32_t blk_size;
  45     QIOChannelSocket *sioc;
  46     struct virtio_blk_config blkcfg;
  47     bool writable;
  48 } VuBlkExport;
  49
  50 static void vu_blk_req_complete(VuBlkReq *req)
  51 {
  52     VuDev *vu_dev = &req->server->vu_dev;
  53
  54     /* IO size with 1 extra status byte */
  55     vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
  56     vu_queue_notify(vu_dev, req->vq);
  57
  58     free(req);
  59 }
  60
  61 static int coroutine_fn
  62 vu_blk_discard_write_zeroes(BlockBackend *blk, struct iovec *iov,
  63                             uint32_t iovcnt, uint32_t type)
  64 {
  65     struct virtio_blk_discard_write_zeroes desc;
  66     ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
  67     if (unlikely(size != sizeof(desc))) {
  68         error_report("Invalid size %zd, expect %zu", size, sizeof(desc));
  69         return -EINVAL;
  70     }
  71
  72     uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
  73                           le32_to_cpu(desc.num_sectors) << 9 };
  74     if (type == VIRTIO_BLK_T_DISCARD) {
  75         if (blk_co_pdiscard(blk, range[0], range[1]) == 0) {
  76             return 0;
  77         }
  78     } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
  79         if (blk_co_pwrite_zeroes(blk, range[0], range[1], 0) == 0) {
  80             return 0;
  81         }
  82     }
  83
  84     return -EINVAL;
  85 }
  86
  87 static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
  88 {
  89     VuBlkReq *req = opaque;
  90     VuServer *server = req->server;
  91     VuVirtqElement *elem = &req->elem;
  92     uint32_t type;
  93
  94     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
  95     BlockBackend *blk = vexp->export.blk;
  96
  97     struct iovec *in_iov = elem->in_sg;
  98     struct iovec *out_iov = elem->out_sg;
  99     unsigned in_num = elem->in_num;
 100     unsigned out_num = elem->out_num;
 101
 102     /* refer to hw/block/virtio_blk.c */
 103     if (elem->out_num < 1 || elem->in_num < 1) {
 104         error_report("virtio-blk request missing headers");
 105         goto err;
 106     }
 107
 108     if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
 109                             sizeof(req->out)) != sizeof(req->out))) {
 110         error_report("virtio-blk request outhdr too short");
 111         goto err;
 112     }
 113
 114     iov_discard_front(&out_iov, &out_num, sizeof(req->out));
 115
 116     if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
 117         error_report("virtio-blk request inhdr too short");
 118         goto err;
 119     }
 120
 121     /* We always touch the last byte, so just see how big in_iov is.  */
 122     req->in = (void *)in_iov[in_num - 1].iov_base
 123               + in_iov[in_num - 1].iov_len
 124               - sizeof(struct virtio_blk_inhdr);
 125     iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
 126
 127     type = le32_to_cpu(req->out.type);
 128     switch (type & ~VIRTIO_BLK_T_BARRIER) {
 129     case VIRTIO_BLK_T_IN:
 130     case VIRTIO_BLK_T_OUT: {
 131         ssize_t ret = 0;
 132         bool is_write = type & VIRTIO_BLK_T_OUT;
 133         req->sector_num = le64_to_cpu(req->out.sector);
 134
 135         if (is_write && !vexp->writable) {
 136             req->in->status = VIRTIO_BLK_S_IOERR;
 137             break;
 138         }
 139
 140         int64_t offset = req->sector_num * vexp->blk_size;
 141         QEMUIOVector qiov;
 142         if (is_write) {
 143             qemu_iovec_init_external(&qiov, out_iov, out_num);
 144             ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
 145         } else {
 146             qemu_iovec_init_external(&qiov, in_iov, in_num);
 147             ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
 148         }
 149         if (ret >= 0) {
 150             req->in->status = VIRTIO_BLK_S_OK;
 151         } else {
 152             req->in->status = VIRTIO_BLK_S_IOERR;
 153         }
 154         break;
 155     }
 156     case VIRTIO_BLK_T_FLUSH:
 157         if (blk_co_flush(blk) == 0) {
 158             req->in->status = VIRTIO_BLK_S_OK;
 159         } else {
 160             req->in->status = VIRTIO_BLK_S_IOERR;
 161         }
 162         break;
 163     case VIRTIO_BLK_T_GET_ID: {
 164         size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
 165                           VIRTIO_BLK_ID_BYTES);
 166         snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
 167         req->in->status = VIRTIO_BLK_S_OK;
 168         req->size = elem->in_sg[0].iov_len;
 169         break;
 170     }
 171     case VIRTIO_BLK_T_DISCARD:
 172     case VIRTIO_BLK_T_WRITE_ZEROES: {
 173         int rc;
 174
 175         if (!vexp->writable) {
 176             req->in->status = VIRTIO_BLK_S_IOERR;
 177             break;
 178         }
 179
 180         rc = vu_blk_discard_write_zeroes(blk, &elem->out_sg[1], out_num, type);
 181         if (rc == 0) {
 182             req->in->status = VIRTIO_BLK_S_OK;
 183         } else {
 184             req->in->status = VIRTIO_BLK_S_IOERR;
 185         }
 186         break;
 187     }
 188     default:
 189         req->in->status = VIRTIO_BLK_S_UNSUPP;
 190         break;
 191     }
 192
 193     vu_blk_req_complete(req);
 194     return;
 195
 196 err:
 197     free(req);
 198 }
 199
 200 static void vu_blk_process_vq(VuDev *vu_dev, int idx)
 201 {
 202     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 203     VuVirtq *vq = vu_get_queue(vu_dev, idx);
 204
 205     while (1) {
 206         VuBlkReq *req;
 207
 208         req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
 209         if (!req) {
 210             break;
 211         }
 212
 213         req->server = server;
 214         req->vq = vq;
 215
 216         Coroutine *co =
 217             qemu_coroutine_create(vu_blk_virtio_process_req, req);
 218         qemu_coroutine_enter(co);
 219     }
 220 }
 221
 222 static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
 223 {
 224     VuVirtq *vq;
 225
 226     assert(vu_dev);
 227
 228     vq = vu_get_queue(vu_dev, idx);
 229     vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
 230 }
 231
 232 static uint64_t vu_blk_get_features(VuDev *dev)
 233 {
 234     uint64_t features;
 235     VuServer *server = container_of(dev, VuServer, vu_dev);
 236     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 237     features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
 238                1ull << VIRTIO_BLK_F_SEG_MAX |
 239                1ull << VIRTIO_BLK_F_TOPOLOGY |
 240                1ull << VIRTIO_BLK_F_BLK_SIZE |
 241                1ull << VIRTIO_BLK_F_FLUSH |
 242                1ull << VIRTIO_BLK_F_DISCARD |
 243                1ull << VIRTIO_BLK_F_WRITE_ZEROES |
 244                1ull << VIRTIO_BLK_F_CONFIG_WCE |
 245                1ull << VIRTIO_BLK_F_MQ |
 246                1ull << VIRTIO_F_VERSION_1 |
 247                1ull << VIRTIO_RING_F_INDIRECT_DESC |
 248                1ull << VIRTIO_RING_F_EVENT_IDX |
 249                1ull << VHOST_USER_F_PROTOCOL_FEATURES;
 250
 251     if (!vexp->writable) {
 252         features |= 1ull << VIRTIO_BLK_F_RO;
 253     }
 254
 255     return features;
 256 }
 257
 258 static uint64_t vu_blk_get_protocol_features(VuDev *dev)
 259 {
 260     return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
 261            1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
 262 }
 263
 264 static int
 265 vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 266 {
 267     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 268     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 269
 270     if (len > sizeof(struct virtio_blk_config)) {
 271         return -1;
 272     }
 273
 274     memcpy(config, &vexp->blkcfg, len);
 275     return 0;
 276 }
 277
 278 static int
 279 vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
 280                     uint32_t offset, uint32_t size, uint32_t flags)
 281 {
 282     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 283     VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 284     uint8_t wce;
 285
 286     /* don't support live migration */
 287     if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
 288         return -EINVAL;
 289     }
 290
 291     if (offset != offsetof(struct virtio_blk_config, wce) ||
 292         size != 1) {
 293         return -EINVAL;
 294     }
 295
 296     wce = *data;
 297     vexp->blkcfg.wce = wce;
 298     blk_set_enable_write_cache(vexp->export.blk, wce);
 299     return 0;
 300 }
 301
 302 /*
 303  * When the client disconnects, it sends a VHOST_USER_NONE request
 304  * and vu_process_message will simple call exit which cause the VM
 305  * to exit abruptly.
 306  * To avoid this issue,  process VHOST_USER_NONE request ahead
 307  * of vu_process_message.
 308  *
 309  */
 310 static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 311 {
 312     if (vmsg->request == VHOST_USER_NONE) {
 313         dev->panic(dev, "disconnect");
 314         return true;
 315     }
 316     return false;
 317 }
 318
 319 static const VuDevIface vu_blk_iface = {
 320     .get_features          = vu_blk_get_features,
 321     .queue_set_started     = vu_blk_queue_set_started,
 322     .get_protocol_features = vu_blk_get_protocol_features,
 323     .get_config            = vu_blk_get_config,
 324     .set_config            = vu_blk_set_config,
 325     .process_msg           = vu_blk_process_msg,
 326 };
 327
 328 static void blk_aio_attached(AioContext *ctx, void *opaque)
 329 {
 330     VuBlkExport *vexp = opaque;
 331
 332     vexp->export.ctx = ctx;
 333     vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
 334 }
 335
 336 static void blk_aio_detach(void *opaque)
 337 {
 338     VuBlkExport *vexp = opaque;
 339
 340     vhost_user_server_detach_aio_context(&vexp->vu_server);
 341     vexp->export.ctx = NULL;
 342 }
 343
 344 static void
 345 vu_blk_initialize_config(BlockDriverState *bs,
 346                          struct virtio_blk_config *config,
 347                          uint32_t blk_size,
 348                          uint16_t num_queues)
 349 {
 350     config->capacity = cpu_to_le64(bdrv_getlength(bs) >> BDRV_SECTOR_BITS);
 351     config->blk_size = cpu_to_le32(blk_size);
 352     config->size_max = cpu_to_le32(0);
 353     config->seg_max = cpu_to_le32(128 - 2);
 354     config->min_io_size = cpu_to_le16(1);
 355     config->opt_io_size = cpu_to_le32(1);
 356     config->num_queues = cpu_to_le16(num_queues);
 357     config->max_discard_sectors = cpu_to_le32(32768);
 358     config->max_discard_seg = cpu_to_le32(1);
 359     config->discard_sector_alignment = cpu_to_le32(config->blk_size >> 9);
 360     config->max_write_zeroes_sectors = cpu_to_le32(32768);
 361     config->max_write_zeroes_seg = cpu_to_le32(1);
 362 }
 363
 364 static void vu_blk_exp_request_shutdown(BlockExport *exp)
 365 {
 366     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 367
 368     vhost_user_server_stop(&vexp->vu_server);
 369 }
 370
 371 static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
 372                              Error **errp)
 373 {
 374     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 375     BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
 376     Error *local_err = NULL;
 377     uint64_t logical_block_size;
 378     uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
 379
 380     vexp->writable = opts->writable;
 381     vexp->blkcfg.wce = 0;
 382
 383     if (vu_opts->has_logical_block_size) {
 384         logical_block_size = vu_opts->logical_block_size;
 385     } else {
 386         logical_block_size = BDRV_SECTOR_SIZE;
 387     }
 388     check_block_size(exp->id, "logical-block-size", logical_block_size,
 389                      &local_err);
 390     if (local_err) {
 391         error_propagate(errp, local_err);
 392         return -EINVAL;
 393     }
 394     vexp->blk_size = logical_block_size;
 395     blk_set_guest_block_size(exp->blk, logical_block_size);
 396
 397     if (vu_opts->has_num_queues) {
 398         num_queues = vu_opts->num_queues;
 399     }
 400     if (num_queues == 0) {
 401         error_setg(errp, "num-queues must be greater than 0");
 402         return -EINVAL;
 403     }
 404
 405     vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
 406                              logical_block_size, num_queues);
 407
 408     blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 409                                  vexp);
 410
 411     if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
 412                                  num_queues, &vu_blk_iface, errp)) {
 413         blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
 414                                         blk_aio_detach, vexp);
 415         return -EADDRNOTAVAIL;
 416     }
 417
 418     return 0;
 419 }
 420
 421 static void vu_blk_exp_delete(BlockExport *exp)
 422 {
 423     VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 424
 425     blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 426                                     vexp);
 427 }
 428
 429 const BlockExportDriver blk_exp_vhost_user_blk = {
 430     .type               = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
 431     .instance_size      = sizeof(VuBlkExport),
 432     .create             = vu_blk_exp_create,
 433     .delete             = vu_blk_exp_delete,
 434     .request_shutdown   = vu_blk_exp_request_shutdown,
 435 };