Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2021 Intel Corporation
3 : : */
4 : :
5 : : #include <dirent.h>
6 : : #include <fcntl.h>
7 : : #include <unistd.h>
8 : : #include <sys/mman.h>
9 : : #include <libgen.h>
10 : :
11 : : #include <bus_driver.h>
12 : : #include <dev_driver.h>
13 : : #include <rte_devargs.h>
14 : : #include <rte_eal.h>
15 : : #include <rte_memory.h>
16 : : #include <rte_log.h>
17 : : #include <rte_dmadev_pmd.h>
18 : : #include <rte_string_fns.h>
19 : :
20 : : #include "idxd_internal.h"
21 : :
22 : : /* default value for DSA paths, but allow override in environment for testing */
23 : : #define DSA_DEV_PATH "/dev/dsa"
24 : : #define DSA_SYSFS_PATH "/sys/bus/dsa/devices"
25 : :
26 : : static unsigned int devcount;
27 : :
28 : : /** unique identifier for a DSA device/WQ instance */
29 : : struct dsa_wq_addr {
30 : : uint16_t device_id;
31 : : uint16_t wq_id;
32 : : };
33 : :
34 : : /** a DSA device instance */
35 : : struct rte_dsa_device {
36 : : struct rte_device device; /**< Inherit core device */
37 : : TAILQ_ENTRY(rte_dsa_device) next; /**< next dev in list */
38 : :
39 : : char wq_name[32]; /**< the workqueue name/number e.g. wq0.1 */
40 : : struct dsa_wq_addr addr; /**< Identifies the specific WQ */
41 : : };
42 : :
43 : : /* forward prototypes */
44 : : struct dsa_bus;
45 : : static int dsa_scan(void);
46 : : static int dsa_probe(void);
47 : : static struct rte_device *dsa_find_device(const struct rte_device *start,
48 : : rte_dev_cmp_t cmp, const void *data);
49 : : static enum rte_iova_mode dsa_get_iommu_class(void);
50 : : static int dsa_addr_parse(const char *name, void *addr);
51 : :
52 : : /** List of devices */
53 : : TAILQ_HEAD(dsa_device_list, rte_dsa_device);
54 : :
55 : : /**
56 : : * Structure describing the DSA bus
57 : : */
58 : : struct dsa_bus {
59 : : struct rte_bus bus; /**< Inherit the generic class */
60 : : struct rte_driver driver; /**< Driver struct for devices to point to */
61 : : struct dsa_device_list device_list; /**< List of PCI devices */
62 : : };
63 : :
64 : : struct dsa_bus dsa_bus = {
65 : : .bus = {
66 : : .scan = dsa_scan,
67 : : .probe = dsa_probe,
68 : : .find_device = dsa_find_device,
69 : : .get_iommu_class = dsa_get_iommu_class,
70 : : .parse = dsa_addr_parse,
71 : : },
72 : : .driver = {
73 : : .name = "dmadev_idxd"
74 : : },
75 : : .device_list = TAILQ_HEAD_INITIALIZER(dsa_bus.device_list),
76 : : };
77 : :
78 : : static inline const char *
79 : : dsa_get_dev_path(void)
80 : : {
81 : 216 : const char *path = getenv("DSA_DEV_PATH");
82 [ + - - - ]: 216 : return path ? path : DSA_DEV_PATH;
83 : : }
84 : :
85 : : static inline const char *
86 : : dsa_get_sysfs_path(void)
87 : : {
88 : 0 : const char *path = getenv("DSA_SYSFS_PATH");
89 [ # # # # : 0 : return path ? path : DSA_SYSFS_PATH;
# # ]
90 : : }
91 : :
92 : : static int
93 : 0 : idxd_dev_close(struct rte_dma_dev *dev)
94 : : {
95 : 0 : struct idxd_dmadev *idxd = dev->data->dev_private;
96 : 0 : munmap(RTE_CAST_PTR(void *, idxd->portal), 0x1000);
97 : 0 : return 0;
98 : : }
99 : :
100 : : static const struct rte_dma_dev_ops idxd_bus_ops = {
101 : : .dev_close = idxd_dev_close,
102 : : .dev_dump = idxd_dump,
103 : : .dev_configure = idxd_configure,
104 : : .vchan_setup = idxd_vchan_setup,
105 : : .dev_info_get = idxd_info_get,
106 : : .stats_get = idxd_stats_get,
107 : : .stats_reset = idxd_stats_reset,
108 : : .vchan_status = idxd_vchan_status,
109 : : };
110 : :
111 : : static void *
112 : 0 : idxd_bus_mmap_wq(struct rte_dsa_device *dev)
113 : : {
114 : : void *addr;
115 : : char path[PATH_MAX];
116 : : int fd;
117 : :
118 : 0 : snprintf(path, sizeof(path), "%s/%s", dsa_get_dev_path(), dev->wq_name);
119 : : fd = open(path, O_RDWR);
120 [ # # ]: 0 : if (fd < 0) {
121 : 0 : IDXD_PMD_ERR("Failed to open device path: %s", path);
122 : 0 : return NULL;
123 : : }
124 : :
125 : 0 : addr = mmap(NULL, 0x1000, PROT_WRITE, MAP_SHARED, fd, 0);
126 : 0 : close(fd);
127 [ # # ]: 0 : if (addr == MAP_FAILED) {
128 : 0 : IDXD_PMD_ERR("Failed to mmap device %s", path);
129 : 0 : return NULL;
130 : : }
131 : :
132 : : return addr;
133 : : }
134 : :
135 : : static int
136 : 0 : read_wq_string(struct rte_dsa_device *dev, const char *filename,
137 : : char *value, size_t valuelen)
138 : : {
139 : : char sysfs_node[PATH_MAX];
140 : : int len;
141 : : int fd;
142 : :
143 : : snprintf(sysfs_node, sizeof(sysfs_node), "%s/%s/%s",
144 : 0 : dsa_get_sysfs_path(), dev->wq_name, filename);
145 : : fd = open(sysfs_node, O_RDONLY);
146 [ # # ]: 0 : if (fd < 0) {
147 : 0 : IDXD_PMD_ERR("%s(): opening file '%s' failed: %s",
148 : : __func__, sysfs_node, strerror(errno));
149 : 0 : return -1;
150 : : }
151 : :
152 [ # # ]: 0 : len = read(fd, value, valuelen - 1);
153 : 0 : close(fd);
154 [ # # ]: 0 : if (len < 0) {
155 : 0 : IDXD_PMD_ERR("%s(): error reading file '%s': %s",
156 : : __func__, sysfs_node, strerror(errno));
157 : 0 : return -1;
158 : : }
159 : 0 : value[len] = '\0';
160 : 0 : return 0;
161 : : }
162 : :
163 : : static int
164 : 0 : read_wq_int(struct rte_dsa_device *dev, const char *filename,
165 : : int *value)
166 : : {
167 : : char sysfs_node[PATH_MAX];
168 : : FILE *f;
169 : : int ret = 0;
170 : :
171 : : snprintf(sysfs_node, sizeof(sysfs_node), "%s/%s/%s",
172 : 0 : dsa_get_sysfs_path(), dev->wq_name, filename);
173 : 0 : f = fopen(sysfs_node, "r");
174 [ # # ]: 0 : if (f == NULL) {
175 : 0 : IDXD_PMD_ERR("%s(): opening file '%s' failed: %s",
176 : : __func__, sysfs_node, strerror(errno));
177 : 0 : return -1;
178 : : }
179 : :
180 [ # # ]: 0 : if (fscanf(f, "%d", value) != 1) {
181 : 0 : IDXD_PMD_ERR("%s(): error reading file '%s': %s",
182 : : __func__, sysfs_node, strerror(errno));
183 : : ret = -1;
184 : : }
185 : :
186 : 0 : fclose(f);
187 : 0 : return ret;
188 : : }
189 : :
190 : : static int
191 : 0 : read_device_int(struct rte_dsa_device *dev, const char *filename,
192 : : int *value)
193 : : {
194 : : char sysfs_node[PATH_MAX];
195 : : FILE *f;
196 : : int ret = 0;
197 : :
198 : 0 : snprintf(sysfs_node, sizeof(sysfs_node), "%s/dsa%d/%s",
199 : 0 : dsa_get_sysfs_path(), dev->addr.device_id, filename);
200 : 0 : f = fopen(sysfs_node, "r");
201 [ # # ]: 0 : if (f == NULL) {
202 : 0 : IDXD_PMD_ERR("%s(): opening file '%s' failed: %s",
203 : : __func__, sysfs_node, strerror(errno));
204 : 0 : return -1;
205 : : }
206 : :
207 [ # # ]: 0 : if (fscanf(f, "%d", value) != 1) {
208 : 0 : IDXD_PMD_ERR("%s(): error reading file '%s': %s",
209 : : __func__, sysfs_node, strerror(errno));
210 : : ret = -1;
211 : : }
212 : :
213 : 0 : fclose(f);
214 : 0 : return ret;
215 : : }
216 : :
217 : : static int
218 : 0 : idxd_probe_dsa(struct rte_dsa_device *dev)
219 : : {
220 : 0 : struct idxd_dmadev idxd = {0};
221 : 0 : int ret = 0;
222 : :
223 : 0 : IDXD_PMD_INFO("Probing device %s on numa node %d",
224 : : dev->wq_name, dev->device.numa_node);
225 [ # # ]: 0 : if (read_wq_int(dev, "size", &ret) < 0)
226 : : return -1;
227 : 0 : idxd.max_batches = ret;
228 [ # # ]: 0 : if (read_wq_int(dev, "max_batch_size", &ret) < 0)
229 : : return -1;
230 : 0 : idxd.max_batch_size = ret;
231 : 0 : idxd.qid = dev->addr.wq_id;
232 : 0 : idxd.u.bus.dsa_id = dev->addr.device_id;
233 : 0 : idxd.sva_support = 1;
234 : :
235 : 0 : idxd.portal = idxd_bus_mmap_wq(dev);
236 [ # # ]: 0 : if (idxd.portal == NULL) {
237 : 0 : IDXD_PMD_ERR("WQ mmap failed");
238 : 0 : return -ENOENT;
239 : : }
240 : :
241 : 0 : ret = idxd_dmadev_create(dev->wq_name, &dev->device, &idxd, &idxd_bus_ops);
242 [ # # ]: 0 : if (ret) {
243 : 0 : IDXD_PMD_ERR("Failed to create dmadev %s", dev->wq_name);
244 : 0 : return ret;
245 : : }
246 : :
247 : : return 0;
248 : : }
249 : :
250 : : static int
251 : 0 : is_for_this_process_use(struct rte_dsa_device *dev, const char *name)
252 : : {
253 : : char prefix[256];
254 : : int retval = 0;
255 : : size_t prefixlen;
256 : :
257 : 0 : prefixlen = rte_basename(rte_eal_get_runtime_dir(), prefix, sizeof(prefix));
258 [ # # # # ]: 0 : if (prefixlen >= sizeof(prefix) || strcmp(prefix, ".") == 0)
259 : : return retval;
260 : :
261 [ # # ]: 0 : if (strncmp(name, "dpdk_", 5) == 0)
262 : : retval = 1;
263 [ # # # # ]: 0 : if (strncmp(name, prefix, prefixlen) == 0 && name[prefixlen] == '_')
264 : : retval = 1;
265 : :
266 [ # # ]: 0 : if (retval)
267 : 0 : retval = !rte_bus_device_is_ignored(&dsa_bus.bus, dev->device.name);
268 : :
269 : : return retval;
270 : : }
271 : :
272 : : static int
273 : 211 : dsa_probe(void)
274 : : {
275 : : struct rte_dsa_device *dev;
276 : :
277 [ - + ]: 211 : TAILQ_FOREACH(dev, &dsa_bus.device_list, next) {
278 : : char type[64], name[64];
279 : :
280 [ # # # # ]: 0 : if (read_wq_string(dev, "type", type, sizeof(type)) < 0 ||
281 : 0 : read_wq_string(dev, "name", name, sizeof(name)) < 0)
282 : 0 : continue;
283 : :
284 [ # # # # ]: 0 : if (strncmp(type, "user", 4) == 0 &&
285 : 0 : is_for_this_process_use(dev, name)) {
286 : 0 : dev->device.driver = &dsa_bus.driver;
287 : 0 : idxd_probe_dsa(dev);
288 : 0 : continue;
289 : : }
290 : 0 : IDXD_PMD_DEBUG("WQ '%s', not allocated to DPDK", dev->wq_name);
291 : : }
292 : :
293 : 211 : return 0;
294 : : }
295 : :
296 : : static int
297 : 216 : dsa_scan(void)
298 : : {
299 : : const char *path = dsa_get_dev_path();
300 : : struct dirent *wq;
301 : : DIR *dev_dir;
302 : :
303 : 216 : dev_dir = opendir(path);
304 [ + - ]: 216 : if (dev_dir == NULL) {
305 [ - + ]: 216 : if (errno == ENOENT)
306 : : return 0; /* no bus, return without error */
307 : 0 : IDXD_PMD_ERR("%s(): opendir '%s' failed: %s",
308 : : __func__, path, strerror(errno));
309 : 0 : return -1;
310 : : }
311 : :
312 [ # # ]: 0 : while ((wq = readdir(dev_dir)) != NULL) {
313 : : struct rte_dsa_device *dev;
314 : 0 : int numa_node = SOCKET_ID_ANY;
315 : :
316 [ # # ]: 0 : if (strncmp(wq->d_name, "wq", 2) != 0)
317 : 0 : continue;
318 [ # # ]: 0 : if (strnlen(wq->d_name, sizeof(dev->wq_name)) == sizeof(dev->wq_name)) {
319 : 0 : IDXD_PMD_ERR("%s(): wq name too long: '%s', skipping",
320 : : __func__, wq->d_name);
321 : 0 : continue;
322 : : }
323 : 0 : IDXD_PMD_DEBUG("%s(): found %s/%s", __func__, path, wq->d_name);
324 : :
325 : 0 : dev = malloc(sizeof(*dev));
326 [ # # ]: 0 : if (dev == NULL) {
327 : 0 : closedir(dev_dir);
328 : 0 : return -ENOMEM;
329 : : }
330 [ # # ]: 0 : if (dsa_addr_parse(wq->d_name, &dev->addr) < 0) {
331 : 0 : IDXD_PMD_ERR("Error parsing WQ name: %s", wq->d_name);
332 : 0 : free(dev);
333 : 0 : continue;
334 : : }
335 : 0 : dev->device.bus = &dsa_bus.bus;
336 : 0 : strlcpy(dev->wq_name, wq->d_name, sizeof(dev->wq_name));
337 : 0 : TAILQ_INSERT_TAIL(&dsa_bus.device_list, dev, next);
338 : 0 : devcount++;
339 : :
340 : 0 : read_device_int(dev, "numa_node", &numa_node);
341 : 0 : dev->device.numa_node = numa_node;
342 : 0 : dev->device.name = dev->wq_name;
343 : : }
344 : :
345 : 0 : closedir(dev_dir);
346 : 0 : return 0;
347 : : }
348 : :
349 : : static struct rte_device *
350 : 0 : dsa_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
351 : : const void *data)
352 : : {
353 : 0 : struct rte_dsa_device *dev = TAILQ_FIRST(&dsa_bus.device_list);
354 : :
355 : : /* the rte_device struct must be at start of dsa structure */
356 : : RTE_BUILD_BUG_ON(offsetof(struct rte_dsa_device, device) != 0);
357 : :
358 [ # # ]: 0 : if (start != NULL) /* jump to start point if given */
359 : 0 : dev = TAILQ_NEXT((const struct rte_dsa_device *)start, next);
360 [ # # ]: 0 : while (dev != NULL) {
361 [ # # ]: 0 : if (cmp(&dev->device, data) == 0)
362 : 0 : return &dev->device;
363 : 0 : dev = TAILQ_NEXT(dev, next);
364 : : }
365 : : return NULL;
366 : : }
367 : :
368 : : static enum rte_iova_mode
369 : 216 : dsa_get_iommu_class(void)
370 : : {
371 : : /* if there are no devices, report don't care, otherwise VA mode */
372 [ + - ]: 216 : return devcount > 0 ? RTE_IOVA_VA : RTE_IOVA_DC;
373 : : }
374 : :
375 : : static int
376 : 15 : dsa_addr_parse(const char *name, void *addr)
377 : : {
378 : : struct dsa_wq_addr *wq = addr;
379 : : unsigned int device_id, wq_id;
380 : :
381 [ + - ]: 15 : if (sscanf(name, "wq%u.%u", &device_id, &wq_id) != 2) {
382 : 15 : IDXD_PMD_DEBUG("Parsing WQ name failed: %s", name);
383 : 15 : return -1;
384 : : }
385 : :
386 [ # # ]: 0 : if (wq != NULL) {
387 : 0 : wq->device_id = device_id;
388 : 0 : wq->wq_id = wq_id;
389 : : }
390 : :
391 : : return 0;
392 : : }
393 : :
394 : 284 : RTE_REGISTER_BUS(dsa, dsa_bus.bus);
|
