1 // SPDX-License-Identifier: GPL-2.0
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>
11 #include <linux/mutex.h>
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;
17 	struct mutex lock;
18 };
19 
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)
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;
28 
29 	mutex_lock(&dev_data->lock);
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 
40 	mutex_unlock(&dev_data->lock);
41 
42 	return dev;
43 }
44 
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)
48 {
49 	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
50 	struct pci_dev_entry *dev_entry;
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 
59 	mutex_lock(&dev_data->lock);
60 	list_add_tail(&dev_entry->list, &dev_data->dev_list);
61 	mutex_unlock(&dev_data->lock);
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 
72 static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
73 					struct pci_dev *dev, bool lock)
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;
78 
79 	mutex_lock(&dev_data->lock);
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 
89 	mutex_unlock(&dev_data->lock);
90 
91 	if (found_dev) {
92 		if (lock)
93 			device_lock(&found_dev->dev);
94 		pcistub_put_pci_dev(found_dev);
95 		if (lock)
96 			device_unlock(&found_dev->dev);
97 	}
98 }
99 
100 static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
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 
108 	mutex_init(&dev_data->lock);
109 
110 	INIT_LIST_HEAD(&dev_data->dev_list);
111 
112 	pdev->pci_dev_data = dev_data;
113 
114 	return 0;
115 }
116 
117 static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
118 					 publish_pci_root_cb publish_root_cb)
119 {
120 	int err = 0;
121 	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
122 	struct pci_dev_entry *dev_entry, *e;
123 	struct pci_dev *dev;
124 	int found;
125 	unsigned int domain, bus;
126 
127 	mutex_lock(&dev_data->lock);
128 
129 	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
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 
154 	mutex_unlock(&dev_data->lock);
155 
156 	return err;
157 }
158 
159 static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
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) {
165 		struct pci_dev *dev = dev_entry->dev;
166 		list_del(&dev_entry->list);
167 		device_lock(&dev->dev);
168 		pcistub_put_pci_dev(dev);
169 		device_unlock(&dev->dev);
170 		kfree(dev_entry);
171 	}
172 
173 	kfree(dev_data);
174 	pdev->pci_dev_data = NULL;
175 }
176 
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)
181 {
182 	*domain = pci_domain_nr(pcidev->bus);
183 	*bus = pcidev->bus->number;
184 	*devfn = pcidev->devfn;
185 	return 1;
186 }
187 
188 const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
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 };
198