Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2021 NVIDIA Corporation & Affiliates
3 : : */
4 : :
5 : : #include <string.h>
6 : : #include <inttypes.h>
7 : : #include <stdint.h>
8 : : #include <stdbool.h>
9 : : #include <stdlib.h>
10 : : #include <stdio.h>
11 : : #include <sys/queue.h>
12 : : #include <rte_errno.h>
13 : : #include <rte_interrupts.h>
14 : : #include <rte_log.h>
15 : : #include <bus_driver.h>
16 : : #include <rte_per_lcore.h>
17 : : #include <rte_memory.h>
18 : : #include <rte_eal.h>
19 : : #include <rte_eal_paging.h>
20 : : #include <rte_lcore.h>
21 : : #include <rte_string_fns.h>
22 : : #include <rte_common.h>
23 : : #include <rte_devargs.h>
24 : :
25 : : #include "private.h"
26 : :
27 : : static struct rte_devargs *
28 : 0 : auxiliary_devargs_lookup(const char *name)
29 : : {
30 : : struct rte_devargs *devargs;
31 : :
32 [ # # ]: 0 : RTE_EAL_DEVARGS_FOREACH(RTE_BUS_AUXILIARY_NAME, devargs) {
33 [ # # ]: 0 : if (strcmp(devargs->name, name) == 0)
34 : 0 : return devargs;
35 : : }
36 : : return NULL;
37 : : }
38 : :
39 : : #ifndef AUXILIARY_OS_SUPPORTED
40 : : /*
41 : : * Test whether the auxiliary device exist.
42 : : *
43 : : * Stub for OS not supporting auxiliary bus.
44 : : */
45 : : bool
46 : : auxiliary_dev_exists(const char *name)
47 : : {
48 : : RTE_SET_USED(name);
49 : : return false;
50 : : }
51 : :
52 : : /*
53 : : * Scan the devices in the auxiliary bus.
54 : : *
55 : : * Stub for OS not supporting auxiliary bus.
56 : : */
57 : : int
58 : : auxiliary_scan(void)
59 : : {
60 : : return 0;
61 : : }
62 : : #endif /* AUXILIARY_OS_SUPPORTED */
63 : :
64 : : /*
65 : : * Update a device's devargs being scanned.
66 : : */
67 : : void
68 : 0 : auxiliary_on_scan(struct rte_auxiliary_device *aux_dev)
69 : : {
70 : 0 : aux_dev->device.devargs = auxiliary_devargs_lookup(aux_dev->name);
71 : 0 : }
72 : :
73 : : /*
74 : : * Match the auxiliary driver and device using driver function.
75 : : */
76 : : bool
77 : 0 : auxiliary_match(const struct rte_auxiliary_driver *aux_drv,
78 : : const struct rte_auxiliary_device *aux_dev)
79 : : {
80 [ # # ]: 0 : if (aux_drv->match == NULL)
81 : : return false;
82 : 0 : return aux_drv->match(aux_dev->name);
83 : : }
84 : :
85 : : /*
86 : : * Call the probe() function of the driver.
87 : : */
88 : : static int
89 : 0 : rte_auxiliary_probe_one_driver(struct rte_auxiliary_driver *drv,
90 : : struct rte_auxiliary_device *dev)
91 : : {
92 : : enum rte_iova_mode iova_mode;
93 : : int ret;
94 : :
95 [ # # ]: 0 : if (drv == NULL || dev == NULL)
96 : : return -EINVAL;
97 : :
98 : : /* Check if driver supports it. */
99 [ # # ]: 0 : if (!auxiliary_match(drv, dev))
100 : : /* Match of device and driver failed */
101 : : return 1;
102 : :
103 : : /* No initialization when marked as blocked, return without error. */
104 [ # # ]: 0 : if (dev->device.devargs != NULL &&
105 [ # # ]: 0 : dev->device.devargs->policy == RTE_DEV_BLOCKED) {
106 : 0 : AUXILIARY_LOG(INFO, "Device is blocked, not initializing");
107 : 0 : return -1;
108 : : }
109 : :
110 [ # # # # ]: 0 : if (dev->device.numa_node < 0 && rte_socket_count() > 1)
111 : 0 : AUXILIARY_LOG(INFO, "Device %s is not NUMA-aware", dev->name);
112 : :
113 [ # # ]: 0 : if (rte_dev_is_probed(&dev->device)) {
114 : 0 : AUXILIARY_LOG(DEBUG, "Device %s is already probed on auxiliary bus",
115 : : dev->device.name);
116 : 0 : return -EEXIST;
117 : : }
118 : :
119 : 0 : iova_mode = rte_eal_iova_mode();
120 [ # # # # ]: 0 : if ((drv->drv_flags & RTE_AUXILIARY_DRV_NEED_IOVA_AS_VA) > 0 &&
121 : : iova_mode != RTE_IOVA_VA) {
122 : 0 : AUXILIARY_LOG(ERR, "Driver %s expecting VA IOVA mode but current mode is PA, not initializing",
123 : : drv->driver.name);
124 : 0 : return -EINVAL;
125 : : }
126 : :
127 : : /* Allocate interrupt instance */
128 : 0 : dev->intr_handle =
129 : 0 : rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_PRIVATE);
130 [ # # ]: 0 : if (dev->intr_handle == NULL) {
131 : 0 : AUXILIARY_LOG(ERR, "Could not allocate interrupt instance for device %s",
132 : : dev->name);
133 : 0 : return -ENOMEM;
134 : : }
135 : :
136 : 0 : dev->driver = drv;
137 : :
138 : 0 : AUXILIARY_LOG(INFO, "Probe auxiliary driver: %s device: %s (NUMA node %i)",
139 : : drv->driver.name, dev->name, dev->device.numa_node);
140 : 0 : ret = drv->probe(drv, dev);
141 [ # # ]: 0 : if (ret != 0) {
142 : 0 : dev->driver = NULL;
143 : 0 : rte_intr_instance_free(dev->intr_handle);
144 : 0 : dev->intr_handle = NULL;
145 : : } else {
146 : 0 : dev->device.driver = &drv->driver;
147 : : }
148 : :
149 : : return ret;
150 : : }
151 : :
152 : : /*
153 : : * Call the remove() function of the driver.
154 : : */
155 : : static int
156 : 0 : rte_auxiliary_driver_remove_dev(struct rte_auxiliary_device *dev)
157 : : {
158 : : struct rte_auxiliary_driver *drv;
159 : : int ret = 0;
160 : :
161 [ # # ]: 0 : if (dev == NULL)
162 : : return -EINVAL;
163 : :
164 : 0 : drv = dev->driver;
165 : :
166 : 0 : AUXILIARY_LOG(DEBUG, "Driver %s remove auxiliary device %s on NUMA node %i",
167 : : drv->driver.name, dev->name, dev->device.numa_node);
168 : :
169 [ # # ]: 0 : if (drv->remove != NULL) {
170 : 0 : ret = drv->remove(dev);
171 [ # # ]: 0 : if (ret < 0)
172 : : return ret;
173 : : }
174 : :
175 : : /* clear driver structure */
176 : 0 : dev->driver = NULL;
177 : 0 : dev->device.driver = NULL;
178 : :
179 : 0 : return 0;
180 : : }
181 : :
182 : : /*
183 : : * Call the probe() function of all registered drivers for the given device.
184 : : * Return < 0 if initialization failed.
185 : : * Return 1 if no driver is found for this device.
186 : : */
187 : : static int
188 : 0 : auxiliary_probe_all_drivers(struct rte_auxiliary_device *dev)
189 : : {
190 : : struct rte_auxiliary_driver *drv;
191 : : int rc;
192 : :
193 [ # # ]: 0 : if (dev == NULL)
194 : : return -EINVAL;
195 : :
196 [ # # ]: 0 : FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) {
197 [ # # ]: 0 : if (!drv->match(dev->name))
198 : 0 : continue;
199 : :
200 : 0 : rc = rte_auxiliary_probe_one_driver(drv, dev);
201 [ # # ]: 0 : if (rc < 0)
202 : : /* negative value is an error */
203 : 0 : return rc;
204 [ # # ]: 0 : if (rc > 0)
205 : : /* positive value means driver doesn't support it */
206 : 0 : continue;
207 : : return 0;
208 : : }
209 : : return 1;
210 : : }
211 : :
212 : : /*
213 : : * Scan the content of the auxiliary bus, and call the probe function for
214 : : * all registered drivers to try to probe discovered devices.
215 : : */
216 : : static int
217 : 180 : auxiliary_probe(void)
218 : : {
219 : : struct rte_auxiliary_device *dev = NULL;
220 : : size_t probed = 0, failed = 0;
221 : : int ret = 0;
222 : :
223 [ - + ]: 180 : FOREACH_DEVICE_ON_AUXILIARY_BUS(dev) {
224 : 0 : probed++;
225 : :
226 : 0 : ret = auxiliary_probe_all_drivers(dev);
227 [ # # ]: 0 : if (ret < 0) {
228 [ # # ]: 0 : if (ret != -EEXIST) {
229 : 0 : AUXILIARY_LOG(ERR, "Requested device %s cannot be used",
230 : : dev->name);
231 : 0 : rte_errno = errno;
232 : 0 : failed++;
233 : : }
234 : : ret = 0;
235 : : }
236 : : }
237 : :
238 [ + - ]: 180 : return (probed && probed == failed) ? -1 : 0;
239 : : }
240 : :
241 : : static int
242 : 37 : auxiliary_parse(const char *name, void *addr)
243 : : {
244 : : struct rte_auxiliary_driver *drv = NULL;
245 : : const char **out = addr;
246 : :
247 : : /* Allow empty device name "auxiliary:" to bypass entire bus scan. */
248 [ + - ]: 37 : if (strlen(name) == 0)
249 : : return 0;
250 : :
251 [ + + ]: 74 : FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) {
252 [ + - ]: 37 : if (drv->match(name))
253 : : break;
254 : : }
255 [ - + ]: 37 : if (drv != NULL && addr != NULL)
256 : 0 : *out = name;
257 [ + - ]: 37 : return drv != NULL ? 0 : -1;
258 : : }
259 : :
260 : : /* Register a driver */
261 : : void
262 : 252 : rte_auxiliary_register(struct rte_auxiliary_driver *driver)
263 : : {
264 : 252 : TAILQ_INSERT_TAIL(&auxiliary_bus.driver_list, driver, next);
265 : 252 : }
266 : :
267 : : /* Unregister a driver */
268 : : void
269 : 252 : rte_auxiliary_unregister(struct rte_auxiliary_driver *driver)
270 : : {
271 [ - + ]: 252 : TAILQ_REMOVE(&auxiliary_bus.driver_list, driver, next);
272 : 252 : }
273 : :
274 : : /* Add a device to auxiliary bus */
275 : : void
276 : 0 : auxiliary_add_device(struct rte_auxiliary_device *aux_dev)
277 : : {
278 : 0 : TAILQ_INSERT_TAIL(&auxiliary_bus.device_list, aux_dev, next);
279 : 0 : }
280 : :
281 : : /* Insert a device into a predefined position in auxiliary bus */
282 : : void
283 : 0 : auxiliary_insert_device(struct rte_auxiliary_device *exist_aux_dev,
284 : : struct rte_auxiliary_device *new_aux_dev)
285 : : {
286 : 0 : TAILQ_INSERT_BEFORE(exist_aux_dev, new_aux_dev, next);
287 : 0 : }
288 : :
289 : : /* Remove a device from auxiliary bus */
290 : : static void
291 : : rte_auxiliary_remove_device(struct rte_auxiliary_device *auxiliary_dev)
292 : : {
293 [ # # ]: 0 : TAILQ_REMOVE(&auxiliary_bus.device_list, auxiliary_dev, next);
294 : : }
295 : :
296 : : static struct rte_device *
297 : 0 : auxiliary_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
298 : : const void *data)
299 : : {
300 : : const struct rte_auxiliary_device *pstart;
301 : : struct rte_auxiliary_device *adev;
302 : :
303 [ # # ]: 0 : if (start != NULL) {
304 : 0 : pstart = RTE_DEV_TO_AUXILIARY_CONST(start);
305 : 0 : adev = TAILQ_NEXT(pstart, next);
306 : : } else {
307 : 0 : adev = TAILQ_FIRST(&auxiliary_bus.device_list);
308 : : }
309 [ # # ]: 0 : while (adev != NULL) {
310 [ # # ]: 0 : if (cmp(&adev->device, data) == 0)
311 : 0 : return &adev->device;
312 : 0 : adev = TAILQ_NEXT(adev, next);
313 : : }
314 : : return NULL;
315 : : }
316 : :
317 : : static int
318 : 0 : auxiliary_plug(struct rte_device *dev)
319 : : {
320 [ # # ]: 0 : if (!auxiliary_dev_exists(dev->name))
321 : : return -ENOENT;
322 : 0 : return auxiliary_probe_all_drivers(RTE_DEV_TO_AUXILIARY(dev));
323 : : }
324 : :
325 : : static int
326 : 0 : auxiliary_unplug(struct rte_device *dev)
327 : : {
328 : : struct rte_auxiliary_device *adev;
329 : : int ret;
330 : :
331 : 0 : adev = RTE_DEV_TO_AUXILIARY(dev);
332 : 0 : ret = rte_auxiliary_driver_remove_dev(adev);
333 [ # # ]: 0 : if (ret == 0) {
334 : : rte_auxiliary_remove_device(adev);
335 : 0 : rte_devargs_remove(dev->devargs);
336 : 0 : rte_intr_instance_free(adev->intr_handle);
337 : 0 : free(adev);
338 : : }
339 : 0 : return ret;
340 : : }
341 : :
342 : : static int
343 : 252 : auxiliary_cleanup(void)
344 : : {
345 : : struct rte_auxiliary_device *dev, *tmp_dev;
346 : : int error = 0;
347 : :
348 [ - + ]: 252 : RTE_TAILQ_FOREACH_SAFE(dev, &auxiliary_bus.device_list, next, tmp_dev) {
349 : : int ret;
350 : :
351 : 0 : ret = auxiliary_unplug(&dev->device);
352 [ # # ]: 0 : if (ret < 0) {
353 : 0 : rte_errno = errno;
354 : : error = -1;
355 : : }
356 : : }
357 : :
358 : 252 : return error;
359 : : }
360 : :
361 : : static int
362 : 0 : auxiliary_dma_map(struct rte_device *dev, void *addr, uint64_t iova, size_t len)
363 : : {
364 : 0 : struct rte_auxiliary_device *aux_dev = RTE_DEV_TO_AUXILIARY(dev);
365 : :
366 [ # # # # ]: 0 : if (dev == NULL || aux_dev->driver == NULL) {
367 : 0 : rte_errno = EINVAL;
368 : 0 : return -1;
369 : : }
370 [ # # ]: 0 : if (aux_dev->driver->dma_map == NULL) {
371 : 0 : rte_errno = ENOTSUP;
372 : 0 : return -1;
373 : : }
374 : 0 : return aux_dev->driver->dma_map(aux_dev, addr, iova, len);
375 : : }
376 : :
377 : : static int
378 : 0 : auxiliary_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova,
379 : : size_t len)
380 : : {
381 : 0 : struct rte_auxiliary_device *aux_dev = RTE_DEV_TO_AUXILIARY(dev);
382 : :
383 [ # # # # ]: 0 : if (dev == NULL || aux_dev->driver == NULL) {
384 : 0 : rte_errno = EINVAL;
385 : 0 : return -1;
386 : : }
387 [ # # ]: 0 : if (aux_dev->driver->dma_unmap == NULL) {
388 : 0 : rte_errno = ENOTSUP;
389 : 0 : return -1;
390 : : }
391 : 0 : return aux_dev->driver->dma_unmap(aux_dev, addr, iova, len);
392 : : }
393 : :
394 : : bool
395 : 0 : auxiliary_is_ignored_device(const char *name)
396 : : {
397 : 0 : struct rte_devargs *devargs = auxiliary_devargs_lookup(name);
398 : :
399 [ # # # ]: 0 : switch (auxiliary_bus.bus.conf.scan_mode) {
400 : 0 : case RTE_BUS_SCAN_ALLOWLIST:
401 [ # # # # ]: 0 : if (devargs && devargs->policy == RTE_DEV_ALLOWED)
402 : 0 : return false;
403 : : break;
404 : 0 : case RTE_BUS_SCAN_UNDEFINED:
405 : : case RTE_BUS_SCAN_BLOCKLIST:
406 [ # # # # ]: 0 : if (devargs == NULL || devargs->policy != RTE_DEV_BLOCKED)
407 : 0 : return false;
408 : : break;
409 : : }
410 : : return true;
411 : : }
412 : :
413 : : static enum rte_iova_mode
414 : 185 : auxiliary_get_iommu_class(void)
415 : : {
416 : : const struct rte_auxiliary_driver *drv;
417 : :
418 [ + + ]: 370 : FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) {
419 [ + - ]: 185 : if ((drv->drv_flags & RTE_AUXILIARY_DRV_NEED_IOVA_AS_VA) > 0)
420 : : return RTE_IOVA_VA;
421 : : }
422 : :
423 : : return RTE_IOVA_DC;
424 : : }
425 : :
426 : : struct rte_auxiliary_bus auxiliary_bus = {
427 : : .bus = {
428 : : .scan = auxiliary_scan,
429 : : .probe = auxiliary_probe,
430 : : .cleanup = auxiliary_cleanup,
431 : : .find_device = auxiliary_find_device,
432 : : .plug = auxiliary_plug,
433 : : .unplug = auxiliary_unplug,
434 : : .parse = auxiliary_parse,
435 : : .dma_map = auxiliary_dma_map,
436 : : .dma_unmap = auxiliary_dma_unmap,
437 : : .get_iommu_class = auxiliary_get_iommu_class,
438 : : .dev_iterate = auxiliary_dev_iterate,
439 : : },
440 : : .device_list = TAILQ_HEAD_INITIALIZER(auxiliary_bus.device_list),
441 : : .driver_list = TAILQ_HEAD_INITIALIZER(auxiliary_bus.driver_list),
442 : : };
443 : :
444 : 252 : RTE_REGISTER_BUS(auxiliary, auxiliary_bus.bus);
445 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(auxiliary_bus_logtype, NOTICE);
|
