@@ -81,7 +81,6 @@ typedef ODP_MODULE_CLASS(pktio_ops) {
} pktio_ops_module_t;
/* All implementations of this subsystem */
-#include <odp_pktio_ops_ipc.h>
#include <odp_pktio_ops_netmap.h>
#include <odp_pktio_ops_pcap.h>
@@ -90,7 +89,6 @@ typedef ODP_MODULE_CLASS(pktio_ops) {
*/
typedef union {
void *dpdk;
- pktio_ops_ipc_data_t ipc;
pktio_ops_netmap_data_t netmap;
pktio_ops_pcap_data_t pcap;
} pktio_ops_data_t;
@@ -11,10 +11,12 @@
#include <odp/api/system_info.h>
#include <odp_shm_internal.h>
#include <_ishm_internal.h>
+#include <odp_pktio_ops_ipc.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
+#include <linux/if_ether.h>
#define IPC_ODP_DEBUG_PRINT 0
@@ -45,7 +47,8 @@ static const char *_ipc_odp_buffer_pool_shm_name(odp_pool_t pool_hdl)
static int _ipc_master_start(pktio_entry_t *pktio_entry)
{
- struct pktio_info *pinfo = pktio_entry->ops_data(ipc).pinfo;
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
+ struct pktio_info *pinfo = pkt_ipc->pinfo;
odp_shm_t shm;
if (pinfo->slave.init_done == 0)
@@ -59,11 +62,11 @@ static int _ipc_master_start(pktio_entry_t *pktio_entry)
return -1;
}
- pktio_entry->ops_data(ipc).remote_pool_shm = shm;
- pktio_entry->ops_data(ipc).pool_base = odp_shm_addr(shm);
- pktio_entry->ops_data(ipc).pool_mdata_base = (char *)odp_shm_addr(shm);
+ pkt_ipc->remote_pool_shm = shm;
+ pkt_ipc->pool_base = odp_shm_addr(shm);
+ pkt_ipc->pool_mdata_base = (char *)odp_shm_addr(shm);
- odp_atomic_store_u32(&pktio_entry->ops_data(ipc).ready, 1);
+ odp_atomic_store_u32(&pkt_ipc->ready, 1);
IPC_ODP_DBG("%s started.\n", pktio_entry->s.name);
return 0;
@@ -73,6 +76,7 @@ static int _ipc_init_master(pktio_entry_t *pktio_entry,
const char *dev,
odp_pool_t pool_hdl)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
char ipc_shm_name[ODP_POOL_NAME_LEN + sizeof("_m_prod")];
pool_t *pool;
struct pktio_info *pinfo;
@@ -90,62 +94,62 @@ static int _ipc_init_master(pktio_entry_t *pktio_entry,
* to be processed packets ring.
*/
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_m_prod", dev);
- pktio_entry->ops_data(ipc).tx.send = _ring_create(ipc_shm_name,
+ pkt_ipc->tx.send = _ring_create(ipc_shm_name,
PKTIO_IPC_ENTRIES,
_RING_SHM_PROC | _RING_NO_LIST);
- if (!pktio_entry->ops_data(ipc).tx.send) {
+ if (!pkt_ipc->tx.send) {
ODP_ERR("pid %d unable to create ipc ring %s name\n",
getpid(), ipc_shm_name);
return -1;
}
ODP_DBG("Created IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).tx.send),
- _ring_free_count(pktio_entry->ops_data(ipc).tx.send));
+ ipc_shm_name, _ring_count(pkt_ipc->tx.send),
+ _ring_free_count(pkt_ipc->tx.send));
/* generate name in shm like ipc_pktio_p for
* already processed packets
*/
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_m_cons", dev);
- pktio_entry->ops_data(ipc).tx.free = _ring_create(ipc_shm_name,
+ pkt_ipc->tx.free = _ring_create(ipc_shm_name,
PKTIO_IPC_ENTRIES,
_RING_SHM_PROC | _RING_NO_LIST);
- if (!pktio_entry->ops_data(ipc).tx.free) {
+ if (!pkt_ipc->tx.free) {
ODP_ERR("pid %d unable to create ipc ring %s name\n",
getpid(), ipc_shm_name);
goto free_m_prod;
}
ODP_DBG("Created IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).tx.free),
- _ring_free_count(pktio_entry->ops_data(ipc).tx.free));
+ ipc_shm_name, _ring_count(pkt_ipc->tx.free),
+ _ring_free_count(pkt_ipc->tx.free));
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_s_prod", dev);
- pktio_entry->ops_data(ipc).rx.recv = _ring_create(ipc_shm_name,
+ pkt_ipc->rx.recv = _ring_create(ipc_shm_name,
PKTIO_IPC_ENTRIES,
_RING_SHM_PROC | _RING_NO_LIST);
- if (!pktio_entry->ops_data(ipc).rx.recv) {
+ if (!pkt_ipc->rx.recv) {
ODP_ERR("pid %d unable to create ipc ring %s name\n",
getpid(), ipc_shm_name);
goto free_m_cons;
}
ODP_DBG("Created IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).rx.recv),
- _ring_free_count(pktio_entry->ops_data(ipc).rx.recv));
+ ipc_shm_name, _ring_count(pkt_ipc->rx.recv),
+ _ring_free_count(pkt_ipc->rx.recv));
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_s_cons", dev);
- pktio_entry->ops_data(ipc).rx.free = _ring_create(ipc_shm_name,
+ pkt_ipc->rx.free = _ring_create(ipc_shm_name,
PKTIO_IPC_ENTRIES,
_RING_SHM_PROC | _RING_NO_LIST);
- if (!pktio_entry->ops_data(ipc).rx.free) {
+ if (!pkt_ipc->rx.free) {
ODP_ERR("pid %d unable to create ipc ring %s name\n",
getpid(), ipc_shm_name);
goto free_s_prod;
}
ODP_DBG("Created IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).rx.free),
- _ring_free_count(pktio_entry->ops_data(ipc).rx.free));
+ ipc_shm_name, _ring_count(pkt_ipc->rx.free),
+ _ring_free_count(pkt_ipc->rx.free));
/* Set up pool name for remote info */
- pinfo = pktio_entry->ops_data(ipc).pinfo;
+ pinfo = pkt_ipc->pinfo;
pool_name = _ipc_odp_buffer_pool_shm_name(pool_hdl);
if (strlen(pool_name) > ODP_POOL_NAME_LEN) {
ODP_ERR("pid %d ipc pool name %s is too big %d\n",
@@ -158,7 +162,7 @@ static int _ipc_init_master(pktio_entry_t *pktio_entry,
pinfo->slave.pid = 0;
pinfo->slave.init_done = 0;
- pktio_entry->ops_data(ipc).pool = pool_hdl;
+ pkt_ipc->pool = pool_hdl;
ODP_DBG("Pre init... DONE.\n");
pinfo->master.init_done = 1;
@@ -224,15 +228,18 @@ static int _ipc_init_slave(const char *dev,
pktio_entry_t *pktio_entry,
odp_pool_t pool)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
+
if (strlen(dev) > (ODP_POOL_NAME_LEN - sizeof("_slave_r")))
ODP_ABORT("too big ipc name\n");
- pktio_entry->ops_data(ipc).pool = pool;
+ pkt_ipc->pool = pool;
return 0;
}
static int _ipc_slave_start(pktio_entry_t *pktio_entry)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
char ipc_shm_name[ODP_POOL_NAME_LEN + sizeof("_slave_r")];
struct pktio_info *pinfo;
odp_shm_t shm;
@@ -248,61 +255,61 @@ static int _ipc_slave_start(pktio_entry_t *pktio_entry)
sprintf(dev, "ipc:%s", tail);
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_m_prod", dev);
- pktio_entry->ops_data(ipc).rx.recv = _ipc_shm_map(ipc_shm_name, pid);
- if (!pktio_entry->ops_data(ipc).rx.recv) {
+ pkt_ipc->rx.recv = _ipc_shm_map(ipc_shm_name, pid);
+ if (!pkt_ipc->rx.recv) {
ODP_DBG("pid %d unable to find ipc ring %s name\n",
getpid(), dev);
sleep(1);
return -1;
}
ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).rx.recv),
- _ring_free_count(pktio_entry->ops_data(ipc).rx.recv));
+ ipc_shm_name, _ring_count(pkt_ipc->rx.recv),
+ _ring_free_count(pkt_ipc->rx.recv));
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_m_cons", dev);
- pktio_entry->ops_data(ipc).rx.free = _ipc_shm_map(ipc_shm_name, pid);
- if (!pktio_entry->ops_data(ipc).rx.free) {
+ pkt_ipc->rx.free = _ipc_shm_map(ipc_shm_name, pid);
+ if (!pkt_ipc->rx.free) {
ODP_ERR("pid %d unable to find ipc ring %s name\n",
getpid(), dev);
goto free_m_prod;
}
ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).rx.free),
- _ring_free_count(pktio_entry->ops_data(ipc).rx.free));
+ ipc_shm_name, _ring_count(pkt_ipc->rx.free),
+ _ring_free_count(pkt_ipc->rx.free));
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_s_prod", dev);
- pktio_entry->ops_data(ipc).tx.send = _ipc_shm_map(ipc_shm_name, pid);
- if (!pktio_entry->ops_data(ipc).tx.send) {
+ pkt_ipc->tx.send = _ipc_shm_map(ipc_shm_name, pid);
+ if (!pkt_ipc->tx.send) {
ODP_ERR("pid %d unable to find ipc ring %s name\n",
getpid(), dev);
goto free_m_cons;
}
ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).tx.send),
- _ring_free_count(pktio_entry->ops_data(ipc).tx.send));
+ ipc_shm_name, _ring_count(pkt_ipc->tx.send),
+ _ring_free_count(pkt_ipc->tx.send));
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_s_cons", dev);
- pktio_entry->ops_data(ipc).tx.free = _ipc_shm_map(ipc_shm_name, pid);
- if (!pktio_entry->ops_data(ipc).tx.free) {
+ pkt_ipc->tx.free = _ipc_shm_map(ipc_shm_name, pid);
+ if (!pkt_ipc->tx.free) {
ODP_ERR("pid %d unable to find ipc ring %s name\n",
getpid(), dev);
goto free_s_prod;
}
ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
- ipc_shm_name, _ring_count(pktio_entry->ops_data(ipc).tx.free),
- _ring_free_count(pktio_entry->ops_data(ipc).tx.free));
+ ipc_shm_name, _ring_count(pkt_ipc->tx.free),
+ _ring_free_count(pkt_ipc->tx.free));
/* Get info about remote pool */
- pinfo = pktio_entry->ops_data(ipc).pinfo;
+ pinfo = pkt_ipc->pinfo;
shm = _ipc_map_remote_pool(pinfo->master.pool_name,
pid);
- pktio_entry->ops_data(ipc).remote_pool_shm = shm;
- pktio_entry->ops_data(ipc).pool_mdata_base = (char *)odp_shm_addr(shm);
- pktio_entry->ops_data(ipc).pkt_size = pinfo->master.block_size;
+ pkt_ipc->remote_pool_shm = shm;
+ pkt_ipc->pool_mdata_base = (char *)odp_shm_addr(shm);
+ pkt_ipc->pkt_size = pinfo->master.block_size;
- _ipc_export_pool(pinfo, pktio_entry->ops_data(ipc).pool);
+ _ipc_export_pool(pinfo, pkt_ipc->pool);
- odp_atomic_store_u32(&pktio_entry->ops_data(ipc).ready, 1);
+ odp_atomic_store_u32(&pkt_ipc->ready, 1);
pinfo->slave.init_done = 1;
ODP_DBG("%s started.\n", pktio_entry->s.name);
@@ -334,6 +341,7 @@ static int ipc_pktio_open(odp_pktio_t id ODP_UNUSED,
char name[ODP_POOL_NAME_LEN + sizeof("_info")];
char tail[ODP_POOL_NAME_LEN];
odp_shm_t shm;
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
ODP_STATIC_ASSERT(ODP_POOL_NAME_LEN == _RING_NAMESIZE,
"mismatch pool and ring name arrays");
@@ -341,15 +349,15 @@ static int ipc_pktio_open(odp_pktio_t id ODP_UNUSED,
if (strncmp(dev, "ipc", 3))
return -1;
- odp_atomic_init_u32(&pktio_entry->ops_data(ipc).ready, 0);
+ odp_atomic_init_u32(&pkt_ipc->ready, 0);
- pktio_entry->ops_data(ipc).rx.cache = _ring_create("ipc_rx_cache",
+ pkt_ipc->rx.cache = _ring_create("ipc_rx_cache",
PKTIO_IPC_ENTRIES,
_RING_NO_LIST);
/* Shared info about remote pktio */
if (sscanf(dev, "ipc:%d:%s", &pid, tail) == 2) {
- pktio_entry->ops_data(ipc).type = PKTIO_TYPE_IPC_SLAVE;
+ pkt_ipc->type = PKTIO_TYPE_IPC_SLAVE;
snprintf(name, sizeof(name), "ipc:%s_info", tail);
IPC_ODP_DBG("lookup for name %s for pid %d\n", name, pid);
@@ -362,12 +370,12 @@ static int ipc_pktio_open(odp_pktio_t id ODP_UNUSED,
odp_shm_free(shm);
return -1;
}
- pktio_entry->ops_data(ipc).pinfo = pinfo;
- pktio_entry->ops_data(ipc).pinfo_shm = shm;
+ pkt_ipc->pinfo = pinfo;
+ pkt_ipc->pinfo_shm = shm;
ODP_DBG("process %d is slave\n", getpid());
ret = _ipc_init_slave(name, pktio_entry, pool);
} else {
- pktio_entry->ops_data(ipc).type = PKTIO_TYPE_IPC_MASTER;
+ pkt_ipc->type = PKTIO_TYPE_IPC_MASTER;
snprintf(name, sizeof(name), "%s_info", dev);
shm = odp_shm_reserve(name, sizeof(struct pktio_info),
ODP_CACHE_LINE_SIZE,
@@ -380,8 +388,8 @@ static int ipc_pktio_open(odp_pktio_t id ODP_UNUSED,
pinfo = odp_shm_addr(shm);
pinfo->master.init_done = 0;
pinfo->master.pool_name[0] = 0;
- pktio_entry->ops_data(ipc).pinfo = pinfo;
- pktio_entry->ops_data(ipc).pinfo_shm = shm;
+ pkt_ipc->pinfo = pinfo;
+ pkt_ipc->pinfo_shm = shm;
ODP_DBG("process %d is master\n", getpid());
ret = _ipc_init_master(pktio_entry, dev, pool);
}
@@ -391,6 +399,7 @@ static int ipc_pktio_open(odp_pktio_t id ODP_UNUSED,
static void _ipc_free_ring_packets(pktio_entry_t *pktio_entry, _ring_t *r)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
uintptr_t offsets[PKTIO_IPC_ENTRIES];
int ret;
void **rbuf_p;
@@ -401,7 +410,7 @@ static void _ipc_free_ring_packets(pktio_entry_t *pktio_entry, _ring_t *r)
if (!r)
return;
- pool = pool_entry_from_hdl(pktio_entry->ops_data(ipc).pool);
+ pool = pool_entry_from_hdl(pkt_ipc->pool);
addr = odp_shm_addr(pool->shm);
rbuf_p = (void *)&offsets;
@@ -426,6 +435,7 @@ static void _ipc_free_ring_packets(pktio_entry_t *pktio_entry, _ring_t *r)
static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
odp_packet_t pkt_table[], int len)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
int pkts = 0;
int i;
_ring_t *r;
@@ -435,16 +445,16 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
uint32_t ready;
int pkts_ring;
- ready = odp_atomic_load_u32(&pktio_entry->ops_data(ipc).ready);
+ ready = odp_atomic_load_u32(&pkt_ipc->ready);
if (odp_unlikely(!ready)) {
IPC_ODP_DBG("start pktio is missing before usage?\n");
return 0;
}
- _ipc_free_ring_packets(pktio_entry, pktio_entry->ops_data(ipc).tx.free);
+ _ipc_free_ring_packets(pktio_entry, pkt_ipc->tx.free);
/* rx from cache */
- r = pktio_entry->ops_data(ipc).rx.cache;
+ r = pkt_ipc->rx.cache;
pkts = _ring_mc_dequeue_burst(r, ipcbufs_p, len);
if (odp_unlikely(pkts < 0))
ODP_ABORT("internal error dequeue\n");
@@ -452,7 +462,7 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
/* rx from other app */
if (pkts == 0) {
ipcbufs_p = (void *)&offsets[0];
- r = pktio_entry->ops_data(ipc).rx.recv;
+ r = pkt_ipc->rx.recv;
pkts = _ring_mc_dequeue_burst(r, ipcbufs_p, len);
if (odp_unlikely(pkts < 0))
ODP_ABORT("internal error dequeue\n");
@@ -470,10 +480,10 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
uint64_t data_pool_off;
void *rmt_data_ptr;
- phdr = (void *)((uint8_t *)pktio_entry->
- ops_data(ipc).pool_mdata_base + offsets[i]);
+ phdr = (void *)((uint8_t *)pkt_ipc->pool_mdata_base +
+ offsets[i]);
- pool = pktio_entry->ops_data(ipc).pool;
+ pool = pkt_ipc->pool;
if (odp_unlikely(pool == ODP_POOL_INVALID))
ODP_ABORT("invalid pool");
@@ -497,12 +507,11 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
pkt_data = odp_packet_data(pkt);
if (odp_unlikely(!pkt_data))
ODP_ABORT("unable to map pkt_data ipc_slave %d\n",
- (PKTIO_TYPE_IPC_SLAVE ==
- pktio_entry->ops_data(ipc).type));
+ (PKTIO_TYPE_IPC_SLAVE == pkt_ipc->type));
/* Copy packet data from shared pool to local pool. */
- rmt_data_ptr = (uint8_t *)pktio_entry->
- ops_data(ipc).pool_mdata_base + data_pool_off;
+ rmt_data_ptr = (uint8_t *)pkt_ipc->pool_mdata_base +
+ data_pool_off;
memcpy(pkt_data, rmt_data_ptr, phdr->frame_len);
/* Copy packets L2, L3 parsed offsets and size */
@@ -521,7 +530,7 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
/* put back to rx ring dequed but not processed packets*/
if (pkts != i) {
ipcbufs_p = (void *)&offsets[i];
- r_p = pktio_entry->ops_data(ipc).rx.cache;
+ r_p = pkt_ipc->rx.cache;
pkts_ring = _ring_mp_enqueue_burst(r_p, ipcbufs_p, pkts - i);
if (pkts_ring != (pkts - i))
@@ -529,14 +538,13 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
if (i == 0)
return 0;
-
}
/*num of actually received packets*/
pkts = i;
/* Now tell other process that we no longer need that buffers.*/
- r_p = pktio_entry->ops_data(ipc).rx.free;
+ r_p = pkt_ipc->rx.free;
repeat:
@@ -580,11 +588,12 @@ static int ipc_pktio_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
static int ipc_pktio_send_lockless(pktio_entry_t *pktio_entry,
const odp_packet_t pkt_table[], int len)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
_ring_t *r;
void **rbuf_p;
int ret;
int i;
- uint32_t ready = odp_atomic_load_u32(&pktio_entry->ops_data(ipc).ready);
+ uint32_t ready = odp_atomic_load_u32(&pkt_ipc->ready);
odp_packet_t pkt_table_mapped[len]; /**< Ready to send packet has to be
* in memory mapped pool. */
uintptr_t offsets[len];
@@ -592,7 +601,7 @@ static int ipc_pktio_send_lockless(pktio_entry_t *pktio_entry,
if (odp_unlikely(!ready))
return 0;
- _ipc_free_ring_packets(pktio_entry, pktio_entry->ops_data(ipc).tx.free);
+ _ipc_free_ring_packets(pktio_entry, pkt_ipc->tx.free);
/* Copy packets to shm shared pool if they are in different
* pool, or if they are references (we can't share across IPC).
@@ -600,7 +609,7 @@ static int ipc_pktio_send_lockless(pktio_entry_t *pktio_entry,
for (i = 0; i < len; i++) {
odp_packet_t pkt = pkt_table[i];
pool_t *ipc_pool = pool_entry_from_hdl(
- pktio_entry->ops_data(ipc).pool);
+ pkt_ipc->pool);
odp_packet_hdr_t *pkt_hdr;
pool_t *pool;
@@ -611,8 +620,7 @@ static int ipc_pktio_send_lockless(pktio_entry_t *pktio_entry,
odp_packet_has_ref(pkt)) {
odp_packet_t newpkt;
- newpkt = odp_packet_copy(
- pkt, pktio_entry->ops_data(ipc).pool);
+ newpkt = odp_packet_copy(pkt, pkt_ipc->pool);
if (newpkt == ODP_PACKET_INVALID)
ODP_ABORT("Unable to copy packet\n");
@@ -644,20 +652,17 @@ static int ipc_pktio_send_lockless(pktio_entry_t *pktio_entry,
odp_packet_to_u64(pkt), odp_pool_to_u64(pool_hdl),
pkt_hdr, pkt_hdr->buf_hdr.ipc_data_offset,
offsets[i], odp_shm_addr(pool->shm),
- odp_shm_addr(pool_entry_from_hdl(pktio_entry->
- ops_data(ipc).pool)->shm));
+ odp_shm_addr(pool_entry_from_hdl(
+ pkt_ipc->pool)->shm));
}
/* Put packets to ring to be processed by other process. */
rbuf_p = (void *)&offsets[0];
- r = pktio_entry->ops_data(ipc).tx.send;
+ r = pkt_ipc->tx.send;
ret = _ring_mp_enqueue_burst(r, rbuf_p, len);
if (odp_unlikely(ret < 0)) {
ODP_ERR("pid %d odp_ring_mp_enqueue_bulk fail, ipc_slave %d, ret %d\n",
- getpid(),
- (PKTIO_TYPE_IPC_SLAVE ==
- pktio_entry->ops_data(ipc).type),
- ret);
+ getpid(), (PKTIO_TYPE_IPC_SLAVE == pkt_ipc->type), ret);
ODP_ERR("odp_ring_full: %d, odp_ring_count %d, _ring_free_count %d\n",
_ring_full(r), _ring_count(r),
_ring_free_count(r));
@@ -696,15 +701,15 @@ static int ipc_mac_addr_get(pktio_entry_t *pktio_entry ODP_UNUSED,
static int ipc_start(pktio_entry_t *pktio_entry)
{
- uint32_t ready = odp_atomic_load_u32(
- &pktio_entry->ops_data(ipc).ready);
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
+ uint32_t ready = odp_atomic_load_u32(&pkt_ipc->ready);
if (ready) {
ODP_ABORT("%s Already started\n", pktio_entry->s.name);
return -1;
}
- if (pktio_entry->ops_data(ipc).type == PKTIO_TYPE_IPC_MASTER)
+ if (pkt_ipc->type == PKTIO_TYPE_IPC_MASTER)
return _ipc_master_start(pktio_entry);
else
return _ipc_slave_start(pktio_entry);
@@ -712,24 +717,23 @@ static int ipc_start(pktio_entry_t *pktio_entry)
static int ipc_stop(pktio_entry_t *pktio_entry)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
unsigned tx_send = 0, tx_free = 0;
- odp_atomic_store_u32(&pktio_entry->ops_data(ipc).ready, 0);
+ odp_atomic_store_u32(&pkt_ipc->ready, 0);
- if (pktio_entry->ops_data(ipc).tx.send)
- _ipc_free_ring_packets(pktio_entry,
- pktio_entry->ops_data(ipc).tx.send);
+ if (pkt_ipc->tx.send)
+ _ipc_free_ring_packets(pktio_entry, pkt_ipc->tx.send);
/* other process can transfer packets from one ring to
* other, use delay here to free that packets. */
sleep(1);
- if (pktio_entry->ops_data(ipc).tx.free)
- _ipc_free_ring_packets(pktio_entry,
- pktio_entry->ops_data(ipc).tx.free);
-
- if (pktio_entry->ops_data(ipc).tx.send)
- tx_send = _ring_count(pktio_entry->ops_data(ipc).tx.send);
- if (pktio_entry->ops_data(ipc).tx.free)
- tx_free = _ring_count(pktio_entry->ops_data(ipc).tx.free);
+ if (pkt_ipc->tx.free)
+ _ipc_free_ring_packets(pktio_entry, pkt_ipc->tx.free);
+
+ if (pkt_ipc->tx.send)
+ tx_send = _ring_count(pkt_ipc->tx.send);
+ if (pkt_ipc->tx.free)
+ tx_free = _ring_count(pkt_ipc->tx.free);
if (tx_send | tx_free) {
ODP_DBG("IPC rings: tx send %d tx free %d\n",
tx_send, tx_free);
@@ -740,6 +744,7 @@ static int ipc_stop(pktio_entry_t *pktio_entry)
static int ipc_close(pktio_entry_t *pktio_entry)
{
+ pktio_ops_ipc_data_t *pkt_ipc = odp_ops_data(pktio_entry, ipc);
char ipc_shm_name[ODP_POOL_NAME_LEN + sizeof("_m_prod")];
char *dev = pktio_entry->s.name;
char name[ODP_POOL_NAME_LEN];
@@ -748,7 +753,7 @@ static int ipc_close(pktio_entry_t *pktio_entry)
ipc_stop(pktio_entry);
- odp_shm_free(pktio_entry->ops_data(ipc).remote_pool_shm);
+ odp_shm_free(pkt_ipc->remote_pool_shm);
if (sscanf(dev, "ipc:%d:%s", &pid, tail) == 2)
snprintf(name, sizeof(name), "ipc:%s", tail);
@@ -756,7 +761,7 @@ static int ipc_close(pktio_entry_t *pktio_entry)
snprintf(name, sizeof(name), "%s", dev);
/* unlink this pktio info for both master and slave */
- odp_shm_free(pktio_entry->ops_data(ipc).pinfo_shm);
+ odp_shm_free(pkt_ipc->pinfo_shm);
/* destroy rings */
snprintf(ipc_shm_name, sizeof(ipc_shm_name), "%s_s_cons", name);