diff --git a/configure.ac b/configure.ac
index 57054c5..edd335a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -251,6 +251,7 @@ AC_CONFIG_FILES([Makefile
 		 doc/Makefile
 		 example/Makefile
 		 example/generator/Makefile
+		 example/ipc/Makefile
 		 example/ipsec/Makefile
 		 example/l2fwd/Makefile
 		 example/packet/Makefile
diff --git a/example/Makefile.am b/example/Makefile.am
index 3021571..2d1b02a 100644
--- a/example/Makefile.am
+++ b/example/Makefile.am
@@ -1 +1 @@
-SUBDIRS = generator ipsec l2fwd packet timer
+SUBDIRS = generator ipc ipsec l2fwd packet timer
diff --git a/example/ipc/.gitignore b/example/ipc/.gitignore
new file mode 100644
index 0000000..963d99d
--- /dev/null
+++ b/example/ipc/.gitignore
@@ -0,0 +1 @@
+odp_ipc
diff --git a/example/ipc/Makefile.am b/example/ipc/Makefile.am
new file mode 100644
index 0000000..3da9549
--- /dev/null
+++ b/example/ipc/Makefile.am
@@ -0,0 +1,7 @@
+include $(top_srcdir)/example/Makefile.inc
+
+bin_PROGRAMS = odp_ipc
+odp_ipc_LDFLAGS = $(AM_LDFLAGS) -static
+odp_ipc_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/example
+
+dist_odp_ipc_SOURCES = odp_ipc.c
diff --git a/example/ipc/odp_ipc.c b/example/ipc/odp_ipc.c
new file mode 100644
index 0000000..aadf27a
--- /dev/null
+++ b/example/ipc/odp_ipc.c
@@ -0,0 +1,425 @@
+/* Copyright (c) 2015, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+/**
+ * @file
+ *
+ * @example odp_pktio.c  ODP basic packet IO loopback test application
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <unistd.h>
+
+#include <example_debug.h>
+
+#include <odp.h>
+#include <odp/helper/linux.h>
+#include <odp/helper/eth.h>
+#include <odp/helper/ip.h>
+
+/** @def SHM_PKT_POOL_SIZE
+ * @brief Size of the shared memory block
+ */
+#define SHM_PKT_POOL_SIZE      (512*2048)
+
+/** @def SHM_PKT_POOL_BUF_SIZE
+ * @brief Buffer size of the packet pool buffer
+ */
+#define SHM_PKT_POOL_BUF_SIZE  1856
+
+/** @def MAX_PKT_BURST
+ * @brief Maximum number of packet bursts
+ */
+#define MAX_PKT_BURST          16
+
+/** Get rid of path in filename - only for unix-type paths using '/' */
+#define NO_PATH(file_name) (strrchr((file_name), '/') ? \
+			    strrchr((file_name), '/') + 1 : (file_name))
+
+/** Application argument */
+static char *pktio_name;
+
+/* helper funcs */
+static int drop_err_pkts(odp_packet_t pkt_tbl[], unsigned len);
+static void parse_args(int argc, char *argv[]);
+static void print_info(char *progname);
+static void usage(char *progname);
+
+/**
+ * Create a pktio handle, optionally associating a default input queue.
+ *
+ * @param dev Name of device to open
+ * @param pool Pool to associate with device for packet RX/TX
+ *
+ * @return The handle of the created pktio object.
+ * @retval ODP_PKTIO_INVALID if the create fails.
+ */
+static odp_pktio_t create_pktio(const char *dev, odp_pool_t pool)
+{
+	odp_pktio_t pktio;
+	char inq_name[ODP_QUEUE_NAME_LEN];
+	odp_pktio_t ipc_pktio;
+
+	/* Open a packet IO instance */
+	pktio = odp_pktio_open(dev, pool);
+	if (pktio == ODP_PKTIO_INVALID)
+		EXAMPLE_ABORT("Error: pktio create failed for %s\n", dev);
+
+	snprintf(inq_name, sizeof(inq_name), "%" PRIu64 "-pktio_inq_def",
+		 odp_pktio_to_u64(pktio));
+	inq_name[ODP_QUEUE_NAME_LEN - 1] = '\0';
+
+	printf("pid: %d, create IPC pktio\n", getpid());
+	ipc_pktio = odp_pktio_open("ipc_pktio", pool);
+	if (ipc_pktio == ODP_PKTIO_INVALID) {
+		EXAMPLE_ABORT("Error: ipc pktio create failed.\n");
+	}
+
+	return pktio;
+}
+
+/**
+ * Packet IO loopback worker thread using bursts from/to IO resources
+ *
+ * @param arg  thread arguments of type 'thread_args_t *'
+ */
+static void *pktio_ifburst_thread(void *arg ODP_UNUSED)
+{
+	int thr;
+	odp_pktio_t pktio;
+	int pkts, pkts_ok;
+	odp_packet_t pkt_tbl[MAX_PKT_BURST];
+	odp_pktio_t ipc_pktio;
+
+	thr = odp_thread_id();
+
+	pktio = odp_pktio_lookup(pktio_name);
+	if (pktio == ODP_PKTIO_INVALID) {
+		EXAMPLE_ERR("  [%02i] Error: lookup of pktio %s failed\n",
+			    thr, pktio_name);
+		return NULL;
+	}
+
+	printf("  [%02i] looked up pktio:%02" PRIu64 ", burst mode\n",
+	       thr, odp_pktio_to_u64(pktio));
+
+	ipc_pktio = odp_pktio_lookup("ipc_pktio");
+	if (pktio == ODP_PKTIO_INVALID) {
+		EXAMPLE_ERR("  [%02i] Error: lookup of pktio %s failed\n",
+			    thr, "ipc_pktio");
+		return NULL;
+	}
+	printf("  [%02i] looked up ipc_pktio:%02" PRIu64 ", burst mode\n",
+	       thr, odp_pktio_to_u64(pktio));
+
+	/* Loop packets */
+	for (;;) {
+		int i;
+
+		pkts = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST);
+		if (pkts > 0) {
+			/* Drop packets with errors */
+			pkts_ok = drop_err_pkts(pkt_tbl, pkts);
+			if (pkts_ok > 0) {
+				time_t tm = time(NULL);
+				char *tm_str = ctime(&tm);
+				for (i = 0; i < pkts_ok; i++) {
+					odp_packet_copydata_in(pkt_tbl[i], 0, strlen(tm_str), tm_str);
+					odp_packet_copydata_in(pkt_tbl[i], strlen(tm_str), 1, "\0");
+				}
+
+				odp_pktio_send(ipc_pktio, pkt_tbl, pkts_ok);
+				printf("---main pid %d: ipcsend %d pkts, size %d, data: %s\n", getpid(), pkts_ok, odp_packet_len(pkt_tbl[0]), tm_str);
+			}
+
+		}
+		pkts = odp_pktio_recv(ipc_pktio, pkt_tbl, MAX_PKT_BURST);
+		if (pkts > 0) {
+			for (i = 0; i < pkts; i++) {
+				char *b = malloc(odp_packet_len(pkt_tbl[i]));
+				odp_packet_copydata_out(pkt_tbl[i], 0, odp_packet_len(pkt_tbl[i]),  b);
+				printf("---main pid %d: ipcsrecv: size %d, data: %s\n", getpid(), odp_packet_len(pkt_tbl[i]), b);
+				free(b);
+				odp_packet_free(pkt_tbl[i]);
+			}
+		}
+
+	}
+
+/* unreachable */
+	return NULL;
+}
+
+
+static int ipc_second_process(void)
+{
+	odp_pktio_t pktio;
+	odp_packet_t pkt_tbl[MAX_PKT_BURST];
+	int i;
+	int pkts;
+
+	/* linux shared memory can already have objects with names which
+	 * second process can try to connect. That might be even interrupted
+	 * current application. Might be later I will add magic numbers to
+	 * each ipc object in linux-generic. HW platfrom shound not have that
+	 * problem. So just wait a little while master process will create
+	 * all ipc objects before connectioning to them.
+	 */
+	sleep(3);
+
+	/* Do lookup packet I/O in IPC shared memory,
+	 * and link it to local pool. */
+	while (1) {
+		pktio = odp_pktio_open("ipc_pktio", NULL);
+		if (pktio == ODP_PKTIO_INVALID) {
+			sleep(1);
+			printf("%s() pid %d: looking for ipc_pktio\n", __func__, getpid());
+			continue;
+		}
+		break;
+	}
+
+	for (;;) {
+		pkts = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST);
+		if (pkts > 0) {
+			for (i = 0; i < pkts; i++) {
+				char *b = malloc(odp_packet_len(pkt_tbl[i]));
+
+				odp_packet_copydata_out(pkt_tbl[i], 0, odp_packet_len(pkt_tbl[i]),  b);
+
+				printf("++++%s: pid %d, got packet %p, size %d, data: %s\n",
+						__func__, getpid(), (void*)pkt_tbl[i],
+						odp_packet_len(pkt_tbl[i]), b);
+				free(b);
+
+				odp_pktio_send(pktio, pkt_tbl, pkts);
+			}
+		} else {
+			/* No need to load cpu in example app.*/
+			sleep(1);
+		}
+	}
+
+	EXAMPLE_ERR("Unexpected close.");
+	return 0;
+}
+
+/**
+ * ODP packet example main function
+ */
+int main(int argc, char *argv[])
+{
+	odp_pool_t pool;
+	odp_pool_param_t params;
+	int f;
+
+	/* Parse and store the application arguments */
+	parse_args(argc, argv);
+
+	f = fork();
+	if (f) {
+		printf("Process one pid: %d\n", getpid());
+		/* Init ODP before calling anything else */
+		if (odp_init_global(NULL, NULL)) {
+			EXAMPLE_ERR("Error: ODP global init failed.\n");
+			exit(EXIT_FAILURE);
+		}
+
+		/* Init this thread */
+		if (odp_init_local()) {
+			EXAMPLE_ERR("Error: ODP local init failed.\n");
+			exit(EXIT_FAILURE);
+		}
+
+		ipc_second_process();
+	} else {
+		printf("Process two pid: %d\n", getpid());
+	}
+
+
+	/* Init ODP before calling anything else */
+	if (odp_init_global(NULL, NULL)) {
+		EXAMPLE_ERR("Error: ODP global init failed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	/* Init this thread */
+	if (odp_init_local()) {
+		EXAMPLE_ERR("Error: ODP local init failed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	/* Print both system and application information */
+	print_info(NO_PATH(argv[0]));
+
+	/* Create packet pool */
+	memset(&params, 0, sizeof(params));
+	params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
+	params.pkt.len     = SHM_PKT_POOL_BUF_SIZE;
+	params.pkt.num     = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
+	params.type        = ODP_POOL_PACKET;
+	params.shm_flags   = ODP_SHM_PROC;
+
+	EXAMPLE_DBG("Main proc: packet pool create:  "
+		"num %d, len %d, seg_len %d\n",
+		params.pkt.num, params.pkt.len, params.pkt.seg_len);
+
+	pool = odp_pool_create("packet_pool", ODP_SHM_NULL, &params);
+
+	if (pool == ODP_POOL_INVALID) {
+		EXAMPLE_ERR("Error: packet pool create failed.\n");
+		exit(EXIT_FAILURE);
+	}
+	odp_pool_print(pool);
+
+	create_pktio(pktio_name, pool);
+
+	pktio_ifburst_thread(NULL);
+
+	return 0;
+}
+
+/**
+ * Drop packets which input parsing marked as containing errors.
+ *
+ * Frees packets with error and modifies pkt_tbl[] to only contain packets with
+ * no detected errors.
+ *
+ * @param pkt_tbl  Array of packet
+ * @param len      Length of pkt_tbl[]
+ *
+ * @return Number of packets with no detected error
+ */
+static int drop_err_pkts(odp_packet_t pkt_tbl[], unsigned len)
+{
+	odp_packet_t pkt;
+	unsigned pkt_cnt = len;
+	unsigned i, j;
+
+	for (i = 0, j = 0; i < len; ++i) {
+		pkt = pkt_tbl[i];
+
+		if (odp_unlikely(odp_packet_has_error(pkt))) {
+			odp_packet_free(pkt); /* Drop */
+			pkt_cnt--;
+		} else if (odp_unlikely(i != j++)) {
+			pkt_tbl[j-1] = pkt;
+		}
+	}
+
+	return pkt_cnt;
+}
+
+/**
+ * Parse and store the command line arguments
+ *
+ * @param argc       argument count
+ * @param argv[]     argument vector
+ * @param appl_args  Store application arguments here
+ */
+static void parse_args(int argc, char *argv[])
+{
+	int opt;
+	int long_index;
+	size_t len;
+	static struct option longopts[] = {
+		{"interface", required_argument, NULL, 'i'},	/* return 'i' */
+		{"help", no_argument, NULL, 'h'},		/* return 'h' */
+		{NULL, 0, NULL, 0}
+	};
+
+	while (1) {
+		opt = getopt_long(argc, argv, "i:h",
+				  longopts, &long_index);
+
+		if (opt == -1)
+			break;	/* No more options */
+
+		switch (opt) {
+		case 'i':
+			len = strlen(optarg);
+			if (len == 0) {
+				usage(argv[0]);
+				exit(EXIT_FAILURE);
+			}
+			len += 1;	/* add room for '\0' */
+
+			pktio_name = malloc(len);
+			if (pktio_name == NULL) {
+				usage(argv[0]);
+				exit(EXIT_FAILURE);
+			}
+			strcpy(pktio_name, optarg);
+
+			break;
+		case 'h':
+			usage(argv[0]);
+			exit(EXIT_SUCCESS);
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	if (pktio_name == NULL) {
+		usage(argv[0]);
+		exit(EXIT_FAILURE);
+	}
+
+	optind = 1;		/* reset 'extern optind' from the getopt lib */
+}
+
+/**
+ * Print system and application info
+ */
+static void print_info(char *progname)
+{
+	printf("\n"
+	       "ODP system info\n"
+	       "---------------\n"
+	       "ODP API version: %s\n"
+	       "CPU model:       %s\n"
+	       "CPU freq (hz):   %"PRIu64"\n"
+	       "Cache line size: %i\n"
+	       "CPU count:       %i\n"
+	       "\n",
+	       odp_version_api_str(), odp_sys_cpu_model_str(), odp_sys_cpu_hz(),
+	       odp_sys_cache_line_size(), odp_cpu_count());
+
+	printf("Running ODP appl: \"%s\"\n"
+	       "-----------------\n"
+	       "Using IF:        %s\n",
+	       progname, pktio_name);
+	printf("\n\n");
+	fflush(NULL);
+}
+
+/**
+ * Prinf usage information
+ */
+static void usage(char *progname)
+{
+	printf("\n"
+	       "Usage: %s OPTIONS\n"
+	       "  E.g. %s -i eth0\n"
+	       "\n"
+	       "OpenDataPlane example application.\n"
+	       "\n"
+	       "Mandatory OPTIONS:\n"
+	       "  -i, --interface Eth interface\n"
+	       "\n"
+	       "Optional OPTIONS\n"
+	       "  -h, --help           Display help and exit.\n"
+	       " environment variables: ODP_PKTIO_DISABLE_SOCKET_MMAP\n"
+	       "                        ODP_PKTIO_DISABLE_SOCKET_MMSG\n"
+	       "                        ODP_PKTIO_DISABLE_SOCKET_BASIC\n"
+	       " can be used to advanced pkt I/O selection for linux-generic\n"
+	       "\n", NO_PATH(progname), NO_PATH(progname)
+	    );
+}
diff --git a/helper/include/odp/helper/ring.h b/helper/include/odp/helper/ring.h
index 65c32ad..5e640a7 100644
--- a/helper/include/odp/helper/ring.h
+++ b/helper/include/odp/helper/ring.h
@@ -158,6 +158,8 @@ typedef struct odph_ring {
 
 #define ODPH_RING_F_SP_ENQ 0x0001 /* The default enqueue is "single-producer".*/
 #define ODPH_RING_F_SC_DEQ 0x0002 /* The default dequeue is "single-consumer".*/
+#define ODPH_RING_SHM_PROC 0x0004 /* If set - ring is visible from different
+				    processes. Default is thread visible.     */
 #define ODPH_RING_QUOT_EXCEED (1 << 31)  /* Quota exceed for burst ops */
 #define ODPH_RING_SZ_MASK  (unsigned)(0x0fffffff) /* Ring size mask */
 
diff --git a/include/odp/api/pool.h b/include/odp/api/pool.h
index 241b98a..2401f47 100644
--- a/include/odp/api/pool.h
+++ b/include/odp/api/pool.h
@@ -83,6 +83,7 @@ typedef struct odp_pool_param_t {
 	};
 
 	int type;  /**< Pool type */
+	uint32_t shm_flags; /**< Flags to odp_shm_reserve() */
 } odp_pool_param_t;
 
 /** Packet pool*/
diff --git a/include/odp/api/shared_memory.h b/include/odp/api/shared_memory.h
index 5d851ce..57b4b77 100644
--- a/include/odp/api/shared_memory.h
+++ b/include/odp/api/shared_memory.h
@@ -49,6 +49,7 @@ extern "C" {
 /* Share level */
 #define ODP_SHM_SW_ONLY 0x1 /**< Application SW only, no HW access */
 #define ODP_SHM_PROC    0x2 /**< Share with external processes */
+#define ODP_SHM_PROC_NOCREAT 0x4
 
 /**
  * Shared memory block info
@@ -125,7 +126,6 @@ void *odp_shm_addr(odp_shm_t shm);
  */
 int odp_shm_info(odp_shm_t shm, odp_shm_info_t *info);
 
-
 /**
  * Print all shared memory blocks
  */
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index e5558ac..f0e1eff 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -148,6 +148,7 @@ __LIB__libodp_la_SOURCES = \
 			   odp_errno.c \
 			   odp_event.c \
 			   odp_init.c \
+			   odp_ipc.c \
 			   odp_impl.c \
 			   odp_linux.c \
 			   odp_packet.c \
diff --git a/platform/linux-generic/include/odp_buffer_internal.h b/platform/linux-generic/include/odp_buffer_internal.h
index 3a3d2a2..ffaed5c 100644
--- a/platform/linux-generic/include/odp_buffer_internal.h
+++ b/platform/linux-generic/include/odp_buffer_internal.h
@@ -129,6 +129,8 @@ typedef struct odp_buffer_hdr_t {
 	size_t                   udata_size; /* size of user metadata */
 	uint32_t                 segcount;   /* segment count */
 	uint32_t                 segsize;    /* segment size */
+	/* ipc mapped process can not walk over pointers, offset has to be used */
+	uint64_t		 ipc_addr_offset[ODP_BUFFER_MAX_SEG];
 	void                    *addr[ODP_BUFFER_MAX_SEG]; /* block addrs */
 } odp_buffer_hdr_t;
 
diff --git a/platform/linux-generic/include/odp_ipc.h b/platform/linux-generic/include/odp_ipc.h
new file mode 100644
index 0000000..8d5f15e
--- /dev/null
+++ b/platform/linux-generic/include/odp_ipc.h
@@ -0,0 +1,47 @@
+/* Copyright (c) 2015, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+#include <odp/packet_io.h>
+#include <odp_packet_io_internal.h>
+#include <odp/packet.h>
+#include <odp_packet_internal.h>
+#include <odp_internal.h>
+#include <odp/shared_memory.h>
+
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+/* IPC packet I/O over odph_ring */
+#include <odp/helper/ring.h>
+
+#define PKTIO_IPC_ENTRIES     4096 /**< number of odp buffers in
+					odp ring queue */
+
+/* that struct is exported to shared memory, so that 2 processes can find
+ * each other.
+ */
+struct pktio_info {
+	char remote_pool_name[30];
+	int shm_pool_num;
+	size_t shm_pkt_pool_size;
+	size_t shm_pkt_size;
+	size_t mdata_offset; /*offset of shared memory block start to pool_mdata_addr*/
+	struct {
+		size_t mdata_offset;
+		char   pool_name[30];
+	} slave;
+
+} __packed;
+
+int ipc_pktio_init(pktio_entry_t *pktio_entry, const char *dev,
+		   odp_pool_t pool);
+
+int ipc_pktio_recv(pktio_entry_t *pktio_entry, odp_packet_t pkt_table[],
+		      unsigned len);
+
+int ipc_pktio_send(pktio_entry_t *pktio_entry, odp_packet_t pkt_table[],
+		      unsigned len);
diff --git a/platform/linux-generic/include/odp_packet_io_internal.h b/platform/linux-generic/include/odp_packet_io_internal.h
index 47b8992..c19d461 100644
--- a/platform/linux-generic/include/odp_packet_io_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_internal.h
@@ -22,6 +22,7 @@ extern "C" {
 #include <odp_packet_socket.h>
 #include <odp_classification_datamodel.h>
 #include <odp_align_internal.h>
+#include <odp/helper/ring.h>
 
 #include <odp/config.h>
 #include <odp/hints.h>
@@ -35,6 +36,8 @@ typedef enum {
 	ODP_PKTIO_TYPE_SOCKET_MMSG,
 	ODP_PKTIO_TYPE_SOCKET_MMAP,
 	ODP_PKTIO_TYPE_LOOPBACK,
+	ODP_PKTIO_TYPE_IPC,
+	ODP_PKTIO_TYPE_IPC_SLAVE,
 } odp_pktio_type_t;
 
 struct pktio_entry {
@@ -50,6 +53,18 @@ struct pktio_entry {
 	char name[IFNAMSIZ];		/**< name of pktio provided to
 					   pktio_open() */
 	odp_bool_t promisc;		/**< promiscuous mode state */
+	odph_ring_t	*ipc_r;		/**< ODP ring for IPC mgs packets
+					indexes transmitted to shared memory */
+	odph_ring_t	*ipc_p;		/**< ODP ring for IPC msg packets
+					indexes already processed by remote process */
+	void		*ipc_pool_base; /**< IPC Remote pool base addr */
+	void		*ipc_pool_mdata_base; /**< IPC Remote pool mdata base addr */
+	uint64_t	ipc_pkt_size;	/**< IPC: packet size in remote pool */
+
+	odph_ring_t	*ipc_r_slave;
+	odph_ring_t	*ipc_p_slave;
+
+	odp_pool_t 	ipc_pool; 	/**< IPC: Pool of main process to alloc packets */
 };
 
 typedef union {
diff --git a/platform/linux-generic/include/odp_pool_internal.h b/platform/linux-generic/include/odp_pool_internal.h
index feeb284..7b80bc5 100644
--- a/platform/linux-generic/include/odp_pool_internal.h
+++ b/platform/linux-generic/include/odp_pool_internal.h
@@ -22,6 +22,7 @@ extern "C" {
 #include <odp/align.h>
 #include <odp_align_internal.h>
 #include <odp/pool.h>
+#include <odp_pool_internal.h>
 #include <odp_buffer_internal.h>
 #include <odp/hints.h>
 #include <odp/config.h>
diff --git a/platform/linux-generic/odp_init.c b/platform/linux-generic/odp_init.c
index bf36e68..630aa99 100644
--- a/platform/linux-generic/odp_init.c
+++ b/platform/linux-generic/odp_init.c
@@ -8,6 +8,7 @@
 #include <odp_internal.h>
 #include <odp/debug.h>
 #include <odp_debug_internal.h>
+#include <odp/helper/ring.h>
 
 struct odp_global_data_s odp_global_data;
 
@@ -71,6 +72,11 @@ int odp_init_global(odp_init_t *params,
 		return -1;
 	}
 
+	/* for linux-generic IPC queue implemented totaly in
+	 * software using odp_ring.
+	 */
+	odph_ring_tailq_init();
+
 	return 0;
 }
 
diff --git a/platform/linux-generic/odp_ipc.c b/platform/linux-generic/odp_ipc.c
new file mode 100644
index 0000000..1e64009
--- /dev/null
+++ b/platform/linux-generic/odp_ipc.c
@@ -0,0 +1,597 @@
+
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+#include <odp_ipc.h>
+#include <odp_debug_internal.h>
+#include <odp_packet_io_internal.h>
+#include <odp_spin_internal.h>
+#include <odp/system_info.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+static void *_ipc_map_remote_pool(const char *name, size_t size);
+
+static const char *_ipc_odp_buffer_pool_shm_name(odp_pool_t pool_hdl)
+{
+	pool_entry_t *pool;
+	uint32_t pool_id;
+	odp_shm_t shm;
+	odp_shm_info_t info;
+
+	pool_id = pool_handle_to_index(pool_hdl);
+	pool    = get_pool_entry(pool_id);
+	shm = pool->s.pool_shm;
+
+	odp_shm_info(shm, &info);
+
+	return info.name;
+}
+
+#if 0
+static uint64_t odp_buffer_pool_get_pktsize(odp_pool_t pool_hdl)
+{
+	pool_entry_t *pool;
+	uint32_t pool_id;
+
+	pool_id = pool_handle_to_index(pool_hdl);
+	pool    = get_pool_entry(pool_id);
+
+	return pool->s.blk_size;
+}
+
+static uint64_t odp_buffer_pool_get_size(odp_pool_t pool_hdl)
+{
+	pool_entry_t *pool;
+	uint32_t pool_id;
+
+	pool_id = pool_handle_to_index(pool_hdl);
+	pool    = get_pool_entry(pool_id);
+
+	return pool->s.pool_size;
+}
+#endif
+
+
+/**
+* Look up for shared memory object.
+*
+* @param name   name of shm object
+*
+* @return 0 on success, otherwise non-zero
+*/
+static int _odp_shm_lookup_ipc(const char *name)
+{
+	int shm;
+
+	shm = shm_open(name, O_RDWR, S_IRUSR | S_IWUSR);
+	if (shm == -1) {
+		ODP_DBG("IPC shm_open for %s not found\n", name);
+		return -1;
+	}
+	close(shm);
+	return 0;
+}
+
+static struct pktio_info *_ipc_map_pool_info(const char *pool_name, int flag)
+{
+	char *name;
+	struct pktio_info *pinfo;
+
+	/* Create info about remote pktio */
+	name = (char *)malloc(strlen(pool_name) + sizeof("_info"));
+	memcpy(name, pool_name, strlen(pool_name));
+	memcpy(name + strlen(pool_name), "_info", sizeof("_info"));
+	odp_shm_t shm = odp_shm_reserve(name, sizeof(struct pktio_info),
+			ODP_CACHE_LINE_SIZE,
+			flag);
+	if (ODP_SHM_INVALID == shm)
+		ODP_ABORT("unable to reserve memory for shm info");
+	free(name);
+	pinfo = odp_shm_addr(shm);
+	if (flag != ODP_SHM_PROC_NOCREAT)
+		memset(pinfo->remote_pool_name, 0, 30);
+	return pinfo;
+}
+
+static int _ipc_pktio_init_master(pktio_entry_t *pktio_entry, const char *dev,
+			   odp_pool_t pool)
+{
+	char ipc_shm_name[ODPH_RING_NAMESIZE];
+	pool_entry_t *pool_entry;
+	uint32_t pool_id;
+	void *ipc_pool_base;
+	struct pktio_info *pinfo;
+	const char *pool_name;
+
+	pool_id = pool_handle_to_index(pool);
+	pool_entry    = get_pool_entry(pool_id);
+
+	/* generate name in shm like ipc_pktio_r for
+	 * to be processed packets ring.
+	 */
+	memset(ipc_shm_name, 0, ODPH_RING_NAMESIZE);
+	memcpy(ipc_shm_name, dev, strlen(dev));
+	memcpy(ipc_shm_name + strlen(dev), "_r", 2);
+
+	pktio_entry->s.ipc_r = odph_ring_create(ipc_shm_name,
+			PKTIO_IPC_ENTRIES,
+			ODPH_RING_SHM_PROC);
+	if (!pktio_entry->s.ipc_r) {
+		ODP_DBG("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, odph_ring_count(pktio_entry->s.ipc_r),
+		 odph_ring_free_count(pktio_entry->s.ipc_r));
+
+	/* generate name in shm like ipc_pktio_p for
+	 * already processed packets
+	 */
+	memcpy(ipc_shm_name + strlen(dev), "_p", 2);
+
+	pktio_entry->s.ipc_p = odph_ring_create(ipc_shm_name,
+			PKTIO_IPC_ENTRIES,
+			ODPH_RING_SHM_PROC);
+	if (!pktio_entry->s.ipc_p) {
+		ODP_DBG("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, odph_ring_count(pktio_entry->s.ipc_p),
+		odph_ring_free_count(pktio_entry->s.ipc_p));
+
+
+	memcpy(ipc_shm_name + strlen(dev), "_slave_r", 8);
+	pktio_entry->s.ipc_r_slave = odph_ring_create(ipc_shm_name,
+			PKTIO_IPC_ENTRIES,
+			ODPH_RING_SHM_PROC);
+	if (!pktio_entry->s.ipc_r_slave) {
+		ODP_DBG("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, odph_ring_count(pktio_entry->s.ipc_r_slave),
+		 odph_ring_free_count(pktio_entry->s.ipc_r_slave));
+
+
+	memcpy(ipc_shm_name + strlen(dev), "_slave_p", 8);
+	pktio_entry->s.ipc_p_slave = odph_ring_create(ipc_shm_name,
+			PKTIO_IPC_ENTRIES,
+			ODPH_RING_SHM_PROC);
+	if (!pktio_entry->s.ipc_p_slave) {
+		ODP_DBG("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, odph_ring_count(pktio_entry->s.ipc_p_slave),
+		 odph_ring_free_count(pktio_entry->s.ipc_p_slave));
+
+	/* Memory to store information about exported pool */
+	pinfo = _ipc_map_pool_info(dev, ODP_SHM_PROC);
+
+	/* Set up pool name for remote info */
+	pool_name = _ipc_odp_buffer_pool_shm_name(pool);
+	memcpy(pinfo->remote_pool_name, pool_name, strlen(pool_name));
+	pinfo->shm_pkt_pool_size = pool_entry->s.pool_size;
+	pinfo->shm_pool_num = pool_entry->s.buf_num;
+	pinfo->shm_pkt_size = pool_entry->s.seg_size;
+	pinfo->mdata_offset =  pool_entry->s.pool_mdata_addr - pool_entry->s.pool_base_addr;
+	pinfo->slave.mdata_offset = 0;
+	ODP_DBG("Master waiting for slave to be connected now..\n");
+
+	/* Wait for remote process to export his pool. */
+	ODP_DBG("Wait for second process set mdata_offset...\n");
+	while (pinfo->slave.mdata_offset == 0) {
+		odp_spin();
+	}
+	ODP_DBG("Wait for second process set mdata_offset... DONE.\n");
+
+
+	while (1) {
+		int ret = _odp_shm_lookup_ipc(pinfo->slave.pool_name);
+		if (!ret)
+			break;
+		ODP_DBG("Master looking for %s\n", pinfo->slave.pool_name);
+		sleep(1);
+	}
+
+	ipc_pool_base = _ipc_map_remote_pool(pinfo->slave.pool_name, pinfo->shm_pkt_pool_size);
+	pktio_entry->s.ipc_pool_mdata_base = (char *)ipc_pool_base + pinfo->slave.mdata_offset;
+
+	pktio_entry->s.ipc_pool = pool;
+
+	return 0;
+}
+
+static odp_pool_t _ipc_odp_alloc_and_create_pool_slave(struct pktio_info *pinfo)
+{
+	odp_pool_t pool;
+	char *pool_name;
+	odp_pool_param_t params;
+	int num = pinfo->shm_pool_num;
+	uint64_t buf_size = pinfo->shm_pkt_size;
+	pool_entry_t *pool_entry;
+
+	pool_name = calloc(1, strlen(pinfo->remote_pool_name) + sizeof("ipc_pool_slave_"));
+	sprintf(pool_name, "ipc_pool_slave_%s", pinfo->remote_pool_name);
+
+	ODP_DBG("slave uses pool %s\n", pool_name);
+
+	memset(&params, 0, sizeof(params));
+	params.pkt.num = num;
+	params.pkt.len = buf_size;
+	params.pkt.seg_len = buf_size;
+	params.type = ODP_POOL_PACKET;
+	params.shm_flags = ODP_SHM_PROC;
+
+	pool = odp_pool_create(pool_name, ODP_SHM_NULL, &params);
+	if (pool == ODP_POOL_INVALID)
+		ODP_ABORT("Error: packet pool create failed.\n"
+			"num %d, len %d, seg_len %d\n",
+			params.pkt.num, params.pkt.len, params.pkt.seg_len);
+
+	/* Export info so that master can connect to that pool*/
+	snprintf(pinfo->slave.pool_name, 30, "%s", pool_name);
+	pool_entry = odp_pool_to_entry(pool);
+	pinfo->slave.mdata_offset = pool_entry->s.pool_mdata_addr - pool_entry->s.pool_base_addr;
+	free(pool_name);
+
+	return pool;
+}
+
+static void *_ipc_map_remote_pool(const char *name, size_t size)
+{
+	odp_shm_t shm;
+
+	ODP_DBG("Mapping remote pool %s, size %ld\n", name, size);
+	shm = odp_shm_reserve(name,
+			size,
+			ODP_CACHE_LINE_SIZE,
+			ODP_SHM_PROC_NOCREAT);
+	if (shm == ODP_SHM_INVALID)
+		ODP_ABORT("unable map %s\n", name);
+	return odp_shm_addr(shm);
+}
+
+static void * _ipc_shm_map(char *name, size_t size, int timeout)
+{
+	odp_shm_t shm;
+	int ret;
+
+	while (1) {
+		ret = _odp_shm_lookup_ipc(name);
+		if (!ret)
+			break;
+		ODP_DBG("Waiting for %s\n", name);
+		if (timeout <= 0)
+			return NULL;
+		timeout--;
+		sleep(1);
+	}
+
+	shm = odp_shm_reserve(name, size,
+			ODP_CACHE_LINE_SIZE,
+			ODP_SHM_PROC_NOCREAT);
+	if (ODP_SHM_INVALID == shm)
+		ODP_ABORT("unable to map: %s\n", name);
+
+	return odp_shm_addr(shm);
+}
+
+static int _ipc_pktio_init_slave(const char *dev, pktio_entry_t *pktio_entry)
+{
+	int ret = -1;
+	char ipc_shm_name[ODPH_RING_NAMESIZE];
+	size_t ring_size = PKTIO_IPC_ENTRIES * sizeof(void *) +
+			   sizeof(odph_ring_t);
+	struct pktio_info *pinfo;
+	void *ipc_pool_base;
+
+	memset(ipc_shm_name, 0, ODPH_RING_NAMESIZE);
+	memcpy(ipc_shm_name, dev, strlen(dev));
+
+	memcpy(ipc_shm_name + strlen(dev), "_r", 2);
+	pktio_entry->s.ipc_r  = _ipc_shm_map(ipc_shm_name, ring_size, 10);
+	if (!pktio_entry->s.ipc_r) {
+		ODP_DBG("pid %d unable to find ipc ring %s name\n",
+			getpid(), dev);
+		goto error;
+	}
+	ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
+			ipc_shm_name, odph_ring_count(pktio_entry->s.ipc_r),
+			odph_ring_free_count(pktio_entry->s.ipc_r));
+
+
+	memcpy(ipc_shm_name + strlen(dev), "_p", 2);
+	pktio_entry->s.ipc_p = _ipc_shm_map(ipc_shm_name, ring_size, 10);
+	if (!pktio_entry->s.ipc_p) {
+		ODP_DBG("pid %d unable to find ipc ring %s name\n",
+			getpid(), dev);
+		goto error;
+	}
+	ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
+			ipc_shm_name, odph_ring_count(pktio_entry->s.ipc_p),
+			odph_ring_free_count(pktio_entry->s.ipc_p));
+
+	memcpy(ipc_shm_name + strlen(dev), "_slave_r", 8);
+	pktio_entry->s.ipc_r_slave = _ipc_shm_map(ipc_shm_name, ring_size, 10);
+	if (!pktio_entry->s.ipc_r_slave) {
+		ODP_DBG("pid %d unable to find ipc ring %s name\n",
+			getpid(), dev);
+		goto error;
+	}
+	ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
+		 ipc_shm_name, odph_ring_count(pktio_entry->s.ipc_r_slave),
+		 odph_ring_free_count(pktio_entry->s.ipc_r_slave));
+
+	memcpy(ipc_shm_name + strlen(dev), "_slave_p", 8);
+	pktio_entry->s.ipc_p_slave = _ipc_shm_map(ipc_shm_name, ring_size, 10);
+	if (!pktio_entry->s.ipc_p_slave) {
+		ODP_DBG("pid %d unable to find ipc ring %s name\n",
+			getpid(), dev);
+		goto error;
+	}
+	ODP_DBG("Connected IPC ring: %s, count %d, free %d\n",
+		 ipc_shm_name, odph_ring_count(pktio_entry->s.ipc_p_slave),
+		 odph_ring_free_count(pktio_entry->s.ipc_p_slave));
+
+
+	/* Get info about remote pool */
+	pinfo = _ipc_map_pool_info(dev, ODP_SHM_PROC_NOCREAT);
+
+	ipc_pool_base = _ipc_map_remote_pool(pinfo->remote_pool_name, pinfo->shm_pkt_pool_size);
+	pktio_entry->s.ipc_pool_mdata_base = (char *)ipc_pool_base +  pinfo->mdata_offset;
+	pktio_entry->s.ipc_pkt_size = pinfo->shm_pkt_size;
+
+	/* @todo: to simplify in linux-generic implementation we create pool for
+	 * packets from IPC queue. On receive implementation copies packets to
+	 * that pool. Later we can try to reuse original pool without packets
+	 * copying.
+	 */
+	pktio_entry->s.ipc_pool = _ipc_odp_alloc_and_create_pool_slave(pinfo);
+
+	ret = 0;
+	ODP_DBG("%s OK.\n", __func__);
+error:
+	/* @todo free shm on error (api not impemented yet) */
+	return ret;
+}
+
+int ipc_pktio_init(pktio_entry_t *pktio_entry, const char *dev,
+			   odp_pool_t pool)
+{
+	int ret;
+
+	/* if pool is zero we assume that it's slave process connects
+	 * to shared memory already created by main process.
+	 */
+	if (pool) {
+		pktio_entry->s.type = ODP_PKTIO_TYPE_IPC;
+		ret = _ipc_pktio_init_master(pktio_entry, dev, pool);
+	} else {
+		pktio_entry->s.type = ODP_PKTIO_TYPE_IPC_SLAVE;
+		ret = _ipc_pktio_init_slave(dev, pktio_entry);
+	}
+
+	return ret;
+}
+
+
+static inline void *_ipc_buffer_map(odp_buffer_hdr_t *buf,
+			       uint32_t offset,
+			       uint32_t *seglen,
+			       uint32_t limit)
+{
+	int seg_index  = offset / buf->segsize;
+	int seg_offset = offset % buf->segsize;
+	void *addr = (char *)buf - buf->ipc_addr_offset[seg_index];
+
+	if (seglen != NULL) {
+		uint32_t buf_left = limit - offset;
+		*seglen = seg_offset + buf_left <= buf->segsize ?
+			buf_left : buf->segsize - seg_offset;
+	}
+
+	return (void *)(seg_offset + (uint8_t *)addr);
+}
+
+
+static inline void *_ipc_packet_map(odp_packet_hdr_t *pkt_hdr,
+			       uint32_t offset, uint32_t *seglen)
+{
+	if (offset > pkt_hdr->frame_len)
+		return NULL;
+
+	return _ipc_buffer_map(&pkt_hdr->buf_hdr,
+			  pkt_hdr->headroom + offset, seglen,
+			  pkt_hdr->headroom + pkt_hdr->frame_len);
+
+}
+
+int ipc_pktio_recv(pktio_entry_t *pktio_entry,
+		      odp_packet_t pkt_table[], unsigned len)
+{
+	int pkts = 0;
+	int ret;
+	int i;
+	odph_ring_t *r;
+	odph_ring_t *r_p;
+	odp_packet_t remote_pkts[PKTIO_IPC_ENTRIES];
+	void **ipcbufs_p = (void *)&remote_pkts;
+	unsigned ring_len;
+	int p_free;
+
+	if (pktio_entry->s.type == ODP_PKTIO_TYPE_IPC) {
+		r = pktio_entry->s.ipc_r_slave;
+		r_p = pktio_entry->s.ipc_p_slave;
+	} else if (pktio_entry->s.type == ODP_PKTIO_TYPE_IPC_SLAVE) {
+		r = pktio_entry->s.ipc_r;
+		r_p = pktio_entry->s.ipc_p;
+	} else
+		ODP_ABORT("wrong type: %d\n", pktio_entry->s.type);
+
+	ring_len = odph_ring_count(r);
+
+	pkts = len;
+	if (len > ring_len)
+		pkts = ring_len;
+
+	/* Do not dequeue more then we can put to producer ring */
+	p_free = odph_ring_free_count(r_p);
+	if (pkts > p_free)
+		pkts = p_free;
+
+	ret = odph_ring_mc_dequeue_bulk(r, ipcbufs_p, pkts);
+	if (ret != 0) {
+		ODP_DBG("error to dequeue no packets\n");
+		pkts = -1;
+		return pkts;
+	}
+
+	if (pkts == 0)
+		return 0;
+
+	for (i = 0; i < pkts; i++) {
+		odp_pool_t pool;
+		odp_packet_t pkt;
+		odp_packet_hdr_t *phdr;
+		odp_buffer_bits_t handle;
+		int idx; /* Remote packet has coded pool and index. We need only index.*/
+		void *pkt_data;
+		void *remote_pkt_data;
+
+		handle.handle = _odp_packet_to_buffer(remote_pkts[i]);
+		idx = handle.index;
+
+		/* Link to packed data. To this line we have Zero-Copy between
+		 * processes, to simplify use packet copy in that version which
+		 * can be removed later with more advance buffer management
+		 * (ref counters).
+		 */
+		phdr = (odp_packet_hdr_t *)((char *)pktio_entry->s.ipc_pool_mdata_base  +
+				(idx *  ODP_CACHE_LINE_SIZE)); /* reverse odp_buf_to_hdr() */
+
+		/* Allocate new packet. Select*/
+		pool = pktio_entry->s.ipc_pool;
+		if (odp_unlikely(pool == ODP_POOL_INVALID))
+			ODP_ABORT("invalid pool");
+
+		pkt = odp_packet_alloc(pool, phdr->frame_len);
+		if (odp_unlikely(pkt == ODP_PACKET_INVALID)) {
+			/* Original pool might be smaller then PKTIO_IPC_ENTRIES.
+			 * if packet can not be allocated from pool at this time,
+			 * simple get in on next recv() call.
+			 */
+			pkts = i - 1;
+			break;
+		}
+
+		/* Copy packet data. */
+		pkt_data = odp_packet_data(pkt);
+		if (odp_unlikely(pkt_data == NULL))
+			ODP_ABORT("unable to map pkt_data ipc_slave %d\n",
+				(ODP_PKTIO_TYPE_IPC_SLAVE == pktio_entry->s.type));
+
+		remote_pkt_data =  _ipc_packet_map(phdr, 0, NULL);
+		if (odp_unlikely(remote_pkt_data == NULL))
+			ODP_ABORT("unable to map remote_pkt_data, ipc_slave %d\n",
+			(ODP_PKTIO_TYPE_IPC_SLAVE == pktio_entry->s.type));
+
+		memcpy(pkt_data, remote_pkt_data, phdr->frame_len);  // FIXME: copy packet!!!
+
+		/* Copy packets L2, L3 parsed offsets and size */
+		odp_packet_hdr(pkt)->l2_offset = phdr->l2_offset;
+		odp_packet_hdr(pkt)->l3_offset = phdr->l3_offset;
+		odp_packet_hdr(pkt)->l4_offset = phdr->l4_offset;
+		odp_packet_hdr(pkt)->payload_offset = phdr->payload_offset;
+
+		odp_packet_hdr(pkt)->vlan_s_tag =  phdr->vlan_s_tag;
+		odp_packet_hdr(pkt)->vlan_c_tag =  phdr->vlan_c_tag;
+		odp_packet_hdr(pkt)->l3_protocol = phdr->l3_protocol;
+		odp_packet_hdr(pkt)->l3_len = phdr->l3_len;
+
+		odp_packet_hdr(pkt)->frame_len = phdr->frame_len;
+		odp_packet_hdr(pkt)->headroom = phdr->headroom;
+		odp_packet_hdr(pkt)->tailroom = phdr->tailroom;
+		pkt_table[i] = pkt;
+	}
+
+	/* Now tell other process that we no longer need that buffers.*/
+	ret = odph_ring_mp_enqueue_bulk(r_p, ipcbufs_p, pkts);
+	if (ret != 0)
+		ODP_ABORT("ipc: odp_ring_mp_enqueue_bulk r_p fail\n");
+
+	return pkts;
+}
+
+int ipc_pktio_send(pktio_entry_t *pktio_entry, odp_packet_t pkt_table[],
+		      unsigned len)
+{
+	odph_ring_t *r;
+	odph_ring_t *r_p;
+	void **rbuf_p;
+	int ret;
+	unsigned i;
+
+	if (pktio_entry->s.type == ODP_PKTIO_TYPE_IPC_SLAVE) {
+		r = pktio_entry->s.ipc_r_slave;
+		r_p = pktio_entry->s.ipc_p_slave;
+	} else if (pktio_entry->s.type == ODP_PKTIO_TYPE_IPC) {
+		r = pktio_entry->s.ipc_r;
+		r_p = pktio_entry->s.ipc_p;
+	} else
+		ODP_ABORT("wrong type: %d\n", pktio_entry->s.type);
+
+
+	/* Free already processed packets, if any */
+	{
+		unsigned complete_packets = odph_ring_count(r_p);
+		odp_packet_t r_p_pkts[PKTIO_IPC_ENTRIES];
+
+		if (complete_packets > 0) {
+			rbuf_p = (void *)&r_p_pkts;
+			ret = odph_ring_mc_dequeue_bulk(r_p, rbuf_p,
+					complete_packets);
+			if (ret == 0) {
+				for (i = 0; i < complete_packets; i++)
+					odp_buffer_free(_odp_packet_to_buffer(r_p_pkts[i]));
+			}
+		}
+	}
+
+	/* wait while second process takes packet from the ring.*/
+	i = 3;
+	while (odph_ring_free_count(r) < len && i) {
+		i --;
+		sleep(1);
+	}
+
+	/* Put packets to ring to be processed in other process. */
+	for (i = 0; i < len; i++) {
+		int j;
+		odp_packet_t pkt =  pkt_table[i];
+		rbuf_p = (void *)&pkt;
+		odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
+
+		/* buf_hdr.addr can not be used directly in remote process, convert it to offset */
+		for (j = 0; j < ODP_BUFFER_MAX_SEG; j++)
+			pkt_hdr->buf_hdr.ipc_addr_offset[j] = (char *)pkt_hdr -
+				(char*)pkt_hdr->buf_hdr.addr[j];
+
+		ret = odph_ring_mp_enqueue_bulk(r, rbuf_p, 1);
+		if (odp_unlikely(ret != 0)) {
+			ODP_ERR("pid %d odp_ring_mp_enqueue_bulk fail, ipc_slave %d, ret %d\n", getpid(),
+				(ODP_PKTIO_TYPE_IPC_SLAVE == pktio_entry->s.type), ret);
+			ODP_ERR("odp_ring_full: %d, odp_ring_count %d, odph_ring_free_count %d\n",
+				odph_ring_full(r), odph_ring_count(r), odph_ring_free_count(r));
+		}
+	}
+	return len;
+}
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 21f0c17..2d90d41 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -18,6 +18,7 @@
 #include <odp_schedule_internal.h>
 #include <odp_classification_internal.h>
 #include <odp_debug_internal.h>
+#include <odp_ipc.h>
 
 #include <string.h>
 #include <sys/ioctl.h>
@@ -25,6 +26,15 @@
 #include <ifaddrs.h>
 #include <errno.h>
 
+#include <sys/types.h>
+#include <unistd.h>
+
+/* IPC packet I/O over odph_ring */
+#include <odp/helper/ring.h>
+
+#define PKTIO_IPC_ENTRIES     4096 /**< number of odp buffers in
+					odp ring queue */
+
 /* MTU to be reported for the "loop" interface */
 #define PKTIO_LOOP_MTU 1500
 /* MAC address for the "loop" interface */
@@ -260,7 +270,12 @@ static odp_pktio_t setup_pktio_entry(const char *dev, odp_pool_t pool)
 
 	if (strcmp(dev, "loop") == 0)
 		ret = init_loop(pktio_entry, id);
-	else
+	else if (!strncmp(dev, "ipc", 3)) {
+		ret = ipc_pktio_init(pktio_entry, dev, pool);
+		if (ret != 0)
+			ODP_ABORT("unable to init ipc for %s, pool %" PRIu64 "\n",
+				  dev, pool);
+	} else
 		ret = init_socket(pktio_entry, dev, pool);
 
 	if (ret != 0) {
@@ -280,6 +295,10 @@ odp_pktio_t odp_pktio_open(const char *dev, odp_pool_t pool)
 {
 	odp_pktio_t id;
 
+	/* no local table lookup for ipc case */
+	if (pool == NULL && !memcmp(dev, "ipc", 3))
+		goto no_local_lookup;
+
 	id = odp_pktio_lookup(dev);
 	if (id != ODP_PKTIO_INVALID) {
 		/* interface is already open */
@@ -287,6 +306,7 @@ odp_pktio_t odp_pktio_open(const char *dev, odp_pool_t pool)
 		return ODP_PKTIO_INVALID;
 	}
 
+no_local_lookup:
 	odp_spinlock_lock(&pktio_tbl->lock);
 	id = setup_pktio_entry(dev, pool);
 	odp_spinlock_unlock(&pktio_tbl->lock);
@@ -403,6 +423,10 @@ int odp_pktio_recv(odp_pktio_t id, odp_packet_t pkt_table[], int len)
 	case ODP_PKTIO_TYPE_LOOPBACK:
 		pkts = deq_loopback(pktio_entry, pkt_table, len);
 		break;
+	case ODP_PKTIO_TYPE_IPC_SLAVE:
+	case ODP_PKTIO_TYPE_IPC:
+		pkts = ipc_pktio_recv(pktio_entry, pkt_table, len);
+		break;
 	default:
 		pkts = -1;
 		break;
@@ -457,6 +481,10 @@ int odp_pktio_send(odp_pktio_t id, odp_packet_t pkt_table[], int len)
 	case ODP_PKTIO_TYPE_LOOPBACK:
 		pkts = enq_loopback(pktio_entry, pkt_table, len);
 		break;
+	case ODP_PKTIO_TYPE_IPC:
+	case ODP_PKTIO_TYPE_IPC_SLAVE:
+		pkts = ipc_pktio_send(pktio_entry, pkt_table, len);
+		break;
 	default:
 		pkts = -1;
 	}
diff --git a/platform/linux-generic/odp_pool.c b/platform/linux-generic/odp_pool.c
index 468b7a5..9f2476b 100644
--- a/platform/linux-generic/odp_pool.c
+++ b/platform/linux-generic/odp_pool.c
@@ -219,8 +219,10 @@ odp_pool_t odp_pool_create(const char *name,
 			ODP_ALIGN_ROUNDUP(params->pkt.len, seg_len);
 
 		/* Reject create if pkt.len needs too many segments */
-		if (blk_size / seg_len > ODP_BUFFER_MAX_SEG)
+		if (blk_size / seg_len > ODP_BUFFER_MAX_SEG) {
+			ODP_DBG("Reject create if pkt.len needs too many segments\n");
 			return ODP_POOL_INVALID;
+		}
 
 		buf_stride = sizeof(odp_packet_hdr_stride);
 		break;
@@ -237,8 +239,10 @@ odp_pool_t odp_pool_create(const char *name,
 
 	/* Validate requested number of buffers against addressable limits */
 	if (buf_num >
-	    (ODP_BUFFER_MAX_BUFFERS / (buf_stride / ODP_CACHE_LINE_SIZE)))
+	    (ODP_BUFFER_MAX_BUFFERS / (buf_stride / ODP_CACHE_LINE_SIZE))) {
+		ODP_DBG("Validate requested number of buffers against addressable limits\n");
 		return ODP_POOL_INVALID;
+	}
 
 	/* Find an unused buffer pool slot and iniitalize it as requested */
 	for (i = 0; i < ODP_CONFIG_POOLS; i++) {
@@ -290,7 +294,8 @@ odp_pool_t odp_pool_create(const char *name,
 		if (shm == ODP_SHM_NULL) {
 			shm = odp_shm_reserve(pool->s.name,
 					      pool->s.pool_size,
-					      ODP_PAGE_SIZE, 0);
+					      ODP_PAGE_SIZE,
+					      params->shm_flags);
 			if (shm == ODP_SHM_INVALID) {
 				POOL_UNLOCK(&pool->s.lock);
 				return ODP_POOL_INVALID;
@@ -301,6 +306,8 @@ odp_pool_t odp_pool_create(const char *name,
 			if (odp_shm_info(shm, &info) != 0 ||
 			    info.size < pool->s.pool_size) {
 				POOL_UNLOCK(&pool->s.lock);
+				ODP_DBG("shm info %d, info size %ld, pool size %ld\n",
+					odp_shm_info(shm, &info), info.size, pool->s.pool_size);
 				return ODP_POOL_INVALID;
 			}
 			pool->s.pool_base_addr = odp_shm_addr(shm);
@@ -312,6 +319,7 @@ odp_pool_t odp_pool_create(const char *name,
 				    ((size_t)page_addr -
 				     (size_t)pool->s.pool_base_addr)) {
 					POOL_UNLOCK(&pool->s.lock);
+					ODP_DBG("wrong shm\n");
 					return ODP_POOL_INVALID;
 				}
 				pool->s.pool_base_addr = page_addr;
diff --git a/platform/linux-generic/odp_ring.c b/platform/linux-generic/odp_ring.c
index a24a020..0927a6c 100644
--- a/platform/linux-generic/odp_ring.c
+++ b/platform/linux-generic/odp_ring.c
@@ -159,8 +159,14 @@ odph_ring_create(const char *name, unsigned count, unsigned flags)
 	char ring_name[ODPH_RING_NAMESIZE];
 	odph_ring_t *r;
 	size_t ring_size;
+	uint32_t shm_flag;
 	odp_shm_t shm;
 
+	if (flags & ODPH_RING_SHM_PROC)
+		shm_flag = ODP_SHM_PROC;
+	else
+		shm_flag = 0;
+
 	/* count must be a power of 2 */
 	if (!ODP_VAL_IS_POWER_2(count) || (count > ODPH_RING_SZ_MASK)) {
 		ODP_ERR("Requested size is invalid, must be power of 2, and  do not exceed the size limit %u\n",
@@ -173,7 +179,8 @@ odph_ring_create(const char *name, unsigned count, unsigned flags)
 
 	odp_rwlock_write_lock(&qlock);
 	/* reserve a memory zone for this ring.*/
-	shm = odp_shm_reserve(ring_name, ring_size, ODP_CACHE_LINE_SIZE, 0);
+	shm = odp_shm_reserve(ring_name, ring_size, ODP_CACHE_LINE_SIZE,
+			      shm_flag);
 
 	r = odp_shm_addr(shm);
 
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index dd65168..dd9c9a6 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -101,6 +101,7 @@ int odp_schedule_init_global(void)
 		return -1;
 	}
 
+	memset(&params, 0, sizeof(params));
 	params.buf.size  = sizeof(queue_desc_t);
 	params.buf.align = 0;
 	params.buf.num   = SCHED_POOL_SIZE/sizeof(queue_desc_t);
diff --git a/platform/linux-generic/odp_shared_memory.c b/platform/linux-generic/odp_shared_memory.c
index ab48dda..d06b6a0 100644
--- a/platform/linux-generic/odp_shared_memory.c
+++ b/platform/linux-generic/odp_shared_memory.c
@@ -16,6 +16,7 @@
 #include <odp_debug_internal.h>
 #include <odp_align_internal.h>
 #include <odp/config.h>
+#include <odp/helper/ring.h>
 
 #include <unistd.h>
 #include <sys/mman.h>
@@ -189,7 +190,7 @@ odp_shm_t odp_shm_reserve(const char *name, uint64_t size, uint64_t align,
 	int fd = -1;
 	int map_flag = MAP_SHARED;
 	/* If already exists: O_EXCL: error, O_TRUNC: truncate to zero */
-	int oflag = O_RDWR | O_CREAT | O_TRUNC;
+	int oflag = O_RDWR;
 	uint64_t alloc_size;
 	uint64_t page_sz, huge_sz;
 #ifdef MAP_HUGETLB
@@ -207,7 +208,12 @@ odp_shm_t odp_shm_reserve(const char *name, uint64_t size, uint64_t align,
 	alloc_hp_size = (size + align + (huge_sz - 1)) & (-huge_sz);
 #endif
 
-	if (flags & ODP_SHM_PROC) {
+	if (flags & ODP_SHM_PROC)
+		oflag |= O_CREAT | O_TRUNC;
+
+	if (flags & (ODP_SHM_PROC | ODP_SHM_PROC_NOCREAT)) {
+		need_huge_page = 0;
+
 		/* Creates a file to /dev/shm */
 		fd = shm_open(name, oflag,
 			      S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
