lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening PHC | |
Open Source and information security mailing list archives
| ||
|
Date: Fri, 31 Aug 2018 10:04:29 +0200 From: Christian König <christian.koenig@....com> To: Logan Gunthorpe <logang@...tatee.com>, linux-kernel@...r.kernel.org, linux-pci@...r.kernel.org, linux-nvme@...ts.infradead.org, linux-rdma@...r.kernel.org, linux-nvdimm@...ts.01.org, linux-block@...r.kernel.org Cc: Stephen Bates <sbates@...thlin.com>, Christoph Hellwig <hch@....de>, Keith Busch <keith.busch@...el.com>, Sagi Grimberg <sagi@...mberg.me>, Bjorn Helgaas <bhelgaas@...gle.com>, Jason Gunthorpe <jgg@...lanox.com>, Max Gurtovoy <maxg@...lanox.com>, Dan Williams <dan.j.williams@...el.com>, Jérôme Glisse <jglisse@...hat.com>, Benjamin Herrenschmidt <benh@...nel.crashing.org>, Alex Williamson <alex.williamson@...hat.com> Subject: Re: [PATCH v5 01/13] PCI/P2PDMA: Support peer-to-peer memory Am 30.08.2018 um 20:53 schrieb Logan Gunthorpe: > Some PCI devices may have memory mapped in a BAR space that's > intended for use in peer-to-peer transactions. In order to enable > such transactions the memory must be registered with ZONE_DEVICE pages > so it can be used by DMA interfaces in existing drivers. We want to use that feature without ZONE_DEVICE pages for DMA-buf as well. How hard would it be to separate enabling P2P detection (e.g. distance between two devices) from this? Regards, Christian. > > Add an interface for other subsystems to find and allocate chunks of P2P > memory as necessary to facilitate transfers between two PCI peers: > > int pci_p2pdma_add_client(); > struct pci_dev *pci_p2pmem_find(); > void *pci_alloc_p2pmem(); > > The new interface requires a driver to collect a list of client devices > involved in the transaction with the pci_p2pmem_add_client*() functions > then call pci_p2pmem_find() to obtain any suitable P2P memory. Once > this is done the list is bound to the memory and the calling driver is > free to add and remove clients as necessary (adding incompatible clients > will fail). With a suitable p2pmem device, memory can then be > allocated with pci_alloc_p2pmem() for use in DMA transactions. > > Depending on hardware, using peer-to-peer memory may reduce the bandwidth > of the transfer but can significantly reduce pressure on system memory. > This may be desirable in many cases: for example a system could be designed > with a small CPU connected to a PCIe switch by a small number of lanes > which would maximize the number of lanes available to connect to NVMe > devices. > > The code is designed to only utilize the p2pmem device if all the devices > involved in a transfer are behind the same PCI bridge. This is because we > have no way of knowing whether peer-to-peer routing between PCIe Root Ports > is supported (PCIe r4.0, sec 1.3.1). Additionally, the benefits of P2P > transfers that go through the RC is limited to only reducing DRAM usage > and, in some cases, coding convenience. The PCI-SIG may be exploring > adding a new capability bit to advertise whether this is possible for > future hardware. > > This commit includes significant rework and feedback from Christoph > Hellwig. > > Signed-off-by: Christoph Hellwig <hch@....de> > Signed-off-by: Logan Gunthorpe <logang@...tatee.com> > --- > drivers/pci/Kconfig | 17 + > drivers/pci/Makefile | 1 + > drivers/pci/p2pdma.c | 761 +++++++++++++++++++++++++++++++++++++++++++++ > include/linux/memremap.h | 5 + > include/linux/mm.h | 18 ++ > include/linux/pci-p2pdma.h | 102 ++++++ > include/linux/pci.h | 4 + > 7 files changed, 908 insertions(+) > create mode 100644 drivers/pci/p2pdma.c > create mode 100644 include/linux/pci-p2pdma.h > > diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig > index 56ff8f6d31fc..deb68be4fdac 100644 > --- a/drivers/pci/Kconfig > +++ b/drivers/pci/Kconfig > @@ -132,6 +132,23 @@ config PCI_PASID > > If unsure, say N. > > +config PCI_P2PDMA > + bool "PCI peer-to-peer transfer support" > + depends on PCI && ZONE_DEVICE > + select GENERIC_ALLOCATOR > + help > + Enableѕ drivers to do PCI peer-to-peer transactions to and from > + BARs that are exposed in other devices that are the part of > + the hierarchy where peer-to-peer DMA is guaranteed by the PCI > + specification to work (ie. anything below a single PCI bridge). > + > + Many PCIe root complexes do not support P2P transactions and > + it's hard to tell which support it at all, so at this time, > + P2P DMA transations must be between devices behind the same root > + port. > + > + If unsure, say N. > + > config PCI_LABEL > def_bool y if (DMI || ACPI) > depends on PCI > diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile > index 1b2cfe51e8d7..85f4a703b2be 100644 > --- a/drivers/pci/Makefile > +++ b/drivers/pci/Makefile > @@ -26,6 +26,7 @@ obj-$(CONFIG_PCI_SYSCALL) += syscall.o > obj-$(CONFIG_PCI_STUB) += pci-stub.o > obj-$(CONFIG_PCI_PF_STUB) += pci-pf-stub.o > obj-$(CONFIG_PCI_ECAM) += ecam.o > +obj-$(CONFIG_PCI_P2PDMA) += p2pdma.o > obj-$(CONFIG_XEN_PCIDEV_FRONTEND) += xen-pcifront.o > > # Endpoint library must be initialized before its users > diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c > new file mode 100644 > index 000000000000..88aaec5351cd > --- /dev/null > +++ b/drivers/pci/p2pdma.c > @@ -0,0 +1,761 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * PCI Peer 2 Peer DMA support. > + * > + * Copyright (c) 2016-2018, Logan Gunthorpe > + * Copyright (c) 2016-2017, Microsemi Corporation > + * Copyright (c) 2017, Christoph Hellwig > + * Copyright (c) 2018, Eideticom Inc. > + */ > + > +#define pr_fmt(fmt) "pci-p2pdma: " fmt > +#include <linux/pci-p2pdma.h> > +#include <linux/module.h> > +#include <linux/slab.h> > +#include <linux/genalloc.h> > +#include <linux/memremap.h> > +#include <linux/percpu-refcount.h> > +#include <linux/random.h> > +#include <linux/seq_buf.h> > + > +struct pci_p2pdma { > + struct percpu_ref devmap_ref; > + struct completion devmap_ref_done; > + struct gen_pool *pool; > + bool p2pmem_published; > +}; > + > +static void pci_p2pdma_percpu_release(struct percpu_ref *ref) > +{ > + struct pci_p2pdma *p2p = > + container_of(ref, struct pci_p2pdma, devmap_ref); > + > + complete_all(&p2p->devmap_ref_done); > +} > + > +static void pci_p2pdma_percpu_kill(void *data) > +{ > + struct percpu_ref *ref = data; > + > + if (percpu_ref_is_dying(ref)) > + return; > + > + percpu_ref_kill(ref); > +} > + > +static void pci_p2pdma_release(void *data) > +{ > + struct pci_dev *pdev = data; > + > + if (!pdev->p2pdma) > + return; > + > + wait_for_completion(&pdev->p2pdma->devmap_ref_done); > + percpu_ref_exit(&pdev->p2pdma->devmap_ref); > + > + gen_pool_destroy(pdev->p2pdma->pool); > + pdev->p2pdma = NULL; > +} > + > +static int pci_p2pdma_setup(struct pci_dev *pdev) > +{ > + int error = -ENOMEM; > + struct pci_p2pdma *p2p; > + > + p2p = devm_kzalloc(&pdev->dev, sizeof(*p2p), GFP_KERNEL); > + if (!p2p) > + return -ENOMEM; > + > + p2p->pool = gen_pool_create(PAGE_SHIFT, dev_to_node(&pdev->dev)); > + if (!p2p->pool) > + goto out; > + > + init_completion(&p2p->devmap_ref_done); > + error = percpu_ref_init(&p2p->devmap_ref, > + pci_p2pdma_percpu_release, 0, GFP_KERNEL); > + if (error) > + goto out_pool_destroy; > + > + percpu_ref_switch_to_atomic_sync(&p2p->devmap_ref); > + > + error = devm_add_action_or_reset(&pdev->dev, pci_p2pdma_release, pdev); > + if (error) > + goto out_pool_destroy; > + > + pdev->p2pdma = p2p; > + > + return 0; > + > +out_pool_destroy: > + gen_pool_destroy(p2p->pool); > +out: > + devm_kfree(&pdev->dev, p2p); > + return error; > +} > + > +/** > + * pci_p2pdma_add_resource - add memory for use as p2p memory > + * @pdev: the device to add the memory to > + * @bar: PCI BAR to add > + * @size: size of the memory to add, may be zero to use the whole BAR > + * @offset: offset into the PCI BAR > + * > + * The memory will be given ZONE_DEVICE struct pages so that it may > + * be used with any DMA request. > + */ > +int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, > + u64 offset) > +{ > + struct dev_pagemap *pgmap; > + void *addr; > + int error; > + > + if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) > + return -EINVAL; > + > + if (offset >= pci_resource_len(pdev, bar)) > + return -EINVAL; > + > + if (!size) > + size = pci_resource_len(pdev, bar) - offset; > + > + if (size + offset > pci_resource_len(pdev, bar)) > + return -EINVAL; > + > + if (!pdev->p2pdma) { > + error = pci_p2pdma_setup(pdev); > + if (error) > + return error; > + } > + > + pgmap = devm_kzalloc(&pdev->dev, sizeof(*pgmap), GFP_KERNEL); > + if (!pgmap) > + return -ENOMEM; > + > + pgmap->res.start = pci_resource_start(pdev, bar) + offset; > + pgmap->res.end = pgmap->res.start + size - 1; > + pgmap->res.flags = pci_resource_flags(pdev, bar); > + pgmap->ref = &pdev->p2pdma->devmap_ref; > + pgmap->type = MEMORY_DEVICE_PCI_P2PDMA; > + > + addr = devm_memremap_pages(&pdev->dev, pgmap); > + if (IS_ERR(addr)) { > + error = PTR_ERR(addr); > + goto pgmap_free; > + } > + > + error = gen_pool_add_virt(pdev->p2pdma->pool, (unsigned long)addr, > + pci_bus_address(pdev, bar) + offset, > + resource_size(&pgmap->res), dev_to_node(&pdev->dev)); > + if (error) > + goto pgmap_free; > + > + error = devm_add_action_or_reset(&pdev->dev, pci_p2pdma_percpu_kill, > + &pdev->p2pdma->devmap_ref); > + if (error) > + goto pgmap_free; > + > + pci_info(pdev, "added peer-to-peer DMA memory %pR\n", > + &pgmap->res); > + > + return 0; > + > +pgmap_free: > + devres_free(pgmap); > + return error; > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_add_resource); > + > +static struct pci_dev *find_parent_pci_dev(struct device *dev) > +{ > + struct device *parent; > + > + dev = get_device(dev); > + > + while (dev) { > + if (dev_is_pci(dev)) > + return to_pci_dev(dev); > + > + parent = get_device(dev->parent); > + put_device(dev); > + dev = parent; > + } > + > + return NULL; > +} > + > +/* > + * Check if a PCI bridge has it's ACS redirection bits set to redirect P2P > + * TLPs upstream via ACS. Returns 1 if the packets will be redirected > + * upstream, 0 otherwise. > + */ > +static int pci_bridge_has_acs_redir(struct pci_dev *dev) > +{ > + int pos; > + u16 ctrl; > + > + pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ACS); > + if (!pos) > + return 0; > + > + pci_read_config_word(dev, pos + PCI_ACS_CTRL, &ctrl); > + > + if (ctrl & (PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_EC)) > + return 1; > + > + return 0; > +} > + > +static void seq_buf_print_bus_devfn(struct seq_buf *buf, struct pci_dev *dev) > +{ > + if (!buf) > + return; > + > + seq_buf_printf(buf, "%04x:%02x:%02x.%x;", pci_domain_nr(dev->bus), > + dev->bus->number, PCI_SLOT(dev->devfn), > + PCI_FUNC(dev->devfn)); > +} > + > +/* > + * Find the distance through the nearest common upstream bridge between > + * two PCI devices. > + * > + * If the two devices are the same device then 0 will be returned. > + * > + * If there are two virtual functions of the same device behind the same > + * bridge port then 2 will be returned (one step down to the PCIe switch, > + * then one step back to the same device). > + * > + * In the case where two devices are connected to the same PCIe switch, the > + * value 4 will be returned. This corresponds to the following PCI tree: > + * > + * -+ Root Port > + * \+ Switch Upstream Port > + * +-+ Switch Downstream Port > + * + \- Device A > + * \-+ Switch Downstream Port > + * \- Device B > + * > + * The distance is 4 because we traverse from Device A through the downstream > + * port of the switch, to the common upstream port, back up to the second > + * downstream port and then to Device B. > + * > + * Any two devices that don't have a common upstream bridge will return -1. > + * In this way devices on separate PCIe root ports will be rejected, which > + * is what we want for peer-to-peer seeing each PCIe root port defines a > + * separate hierarchy domain and there's no way to determine whether the root > + * complex supports forwarding between them. > + * > + * In the case where two devices are connected to different PCIe switches, > + * this function will still return a positive distance as long as both > + * switches evenutally have a common upstream bridge. Note this covers > + * the case of using multiple PCIe switches to achieve a desired level of > + * fan-out from a root port. The exact distance will be a function of the > + * number of switches between Device A and Device B. > + * > + * If a bridge which has any ACS redirection bits set is in the path > + * then this functions will return -2. This is so we reject any > + * cases where the TLPs are forwarded up into the root complex. > + * In this case, a list of all infringing bridge addresses will be > + * populated in acs_list (assuming it's non-null) for printk purposes. > + */ > +static int upstream_bridge_distance(struct pci_dev *a, > + struct pci_dev *b, > + struct seq_buf *acs_list) > +{ > + int dist_a = 0; > + int dist_b = 0; > + struct pci_dev *bb = NULL; > + int acs_cnt = 0; > + > + /* > + * Note, we don't need to take references to devices returned by > + * pci_upstream_bridge() seeing we hold a reference to a child > + * device which will already hold a reference to the upstream bridge. > + */ > + > + while (a) { > + dist_b = 0; > + > + if (pci_bridge_has_acs_redir(a)) { > + seq_buf_print_bus_devfn(acs_list, a); > + acs_cnt++; > + } > + > + bb = b; > + > + while (bb) { > + if (a == bb) > + goto check_b_path_acs; > + > + bb = pci_upstream_bridge(bb); > + dist_b++; > + } > + > + a = pci_upstream_bridge(a); > + dist_a++; > + } > + > + return -1; > + > +check_b_path_acs: > + bb = b; > + > + while (bb) { > + if (a == bb) > + break; > + > + if (pci_bridge_has_acs_redir(bb)) { > + seq_buf_print_bus_devfn(acs_list, bb); > + acs_cnt++; > + } > + > + bb = pci_upstream_bridge(bb); > + } > + > + if (acs_cnt) > + return -2; > + > + return dist_a + dist_b; > +} > + > +static int upstream_bridge_distance_warn(struct pci_dev *provider, > + struct pci_dev *client) > +{ > + struct seq_buf acs_list; > + int ret; > + > + seq_buf_init(&acs_list, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE); > + > + ret = upstream_bridge_distance(provider, client, &acs_list); > + if (ret == -2) { > + pci_warn(client, "cannot be used for peer-to-peer DMA as ACS redirect is set between the client and provider\n"); > + /* Drop final semicolon */ > + acs_list.buffer[acs_list.len-1] = 0; > + pci_warn(client, "to disable ACS redirect for this path, add the kernel parameter: pci=disable_acs_redir=%s\n", > + acs_list.buffer); > + > + } else if (ret < 0) { > + pci_warn(client, "cannot be used for peer-to-peer DMA as the client and provider do not share an upstream bridge\n"); > + } > + > + kfree(acs_list.buffer); > + > + return ret; > +} > + > +struct pci_p2pdma_client { > + struct list_head list; > + struct pci_dev *client; > + struct pci_dev *provider; > +}; > + > +/** > + * pci_p2pdma_add_client - allocate a new element in a client device list > + * @head: list head of p2pdma clients > + * @dev: device to add to the list > + * > + * This adds @dev to a list of clients used by a p2pdma device. > + * This list should be passed to pci_p2pmem_find(). Once pci_p2pmem_find() has > + * been called successfully, the list will be bound to a specific p2pdma > + * device and new clients can only be added to the list if they are > + * supported by that p2pdma device. > + * > + * The caller is expected to have a lock which protects @head as necessary > + * so that none of the pci_p2p functions can be called concurrently > + * on that list. > + * > + * Returns 0 if the client was successfully added. > + */ > +int pci_p2pdma_add_client(struct list_head *head, struct device *dev) > +{ > + struct pci_p2pdma_client *item, *new_item; > + struct pci_dev *provider = NULL; > + struct pci_dev *client; > + int ret; > + > + if (IS_ENABLED(CONFIG_DMA_VIRT_OPS) && dev->dma_ops == &dma_virt_ops) { > + dev_warn(dev, "cannot be used for peer-to-peer DMA because the driver makes use of dma_virt_ops\n"); > + return -ENODEV; > + } > + > + client = find_parent_pci_dev(dev); > + if (!client) { > + dev_warn(dev, "cannot be used for peer-to-peer DMA as it is not a PCI device\n"); > + return -ENODEV; > + } > + > + item = list_first_entry_or_null(head, struct pci_p2pdma_client, list); > + if (item && item->provider) { > + provider = item->provider; > + > + ret = upstream_bridge_distance_warn(provider, client); > + if (ret < 0) { > + ret = -EXDEV; > + goto put_client; > + } > + } > + > + new_item = kzalloc(sizeof(*new_item), GFP_KERNEL); > + if (!new_item) { > + ret = -ENOMEM; > + goto put_client; > + } > + > + new_item->client = client; > + new_item->provider = pci_dev_get(provider); > + > + list_add_tail(&new_item->list, head); > + > + return 0; > + > +put_client: > + pci_dev_put(client); > + return ret; > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_add_client); > + > +static void pci_p2pdma_client_free(struct pci_p2pdma_client *item) > +{ > + list_del(&item->list); > + pci_dev_put(item->client); > + pci_dev_put(item->provider); > + kfree(item); > +} > + > +/** > + * pci_p2pdma_remove_client - remove and free a p2pdma client > + * @head: list head of p2pdma clients > + * @dev: device to remove from the list > + * > + * This removes @dev from a list of clients used by a p2pdma device. > + * The caller is expected to have a lock which protects @head as necessary > + * so that none of the pci_p2p functions can be called concurrently > + * on that list. > + */ > +void pci_p2pdma_remove_client(struct list_head *head, struct device *dev) > +{ > + struct pci_p2pdma_client *pos, *tmp; > + struct pci_dev *pdev; > + > + pdev = find_parent_pci_dev(dev); > + if (!pdev) > + return; > + > + list_for_each_entry_safe(pos, tmp, head, list) { > + if (pos->client != pdev) > + continue; > + > + pci_p2pdma_client_free(pos); > + } > + > + pci_dev_put(pdev); > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_remove_client); > + > +/** > + * pci_p2pdma_client_list_free - free an entire list of p2pdma clients > + * @head: list head of p2pdma clients > + * > + * This removes all devices in a list of clients used by a p2pdma device. > + * The caller is expected to have a lock which protects @head as necessary > + * so that none of the pci_p2pdma functions can be called concurrently > + * on that list. > + */ > +void pci_p2pdma_client_list_free(struct list_head *head) > +{ > + struct pci_p2pdma_client *pos, *tmp; > + > + list_for_each_entry_safe(pos, tmp, head, list) > + pci_p2pdma_client_free(pos); > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_client_list_free); > + > +/** > + * pci_p2pdma_distance - Determive the cumulative distance between > + * a p2pdma provider and the clients in use. > + * @provider: p2pdma provider to check against the client list > + * @clients: list of devices to check (NULL-terminated) > + * @verbose: if true, print warnings for devices when we return -1 > + * > + * Returns -1 if any of the clients are not compatible (behind the same > + * root port as the provider), otherwise returns a positive number where > + * the lower number is the preferrable choice. (If there's one client > + * that's the same as the provider it will return 0, which is best choice). > + * > + * For now, "compatible" means the provider and the clients are all behind > + * the same PCI root port. This cuts out cases that may work but is safest > + * for the user. Future work can expand this to white-list root complexes that > + * can safely forward between each ports. > + */ > +int pci_p2pdma_distance(struct pci_dev *provider, struct list_head *clients, > + bool verbose) > +{ > + struct pci_p2pdma_client *pos; > + int ret; > + int distance = 0; > + bool not_supported = false; > + > + if (list_empty(clients)) > + return -1; > + > + list_for_each_entry(pos, clients, list) { > + if (verbose) > + ret = upstream_bridge_distance_warn(provider, > + pos->client); > + else > + ret = upstream_bridge_distance(provider, pos->client, > + NULL); > + > + if (ret < 0) > + not_supported = true; > + > + if (not_supported && !verbose) > + break; > + > + distance += ret; > + } > + > + if (not_supported) > + return -1; > + > + return distance; > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_distance); > + > +/** > + * pci_p2pdma_assign_provider - Check compatibily (as per pci_p2pdma_distance) > + * and assign a provider to a list of clients > + * @provider: p2pdma provider to assign to the client list > + * @clients: list of devices to check (NULL-terminated) > + * > + * Returns false if any of the clients are not compatible, true if the > + * provider was successfully assigned to the clients. > + */ > +bool pci_p2pdma_assign_provider(struct pci_dev *provider, > + struct list_head *clients) > +{ > + struct pci_p2pdma_client *pos; > + > + if (pci_p2pdma_distance(provider, clients, true) < 0) > + return false; > + > + list_for_each_entry(pos, clients, list) > + pos->provider = provider; > + > + return true; > +} > +EXPORT_SYMBOL_GPL(pci_p2pdma_assign_provider); > + > +/** > + * pci_has_p2pmem - check if a given PCI device has published any p2pmem > + * @pdev: PCI device to check > + */ > +bool pci_has_p2pmem(struct pci_dev *pdev) > +{ > + return pdev->p2pdma && pdev->p2pdma->p2pmem_published; > +} > +EXPORT_SYMBOL_GPL(pci_has_p2pmem); > + > +/** > + * pci_p2pmem_find - find a peer-to-peer DMA memory device compatible with > + * the specified list of clients and shortest distance (as determined > + * by pci_p2pmem_dma()) > + * @clients: list of devices to check (NULL-terminated) > + * > + * If multiple devices are behind the same switch, the one "closest" to the > + * client devices in use will be chosen first. (So if one of the providers are > + * the same as one of the clients, that provider will be used ahead of any > + * other providers that are unrelated). If multiple providers are an equal > + * distance away, one will be chosen at random. > + * > + * Returns a pointer to the PCI device with a reference taken (use pci_dev_put > + * to return the reference) or NULL if no compatible device is found. The > + * found provider will also be assigned to the client list. > + */ > +struct pci_dev *pci_p2pmem_find(struct list_head *clients) > +{ > + struct pci_dev *pdev = NULL; > + struct pci_p2pdma_client *pos; > + int distance; > + int closest_distance = INT_MAX; > + struct pci_dev **closest_pdevs; > + int dev_cnt = 0; > + const int max_devs = PAGE_SIZE / sizeof(*closest_pdevs); > + int i; > + > + closest_pdevs = kmalloc(PAGE_SIZE, GFP_KERNEL); > + > + while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev))) { > + if (!pci_has_p2pmem(pdev)) > + continue; > + > + distance = pci_p2pdma_distance(pdev, clients, false); > + if (distance < 0 || distance > closest_distance) > + continue; > + > + if (distance == closest_distance && dev_cnt >= max_devs) > + continue; > + > + if (distance < closest_distance) { > + for (i = 0; i < dev_cnt; i++) > + pci_dev_put(closest_pdevs[i]); > + > + dev_cnt = 0; > + closest_distance = distance; > + } > + > + closest_pdevs[dev_cnt++] = pci_dev_get(pdev); > + } > + > + if (dev_cnt) > + pdev = pci_dev_get(closest_pdevs[prandom_u32_max(dev_cnt)]); > + > + for (i = 0; i < dev_cnt; i++) > + pci_dev_put(closest_pdevs[i]); > + > + if (pdev) > + list_for_each_entry(pos, clients, list) > + pos->provider = pdev; > + > + kfree(closest_pdevs); > + return pdev; > +} > +EXPORT_SYMBOL_GPL(pci_p2pmem_find); > + > +/** > + * pci_alloc_p2p_mem - allocate peer-to-peer DMA memory > + * @pdev: the device to allocate memory from > + * @size: number of bytes to allocate > + * > + * Returns the allocated memory or NULL on error. > + */ > +void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size) > +{ > + void *ret; > + > + if (unlikely(!pdev->p2pdma)) > + return NULL; > + > + if (unlikely(!percpu_ref_tryget_live(&pdev->p2pdma->devmap_ref))) > + return NULL; > + > + ret = (void *)gen_pool_alloc(pdev->p2pdma->pool, size); > + > + if (unlikely(!ret)) > + percpu_ref_put(&pdev->p2pdma->devmap_ref); > + > + return ret; > +} > +EXPORT_SYMBOL_GPL(pci_alloc_p2pmem); > + > +/** > + * pci_free_p2pmem - allocate peer-to-peer DMA memory > + * @pdev: the device the memory was allocated from > + * @addr: address of the memory that was allocated > + * @size: number of bytes that was allocated > + */ > +void pci_free_p2pmem(struct pci_dev *pdev, void *addr, size_t size) > +{ > + gen_pool_free(pdev->p2pdma->pool, (uintptr_t)addr, size); > + percpu_ref_put(&pdev->p2pdma->devmap_ref); > +} > +EXPORT_SYMBOL_GPL(pci_free_p2pmem); > + > +/** > + * pci_virt_to_bus - return the PCI bus address for a given virtual > + * address obtained with pci_alloc_p2pmem() > + * @pdev: the device the memory was allocated from > + * @addr: address of the memory that was allocated > + */ > +pci_bus_addr_t pci_p2pmem_virt_to_bus(struct pci_dev *pdev, void *addr) > +{ > + if (!addr) > + return 0; > + if (!pdev->p2pdma) > + return 0; > + > + /* > + * Note: when we added the memory to the pool we used the PCI > + * bus address as the physical address. So gen_pool_virt_to_phys() > + * actually returns the bus address despite the misleading name. > + */ > + return gen_pool_virt_to_phys(pdev->p2pdma->pool, (unsigned long)addr); > +} > +EXPORT_SYMBOL_GPL(pci_p2pmem_virt_to_bus); > + > +/** > + * pci_p2pmem_alloc_sgl - allocate peer-to-peer DMA memory in a scatterlist > + * @pdev: the device to allocate memory from > + * @sgl: the allocated scatterlist > + * @nents: the number of SG entries in the list > + * @length: number of bytes to allocate > + * > + * Returns 0 on success > + */ > +struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev, > + unsigned int *nents, u32 length) > +{ > + struct scatterlist *sg; > + void *addr; > + > + sg = kzalloc(sizeof(*sg), GFP_KERNEL); > + if (!sg) > + return NULL; > + > + sg_init_table(sg, 1); > + > + addr = pci_alloc_p2pmem(pdev, length); > + if (!addr) > + goto out_free_sg; > + > + sg_set_buf(sg, addr, length); > + *nents = 1; > + return sg; > + > +out_free_sg: > + kfree(sg); > + return NULL; > +} > +EXPORT_SYMBOL_GPL(pci_p2pmem_alloc_sgl); > + > +/** > + * pci_p2pmem_free_sgl - free a scatterlist allocated by pci_p2pmem_alloc_sgl() > + * @pdev: the device to allocate memory from > + * @sgl: the allocated scatterlist > + * @nents: the number of SG entries in the list > + */ > +void pci_p2pmem_free_sgl(struct pci_dev *pdev, struct scatterlist *sgl) > +{ > + struct scatterlist *sg; > + int count; > + > + for_each_sg(sgl, sg, INT_MAX, count) { > + if (!sg) > + break; > + > + pci_free_p2pmem(pdev, sg_virt(sg), sg->length); > + } > + kfree(sgl); > +} > +EXPORT_SYMBOL_GPL(pci_p2pmem_free_sgl); > + > +/** > + * pci_p2pmem_publish - publish the peer-to-peer DMA memory for use by > + * other devices with pci_p2pmem_find() > + * @pdev: the device with peer-to-peer DMA memory to publish > + * @publish: set to true to publish the memory, false to unpublish it > + * > + * Published memory can be used by other PCI device drivers for > + * peer-2-peer DMA operations. Non-published memory is reserved for > + * exlusive use of the device driver that registers the peer-to-peer > + * memory. > + */ > +void pci_p2pmem_publish(struct pci_dev *pdev, bool publish) > +{ > + if (publish && !pdev->p2pdma) > + return; > + > + pdev->p2pdma->p2pmem_published = publish; > +} > +EXPORT_SYMBOL_GPL(pci_p2pmem_publish); > diff --git a/include/linux/memremap.h b/include/linux/memremap.h > index f91f9e763557..9553370ebdad 100644 > --- a/include/linux/memremap.h > +++ b/include/linux/memremap.h > @@ -53,11 +53,16 @@ struct vmem_altmap { > * wakeup event whenever a page is unpinned and becomes idle. This > * wakeup is used to coordinate physical address space management (ex: > * fs truncate/hole punch) vs pinned pages (ex: device dma). > + * > + * MEMORY_DEVICE_PCI_P2PDMA: > + * Device memory residing in a PCI BAR intended for use with Peer-to-Peer > + * transactions. > */ > enum memory_type { > MEMORY_DEVICE_PRIVATE = 1, > MEMORY_DEVICE_PUBLIC, > MEMORY_DEVICE_FS_DAX, > + MEMORY_DEVICE_PCI_P2PDMA, > }; > > /* > diff --git a/include/linux/mm.h b/include/linux/mm.h > index a61ebe8ad4ca..2055df412a77 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -890,6 +890,19 @@ static inline bool is_device_public_page(const struct page *page) > page->pgmap->type == MEMORY_DEVICE_PUBLIC; > } > > +#ifdef CONFIG_PCI_P2PDMA > +static inline bool is_pci_p2pdma_page(const struct page *page) > +{ > + return is_zone_device_page(page) && > + page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA; > +} > +#else /* CONFIG_PCI_P2PDMA */ > +static inline bool is_pci_p2pdma_page(const struct page *page) > +{ > + return false; > +} > +#endif /* CONFIG_PCI_P2PDMA */ > + > #else /* CONFIG_DEV_PAGEMAP_OPS */ > static inline void dev_pagemap_get_ops(void) > { > @@ -913,6 +926,11 @@ static inline bool is_device_public_page(const struct page *page) > { > return false; > } > + > +static inline bool is_pci_p2pdma_page(const struct page *page) > +{ > + return false; > +} > #endif /* CONFIG_DEV_PAGEMAP_OPS */ > > static inline void get_page(struct page *page) > diff --git a/include/linux/pci-p2pdma.h b/include/linux/pci-p2pdma.h > new file mode 100644 > index 000000000000..7b2b0f547528 > --- /dev/null > +++ b/include/linux/pci-p2pdma.h > @@ -0,0 +1,102 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * PCI Peer 2 Peer DMA support. > + * > + * Copyright (c) 2016-2018, Logan Gunthorpe > + * Copyright (c) 2016-2017, Microsemi Corporation > + * Copyright (c) 2017, Christoph Hellwig > + * Copyright (c) 2018, Eideticom Inc. > + * > + */ > + > +#ifndef _LINUX_PCI_P2PDMA_H > +#define _LINUX_PCI_P2PDMA_H > + > +#include <linux/pci.h> > + > +struct block_device; > +struct scatterlist; > + > +#ifdef CONFIG_PCI_P2PDMA > +int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, > + u64 offset); > +int pci_p2pdma_add_client(struct list_head *head, struct device *dev); > +void pci_p2pdma_remove_client(struct list_head *head, struct device *dev); > +void pci_p2pdma_client_list_free(struct list_head *head); > +int pci_p2pdma_distance(struct pci_dev *provider, struct list_head *clients, > + bool verbose); > +bool pci_p2pdma_assign_provider(struct pci_dev *provider, > + struct list_head *clients); > +bool pci_has_p2pmem(struct pci_dev *pdev); > +struct pci_dev *pci_p2pmem_find(struct list_head *clients); > +void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size); > +void pci_free_p2pmem(struct pci_dev *pdev, void *addr, size_t size); > +pci_bus_addr_t pci_p2pmem_virt_to_bus(struct pci_dev *pdev, void *addr); > +struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev, > + unsigned int *nents, u32 length); > +void pci_p2pmem_free_sgl(struct pci_dev *pdev, struct scatterlist *sgl); > +void pci_p2pmem_publish(struct pci_dev *pdev, bool publish); > +#else /* CONFIG_PCI_P2PDMA */ > +static inline int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, > + size_t size, u64 offset) > +{ > + return -EOPNOTSUPP; > +} > +static inline int pci_p2pdma_add_client(struct list_head *head, > + struct device *dev) > +{ > + return 0; > +} > +static inline void pci_p2pdma_remove_client(struct list_head *head, > + struct device *dev) > +{ > +} > +static inline void pci_p2pdma_client_list_free(struct list_head *head) > +{ > +} > +static inline int pci_p2pdma_distance(struct pci_dev *provider, > + struct list_head *clients, > + bool verbose) > +{ > + return -1; > +} > +static inline bool pci_p2pdma_assign_provider(struct pci_dev *provider, > + struct list_head *clients) > +{ > + return false; > +} > +static inline bool pci_has_p2pmem(struct pci_dev *pdev) > +{ > + return false; > +} > +static inline struct pci_dev *pci_p2pmem_find(struct list_head *clients) > +{ > + return NULL; > +} > +static inline void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size) > +{ > + return NULL; > +} > +static inline void pci_free_p2pmem(struct pci_dev *pdev, void *addr, > + size_t size) > +{ > +} > +static inline pci_bus_addr_t pci_p2pmem_virt_to_bus(struct pci_dev *pdev, > + void *addr) > +{ > + return 0; > +} > +static inline struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev, > + unsigned int *nents, u32 length) > +{ > + return NULL; > +} > +static inline void pci_p2pmem_free_sgl(struct pci_dev *pdev, > + struct scatterlist *sgl) > +{ > +} > +static inline void pci_p2pmem_publish(struct pci_dev *pdev, bool publish) > +{ > +} > +#endif /* CONFIG_PCI_P2PDMA */ > +#endif /* _LINUX_PCI_P2P_H */ > diff --git a/include/linux/pci.h b/include/linux/pci.h > index e72ca8dd6241..5d95dbf21f4a 100644 > --- a/include/linux/pci.h > +++ b/include/linux/pci.h > @@ -281,6 +281,7 @@ struct pcie_link_state; > struct pci_vpd; > struct pci_sriov; > struct pci_ats; > +struct pci_p2pdma; > > /* The pci_dev structure describes PCI devices */ > struct pci_dev { > @@ -439,6 +440,9 @@ struct pci_dev { > #ifdef CONFIG_PCI_PASID > u16 pasid_features; > #endif > +#ifdef CONFIG_PCI_P2PDMA > + struct pci_p2pdma *p2pdma; > +#endif > phys_addr_t rom; /* Physical address if not from BAR */ > size_t romlen; /* Length if not from BAR */ > char *driver_override; /* Driver name to force a match */
Powered by blists - more mailing lists