drivers/xen/grant-dma-ops.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Xen grant DMA-mapping layer - contains special DMA-mapping routines
   4  * for providing grant references as DMA addresses to be used by frontends
   5  * (e.g. virtio) in Xen guests
   6  *
   7  * Copyright (c) 2021, Juergen Gross <jgross@suse.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/dma-map-ops.h>
  12 #include <linux/of.h>
  13 #include <linux/pci.h>
  14 #include <linux/pfn.h>
  15 #include <linux/xarray.h>
  16 #include <linux/virtio_anchor.h>
  17 #include <linux/virtio.h>
  18 #include <xen/xen.h>
  19 #include <xen/xen-ops.h>
  20 #include <xen/grant_table.h>
  21
  22 struct xen_grant_dma_data {
  23         /* The ID of backend domain */
  24         domid_t backend_domid;
  25         /* Is device behaving sane? */
  26         bool broken;
  27 };
  28
  29 static DEFINE_XARRAY_FLAGS(xen_grant_dma_devices, XA_FLAGS_LOCK_IRQ);
  30
  31 #define XEN_GRANT_DMA_ADDR_OFF  (1ULL << 63)
  32
  33 static inline dma_addr_t grant_to_dma(grant_ref_t grant)
  34 {
  35         return XEN_GRANT_DMA_ADDR_OFF | ((dma_addr_t)grant << XEN_PAGE_SHIFT);
  36 }
  37
  38 static inline grant_ref_t dma_to_grant(dma_addr_t dma)
  39 {
  40         return (grant_ref_t)((dma & ~XEN_GRANT_DMA_ADDR_OFF) >> XEN_PAGE_SHIFT);
  41 }
  42
  43 static struct xen_grant_dma_data *find_xen_grant_dma_data(struct device *dev)
  44 {
  45         struct xen_grant_dma_data *data;
  46         unsigned long flags;
  47
  48         xa_lock_irqsave(&xen_grant_dma_devices, flags);
  49         data = xa_load(&xen_grant_dma_devices, (unsigned long)dev);
  50         xa_unlock_irqrestore(&xen_grant_dma_devices, flags);
  51
  52         return data;
  53 }
  54
  55 static int store_xen_grant_dma_data(struct device *dev,
  56                                     struct xen_grant_dma_data *data)
  57 {
  58         unsigned long flags;
  59         int ret;
  60
  61         xa_lock_irqsave(&xen_grant_dma_devices, flags);
  62         ret = xa_err(__xa_store(&xen_grant_dma_devices, (unsigned long)dev, data,
  63                         GFP_ATOMIC));
  64         xa_unlock_irqrestore(&xen_grant_dma_devices, flags);
  65
  66         return ret;
  67 }
  68
  69 /*
  70  * DMA ops for Xen frontends (e.g. virtio).
  71  *
  72  * Used to act as a kind of software IOMMU for Xen guests by using grants as
  73  * DMA addresses.
  74  * Such a DMA address is formed by using the grant reference as a frame
  75  * number and setting the highest address bit (this bit is for the backend
  76  * to be able to distinguish it from e.g. a mmio address).
  77  */
  78 static void *xen_grant_dma_alloc(struct device *dev, size_t size,
  79                                  dma_addr_t *dma_handle, gfp_t gfp,
  80                                  unsigned long attrs)
  81 {
  82         struct xen_grant_dma_data *data;
  83         unsigned int i, n_pages = XEN_PFN_UP(size);
  84         unsigned long pfn;
  85         grant_ref_t grant;
  86         void *ret;
  87
  88         data = find_xen_grant_dma_data(dev);
  89         if (!data)
  90                 return NULL;
  91
  92         if (unlikely(data->broken))
  93                 return NULL;
  94
  95         ret = alloc_pages_exact(n_pages * XEN_PAGE_SIZE, gfp);
  96         if (!ret)
  97                 return NULL;
  98
  99         pfn = virt_to_pfn(ret);
 100
 101         if (gnttab_alloc_grant_reference_seq(n_pages, &grant)) {
 102                 free_pages_exact(ret, n_pages * XEN_PAGE_SIZE);
 103                 return NULL;
 104         }
 105
 106         for (i = 0; i < n_pages; i++) {
 107                 gnttab_grant_foreign_access_ref(grant + i, data->backend_domid,
 108                                 pfn_to_gfn(pfn + i), 0);
 109         }
 110
 111         *dma_handle = grant_to_dma(grant);
 112
 113         return ret;
 114 }
 115
 116 static void xen_grant_dma_free(struct device *dev, size_t size, void *vaddr,
 117                                dma_addr_t dma_handle, unsigned long attrs)
 118 {
 119         struct xen_grant_dma_data *data;
 120         unsigned int i, n_pages = XEN_PFN_UP(size);
 121         grant_ref_t grant;
 122
 123         data = find_xen_grant_dma_data(dev);
 124         if (!data)
 125                 return;
 126
 127         if (unlikely(data->broken))
 128                 return;
 129
 130         grant = dma_to_grant(dma_handle);
 131
 132         for (i = 0; i < n_pages; i++) {
 133                 if (unlikely(!gnttab_end_foreign_access_ref(grant + i))) {
 134                         dev_alert(dev, "Grant still in use by backend domain, disabled for further use\n");
 135                         data->broken = true;
 136                         return;
 137                 }
 138         }
 139
 140         gnttab_free_grant_reference_seq(grant, n_pages);
 141
 142         free_pages_exact(vaddr, n_pages * XEN_PAGE_SIZE);
 143 }
 144
 145 static struct page *xen_grant_dma_alloc_pages(struct device *dev, size_t size,
 146                                               dma_addr_t *dma_handle,
 147                                               enum dma_data_direction dir,
 148                                               gfp_t gfp)
 149 {
 150         void *vaddr;
 151
 152         vaddr = xen_grant_dma_alloc(dev, size, dma_handle, gfp, 0);
 153         if (!vaddr)
 154                 return NULL;
 155
 156         return virt_to_page(vaddr);
 157 }
 158
 159 static void xen_grant_dma_free_pages(struct device *dev, size_t size,
 160                                      struct page *vaddr, dma_addr_t dma_handle,
 161                                      enum dma_data_direction dir)
 162 {
 163         xen_grant_dma_free(dev, size, page_to_virt(vaddr), dma_handle, 0);
 164 }
 165
 166 static dma_addr_t xen_grant_dma_map_page(struct device *dev, struct page *page,
 167                                          unsigned long offset, size_t size,
 168                                          enum dma_data_direction dir,
 169                                          unsigned long attrs)
 170 {
 171         struct xen_grant_dma_data *data;
 172         unsigned long dma_offset = xen_offset_in_page(offset),
 173                         pfn_offset = XEN_PFN_DOWN(offset);
 174         unsigned int i, n_pages = XEN_PFN_UP(dma_offset + size);
 175         grant_ref_t grant;
 176         dma_addr_t dma_handle;
 177
 178         if (WARN_ON(dir == DMA_NONE))
 179                 return DMA_MAPPING_ERROR;
 180
 181         data = find_xen_grant_dma_data(dev);
 182         if (!data)
 183                 return DMA_MAPPING_ERROR;
 184
 185         if (unlikely(data->broken))
 186                 return DMA_MAPPING_ERROR;
 187
 188         if (gnttab_alloc_grant_reference_seq(n_pages, &grant))
 189                 return DMA_MAPPING_ERROR;
 190
 191         for (i = 0; i < n_pages; i++) {
 192                 gnttab_grant_foreign_access_ref(grant + i, data->backend_domid,
 193                                 pfn_to_gfn(page_to_xen_pfn(page) + i + pfn_offset),
 194                                 dir == DMA_TO_DEVICE);
 195         }
 196
 197         dma_handle = grant_to_dma(grant) + dma_offset;
 198
 199         return dma_handle;
 200 }
 201
 202 static void xen_grant_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
 203                                      size_t size, enum dma_data_direction dir,
 204                                      unsigned long attrs)
 205 {
 206         struct xen_grant_dma_data *data;
 207         unsigned long dma_offset = xen_offset_in_page(dma_handle);
 208         unsigned int i, n_pages = XEN_PFN_UP(dma_offset + size);
 209         grant_ref_t grant;
 210
 211         if (WARN_ON(dir == DMA_NONE))
 212                 return;
 213
 214         data = find_xen_grant_dma_data(dev);
 215         if (!data)
 216                 return;
 217
 218         if (unlikely(data->broken))
 219                 return;
 220
 221         grant = dma_to_grant(dma_handle);
 222
 223         for (i = 0; i < n_pages; i++) {
 224                 if (unlikely(!gnttab_end_foreign_access_ref(grant + i))) {
 225                         dev_alert(dev, "Grant still in use by backend domain, disabled for further use\n");
 226                         data->broken = true;
 227                         return;
 228                 }
 229         }
 230
 231         gnttab_free_grant_reference_seq(grant, n_pages);
 232 }
 233
 234 static void xen_grant_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
 235                                    int nents, enum dma_data_direction dir,
 236                                    unsigned long attrs)
 237 {
 238         struct scatterlist *s;
 239         unsigned int i;
 240
 241         if (WARN_ON(dir == DMA_NONE))
 242                 return;
 243
 244         for_each_sg(sg, s, nents, i)
 245                 xen_grant_dma_unmap_page(dev, s->dma_address, sg_dma_len(s), dir,
 246                                 attrs);
 247 }
 248
 249 static int xen_grant_dma_map_sg(struct device *dev, struct scatterlist *sg,
 250                                 int nents, enum dma_data_direction dir,
 251                                 unsigned long attrs)
 252 {
 253         struct scatterlist *s;
 254         unsigned int i;
 255
 256         if (WARN_ON(dir == DMA_NONE))
 257                 return -EINVAL;
 258
 259         for_each_sg(sg, s, nents, i) {
 260                 s->dma_address = xen_grant_dma_map_page(dev, sg_page(s), s->offset,
 261                                 s->length, dir, attrs);
 262                 if (s->dma_address == DMA_MAPPING_ERROR)
 263                         goto out;
 264
 265                 sg_dma_len(s) = s->length;
 266         }
 267
 268         return nents;
 269
 270 out:
 271         xen_grant_dma_unmap_sg(dev, sg, i, dir, attrs | DMA_ATTR_SKIP_CPU_SYNC);
 272         sg_dma_len(sg) = 0;
 273
 274         return -EIO;
 275 }
 276
 277 static int xen_grant_dma_supported(struct device *dev, u64 mask)
 278 {
 279         return mask == DMA_BIT_MASK(64);
 280 }
 281
 282 static const struct dma_map_ops xen_grant_dma_ops = {
 283         .alloc = xen_grant_dma_alloc,
 284         .free = xen_grant_dma_free,
 285         .alloc_pages = xen_grant_dma_alloc_pages,
 286         .free_pages = xen_grant_dma_free_pages,
 287         .mmap = dma_common_mmap,
 288         .get_sgtable = dma_common_get_sgtable,
 289         .map_page = xen_grant_dma_map_page,
 290         .unmap_page = xen_grant_dma_unmap_page,
 291         .map_sg = xen_grant_dma_map_sg,
 292         .unmap_sg = xen_grant_dma_unmap_sg,
 293         .dma_supported = xen_grant_dma_supported,
 294 };
 295
 296 static struct device_node *xen_dt_get_node(struct device *dev)
 297 {
 298         if (dev_is_pci(dev)) {
 299                 struct pci_dev *pdev = to_pci_dev(dev);
 300                 struct pci_bus *bus = pdev->bus;
 301
 302                 /* Walk up to the root bus to look for PCI Host controller */
 303                 while (!pci_is_root_bus(bus))
 304                         bus = bus->parent;
 305
 306                 if (!bus->bridge->parent)
 307                         return NULL;
 308                 return of_node_get(bus->bridge->parent->of_node);
 309         }
 310
 311         return of_node_get(dev->of_node);
 312 }
 313
 314 static int xen_dt_grant_init_backend_domid(struct device *dev,
 315                                            struct device_node *np,
 316                                            domid_t *backend_domid)
 317 {
 318         struct of_phandle_args iommu_spec = { .args_count = 1 };
 319
 320         if (dev_is_pci(dev)) {
 321                 struct pci_dev *pdev = to_pci_dev(dev);
 322                 u32 rid = PCI_DEVID(pdev->bus->number, pdev->devfn);
 323
 324                 if (of_map_id(np, rid, "iommu-map", "iommu-map-mask", &iommu_spec.np,
 325                                 iommu_spec.args)) {
 326                         dev_dbg(dev, "Cannot translate ID\n");
 327                         return -ESRCH;
 328                 }
 329         } else {
 330                 if (of_parse_phandle_with_args(np, "iommus", "#iommu-cells",
 331                                 0, &iommu_spec)) {
 332                         dev_dbg(dev, "Cannot parse iommus property\n");
 333                         return -ESRCH;
 334                 }
 335         }
 336
 337         if (!of_device_is_compatible(iommu_spec.np, "xen,grant-dma") ||
 338                         iommu_spec.args_count != 1) {
 339                 dev_dbg(dev, "Incompatible IOMMU node\n");
 340                 of_node_put(iommu_spec.np);
 341                 return -ESRCH;
 342         }
 343
 344         of_node_put(iommu_spec.np);
 345
 346         /*
 347          * The endpoint ID here means the ID of the domain where the
 348          * corresponding backend is running
 349          */
 350         *backend_domid = iommu_spec.args[0];
 351
 352         return 0;
 353 }
 354
 355 static int xen_grant_init_backend_domid(struct device *dev,
 356                                         domid_t *backend_domid)
 357 {
 358         struct device_node *np;
 359         int ret = -ENODEV;
 360
 361         np = xen_dt_get_node(dev);
 362         if (np) {
 363                 ret = xen_dt_grant_init_backend_domid(dev, np, backend_domid);
 364                 of_node_put(np);
 365         } else if (IS_ENABLED(CONFIG_XEN_VIRTIO_FORCE_GRANT) || xen_pv_domain()) {
 366                 dev_info(dev, "Using dom0 as backend\n");
 367                 *backend_domid = 0;
 368                 ret = 0;
 369         }
 370
 371         return ret;
 372 }
 373
 374 static void xen_grant_setup_dma_ops(struct device *dev, domid_t backend_domid)
 375 {
 376         struct xen_grant_dma_data *data;
 377
 378         data = find_xen_grant_dma_data(dev);
 379         if (data) {
 380                 dev_err(dev, "Xen grant DMA data is already created\n");
 381                 return;
 382         }
 383
 384         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 385         if (!data)
 386                 goto err;
 387
 388         data->backend_domid = backend_domid;
 389
 390         if (store_xen_grant_dma_data(dev, data)) {
 391                 dev_err(dev, "Cannot store Xen grant DMA data\n");
 392                 goto err;
 393         }
 394
 395         dev->dma_ops = &xen_grant_dma_ops;
 396
 397         return;
 398
 399 err:
 400         devm_kfree(dev, data);
 401         dev_err(dev, "Cannot set up Xen grant DMA ops, retain platform DMA ops\n");
 402 }
 403
 404 bool xen_virtio_restricted_mem_acc(struct virtio_device *dev)
 405 {
 406         domid_t backend_domid;
 407
 408         if (!xen_grant_init_backend_domid(dev->dev.parent, &backend_domid)) {
 409                 xen_grant_setup_dma_ops(dev->dev.parent, backend_domid);
 410                 return true;
 411         }
 412
 413         return false;
 414 }
 415
 416 MODULE_DESCRIPTION("Xen grant DMA-mapping layer");
 417 MODULE_AUTHOR("Juergen Gross <jgross@suse.com>");
 418 MODULE_LICENSE("GPL");