eal: add API to lock/unlock tailq list

Currently, locking/unlocking the TAILQ list requires direct
access to the shared memory config. Add an API to do the same,
and search-and-replace all usages.

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Acked-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: David Marchand <david.marchand@redhat.com>

diff --git a/lib/librte_acl/rte_acl.c b/lib/librte_acl/rte_acl.c
index fd5bd5e..7ff11d2 100644 (file)
--- a/lib/librte_acl/rte_acl.c
+++ b/lib/librte_acl/rte_acl.c
@@ -156,13 +156,13 @@ rte_acl_find_existing(const char *name)
 
        acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, acl_list, next) {
                ctx = (struct rte_acl_ctx *) te->data;
                if (strncmp(name, ctx->name, sizeof(ctx->name)) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -182,7 +182,7 @@ rte_acl_free(struct rte_acl_ctx *ctx)
 
        acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find our tailq entry */
        TAILQ_FOREACH(te, acl_list, next) {
@@ -190,13 +190,13 @@ rte_acl_free(struct rte_acl_ctx *ctx)
                        break;
        }
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(acl_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(ctx->mem);
        rte_free(ctx);
@@ -226,7 +226,7 @@ rte_acl_create(const struct rte_acl_param *param)
        sz = sizeof(*ctx) + param->max_rule_num * param->rule_size;
 
        /* get EAL TAILQ lock. */
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* if we already have one with that name */
        TAILQ_FOREACH(te, acl_list, next) {
@@ -268,7 +268,7 @@ rte_acl_create(const struct rte_acl_param *param)
        }
 
 exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        return ctx;
 }
 
@@ -377,10 +377,10 @@ rte_acl_list_dump(void)
 
        acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, acl_list, next) {
                ctx = (struct rte_acl_ctx *) te->data;
                rte_acl_dump(ctx);
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 }

diff --git a/lib/librte_distributor/rte_distributor.c b/lib/librte_distributor/rte_distributor.c
index 208abfb..9eb78b3 100644 (file)
--- a/lib/librte_distributor/rte_distributor.c
+++ b/lib/librte_distributor/rte_distributor.c
@@ -645,9 +645,9 @@ rte_distributor_create_v1705(const char *name,
                                          rte_dist_burst_list);
 
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
        TAILQ_INSERT_TAIL(dist_burst_list, d, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return d;
 }

diff --git a/lib/librte_distributor/rte_distributor_v20.c b/lib/librte_distributor/rte_distributor_v20.c
index cd59407..1fc03b9 100644 (file)
--- a/lib/librte_distributor/rte_distributor_v20.c
+++ b/lib/librte_distributor/rte_distributor_v20.c
@@ -392,9 +392,9 @@ rte_distributor_create_v20(const char *name,
        distributor_list = RTE_TAILQ_CAST(rte_distributor_tailq.head,
                                          rte_distributor_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
        TAILQ_INSERT_TAIL(distributor_list, d, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return d;
 }

diff --git a/lib/librte_eal/common/eal_common_mcfg.c b/lib/librte_eal/common/eal_common_mcfg.c
index 985d36c..05167e4 100644 (file)
--- a/lib/librte_eal/common/eal_common_mcfg.c
+++ b/lib/librte_eal/common/eal_common_mcfg.c
@@ -32,3 +32,31 @@ rte_mcfg_mem_write_unlock(void)
        struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
        rte_rwlock_write_unlock(&mcfg->memory_hotplug_lock);
 }
+
+void
+rte_mcfg_tailq_read_lock(void)
+{
+       struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
+       rte_rwlock_read_lock(&mcfg->qlock);
+}
+
+void
+rte_mcfg_tailq_read_unlock(void)
+{
+       struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
+       rte_rwlock_read_unlock(&mcfg->qlock);
+}
+
+void
+rte_mcfg_tailq_write_lock(void)
+{
+       struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
+       rte_rwlock_write_lock(&mcfg->qlock);
+}
+
+void
+rte_mcfg_tailq_write_unlock(void)
+{
+       struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
+       rte_rwlock_write_unlock(&mcfg->qlock);
+}

diff --git a/lib/librte_eal/common/eal_common_tailqs.c b/lib/librte_eal/common/eal_common_tailqs.c
index ca2a7d3..dc2c13c 100644 (file)
--- a/lib/librte_eal/common/eal_common_tailqs.c
+++ b/lib/librte_eal/common/eal_common_tailqs.c
@@ -58,7 +58,7 @@ rte_dump_tailq(FILE *f)
 
        mcfg = rte_eal_get_configuration()->mem_config;
 
-       rte_rwlock_read_lock(&mcfg->qlock);
+       rte_mcfg_tailq_read_lock();
        for (i = 0; i < RTE_MAX_TAILQ; i++) {
                const struct rte_tailq_head *tailq = &mcfg->tailq_head[i];
                const struct rte_tailq_entry_head *head = &tailq->tailq_head;
@@ -66,7 +66,7 @@ rte_dump_tailq(FILE *f)
                fprintf(f, "Tailq %u: qname:<%s>, tqh_first:%p, tqh_last:%p\n",
                        i, tailq->name, head->tqh_first, head->tqh_last);
        }
-       rte_rwlock_read_unlock(&mcfg->qlock);
+       rte_mcfg_tailq_read_unlock();
 }
 
 static struct rte_tailq_head *

diff --git a/lib/librte_eal/common/include/rte_eal.h b/lib/librte_eal/common/include/rte_eal.h
index bf0c74e..28cbf2d 100644 (file)
--- a/lib/librte_eal/common/include/rte_eal.h
+++ b/lib/librte_eal/common/include/rte_eal.h
@@ -446,11 +446,6 @@ typedef void       (*rte_usage_hook_t)(const char * prgname);
 rte_usage_hook_t
 rte_set_application_usage_hook(rte_usage_hook_t usage_func);
 
-/**
- * macro to get the lock of tailq in mem_config
- */
-#define RTE_EAL_TAILQ_RWLOCK         (&rte_eal_get_configuration()->mem_config->qlock)
-
 /**
  * macro to get the multiple lock of mempool shared by multiple-instance
  */

diff --git a/lib/librte_eal/common/include/rte_eal_memconfig.h b/lib/librte_eal/common/include/rte_eal_memconfig.h
index a554518..240fa15 100644 (file)
--- a/lib/librte_eal/common/include/rte_eal_memconfig.h
+++ b/lib/librte_eal/common/include/rte_eal_memconfig.h
@@ -124,6 +124,30 @@ rte_mcfg_mem_write_lock(void);
 void
 rte_mcfg_mem_write_unlock(void);
 
+/**
+ * Lock the internal EAL TAILQ list for shared access.
+ */
+void
+rte_mcfg_tailq_read_lock(void);
+
+/**
+ * Unlock the internal EAL TAILQ list for shared access.
+ */
+void
+rte_mcfg_tailq_read_unlock(void);
+
+/**
+ * Lock the internal EAL TAILQ list for exclusive access.
+ */
+void
+rte_mcfg_tailq_write_lock(void);
+
+/**
+ * Unlock the internal EAL TAILQ list for exclusive access.
+ */
+void
+rte_mcfg_tailq_write_unlock(void);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/lib/librte_eal/rte_eal_version.map b/lib/librte_eal/rte_eal_version.map
index 754060d..d78a3a8 100644 (file)
--- a/lib/librte_eal/rte_eal_version.map
+++ b/lib/librte_eal/rte_eal_version.map
@@ -296,6 +296,10 @@ DPDK_19.08 {
        rte_mcfg_mem_read_unlock;
        rte_mcfg_mem_write_lock;
        rte_mcfg_mem_write_unlock;
+       rte_mcfg_tailq_read_lock;
+       rte_mcfg_tailq_read_unlock;
+       rte_mcfg_tailq_write_lock;
+       rte_mcfg_tailq_write_unlock;
        rte_rand;
        rte_srand;
 

diff --git a/lib/librte_efd/rte_efd.c b/lib/librte_efd/rte_efd.c
index 14e493b..b808ce9 100644 (file)
--- a/lib/librte_efd/rte_efd.c
+++ b/lib/librte_efd/rte_efd.c
@@ -532,7 +532,7 @@ rte_efd_create(const char *name, uint32_t max_num_rules, uint32_t key_len,
 
        num_chunks_shift = rte_bsf32(num_chunks);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /*
         * Guarantee there's no existing: this is normally already checked
@@ -685,7 +685,7 @@ rte_efd_create(const char *name, uint32_t max_num_rules, uint32_t key_len,
 
        te->data = (void *) table;
        TAILQ_INSERT_TAIL(efd_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        snprintf(ring_name, sizeof(ring_name), "HT_%s", table->name);
        /* Create ring (Dummy slot index is not enqueued) */
@@ -705,7 +705,7 @@ rte_efd_create(const char *name, uint32_t max_num_rules, uint32_t key_len,
        return table;
 
 error_unlock_exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        rte_efd_free(table);
 
        return NULL;
@@ -720,7 +720,7 @@ rte_efd_find_existing(const char *name)
 
        efd_list = RTE_TAILQ_CAST(rte_efd_tailq.head, rte_efd_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        TAILQ_FOREACH(te, efd_list, next)
        {
@@ -728,7 +728,7 @@ rte_efd_find_existing(const char *name)
                if (strncmp(name, table->name, RTE_EFD_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -751,7 +751,7 @@ rte_efd_free(struct rte_efd_table *table)
                rte_free(table->chunks[socket_id]);
 
        efd_list = RTE_TAILQ_CAST(rte_efd_tailq.head, rte_efd_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        TAILQ_FOREACH_SAFE(te, efd_list, next, temp) {
                if (te->data == (void *) table) {
@@ -761,7 +761,7 @@ rte_efd_free(struct rte_efd_table *table)
                }
        }
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        rte_ring_free(table->free_slots);
        rte_free(table->offline_chunks);
        rte_free(table->keys);

diff --git a/lib/librte_eventdev/rte_event_ring.c b/lib/librte_eventdev/rte_event_ring.c
index 16d02a9..50190de 100644 (file)
--- a/lib/librte_eventdev/rte_event_ring.c
+++ b/lib/librte_eventdev/rte_event_ring.c
@@ -72,7 +72,7 @@ rte_event_ring_create(const char *name, unsigned int count, int socket_id,
                return NULL;
        }
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /*
         * reserve a memory zone for this ring. If we can't get rte_config or
@@ -89,7 +89,7 @@ rte_event_ring_create(const char *name, unsigned int count, int socket_id,
                        if (rte_memzone_free(mz) != 0)
                                RTE_LOG(ERR, RING, "Cannot free memzone\n");
                        rte_free(te);
-                       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+                       rte_mcfg_tailq_write_unlock();
                        return NULL;
                }
 
@@ -102,7 +102,7 @@ rte_event_ring_create(const char *name, unsigned int count, int socket_id,
                RTE_LOG(ERR, RING, "Cannot reserve memory\n");
                rte_free(te);
        }
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return r;
 }
@@ -118,7 +118,7 @@ rte_event_ring_lookup(const char *name)
        ring_list = RTE_TAILQ_CAST(rte_event_ring_tailq.head,
                        rte_event_ring_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        TAILQ_FOREACH(te, ring_list, next) {
                r = (struct rte_event_ring *) te->data;
@@ -126,7 +126,7 @@ rte_event_ring_lookup(const char *name)
                        break;
        }
 
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -163,7 +163,7 @@ rte_event_ring_free(struct rte_event_ring *r)
 
        ring_list = RTE_TAILQ_CAST(rte_event_ring_tailq.head,
                        rte_event_ring_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find out tailq entry */
        TAILQ_FOREACH(te, ring_list, next) {
@@ -172,13 +172,13 @@ rte_event_ring_free(struct rte_event_ring *r)
        }
 
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(ring_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(te);
 }

diff --git a/lib/librte_hash/rte_cuckoo_hash.c b/lib/librte_hash/rte_cuckoo_hash.c
index 51198b4..47cd0da 100644 (file)
--- a/lib/librte_hash/rte_cuckoo_hash.c
+++ b/lib/librte_hash/rte_cuckoo_hash.c
@@ -52,13 +52,13 @@ rte_hash_find_existing(const char *name)
 
        hash_list = RTE_TAILQ_CAST(rte_hash_tailq.head, rte_hash_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, hash_list, next) {
                h = (struct rte_hash *) te->data;
                if (strncmp(name, h->name, RTE_HASH_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -239,7 +239,7 @@ rte_hash_create(const struct rte_hash_parameters *params)
 
        snprintf(hash_name, sizeof(hash_name), "HT_%s", params->name);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* guarantee there's no existing: this is normally already checked
         * by ring creation above */
@@ -437,11 +437,11 @@ rte_hash_create(const struct rte_hash_parameters *params)
 
        te->data = (void *) h;
        TAILQ_INSERT_TAIL(hash_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return h;
 err_unlock:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 err:
        rte_ring_free(r);
        rte_ring_free(r_ext);
@@ -466,7 +466,7 @@ rte_hash_free(struct rte_hash *h)
 
        hash_list = RTE_TAILQ_CAST(rte_hash_tailq.head, rte_hash_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find out tailq entry */
        TAILQ_FOREACH(te, hash_list, next) {
@@ -475,13 +475,13 @@ rte_hash_free(struct rte_hash *h)
        }
 
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(hash_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        if (h->use_local_cache)
                rte_free(h->local_free_slots);

diff --git a/lib/librte_hash/rte_fbk_hash.c b/lib/librte_hash/rte_fbk_hash.c
index 9360f79..db118c9 100644 (file)
--- a/lib/librte_hash/rte_fbk_hash.c
+++ b/lib/librte_hash/rte_fbk_hash.c
@@ -50,13 +50,13 @@ rte_fbk_hash_find_existing(const char *name)
        fbk_hash_list = RTE_TAILQ_CAST(rte_fbk_hash_tailq.head,
                                       rte_fbk_hash_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, fbk_hash_list, next) {
                h = (struct rte_fbk_hash_table *) te->data;
                if (strncmp(name, h->name, RTE_FBK_HASH_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
        if (te == NULL) {
                rte_errno = ENOENT;
                return NULL;
@@ -103,7 +103,7 @@ rte_fbk_hash_create(const struct rte_fbk_hash_params *params)
 
        snprintf(hash_name, sizeof(hash_name), "FBK_%s", params->name);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* guarantee there's no existing */
        TAILQ_FOREACH(te, fbk_hash_list, next) {
@@ -165,7 +165,7 @@ rte_fbk_hash_create(const struct rte_fbk_hash_params *params)
        TAILQ_INSERT_TAIL(fbk_hash_list, te, next);
 
 exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return ht;
 }
@@ -188,7 +188,7 @@ rte_fbk_hash_free(struct rte_fbk_hash_table *ht)
        fbk_hash_list = RTE_TAILQ_CAST(rte_fbk_hash_tailq.head,
                                       rte_fbk_hash_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find out tailq entry */
        TAILQ_FOREACH(te, fbk_hash_list, next) {
@@ -197,13 +197,13 @@ rte_fbk_hash_free(struct rte_fbk_hash_table *ht)
        }
 
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(fbk_hash_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(ht);
        rte_free(te);

diff --git a/lib/librte_kni/rte_kni.c b/lib/librte_kni/rte_kni.c
index e60de2c..9dd5ebe 100644 (file)
--- a/lib/librte_kni/rte_kni.c
+++ b/lib/librte_kni/rte_kni.c
@@ -219,7 +219,7 @@ rte_kni_alloc(struct rte_mempool *pktmbuf_pool,
                return NULL;
        }
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        kni = __rte_kni_get(conf->name);
        if (kni != NULL) {
@@ -309,7 +309,7 @@ rte_kni_alloc(struct rte_mempool *pktmbuf_pool,
        kni_list = RTE_TAILQ_CAST(rte_kni_tailq.head, rte_kni_list);
        TAILQ_INSERT_TAIL(kni_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        /* Allocate mbufs and then put them into alloc_q */
        kni_allocate_mbufs(kni);
@@ -323,7 +323,7 @@ mz_fail:
 kni_fail:
        rte_free(te);
 unlock:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return NULL;
 }
@@ -386,7 +386,7 @@ rte_kni_release(struct rte_kni *kni)
 
        kni_list = RTE_TAILQ_CAST(rte_kni_tailq.head, rte_kni_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        TAILQ_FOREACH(te, kni_list, next) {
                if (te->data == kni)
@@ -404,7 +404,7 @@ rte_kni_release(struct rte_kni *kni)
 
        TAILQ_REMOVE(kni_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        /* mbufs in all fifo should be released, except request/response */
 
@@ -428,7 +428,7 @@ rte_kni_release(struct rte_kni *kni)
        return 0;
 
 unlock:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return -1;
 }
@@ -645,11 +645,11 @@ rte_kni_get(const char *name)
        if (name == NULL || name[0] == '\0')
                return NULL;
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        kni = __rte_kni_get(name);
 
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        return kni;
 }

diff --git a/lib/librte_lpm/rte_lpm.c b/lib/librte_lpm/rte_lpm.c
index 6b7b28a..b91f742 100644 (file)
--- a/lib/librte_lpm/rte_lpm.c
+++ b/lib/librte_lpm/rte_lpm.c
@@ -97,13 +97,13 @@ rte_lpm_find_existing_v20(const char *name)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm_tailq.head, rte_lpm_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, lpm_list, next) {
                l = te->data;
                if (strncmp(name, l->name, RTE_LPM_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -123,13 +123,13 @@ rte_lpm_find_existing_v1604(const char *name)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm_tailq.head, rte_lpm_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, lpm_list, next) {
                l = te->data;
                if (strncmp(name, l->name, RTE_LPM_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -170,7 +170,7 @@ rte_lpm_create_v20(const char *name, int socket_id, int max_rules,
        /* Determine the amount of memory to allocate. */
        mem_size = sizeof(*lpm) + (sizeof(lpm->rules_tbl[0]) * max_rules);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* guarantee there's no existing */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -212,7 +212,7 @@ rte_lpm_create_v20(const char *name, int socket_id, int max_rules,
        TAILQ_INSERT_TAIL(lpm_list, te, next);
 
 exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return lpm;
 }
@@ -247,7 +247,7 @@ rte_lpm_create_v1604(const char *name, int socket_id,
        tbl8s_size = (sizeof(struct rte_lpm_tbl_entry) *
                        RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* guarantee there's no existing */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -315,7 +315,7 @@ rte_lpm_create_v1604(const char *name, int socket_id,
        TAILQ_INSERT_TAIL(lpm_list, te, next);
 
 exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return lpm;
 }
@@ -339,7 +339,7 @@ rte_lpm_free_v20(struct rte_lpm_v20 *lpm)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm_tailq.head, rte_lpm_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find our tailq entry */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -349,7 +349,7 @@ rte_lpm_free_v20(struct rte_lpm_v20 *lpm)
        if (te != NULL)
                TAILQ_REMOVE(lpm_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(lpm);
        rte_free(te);
@@ -368,7 +368,7 @@ rte_lpm_free_v1604(struct rte_lpm *lpm)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm_tailq.head, rte_lpm_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find our tailq entry */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -378,7 +378,7 @@ rte_lpm_free_v1604(struct rte_lpm *lpm)
        if (te != NULL)
                TAILQ_REMOVE(lpm_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(lpm->tbl8);
        rte_free(lpm->rules_tbl);

diff --git a/lib/librte_lpm/rte_lpm6.c b/lib/librte_lpm/rte_lpm6.c
index a918031..5af74a5 100644 (file)
--- a/lib/librte_lpm/rte_lpm6.c
+++ b/lib/librte_lpm/rte_lpm6.c
@@ -316,7 +316,7 @@ rte_lpm6_create(const char *name, int socket_id,
        mem_size = sizeof(*lpm) + (sizeof(lpm->tbl8[0]) *
                        RTE_LPM6_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* Guarantee there's no existing */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -363,11 +363,11 @@ rte_lpm6_create(const char *name, int socket_id,
        te->data = (void *) lpm;
 
        TAILQ_INSERT_TAIL(lpm_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        return lpm;
 
 fail:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
 fail_wo_unlock:
        rte_free(tbl8_hdrs);
@@ -389,13 +389,13 @@ rte_lpm6_find_existing(const char *name)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm6_tailq.head, rte_lpm6_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, lpm_list, next) {
                l = (struct rte_lpm6 *) te->data;
                if (strncmp(name, l->name, RTE_LPM6_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -420,7 +420,7 @@ rte_lpm6_free(struct rte_lpm6 *lpm)
 
        lpm_list = RTE_TAILQ_CAST(rte_lpm6_tailq.head, rte_lpm6_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find our tailq entry */
        TAILQ_FOREACH(te, lpm_list, next) {
@@ -431,7 +431,7 @@ rte_lpm6_free(struct rte_lpm6 *lpm)
        if (te != NULL)
                TAILQ_REMOVE(lpm_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(lpm->tbl8_hdrs);
        rte_free(lpm->tbl8_pool);

diff --git a/lib/librte_member/rte_member.c b/lib/librte_member/rte_member.c
index fd228f4..efed28d 100644 (file)
--- a/lib/librte_member/rte_member.c
+++ b/lib/librte_member/rte_member.c
@@ -32,13 +32,13 @@ rte_member_find_existing(const char *name)
 
        member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, member_list, next) {
                setsum = (struct rte_member_setsum *) te->data;
                if (strncmp(name, setsum->name, RTE_MEMBER_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;
@@ -56,17 +56,17 @@ rte_member_free(struct rte_member_setsum *setsum)
        if (setsum == NULL)
                return;
        member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
        TAILQ_FOREACH(te, member_list, next) {
                if (te->data == (void *)setsum)
                        break;
        }
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
        TAILQ_REMOVE(member_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        switch (setsum->type) {
        case RTE_MEMBER_TYPE_HT:
@@ -105,7 +105,7 @@ rte_member_create(const struct rte_member_parameters *params)
 
        member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        TAILQ_FOREACH(te, member_list, next) {
                setsum = te->data;
@@ -159,13 +159,13 @@ rte_member_create(const struct rte_member_parameters *params)
 
        te->data = (void *)setsum;
        TAILQ_INSERT_TAIL(member_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        return setsum;
 
 error_unlock_exit:
        rte_free(te);
        rte_free(setsum);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        return NULL;
 }
 

diff --git a/lib/librte_mempool/rte_mempool.c b/lib/librte_mempool/rte_mempool.c
index 69bd2a6..238287a 100644 (file)
--- a/lib/librte_mempool/rte_mempool.c
+++ b/lib/librte_mempool/rte_mempool.c
@@ -711,7 +711,7 @@ rte_mempool_free(struct rte_mempool *mp)
                return;
 
        mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
        /* find out tailq entry */
        TAILQ_FOREACH(te, mempool_list, next) {
                if (te->data == (void *)mp)
@@ -722,7 +722,7 @@ rte_mempool_free(struct rte_mempool *mp)
                TAILQ_REMOVE(mempool_list, te, next);
                rte_free(te);
        }
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_mempool_free_memchunks(mp);
        rte_mempool_ops_free(mp);
@@ -898,9 +898,9 @@ rte_mempool_create_empty(const char *name, unsigned n, unsigned elt_size,
 
        te->data = mp;
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
        TAILQ_INSERT_TAIL(mempool_list, te, next);
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        rte_rwlock_write_unlock(RTE_EAL_MEMPOOL_RWLOCK);
 
        return mp;

diff --git a/lib/librte_reorder/rte_reorder.c b/lib/librte_reorder/rte_reorder.c
index 3a4a1b0..ae6e3f5 100644 (file)
--- a/lib/librte_reorder/rte_reorder.c
+++ b/lib/librte_reorder/rte_reorder.c
@@ -119,7 +119,7 @@ rte_reorder_create(const char *name, unsigned socket_id, unsigned int size)
                return NULL;
        }
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* guarantee there's no existing */
        TAILQ_FOREACH(te, reorder_list, next) {
@@ -152,7 +152,7 @@ rte_reorder_create(const char *name, unsigned socket_id, unsigned int size)
        }
 
 exit:
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
        return b;
 }
 
@@ -193,7 +193,7 @@ rte_reorder_free(struct rte_reorder_buffer *b)
 
        reorder_list = RTE_TAILQ_CAST(rte_reorder_tailq.head, rte_reorder_list);
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find our tailq entry */
        TAILQ_FOREACH(te, reorder_list, next) {
@@ -201,13 +201,13 @@ rte_reorder_free(struct rte_reorder_buffer *b)
                        break;
        }
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(reorder_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_reorder_free_mbufs(b);
 
@@ -229,13 +229,13 @@ rte_reorder_find_existing(const char *name)
 
        reorder_list = RTE_TAILQ_CAST(rte_reorder_tailq.head, rte_reorder_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
        TAILQ_FOREACH(te, reorder_list, next) {
                b = (struct rte_reorder_buffer *) te->data;
                if (strncmp(name, b->name, RTE_REORDER_NAMESIZE) == 0)
                        break;
        }
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;

diff --git a/lib/librte_ring/rte_ring.c b/lib/librte_ring/rte_ring.c
index b89ecf9..9ea26a6 100644 (file)
--- a/lib/librte_ring/rte_ring.c
+++ b/lib/librte_ring/rte_ring.c
@@ -147,7 +147,7 @@ rte_ring_create(const char *name, unsigned count, int socket_id,
                return NULL;
        }
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* reserve a memory zone for this ring. If we can't get rte_config or
         * we are secondary process, the memzone_reserve function will set
@@ -169,7 +169,7 @@ rte_ring_create(const char *name, unsigned count, int socket_id,
                RTE_LOG(ERR, RING, "Cannot reserve memory\n");
                rte_free(te);
        }
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return r;
 }
@@ -200,7 +200,7 @@ rte_ring_free(struct rte_ring *r)
        }
 
        ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find out tailq entry */
        TAILQ_FOREACH(te, ring_list, next) {
@@ -209,13 +209,13 @@ rte_ring_free(struct rte_ring *r)
        }
 
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(ring_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(te);
 }
@@ -245,13 +245,13 @@ rte_ring_list_dump(FILE *f)
 
        ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        TAILQ_FOREACH(te, ring_list, next) {
                rte_ring_dump(f, (struct rte_ring *) te->data);
        }
 
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 }
 
 /* search a ring from its name */
@@ -264,7 +264,7 @@ rte_ring_lookup(const char *name)
 
        ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        TAILQ_FOREACH(te, ring_list, next) {
                r = (struct rte_ring *) te->data;
@@ -272,7 +272,7 @@ rte_ring_lookup(const char *name)
                        break;
        }
 
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;

diff --git a/lib/librte_stack/rte_stack.c b/lib/librte_stack/rte_stack.c
index 60f63a6..2cc7e8e 100644 (file)
--- a/lib/librte_stack/rte_stack.c
+++ b/lib/librte_stack/rte_stack.c
@@ -84,13 +84,13 @@ rte_stack_create(const char *name, unsigned int count, int socket_id,
                return NULL;
        }
 
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        mz = rte_memzone_reserve_aligned(mz_name, sz, socket_id,
                                         0, __alignof__(*s));
        if (mz == NULL) {
                STACK_LOG_ERR("Cannot reserve stack memzone!\n");
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                rte_free(te);
                return NULL;
        }
@@ -102,7 +102,7 @@ rte_stack_create(const char *name, unsigned int count, int socket_id,
        /* Store the name for later lookups */
        ret = strlcpy(s->name, name, sizeof(s->name));
        if (ret < 0 || ret >= (int)sizeof(s->name)) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
 
                rte_errno = ENAMETOOLONG;
                rte_free(te);
@@ -120,7 +120,7 @@ rte_stack_create(const char *name, unsigned int count, int socket_id,
 
        TAILQ_INSERT_TAIL(stack_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        return s;
 }
@@ -135,7 +135,7 @@ rte_stack_free(struct rte_stack *s)
                return;
 
        stack_list = RTE_TAILQ_CAST(rte_stack_tailq.head, rte_stack_list);
-       rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_lock();
 
        /* find out tailq entry */
        TAILQ_FOREACH(te, stack_list, next) {
@@ -144,13 +144,13 @@ rte_stack_free(struct rte_stack *s)
        }
 
        if (te == NULL) {
-               rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+               rte_mcfg_tailq_write_unlock();
                return;
        }
 
        TAILQ_REMOVE(stack_list, te, next);
 
-       rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_write_unlock();
 
        rte_free(te);
 
@@ -171,7 +171,7 @@ rte_stack_lookup(const char *name)
 
        stack_list = RTE_TAILQ_CAST(rte_stack_tailq.head, rte_stack_list);
 
-       rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_lock();
 
        TAILQ_FOREACH(te, stack_list, next) {
                r = (struct rte_stack *) te->data;
@@ -179,7 +179,7 @@ rte_stack_lookup(const char *name)
                        break;
        }
 
-       rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
+       rte_mcfg_tailq_read_unlock();
 
        if (te == NULL) {
                rte_errno = ENOENT;