net/cxgbe: use C11-style compiler builtins for atomics

Replace rte_atomic ops with C11 atomics.

Signed-off-by: Rahul Lakkireddy <rahul.lakkireddy@chelsio.com>

diff --git a/drivers/net/cxgbe/base/t4_hw.c b/drivers/net/cxgbe/base/t4_hw.c
index 7ebf4a9..b60bcdc 100644 (file)
--- a/drivers/net/cxgbe/base/t4_hw.c
+++ b/drivers/net/cxgbe/base/t4_hw.c
@@ -9,7 +9,6 @@
 #include <rte_log.h>
 #include <rte_debug.h>
 #include <rte_pci.h>
-#include <rte_atomic.h>
 #include <rte_branch_prediction.h>
 #include <rte_memory.h>
 #include <rte_tailq.h>

diff --git a/drivers/net/cxgbe/clip_tbl.c b/drivers/net/cxgbe/clip_tbl.c
index a0ab2a6..072fc74 100644 (file)
--- a/drivers/net/cxgbe/clip_tbl.c
+++ b/drivers/net/cxgbe/clip_tbl.c
@@ -55,7 +55,7 @@ void cxgbe_clip_release(struct rte_eth_dev *dev, struct clip_entry *ce)
        int ret;
 
        t4_os_lock(&ce->lock);
