From f66967d21878ceada957d1aa02b931424f066c18 Mon Sep 17 00:00:00 2001 From: Ori Kam Date: Mon, 6 Jul 2020 17:36:49 +0000 Subject: [PATCH] regexdev: implement API functions This commit implements all the RegEx public API. Signed-off-by: Ori Kam Acked-by: Guy Kaneti --- config/common_base | 1 + lib/librte_regexdev/rte_regexdev.c | 437 +++++++++++++++++++++++- lib/librte_regexdev/rte_regexdev.h | 59 +++- lib/librte_regexdev/rte_regexdev_core.h | 9 + 4 files changed, 496 insertions(+), 10 deletions(-) diff --git a/config/common_base b/config/common_base index 87469d3852..cc9d034bef 100644 --- a/config/common_base +++ b/config/common_base @@ -739,6 +739,7 @@ CONFIG_RTE_LIBRTE_PMD_ZLIB=n # Compile RegEx device support # CONFIG_RTE_LIBRTE_REGEXDEV=y +CONFIG_RTE_LIBRTE_REGEXDEV_DEBUG=n CONFIG_RTE_MAX_REGEXDEV_DEVS=32 # diff --git a/lib/librte_regexdev/rte_regexdev.c b/lib/librte_regexdev/rte_regexdev.c index 3f112ff2e3..04ab713730 100644 --- a/lib/librte_regexdev/rte_regexdev.c +++ b/lib/librte_regexdev/rte_regexdev.c @@ -15,7 +15,7 @@ #include "rte_regexdev_driver.h" static const char *MZ_RTE_REGEXDEV_DATA = "rte_regexdev_data"; -static struct rte_regexdev regex_devices[RTE_MAX_REGEXDEV_DEVS]; +struct rte_regexdev rte_regex_devices[RTE_MAX_REGEXDEV_DEVS]; /* Shared memory between primary and secondary processes. */ static struct { struct rte_regexdev_data data[RTE_MAX_REGEXDEV_DEVS]; @@ -29,7 +29,7 @@ regexdev_find_free_dev(void) uint16_t i; for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) { - if (regex_devices[i].state == RTE_REGEXDEV_UNUSED) + if (rte_regex_devices[i].state == RTE_REGEXDEV_UNUSED) return i; } return RTE_MAX_REGEXDEV_DEVS; @@ -41,9 +41,9 @@ regexdev_allocated(const char *name) uint16_t i; for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) { - if (regex_devices[i].state != RTE_REGEXDEV_UNUSED) - if (!strcmp(name, regex_devices[i].data->dev_name)) - return ®ex_devices[i]; + if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED) + if (!strcmp(name, rte_regex_devices[i].data->dev_name)) + return &rte_regex_devices[i]; } return NULL; } @@ -117,7 +117,7 @@ rte_regexdev_register(const char *name) return NULL; } - dev = ®ex_devices[dev_id]; + dev = &rte_regex_devices[dev_id]; dev->state = RTE_REGEXDEV_REGISTERED; if (dev->data == NULL) dev->data = &rte_regexdev_shared_data->data[dev_id]; @@ -141,3 +141,428 @@ rte_regexdev_get_device_by_name(const char *name) return NULL; return regexdev_allocated(name); } + +uint8_t +rte_regexdev_count(void) +{ + int i; + int count = 0; + + for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) { + if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED) + count++; + } + return count; +} + +int +rte_regexdev_get_dev_id(const char *name) +{ + int i; + int id = -EINVAL; + + if (name == NULL) + return -EINVAL; + for (i = 0; i < RTE_MAX_REGEXDEV_DEVS; i++) { + if (rte_regex_devices[i].state != RTE_REGEXDEV_UNUSED) + if (strcmp(name, rte_regex_devices[i].data->dev_name)) { + id = rte_regex_devices[i].data->dev_id; + break; + } + } + return id; +} + +int +rte_regexdev_is_valid_dev(uint16_t dev_id) +{ + if (dev_id >= RTE_MAX_REGEXDEV_DEVS || + rte_regex_devices[dev_id].state != RTE_REGEXDEV_READY) + return 0; + return 1; +} + +static int +regexdev_info_get(uint8_t dev_id, struct rte_regexdev_info *dev_info) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + if (dev_info == NULL) + return -EINVAL; + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_info_get, -ENOTSUP); + return (*dev->dev_ops->dev_info_get)(dev, dev_info); + +} + +int +rte_regexdev_info_get(uint8_t dev_id, struct rte_regexdev_info *dev_info) +{ + return regexdev_info_get(dev_id, dev_info); +} + +int +rte_regexdev_configure(uint8_t dev_id, const struct rte_regexdev_config *cfg) +{ + struct rte_regexdev *dev; + struct rte_regexdev_info dev_info; + int ret; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + if (cfg == NULL) + return -EINVAL; + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP); + if (dev->data->dev_started) { + RTE_REGEXDEV_LOG + (ERR, "Dev %u must be stopped to allow configuration\n", + dev_id); + return -EBUSY; + } + ret = regexdev_info_get(dev_id, &dev_info); + if (ret < 0) + return ret; + if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_CROSS_BUFFER_SCAN_F) && + !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_CROSS_BUFFER_F)) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u doesn't support cross buffer scan\n", + dev_id); + return -EINVAL; + } + if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_MATCH_AS_END_F) && + !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_MATCH_AS_END_F)) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u doesn't support match as end\n", + dev_id); + return -EINVAL; + } + if ((cfg->dev_cfg_flags & RTE_REGEXDEV_CFG_MATCH_ALL_F) && + !(dev_info.regexdev_capa & RTE_REGEXDEV_SUPP_MATCH_ALL_F)) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u doesn't support match all\n", + dev_id); + return -EINVAL; + } + if (cfg->nb_groups == 0) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of groups must be > 0\n", + dev_id); + return -EINVAL; + } + if (cfg->nb_groups > dev_info.max_groups) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of groups %d > %d\n", + dev_id, cfg->nb_groups, dev_info.max_groups); + return -EINVAL; + } + if (cfg->nb_max_matches == 0) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of matches must be > 0\n", + dev_id); + return -EINVAL; + } + if (cfg->nb_max_matches > dev_info.max_matches) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of matches %d > %d\n", + dev_id, cfg->nb_max_matches, + dev_info.max_matches); + return -EINVAL; + } + if (cfg->nb_queue_pairs == 0) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of queues must be > 0\n", + dev_id); + return -EINVAL; + } + if (cfg->nb_queue_pairs > dev_info.max_queue_pairs) { + RTE_REGEXDEV_LOG(ERR, "Dev %u num of queues %d > %d\n", + dev_id, cfg->nb_queue_pairs, + dev_info.max_queue_pairs); + return -EINVAL; + } + if (cfg->nb_rules_per_group == 0) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u num of rules per group must be > 0\n", + dev_id); + return -EINVAL; + } + if (cfg->nb_rules_per_group > dev_info.max_rules_per_group) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u num of rules per group %d > %d\n", + dev_id, cfg->nb_rules_per_group, + dev_info.max_rules_per_group); + return -EINVAL; + } + ret = (*dev->dev_ops->dev_configure)(dev, cfg); + if (ret == 0) + dev->data->dev_conf = *cfg; + return ret; +} + +int +rte_regexdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id, + const struct rte_regexdev_qp_conf *qp_conf) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_qp_setup, -ENOTSUP); + if (dev->data->dev_started) { + RTE_REGEXDEV_LOG + (ERR, "Dev %u must be stopped to allow configuration\n", + dev_id); + return -EBUSY; + } + if (queue_pair_id >= dev->data->dev_conf.nb_queue_pairs) { + RTE_REGEXDEV_LOG(ERR, + "Dev %u invalid queue %d > %d\n", + dev_id, queue_pair_id, + dev->data->dev_conf.nb_queue_pairs); + return -EINVAL; + } + if (dev->data->dev_started) { + RTE_REGEXDEV_LOG + (ERR, "Dev %u must be stopped to allow configuration\n", + dev_id); + return -EBUSY; + } + return (*dev->dev_ops->dev_qp_setup)(dev, queue_pair_id, qp_conf); +} + +int +rte_regexdev_start(uint8_t dev_id) +{ + struct rte_regexdev *dev; + int ret; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP); + ret = (*dev->dev_ops->dev_start)(dev); + if (ret == 0) + dev->data->dev_started = 1; + return ret; +} + +int +rte_regexdev_stop(uint8_t dev_id) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_stop, -ENOTSUP); + (*dev->dev_ops->dev_stop)(dev); + dev->data->dev_started = 0; + return 0; +} + +int +rte_regexdev_close(uint8_t dev_id) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP); + (*dev->dev_ops->dev_close)(dev); + dev->data->dev_started = 0; + dev->state = RTE_REGEXDEV_UNUSED; + return 0; +} + +int +rte_regexdev_attr_get(uint8_t dev_id, enum rte_regexdev_attr_id attr_id, + void *attr_value) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_attr_get, -ENOTSUP); + if (attr_value == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d attribute value can't be NULL\n", + dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_attr_get)(dev, attr_id, attr_value); +} + +int +rte_regexdev_attr_set(uint8_t dev_id, enum rte_regexdev_attr_id attr_id, + const void *attr_value) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_attr_set, -ENOTSUP); + if (attr_value == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d attribute value can't be NULL\n", + dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_attr_set)(dev, attr_id, attr_value); +} + +int +rte_regexdev_rule_db_update(uint8_t dev_id, + const struct rte_regexdev_rule *rules, + uint32_t nb_rules) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_rule_db_update, -ENOTSUP); + if (rules == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d rules can't be NULL\n", + dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_rule_db_update)(dev, rules, nb_rules); +} + +int +rte_regexdev_rule_db_compile_activate(uint8_t dev_id) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_rule_db_compile_activate, + -ENOTSUP); + return (*dev->dev_ops->dev_rule_db_compile_activate)(dev); +} + +int +rte_regexdev_rule_db_import(uint8_t dev_id, const char *rule_db, + uint32_t rule_db_len) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_db_import, + -ENOTSUP); + if (rule_db == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d rules can't be NULL\n", + dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_db_import)(dev, rule_db, rule_db_len); +} + +int +rte_regexdev_rule_db_export(uint8_t dev_id, char *rule_db) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_db_export, + -ENOTSUP); + return (*dev->dev_ops->dev_db_export)(dev, rule_db); +} + +int +rte_regexdev_xstats_names_get(uint8_t dev_id, + struct rte_regexdev_xstats_map *xstats_map) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_xstats_names_get, + -ENOTSUP); + if (xstats_map == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d xstats map can't be NULL\n", + dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_xstats_names_get)(dev, xstats_map); +} + +int +rte_regexdev_xstats_get(uint8_t dev_id, const uint16_t *ids, + uint64_t *values, uint16_t n) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_xstats_get, -ENOTSUP); + if (ids == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d ids can't be NULL\n", dev_id); + return -EINVAL; + } + if (values == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d values can't be NULL\n", dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_xstats_get)(dev, ids, values, n); +} + +int +rte_regexdev_xstats_by_name_get(uint8_t dev_id, const char *name, + uint16_t *id, uint64_t *value) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_xstats_by_name_get, + -ENOTSUP); + if (name == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d name can't be NULL\n", dev_id); + return -EINVAL; + } + if (id == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d id can't be NULL\n", dev_id); + return -EINVAL; + } + if (value == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d value can't be NULL\n", dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_xstats_by_name_get)(dev, name, id, value); +} + +int +rte_regexdev_xstats_reset(uint8_t dev_id, const uint16_t *ids, + uint16_t nb_ids) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_xstats_reset, -ENOTSUP); + if (ids == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d ids can't be NULL\n", dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_xstats_reset)(dev, ids, nb_ids); +} + +int +rte_regexdev_selftest(uint8_t dev_id) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_selftest, -ENOTSUP); + return (*dev->dev_ops->dev_selftest)(dev); +} + +int +rte_regexdev_dump(uint8_t dev_id, FILE *f) +{ + struct rte_regexdev *dev; + + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + dev = &rte_regex_devices[dev_id]; + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_dump, -ENOTSUP); + if (f == NULL) { + RTE_REGEXDEV_LOG(ERR, "Dev %d file can't be NULL\n", dev_id); + return -EINVAL; + } + return (*dev->dev_ops->dev_dump)(dev, f); +} diff --git a/lib/librte_regexdev/rte_regexdev.h b/lib/librte_regexdev/rte_regexdev.h index 5e7a653fe0..4077e62c95 100644 --- a/lib/librte_regexdev/rte_regexdev.h +++ b/lib/librte_regexdev/rte_regexdev.h @@ -212,6 +212,33 @@ extern int rte_regexdev_logtype; #define RTE_REGEXDEV_LOG(level, ...) \ rte_log(RTE_LOG_ ## level, rte_regexdev_logtype, "" __VA_ARGS__) +/* Macros to check for valid port */ +#define RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, retval) do { \ + if (!rte_regexdev_is_valid_dev(dev_id)) { \ + RTE_REGEXDEV_LOG(ERR, "Invalid dev_id=%u\n", dev_id); \ + return retval; \ + } \ +} while (0) + +#define RTE_REGEXDEV_VALID_DEV_ID_OR_RET(dev_id) do { \ + if (!rte_regexdev_is_valid_dev(dev_id)) { \ + RTE_REGEXDEV_LOG(ERR, "Invalid dev_id=%u\n", dev_id); \ + return; \ + } \ +} while (0) + +/** + * Check if dev_id is ready. + * + * @param dev_id + * The dev identifier of the RegEx device. + * + * @return + * - 0 if device state is not in ready state. + * - 1 if device state is ready state. + */ +int rte_regexdev_is_valid_dev(uint16_t dev_id); + /** * @warning * @b EXPERIMENTAL: this API may change without prior notice. @@ -1424,9 +1451,21 @@ struct rte_regex_ops { * to take care of them. */ __rte_experimental -uint16_t +static inline uint16_t rte_regexdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id, - struct rte_regex_ops **ops, uint16_t nb_ops); + struct rte_regex_ops **ops, uint16_t nb_ops) +{ + struct rte_regexdev *dev = &rte_regex_devices[dev_id]; +#ifdef RTE_LIBRTE_REGEXDEV_DEBUG + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + RTE_FUNC_PTR_OR_ERR_RET(*dev->enqueue, -ENOTSUP); + if (qp_id >= dev->data->dev_conf.nb_queue_pairs) { + RTE_REGEXDEV_LOG(ERR, "Invalid queue %d\n", qp_id); + return -EINVAL; + } +#endif + return (*dev->enqueue)(dev, qp_id, ops, nb_ops); +} /** * @warning @@ -1471,9 +1510,21 @@ rte_regexdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id, * of them. */ __rte_experimental -uint16_t +static inline uint16_t rte_regexdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id, - struct rte_regex_ops **ops, uint16_t nb_ops); + struct rte_regex_ops **ops, uint16_t nb_ops) +{ + struct rte_regexdev *dev = &rte_regex_devices[dev_id]; +#ifdef RTE_LIBRTE_REGEXDEV_DEBUG + RTE_REGEXDEV_VALID_DEV_ID_OR_ERR_RET(dev_id, -EINVAL); + RTE_FUNC_PTR_OR_ERR_RET(*dev->dequeue, -ENOTSUP); + if (qp_id >= dev->data->dev_conf.nb_queue_pairs) { + RTE_REGEXDEV_LOG(ERR, "Invalid queue %d\n", qp_id); + return -EINVAL; + } +#endif + return (*dev->dequeue)(dev, qp_id, ops, nb_ops); +} #ifdef __cplusplus } diff --git a/lib/librte_regexdev/rte_regexdev_core.h b/lib/librte_regexdev/rte_regexdev_core.h index 6179617533..a5576d353f 100644 --- a/lib/librte_regexdev/rte_regexdev_core.h +++ b/lib/librte_regexdev/rte_regexdev_core.h @@ -149,6 +149,8 @@ struct rte_regexdev_data { void *dev_private; /**< PMD-specific private data. */ char dev_name[RTE_REGEXDEV_NAME_MAX_LEN]; /**< Unique identifier name */ uint16_t dev_id; /**< Device [external] identifier. */ + struct rte_regexdev_config dev_conf; /**< RegEx configuration. */ + uint8_t dev_started : 1; /**< Device started to work. */ } __rte_cache_aligned; /** @@ -171,4 +173,11 @@ struct rte_regexdev { struct rte_regexdev_data *data; /**< Pointer to device data. */ } __rte_cache_aligned; +/** + * @internal + * The pool of *rte_regexdev* structures. The size of the pool + * is configured at compile-time in the file. + */ +extern struct rte_regexdev rte_regex_devices[]; + #endif /* _RTE_REGEX_CORE_H_ */ -- 2.20.1