[linux-2.6-block.git] / drivers / xen / xen-pciback / passthrough.c

// SPDX-License-Identifier: GPL-2.0
/*
 * PCI Backend - Provides restricted access to the real PCI bus topology
 *               to the frontend
 *
 *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
 */

#include <linux/list.h>
#include <linux/pci.h>
#include <linux/mutex.h>
#include "pciback.h"

struct passthrough_dev_data {
	/* Access to dev_list must be protected by lock */
	struct list_head dev_list;
	struct mutex lock;
};

static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
					       unsigned int domain,
					       unsigned int bus,
					       unsigned int devfn)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry;
	struct pci_dev *dev = NULL;

	mutex_lock(&dev_data->lock);

	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
		if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
		    && bus == (unsigned int)dev_entry->dev->bus->number
		    && devfn == dev_entry->dev->devfn) {
			dev = dev_entry->dev;
			break;
		}
	}

	mutex_unlock(&dev_data->lock);

	return dev;
}

static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
				   struct pci_dev *dev,
				   int devid, publish_pci_dev_cb publish_cb)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry;
	unsigned int domain, bus, devfn;
	int err;

	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
	if (!dev_entry)
		return -ENOMEM;
	dev_entry->dev = dev;

	mutex_lock(&dev_data->lock);
	list_add_tail(&dev_entry->list, &dev_data->dev_list);
	mutex_unlock(&dev_data->lock);

	/* Publish this device. */
	domain = (unsigned int)pci_domain_nr(dev->bus);
	bus = (unsigned int)dev->bus->number;
	devfn = dev->devfn;
	err = publish_cb(pdev, domain, bus, devfn, devid);

	return err;
}

static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
					struct pci_dev *dev, bool lock)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *t;
	struct pci_dev *found_dev = NULL;

	mutex_lock(&dev_data->lock);

	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
		if (dev_entry->dev == dev) {
			list_del(&dev_entry->list);
			found_dev = dev_entry->dev;
			kfree(dev_entry);
		}
	}

	mutex_unlock(&dev_data->lock);

	if (found_dev) {
		if (lock)
			device_lock(&found_dev->dev);
		pcistub_put_pci_dev(found_dev);
		if (lock)
			device_unlock(&found_dev->dev);
	}
}

static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
{
	struct passthrough_dev_data *dev_data;

	dev_data = kmalloc(sizeof(*dev_data), GFP_KERNEL);
	if (!dev_data)
		return -ENOMEM;

	mutex_init(&dev_data->lock);

	INIT_LIST_HEAD(&dev_data->dev_list);

	pdev->pci_dev_data = dev_data;

	return 0;
}

static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
					 publish_pci_root_cb publish_root_cb)
{
	int err = 0;
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *e;
	struct pci_dev *dev;
	int found;
	unsigned int domain, bus;

	mutex_lock(&dev_data->lock);

	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
		/* Only publish this device as a root if none of its
		 * parent bridges are exported
		 */
		found = 0;
		dev = dev_entry->dev->bus->self;
		for (; !found && dev != NULL; dev = dev->bus->self) {
			list_for_each_entry(e, &dev_data->dev_list, list) {
				if (dev == e->dev) {
					found = 1;
					break;
				}
			}
		}

		domain = (unsigned int)pci_domain_nr(dev_entry->dev->bus);
		bus = (unsigned int)dev_entry->dev->bus->number;

		if (!found) {
			err = publish_root_cb(pdev, domain, bus);
			if (err)
				break;
		}
	}

	mutex_unlock(&dev_data->lock);

	return err;
}

static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *t;

	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
		struct pci_dev *dev = dev_entry->dev;
		list_del(&dev_entry->list);
		device_lock(&dev->dev);
		pcistub_put_pci_dev(dev);
		device_unlock(&dev->dev);
		kfree(dev_entry);
	}

	kfree(dev_data);
	pdev->pci_dev_data = NULL;
}

