[RFC 3/7] regex/hs: add rule database update and compilation

[Prudvi Deti <prudvi.deti@intel.com>]

Implement rule_db_update, rule_db_compile_activate, db_import, and
db_export.

rule_db_update supports ADD and REMOVE operations with O(1) duplicate
detection via rte_hash. Extended parameters (min_offset, max_offset)
are extracted from rule_flags bits 37-63.

Compilation uses hs_compile_ext_multi() with per-rule extended
parameter support. Per-QP scratch is allocated with rollback on
partial failure.

The configure path optionally imports a serialized database when
cfg->rule_db is provided.

Signed-off-by: Prudvi Deti <prudvi.deti@intel.com>
---
 drivers/regex/hs/hs_regex.c | 404 +++++++++++++++++++++++++++++++++++-
 drivers/regex/hs/hs_regex.h |  11 +
 2 files changed, 414 insertions(+), 1 deletion(-)

diff --git a/drivers/regex/hs/hs_regex.c b/drivers/regex/hs/hs_regex.c
index afe00b5..116aff9 100644
--- a/drivers/regex/hs/hs_regex.c
+++ b/drivers/regex/hs/hs_regex.c
@@ -39,6 +39,10 @@ RTE_LOG_REGISTER_DEFAULT(hs_regex_logtype, NOTICE);
 #define HS_LOG(level, ...) \
 	RTE_LOG_LINE(level, HS_REGEX, __VA_ARGS__)
 