-       if (rte_atomic32_dec_and_test(&ce->refcnt)) {
+       if (__atomic_sub_fetch(&ce->refcnt, 1, __ATOMIC_RELAXED) == 0) {
                ret = clip6_release_mbox(dev, ce->addr);
                if (ret)
                        dev_debug(adap, "CLIP FW DEL CMD failed: %d", ret);
@@ -79,7 +79,7 @@ static struct clip_entry *find_or_alloc_clipe(struct clip_tbl *c,
        unsigned int clipt_size = c->clipt_size;
 
        for (e = &c->cl_list[0], end = &c->cl_list[clipt_size]; e != end; ++e) {
-               if (rte_atomic32_read(&e->refcnt) == 0) {
+               if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) == 0) {
                        if (!first_free)
                                first_free = e;
                } else {
@@ -114,11 +114,12 @@ static struct clip_entry *t4_clip_alloc(struct rte_eth_dev *dev,
        ce = find_or_alloc_clipe(ctbl, lip);
        if (ce) {
                t4_os_lock(&ce->lock);
-               if (!rte_atomic32_read(&ce->refcnt)) {
+               if (__atomic_load_n(&ce->refcnt, __ATOMIC_RELAXED) == 0) {
                        rte_memcpy(ce->addr, lip, sizeof(ce->addr));
                        if (v6) {
                                ce->type = FILTER_TYPE_IPV6;
-                               rte_atomic32_set(&ce->refcnt, 1);
+                               __atomic_store_n(&ce->refcnt, 1,
+                                                __ATOMIC_RELAXED);
                                ret = clip6_get_mbox(dev, lip);
                                if (ret)
                                        dev_debug(adap,
@@ -128,7 +129,7 @@ static struct clip_entry *t4_clip_alloc(struct rte_eth_dev *dev,
                                ce->type = FILTER_TYPE_IPV4;
                        }
                } else {
-                       rte_atomic32_inc(&ce->refcnt);
+                       __atomic_add_fetch(&ce->refcnt, 1, __ATOMIC_RELAXED);
                }
                t4_os_unlock(&ce->lock);
        }
@@ -177,7 +178,7 @@ struct clip_tbl *t4_init_clip_tbl(unsigned int clipt_start,
 
        for (i = 0; i < ctbl->clipt_size; i++) {
                t4_os_lock_init(&ctbl->cl_list[i].lock);
-               rte_atomic32_set(&ctbl->cl_list[i].refcnt, 0);
+               ctbl->cl_list[i].refcnt = 0;
        }
 
        return ctbl;

diff --git a/drivers/net/cxgbe/clip_tbl.h b/drivers/net/cxgbe/clip_tbl.h
index 737ccc6..d7689f4 100644 (file)
--- a/drivers/net/cxgbe/clip_tbl.h
+++ b/drivers/net/cxgbe/clip_tbl.h
@@ -13,7 +13,7 @@ struct clip_entry {
        enum filter_type type;       /* entry type */
        u32 addr[4];                 /* IPV4 or IPV6 address */
        rte_spinlock_t lock;         /* entry lock */
-       rte_atomic32_t refcnt;       /* entry reference count */
+       u32 refcnt;                  /* entry reference count */
 };
 
 struct clip_tbl {

diff --git a/drivers/net/cxgbe/cxgbe_ethdev.c b/drivers/net/cxgbe/cxgbe_ethdev.c
index a12a981..b88f80f 100644 (file)
--- a/drivers/net/cxgbe/cxgbe_ethdev.c
+++ b/drivers/net/cxgbe/cxgbe_ethdev.c
@@ -21,7 +21,6 @@
 #include <rte_debug.h>
 #include <rte_pci.h>
 #include <rte_bus_pci.h>
-#include <rte_atomic.h>
 #include <rte_branch_prediction.h>
 #include <rte_memory.h>
 #include <rte_tailq.h>

diff --git a/drivers/net/cxgbe/cxgbe_main.c b/drivers/net/cxgbe/cxgbe_main.c
index c759d97..b14ce28 100644 (file)
--- a/drivers/net/cxgbe/cxgbe_main.c
+++ b/drivers/net/cxgbe/cxgbe_main.c
@@ -20,7 +20,6 @@
 #include <rte_log.h>
 #include <rte_debug.h>
 #include <rte_pci.h>
-#include <rte_atomic.h>
 #include <rte_branch_prediction.h>
 #include <rte_memory.h>
 #include <rte_tailq.h>
@@ -417,13 +416,15 @@ void cxgbe_remove_tid(struct tid_info *t, unsigned int chan, unsigned int tid,
 
        if (t->tid_tab[tid]) {
                t->tid_tab[tid] = NULL;
-               rte_atomic32_dec(&t->conns_in_use);
+               __atomic_sub_fetch(&t->conns_in_use, 1, __ATOMIC_RELAXED);
                if (t->hash_base && tid >= t->hash_base) {
                        if (family == FILTER_TYPE_IPV4)
-                               rte_atomic32_dec(&t->hash_tids_in_use);
+                               __atomic_sub_fetch(&t->hash_tids_in_use, 1,
+                                                  __ATOMIC_RELAXED);
                } else {
                        if (family == FILTER_TYPE_IPV4)
-                               rte_atomic32_dec(&t->tids_in_use);
+                               __atomic_sub_fetch(&t->tids_in_use, 1,
+                                                  __ATOMIC_RELAXED);
                }
        }
 
@@ -445,13 +446,15 @@ void cxgbe_insert_tid(struct tid_info *t, void *data, unsigned int tid,
        t->tid_tab[tid] = data;
        if (t->hash_base && tid >= t->hash_base) {
                if (family == FILTER_TYPE_IPV4)
-                       rte_atomic32_inc(&t->hash_tids_in_use);
+                       __atomic_add_fetch(&t->hash_tids_in_use, 1,
+                                          __ATOMIC_RELAXED);
        } else {
                if (family == FILTER_TYPE_IPV4)
-                       rte_atomic32_inc(&t->tids_in_use);
+                       __atomic_add_fetch(&t->tids_in_use, 1,
+                                          __ATOMIC_RELAXED);
        }
 
-       rte_atomic32_inc(&t->conns_in_use);
+       __atomic_add_fetch(&t->conns_in_use, 1, __ATOMIC_RELAXED);
 }
 
 /**
@@ -504,10 +507,8 @@ static int tid_init(struct tid_info *t)
 
        t->afree = NULL;
        t->atids_in_use = 0;
-       rte_atomic32_init(&t->tids_in_use);
-       rte_atomic32_set(&t->tids_in_use, 0);
-       rte_atomic32_init(&t->conns_in_use);
-       rte_atomic32_set(&t->conns_in_use, 0);
+       t->tids_in_use = 0;
+       t->conns_in_use = 0;
 
        /* Setup the free list for atid_tab and clear the stid bitmap. */
        if (natids) {

diff --git a/drivers/net/cxgbe/cxgbe_ofld.h b/drivers/net/cxgbe/cxgbe_ofld.h
index 50931ed..33697c7 100644 (file)
--- a/drivers/net/cxgbe/cxgbe_ofld.h
+++ b/drivers/net/cxgbe/cxgbe_ofld.h
@@ -60,10 +60,10 @@ struct tid_info {
        unsigned int atids_in_use;
 
        /* TIDs in the TCAM */
-       rte_atomic32_t tids_in_use;
+       u32 tids_in_use;
        /* TIDs in the HASH */
-       rte_atomic32_t hash_tids_in_use;
-       rte_atomic32_t conns_in_use;
+       u32 hash_tids_in_use;
+       u32 conns_in_use;
 
        rte_spinlock_t atid_lock __rte_cache_aligned;
        rte_spinlock_t ftid_lock;

diff --git a/drivers/net/cxgbe/l2t.c b/drivers/net/cxgbe/l2t.c
index f9d651f..66f5789 100644 (file)
--- a/drivers/net/cxgbe/l2t.c
+++ b/drivers/net/cxgbe/l2t.c
@@ -14,8 +14,8 @@
  */
 void cxgbe_l2t_release(struct l2t_entry *e)
 {
-       if (rte_atomic32_read(&e->refcnt) != 0)
-               rte_atomic32_dec(&e->refcnt);
+       if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) != 0)
+               __atomic_sub_fetch(&e->refcnt, 1, __ATOMIC_RELAXED);
 }
 
 /**
@@ -112,7 +112,7 @@ static struct l2t_entry *find_or_alloc_l2e(struct l2t_data *d, u16 vlan,
        struct l2t_entry *first_free = NULL;
 
        for (e = &d->l2tab[0], end = &d->l2tab[d->l2t_size]; e != end; ++e) {
-               if (rte_atomic32_read(&e->refcnt) == 0) {
+               if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) == 0) {
                        if (!first_free)
                                first_free = e;
                } else {
@@ -151,18 +151,18 @@ static struct l2t_entry *t4_l2t_alloc_switching(struct rte_eth_dev *dev,
        e = find_or_alloc_l2e(d, vlan, port, eth_addr);
        if (e) {
                t4_os_lock(&e->lock);
-               if (!rte_atomic32_read(&e->refcnt)) {
+               if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) == 0) {
                        e->state = L2T_STATE_SWITCHING;
                        e->vlan = vlan;
                        e->lport = port;
                        rte_memcpy(e->dmac, eth_addr, RTE_ETHER_ADDR_LEN);
-                       rte_atomic32_set(&e->refcnt, 1);
+                       __atomic_store_n(&e->refcnt, 1, __ATOMIC_RELAXED);
                        ret = write_l2e(dev, e, 0, !L2T_LPBK, !L2T_ARPMISS);
                        if (ret < 0)
                                dev_debug(adap, "Failed to write L2T entry: %d",
                                          ret);
                } else {
-                       rte_atomic32_inc(&e->refcnt);
+                       __atomic_add_fetch(&e->refcnt, 1, __ATOMIC_RELAXED);
                }
                t4_os_unlock(&e->lock);
        }
@@ -213,7 +213,7 @@ struct l2t_data *t4_init_l2t(unsigned int l2t_start, unsigned int l2t_end)
                d->l2tab[i].idx = i;
                d->l2tab[i].state = L2T_STATE_UNUSED;
                t4_os_lock_init(&d->l2tab[i].lock);
-               rte_atomic32_set(&d->l2tab[i].refcnt, 0);
+               d->l2tab[i].refcnt = 0;
        }
 
        return d;

diff --git a/drivers/net/cxgbe/l2t.h b/drivers/net/cxgbe/l2t.h
index 2c489e4..9845c9f 100644 (file)
--- a/drivers/net/cxgbe/l2t.h
+++ b/drivers/net/cxgbe/l2t.h
@@ -30,7 +30,7 @@ struct l2t_entry {
        u8  lport;                  /* destination port */
        u8  dmac[RTE_ETHER_ADDR_LEN];   /* destination MAC address */
        rte_spinlock_t lock;        /* entry lock */
-       rte_atomic32_t refcnt;      /* entry reference count */
+       u32 refcnt;                 /* entry reference count */
 };
 
 struct l2t_data {

diff --git a/drivers/net/cxgbe/mps_tcam.c b/drivers/net/cxgbe/mps_tcam.c
index 6e5fae9..178921b 100644 (file)
--- a/drivers/net/cxgbe/mps_tcam.c
+++ b/drivers/net/cxgbe/mps_tcam.c
@@ -75,7 +75,7 @@ int cxgbe_mpstcam_alloc(struct port_info *pi, const u8 *eth_addr,
        t4_os_write_lock(&mpstcam->lock);
        entry = cxgbe_mpstcam_lookup(adap->mpstcam, eth_addr, mask);
        if (entry) {
-               rte_atomic32_add(&entry->refcnt, 1);
+               __atomic_add_fetch(&entry->refcnt, 1, __ATOMIC_RELAXED);
                t4_os_write_unlock(&mpstcam->lock);
                return entry->idx;
        }
@@ -97,7 +97,7 @@ int cxgbe_mpstcam_alloc(struct port_info *pi, const u8 *eth_addr,
        entry = &mpstcam->entry[ret];
        memcpy(entry->eth_addr, eth_addr, RTE_ETHER_ADDR_LEN);
        memcpy(entry->mask, mask, RTE_ETHER_ADDR_LEN);
-       rte_atomic32_set(&entry->refcnt, 1);
+       __atomic_store_n(&entry->refcnt, 1, __ATOMIC_RELAXED);
        entry->state = MPS_ENTRY_USED;
 
        if (cxgbe_update_free_idx(mpstcam))
@@ -146,7 +146,7 @@ int cxgbe_mpstcam_modify(struct port_info *pi, int idx, const u8 *addr)
         * provided value is -1
         */
        if (entry->state == MPS_ENTRY_UNUSED) {
-               rte_atomic32_set(&entry->refcnt, 1);
+               __atomic_store_n(&entry->refcnt, 1, __ATOMIC_RELAXED);
                entry->state = MPS_ENTRY_USED;
        }
 
@@ -164,7 +164,7 @@ static inline void reset_mpstcam_entry(struct mps_tcam_entry *entry)
 {
        memset(entry->eth_addr, 0, RTE_ETHER_ADDR_LEN);
        memset(entry->mask, 0, RTE_ETHER_ADDR_LEN);
-       rte_atomic32_clear(&entry->refcnt);
+       __atomic_store_n(&entry->refcnt, 0, __ATOMIC_RELAXED);
        entry->state = MPS_ENTRY_UNUSED;
 }
 
@@ -189,12 +189,12 @@ int cxgbe_mpstcam_remove(struct port_info *pi, u16 idx)
                return -EINVAL;
        }
 
-       if (rte_atomic32_read(&entry->refcnt) == 1)
+       if (__atomic_load_n(&entry->refcnt, __ATOMIC_RELAXED) == 1)
                ret = t4_free_raw_mac_filt(adap, pi->viid, entry->eth_addr,
                                           entry->mask, idx, 1, pi->port_id,
                                           false);
        else
-               ret = rte_atomic32_sub_return(&entry->refcnt, 1);
+               ret = __atomic_sub_fetch(&entry->refcnt, 1, __ATOMIC_RELAXED);
 
        if (ret == 0) {
                reset_mpstcam_entry(entry);

diff --git a/drivers/net/cxgbe/mps_tcam.h b/drivers/net/cxgbe/mps_tcam.h
index 3d1e8d3..998c2b5 100644 (file)
--- a/drivers/net/cxgbe/mps_tcam.h
+++ b/drivers/net/cxgbe/mps_tcam.h
@@ -28,7 +28,7 @@ struct mps_tcam_entry {
        u8 mask[RTE_ETHER_ADDR_LEN];
 
        struct mpstcam_table *mpstcam; /* backptr */
-       rte_atomic32_t refcnt;
+       u32 refcnt;
 };
 
 struct mpstcam_table {

diff --git a/drivers/net/cxgbe/sge.c b/drivers/net/cxgbe/sge.c
index 56b8ec1..e5f7721 100644 (file)
--- a/drivers/net/cxgbe/sge.c
+++ b/drivers/net/cxgbe/sge.c
@@ -20,7 +20,6 @@
 #include <rte_log.h>
 #include <rte_debug.h>
 #include <rte_pci.h>
-#include <rte_atomic.h>
 #include <rte_branch_prediction.h>
 #include <rte_memory.h>
 #include <rte_memzone.h>

diff --git a/drivers/net/cxgbe/smt.c b/drivers/net/cxgbe/smt.c
index b7b5a4a..810c757 100644 (file)
--- a/drivers/net/cxgbe/smt.c
+++ b/drivers/net/cxgbe/smt.c
@@ -119,7 +119,7 @@ static struct smt_entry *find_or_alloc_smte(struct smt_data *s, u8 *smac)
        struct smt_entry *e, *end, *first_free = NULL;
 
        for (e = &s->smtab[0], end = &s->smtab[s->smt_size]; e != end; ++e) {
-               if (!rte_atomic32_read(&e->refcnt)) {
+               if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) == 0) {
                        if (!first_free)
                                first_free = e;
                } else {
@@ -156,7 +156,7 @@ static struct smt_entry *t4_smt_alloc_switching(struct rte_eth_dev *dev,
        e = find_or_alloc_smte(s, smac);
        if (e) {
                t4_os_lock(&e->lock);
-               if (!rte_atomic32_read(&e->refcnt)) {
+               if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) == 0) {
                        e->pfvf = pfvf;
                        rte_memcpy(e->src_mac, smac, RTE_ETHER_ADDR_LEN);
                        ret = write_smt_entry(dev, e);
@@ -168,9 +168,9 @@ static struct smt_entry *t4_smt_alloc_switching(struct rte_eth_dev *dev,
                                goto out_write_unlock;
                        }
                        e->state = SMT_STATE_SWITCHING;
-                       rte_atomic32_set(&e->refcnt, 1);
+                       __atomic_store_n(&e->refcnt, 1, __ATOMIC_RELAXED);
                } else {
-                       rte_atomic32_inc(&e->refcnt);
+                       __atomic_add_fetch(&e->refcnt, 1, __ATOMIC_RELAXED);
                }
                t4_os_unlock(&e->lock);
        }
@@ -195,8 +195,8 @@ struct smt_entry *cxgbe_smt_alloc_switching(struct rte_eth_dev *dev, u8 *smac)
 
 void cxgbe_smt_release(struct smt_entry *e)
 {
-       if (rte_atomic32_read(&e->refcnt))
-               rte_atomic32_dec(&e->refcnt);
+       if (__atomic_load_n(&e->refcnt, __ATOMIC_RELAXED) != 0)
+               __atomic_sub_fetch(&e->refcnt, 1, __ATOMIC_RELAXED);
 }
 
 /**
@@ -221,7 +221,7 @@ struct smt_data *t4_init_smt(u32 smt_start_idx, u32 smt_size)
                s->smtab[i].state = SMT_STATE_UNUSED;
                memset(&s->smtab[i].src_mac, 0, RTE_ETHER_ADDR_LEN);
                t4_os_lock_init(&s->smtab[i].lock);
-               rte_atomic32_set(&s->smtab[i].refcnt, 0);
+               s->smtab[i].refcnt = 0;
        }
        return s;
 }

diff --git a/drivers/net/cxgbe/smt.h b/drivers/net/cxgbe/smt.h
index 92c63c8..e6e8aea 100644 (file)
--- a/drivers/net/cxgbe/smt.h
+++ b/drivers/net/cxgbe/smt.h
@@ -23,7 +23,7 @@ struct smt_entry {
        u16 pfvf;
        u16 hw_idx;
        u8 src_mac[RTE_ETHER_ADDR_LEN];
-       rte_atomic32_t refcnt;
+       u32 refcnt;
        rte_spinlock_t lock;
 };