drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VDPA simulator for block device.
   4  *
   5  * Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
   6  * Copyright (c) 2021, Red Hat Inc. All rights reserved.
   7  *
   8  */
   9
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/blkdev.h>
  16 #include <linux/vringh.h>
  17 #include <linux/vdpa.h>
  18 #include <uapi/linux/virtio_blk.h>
  19
  20 #include "vdpa_sim.h"
  21
  22 #define DRV_VERSION  "0.1"
  23 #define DRV_AUTHOR   "Max Gurtovoy <mgurtovoy@nvidia.com>"
  24 #define DRV_DESC     "vDPA Device Simulator for block device"
  25 #define DRV_LICENSE  "GPL v2"
  26
  27 #define VDPASIM_BLK_FEATURES    (VDPASIM_FEATURES | \
  28                                  (1ULL << VIRTIO_BLK_F_SIZE_MAX) | \
  29                                  (1ULL << VIRTIO_BLK_F_SEG_MAX)  | \
  30                                  (1ULL << VIRTIO_BLK_F_BLK_SIZE) | \
  31                                  (1ULL << VIRTIO_BLK_F_TOPOLOGY) | \
  32                                  (1ULL << VIRTIO_BLK_F_MQ))
  33
  34 #define VDPASIM_BLK_CAPACITY    0x40000
  35 #define VDPASIM_BLK_SIZE_MAX    0x1000
  36 #define VDPASIM_BLK_SEG_MAX     32
  37 #define VDPASIM_BLK_VQ_NUM      1
  38
  39 static char vdpasim_blk_id[VIRTIO_BLK_ID_BYTES] = "vdpa_blk_sim";
  40
  41 static bool vdpasim_blk_check_range(u64 start_sector, size_t range_size)
  42 {
  43         u64 range_sectors = range_size >> SECTOR_SHIFT;
  44
  45         if (range_size > VDPASIM_BLK_SIZE_MAX * VDPASIM_BLK_SEG_MAX)
  46                 return false;
  47
  48         if (start_sector > VDPASIM_BLK_CAPACITY)
  49                 return false;
  50
  51         if (range_sectors > VDPASIM_BLK_CAPACITY - start_sector)
  52                 return false;
  53
  54         return true;
  55 }
  56
  57 /* Returns 'true' if the request is handled (with or without an I/O error)
  58  * and the status is correctly written in the last byte of the 'in iov',
  59  * 'false' otherwise.
  60  */
  61 static bool vdpasim_blk_handle_req(struct vdpasim *vdpasim,
  62                                    struct vdpasim_virtqueue *vq)
  63 {
  64         size_t pushed = 0, to_pull, to_push;
  65         struct virtio_blk_outhdr hdr;
  66         ssize_t bytes;
  67         loff_t offset;
  68         u64 sector;
  69         u8 status;
  70         u32 type;
  71         int ret;
  72
  73         ret = vringh_getdesc_iotlb(&vq->vring, &vq->out_iov, &vq->in_iov,
  74                                    &vq->head, GFP_ATOMIC);
  75         if (ret != 1)
  76                 return false;
  77
  78         if (vq->out_iov.used < 1 || vq->in_iov.used < 1) {
  79                 dev_err(&vdpasim->vdpa.dev, "missing headers - out_iov: %u in_iov %u\n",
  80                         vq->out_iov.used, vq->in_iov.used);
  81                 return false;
  82         }
  83
  84         if (vq->in_iov.iov[vq->in_iov.used - 1].iov_len < 1) {
  85                 dev_err(&vdpasim->vdpa.dev, "request in header too short\n");
  86                 return false;
  87         }
  88
  89         /* The last byte is the status and we checked if the last iov has
  90          * enough room for it.
  91          */
  92         to_push = vringh_kiov_length(&vq->in_iov) - 1;
  93
  94         to_pull = vringh_kiov_length(&vq->out_iov);
  95
  96         bytes = vringh_iov_pull_iotlb(&vq->vring, &vq->out_iov, &hdr,
  97                                       sizeof(hdr));
  98         if (bytes != sizeof(hdr)) {
  99                 dev_err(&vdpasim->vdpa.dev, "request out header too short\n");
 100                 return false;
 101         }
 102
 103         to_pull -= bytes;
 104
 105         type = vdpasim32_to_cpu(vdpasim, hdr.type);
 106         sector = vdpasim64_to_cpu(vdpasim, hdr.sector);
 107         offset = sector << SECTOR_SHIFT;
 108         status = VIRTIO_BLK_S_OK;
 109
 110         switch (type) {
 111         case VIRTIO_BLK_T_IN:
 112                 if (!vdpasim_blk_check_range(sector, to_push)) {
 113                         dev_err(&vdpasim->vdpa.dev,
 114                                 "reading over the capacity - offset: 0x%llx len: 0x%zx\n",
 115                                 offset, to_push);
 116                         status = VIRTIO_BLK_S_IOERR;
 117                         break;
 118                 }
 119
 120                 bytes = vringh_iov_push_iotlb(&vq->vring, &vq->in_iov,
 121                                               vdpasim->buffer + offset,
 122                                               to_push);
 123                 if (bytes < 0) {
 124                         dev_err(&vdpasim->vdpa.dev,
 125                                 "vringh_iov_push_iotlb() error: %zd offset: 0x%llx len: 0x%zx\n",
 126                                 bytes, offset, to_push);
 127                         status = VIRTIO_BLK_S_IOERR;
 128                         break;
 129                 }
 130
 131                 pushed += bytes;
 132                 break;
 133
 134         case VIRTIO_BLK_T_OUT:
 135                 if (!vdpasim_blk_check_range(sector, to_pull)) {
 136                         dev_err(&vdpasim->vdpa.dev,
 137                                 "writing over the capacity - offset: 0x%llx len: 0x%zx\n",
 138                                 offset, to_pull);
 139                         status = VIRTIO_BLK_S_IOERR;
 140                         break;
 141                 }
 142
 143                 bytes = vringh_iov_pull_iotlb(&vq->vring, &vq->out_iov,
 144                                               vdpasim->buffer + offset,
 145                                               to_pull);
 146                 if (bytes < 0) {
 147                         dev_err(&vdpasim->vdpa.dev,
 148                                 "vringh_iov_pull_iotlb() error: %zd offset: 0x%llx len: 0x%zx\n",
 149                                 bytes, offset, to_pull);
 150                         status = VIRTIO_BLK_S_IOERR;
 151                         break;
 152                 }
 153                 break;
 154
 155         case VIRTIO_BLK_T_GET_ID:
 156                 bytes = vringh_iov_push_iotlb(&vq->vring, &vq->in_iov,
 157                                               vdpasim_blk_id,
 158                                               VIRTIO_BLK_ID_BYTES);
 159                 if (bytes < 0) {
 160                         dev_err(&vdpasim->vdpa.dev,
 161                                 "vringh_iov_push_iotlb() error: %zd\n", bytes);
 162                         status = VIRTIO_BLK_S_IOERR;
 163                         break;
 164                 }
 165
 166                 pushed += bytes;
 167                 break;
 168
 169         default:
 170                 dev_warn(&vdpasim->vdpa.dev,
 171                          "Unsupported request type %d\n", type);
 172                 status = VIRTIO_BLK_S_IOERR;
 173                 break;
 174         }
 175
 176         /* If some operations fail, we need to skip the remaining bytes
 177          * to put the status in the last byte
 178          */
 179         if (to_push - pushed > 0)
 180                 vringh_kiov_advance(&vq->in_iov, to_push - pushed);
 181
 182         /* Last byte is the status */
 183         bytes = vringh_iov_push_iotlb(&vq->vring, &vq->in_iov, &status, 1);
 184         if (bytes != 1)
 185                 return false;
 186
 187         pushed += bytes;
 188
 189         /* Make sure data is wrote before advancing index */
 190         smp_wmb();
 191
 192         vringh_complete_iotlb(&vq->vring, vq->head, pushed);
 193
 194         return true;
 195 }
 196
 197 static void vdpasim_blk_work(struct work_struct *work)
 198 {
 199         struct vdpasim *vdpasim = container_of(work, struct vdpasim, work);
 200         int i;
 201
 202         spin_lock(&vdpasim->lock);
 203
 204         if (!(vdpasim->status & VIRTIO_CONFIG_S_DRIVER_OK))
 205                 goto out;
 206
 207         for (i = 0; i < VDPASIM_BLK_VQ_NUM; i++) {
 208                 struct vdpasim_virtqueue *vq = &vdpasim->vqs[i];
 209
 210                 if (!vq->ready)
 211                         continue;
 212
 213                 while (vdpasim_blk_handle_req(vdpasim, vq)) {
 214                         /* Make sure used is visible before rasing the interrupt. */
 215                         smp_wmb();
 216
 217                         local_bh_disable();
 218                         if (vringh_need_notify_iotlb(&vq->vring) > 0)
 219                                 vringh_notify(&vq->vring);
 220                         local_bh_enable();
 221                 }
 222         }
 223 out:
 224         spin_unlock(&vdpasim->lock);
 225 }
 226
 227 static void vdpasim_blk_get_config(struct vdpasim *vdpasim, void *config)
 228 {
 229         struct virtio_blk_config *blk_config = config;
 230
 231         memset(config, 0, sizeof(struct virtio_blk_config));
 232
 233         blk_config->capacity = cpu_to_vdpasim64(vdpasim, VDPASIM_BLK_CAPACITY);
 234         blk_config->size_max = cpu_to_vdpasim32(vdpasim, VDPASIM_BLK_SIZE_MAX);
 235         blk_config->seg_max = cpu_to_vdpasim32(vdpasim, VDPASIM_BLK_SEG_MAX);
 236         blk_config->num_queues = cpu_to_vdpasim16(vdpasim, VDPASIM_BLK_VQ_NUM);
 237         blk_config->min_io_size = cpu_to_vdpasim16(vdpasim, 1);
 238         blk_config->opt_io_size = cpu_to_vdpasim32(vdpasim, 1);
 239         blk_config->blk_size = cpu_to_vdpasim32(vdpasim, SECTOR_SIZE);
 240 }
 241
 242 static void vdpasim_blk_mgmtdev_release(struct device *dev)
 243 {
 244 }
 245
 246 static struct device vdpasim_blk_mgmtdev = {
 247         .init_name = "vdpasim_blk",
 248         .release = vdpasim_blk_mgmtdev_release,
 249 };
 250
 251 static int vdpasim_blk_dev_add(struct vdpa_mgmt_dev *mdev, const char *name)
 252 {
 253         struct vdpasim_dev_attr dev_attr = {};
 254         struct vdpasim *simdev;
 255         int ret;
 256
 257         dev_attr.mgmt_dev = mdev;
 258         dev_attr.name = name;
 259         dev_attr.id = VIRTIO_ID_BLOCK;
 260         dev_attr.supported_features = VDPASIM_BLK_FEATURES;
 261         dev_attr.nvqs = VDPASIM_BLK_VQ_NUM;
 262         dev_attr.config_size = sizeof(struct virtio_blk_config);
 263         dev_attr.get_config = vdpasim_blk_get_config;
 264         dev_attr.work_fn = vdpasim_blk_work;
 265         dev_attr.buffer_size = VDPASIM_BLK_CAPACITY << SECTOR_SHIFT;
 266
 267         simdev = vdpasim_create(&dev_attr);
 268         if (IS_ERR(simdev))
 269                 return PTR_ERR(simdev);
 270
 271         ret = _vdpa_register_device(&simdev->vdpa, VDPASIM_BLK_VQ_NUM);
 272         if (ret)
 273                 goto put_dev;
 274
 275         return 0;
 276
 277 put_dev:
 278         put_device(&simdev->vdpa.dev);
 279         return ret;
 280 }
 281
 282 static void vdpasim_blk_dev_del(struct vdpa_mgmt_dev *mdev,
 283                                 struct vdpa_device *dev)
 284 {
 285         struct vdpasim *simdev = container_of(dev, struct vdpasim, vdpa);
 286
 287         _vdpa_unregister_device(&simdev->vdpa);
 288 }
 289
 290 static const struct vdpa_mgmtdev_ops vdpasim_blk_mgmtdev_ops = {
 291         .dev_add = vdpasim_blk_dev_add,
 292         .dev_del = vdpasim_blk_dev_del
 293 };
 294
 295 static struct virtio_device_id id_table[] = {
 296         { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
 297         { 0 },
 298 };
 299
 300 static struct vdpa_mgmt_dev mgmt_dev = {
 301         .device = &vdpasim_blk_mgmtdev,
 302         .id_table = id_table,
 303         .ops = &vdpasim_blk_mgmtdev_ops,
 304 };
 305
 306 static int __init vdpasim_blk_init(void)
 307 {
 308         int ret;
 309
 310         ret = device_register(&vdpasim_blk_mgmtdev);
 311         if (ret)
 312                 return ret;
 313
 314         ret = vdpa_mgmtdev_register(&mgmt_dev);
 315         if (ret)
 316                 goto parent_err;
 317
 318         return 0;
 319
 320 parent_err:
 321         device_unregister(&vdpasim_blk_mgmtdev);
 322         return ret;
 323 }
 324
 325 static void __exit vdpasim_blk_exit(void)
 326 {
 327         vdpa_mgmtdev_unregister(&mgmt_dev);
 328         device_unregister(&vdpasim_blk_mgmtdev);
 329 }
 330
 331 module_init(vdpasim_blk_init)
 332 module_exit(vdpasim_blk_exit)
 333
 334 MODULE_VERSION(DRV_VERSION);
 335 MODULE_LICENSE(DRV_LICENSE);
 336 MODULE_AUTHOR(DRV_AUTHOR);
 337 MODULE_DESCRIPTION(DRV_DESC);