1// SPDX-License-Identifier: GPL-2.0
2/*
3 * PCI Backend - Provides a Virtual PCI bus (with real devices)
4 *               to the frontend
5 *
6 *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
7 */
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10#define dev_fmt pr_fmt
11
12#include <linux/list.h>
13#include <linux/slab.h>
14#include <linux/pci.h>
15#include <linux/mutex.h>
16#include "pciback.h"
17
18#define PCI_SLOT_MAX 32
19
20struct vpci_dev_data {
21	/* Access to dev_list must be protected by lock */
22	struct list_head dev_list[PCI_SLOT_MAX];
23	struct mutex lock;
24};
25
26static inline struct list_head *list_first(struct list_head *head)
27{
28	return head->next;
29}
30
31static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
32					       unsigned int domain,
33					       unsigned int bus,
34					       unsigned int devfn)
35{
36	struct pci_dev_entry *entry;
37	struct pci_dev *dev = NULL;
38	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
39
40	if (domain != 0 || bus != 0)
41		return NULL;
42
43	if (PCI_SLOT(devfn) < PCI_SLOT_MAX) {
44		mutex_lock(&vpci_dev->lock);
45
46		list_for_each_entry(entry,
47				    &vpci_dev->dev_list[PCI_SLOT(devfn)],
48				    list) {
49			if (PCI_FUNC(entry->dev->devfn) == PCI_FUNC(devfn)) {
50				dev = entry->dev;
51				break;
52			}
53		}
54
55		mutex_unlock(&vpci_dev->lock);
56	}
57	return dev;
58}
59
60static inline int match_slot(struct pci_dev *l, struct pci_dev *r)
61{
62	if (pci_domain_nr(l->bus) == pci_domain_nr(r->bus)
63	    && l->bus == r->bus && PCI_SLOT(l->devfn) == PCI_SLOT(r->devfn))
64		return 1;
65
66	return 0;
67}
68
69static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
70				   struct pci_dev *dev, int devid,
71				   publish_pci_dev_cb publish_cb)
72{
73	int err = 0, slot, func = PCI_FUNC(dev->devfn);
74	struct pci_dev_entry *t, *dev_entry;
75	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
76
77	if ((dev->class >> 24) == PCI_BASE_CLASS_BRIDGE) {
78		err = -EFAULT;
79		xenbus_dev_fatal(pdev->xdev, err,
80				 "Can't export bridges on the virtual PCI bus");
81		goto out;
82	}
83
84	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
85	if (!dev_entry) {
86		err = -ENOMEM;
87		xenbus_dev_fatal(pdev->xdev, err,
88				 "Error adding entry to virtual PCI bus");
89		goto out;
90	}
91
92	dev_entry->dev = dev;
93
94	mutex_lock(&vpci_dev->lock);
95
96	/*
97	 * Keep multi-function devices together on the virtual PCI bus, except
98	 * that we want to keep virtual functions at func 0 on their own. They
99	 * aren't multi-function devices and hence their presence at func 0
100	 * may cause guests to not scan the other functions.
101	 */
102	if (!dev->is_virtfn || func) {
103		for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
104			if (list_empty(&vpci_dev->dev_list[slot]))
105				continue;
106
107			t = list_entry(list_first(&vpci_dev->dev_list[slot]),
108				       struct pci_dev_entry, list);
109			if (t->dev->is_virtfn && !PCI_FUNC(t->dev->devfn))
110				continue;
111
112			if (match_slot(dev, t->dev)) {
113				dev_info(&dev->dev, "vpci: assign to virtual slot %d func %d\n",
114					 slot, func);
115				list_add_tail(&dev_entry->list,
116					      &vpci_dev->dev_list[slot]);
117				goto unlock;
118			}
119		}
120	}
121
122	/* Assign to a new slot on the virtual PCI bus */
123	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
124		if (list_empty(&vpci_dev->dev_list[slot])) {
125			dev_info(&dev->dev, "vpci: assign to virtual slot %d\n",
126				 slot);
127			list_add_tail(&dev_entry->list,
128				      &vpci_dev->dev_list[slot]);
129			goto unlock;
130		}
131	}
132
133	err = -ENOMEM;
134	xenbus_dev_fatal(pdev->xdev, err,
135			 "No more space on root virtual PCI bus");
136
137unlock:
138	mutex_unlock(&vpci_dev->lock);
139
140	/* Publish this device. */
141	if (!err)
142		err = publish_cb(pdev, 0, 0, PCI_DEVFN(slot, func), devid);
143	else
144		kfree(dev_entry);
145
146out:
147	return err;
148}
149
150static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
151					struct pci_dev *dev, bool lock)
152{
153	int slot;
154	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
155	struct pci_dev *found_dev = NULL;
156
157	mutex_lock(&vpci_dev->lock);
158
159	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
160		struct pci_dev_entry *e;
161
162		list_for_each_entry(e, &vpci_dev->dev_list[slot], list) {
163			if (e->dev == dev) {
164				list_del(&e->list);
165				found_dev = e->dev;
166				kfree(e);
167				goto out;
168			}
169		}
170	}
171
172out:
173	mutex_unlock(&vpci_dev->lock);
174
175	if (found_dev) {
176		if (lock)
177			device_lock(&found_dev->dev);
178		pcistub_put_pci_dev(found_dev);
179		if (lock)
180			device_unlock(&found_dev->dev);
181	}
182}
183
184static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
185{
186	int slot;
187	struct vpci_dev_data *vpci_dev;
188
189	vpci_dev = kmalloc(sizeof(*vpci_dev), GFP_KERNEL);
190	if (!vpci_dev)
191		return -ENOMEM;
192
193	mutex_init(&vpci_dev->lock);
194
195	for (slot = 0; slot < PCI_SLOT_MAX; slot++)
196		INIT_LIST_HEAD(&vpci_dev->dev_list[slot]);
197
198	pdev->pci_dev_data = vpci_dev;
199
200	return 0;
201}
202
203static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
204					 publish_pci_root_cb publish_cb)
205{
206	/* The Virtual PCI bus has only one root */
207	return publish_cb(pdev, 0, 0);
208}
209
210static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
211{
212	int slot;
213	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
214
215	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
216		struct pci_dev_entry *e, *tmp;
217		list_for_each_entry_safe(e, tmp, &vpci_dev->dev_list[slot],
218					 list) {
219			struct pci_dev *dev = e->dev;
220			list_del(&e->list);
221			device_lock(&dev->dev);
222			pcistub_put_pci_dev(dev);
223			device_unlock(&dev->dev);
224			kfree(e);
225		}
226	}
227
228	kfree(vpci_dev);
229	pdev->pci_dev_data = NULL;
230}
231
232static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
233					struct xen_pcibk_device *pdev,
234					unsigned int *domain, unsigned int *bus,
235					unsigned int *devfn)
236{
237	struct pci_dev_entry *entry;
238	struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
239	int found = 0, slot;
240
241	mutex_lock(&vpci_dev->lock);
242	for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
243		list_for_each_entry(entry,
244			    &vpci_dev->dev_list[slot],
245			    list) {
246			if (entry->dev == pcidev) {
247				found = 1;
248				*domain = 0;
249				*bus = 0;
250				*devfn = PCI_DEVFN(slot,
251					 PCI_FUNC(pcidev->devfn));
252			}
253		}
254	}
255	mutex_unlock(&vpci_dev->lock);
256	return found;
257}
258
259const struct xen_pcibk_backend xen_pcibk_vpci_backend = {
260	.name		= "vpci",
261	.init		= __xen_pcibk_init_devices,
262	.free		= __xen_pcibk_release_devices,
263	.find		= __xen_pcibk_get_pcifront_dev,
264	.publish	= __xen_pcibk_publish_pci_roots,
265	.release	= __xen_pcibk_release_pci_dev,
266	.add		= __xen_pcibk_add_pci_dev,
267	.get		= __xen_pcibk_get_pci_dev,
268};
269