static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
					struct xen_pcibk_device *pdev,
					unsigned int *domain, unsigned int *bus,
					unsigned int *devfn)
{
	*domain = pci_domain_nr(pcidev->bus);
	*bus = pcidev->bus->number;
	*devfn = pcidev->devfn;
	return 1;
}

const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
	.name           = "passthrough",
	.init           = __xen_pcibk_init_devices,
	.free		= __xen_pcibk_release_devices,
	.find           = __xen_pcibk_get_pcifront_dev,
	.publish        = __xen_pcibk_publish_pci_roots,
	.release        = __xen_pcibk_release_pci_dev,
	.add            = __xen_pcibk_add_pci_dev,
	.get            = __xen_pcibk_get_pci_dev,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
30edc14b KRW	2	/*
	3	* PCI Backend - Provides restricted access to the real PCI bus topology
	4	* to the frontend
	5	*
	6	* Author: Ryan Wilson <hap9@epoch.ncsc.mil>
	7	*/
	8
	9	#include <linux/list.h>
	10	#include <linux/pci.h>
04df3552	11	#include <linux/mutex.h>
30edc14b KRW	12	#include "pciback.h"
	13
	14	struct passthrough_dev_data {
	15	/* Access to dev_list must be protected by lock */
	16	struct list_head dev_list;
04df3552	17	struct mutex lock;
30edc14b KRW	18	};
30edc14b KRW	19
2ebdc426 KRW	20	static struct pci_dev __xen_pcibk_get_pci_dev(struct xen_pcibk_device pdev,
	21	unsigned int domain,
	22	unsigned int bus,
	23	unsigned int devfn)
30edc14b KRW	24	{
	25	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	26	struct pci_dev_entry *dev_entry;
	27	struct pci_dev *dev = NULL;
30edc14b	28
04df3552	29	mutex_lock(&dev_data->lock);
30edc14b KRW	30
	31	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
	32	if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
	33	&& bus == (unsigned int)dev_entry->dev->bus->number
	34	&& devfn == dev_entry->dev->devfn) {
	35	dev = dev_entry->dev;
	36	break;
	37	}
	38	}
	39
04df3552	40	mutex_unlock(&dev_data->lock);
30edc14b KRW	41
	42	return dev;
	43	}
	44
2ebdc426 KRW	45	static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
	46	struct pci_dev *dev,
	47	int devid, publish_pci_dev_cb publish_cb)
30edc14b KRW	48	{
	49	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	50	struct pci_dev_entry *dev_entry;
30edc14b KRW	51	unsigned int domain, bus, devfn;
	52	int err;
	53
	54	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
	55	if (!dev_entry)
	56	return -ENOMEM;
	57	dev_entry->dev = dev;
	58
04df3552	59	mutex_lock(&dev_data->lock);
30edc14b	60	list_add_tail(&dev_entry->list, &dev_data->dev_list);
04df3552	61	mutex_unlock(&dev_data->lock);
30edc14b KRW	62
	63	/* Publish this device. */
	64	domain = (unsigned int)pci_domain_nr(dev->bus);
	65	bus = (unsigned int)dev->bus->number;
	66	devfn = dev->devfn;
	67	err = publish_cb(pdev, domain, bus, devfn, devid);
	68
	69	return err;
	70	}
	71
2ebdc426	72	static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
e8801a74	73	struct pci_dev *dev, bool lock)
30edc14b KRW	74	{
	75	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	76	struct pci_dev_entry dev_entry, t;
	77	struct pci_dev *found_dev = NULL;
30edc14b	78
04df3552	79	mutex_lock(&dev_data->lock);
30edc14b KRW	80
	81	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
	82	if (dev_entry->dev == dev) {
	83	list_del(&dev_entry->list);
	84	found_dev = dev_entry->dev;
	85	kfree(dev_entry);
	86	}
	87	}
	88