+static int
+hs_regex_rule_db_import(struct rte_regexdev *dev, const char *rule_db,
+			uint32_t rule_db_len);
+
 /* Device Info */
 static int
 hs_regex_info_get(struct rte_regexdev *dev __rte_unused,
@@ -66,6 +70,7 @@ hs_regex_configure(struct rte_regexdev *dev,
 		   const struct rte_regexdev_config *cfg)
 {
 	struct hs_regex_priv *priv;
+	int ret;
 
 	if (dev == NULL || cfg == NULL)
 		return -EINVAL;
@@ -92,7 +97,6 @@ hs_regex_configure(struct rte_regexdev *dev,
 
 	if (priv->rules) {
 		uint32_t i;
-
 		for (i = 0; i < priv->nb_rules; i++)
 			rte_free(priv->rules[i].pattern);
 		rte_free(priv->rules);
@@ -100,6 +104,10 @@ hs_regex_configure(struct rte_regexdev *dev,
 		priv->nb_rules = 0;
 		priv->rules_cap = 0;
 	}
+	if (priv->rule_id_hash) {
+		rte_hash_free(priv->rule_id_hash);
+		priv->rule_id_hash = NULL;
+	}
 	if (priv->db) {
 		hs_free_database(priv->db);
 		priv->db = NULL;
@@ -126,6 +134,20 @@ hs_regex_configure(struct rte_regexdev *dev,
 	       priv->nb_queue_pairs, priv->max_matches);
 
 	priv->dev_state = HS_REGEX_DEV_CONFIGURED;
+
+	if (cfg->rule_db != NULL && cfg->rule_db_len > 0) {
+		ret = hs_regex_rule_db_import(dev, cfg->rule_db,
+					     cfg->rule_db_len);
+		if (ret < 0) {
+			HS_LOG(ERR, "Failed to import rule DB in configure");
+			rte_free(priv->qps);
+			priv->qps = NULL;
+			priv->nb_queue_pairs = 0;
+			priv->dev_state = HS_REGEX_DEV_CREATED;
+			return ret;
+		}
+	}
+
 	return 0;
 }
 
@@ -211,6 +233,382 @@ hs_regex_qp_setup(struct rte_regexdev *dev, uint16_t qp_id,
 	return 0;
 }
 
+/* Rule Database Update */
+static int
+hs_regex_rule_db_update(struct rte_regexdev *dev,
+			const struct rte_regexdev_rule *rules,
+			uint16_t nb_rules)
+{
+	struct hs_regex_priv *priv;
+	uint64_t rf;
+	uint16_t i;
+
+	if (dev == NULL || rules == NULL)
+		return -EINVAL;
+
+	priv = dev->data->dev_private;
+	if (priv == NULL)
+		return -EINVAL;
+
+	if (nb_rules == 0)
+		return 0;
+
+	if (!priv->rule_id_hash) {
+		struct rte_hash_parameters hp = {
+			.name = "hs_rule_ids",
+			.entries = HS_REGEX_MAX_RULES,
+			.key_len = sizeof(uint32_t),
+			.socket_id = SOCKET_ID_ANY,
+		};
+		priv->rule_id_hash = rte_hash_create(&hp);
+		if (!priv->rule_id_hash) {
+			HS_LOG(ERR, "Failed to create rule_id hash");
+			return -ENOMEM;
+		}
+	}
+
+	for (i = 0; i < nb_rules; i++) {
+		if (rules[i].op == RTE_REGEX_RULE_OP_ADD) {
+			uint32_t idx;
+
+			if (!rules[i].pcre_rule || rules[i].pcre_rule_len == 0) {
+				HS_LOG(ERR, "Rule %u: NULL or empty pattern",
+				       rules[i].rule_id);
+				rte_errno = EINVAL;
+				return i;
+			}
+
+			if (priv->rule_id_hash &&
+			    rte_hash_lookup(priv->rule_id_hash,
+					   &rules[i].rule_id) >= 0) {
+				HS_LOG(ERR, "Rule %u: duplicate rule_id",
+				       rules[i].rule_id);
+				rte_errno = EINVAL;
+				return i;
+			}
+
+			if (priv->nb_rules >= HS_REGEX_MAX_RULES) {
+				HS_LOG(ERR, "Rule limit reached (%u)",
+				       HS_REGEX_MAX_RULES);
+				rte_errno = ENOSPC;
+				return i;
+			}
+
+			if (priv->nb_rules >= priv->rules_cap) {
+				uint32_t new_cap = priv->rules_cap ?
+					priv->rules_cap * 2 :
+					HS_REGEX_INITIAL_RULES_CAP;
+				struct hs_regex_rule *tmp = rte_realloc(
+					priv->rules,
+					new_cap * sizeof(struct hs_regex_rule), 0);
+				if (!tmp) {
+					HS_LOG(ERR, "Failed to grow rules");
+					rte_errno = ENOMEM;
+					return i;
+				}
+				priv->rules = tmp;
+				priv->rules_cap = new_cap;
+			}
+
+			idx = priv->nb_rules;
+
+			priv->rules[idx].pattern = rte_malloc("hs_pattern",
+				rules[i].pcre_rule_len + 1, 0);
+			if (!priv->rules[idx].pattern) {
+				rte_errno = ENOMEM;
+				return i;
+			}
+			memcpy(priv->rules[idx].pattern,
+			       rules[i].pcre_rule, rules[i].pcre_rule_len);
+			priv->rules[idx].pattern[rules[i].pcre_rule_len] = '\0';
+
+			priv->rules[idx].rule_id = rules[i].rule_id;
+			priv->rules[idx].group_id = rules[i].group_id;
+			priv->rules[idx].rule_flags = rules[i].rule_flags;
+
+			rf = rules[i].rule_flags;
+			priv->rules[idx].max_offset =
+				(rf >> HS_REGEX_EXT_MAX_OFFSET_SHIFT) &
+				HS_REGEX_EXT_MAX_OFFSET_MASK;
+			priv->rules[idx].min_offset =
+				(rf >> HS_REGEX_EXT_MIN_OFFSET_SHIFT) &
+				HS_REGEX_EXT_MIN_OFFSET_MASK;
+			priv->rules[idx].min_length = 0;
+
+			priv->nb_rules++;
+
+			if (priv->rule_id_hash)
+				rte_hash_add_key(priv->rule_id_hash,
+						 &rules[i].rule_id);
+
+		} else if (rules[i].op == RTE_REGEX_RULE_OP_REMOVE) {
+			uint32_t j;
+
+			if (priv->rule_id_hash)
+				rte_hash_del_key(priv->rule_id_hash,
+						 &rules[i].rule_id);
+
+			for (j = 0; j < priv->nb_rules; j++) {
+				if (priv->rules[j].rule_id !=
+				    rules[i].rule_id)
+					continue;
+				rte_free(priv->rules[j].pattern);
+				memmove(&priv->rules[j], &priv->rules[j + 1],
+					(priv->nb_rules - j - 1) *
+					sizeof(struct hs_regex_rule));
+				priv->nb_rules--;
+				break;
+			}
+		}
+	}
+
+	priv->db_compiled = 0;
+	HS_LOG(INFO, "Rule DB updated: %u total rules", priv->nb_rules);
+	return nb_rules;
+}
+
+/* Compile and Activate */
+static int
+hs_regex_rule_db_compile_activate(struct rte_regexdev *dev)
+{
+	struct hs_regex_priv *priv;
+	hs_compile_error_t *compile_err = NULL;
+	hs_error_t err;
+	const char **expressions;
+	unsigned int *flags;
+	unsigned int *ids;
+	hs_expr_ext_t *ext;
+	const hs_expr_ext_t **ext_ptrs;
+	uint32_t i;
+
+	if (dev == NULL)
+		return -EINVAL;
+
+	priv = dev->data->dev_private;
+	if (priv == NULL)
+		return -EINVAL;
+
+	if (priv->nb_rules == 0) {
+		HS_LOG(ERR, "No rules to compile");
+		return -EINVAL;
+	}
+
+	if (priv->qps == NULL) {
+		HS_LOG(ERR, "Cannot compile: queue pairs not allocated");
+		return -EINVAL;
+	}
+
+	if (priv->db) {
+		hs_free_database(priv->db);
+		priv->db = NULL;
+	}
+
+	expressions = rte_malloc("hs_expr",
+				 sizeof(char *) * priv->nb_rules, 0);
+	flags = rte_malloc("hs_flags",
+			   sizeof(unsigned int) * priv->nb_rules, 0);
+	ids = rte_malloc("hs_ids",
+			 sizeof(unsigned int) * priv->nb_rules, 0);
+	ext = rte_zmalloc("hs_ext",
+			  sizeof(hs_expr_ext_t) * priv->nb_rules, 0);
+	ext_ptrs = rte_malloc("hs_ext_ptrs",
+			      sizeof(hs_expr_ext_t *) * priv->nb_rules, 0);
+
+	if (!expressions || !flags || !ids || !ext || !ext_ptrs) {
+		rte_free(expressions);
+		rte_free(flags);
+		rte_free(ids);
+		rte_free(ext);
+		rte_free(ext_ptrs);
+		return -ENOMEM;
+	}
+
+	for (i = 0; i < priv->nb_rules; i++) {
+		expressions[i] = priv->rules[i].pattern;
+		ids[i] = priv->rules[i].rule_id;
+
+		flags[i] = 0;
+		if (priv->rules[i].rule_flags & RTE_REGEX_PCRE_RULE_CASELESS_F)
+			flags[i] |= HS_FLAG_CASELESS;
+		if (priv->rules[i].rule_flags & RTE_REGEX_PCRE_RULE_DOTALL_F)
+			flags[i] |= HS_FLAG_DOTALL;
+		if (priv->rules[i].rule_flags & RTE_REGEX_PCRE_RULE_MULTILINE_F)
+			flags[i] |= HS_FLAG_MULTILINE;
+		if (priv->rules[i].rule_flags & RTE_REGEX_PCRE_RULE_UTF_F)
+			flags[i] |= HS_FLAG_UTF8;
+
+		ext[i].flags = 0;
+		if (priv->rules[i].min_offset) {
+			ext[i].flags |= HS_EXT_FLAG_MIN_OFFSET;
+			ext[i].min_offset = priv->rules[i].min_offset;
+		}
+		if (priv->rules[i].max_offset) {
+			ext[i].flags |= HS_EXT_FLAG_MAX_OFFSET;
+			ext[i].max_offset = priv->rules[i].max_offset;
+		}
+		if (priv->rules[i].min_length) {
+			ext[i].flags |= HS_EXT_FLAG_MIN_LENGTH;
+			ext[i].min_length = priv->rules[i].min_length;
+		}
+		ext_ptrs[i] = &ext[i];
+	}
+
+	err = hs_compile_ext_multi(expressions, flags, ids, ext_ptrs,
+				   priv->nb_rules, HS_MODE_BLOCK, NULL,
+				   &priv->db, &compile_err);
+
+	rte_free(expressions);
+	rte_free(flags);
+	rte_free(ids);
+	rte_free(ext);
+	rte_free(ext_ptrs);
+
+	if (err != HS_SUCCESS) {
+		HS_LOG(ERR, "hs_compile_ext_multi failed: %s (pattern %d)",
+		       compile_err ? compile_err->message : "unknown",
+		       compile_err ? compile_err->expression : -1);
+		if (compile_err)
+			hs_free_compile_error(compile_err);
+		return -EINVAL;
+	}
+
+	for (i = 0; i < priv->nb_queue_pairs; i++) {
+		struct hs_regex_qp *qp = &priv->qps[i];
+
+		if (qp->scratch) {
+			hs_free_scratch(qp->scratch);
+			qp->scratch = NULL;
+		}
+		err = hs_alloc_scratch(priv->db, &qp->scratch);
+		if (err != HS_SUCCESS) {
+			uint32_t j;
+
+			HS_LOG(ERR, "Scratch alloc failed for qp %u", i);
+			for (j = 0; j < i; j++) {
+				if (priv->qps[j].scratch) {
+					hs_free_scratch(priv->qps[j].scratch);
+					priv->qps[j].scratch = NULL;
+				}
+			}
+			hs_free_database(priv->db);
+			priv->db = NULL;
+			return -ENOMEM;
+		}
+	}
+
+	priv->db_compiled = 1;
+	HS_LOG(INFO, "Compiled %u rules into Hyperscan database",
+	       priv->nb_rules);
+	return 0;
+}
+
+static int
+hs_regex_rule_db_import(struct rte_regexdev *dev, const char *rule_db,
+			uint32_t rule_db_len)
+{
+	struct hs_regex_priv *priv;
+	hs_error_t err;
+	uint32_t i;
+
+	if (dev == NULL)
+		return -EINVAL;
+
+	priv = dev->data->dev_private;
+	if (priv == NULL)
+		return -EINVAL;
+
+	if (!rule_db || rule_db_len == 0) {
+		HS_LOG(ERR, "Invalid rule_db pointer or length");
+		return -EINVAL;
+	}
+
+	if (priv->qps == NULL) {
+		HS_LOG(ERR, "Cannot import: queue pairs not allocated");
+		return -EINVAL;
+	}
+
+	if (priv->db) {
+		hs_free_database(priv->db);
+		priv->db = NULL;
+	}
+
+	err = hs_deserialize_database(rule_db, (size_t)rule_db_len, &priv->db);
+	if (err != HS_SUCCESS) {
+		HS_LOG(ERR, "hs_deserialize_database failed (error %d)", err);
+		return -EINVAL;
+	}
+
+	for (i = 0; i < priv->nb_queue_pairs; i++) {
+		struct hs_regex_qp *qp = &priv->qps[i];
+
+		if (qp->scratch) {
+			hs_free_scratch(qp->scratch);
+			qp->scratch = NULL;
+		}
+		err = hs_alloc_scratch(priv->db, &qp->scratch);
+		if (err != HS_SUCCESS) {
+			uint32_t j;
+
+			HS_LOG(ERR, "Scratch alloc failed for qp %u"
+			       " after import", i);
+			for (j = 0; j < i; j++) {
+				if (priv->qps[j].scratch) {
+					hs_free_scratch(priv->qps[j].scratch);
+					priv->qps[j].scratch = NULL;
+				}
+			}
+			hs_free_database(priv->db);
+			priv->db = NULL;
+			return -ENOMEM;
+		}
+	}
+
+	priv->db_compiled = 1;
+	HS_LOG(INFO, "Imported serialized Hyperscan database (%u bytes)",
+	       rule_db_len);
+	return 0;
+}
+
+static int
+hs_regex_rule_db_export(struct rte_regexdev *dev, char *rule_db)
+{
+	struct hs_regex_priv *priv;
+	hs_error_t err;
+	char *buf;
+	size_t len;
+
+	if (dev == NULL)
+		return -EINVAL;
+
+	priv = dev->data->dev_private;
+	if (priv == NULL)
+		return -EINVAL;
+
+	if (!priv->db) {
+		HS_LOG(ERR, "No database to export");
+		return -EINVAL;
+	}
+
+	err = hs_serialize_database(priv->db, &buf, &len);
+	if (err != HS_SUCCESS) {
+		HS_LOG(ERR, "hs_serialize_database failed (error %d)", err);
+		return -EIO;
+	}
+
+	if (rule_db == NULL) {
+		free(buf);
+		if (len > INT_MAX) {
+			HS_LOG(ERR, "Serialized DB too large (%zu bytes)", len);
+			return -EOVERFLOW;
+		}
+		return (int)len;
+	}
+
+	memcpy(rule_db, buf, len);
+	free(buf);
+	return 0;
+}
+
 /* Fast path stubs replaced by real implementations in later patches. */
 
 static uint16_t
@@ -235,6 +633,10 @@ static const struct rte_regexdev_ops hs_regexdev_ops = {
 	.dev_info_get = hs_regex_info_get,
 	.dev_configure = hs_regex_configure,
 	.dev_qp_setup = hs_regex_qp_setup,
+	.dev_rule_db_update = hs_regex_rule_db_update,
+	.dev_rule_db_compile_activate = hs_regex_rule_db_compile_activate,
+	.dev_db_import = hs_regex_rule_db_import,
+	.dev_db_export = hs_regex_rule_db_export,
 };
 
 /* Device Lifecycle */
diff --git a/drivers/regex/hs/hs_regex.h b/drivers/regex/hs/hs_regex.h
index be4c2e9..ddd6d9b 100644
--- a/drivers/regex/hs/hs_regex.h
+++ b/drivers/regex/hs/hs_regex.h
@@ -6,6 +6,7 @@
 #define HS_REGEX_H
 
 #include <rte_regexdev.h>
+#include <rte_hash.h>
 #include <hs/hs.h>
 
 #define HS_REGEX_DRIVER_NAME "regex_hs"
@@ -16,6 +17,12 @@
 #define HS_REGEX_DEFAULT_NB_DESC 1024
 #define HS_REGEX_MAX_NB_DESC 32768
 
+/* Ext params encoded in rule_flags bits 37-63 */
+#define HS_REGEX_EXT_MAX_OFFSET_SHIFT 37
+#define HS_REGEX_EXT_MAX_OFFSET_MASK  0x1FFFULL
+#define HS_REGEX_EXT_MIN_OFFSET_SHIFT 50
+#define HS_REGEX_EXT_MIN_OFFSET_MASK  0x3FFFULL
+
 /* Device lifecycle state machine. */
 enum hs_regex_dev_state {
 	HS_REGEX_DEV_CREATED = 0,
@@ -30,6 +37,9 @@ struct hs_regex_rule {
 	uint32_t rule_id;
 	uint16_t group_id;
 	uint64_t rule_flags;
+	uint64_t min_offset;
+	uint64_t max_offset;
+	uint64_t min_length;
 };
 
 /* Queue pair */
@@ -48,6 +58,7 @@ struct hs_regex_qp {
 /* Per-device private data */
 struct hs_regex_priv {
 	struct hs_regex_rule *rules;
+	struct rte_hash *rule_id_hash;
 	uint32_t nb_rules;
 	uint32_t rules_cap;
 
-- 
2.43.0