[dpdk-dev] [PATCH 08/10] rte_lpm: make lpm tailq fully local

[Anatoly Burakov]

Signed-off-by: Anatoly Burakov <anatoly.burakov at intel.com>
---
 lib/librte_lpm/rte_lpm.c | 65 ++++++++++++++++++++++++++++++++++++++++--------
 lib/librte_lpm/rte_lpm.h |  2 --
 2 files changed, 54 insertions(+), 13 deletions(-)

diff --git a/lib/librte_lpm/rte_lpm.c b/lib/librte_lpm/rte_lpm.c
index 35209c3..1ee4e96 100644
--- a/lib/librte_lpm/rte_lpm.c
+++ b/lib/librte_lpm/rte_lpm.c
@@ -56,7 +56,7 @@

 #include "rte_lpm.h"

-TAILQ_HEAD(rte_lpm_list, rte_lpm);
+TAILQ_HEAD(rte_lpm_list, rte_tailq_entry);

 #define MAX_DEPTH_TBL24 24

@@ -118,24 +118,29 @@ depth_to_range(uint8_t depth)
 struct rte_lpm *
 rte_lpm_find_existing(const char *name)
 {
-       struct rte_lpm *l;
+       struct rte_lpm *l = NULL;
+       struct rte_tailq_entry *te;
        struct rte_lpm_list *lpm_list;

        /* check that we have an initialised tail queue */
-       if ((lpm_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_LPM, rte_lpm_list)) 
== NULL) {
+       if ((lpm_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_LPM,
+                       rte_lpm_list)) == NULL) {
                rte_errno = E_RTE_NO_TAILQ;
                return NULL;
        }

        rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
-       TAILQ_FOREACH(l, lpm_list, next) {
+       TAILQ_FOREACH(te, lpm_list, next) {
+               l = (struct rte_lpm *) te->data;
                if (strncmp(name, l->name, RTE_LPM_NAMESIZE) == 0)
                        break;
        }
        rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);

-       if (l == NULL)
+       if (te == NULL) {
                rte_errno = ENOENT;
+               return NULL;
+       }

        return l;
 }
@@ -149,12 +154,13 @@ rte_lpm_create(const char *name, int socket_id, int 
max_rules,
 {
        char mem_name[RTE_LPM_NAMESIZE];
        struct rte_lpm *lpm = NULL;
+       struct rte_tailq_entry *te;
        uint32_t mem_size;
        struct rte_lpm_list *lpm_list;

        /* check that we have an initialised tail queue */
-       if ((lpm_list =
-            RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_LPM, rte_lpm_list)) == NULL) {
+       if ((lpm_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_LPM,
+                       rte_lpm_list)) == NULL) {
                rte_errno = E_RTE_NO_TAILQ;
                return NULL;
        }
@@ -176,18 +182,27 @@ rte_lpm_create(const char *name, int socket_id, int 
max_rules,
        rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);

        /* guarantee there's no existing */
-       TAILQ_FOREACH(lpm, lpm_list, next) {
+       TAILQ_FOREACH(te, lpm_list, next) {
+               lpm = (struct rte_lpm *) te->data;
                if (strncmp(name, lpm->name, RTE_LPM_NAMESIZE) == 0)
                        break;
        }
-       if (lpm != NULL)
+       if (te != NULL)
                goto exit;

+       /* allocate tailq entry */
+       te = rte_zmalloc("LPM_TAILQ_ENTRY", sizeof(*te), 0);
+       if (te == NULL) {
+               RTE_LOG(ERR, LPM, "Failed to allocate tailq entry\n");
+               goto exit;
+       }
+
        /* Allocate memory to store the LPM data structures. */
        lpm = (struct rte_lpm *)rte_zmalloc_socket(mem_name, mem_size,
                        CACHE_LINE_SIZE, socket_id);
        if (lpm == NULL) {
                RTE_LOG(ERR, LPM, "LPM memory allocation failed\n");
+               rte_free(te);
                goto exit;
        }

@@ -195,7 +210,9 @@ rte_lpm_create(const char *name, int socket_id, int 
max_rules,
        lpm->max_rules = max_rules;
        rte_snprintf(lpm->name, sizeof(lpm->name), "%s", name);

-       TAILQ_INSERT_TAIL(lpm_list, lpm, next);
+       te->data = (void *) lpm;
+
+       TAILQ_INSERT_TAIL(lpm_list, te, next);

 exit:
        rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
@@ -209,12 +226,38 @@ exit:
 void
 rte_lpm_free(struct rte_lpm *lpm)
 {
+       struct rte_lpm_list *lpm_list;
+       struct rte_tailq_entry *te;
+
        /* Check user arguments. */
        if (lpm == NULL)
                return;

-       RTE_EAL_TAILQ_REMOVE(RTE_TAILQ_LPM, rte_lpm_list, lpm);
+       /* check that we have an initialised tail queue */
+       if ((lpm_list =
+            RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_LPM, rte_lpm_list)) == NULL) {
+               rte_errno = E_RTE_NO_TAILQ;
+               return;
+       }
+
+       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+
+       /* find our tailq entry */
+       TAILQ_FOREACH(te, lpm_list, next) {
+               if (te->data == (void *) lpm)
+                       break;
+       }
+       if (te == NULL) {
+               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               return;
+       }
+
+       TAILQ_REMOVE(lpm_list, te, next);
+
+       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+
        rte_free(lpm);
+       rte_free(te);
 }

 /*
diff --git a/lib/librte_lpm/rte_lpm.h b/lib/librte_lpm/rte_lpm.h
index 840d871..62d7736 100644
--- a/lib/librte_lpm/rte_lpm.h
+++ b/lib/librte_lpm/rte_lpm.h
@@ -132,8 +132,6 @@ struct rte_lpm_rule_info {

 /** @internal LPM structure. */
 struct rte_lpm {
-       TAILQ_ENTRY(rte_lpm) next;      /**< Next in list. */
-
        /* LPM metadata. */
        char name[RTE_LPM_NAMESIZE];        /**< Name of the lpm. */
        int mem_location; /**< @deprecated @see RTE_LPM_HEAP and 
RTE_LPM_MEMZONE. */
-- 
1.8.1.4