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(bus: 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(lock: &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(size: 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(new: &dev_entry->list, head: &dev_data->dev_list); |
61 | mutex_unlock(lock: &dev_data->lock); |
62 | |
63 | /* Publish this device. */ |
64 | domain = (unsigned int)pci_domain_nr(bus: 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(entry: &dev_entry->list); |
84 | found_dev = dev_entry->dev; |
85 | kfree(objp: dev_entry); |
86 | } |
87 | } |
88 | |
89 | mutex_unlock(lock: &dev_data->lock); |
90 | |
91 | if (found_dev) { |
92 | if (lock) |
93 | device_lock(dev: &found_dev->dev); |
94 | pcistub_put_pci_dev(dev: found_dev); |
95 | if (lock) |
96 | device_unlock(dev: &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(size: sizeof(*dev_data), GFP_KERNEL); |
105 | if (!dev_data) |
106 | return -ENOMEM; |
107 | |
108 | mutex_init(&dev_data->lock); |
109 | |
110 | INIT_LIST_HEAD(list: &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(bus: 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(lock: &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(entry: &dev_entry->list); |
167 | device_lock(dev: &dev->dev); |
168 | pcistub_put_pci_dev(dev); |
169 | device_unlock(dev: &dev->dev); |
170 | kfree(objp: dev_entry); |
171 | } |
172 | |
173 | kfree(objp: 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(bus: 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 | |