Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2019 Marvell International Ltd.
3 : : * Copyright 2020 Mellanox Technologies, Ltd
4 : : */
5 : :
6 : : #include <string.h>
7 : :
8 : : #include <eal_export.h>
9 : : #include <rte_memzone.h>
10 : : #include <rte_string_fns.h>
11 : :
12 : : #include "rte_regexdev.h"
13 : : #include "rte_regexdev_core.h"
14 : : #include "rte_regexdev_driver.h"
15 : :
16 : : static const char *MZ_RTE_REGEXDEV_DATA = "rte_regexdev_data";
17 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regex_devices, 22.03)
18 : : struct rte_regexdev rte_regex_devices[RTE_MAX_REGEXDEV_DEVS];
19 : : /* Shared memory between primary and secondary processes. */
20 : : static struct {
21 : : struct rte_regexdev_data data[RTE_MAX_REGEXDEV_DEVS];
22 : : } *rte_regexdev_shared_data;
23 : :
24 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_logtype, 22.03)
25 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(rte_regexdev_logtype, INFO);
26 : :
27 : : static uint16_t
28 : : regexdev_find_free_dev(void)
29 : : {
30 : : uint16_t i;
31 : :
32 [ # # ]: 0 : for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) {
33 [ # # ]: 0 : if (rte_regex_devices[i].state == RTE_REGEXDEV_UNUSED)
34 : : return i;
35 : : }
36 : : return RTE_MAX_REGEXDEV_DEVS;
37 : : }
38 : :
39 : : static struct rte_regexdev*
40 : 0 : regexdev_allocated(const char *name)
41 : : {
42 : : uint16_t i;
43 : :
44 [ # # ]: 0 : for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) {
45 [ # # ]: 0 : if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED)
46 [ # # ]: 0 : if (!strcmp(name, rte_regex_devices[i].data->dev_name))
47 : 0 : return &rte_regex_devices[i];
48 : : }
49 : : return NULL;
50 : : }
51 : :
52 : : static int
53 : 0 : regexdev_shared_data_prepare(void)
54 : : {
55 : : const unsigned int flags = 0;
56 : : const struct rte_memzone *mz;
57 : :
58 [ # # ]: 0 : if (rte_regexdev_shared_data == NULL) {
59 : : /* Allocate port data and ownership shared memory. */
60 : 0 : mz = rte_memzone_reserve(MZ_RTE_REGEXDEV_DATA,
61 : : sizeof(*rte_regexdev_shared_data),
62 : 0 : rte_socket_id(), flags);
63 [ # # ]: 0 : if (mz == NULL)
64 : : return -ENOMEM;
65 : :
66 : 0 : rte_regexdev_shared_data = mz->addr;
67 : 0 : memset(rte_regexdev_shared_data->data, 0,
68 : : sizeof(rte_regexdev_shared_data->data));
69 : : }
70 : : return 0;
71 : : }
72 : :
73 : : static int
74 : 0 : regexdev_check_name(const char *name)
75 : : {
76 : : size_t name_len;
77 : :
78 [ # # ]: 0 : if (name == NULL) {
79 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Name can't be NULL");
80 : 0 : return -EINVAL;
81 : : }
82 : 0 : name_len = strnlen(name, RTE_REGEXDEV_NAME_MAX_LEN);
83 [ # # ]: 0 : if (name_len == 0) {
84 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Zero length RegEx device name");
85 : 0 : return -EINVAL;
86 : : }
87 [ # # ]: 0 : if (name_len >= RTE_REGEXDEV_NAME_MAX_LEN) {
88 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "RegEx device name is too long");
89 : 0 : return -EINVAL;
90 : : }
91 : 0 : return (int)name_len;
92 : :
93 : : }
94 : :
95 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_regexdev_register)
96 : : struct rte_regexdev *
97 : 0 : rte_regexdev_register(const char *name)
98 : : {
99 : : uint16_t dev_id;
100 : : int name_len;
101 : : struct rte_regexdev *dev;
102 : :
103 : 0 : name_len = regexdev_check_name(name);
104 [ # # ]: 0 : if (name_len < 0)
105 : : return NULL;
106 : 0 : dev = regexdev_allocated(name);
107 [ # # ]: 0 : if (dev != NULL) {
108 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "RegEx device already allocated");
109 : 0 : return NULL;
110 : : }
111 : : dev_id = regexdev_find_free_dev();
112 [ # # ]: 0 : if (dev_id == RTE_MAX_REGEXDEV_DEVS) {
113 : 0 : RTE_REGEXDEV_LOG_LINE
114 : : (ERR, "Reached maximum number of RegEx devices");
115 : 0 : return NULL;
116 : : }
117 [ # # ]: 0 : if (regexdev_shared_data_prepare() < 0) {
118 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Cannot allocate RegEx shared data");
119 : 0 : return NULL;
120 : : }
121 : :
122 : 0 : dev = &rte_regex_devices[dev_id];
123 : 0 : dev->state = RTE_REGEXDEV_REGISTERED;
124 [ # # ]: 0 : if (dev->data == NULL)
125 : 0 : dev->data = &rte_regexdev_shared_data->data[dev_id];
126 : : else
127 : : memset(dev->data, 1, sizeof(*dev->data));
128 : 0 : dev->data->dev_id = dev_id;
129 : 0 : strlcpy(dev->data->dev_name, name, sizeof(dev->data->dev_name));
130 : 0 : return dev;
131 : : }
132 : :
133 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_regexdev_unregister)
134 : : void
135 : 0 : rte_regexdev_unregister(struct rte_regexdev *dev)
136 : : {
137 : 0 : dev->state = RTE_REGEXDEV_UNUSED;
138 : 0 : }
139 : :
140 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_regexdev_get_device_by_name)
141 : : struct rte_regexdev *
142 : 0 : rte_regexdev_get_device_by_name(const char *name)
143 : : {
144 [ # # ]: 0 : if (regexdev_check_name(name) < 0)
145 : : return NULL;
146 : 0 : return regexdev_allocated(name);
147 : : }
148 : :
149 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_count, 20.08)
150 : : uint8_t
151 : 0 : rte_regexdev_count(void)
152 : : {
153 : : int i;
154 : : int count = 0;
155 : :
156 [ # # ]: 0 : for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) {
157 [ # # ]: 0 : if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED)
158 : 0 : count++;
159 : : }
160 : 0 : return count;
161 : : }
162 : :
163 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_get_dev_id, 20.08)
164 : : int
165 : 0 : rte_regexdev_get_dev_id(const char *name)
166 : : {
167 : : int i;
168 : : int id = -EINVAL;
169 : :
170 [ # # ]: 0 : if (name == NULL)
171 : : return -EINVAL;
172 [ # # ]: 0 : for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) {
173 [ # # ]: 0 : if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED)
174 [ # # ]: 0 : if (strcmp(name, rte_regex_devices[i].data->dev_name)) {
175 : 0 : id = rte_regex_devices[i].data->dev_id;
176 : 0 : break;
177 : : }
178 : : }
179 : : return id;
180 : : }
181 : :
182 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_is_valid_dev, 22.03)
183 : : int
184 : 0 : rte_regexdev_is_valid_dev(uint16_t dev_id)
185 : : {
186 [ # # ]: 0 : if (dev_id >= RTE_MAX_REGEXDEV_DEVS ||
187 [ # # ]: 0 : rte_regex_devices[dev_id].state != RTE_REGEXDEV_READY)
188 : 0 : return 0;
189 : : return 1;
190 : : }
191 : :
192 : : static int
193 : 0 : regexdev_info_get(uint8_t dev_id, struct rte_regexdev_info *dev_info)
194 : : {
195 : : struct rte_regexdev *dev;
196 : :
197 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
198 [ # # ]: 0 : if (dev_info == NULL)
199 : : return -EINVAL;
200 : 0 : dev = &rte_regex_devices[dev_id];
201 [ # # ]: 0 : if (dev->dev_ops->dev_info_get == NULL)
202 : : return -ENOTSUP;
203 : 0 : return dev->dev_ops->dev_info_get(dev, dev_info);
204 : :
205 : : }
206 : :
207 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_info_get, 20.08)
208 : : int
209 : 0 : rte_regexdev_info_get(uint8_t dev_id, struct rte_regexdev_info *dev_info)
210 : : {
211 : 0 : return regexdev_info_get(dev_id, dev_info);
212 : : }
213 : :
214 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_configure, 20.08)
215 : : int
216 : 0 : rte_regexdev_configure(uint8_t dev_id, const struct rte_regexdev_config *cfg)
217 : : {
218 : : struct rte_regexdev *dev;
219 : : struct rte_regexdev_info dev_info;
220 : : int ret;
221 : :
222 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
223 [ # # ]: 0 : if (cfg == NULL)
224 : : return -EINVAL;
225 : 0 : dev = &rte_regex_devices[dev_id];
226 [ # # ]: 0 : if (dev->dev_ops->dev_configure == NULL)
227 : : return -ENOTSUP;
228 [ # # ]: 0 : if (dev->data->dev_started) {
229 : 0 : RTE_REGEXDEV_LOG_LINE
230 : : (ERR, "Dev %u must be stopped to allow configuration",
231 : : dev_id);
232 : 0 : return -EBUSY;
233 : : }
234 : 0 : ret = regexdev_info_get(dev_id, &dev_info);
235 [ # # ]: 0 : if (ret < 0)
236 : : return ret;
237 [ # # ]: 0 : if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_CROSS_BUFFER_SCAN_F) &&
238 [ # # ]: 0 : !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_CROSS_BUFFER_F)) {
239 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
240 : : "Dev %u doesn't support cross buffer scan",
241 : : dev_id);
242 : 0 : return -EINVAL;
243 : : }
244 [ # # ]: 0 : if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_MATCH_AS_END_F) &&
245 [ # # ]: 0 : !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_MATCH_AS_END_F)) {
246 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
247 : : "Dev %u doesn't support match as end",
248 : : dev_id);
249 : 0 : return -EINVAL;
250 : : }
251 [ # # ]: 0 : if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_MATCH_ALL_F) &&
252 [ # # ]: 0 : !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_MATCH_ALL_F)) {
253 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
254 : : "Dev %u doesn't support match all",
255 : : dev_id);
256 : 0 : return -EINVAL;
257 : : }
258 [ # # ]: 0 : if (cfg->nb_groups == 0) {
259 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of groups must be > 0",
260 : : dev_id);
261 : 0 : return -EINVAL;
262 : : }
263 [ # # ]: 0 : if (cfg->nb_groups > dev_info.max_groups) {
264 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of groups %d > %d",
265 : : dev_id, cfg->nb_groups, dev_info.max_groups);
266 : 0 : return -EINVAL;
267 : : }
268 [ # # ]: 0 : if (cfg->nb_max_matches == 0) {
269 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of matches must be > 0",
270 : : dev_id);
271 : 0 : return -EINVAL;
272 : : }
273 [ # # ]: 0 : if (cfg->nb_max_matches > dev_info.max_matches) {
274 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of matches %d > %d",
275 : : dev_id, cfg->nb_max_matches,
276 : : dev_info.max_matches);
277 : 0 : return -EINVAL;
278 : : }
279 [ # # ]: 0 : if (cfg->nb_queue_pairs == 0) {
280 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of queues must be > 0",
281 : : dev_id);
282 : 0 : return -EINVAL;
283 : : }
284 [ # # ]: 0 : if (cfg->nb_queue_pairs > dev_info.max_queue_pairs) {
285 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %u num of queues %d > %d",
286 : : dev_id, cfg->nb_queue_pairs,
287 : : dev_info.max_queue_pairs);
288 : 0 : return -EINVAL;
289 : : }
290 [ # # ]: 0 : if (cfg->nb_rules_per_group == 0) {
291 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
292 : : "Dev %u num of rules per group must be > 0",
293 : : dev_id);
294 : 0 : return -EINVAL;
295 : : }
296 [ # # ]: 0 : if (cfg->nb_rules_per_group > dev_info.max_rules_per_group) {
297 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
298 : : "Dev %u num of rules per group %d > %d",
299 : : dev_id, cfg->nb_rules_per_group,
300 : : dev_info.max_rules_per_group);
301 : 0 : return -EINVAL;
302 : : }
303 : 0 : ret = dev->dev_ops->dev_configure(dev, cfg);
304 [ # # ]: 0 : if (ret == 0)
305 : 0 : dev->data->dev_conf = *cfg;
306 : : return ret;
307 : : }
308 : :
309 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_queue_pair_setup, 20.08)
310 : : int
311 : 0 : rte_regexdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
312 : : const struct rte_regexdev_qp_conf *qp_conf)
313 : : {
314 : : struct rte_regexdev *dev;
315 : :
316 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
317 : 0 : dev = &rte_regex_devices[dev_id];
318 [ # # ]: 0 : if (dev->dev_ops->dev_qp_setup == NULL)
319 : : return -ENOTSUP;
320 [ # # ]: 0 : if (dev->data->dev_started) {
321 : 0 : RTE_REGEXDEV_LOG_LINE
322 : : (ERR, "Dev %u must be stopped to allow configuration",
323 : : dev_id);
324 : 0 : return -EBUSY;
325 : : }
326 [ # # ]: 0 : if (queue_pair_id >= dev->data->dev_conf.nb_queue_pairs) {
327 : 0 : RTE_REGEXDEV_LOG_LINE(ERR,
328 : : "Dev %u invalid queue %d > %d",
329 : : dev_id, queue_pair_id,
330 : : dev->data->dev_conf.nb_queue_pairs);
331 : 0 : return -EINVAL;
332 : : }
333 : : if (dev->data->dev_started) {
334 : : RTE_REGEXDEV_LOG_LINE
335 : : (ERR, "Dev %u must be stopped to allow configuration",
336 : : dev_id);
337 : : return -EBUSY;
338 : : }
339 : 0 : return dev->dev_ops->dev_qp_setup(dev, queue_pair_id, qp_conf);
340 : : }
341 : :
342 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_start, 20.08)
343 : : int
344 : 0 : rte_regexdev_start(uint8_t dev_id)
345 : : {
346 : : struct rte_regexdev *dev;
347 : : int ret;
348 : :
349 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
350 : 0 : dev = &rte_regex_devices[dev_id];
351 [ # # ]: 0 : if (dev->dev_ops->dev_start == NULL)
352 : : return -ENOTSUP;
353 : 0 : ret = dev->dev_ops->dev_start(dev);
354 [ # # ]: 0 : if (ret == 0)
355 : 0 : dev->data->dev_started = 1;
356 : : return ret;
357 : : }
358 : :
359 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_stop, 20.08)
360 : : int
361 : 0 : rte_regexdev_stop(uint8_t dev_id)
362 : : {
363 : : struct rte_regexdev *dev;
364 : :
365 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
366 : 0 : dev = &rte_regex_devices[dev_id];
367 [ # # ]: 0 : if (dev->dev_ops->dev_stop == NULL)
368 : : return -ENOTSUP;
369 : 0 : dev->dev_ops->dev_stop(dev);
370 : 0 : dev->data->dev_started = 0;
371 : 0 : return 0;
372 : : }
373 : :
374 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_close, 20.08)
375 : : int
376 : 0 : rte_regexdev_close(uint8_t dev_id)
377 : : {
378 : : struct rte_regexdev *dev;
379 : :
380 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
381 : 0 : dev = &rte_regex_devices[dev_id];
382 [ # # ]: 0 : if (dev->dev_ops->dev_close == NULL)
383 : : return -ENOTSUP;
384 : 0 : dev->dev_ops->dev_close(dev);
385 : 0 : dev->data->dev_started = 0;
386 : 0 : dev->state = RTE_REGEXDEV_UNUSED;
387 : 0 : return 0;
388 : : }
389 : :
390 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_attr_get, 20.08)
391 : : int
392 : 0 : rte_regexdev_attr_get(uint8_t dev_id, enum rte_regexdev_attr_id attr_id,
393 : : void *attr_value)
394 : : {
395 : : struct rte_regexdev *dev;
396 : :
397 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
398 : 0 : dev = &rte_regex_devices[dev_id];
399 [ # # ]: 0 : if (dev->dev_ops->dev_attr_get == NULL)
400 : : return -ENOTSUP;
401 [ # # ]: 0 : if (attr_value == NULL) {
402 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d attribute value can't be NULL",
403 : : dev_id);
404 : 0 : return -EINVAL;
405 : : }
406 : 0 : return dev->dev_ops->dev_attr_get(dev, attr_id, attr_value);
407 : : }
408 : :
409 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_attr_set, 20.08)
410 : : int
411 : 0 : rte_regexdev_attr_set(uint8_t dev_id, enum rte_regexdev_attr_id attr_id,
412 : : const void *attr_value)
413 : : {
414 : : struct rte_regexdev *dev;
415 : :
416 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
417 : 0 : dev = &rte_regex_devices[dev_id];
418 [ # # ]: 0 : if (dev->dev_ops->dev_attr_set == NULL)
419 : : return -ENOTSUP;
420 [ # # ]: 0 : if (attr_value == NULL) {
421 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d attribute value can't be NULL",
422 : : dev_id);
423 : 0 : return -EINVAL;
424 : : }
425 : 0 : return dev->dev_ops->dev_attr_set(dev, attr_id, attr_value);
426 : : }
427 : :
428 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_rule_db_update, 20.08)
429 : : int
430 : 0 : rte_regexdev_rule_db_update(uint8_t dev_id,
431 : : const struct rte_regexdev_rule *rules,
432 : : uint32_t nb_rules)
433 : : {
434 : : struct rte_regexdev *dev;
435 : :
436 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
437 : 0 : dev = &rte_regex_devices[dev_id];
438 [ # # ]: 0 : if (dev->dev_ops->dev_rule_db_update == NULL)
439 : : return -ENOTSUP;
440 [ # # ]: 0 : if (rules == NULL) {
441 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d rules can't be NULL",
442 : : dev_id);
443 : 0 : return -EINVAL;
444 : : }
445 : 0 : return dev->dev_ops->dev_rule_db_update(dev, rules, nb_rules);
446 : : }
447 : :
448 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_rule_db_compile_activate, 20.08)
449 : : int
450 : 0 : rte_regexdev_rule_db_compile_activate(uint8_t dev_id)
451 : : {
452 : : struct rte_regexdev *dev;
453 : :
454 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
455 : 0 : dev = &rte_regex_devices[dev_id];
456 [ # # ]: 0 : if (dev->dev_ops->dev_rule_db_compile_activate == NULL)
457 : : return -ENOTSUP;
458 : 0 : return dev->dev_ops->dev_rule_db_compile_activate(dev);
459 : : }
460 : :
461 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_rule_db_import, 20.08)
462 : : int
463 : 0 : rte_regexdev_rule_db_import(uint8_t dev_id, const char *rule_db,
464 : : uint32_t rule_db_len)
465 : : {
466 : : struct rte_regexdev *dev;
467 : :
468 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
469 : 0 : dev = &rte_regex_devices[dev_id];
470 [ # # ]: 0 : if (dev->dev_ops->dev_db_import == NULL)
471 : : return -ENOTSUP;
472 [ # # ]: 0 : if (rule_db == NULL) {
473 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d rules can't be NULL",
474 : : dev_id);
475 : 0 : return -EINVAL;
476 : : }
477 : 0 : return dev->dev_ops->dev_db_import(dev, rule_db, rule_db_len);
478 : : }
479 : :
480 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_rule_db_export, 20.08)
481 : : int
482 : 0 : rte_regexdev_rule_db_export(uint8_t dev_id, char *rule_db)
483 : : {
484 : : struct rte_regexdev *dev;
485 : :
486 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
487 : 0 : dev = &rte_regex_devices[dev_id];
488 [ # # ]: 0 : if (dev->dev_ops->dev_db_export == NULL)
489 : : return -ENOTSUP;
490 : 0 : return dev->dev_ops->dev_db_export(dev, rule_db);
491 : : }
492 : :
493 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_xstats_names_get, 20.08)
494 : : int
495 : 0 : rte_regexdev_xstats_names_get(uint8_t dev_id,
496 : : struct rte_regexdev_xstats_map *xstats_map)
497 : : {
498 : : struct rte_regexdev *dev;
499 : :
500 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
501 : 0 : dev = &rte_regex_devices[dev_id];
502 [ # # ]: 0 : if (dev->dev_ops->dev_xstats_names_get == NULL)
503 : : return -ENOTSUP;
504 [ # # ]: 0 : if (xstats_map == NULL) {
505 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d xstats map can't be NULL",
506 : : dev_id);
507 : 0 : return -EINVAL;
508 : : }
509 : 0 : return dev->dev_ops->dev_xstats_names_get(dev, xstats_map);
510 : : }
511 : :
512 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_xstats_get, 20.08)
513 : : int
514 : 0 : rte_regexdev_xstats_get(uint8_t dev_id, const uint16_t *ids,
515 : : uint64_t *values, uint16_t n)
516 : : {
517 : : struct rte_regexdev *dev;
518 : :
519 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
520 : 0 : dev = &rte_regex_devices[dev_id];
521 [ # # ]: 0 : if (dev->dev_ops->dev_xstats_get == NULL)
522 : : return -ENOTSUP;
523 [ # # ]: 0 : if (ids == NULL) {
524 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d ids can't be NULL", dev_id);
525 : 0 : return -EINVAL;
526 : : }
527 [ # # ]: 0 : if (values == NULL) {
528 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d values can't be NULL", dev_id);
529 : 0 : return -EINVAL;
530 : : }
531 : 0 : return dev->dev_ops->dev_xstats_get(dev, ids, values, n);
532 : : }
533 : :
534 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_xstats_by_name_get, 20.08)
535 : : int
536 : 0 : rte_regexdev_xstats_by_name_get(uint8_t dev_id, const char *name,
537 : : uint16_t *id, uint64_t *value)
538 : : {
539 : : struct rte_regexdev *dev;
540 : :
541 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
542 : 0 : dev = &rte_regex_devices[dev_id];
543 [ # # ]: 0 : if (dev->dev_ops->dev_xstats_by_name_get == NULL)
544 : : return -ENOTSUP;
545 [ # # ]: 0 : if (name == NULL) {
546 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d name can't be NULL", dev_id);
547 : 0 : return -EINVAL;
548 : : }
549 [ # # ]: 0 : if (id == NULL) {
550 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d id can't be NULL", dev_id);
551 : 0 : return -EINVAL;
552 : : }
553 [ # # ]: 0 : if (value == NULL) {
554 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d value can't be NULL", dev_id);
555 : 0 : return -EINVAL;
556 : : }
557 : 0 : return dev->dev_ops->dev_xstats_by_name_get(dev, name, id, value);
558 : : }
559 : :
560 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_xstats_reset, 20.08)
561 : : int
562 : 0 : rte_regexdev_xstats_reset(uint8_t dev_id, const uint16_t *ids,
563 : : uint16_t nb_ids)
564 : : {
565 : : struct rte_regexdev *dev;
566 : :
567 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
568 : 0 : dev = &rte_regex_devices[dev_id];
569 [ # # ]: 0 : if (dev->dev_ops->dev_xstats_reset == NULL)
570 : : return -ENOTSUP;
571 [ # # ]: 0 : if (ids == NULL) {
572 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d ids can't be NULL", dev_id);
573 : 0 : return -EINVAL;
574 : : }
575 : 0 : return dev->dev_ops->dev_xstats_reset(dev, ids, nb_ids);
576 : : }
577 : :
578 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_selftest, 20.08)
579 : : int
580 : 0 : rte_regexdev_selftest(uint8_t dev_id)
581 : : {
582 : : struct rte_regexdev *dev;
583 : :
584 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
585 : 0 : dev = &rte_regex_devices[dev_id];
586 [ # # ]: 0 : if (dev->dev_ops->dev_selftest == NULL)
587 : : return -ENOTSUP;
588 : 0 : return dev->dev_ops->dev_selftest(dev);
589 : : }
590 : :
591 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_regexdev_dump, 20.08)
592 : : int
593 : 0 : rte_regexdev_dump(uint8_t dev_id, FILE *f)
594 : : {
595 : : struct rte_regexdev *dev;
596 : :
597 [ # # ]: 0 : RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL);
598 : 0 : dev = &rte_regex_devices[dev_id];
599 [ # # ]: 0 : if (dev->dev_ops->dev_dump == NULL)
600 : : return -ENOTSUP;
601 [ # # ]: 0 : if (f == NULL) {
602 : 0 : RTE_REGEXDEV_LOG_LINE(ERR, "Dev %d file can't be NULL", dev_id);
603 : 0 : return -EINVAL;
604 : : }
605 : 0 : return dev->dev_ops->dev_dump(dev, f);
606 : : }
|
