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