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