04df3552	89	mutex_unlock(&dev_data->lock);
30edc14b	90
e8801a74 KRW	91	if (found_dev) {
	92	if (lock)
	93	device_lock(&found_dev->dev);
30edc14b	94	pcistub_put_pci_dev(found_dev);
e8801a74 KRW	95	if (lock)
	96	device_unlock(&found_dev->dev);
	97	}
30edc14b KRW	98	}
30edc14b KRW	99
2ebdc426	100	static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
30edc14b KRW	101	{
	102	struct passthrough_dev_data *dev_data;
	103
	104	dev_data = kmalloc(sizeof(*dev_data), GFP_KERNEL);
	105	if (!dev_data)
	106	return -ENOMEM;
	107
04df3552	108	mutex_init(&dev_data->lock);
30edc14b KRW	109
	110	INIT_LIST_HEAD(&dev_data->dev_list);
	111
	112	pdev->pci_dev_data = dev_data;
	113
	114	return 0;
	115	}
	116
2ebdc426 KRW	117	static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
2ebdc426 KRW	118	publish_pci_root_cb publish_root_cb)
30edc14b KRW	119	{
	120	int err = 0;
	121	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
04df3552	122	struct pci_dev_entry dev_entry, e;
30edc14b KRW	123	struct pci_dev *dev;
	124	int found;
	125	unsigned int domain, bus;
	126
04df3552	127	mutex_lock(&dev_data->lock);
30edc14b	128
04df3552	129	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
30edc14b KRW	130	/* Only publish this device as a root if none of its
	131	* parent bridges are exported
	132	*/
	133	found = 0;
	134	dev = dev_entry->dev->bus->self;
	135	for (; !found && dev != NULL; dev = dev->bus->self) {
	136	list_for_each_entry(e, &dev_data->dev_list, list) {
	137	if (dev == e->dev) {
	138	found = 1;
	139	break;
	140	}
	141	}
	142	}
	143
	144	domain = (unsigned int)pci_domain_nr(dev_entry->dev->bus);
	145	bus = (unsigned int)dev_entry->dev->bus->number;
	146
	147	if (!found) {
	148	err = publish_root_cb(pdev, domain, bus);
	149	if (err)
	150	break;
	151	}
	152	}
	153
04df3552	154	mutex_unlock(&dev_data->lock);
30edc14b KRW	155
	156	return err;
	157	}
	158
2ebdc426	159	static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
30edc14b KRW	160	{
	161	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	162	struct pci_dev_entry dev_entry, t;
	163
	164	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
e8801a74	165	struct pci_dev *dev = dev_entry->dev;
30edc14b	166	list_del(&dev_entry->list);
e8801a74 KRW	167	device_lock(&dev->dev);
	168	pcistub_put_pci_dev(dev);
	169	device_unlock(&dev->dev);
30edc14b KRW	170	kfree(dev_entry);
	171	}
	172
	173	kfree(dev_data);
	174	pdev->pci_dev_data = NULL;
	175	}
	176
2ebdc426 KRW	177	static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
	178	struct xen_pcibk_device *pdev,
	179	unsigned int domain, unsigned int bus,
	180	unsigned int *devfn)
30edc14b KRW	181	{
	182	*domain = pci_domain_nr(pcidev->bus);
	183	*bus = pcidev->bus->number;
	184	*devfn = pcidev->devfn;
	185	return 1;
	186	}
2ebdc426	187
402c5e15	188	const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
2ebdc426 KRW	189	.name = "passthrough",
	190	.init = __xen_pcibk_init_devices,
	191	.free = __xen_pcibk_release_devices,
	192	.find = __xen_pcibk_get_pcifront_dev,
	193	.publish = __xen_pcibk_publish_pci_roots,
	194	.release = __xen_pcibk_release_pci_dev,
	195	.add = __xen_pcibk_add_pci_dev,
	196	.get = __xen_pcibk_get_pci_dev,
	197	};