block/export/vduse-blk.c

   1 /*
   2  * Export QEMU block device via VDUSE
   3  *
   4  * Copyright (C) 2022 Bytedance Inc. and/or its affiliates. All rights reserved.
   5  *
   6  * Author:
   7  *   Xie Yongji <xieyongji@bytedance.com>
   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
  13 #include <sys/eventfd.h>
  14
  15 #include "qemu/osdep.h"
  16 #include "qapi/error.h"
  17 #include "block/export.h"
  18 #include "qemu/error-report.h"
  19 #include "util/block-helpers.h"
  20 #include "subprojects/libvduse/libvduse.h"
  21 #include "virtio-blk-handler.h"
  22
  23 #include "standard-headers/linux/virtio_blk.h"
  24
  25 #define VDUSE_DEFAULT_NUM_QUEUE 1
  26 #define VDUSE_DEFAULT_QUEUE_SIZE 256
  27
  28 typedef struct VduseBlkExport {
  29     BlockExport export;
  30     VirtioBlkHandler handler;
  31     VduseDev *dev;
  32     uint16_t num_queues;
  33     char *recon_file;
  34     unsigned int inflight;
  35 } VduseBlkExport;
  36
  37 typedef struct VduseBlkReq {
  38     VduseVirtqElement elem;
  39     VduseVirtq *vq;
  40 } VduseBlkReq;
  41
  42 static void vduse_blk_inflight_inc(VduseBlkExport *vblk_exp)
  43 {
  44     vblk_exp->inflight++;
  45 }
  46
  47 static void vduse_blk_inflight_dec(VduseBlkExport *vblk_exp)
  48 {
  49     if (--vblk_exp->inflight == 0) {
  50         aio_wait_kick();
  51     }
  52 }
  53
  54 static void vduse_blk_req_complete(VduseBlkReq *req, size_t in_len)
  55 {
  56     vduse_queue_push(req->vq, &req->elem, in_len);
  57     vduse_queue_notify(req->vq);
  58
  59     free(req);
  60 }
  61
  62 static void coroutine_fn vduse_blk_virtio_process_req(void *opaque)
  63 {
  64     VduseBlkReq *req = opaque;
  65     VduseVirtq *vq = req->vq;
  66     VduseDev *dev = vduse_queue_get_dev(vq);
  67     VduseBlkExport *vblk_exp = vduse_dev_get_priv(dev);
  68     VirtioBlkHandler *handler = &vblk_exp->handler;
  69     VduseVirtqElement *elem = &req->elem;
  70     struct iovec *in_iov = elem->in_sg;
  71     struct iovec *out_iov = elem->out_sg;
  72     unsigned in_num = elem->in_num;
  73     unsigned out_num = elem->out_num;
  74     int in_len;
  75
  76     in_len = virtio_blk_process_req(handler, in_iov,
  77                                     out_iov, in_num, out_num);
  78     if (in_len < 0) {
  79         free(req);
  80         return;
  81     }
  82
  83     vduse_blk_req_complete(req, in_len);
  84     vduse_blk_inflight_dec(vblk_exp);
  85 }
  86
  87 static void vduse_blk_vq_handler(VduseDev *dev, VduseVirtq *vq)
  88 {
  89     VduseBlkExport *vblk_exp = vduse_dev_get_priv(dev);
  90
  91     while (1) {
  92         VduseBlkReq *req;
  93
  94         req = vduse_queue_pop(vq, sizeof(VduseBlkReq));
  95         if (!req) {
  96             break;
  97         }
  98         req->vq = vq;
  99
 100         Coroutine *co =
 101             qemu_coroutine_create(vduse_blk_virtio_process_req, req);
 102
 103         vduse_blk_inflight_inc(vblk_exp);
 104         qemu_coroutine_enter(co);
 105     }
 106 }
 107
 108 static void on_vduse_vq_kick(void *opaque)
 109 {
 110     VduseVirtq *vq = opaque;
 111     VduseDev *dev = vduse_queue_get_dev(vq);
 112     int fd = vduse_queue_get_fd(vq);
 113     eventfd_t kick_data;
 114
 115     if (eventfd_read(fd, &kick_data) == -1) {
 116         error_report("failed to read data from eventfd");
 117         return;
 118     }
 119
 120     vduse_blk_vq_handler(dev, vq);
 121 }
 122
 123 static void vduse_blk_enable_queue(VduseDev *dev, VduseVirtq *vq)
 124 {
 125     VduseBlkExport *vblk_exp = vduse_dev_get_priv(dev);
 126
 127     aio_set_fd_handler(vblk_exp->export.ctx, vduse_queue_get_fd(vq),
 128                        true, on_vduse_vq_kick, NULL, NULL, NULL, vq);
 129     /* Make sure we don't miss any kick afer reconnecting */
 130     eventfd_write(vduse_queue_get_fd(vq), 1);
 131 }
 132
 133 static void vduse_blk_disable_queue(VduseDev *dev, VduseVirtq *vq)
 134 {
 135     VduseBlkExport *vblk_exp = vduse_dev_get_priv(dev);
 136
 137     aio_set_fd_handler(vblk_exp->export.ctx, vduse_queue_get_fd(vq),
 138                        true, NULL, NULL, NULL, NULL, NULL);
 139 }
 140
 141 static const VduseOps vduse_blk_ops = {
 142     .enable_queue = vduse_blk_enable_queue,
 143     .disable_queue = vduse_blk_disable_queue,
 144 };
 145
 146 static void on_vduse_dev_kick(void *opaque)
 147 {
 148     VduseDev *dev = opaque;
 149
 150     vduse_dev_handler(dev);
 151 }
 152
 153 static void vduse_blk_attach_ctx(VduseBlkExport *vblk_exp, AioContext *ctx)
 154 {
 155     int i;
 156
 157     aio_set_fd_handler(vblk_exp->export.ctx, vduse_dev_get_fd(vblk_exp->dev),
 158                        true, on_vduse_dev_kick, NULL, NULL, NULL,
 159                        vblk_exp->dev);
 160
 161     for (i = 0; i < vblk_exp->num_queues; i++) {
 162         VduseVirtq *vq = vduse_dev_get_queue(vblk_exp->dev, i);
 163         int fd = vduse_queue_get_fd(vq);
 164
 165         if (fd < 0) {
 166             continue;
 167         }
 168         aio_set_fd_handler(vblk_exp->export.ctx, fd, true,
 169                            on_vduse_vq_kick, NULL, NULL, NULL, vq);
 170     }
 171 }
 172
 173 static void vduse_blk_detach_ctx(VduseBlkExport *vblk_exp)
 174 {
 175     int i;
 176
 177     for (i = 0; i < vblk_exp->num_queues; i++) {
 178         VduseVirtq *vq = vduse_dev_get_queue(vblk_exp->dev, i);
 179         int fd = vduse_queue_get_fd(vq);
 180
 181         if (fd < 0) {
 182             continue;
 183         }
 184         aio_set_fd_handler(vblk_exp->export.ctx, fd,
 185                            true, NULL, NULL, NULL, NULL, NULL);
 186     }
 187     aio_set_fd_handler(vblk_exp->export.ctx, vduse_dev_get_fd(vblk_exp->dev),
 188                        true, NULL, NULL, NULL, NULL, NULL);
 189
 190     AIO_WAIT_WHILE(vblk_exp->export.ctx, vblk_exp->inflight > 0);
 191 }
 192
 193
 194 static void blk_aio_attached(AioContext *ctx, void *opaque)
 195 {
 196     VduseBlkExport *vblk_exp = opaque;
 197
 198     vblk_exp->export.ctx = ctx;
 199     vduse_blk_attach_ctx(vblk_exp, ctx);
 200 }
 201
 202 static void blk_aio_detach(void *opaque)
 203 {
 204     VduseBlkExport *vblk_exp = opaque;
 205
 206     vduse_blk_detach_ctx(vblk_exp);
 207     vblk_exp->export.ctx = NULL;
 208 }
 209
 210 static void vduse_blk_resize(void *opaque)
 211 {
 212     BlockExport *exp = opaque;
 213     VduseBlkExport *vblk_exp = container_of(exp, VduseBlkExport, export);
 214     struct virtio_blk_config config;
 215
 216     config.capacity =
 217             cpu_to_le64(blk_getlength(exp->blk) >> VIRTIO_BLK_SECTOR_BITS);
 218     vduse_dev_update_config(vblk_exp->dev, sizeof(config.capacity),
 219                             offsetof(struct virtio_blk_config, capacity),
 220                             (char *)&config.capacity);
 221 }
 222
 223 static const BlockDevOps vduse_block_ops = {
 224     .resize_cb = vduse_blk_resize,
 225 };
 226
 227 static int vduse_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
 228                                 Error **errp)
 229 {
 230     VduseBlkExport *vblk_exp = container_of(exp, VduseBlkExport, export);
 231     BlockExportOptionsVduseBlk *vblk_opts = &opts->u.vduse_blk;
 232     uint64_t logical_block_size = VIRTIO_BLK_SECTOR_SIZE;
 233     uint16_t num_queues = VDUSE_DEFAULT_NUM_QUEUE;
 234     uint16_t queue_size = VDUSE_DEFAULT_QUEUE_SIZE;
 235     Error *local_err = NULL;
 236     struct virtio_blk_config config = { 0 };
 237     uint64_t features;
 238     int i, ret;
 239
 240     if (vblk_opts->has_num_queues) {
 241         num_queues = vblk_opts->num_queues;
 242         if (num_queues == 0) {
 243             error_setg(errp, "num-queues must be greater than 0");
 244             return -EINVAL;
 245         }
 246     }
 247
 248     if (vblk_opts->has_queue_size) {
 249         queue_size = vblk_opts->queue_size;
 250         if (queue_size <= 2 || !is_power_of_2(queue_size) ||
 251             queue_size > VIRTQUEUE_MAX_SIZE) {
 252             error_setg(errp, "queue-size is invalid");
 253             return -EINVAL;
 254         }
 255     }
 256
 257     if (vblk_opts->has_logical_block_size) {
 258         logical_block_size = vblk_opts->logical_block_size;
 259         check_block_size(exp->id, "logical-block-size", logical_block_size,
 260                          &local_err);
 261         if (local_err) {
 262             error_propagate(errp, local_err);
 263             return -EINVAL;
 264         }
 265     }
 266     vblk_exp->num_queues = num_queues;
 267     vblk_exp->handler.blk = exp->blk;
 268     vblk_exp->handler.serial = g_strdup(vblk_opts->has_serial ?
 269                                         vblk_opts->serial : "");
 270     vblk_exp->handler.logical_block_size = logical_block_size;
 271     vblk_exp->handler.writable = opts->writable;
 272
 273     config.capacity =
 274             cpu_to_le64(blk_getlength(exp->blk) >> VIRTIO_BLK_SECTOR_BITS);
 275     config.seg_max = cpu_to_le32(queue_size - 2);
 276     config.min_io_size = cpu_to_le16(1);
 277     config.opt_io_size = cpu_to_le32(1);
 278     config.num_queues = cpu_to_le16(num_queues);
 279     config.blk_size = cpu_to_le32(logical_block_size);
 280     config.max_discard_sectors = cpu_to_le32(VIRTIO_BLK_MAX_DISCARD_SECTORS);
 281     config.max_discard_seg = cpu_to_le32(1);
 282     config.discard_sector_alignment =
 283         cpu_to_le32(logical_block_size >> VIRTIO_BLK_SECTOR_BITS);
 284     config.max_write_zeroes_sectors =
 285         cpu_to_le32(VIRTIO_BLK_MAX_WRITE_ZEROES_SECTORS);
 286     config.max_write_zeroes_seg = cpu_to_le32(1);
 287
 288     features = vduse_get_virtio_features() |
 289                (1ULL << VIRTIO_BLK_F_SEG_MAX) |
 290                (1ULL << VIRTIO_BLK_F_TOPOLOGY) |
 291                (1ULL << VIRTIO_BLK_F_BLK_SIZE) |
 292                (1ULL << VIRTIO_BLK_F_FLUSH) |
 293                (1ULL << VIRTIO_BLK_F_DISCARD) |
 294                (1ULL << VIRTIO_BLK_F_WRITE_ZEROES);
 295
 296     if (num_queues > 1) {
 297         features |= 1ULL << VIRTIO_BLK_F_MQ;
 298     }
 299     if (!opts->writable) {
 300         features |= 1ULL << VIRTIO_BLK_F_RO;
 301     }
 302
 303     vblk_exp->dev = vduse_dev_create(vblk_opts->name, VIRTIO_ID_BLOCK, 0,
 304                                      features, num_queues,
 305                                      sizeof(struct virtio_blk_config),
 306                                      (char *)&config, &vduse_blk_ops,
 307                                      vblk_exp);
 308     if (!vblk_exp->dev) {
 309         error_setg(errp, "failed to create vduse device");
 310         ret = -ENOMEM;
 311         goto err_dev;
 312     }
 313
 314     vblk_exp->recon_file = g_strdup_printf("%s/vduse-blk-%s",
 315                                            g_get_tmp_dir(), vblk_opts->name);
 316     if (vduse_set_reconnect_log_file(vblk_exp->dev, vblk_exp->recon_file)) {
 317         error_setg(errp, "failed to set reconnect log file");
 318         ret = -EINVAL;
 319         goto err;
 320     }
 321
 322     for (i = 0; i < num_queues; i++) {
 323         vduse_dev_setup_queue(vblk_exp->dev, i, queue_size);
 324     }
 325
 326     aio_set_fd_handler(exp->ctx, vduse_dev_get_fd(vblk_exp->dev), true,
 327                        on_vduse_dev_kick, NULL, NULL, NULL, vblk_exp->dev);
 328
 329     blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 330                                  vblk_exp);
 331
 332     blk_set_dev_ops(exp->blk, &vduse_block_ops, exp);
 333
 334     return 0;
 335 err:
 336     vduse_dev_destroy(vblk_exp->dev);
 337     g_free(vblk_exp->recon_file);
 338 err_dev:
 339     g_free(vblk_exp->handler.serial);
 340     return ret;
 341 }
 342
 343 static void vduse_blk_exp_delete(BlockExport *exp)
 344 {
 345     VduseBlkExport *vblk_exp = container_of(exp, VduseBlkExport, export);
 346     int ret;
 347
 348     blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 349                                     vblk_exp);
 350     blk_set_dev_ops(exp->blk, NULL, NULL);
 351     ret = vduse_dev_destroy(vblk_exp->dev);
 352     if (ret != -EBUSY) {
 353         unlink(vblk_exp->recon_file);
 354     }
 355     g_free(vblk_exp->recon_file);
 356     g_free(vblk_exp->handler.serial);
 357 }
 358
 359 static void vduse_blk_exp_request_shutdown(BlockExport *exp)
 360 {
 361     VduseBlkExport *vblk_exp = container_of(exp, VduseBlkExport, export);
 362
 363     aio_context_acquire(vblk_exp->export.ctx);
 364     vduse_blk_detach_ctx(vblk_exp);
 365     aio_context_acquire(vblk_exp->export.ctx);
 366 }
 367
 368 const BlockExportDriver blk_exp_vduse_blk = {
 369     .type               = BLOCK_EXPORT_TYPE_VDUSE_BLK,
 370     .instance_size      = sizeof(VduseBlkExport),
 371     .create             = vduse_blk_exp_create,
 372     .delete             = vduse_blk_exp_delete,
 373     .request_shutdown   = vduse_blk_exp_request_shutdown,
 374 };