[CLOUD-DEV,v3,6/9] linux-gen: pktio: ipc: use generic pktio_ops data storage

Message ID 1507636815-18816-7-git-send-email-odpbot@yandex.ru
State Superseded
Headers show
Series
  • Cloud dev pktio ops data pr
Related show

Commit Message

Github ODP bot Oct. 10, 2017, noon
From: Bogdan Pricope <bogdan.pricope@linaro.org>


Signed-off-by: Bogdan Pricope <bogdan.pricope@linaro.org>

---
/** Email created from pull request 196 (bogdanPricope:cloud_dev_pktio_ops_data_pr)
 ** https://github.com/Linaro/odp/pull/196
 ** Patch: https://github.com/Linaro/odp/pull/196.patch
 ** Base sha: 3d3c8f71f39ff139695d6f4b8e5ea17502c5f7cf
 ** Merge commit sha: 2bae88983ff377d83fcf9c99bf5c380275454327
 **/
 .../include/odp_pktio_ops_subsystem.h              |   2 -
 platform/linux-generic/pktio/ipc.c                 | 201 +++++++++++----------
 2 files changed, 103 insertions(+), 100 deletions(-)

Patch

diff --git a/platform/linux-generic/include/odp_pktio_ops_subsystem.h b/platform/linux-generic/include/odp_pktio_ops_subsystem.h
index 526280a10..6bb31516a 100644
--- a/platform/linux-generic/include/odp_pktio_ops_subsystem.h
+++ b/platform/linux-generic/include/odp_pktio_ops_subsystem.h
@@ -79,7 +79,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>
 
@@ -88,7 +87,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;
diff --git a/platform/linux-generic/pktio/ipc.c b/platform/linux-generic/pktio/ipc.c
index 5211d1e5f..a9bd64640 100644
--- a/platform/linux-generic/pktio/ipc.c
+++ b/platform/linux-generic/pktio/ipc.c
@@ -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);