lib/librte_vhost/vdpa.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 /**
   6  * @file
   7  *
   8  * Device specific vhost lib
   9  */
  10
  11 #include <stdbool.h>
  12
  13 #include <rte_malloc.h>
  14 #include "rte_vdpa.h"
  15 #include "vhost.h"
  16
  17 static struct rte_vdpa_device *vdpa_devices[MAX_VHOST_DEVICE];
  18 static uint32_t vdpa_device_num;
  19
  20 static bool
  21 is_same_vdpa_device(struct rte_vdpa_dev_addr *a,
  22                 struct rte_vdpa_dev_addr *b)
  23 {
  24         bool ret = true;
  25
  26         if (a->type != b->type)
  27                 return false;
  28
  29         switch (a->type) {
  30         case PCI_ADDR:
  31                 if (a->pci_addr.domain != b->pci_addr.domain ||
  32                                 a->pci_addr.bus != b->pci_addr.bus ||
  33                                 a->pci_addr.devid != b->pci_addr.devid ||
  34                                 a->pci_addr.function != b->pci_addr.function)
  35                         ret = false;
  36                 break;
  37         default:
  38                 break;
  39         }
  40
  41         return ret;
  42 }
  43
  44 int
  45 rte_vdpa_register_device(struct rte_vdpa_dev_addr *addr,
  46                 struct rte_vdpa_dev_ops *ops)
  47 {
  48         struct rte_vdpa_device *dev;
  49         char device_name[MAX_VDPA_NAME_LEN];
  50         int i;
  51
  52         if (vdpa_device_num >= MAX_VHOST_DEVICE)
  53                 return -1;
  54
  55         for (i = 0; i < MAX_VHOST_DEVICE; i++) {
  56                 dev = vdpa_devices[i];
  57                 if (dev && is_same_vdpa_device(&dev->addr, addr))
  58                         return -1;
  59         }
  60
  61         for (i = 0; i < MAX_VHOST_DEVICE; i++) {
  62                 if (vdpa_devices[i] == NULL)
  63                         break;
  64         }
  65
  66         if (i == MAX_VHOST_DEVICE)
  67                 return -1;
  68
  69         sprintf(device_name, "vdpa-dev-%d", i);
  70         dev = rte_zmalloc(device_name, sizeof(struct rte_vdpa_device),
  71                         RTE_CACHE_LINE_SIZE);
  72         if (!dev)
  73                 return -1;
  74
  75         memcpy(&dev->addr, addr, sizeof(struct rte_vdpa_dev_addr));
  76         dev->ops = ops;
  77         vdpa_devices[i] = dev;
  78         vdpa_device_num++;
  79
  80         return i;
  81 }
  82
  83 int
  84 rte_vdpa_unregister_device(int did)
  85 {
  86         if (did < 0 || did >= MAX_VHOST_DEVICE || vdpa_devices[did] == NULL)
  87                 return -1;
  88
  89         rte_free(vdpa_devices[did]);
  90         vdpa_devices[did] = NULL;
  91         vdpa_device_num--;
  92
  93         return did;
  94 }
  95
  96 int
  97 rte_vdpa_find_device_id(struct rte_vdpa_dev_addr *addr)
  98 {
  99         struct rte_vdpa_device *dev;
 100         int i;
 101
 102         for (i = 0; i < MAX_VHOST_DEVICE; ++i) {
 103                 dev = vdpa_devices[i];
 104                 if (dev && is_same_vdpa_device(&dev->addr, addr))
 105                         return i;
 106         }
 107
 108         return -1;
 109 }
 110
 111 struct rte_vdpa_device *
 112 rte_vdpa_get_device(int did)
 113 {
 114         if (did < 0 || did >= MAX_VHOST_DEVICE)
 115                 return NULL;
 116
 117         return vdpa_devices[did];
 118 }
 119
 120 int
 121 rte_vdpa_get_device_num(void)
 122 {
 123         return vdpa_device_num;
 124 }
 125
 126 int __rte_experimental
 127 rte_vdpa_relay_vring_used(int vid, uint16_t qid, void *vring_m)
 128 {
 129         struct virtio_net *dev = get_device(vid);
 130         uint16_t idx, idx_m, desc_id;
 131         struct vhost_virtqueue *vq;
 132         struct vring_desc desc;
 133         struct vring_desc *desc_ring;
 134         struct vring_desc *idesc = NULL;
 135         struct vring *s_vring;
 136         uint64_t dlen;
 137         uint32_t nr_descs;
 138         int ret;
 139
 140         if (!dev || !vring_m)
 141                 return -1;
 142
 143         if (qid >= dev->nr_vring)
 144                 return -1;
 145
 146         if (vq_is_packed(dev))
 147                 return -1;
 148
 149         s_vring = (struct vring *)vring_m;
 150         vq = dev->virtqueue[qid];
 151         idx = vq->used->idx;
 152         idx_m = s_vring->used->idx;
 153         ret = (uint16_t)(idx_m - idx);
 154
 155         while (idx != idx_m) {
 156                 /* copy used entry, used ring logging is not covered here */
 157                 vq->used->ring[idx & (vq->size - 1)] =
 158                         s_vring->used->ring[idx & (vq->size - 1)];
 159
 160                 desc_id = vq->used->ring[idx & (vq->size - 1)].id;
 161                 desc_ring = vq->desc;
 162                 nr_descs = vq->size;
 163
 164                 if (unlikely(desc_id >= vq->size))
 165                         return -1;
 166
 167                 if (vq->desc[desc_id].flags & VRING_DESC_F_INDIRECT) {
 168                         dlen = vq->desc[desc_id].len;
 169                         nr_descs = dlen / sizeof(struct vring_desc);
 170                         if (unlikely(nr_descs > vq->size))
 171                                 return -1;
 172
 173                         desc_ring = (struct vring_desc *)(uintptr_t)
 174                                 vhost_iova_to_vva(dev, vq,
 175                                                 vq->desc[desc_id].addr, &dlen,
 176                                                 VHOST_ACCESS_RO);
 177                         if (unlikely(!desc_ring))
 178                                 return -1;
 179
 180                         if (unlikely(dlen < vq->desc[desc_id].len)) {
 181                                 idesc = alloc_copy_ind_table(dev, vq,
 182                                                 vq->desc[desc_id].addr,
 183                                                 vq->desc[desc_id].len);
 184                                 if (unlikely(!idesc))
 185                                         return -1;
 186
 187                                 desc_ring = idesc;
 188                         }
 189
 190                         desc_id = 0;
 191                 }
 192
 193                 /* dirty page logging for DMA writeable buffer */
 194                 do {
 195                         if (unlikely(desc_id >= vq->size))
 196                                 goto fail;
 197                         if (unlikely(nr_descs-- == 0))
 198                                 goto fail;
 199                         desc = desc_ring[desc_id];
 200                         if (desc.flags & VRING_DESC_F_WRITE)
 201                                 vhost_log_write(dev, desc.addr, desc.len);
 202                         desc_id = desc.next;
 203                 } while (desc.flags & VRING_DESC_F_NEXT);
 204
 205                 if (unlikely(idesc)) {
 206                         free_ind_table(idesc);
 207                         idesc = NULL;
 208                 }
 209
 210                 idx++;
 211         }
 212
 213         rte_smp_wmb();
 214         vq->used->idx = idx_m;
 215
 216         if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX))
 217                 vring_used_event(s_vring) = idx_m;
 218
 219         return ret;
 220
 221 fail:
 222         if (unlikely(idesc))
 223                 free_ind_table(idesc);
 224         return -1;
 225 }