Numa-aware, growable physical memory allocator (pmalloc)

Change-Id: Ic4c46bc733afae8bf0d8146623ed15633928de30
Signed-off-by: Damjan Marion <damarion@cisco.com>

33 files changed, 1300 insertions, 713 deletions

diff --git a/src/plugins/avf/avf.h b/src/plugins/avf/avf.h
index 187e5c2cd69..4fa19b11b73 100644
--- a/src/plugins/avf/avf.h
+++ b/src/plugins/avf/avf.h
@@ -26,7 +26,7 @@
   _(0, INITIALIZED, "initialized") \
   _(1, ERROR, "error") \
   _(2, ADMIN_UP, "admin-up") \
-  _(3, IOVA, "iova") \
+  _(3, VA_DMA, "vaddr-dma") \
   _(4, LINK_UP, "link-up") \
   _(5, SHARED_TXQ_LOCK, "shared-txq-lock") \
   _(6, ELOG, "elog")
@@ -188,8 +188,6 @@ typedef struct
 
   avf_device_t *devices;
   avf_per_thread_data_t *per_thread_data;
-  vlib_physmem_region_index_t physmem_region;
-  int physmem_region_alloc;
 
   vlib_log_class_t log_class;
 
diff --git a/src/plugins/avf/device.c b/src/plugins/avf/device.c
index 914c32cab4b..713953fe4c6 100644
--- a/src/plugins/avf/device.c
+++ b/src/plugins/avf/device.c
@@ -215,18 +215,23 @@ avf_cmd_rx_ctl_reg_write (vlib_main_t * vm, avf_device_t * ad, u32 reg,
 clib_error_t *
 avf_rxq_init (vlib_main_t * vm, avf_device_t * ad, u16 qid, u16 rxq_size)
 {
-  avf_main_t *am = &avf_main;
+  clib_error_t *err;
   avf_rxq_t *rxq;
-  clib_error_t *error = 0;
   u32 n_alloc, i;
 
   vec_validate_aligned (ad->rxqs, qid, CLIB_CACHE_LINE_BYTES);
   rxq = vec_elt_at_index (ad->rxqs, qid);
   rxq->size = rxq_size;
   rxq->next = 0;
-  rxq->descs = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					   rxq->size * sizeof (avf_rx_desc_t),
+  rxq->descs = vlib_physmem_alloc_aligned (vm, rxq->size *
+					   sizeof (avf_rx_desc_t),
 					   2 * CLIB_CACHE_LINE_BYTES);
+  if (rxq->descs == 0)
+    return vlib_physmem_last_error (vm);
+
+  if ((err = vlib_pci_map_dma (vm, ad->pci_dev_handle, (void *) rxq->descs)))
+    return err;
+
   clib_memset ((void *) rxq->descs, 0, rxq->size * sizeof (avf_rx_desc_t));
   vec_validate_aligned (rxq->bufs, rxq->size, CLIB_CACHE_LINE_BYTES);
   rxq->qrx_tail = ad->bar0 + AVF_QRX_TAIL (qid);
@@ -241,7 +246,7 @@ avf_rxq_init (vlib_main_t * vm, avf_device_t * ad, u16 qid, u16 rxq_size)
   for (i = 0; i < n_alloc; i++)
     {
       vlib_buffer_t *b = vlib_get_buffer (vm, rxq->bufs[i]);
-      if (ad->flags & AVF_DEVICE_F_IOVA)
+      if (ad->flags & AVF_DEVICE_F_VA_DMA)
 	d->qword[0] = vlib_buffer_get_va (b);
       else
 	d->qword[0] = vlib_buffer_get_pa (vm, b);
@@ -255,9 +260,8 @@ avf_rxq_init (vlib_main_t * vm, avf_device_t * ad, u16 qid, u16 rxq_size)
 clib_error_t *
 avf_txq_init (vlib_main_t * vm, avf_device_t * ad, u16 qid, u16 txq_size)
 {
-  avf_main_t *am = &avf_main;
+  clib_error_t *err;
   avf_txq_t *txq;
-  clib_error_t *error = 0;
 
   if (qid >= ad->num_queue_pairs)
     {
@@ -273,9 +277,15 @@ avf_txq_init (vlib_main_t * vm, avf_device_t * ad, u16 qid, u16 txq_size)
   txq = vec_elt_at_index (ad->txqs, qid);
   txq->size = txq_size;
   txq->next = 0;
-  txq->descs = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					   txq->size * sizeof (avf_tx_desc_t),
+  txq->descs = vlib_physmem_alloc_aligned (vm, txq->size *
+					   sizeof (avf_tx_desc_t),
 					   2 * CLIB_CACHE_LINE_BYTES);
+  if (txq->descs == 0)
+    return vlib_physmem_last_error (vm);
+
+  if ((err = vlib_pci_map_dma (vm, ad->pci_dev_handle, (void *) txq->descs)))
+    return err;
+
   vec_validate_aligned (txq->bufs, txq->size, CLIB_CACHE_LINE_BYTES);
   txq->qtx_tail = ad->bar0 + AVF_QTX_TAIL (qid);
 
@@ -305,10 +315,8 @@ avf_arq_slot_init (avf_device_t * ad, u16 slot)
 static inline uword
 avf_dma_addr (vlib_main_t * vm, avf_device_t * ad, void *p)
 {
-  avf_main_t *am = &avf_main;
-  return (ad->flags & AVF_DEVICE_F_IOVA) ?
-    pointer_to_uword (p) :
-    vlib_physmem_virtual_to_physical (vm, am->physmem_region, p);
+  return (ad->flags & AVF_DEVICE_F_VA_DMA) ?
+    pointer_to_uword (p) : vlib_physmem_get_pa (vm, p);
 }
 
 static void
@@ -1126,16 +1134,16 @@ avf_delete_if (vlib_main_t * vm, avf_device_t * ad)
 
   vlib_pci_device_close (vm, ad->pci_dev_handle);
 
-  vlib_physmem_free (vm, am->physmem_region, ad->atq);
-  vlib_physmem_free (vm, am->physmem_region, ad->arq);
-  vlib_physmem_free (vm, am->physmem_region, ad->atq_bufs);
-  vlib_physmem_free (vm, am->physmem_region, ad->arq_bufs);
+  vlib_physmem_free (vm, ad->atq);
+  vlib_physmem_free (vm, ad->arq);
+  vlib_physmem_free (vm, ad->atq_bufs);
+  vlib_physmem_free (vm, ad->arq_bufs);
 
   /* *INDENT-OFF* */
   vec_foreach_index (i, ad->rxqs)
     {
       avf_rxq_t *rxq = vec_elt_at_index (ad->rxqs, i);
-      vlib_physmem_free (vm, am->physmem_region, (void *) rxq->descs);
+      vlib_physmem_free (vm, (void *) rxq->descs);
       if (rxq->n_enqueued)
 	vlib_buffer_free_from_ring (vm, rxq->bufs, rxq->next, rxq->size,
 				    rxq->n_enqueued);
@@ -1148,7 +1156,7 @@ avf_delete_if (vlib_main_t * vm, avf_device_t * ad)
   vec_foreach_index (i, ad->txqs)
     {
       avf_txq_t *txq = vec_elt_at_index (ad->txqs, i);
-      vlib_physmem_free (vm, am->physmem_region, (void *) txq->descs);
+      vlib_physmem_free (vm, (void *) txq->descs);
       if (txq->n_enqueued)
 	{
 	  u16 first = (txq->next - txq->n_enqueued) & (txq->size -1);
@@ -1226,44 +1234,51 @@ avf_create_if (vlib_main_t * vm, avf_create_if_args_t * args)
   if ((error = vlib_pci_enable_msix_irq (vm, h, 0, 2)))
     goto error;
 
-  if (am->physmem_region_alloc == 0)
+  if (!(ad->atq = vlib_physmem_alloc (vm, sizeof (avf_aq_desc_t) *
+				      AVF_MBOX_LEN)))
     {
-      u32 flags = VLIB_PHYSMEM_F_INIT_MHEAP | VLIB_PHYSMEM_F_HUGETLB;
-      error = vlib_physmem_region_alloc (vm, "avf descriptors", 4 << 20, 0,
-					 flags, &am->physmem_region);
-      if (error)
-	goto error;
-      am->physmem_region_alloc = 1;
+      error = vlib_physmem_last_error (vm);
+      goto error;
     }
-  ad->atq = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					sizeof (avf_aq_desc_t) * AVF_MBOX_LEN,
-					64);
-  if (error)
+
+  if ((error = vlib_pci_map_dma (vm, h, ad->atq)))
     goto error;
 
-  ad->arq = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					sizeof (avf_aq_desc_t) * AVF_MBOX_LEN,
-					64);
-  if (error)
+  if (!(ad->arq = vlib_physmem_alloc (vm, sizeof (avf_aq_desc_t) *
+				      AVF_MBOX_LEN)))
+    {
+      error = vlib_physmem_last_error (vm);
+      goto error;
+    }
+
+  if ((error = vlib_pci_map_dma (vm, h, ad->arq)))
     goto error;
 
-  ad->atq_bufs = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					     AVF_MBOX_BUF_SZ * AVF_MBOX_LEN,
-					     64);
-  if (error)
+  if (!(ad->atq_bufs = vlib_physmem_alloc (vm, AVF_MBOX_BUF_SZ *
+					   AVF_MBOX_LEN)))
+    {
+      error = vlib_physmem_last_error (vm);
+      goto error;
+    }
+
+  if ((error = vlib_pci_map_dma (vm, h, ad->atq_bufs)))
     goto error;
 
-  ad->arq_bufs = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
-					     AVF_MBOX_BUF_SZ * AVF_MBOX_LEN,
-					     64);
-  if (error)
+  if (!(ad->arq_bufs = vlib_physmem_alloc (vm, AVF_MBOX_BUF_SZ *
+					   AVF_MBOX_LEN)))
+    {
+      error = vlib_physmem_last_error (vm);
+      goto error;
+    }
+
+  if ((error = vlib_pci_map_dma (vm, h, ad->arq_bufs)))
     goto error;
 
   if ((error = vlib_pci_intr_enable (vm, h)))
     goto error;
 
-  /* FIXME detect */
-  ad->flags |= AVF_DEVICE_F_IOVA;
+  if (vlib_pci_supports_virtual_addr_dma (vm, h))
+    ad->flags |= AVF_DEVICE_F_VA_DMA;
 
   if ((error = avf_device_init (vm, am, ad, args)))
     goto error;
diff --git a/src/plugins/avf/input.c b/src/plugins/avf/input.c
index efe3b0e0251..6d39ed646b5 100644
--- a/src/plugins/avf/input.c
+++ b/src/plugins/avf/input.c
@@ -48,7 +48,7 @@ static __clib_unused char *avf_input_error_strings[] = {
 #define AVF_INPUT_REFILL_TRESHOLD 32
 static_always_inline void
 avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
-		int use_iova)
+		int use_va_dma)
 {
   u16 n_refill, mask, n_alloc, slot;
   u32 s0, s1, s2, s3;
@@ -103,7 +103,7 @@ avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
       b[2] = vlib_get_buffer (vm, rxq->bufs[s2]);
       b[3] = vlib_get_buffer (vm, rxq->bufs[s3]);
 
-      if (use_iova)
+      if (use_va_dma)
 	{
 	  d[0]->qword[0] = vlib_buffer_get_va (b[0]);
 	  d[1]->qword[0] = vlib_buffer_get_va (b[1]);
@@ -132,7 +132,7 @@ avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
       s0 = slot;
       d[0] = ((avf_rx_desc_t *) rxq->descs) + s0;
       b[0] = vlib_get_buffer (vm, rxq->bufs[s0]);
-      if (use_iova)
+      if (use_va_dma)
 	d[0]->qword[0] = vlib_buffer_get_va (b[0]);
       else
 	d[0]->qword[0] = vlib_buffer_get_pa (vm, b[0]);
@@ -433,10 +433,10 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
     goto done;
 
   /* refill rx ring */
-  if (ad->flags & AVF_DEVICE_F_IOVA)
-    avf_rxq_refill (vm, node, rxq, 1 /* use_iova */ );
+  if (ad->flags & AVF_DEVICE_F_VA_DMA)
+    avf_rxq_refill (vm, node, rxq, 1 /* use_va_dma */ );
   else
-    avf_rxq_refill (vm, node, rxq, 0 /* use_iova */ );
+    avf_rxq_refill (vm, node, rxq, 0 /* use_va_dma */ );
 
   vlib_get_buffers (vm, buffer_indices, bufs, n_rxv);
   n_rx_packets = n_rxv;
diff --git a/src/plugins/avf/output.c b/src/plugins/avf/output.c
index c2c4b01d022..72892d16dff 100644
--- a/src/plugins/avf/output.c
+++ b/src/plugins/avf/output.c
@@ -118,7 +118,7 @@ retry:
       b2 = vlib_get_buffer (vm, bi2);
       b3 = vlib_get_buffer (vm, bi3);
 
-      if (ad->flags & AVF_DEVICE_F_IOVA)
+      if (ad->flags & AVF_DEVICE_F_VA_DMA)
 	{
 	  d0->qword[0] = vlib_buffer_get_current_va (b0);
 	  d1->qword[0] = vlib_buffer_get_current_va (b1);
@@ -151,7 +151,7 @@ retry:
       txq->bufs[next] = bi0;
       b0 = vlib_get_buffer (vm, bi0);
 
-      if (ad->flags & AVF_DEVICE_F_IOVA)
+      if (ad->flags & AVF_DEVICE_F_VA_DMA)
 	d0->qword[0] = vlib_buffer_get_current_va (b0);
       else
 	d0->qword[0] = vlib_buffer_get_current_pa (vm, b0);
diff --git a/src/plugins/dpdk/buffer.c b/src/plugins/dpdk/buffer.c
index f7ed932e35f..770e76d398e 100644
--- a/src/plugins/dpdk/buffer.c
+++ b/src/plugins/dpdk/buffer.c
@@ -393,12 +393,12 @@ dpdk_packet_template_init (vlib_main_t * vm,
 clib_error_t *
 dpdk_pool_create (vlib_main_t * vm, u8 * pool_name, u32 elt_size,
 		  u32 num_elts, u32 pool_priv_size, u16 cache_size, u8 numa,
-		  struct rte_mempool **_mp, vlib_physmem_region_index_t * pri)
+		  struct rte_mempool **_mp, u32 * map_index)
 {
   struct rte_mempool *mp;
   enum rte_iova_mode iova_mode;
-  vlib_physmem_region_t *pr;
   dpdk_mempool_private_t priv;
+  vlib_physmem_map_t *pm;
   clib_error_t *error = 0;
   size_t min_chunk_size, align;
   int map_dma = 1;
@@ -406,7 +406,6 @@ dpdk_pool_create (vlib_main_t * vm, u8 * pool_name, u32 elt_size,
   i32 ret;
   uword i;
 
-
   mp = rte_mempool_create_empty ((char *) pool_name, num_elts, elt_size,
 				 512, pool_priv_size, numa, 0);
   if (!mp)
@@ -417,16 +416,13 @@ dpdk_pool_create (vlib_main_t * vm, u8 * pool_name, u32 elt_size,
   size = rte_mempool_op_calc_mem_size_default (mp, num_elts, 21,
 					       &min_chunk_size, &align);
 
-  error = vlib_physmem_region_alloc (vm, (char *) pool_name, size, numa,
-				     VLIB_PHYSMEM_F_HUGETLB |
-				     VLIB_PHYSMEM_F_SHARED, pri);
-  if (error)
+  if ((error = vlib_physmem_shared_map_create (vm, (char *) pool_name, size,
+					       numa, map_index)))
     {
       rte_mempool_free (mp);
       return error;
     }
-
-  pr = vlib_physmem_get_region (vm, pri[0]);
+  pm = vlib_physmem_get_map (vm, *map_index);
 
   /* Call the mempool priv initializer */
   priv.mbp_priv.mbuf_data_room_size = VLIB_BUFFER_PRE_DATA_SIZE +
@@ -438,12 +434,12 @@ dpdk_pool_create (vlib_main_t * vm, u8 * pool_name, u32 elt_size,
     map_dma = 0;
 
   iova_mode = rte_eal_iova_mode ();
-  for (i = 0; i < pr->n_pages; i++)
+  for (i = 0; i < pm->n_pages; i++)
     {
-      size_t page_sz = 1ull << pr->log2_page_size;
-      char *va = ((char *) pr->mem) + i * page_sz;
+      size_t page_sz = 1ULL << pm->log2_page_size;
+      char *va = ((char *) pm->base) + i * page_sz;
       uword pa = iova_mode == RTE_IOVA_VA ?
-	pointer_to_uword (va) : pr->page_table[i];
+	pointer_to_uword (va) : pm->page_table[i];
       ret = rte_mempool_populate_iova (mp, va, pa, page_sz, 0, 0);
       if (ret < 0)
 	{
@@ -467,10 +463,10 @@ dpdk_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
 {
   dpdk_main_t *dm = &dpdk_main;
   struct rte_mempool *rmp;
-  vlib_physmem_region_index_t pri;
   clib_error_t *error = 0;
   u8 *pool_name;
   u32 elt_size, i;
+  u32 map_index;
 
   vec_validate_aligned (dm->pktmbuf_pools, socket_id, CLIB_CACHE_LINE_BYTES);
 
@@ -484,10 +480,9 @@ dpdk_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
     VLIB_BUFFER_HDR_SIZE /* priv size */  +
     VLIB_BUFFER_PRE_DATA_SIZE + VLIB_BUFFER_DATA_SIZE;	/*data room size */
 
-  error =
-    dpdk_pool_create (vm, pool_name, elt_size, num_mbufs,
-		      sizeof (dpdk_mempool_private_t), 512, socket_id,
-		      &rmp, &pri);
+  error = dpdk_pool_create (vm, pool_name, elt_size, num_mbufs,
+			    sizeof (dpdk_mempool_private_t), 512, socket_id,
+			    &rmp, &map_index);
 
   vec_free (pool_name);
 
@@ -497,7 +492,8 @@ dpdk_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
       rte_mempool_obj_iter (rmp, rte_pktmbuf_init, 0);
 
       dpdk_mempool_private_t *privp = rte_mempool_get_priv (rmp);
-      privp->buffer_pool_index = vlib_buffer_pool_create (vm, pri, 0);
+      privp->buffer_pool_index =
+	vlib_buffer_register_physmem_map (vm, map_index);
 
       dm->pktmbuf_pools[socket_id] = rmp;
 
diff --git a/src/plugins/dpdk/device/dpdk.h b/src/plugins/dpdk/device/dpdk.h
index c4f908ea408..46d53f1d895 100644
--- a/src/plugins/dpdk/device/dpdk.h
+++ b/src/plugins/dpdk/device/dpdk.h
@@ -527,8 +527,7 @@ clib_error_t *unformat_hqos (unformat_input_t * input,
 clib_error_t *dpdk_pool_create (vlib_main_t * vm, u8 * pool_name,
 				u32 elt_size, u32 num_elts,
 				u32 pool_priv_size, u16 cache_size, u8 numa,
-				struct rte_mempool **_mp,
-				vlib_physmem_region_index_t * pri);
+				struct rte_mempool **_mp, u32 * map_index);
 
 clib_error_t *dpdk_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
 				       unsigned socket_id);
diff --git a/src/plugins/dpdk/ipsec/ipsec.c b/src/plugins/dpdk/ipsec/ipsec.c
index ded8912e943..bcc4b62ad76 100644
--- a/src/plugins/dpdk/ipsec/ipsec.c
+++ b/src/plugins/dpdk/ipsec/ipsec.c
@@ -827,7 +827,7 @@ crypto_create_crypto_op_pool (vlib_main_t * vm, u8 numa)
   struct rte_crypto_op_pool_private *priv;
   struct rte_mempool *mp;
   clib_error_t *error = NULL;
-  vlib_physmem_region_index_t pri;
+  u32 map_index;
 
   data = vec_elt_at_index (dcm->data, numa);
 
@@ -837,9 +837,8 @@ crypto_create_crypto_op_pool (vlib_main_t * vm, u8 numa)
 
   pool_name = format (0, "crypto_pool_numa%u%c", numa, 0);
 
-  error =
-    dpdk_pool_create (vm, pool_name, crypto_op_len (), conf->num_mbufs,
-		      pool_priv_size, 512, numa, &mp, &pri);
+  error = dpdk_pool_create (vm, pool_name, crypto_op_len (), conf->num_mbufs,
+			    pool_priv_size, 512, numa, &mp, &map_index);
 
   vec_free (pool_name);
 
@@ -867,8 +866,8 @@ crypto_create_session_h_pool (vlib_main_t * vm, u8 numa)
   u8 *pool_name;
   struct rte_mempool *mp;
   clib_error_t *error = NULL;
-  vlib_physmem_region_index_t pri;
   u32 elt_size;
+  u32 map_index;
 
   data = vec_elt_at_index (dcm->data, numa);
 
@@ -880,9 +879,8 @@ crypto_create_session_h_pool (vlib_main_t * vm, u8 numa)
 
   elt_size = rte_cryptodev_sym_get_header_session_size ();
 
-  error =
-    dpdk_pool_create (vm, pool_name, elt_size, DPDK_CRYPTO_NB_SESS_OBJS,
-		      0, 512, numa, &mp, &pri);
+  error = dpdk_pool_create (vm, pool_name, elt_size, DPDK_CRYPTO_NB_SESS_OBJS,
+			    0, 512, numa, &mp, &map_index);
 
   vec_free (pool_name);
 
@@ -902,9 +900,9 @@ crypto_create_session_drv_pool (vlib_main_t * vm, crypto_dev_t * dev)
   u8 *pool_name;
   struct rte_mempool *mp;
   clib_error_t *error = NULL;
-  vlib_physmem_region_index_t pri;
   u32 elt_size;
   u8 numa = dev->numa;
+  u32 map_index;
 
   data = vec_elt_at_index (dcm->data, numa);
 
@@ -920,9 +918,8 @@ crypto_create_session_drv_pool (vlib_main_t * vm, crypto_dev_t * dev)
 
   elt_size = rte_cryptodev_sym_get_private_session_size (dev->id);
 
-  error =
-    dpdk_pool_create (vm, pool_name, elt_size, DPDK_CRYPTO_NB_SESS_OBJS,
-		      0, 512, numa, &mp, &pri);
+  error = dpdk_pool_create (vm, pool_name, elt_size, DPDK_CRYPTO_NB_SESS_OBJS,
+			    0, 512, numa, &mp, &map_index);
 
   vec_free (pool_name);
 
diff --git a/src/plugins/ixge/ixge.c b/src/plugins/ixge/ixge.c
index 3c4a5b4bbfc..5dc22bed3a5 100644
--- a/src/plugins/ixge/ixge.c
+++ b/src/plugins/ixge/ixge.c
@@ -2488,13 +2488,11 @@ ixge_dma_init (ixge_device_t * xd, vlib_rx_or_tx_t rt, u32 queue_index)
     round_pow2 (xm->n_descriptors[rt], xm->n_descriptors_per_cache_line);
   dq->head_index = dq->tail_index = 0;
 
-  dq->descriptors =
-    vlib_physmem_alloc_aligned (vm, xm->physmem_region, &error,
-				dq->n_descriptors *
-				sizeof (dq->descriptors[0]),
-				128 /* per chip spec */ );
-  if (error)
-    return error;
+  dq->descriptors = vlib_physmem_alloc_aligned (vm, dq->n_descriptors *
+						sizeof (dq->descriptors[0]),
+						128 /* per chip spec */ );
+  if (!dq->descriptors)
+    return vlib_physmem_last_error (vm);
 
   clib_memset (dq->descriptors, 0,
 	       dq->n_descriptors * sizeof (dq->descriptors[0]));
@@ -2518,10 +2516,10 @@ ixge_dma_init (ixge_device_t * xd, vlib_rx_or_tx_t rt, u32 queue_index)
     {
       u32 i;
 
-      dq->tx.head_index_write_back = vlib_physmem_alloc (vm,
-							 xm->physmem_region,
-							 &error,
-							 CLIB_CACHE_LINE_BYTES);
+      dq->tx.head_index_write_back =
+	vlib_physmem_alloc (vm, CLIB_CACHE_LINE_BYTES);
+      if (!dq->tx.head_index_write_back)
+	return vlib_physmem_last_error (vm);
 
       for (i = 0; i < dq->n_descriptors; i++)
 	dq->descriptors[i].tx = xm->tx_descriptor_template;
@@ -2533,9 +2531,7 @@ ixge_dma_init (ixge_device_t * xd, vlib_rx_or_tx_t rt, u32 queue_index)
     ixge_dma_regs_t *dr = get_dma_regs (xd, rt, queue_index);
     u64 a;
 
-    a =
-      vlib_physmem_virtual_to_physical (vm, xm->physmem_region,
-					dq->descriptors);
+    a = vlib_physmem_get_pa (vm, dq->descriptors);
     dr->descriptor_address[0] = a & 0xFFFFFFFF;
     dr->descriptor_address[1] = a >> (u64) 32;
     dr->n_descriptor_bytes = dq->n_descriptors * sizeof (dq->descriptors[0]);
@@ -2560,8 +2556,7 @@ ixge_dma_init (ixge_device_t * xd, vlib_rx_or_tx_t rt, u32 queue_index)
 	/* Make sure its initialized before hardware can get to it. */
 	dq->tx.head_index_write_back[0] = dq->head_index;
 
-	a = vlib_physmem_virtual_to_physical (vm, xm->physmem_region,
-					      dq->tx.head_index_write_back);
+	a = vlib_physmem_get_pa (vm, dq->tx.head_index_write_back);
 	dr->tx.head_index_write_back_address[0] = /* enable bit */ 1 | a;
 	dr->tx.head_index_write_back_address[1] = (u64) a >> (u64) 32;
       }
@@ -2848,14 +2843,6 @@ ixge_pci_init (vlib_main_t * vm, vlib_pci_dev_handle_t h)
   vlib_pci_addr_t *addr = vlib_pci_get_addr (vm, h);
   vlib_pci_device_info_t *d = vlib_pci_get_device_info (vm, addr, 0);
 
-  /* Allocate physmem region for DMA buffers */
-  if (xm->physmem_region_allocated == 0)
-    {
-      error = vlib_physmem_region_alloc (vm, "ixge decriptors", 2 << 20, 0,
-					 VLIB_PHYSMEM_F_INIT_MHEAP,
-					 &xm->physmem_region);
-      xm->physmem_region_allocated = 1;
-    }
   if (error)
     return error;
 
diff --git a/src/plugins/ixge/ixge.h b/src/plugins/ixge/ixge.h
index c766397525b..f80d9c0e7cf 100644
--- a/src/plugins/ixge/ixge.h
+++ b/src/plugins/ixge/ixge.h
@@ -1265,8 +1265,6 @@ typedef struct
 
   f64 time_last_stats_update;
 
-  vlib_physmem_region_index_t physmem_region;
-  int physmem_region_allocated;
 } ixge_main_t;
 
 extern ixge_main_t ixge_main;
diff --git a/src/plugins/memif/memif.c b/src/plugins/memif/memif.c
index 763572c2f0e..f976f16dec8 100644
--- a/src/plugins/memif/memif.c
+++ b/src/plugins/memif/memif.c
@@ -340,12 +340,12 @@ memif_init_regions_and_queues (memif_if_t * mif)
       /* *INDENT-OFF* */
       vec_foreach (bp, buffer_main.buffer_pools)
 	{
-	  vlib_physmem_region_t *pr;
-	  pr = vlib_physmem_get_region (vm, bp->physmem_region);
+	  vlib_physmem_map_t *pm;
+	  pm = vlib_physmem_get_map (vm, bp->physmem_map_index);
 	  vec_add2_aligned (mif->regions, r, 1, CLIB_CACHE_LINE_BYTES);
-	  r->fd = pr->fd;
-	  r->region_size = pr->size;
-	  r->shm = pr->mem;
+	  r->fd = pm->fd;
+	  r->region_size = pm->n_pages << pm->log2_page_size;
+	  r->shm = pm->base;
 	  r->is_external = 1;
 	}
       /* *INDENT-ON* */
diff --git a/src/plugins/vmxnet3/vmxnet3.c b/src/plugins/vmxnet3/vmxnet3.c
index e34b3e69a27..f60a8fe2215 100644
--- a/src/plugins/vmxnet3/vmxnet3.c
+++ b/src/plugins/vmxnet3/vmxnet3.c
@@ -139,19 +139,16 @@ vmxnet3_write_mac (vmxnet3_device_t * vd)
 static clib_error_t *
 vmxnet3_provision_driver_shared (vlib_main_t * vm, vmxnet3_device_t * vd)
 {
-  vmxnet3_main_t *vmxm = &vmxnet3_main;
   vmxnet3_shared *shared;
   vmxnet3_queues *q;
   u64 shared_dma;
-  clib_error_t *error;
   u16 qid = 0, rid;
   vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
   vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, qid);
 
-  vd->dma = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
-					sizeof (*vd->dma), 512);
-  if (error)
-    return error;
+  vd->dma = vlib_physmem_alloc_aligned (vm, sizeof (*vd->dma), 512);
+  if (vd->dma == 0)
+    return vlib_physmem_last_error (vm);
 
   clib_memset (vd->dma, 0, sizeof (*vd->dma));
 
@@ -222,9 +219,7 @@ vmxnet3_disable_interrupt (vmxnet3_device_t * vd)
 static clib_error_t *
 vmxnet3_rxq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 {
-  vmxnet3_main_t *vmxm = &vmxnet3_main;
   vmxnet3_rxq_t *rxq;
-  clib_error_t *error;
   u16 rid;
 
   vec_validate_aligned (vd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
@@ -233,19 +228,19 @@ vmxnet3_rxq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
   rxq->size = qsz;
   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
     {
-      rxq->rx_desc[rid] =
-	vlib_physmem_alloc_aligned (vm, vmxm->physmem_region,
-				    &error, qsz * sizeof (*rxq->rx_desc[rid]),
-				    512);
-      if (error)
-	return error;
+      rxq->rx_desc[rid] = vlib_physmem_alloc_aligned
+	(vm, qsz * sizeof (*rxq->rx_desc[rid]), 512);
+
+      if (rxq->rx_desc[rid] == 0)
+	return vlib_physmem_last_error (vm);
+
       clib_memset (rxq->rx_desc[rid], 0, qsz * sizeof (*rxq->rx_desc[rid]));
     }
-  rxq->rx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
-					     qsz * sizeof (*rxq->rx_comp),
+  rxq->rx_comp = vlib_physmem_alloc_aligned (vm, qsz * sizeof (*rxq->rx_comp),
 					     512);
-  if (error)
-    return error;
+  if (rxq->rx_comp == 0)
+    return vlib_physmem_last_error (vm);
+
   clib_memset (rxq->rx_comp, 0, qsz * sizeof (*rxq->rx_comp));
   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
     {
@@ -264,9 +259,7 @@ vmxnet3_rxq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 static clib_error_t *
 vmxnet3_txq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 {
-  vmxnet3_main_t *vmxm = &vmxnet3_main;
   vmxnet3_txq_t *txq;
-  clib_error_t *error;
 
   if (qid >= vd->num_tx_queues)
     {
@@ -282,17 +275,17 @@ vmxnet3_txq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
   txq = vec_elt_at_index (vd->txqs, qid);
   clib_memset (txq, 0, sizeof (*txq));
   txq->size = qsz;
-  txq->tx_desc = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
-					     qsz * sizeof (*txq->tx_desc),
+  txq->tx_desc = vlib_physmem_alloc_aligned (vm, qsz * sizeof (*txq->tx_desc),
 					     512);
-  if (error)
-    return error;
-  clib_memset (txq->tx_desc, 0, qsz * sizeof (*txq->tx_desc));
-  txq->tx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
-					     qsz * sizeof (*txq->tx_comp),
+  if (txq->tx_desc == 0)
+    return vlib_physmem_last_error (vm);
+
+  memset (txq->tx_desc, 0, qsz * sizeof (*txq->tx_desc));
+  txq->tx_comp = vlib_physmem_alloc_aligned (vm, qsz * sizeof (*txq->tx_comp),
 					     512);
-  if (error)
-    return error;
+  if (txq->tx_comp == 0)
+    return vlib_physmem_last_error (vm);
+
   clib_memset (txq->tx_comp, 0, qsz * sizeof (*txq->tx_comp));
   vec_validate_aligned (txq->tx_ring.bufs, txq->size, CLIB_CACHE_LINE_BYTES);
   txq->tx_ring.gen = VMXNET3_TXF_GEN;
@@ -307,7 +300,6 @@ vmxnet3_device_init (vlib_main_t * vm, vmxnet3_device_t * vd,
 {
   clib_error_t *error = 0;
   u32 ret, i;
-  vmxnet3_main_t *vmxm = &vmxnet3_main;
   vlib_thread_main_t *tm = vlib_get_thread_main ();
 
   vd->num_tx_queues = 1;
@@ -372,17 +364,6 @@ vmxnet3_device_init (vlib_main_t * vm, vmxnet3_device_t * vd,
   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_MACH);
   clib_memcpy (vd->mac_addr + 4, &ret, 2);
 
-  if (vmxm->physmem_region_alloc == 0)
-    {
-      u32 flags = VLIB_PHYSMEM_F_INIT_MHEAP | VLIB_PHYSMEM_F_HUGETLB;
-      error =
-	vlib_physmem_region_alloc (vm, "vmxnet3 descriptors", 4 << 20, 0,
-				   flags, &vmxm->physmem_region);
-      if (error)
-	return error;
-      vmxm->physmem_region_alloc = 1;
-    }
-
   error = vmxnet3_rxq_init (vm, vd, 0, args->rxq_size);
   if (error)
     return error;
@@ -629,9 +610,9 @@ vmxnet3_delete_if (vlib_main_t * vm, vmxnet3_device_t * vd)
 	  vlib_buffer_free_from_ring (vm, ring->bufs, desc_idx, rxq->size,
 				      ring->fill);
 	  vec_free (ring->bufs);
-	  vlib_physmem_free (vm, vmxm->physmem_region, rxq->rx_desc[rid]);
+	  vlib_physmem_free (vm, rxq->rx_desc[rid]);
 	}
-      vlib_physmem_free (vm, vmxm->physmem_region, rxq->rx_comp);
+      vlib_physmem_free (vm, rxq->rx_comp);
     }
   /* *INDENT-ON* */
   vec_free (vd->rxqs);
@@ -654,13 +635,13 @@ vmxnet3_delete_if (vlib_main_t * vm, vmxnet3_device_t * vd)
 	}
       clib_spinlock_free (&txq->lock);
       vec_free (txq->tx_ring.bufs);
-      vlib_physmem_free (vm, vmxm->physmem_region, txq->tx_desc);
-      vlib_physmem_free (vm, vmxm->physmem_region, txq->tx_comp);
+      vlib_physmem_free (vm, txq->tx_desc);
+      vlib_physmem_free (vm, txq->tx_comp);
     }
   /* *INDENT-ON* */
   vec_free (vd->txqs);
 
-  vlib_physmem_free (vm, vmxm->physmem_region, vd->dma);
+  vlib_physmem_free (vm, vd->dma);
 
   clib_error_free (vd->error);
   clib_memset (vd, 0, sizeof (*vd));
diff --git a/src/plugins/vmxnet3/vmxnet3.h b/src/plugins/vmxnet3/vmxnet3.h
index 391ddc17113..befbe368d67 100644
--- a/src/plugins/vmxnet3/vmxnet3.h
+++ b/src/plugins/vmxnet3/vmxnet3.h
@@ -493,8 +493,6 @@ typedef struct
 typedef struct
 {
   vmxnet3_device_t *devices;
-  vlib_physmem_region_index_t physmem_region;
-  u32 physmem_region_alloc;
   u16 msg_id_base;
 } vmxnet3_main_t;
 
@@ -546,10 +544,8 @@ vmxnet3_reg_read (vmxnet3_device_t * vd, u8 bar, u32 addr)
 static_always_inline uword
 vmxnet3_dma_addr (vlib_main_t * vm, vmxnet3_device_t * vd, void *p)
 {
-  vmxnet3_main_t *vmxm = &vmxnet3_main;
-
   return (vd->flags & VMXNET3_DEVICE_F_IOVA) ? pointer_to_uword (p) :
-    vlib_physmem_virtual_to_physical (vm, vmxm->physmem_region, p);
+    vlib_physmem_get_pa (vm, p);
 }
 
 static_always_inline void
diff --git a/src/vlib/CMakeLists.txt b/src/vlib/CMakeLists.txt
index 72c73f3c2d8..2a6cbd54da2 100644
--- a/src/vlib/CMakeLists.txt
+++ b/src/vlib/CMakeLists.txt
@@ -39,7 +39,6 @@ add_vpp_library(vlib
   i2c.c
   init.c
   linux/pci.c
-  linux/physmem.c
   linux/vfio.c
   log.c
   main.c
@@ -47,6 +46,7 @@ add_vpp_library(vlib
   node_cli.c
   node_format.c
   pci/pci.c
+  physmem.c
   threads.c
   threads_cli.c
   trace.c
diff --git a/src/vlib/buffer.c b/src/vlib/buffer.c
index ee76290e25a..711b83514f4 100644
--- a/src/vlib/buffer.c
+++ b/src/vlib/buffer.c
@@ -470,26 +470,10 @@ vlib_buffer_delete_free_list_internal (vlib_main_t * vm,
 }
 
 static_always_inline void *
-vlib_buffer_pool_get_buffer (vlib_buffer_pool_t * bp)
+vlib_buffer_pool_get_buffer (vlib_main_t * vm, vlib_buffer_pool_t * bp)
 {
-  uword slot, page, addr;
-
-  if (PREDICT_FALSE (bp->n_elts == bp->n_used))
-    {
-      clib_spinlock_unlock (&bp->lock);
-      return 0;
-    }
-  slot = bp->next_clear;
-  bp->bitmap = clib_bitmap_set (bp->bitmap, slot, 1);
-  bp->next_clear = clib_bitmap_next_clear (bp->bitmap, slot + 1);
-  bp->n_used++;
-
-  page = slot / bp->buffers_per_page;
-  slot -= page * bp->buffers_per_page;
-
-  addr = bp->start + (page << bp->log2_page_size) + slot * bp->buffer_size;
-
-  return uword_to_pointer (addr, void *);
+  return vlib_physmem_alloc_from_map (vm, bp->physmem_map_index,
+				      bp->buffer_size, CLIB_CACHE_LINE_BYTES);
 }
 
 /* Make sure free list has at least given number of free buffers. */
@@ -533,7 +517,7 @@ vlib_buffer_fill_free_list_internal (vlib_main_t * vm,
   clib_spinlock_lock (&bp->lock);
   while (n_alloc < n)
     {
-      if ((b = vlib_buffer_pool_get_buffer (bp)) == 0)
+      if ((b = vlib_buffer_pool_get_buffer (vm, bp)) == 0)
 	goto done;
 
       n_alloc += 1;
@@ -866,14 +850,13 @@ vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
 }
 
 u8
-vlib_buffer_pool_create (vlib_main_t * vm, vlib_physmem_region_index_t pri,
-			 u16 buffer_size)
+vlib_buffer_register_physmem_map (vlib_main_t * vm, u32 physmem_map_index)
 {
   vlib_buffer_main_t *bm = &buffer_main;
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, pri);
   vlib_buffer_pool_t *p;
-  uword start = pointer_to_uword (pr->mem);
-  uword size = pr->size;
+  vlib_physmem_map_t *m = vlib_physmem_get_map (vm, physmem_map_index);
+  uword start = pointer_to_uword (m->base);
+  uword size = m->n_pages << m->log2_page_size;
 
   if (bm->buffer_mem_size == 0)
     {
@@ -903,18 +886,8 @@ vlib_buffer_pool_create (vlib_main_t * vm, vlib_physmem_region_index_t pri,
   vec_add2 (bm->buffer_pools, p, 1);
   p->start = start;
   p->size = size;
-  p->physmem_region = pri;
-
-  if (buffer_size == 0)
-    goto done;
+  p->physmem_map_index = physmem_map_index;
 
-  p->log2_page_size = pr->log2_page_size;
-  p->buffer_size = buffer_size;
-  p->buffers_per_page = (1ull << pr->log2_page_size) / p->buffer_size;
-  p->n_elts = p->buffers_per_page * pr->n_pages;
-  p->n_used = 0;
-  clib_spinlock_init (&p->lock);
-done:
   ASSERT (p - bm->buffer_pools < 256);
   return p - bm->buffer_pools;
 }
@@ -983,8 +956,9 @@ clib_error_t *
 vlib_buffer_main_init (struct vlib_main_t * vm)
 {
   vlib_buffer_main_t *bm = &buffer_main;
-  vlib_physmem_region_index_t pri;
   clib_error_t *error;
+  u32 physmem_map_index;
+  u8 pool_index;
 
   if (vlib_buffer_callbacks)
     {
@@ -1003,25 +977,18 @@ vlib_buffer_main_init (struct vlib_main_t * vm)
     &vlib_buffer_delete_free_list_internal;
   clib_spinlock_init (&bm->buffer_known_hash_lockp);
 
-  /* allocate default region */
-  error = vlib_physmem_region_alloc (vm, "buffers",
-				     vlib_buffer_physmem_sz, 0,
-				     VLIB_PHYSMEM_F_SHARED |
-				     VLIB_PHYSMEM_F_HUGETLB, &pri);
+  if ((error = vlib_physmem_shared_map_create (vm, "buffers",
+					       vlib_buffer_physmem_sz, 1,
+					       &physmem_map_index)))
+    return error;
 
-  if (error == 0)
-    goto done;
+  pool_index = vlib_buffer_register_physmem_map (vm, physmem_map_index);
+  vlib_buffer_pool_t *bp = vlib_buffer_pool_get (pool_index);
+  clib_spinlock_init (&bp->lock);
+  bp->buffer_size = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES +
+    sizeof (vlib_buffer_t);
 
-  clib_error_free (error);
-
-  error = vlib_physmem_region_alloc (vm, "buffers",
-				     vlib_buffer_physmem_sz, 0,
-				     VLIB_PHYSMEM_F_SHARED, &pri);
-done:
-  if (error == 0)
-    vlib_buffer_pool_create (vm, pri, sizeof (vlib_buffer_t) +
-			     VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES);
-  return error;
+  return 0;
 }
 
 static clib_error_t *
diff --git a/src/vlib/buffer.h b/src/vlib/buffer.h
index 0d24779e52b..f9750ecf3e1 100644
--- a/src/vlib/buffer.h
+++ b/src/vlib/buffer.h
@@ -412,16 +412,9 @@ typedef struct
   uword start;
   uword size;
   uword log2_page_size;
-  vlib_physmem_region_index_t physmem_region;
-
+  u32 physmem_map_index;
+  u32 buffer_size;
   u32 *buffers;
-
-  u16 buffer_size;
-  uword buffers_per_page;
-  uword n_elts;
-  uword n_used;
-  uword next_clear;
-  uword *bitmap;
   clib_spinlock_t lock;
 } vlib_buffer_pool_t;
 
@@ -466,9 +459,8 @@ vlib_buffer_pool_get (u8 buffer_pool_index)
   return vec_elt_at_index (bm->buffer_pools, buffer_pool_index);
 }
 
-u8 vlib_buffer_pool_create (struct vlib_main_t * vm,
-			    vlib_physmem_region_index_t region,
-			    u16 buffer_size);
+u8 vlib_buffer_register_physmem_map (struct vlib_main_t * vm,
+				     u32 physmem_map_index);
 
 clib_error_t *vlib_buffer_main_init (struct vlib_main_t *vm);
 
diff --git a/src/vlib/buffer_funcs.h b/src/vlib/buffer_funcs.h
index 1110c206e52..6106b7984a2 100644
--- a/src/vlib/buffer_funcs.h
+++ b/src/vlib/buffer_funcs.h
@@ -317,10 +317,7 @@ vlib_buffer_contents (vlib_main_t * vm, u32 buffer_index, u8 * contents)
 always_inline uword
 vlib_buffer_get_pa (vlib_main_t * vm, vlib_buffer_t * b)
 {
-  vlib_buffer_main_t *bm = &buffer_main;
-  vlib_buffer_pool_t *pool = vec_elt_at_index (bm->buffer_pools,
-					       b->buffer_pool_index);
-  return vlib_physmem_virtual_to_physical (vm, pool->physmem_region, b->data);
+  return vlib_physmem_get_pa (vm, b->data);
 }
 
 always_inline uword
diff --git a/src/vlib/linux/pci.c b/src/vlib/linux/pci.c
index b55fb5042f7..0e2241b0e58 100644
--- a/src/vlib/linux/pci.c
+++ b/src/vlib/linux/pci.c
@@ -951,6 +951,21 @@ add_device_vfio (vlib_main_t * vm, linux_pci_device_t * p,
       linux_pci_vfio_unmask_intx (vm, p);
     }
 
+  if (p->supports_va_dma)
+    {
+      vlib_buffer_pool_t *bp;
+      /* *INDENT-OFF* */
+      vec_foreach (bp, buffer_main.buffer_pools)
+	{
+	  u32 i;
+	  vlib_physmem_map_t *pm;
+	  pm = vlib_physmem_get_map (vm, bp->physmem_map_index);
+	  for (i = 0; i < pm->n_pages; i++)
+	    vfio_map_physmem_page (vm, pm->base + (i << pm->log2_page_size));
+	}
+      /* *INDENT-ON* */
+    }
+
   if (r && r->init_function)
     err = r->init_function (lpm->vlib_main, p->handle);
 
@@ -1092,6 +1107,25 @@ vlib_pci_map_region_fixed (vlib_main_t * vm, vlib_pci_dev_handle_t h,
 }
 
 clib_error_t *
+vlib_pci_map_dma (vlib_main_t * vm, vlib_pci_dev_handle_t h, void *ptr)
+{
+  linux_pci_device_t *p = linux_pci_get_device (h);
+
+  if (!p->supports_va_dma)
+    return 0;
+
+  return vfio_map_physmem_page (vm, ptr);
+}
+
+int
+vlib_pci_supports_virtual_addr_dma (vlib_main_t * vm, vlib_pci_dev_handle_t h)
+{
+  linux_pci_device_t *p = linux_pci_get_device (h);
+
+  return p->supports_va_dma != 0;
+}
+
+clib_error_t *
 vlib_pci_device_open (vlib_main_t * vm, vlib_pci_addr_t * addr,
 		      pci_device_id_t ids[], vlib_pci_dev_handle_t * handle)
 {
diff --git a/src/vlib/linux/physmem.c b/src/vlib/linux/physmem.c
deleted file mode 100755
index 90b0f8cab3d..00000000000
--- a/src/vlib/linux/physmem.c
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * Copyright (c) 2015 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
- * physmem.c: Unix physical memory
- *
- * Copyright (c) 2008 Eliot Dresselhaus
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/mount.h>
-#include <sys/mman.h>
-#include <sys/fcntl.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <vppinfra/linux/syscall.h>
-#include <vppinfra/linux/sysfs.h>
-#include <vlib/vlib.h>
-#include <vlib/physmem.h>
-#include <vlib/unix/unix.h>
-#include <vlib/pci/pci.h>
-#include <vlib/linux/vfio.h>
-
-static void *
-unix_physmem_alloc_aligned (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-			    uword n_bytes, uword alignment)
-{
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  uword lo_offset, hi_offset;
-  uword *to_free = 0;
-
-  if (pr->heap == 0)
-    return 0;
-
-  /* IO memory is always at least cache aligned. */
-  alignment = clib_max (alignment, CLIB_CACHE_LINE_BYTES);
-
-  while (1)
-    {
-#if USE_DLMALLOC == 0
-
-      mheap_get_aligned (pr->heap, n_bytes,
-			 /* align */ alignment,
-			 /* align offset */ 0,
-			 &lo_offset);
-#else
-      lo_offset = (uword) mspace_get_aligned (pr->heap, n_bytes,
-					      alignment, ~0ULL /* offset */ );
-      if (lo_offset == 0)
-	lo_offset = ~0ULL;
-#endif
-
-      /* Allocation failed? */
-      if (lo_offset == ~0)
-	break;
-
-      /* Make sure allocation does not span DMA physical chunk boundary. */
-      hi_offset = lo_offset + n_bytes - 1;
-
-      if (((pointer_to_uword (pr->heap) + lo_offset) >> pr->log2_page_size) ==
-	  ((pointer_to_uword (pr->heap) + hi_offset) >> pr->log2_page_size))
-	break;
-
-      /* Allocation would span chunk boundary, queue it to be freed as soon as
-         we find suitable chunk. */
-      vec_add1 (to_free, lo_offset);
-    }
-
-  if (to_free != 0)
-    {
-      uword i;
-      for (i = 0; i < vec_len (to_free); i++)
-	{
-#if USE_DLMALLOC == 0
-	  mheap_put (pr->heap, to_free[i]);
-#else
-	  mspace_put_no_offset (pr->heap, (void *) to_free[i]);
-#endif
-	}
-      vec_free (to_free);
-    }
-
-#if USE_DLMALLOC == 0
-  return lo_offset != ~0 ? (void *) (pr->heap + lo_offset) : 0;
-#else
-  return lo_offset != ~0 ? (void *) lo_offset : 0;
-#endif
-}
-
-static void
-unix_physmem_free (vlib_main_t * vm, vlib_physmem_region_index_t idx, void *x)
-{
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  /* Return object to region's heap. */
-#if USE_DLMALLOC == 0
-  mheap_put (pr->heap, x - pr->heap);
-#else
-  mspace_put_no_offset (pr->heap, x);
-#endif
-}
-
-static clib_error_t *
-unix_physmem_region_alloc (vlib_main_t * vm, char *name, u32 size,
-			   u8 numa_node, u32 flags,
-			   vlib_physmem_region_index_t * idx)
-{
-  vlib_physmem_main_t *vpm = &physmem_main;
-  vlib_physmem_region_t *pr;
-  clib_error_t *error = 0;
-  clib_mem_vm_alloc_t alloc = { 0 };
-  int i;
-
-  pool_get (vpm->regions, pr);
-
-  if ((pr - vpm->regions) >= 256)
-    {
-      error = clib_error_return (0, "maximum number of regions reached");
-      goto error;
-    }
-
-  alloc.name = name;
-  alloc.size = size;
-  alloc.numa_node = numa_node;
-
-  alloc.flags = (flags & VLIB_PHYSMEM_F_SHARED) ?
-    CLIB_MEM_VM_F_SHARED : CLIB_MEM_VM_F_LOCKED;
-
-  if ((flags & VLIB_PHYSMEM_F_HUGETLB))
-    {
-      alloc.flags |= CLIB_MEM_VM_F_HUGETLB;
-      alloc.flags |= CLIB_MEM_VM_F_HUGETLB_PREALLOC;
-      alloc.flags |= CLIB_MEM_VM_F_NUMA_FORCE;
-    }
-  else
-    {
-      alloc.flags |= CLIB_MEM_VM_F_NUMA_PREFER;
-    }
-
-  error = clib_mem_vm_ext_alloc (&alloc);
-  if (error)
-    goto error;
-
-  pr->index = pr - vpm->regions;
-  pr->flags = flags;
-  pr->fd = alloc.fd;
-  pr->mem = alloc.addr;
-  pr->log2_page_size = alloc.log2_page_size;
-  pr->n_pages = alloc.n_pages;
-  pr->size = (u64) pr->n_pages << (u64) pr->log2_page_size;
-  pr->page_mask = (1ull << pr->log2_page_size) - 1;
-  pr->numa_node = numa_node;
-  pr->name = format (0, "%s%c", name, 0);
-
-  for (i = 0; i < pr->n_pages; i++)
-    {
-      void *ptr = pr->mem + ((u64) i << pr->log2_page_size);
-      int node;
-      if ((move_pages (0, 1, &ptr, 0, &node, 0) == 0) && (numa_node != node))
-	{
-	  clib_warning ("physmem page for region \'%s\' allocated on the"
-			" wrong numa node (requested %u actual %u)",
-			pr->name, pr->numa_node, node, i);
-	  break;
-	}
-    }
-
-  pr->page_table = clib_mem_vm_get_paddr (pr->mem, pr->log2_page_size,
-					  pr->n_pages);
-
-  linux_vfio_dma_map_regions (vm);
-
-  if (flags & VLIB_PHYSMEM_F_INIT_MHEAP)
-    {
-#if USE_DLMALLOC == 0
-      pr->heap = mheap_alloc_with_flags (pr->mem, pr->size,
-					 /* Don't want mheap mmap/munmap with IO memory. */
-					 MHEAP_FLAG_DISABLE_VM |
-					 MHEAP_FLAG_THREAD_SAFE);
-#else
-      pr->heap = create_mspace_with_base (pr->mem, pr->size, 1 /* locked */ );
-      mspace_disable_expand (pr->heap);
-#endif
-    }
-
-  *idx = pr->index;
-
-  goto done;
-
-error:
-  clib_memset (pr, 0, sizeof (*pr));
-  pool_put (vpm->regions, pr);
-
-done:
-  return error;
-}
-
-static void
-unix_physmem_region_free (vlib_main_t * vm, vlib_physmem_region_index_t idx)
-{
-  vlib_physmem_main_t *vpm = &physmem_main;
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-
-  if (pr->fd > 0)
-    close (pr->fd);
-  munmap (pr->mem, pr->size);
-  vec_free (pr->name);
-  pool_put (vpm->regions, pr);
-}
-
-clib_error_t *
-unix_physmem_init (vlib_main_t * vm)
-{
-  vlib_physmem_main_t *vpm = &physmem_main;
-  clib_error_t *error = 0;
-  u64 *pt = 0;
-
-  /* Avoid multiple calls. */
-  if (vm->os_physmem_alloc_aligned)
-    return error;
-
-  /* check if pagemap is accessible */
-  pt = clib_mem_vm_get_paddr (&pt, min_log2 (sysconf (_SC_PAGESIZE)), 1);
-  if (pt[0])
-    vpm->flags |= VLIB_PHYSMEM_MAIN_F_HAVE_PAGEMAP;
-  vec_free (pt);
-
-  if ((error = linux_vfio_init (vm)))
-    return error;
-
-  vm->os_physmem_alloc_aligned = unix_physmem_alloc_aligned;
-  vm->os_physmem_free = unix_physmem_free;
-  vm->os_physmem_region_alloc = unix_physmem_region_alloc;
-  vm->os_physmem_region_free = unix_physmem_region_free;
-
-  return error;
-}
-
-static clib_error_t *
-show_physmem (vlib_main_t * vm,
-	      unformat_input_t * input, vlib_cli_command_t * cmd)
-{
-  vlib_physmem_main_t *vpm = &physmem_main;
-  vlib_physmem_region_t *pr;
-
-  /* *INDENT-OFF* */
-  pool_foreach (pr, vpm->regions, (
-    {
-      vlib_cli_output (vm, "index %u name '%s' page-size %uKB num-pages %d "
-		       "numa-node %u fd %d\n",
-		       pr->index, pr->name, (1 << (pr->log2_page_size -10)),
-		       pr->n_pages, pr->numa_node, pr->fd);
-      if (pr->heap)
-	vlib_cli_output (vm, "  %U", format_mheap, pr->heap, /* verbose */ 1);
-      else
-	vlib_cli_output (vm, "  no heap\n");
-    }));
-  /* *INDENT-ON* */
-  return 0;
-}
-
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (show_physmem_command, static) = {
-  .path = "show physmem",
-  .short_help = "Show physical memory allocation",
-  .function = show_physmem,
-};
-/* *INDENT-ON* */
-
-/*
- * fd.io coding-style-patch-verification: ON
- *
- * Local Variables:
- * eval: (c-set-style "gnu")
- * End:
- */
diff --git a/src/vlib/linux/vfio.c b/src/vlib/linux/vfio.c
index e72f10388ca..d300a683dd7 100644
--- a/src/vlib/linux/vfio.c
+++ b/src/vlib/linux/vfio.c
@@ -34,52 +34,46 @@
 
 linux_vfio_main_t vfio_main;
 
-static int
-vfio_map_regions (vlib_main_t * vm, int fd)
+clib_error_t *
+vfio_map_physmem_page (vlib_main_t * vm, void *addr)
 {
-  vlib_physmem_main_t *vpm = &physmem_main;
+  vlib_physmem_main_t *vpm = &vm->physmem_main;
   linux_vfio_main_t *lvm = &vfio_main;
-  vlib_physmem_region_t *pr;
   struct vfio_iommu_type1_dma_map dm = { 0 };
-  int i;
+  uword log2_page_size = vpm->pmalloc_main->log2_page_sz;
+  uword physmem_start = pointer_to_uword (vpm->pmalloc_main->base);
+
+  if (lvm->container_fd == -1)
+    return clib_error_return (0, "No cointainer fd");
+
+  u32 page_index = vlib_physmem_get_page_index (vm, addr);
+
+  if (clib_bitmap_get (lvm->physmem_pages_mapped, page_index))
+    {
+      vlib_log_debug (lvm->log_default, "map DMA va:%p page:%u already "
+		      "mapped", addr, page_index);
+      return 0;
+    }
 
   dm.argsz = sizeof (struct vfio_iommu_type1_dma_map);
   dm.flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE;
+  dm.vaddr = physmem_start + (page_index << log2_page_size);
+  dm.size = 1ULL << log2_page_size;
+  dm.iova = dm.vaddr;
+  vlib_log_debug (lvm->log_default, "map DMA page:%u va:0x%lx iova:%lx "
+		  "size:0x%lx", page_index, dm.vaddr, dm.iova, dm.size);
 
-  /* *INDENT-OFF* */
-  pool_foreach (pr, vpm->regions,
+  if (ioctl (lvm->container_fd, VFIO_IOMMU_MAP_DMA, &dm) == -1)
     {
-      vec_foreach_index (i, pr->page_table)
-        {
-	  int rv;
-	  dm.vaddr = pointer_to_uword (pr->mem) + ((u64)i << pr->log2_page_size);
-	  dm.size = 1ull << pr->log2_page_size;
-	  dm.iova = dm.vaddr;
-	  vlib_log_debug (lvm->log_default, "map DMA va:0x%lx iova:%lx "
-			  "size:0x%lx", dm.vaddr, dm.iova, dm.size);
-
-	  if ((rv = ioctl (fd, VFIO_IOMMU_MAP_DMA, &dm)) &&
-	      errno != EINVAL)
-	    {
-	      vlib_log_err (lvm->log_default, "map DMA va:0x%lx iova:%lx "
-			    "size:0x%lx failed, error %s (errno %d)",
-			    dm.vaddr, dm.iova, dm.size, strerror (errno),
-			    errno);
-	      return rv;
-	    }
-        }
-    });
-  /* *INDENT-ON* */
-  return 0;
-}
-
-void
-linux_vfio_dma_map_regions (vlib_main_t * vm)
-{
-  linux_vfio_main_t *lvm = &vfio_main;
+      vlib_log_err (lvm->log_default, "map DMA page:%u va:0x%lx iova:%lx "
+		    "size:0x%lx failed, error %s (errno %d)", page_index,
+		    dm.vaddr, dm.iova, dm.size, strerror (errno), errno);
+      return clib_error_return_unix (0, "physmem DMA map failed");
+    }
 
-  if (lvm->container_fd != -1)
-    vfio_map_regions (vm, lvm->container_fd);
+  lvm->physmem_pages_mapped = clib_bitmap_set (lvm->physmem_pages_mapped,
+					       page_index, 1);
+  return 0;
 }
 
 static linux_pci_vfio_iommu_group_t *
diff --git a/src/vlib/linux/vfio.h b/src/vlib/linux/vfio.h
index aae8e3c6ee7..c1d815664c9 100644
--- a/src/vlib/linux/vfio.h
+++ b/src/vlib/linux/vfio.h
@@ -36,6 +36,8 @@ typedef struct
   /* iommu group pool index by group id  hash */
   uword *iommu_pool_index_by_group;
 
+  clib_bitmap_t *physmem_pages_mapped;
+
   /* logging */
   vlib_log_class_t log_default;
 } linux_vfio_main_t;
@@ -43,7 +45,7 @@ typedef struct
 extern linux_vfio_main_t vfio_main;
 
 clib_error_t *linux_vfio_init (vlib_main_t * vm);
-void linux_vfio_dma_map_regions (vlib_main_t * vm);
+clib_error_t *vfio_map_physmem_page (vlib_main_t * vm, void *addr);
 clib_error_t *linux_vfio_group_get_device_fd (vlib_pci_addr_t * addr,
 					      int *fd, int *is_noiommu);
 
diff --git a/src/vlib/main.c b/src/vlib/main.c
index 14d89141ff8..a6ad4032dae 100644
--- a/src/vlib/main.c
+++ b/src/vlib/main.c
@@ -1756,7 +1756,7 @@ vlib_main (vlib_main_t * volatile vm, unformat_input_t * input)
   if (!vm->name)
     vm->name = "VLIB";
 
-  if ((error = unix_physmem_init (vm)))
+  if ((error = vlib_physmem_init (vm)))
     {
       clib_error_report (error);
       goto done;
diff --git a/src/vlib/main.h b/src/vlib/main.h
index ddc14df5360..7c34fb6528d 100644
--- a/src/vlib/main.h
+++ b/src/vlib/main.h
@@ -118,23 +118,8 @@ typedef struct vlib_main_t
   /* Pool of buffer free lists. */
   vlib_buffer_free_list_t *buffer_free_list_pool;
 
-  /* Allocate/free buffer memory for DMA transfers, descriptor rings, etc.
-     buffer memory is guaranteed to be cache-aligned. */
-
-  clib_error_t *(*os_physmem_region_alloc) (struct vlib_main_t * vm,
-					    char *name, u32 size,
-					    u8 numa_node, u32 flags,
-					    vlib_physmem_region_index_t *
-					    idx);
-
-  void (*os_physmem_region_free) (struct vlib_main_t * vm,
-				  vlib_physmem_region_index_t idx);
-
-  void *(*os_physmem_alloc_aligned) (struct vlib_main_t * vm,
-				     vlib_physmem_region_index_t idx,
-				     uword n_bytes, uword alignment);
-  void (*os_physmem_free) (struct vlib_main_t * vm,
-			   vlib_physmem_region_index_t idx, void *x);
+  /* physical memory main structure. */
+  vlib_physmem_main_t physmem_main;
 
   /* Node graph main structure. */
   vlib_node_main_t node_main;
diff --git a/src/vlib/pci/pci.h b/src/vlib/pci/pci.h
index 3d5cd405c89..e0eacf42948 100644
--- a/src/vlib/pci/pci.h
+++ b/src/vlib/pci/pci.h
@@ -293,6 +293,11 @@ clib_error_t *vlib_pci_enable_msix_irq (vlib_main_t * vm,
 clib_error_t *vlib_pci_disable_msix_irq (vlib_main_t * vm,
 					 vlib_pci_dev_handle_t h, u16 start,
 					 u16 count);
+clib_error_t *vlib_pci_map_dma (vlib_main_t * vm, vlib_pci_dev_handle_t h,
+				void *ptr);
+
+int vlib_pci_supports_virtual_addr_dma (vlib_main_t * vm,
+					vlib_pci_dev_handle_t h);
 
 unformat_function_t unformat_vlib_pci_addr;
 format_function_t format_vlib_pci_addr;
diff --git a/src/vlib/physmem.c b/src/vlib/physmem.c
new file mode 100755
index 00000000000..e2d88922f56
--- /dev/null
+++ b/src/vlib/physmem.c
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/mman.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <vppinfra/linux/syscall.h>
+#include <vppinfra/linux/sysfs.h>
+#include <vlib/vlib.h>
+#include <vlib/physmem.h>
+#include <vlib/unix/unix.h>
+#include <vlib/pci/pci.h>
+#include <vlib/linux/vfio.h>
+
+clib_error_t *
+vlib_physmem_shared_map_create (vlib_main_t * vm, char *name, uword size,
+				u32 numa_node, u32 * map_index)
+{
+  clib_pmalloc_main_t *pm = vm->physmem_main.pmalloc_main;
+  vlib_physmem_main_t *vpm = &vm->physmem_main;
+  vlib_physmem_map_t *map;
+  clib_pmalloc_arena_t *a;
+  clib_error_t *error = 0;
+  void *va;
+  int i;
+
+  va = clib_pmalloc_create_shared_arena (pm, name, size, numa_node);
+
+  if (va == 0)
+    return clib_error_return (0, "%U", format_clib_error,
+			      clib_pmalloc_last_error (pm));
+
+  a = clib_pmalloc_get_arena (pm, va);
+
+  pool_get (vpm->maps, map);
+  *map_index = map->index = map - vpm->maps;
+  map->base = va;
+  map->fd = a->fd;
+  map->n_pages = a->n_pages;
+  map->log2_page_size = a->log2_page_sz;
+
+  for (i = 0; i < a->n_pages; i++)
+    {
+      uword pa = clib_pmalloc_get_pa (pm, (u8 *) va + (i << a->log2_page_sz));
+
+      /* maybe iova */
+      if (pa == 0)
+	pa = pointer_to_uword (va);
+
+      vec_add1 (map->page_table, pa);
+    }
+
+  return error;
+}
+
+vlib_physmem_map_t *
+vlib_physmem_get_map (vlib_main_t * vm, u32 index)
+{
+  vlib_physmem_main_t *vpm = &vm->physmem_main;
+  return pool_elt_at_index (vpm->maps, index);
+}
+
+clib_error_t *
+vlib_physmem_init (vlib_main_t * vm)
+{
+  vlib_physmem_main_t *vpm = &vm->physmem_main;
+  clib_error_t *error = 0;
+  u64 *pt = 0;
+  void *p;
+
+  /* check if pagemap is accessible */
+  pt = clib_mem_vm_get_paddr (&pt, min_log2 (sysconf (_SC_PAGESIZE)), 1);
+  if (pt[0])
+    vpm->flags |= VLIB_PHYSMEM_MAIN_F_HAVE_PAGEMAP;
+  vec_free (pt);
+
+  if ((error = linux_vfio_init (vm)))
+    return error;
+
+  p = clib_mem_alloc_aligned (sizeof (clib_pmalloc_main_t),
+			      CLIB_CACHE_LINE_BYTES);
+  memset (p, 0, sizeof (clib_pmalloc_main_t));
+  vpm->pmalloc_main = (clib_pmalloc_main_t *) p;
+  clib_pmalloc_init (vpm->pmalloc_main, 0);
+
+  return error;
+}
+
+static clib_error_t *
+show_physmem (vlib_main_t * vm,
+	      unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+  vlib_physmem_main_t *vpm = &vm->physmem_main;
+  unformat_input_t _line_input, *line_input = &_line_input;
+  u32 verbose = 0;
+
+  if (unformat_user (input, unformat_line_input, line_input))
+    {
+      while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+	{
+	  if (unformat (line_input, "verbose"))
+	    verbose = 1;
+	  else if (unformat (line_input, "v"))
+	    verbose = 1;
+	  else if (unformat (line_input, "detail"))
+	    verbose = 2;
+	  else if (unformat (line_input, "d"))
+	    verbose = 2;
+	  else
+	    break;
+	}
+      unformat_free (line_input);
+    }
+
+  vlib_cli_output (vm, "  %U", format_pmalloc, vpm->pmalloc_main, verbose);
+  return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (show_physmem_command, static) = {
+  .path = "show physmem",
+  .short_help = "Show physical memory allocation",
+  .function = show_physmem,
+};
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/vlib/physmem.h b/src/vlib/physmem.h
index 2f54938ff10..3e73a1b03f0 100644
--- a/src/vlib/physmem.h
+++ b/src/vlib/physmem.h
@@ -40,41 +40,27 @@
 #ifndef included_vlib_physmem_h
 #define included_vlib_physmem_h
 
-typedef u8 vlib_physmem_region_index_t;
+#include <vppinfra/pmalloc.h>
 
 typedef struct
 {
-  vlib_physmem_region_index_t index;
-  void *mem;
-  uword size;
+  int index;
   int fd;
-  u8 log2_page_size;
-  u16 n_pages;
-  u32 page_mask;
-
-  void *heap;
-  u32 flags;
-#define VLIB_PHYSMEM_F_INIT_MHEAP		(1 << 0)
-#define VLIB_PHYSMEM_F_HUGETLB			(1 << 1)
-#define VLIB_PHYSMEM_F_SHARED			(1 << 2)
-
-  u8 numa_node;
-  u64 *page_table;
-  u8 *name;
-} vlib_physmem_region_t;
-
-
+  void *base;
+  u32 n_pages;
+  uword *page_table;
+  u32 log2_page_size;
+} vlib_physmem_map_t;
 
 typedef struct
 {
   u32 flags;
 #define VLIB_PHYSMEM_MAIN_F_HAVE_PAGEMAP	(1 << 0)
 #define VLIB_PHYSMEM_MAIN_F_HAVE_IOMMU		(1 << 1)
-  vlib_physmem_region_t *regions;
+  vlib_physmem_map_t *maps;
+  clib_pmalloc_main_t *pmalloc_main;
 } vlib_physmem_main_t;
 
-extern vlib_physmem_main_t physmem_main;
-
 #endif /* included_vlib_physmem_h */
 
 /*
diff --git a/src/vlib/physmem_funcs.h b/src/vlib/physmem_funcs.h
index bff66aa5726..0082f85c70d 100644
--- a/src/vlib/physmem_funcs.h
+++ b/src/vlib/physmem_funcs.h
@@ -40,115 +40,62 @@
 #ifndef included_vlib_physmem_funcs_h
 #define included_vlib_physmem_funcs_h
 
-always_inline vlib_physmem_region_t *
-vlib_physmem_get_region (vlib_main_t * vm, u8 index)
-{
-  vlib_physmem_main_t *vpm = &physmem_main;
-  return pool_elt_at_index (vpm->regions, index);
-}
-
-always_inline u64
-vlib_physmem_offset_to_physical (vlib_main_t * vm,
-				 vlib_physmem_region_index_t idx, uword o)
-{
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  uword page_index = o >> pr->log2_page_size;
-  ASSERT (o < pr->size);
-  ASSERT (pr->page_table[page_index] != 0);
-  return (vec_elt (pr->page_table, page_index) + (o & pr->page_mask));
-}
-
-always_inline int
-vlib_physmem_is_virtual (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-			 uword p)
-{
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  return p >= pointer_to_uword (pr->mem)
-    && p < (pointer_to_uword (pr->mem) + pr->size);
-}
-
-always_inline uword
-vlib_physmem_offset_of (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-			void *p)
-{
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  uword a = pointer_to_uword (p);
-  uword o;
+clib_error_t *vlib_physmem_init (vlib_main_t * vm);
+clib_error_t *vlib_physmem_shared_map_create (vlib_main_t * vm, char *name,
+					      uword size, u32 numa_node,
+					      u32 * map_index);
 
-  ASSERT (vlib_physmem_is_virtual (vm, idx, a));
-  o = a - pointer_to_uword (pr->mem);
-
-  /* Offset must fit in 32 bits. */
-  ASSERT ((uword) o == a - pointer_to_uword (pr->mem));
-
-  return o;
-}
+vlib_physmem_map_t *vlib_physmem_get_map (vlib_main_t * vm, u32 index);
 
 always_inline void *
-vlib_physmem_at_offset (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-			uword offset)
+vlib_physmem_alloc_aligned (vlib_main_t * vm, uword n_bytes, uword alignment)
 {
-  vlib_physmem_region_t *pr = vlib_physmem_get_region (vm, idx);
-  ASSERT (offset < pr->size);
-  return uword_to_pointer (pointer_to_uword (pr->mem) + offset, void *);
+  clib_pmalloc_main_t *pm = vm->physmem_main.pmalloc_main;
+  return clib_pmalloc_alloc_aligned (pm, n_bytes, alignment);
 }
 
+/* By default allocate I/O memory with cache line alignment. */
 always_inline void *
-vlib_physmem_alloc_aligned (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-			    clib_error_t ** error,
-			    uword n_bytes, uword alignment)
+vlib_physmem_alloc (vlib_main_t * vm, uword n_bytes)
 {
-  void *r = vm->os_physmem_alloc_aligned (vm, idx, n_bytes, alignment);
-  if (!r)
-    *error =
-      clib_error_return (0, "failed to allocate %wd bytes of I/O memory",
-			 n_bytes);
-  else
-    *error = 0;
-  return r;
+  return vlib_physmem_alloc_aligned (vm, n_bytes, CLIB_CACHE_LINE_BYTES);
 }
 
-/* By default allocate I/O memory with cache line alignment. */
 always_inline void *
-vlib_physmem_alloc (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-		    clib_error_t ** error, uword n_bytes)
+vlib_physmem_alloc_from_map (vlib_main_t * vm, u32 physmem_map_index,
+			     uword n_bytes, uword alignment)
 {
-  return vlib_physmem_alloc_aligned (vm, idx, error, n_bytes,
-				     CLIB_CACHE_LINE_BYTES);
+  clib_pmalloc_main_t *pm = vm->physmem_main.pmalloc_main;
+  vlib_physmem_map_t *map = vlib_physmem_get_map (vm, physmem_map_index);
+  return clib_pmalloc_alloc_from_arena (pm, map->base, n_bytes,
+					CLIB_CACHE_LINE_BYTES);
 }
 
 always_inline void
-vlib_physmem_free (vlib_main_t * vm, vlib_physmem_region_index_t idx,
-		   void *mem)
+vlib_physmem_free (vlib_main_t * vm, void *p)
 {
-  if (mem)
-    vm->os_physmem_free (vm, idx, mem);
+  if (p)
+    clib_pmalloc_free (vm->physmem_main.pmalloc_main, p);
 }
 
 always_inline u64
-vlib_physmem_virtual_to_physical (vlib_main_t * vm,
-				  vlib_physmem_region_index_t idx, void *mem)
+vlib_physmem_get_page_index (vlib_main_t * vm, void *mem)
 {
-  vlib_physmem_main_t *vpm = &physmem_main;
-  vlib_physmem_region_t *pr = pool_elt_at_index (vpm->regions, idx);
-  uword o = mem - pr->mem;
-  return vlib_physmem_offset_to_physical (vm, idx, o);
+  clib_pmalloc_main_t *pm = vm->physmem_main.pmalloc_main;
+  return clib_pmalloc_get_page_index (pm, mem);
 }
 
-
-always_inline clib_error_t *
-vlib_physmem_region_alloc (vlib_main_t * vm, char *name, u32 size,
-			   u8 numa_node, u32 flags,
-			   vlib_physmem_region_index_t * idx)
+always_inline u64
+vlib_physmem_get_pa (vlib_main_t * vm, void *mem)
 {
-  return vm->os_physmem_region_alloc (vm, name, size, numa_node, flags, idx);
+  clib_pmalloc_main_t *pm = vm->physmem_main.pmalloc_main;
+  return clib_pmalloc_get_pa (pm, mem);
 }
 
-always_inline void
-vlib_physmem_region_free (struct vlib_main_t *vm,
-			  vlib_physmem_region_index_t idx)
+always_inline clib_error_t *
+vlib_physmem_last_error (struct vlib_main_t * vm)
 {
-  vm->os_physmem_region_free (vm, idx);
+  return clib_error_return (0, "unknown error");
 }
 
 #endif /* included_vlib_physmem_funcs_h */
diff --git a/src/vlib/unix/main.c b/src/vlib/unix/main.c
index 45b12cd5b77..08f0506fbc2 100755
--- a/src/vlib/unix/main.c
+++ b/src/vlib/unix/main.c
@@ -61,7 +61,6 @@ char *vlib_default_runtime_dir = "vlib";
 
 unix_main_t unix_main;
 clib_file_main_t file_main;
-vlib_physmem_main_t physmem_main;
 
 static clib_error_t *
 unix_main_init (vlib_main_t * vm)
diff --git a/src/vlib/unix/unix.h b/src/vlib/unix/unix.h
index 7856e5b7df7..e71b0bac6a5 100644
--- a/src/vlib/unix/unix.h
+++ b/src/vlib/unix/unix.h
@@ -126,8 +126,6 @@ unix_save_error (unix_main_t * um, clib_error_t * error)
 /* Main function for Unix VLIB. */
 int vlib_unix_main (int argc, char *argv[]);
 
-clib_error_t *unix_physmem_init (vlib_main_t * vm);
-
 /* Set prompt for CLI. */
 void vlib_unix_cli_set_prompt (char *prompt);
 
diff --git a/src/vppinfra/CMakeLists.txt b/src/vppinfra/CMakeLists.txt
index 26368493382..6e1a4fd861a 100644
--- a/src/vppinfra/CMakeLists.txt
+++ b/src/vppinfra/CMakeLists.txt
@@ -56,6 +56,7 @@ set(VPPINFRA_SRCS
   macros.c
   maplog.c
   mhash.c
+  pmalloc.c
   pool.c
   ptclosure.c
   random.c
@@ -135,6 +136,7 @@ set(VPPINFRA_HEADERS
   mheap.h
   os.h
   pipeline.h
+  pmalloc.h
   pool.h
   pmc.h
   ptclosure.h
@@ -227,6 +229,7 @@ if(VPP_BUILD_VPPINFRA_TESTS)
     longjmp
     macros
     maplog
+    pmalloc
     pool_iterate
     ptclosure
     random
diff --git a/src/vppinfra/linux/syscall.h b/src/vppinfra/linux/syscall.h
index 4511b85ac1d..1ae029d5802 100644
--- a/src/vppinfra/linux/syscall.h
+++ b/src/vppinfra/linux/syscall.h
@@ -19,6 +19,12 @@
 #include <unistd.h>
 #include <sys/syscall.h>
 
+static inline int
+getcpu (unsigned *cpu, unsigned *node, void *tcache)
+{
+  return syscall (__NR_getcpu, cpu, node, tcache);
+}
+
 static inline long
 set_mempolicy (int mode, const unsigned long *nodemask, unsigned long maxnode)
 {
diff --git a/src/vppinfra/pmalloc.c b/src/vppinfra/pmalloc.c
new file mode 100644
index 00000000000..d354cce8a7d
--- /dev/null
+++ b/src/vppinfra/pmalloc.c
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/mempolicy.h>
+#include <linux/memfd.h>
+
+#include <vppinfra/format.h>
+#include <vppinfra/linux/syscall.h>
+#include <vppinfra/linux/sysfs.h>
+#include <vppinfra/mem.h>
+#include <vppinfra/hash.h>
+#include <vppinfra/pmalloc.h>
+
+#if __SIZEOF_POINTER__ >= 8
+#define DEFAULT_RESERVED_MB 16384
+#else
+#define DEFAULT_RESERVED_MB 256
+#endif
+
+static inline clib_pmalloc_chunk_t *
+get_chunk (clib_pmalloc_page_t * pp, u32 index)
+{
+  return pool_elt_at_index (pp->chunks, index);
+}
+
+static inline int
+pmalloc_validate_numa_node (u32 * numa_node)
+{
+  if (*numa_node == CLIB_PMALLOC_NUMA_LOCAL)
+    {
+      u32 cpu;
+      if (getcpu (&cpu, numa_node, 0) != 0)
+	return 1;
+    }
+  return 0;
+}
+
+int
+clib_pmalloc_init (clib_pmalloc_main_t * pm, uword size)
+{
+  struct stat st;
+  uword off, pagesize;
+  int fd;
+
+  ASSERT (pm->error == 0);
+
+  pm->log2_page_sz = 21;
+  pm->error = clib_mem_create_hugetlb_fd ("detect_hugepage_size", &fd);
+
+  if (pm->error)
+    return -1;
+
+  if (fd != -1)
+    {
+      if (fstat (fd, &st) == -1)
+	pm->log2_page_sz = min_log2 (st.st_blksize);
+      close (fd);
+    }
+
+  pagesize = 1ULL << pm->log2_page_sz;
+
+  size = size ? size : ((u64) DEFAULT_RESERVED_MB) << 20;
+  size = round_pow2 (size, pagesize);
+
+  pm->max_pages = size >> pm->log2_page_sz;
+
+  /* reserve VA space for future growth */
+  pm->base = mmap (0, size + pagesize, PROT_NONE,
+		   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+  if (pm->base == MAP_FAILED)
+    {
+      pm->error = clib_error_return_unix (0, "failed to reserve %u pages");
+      return -1;
+    }
+
+  off = round_pow2 (pointer_to_uword (pm->base), pagesize) -
+    pointer_to_uword (pm->base);
+
+  /* trim start and end of reservation to be page aligned */
+  if (off)
+    {
+      munmap (pm->base, off);
+      pm->base += off;
+    }
+
+  munmap (pm->base + (pm->max_pages * pagesize), pagesize - off);
+  return 0;
+}
+
+static inline void *
+alloc_chunk_from_page (clib_pmalloc_main_t * pm, clib_pmalloc_page_t * pp,
+		       u32 n_blocks, u32 block_align, u32 numa_node)
+{
+  clib_pmalloc_chunk_t *c;
+  void *va;
+  u32 off;
+  u32 alloc_chunk_index;
+
+  if (pp->chunks == 0)
+    {
+      pool_get (pp->chunks, c);
+      pp->n_free_chunks = 1;
+      pp->first_chunk_index = c - pp->chunks;
+      c->prev = c->next = ~0;
+      c->size = pp->n_free_blocks;
+    }
+
+  alloc_chunk_index = pp->first_chunk_index;
+
+next_chunk:
+  c = pool_elt_at_index (pp->chunks, alloc_chunk_index);
+  off = (block_align - (c->start & (block_align - 1))) & (block_align - 1);
+
+  if (c->used || n_blocks + off > c->size)
+    {
+      if (c->next == ~0)
+	return 0;
+      alloc_chunk_index = c->next;
+      goto next_chunk;
+    }
+
+  /* if alignment is needed create new empty chunk */
+  if (off)
+    {
+      u32 offset_chunk_index;
+      clib_pmalloc_chunk_t *co;
+      pool_get (pp->chunks, c);
+      pp->n_free_chunks++;
+      offset_chunk_index = alloc_chunk_index;
+      alloc_chunk_index = c - pp->chunks;
+
+      co = pool_elt_at_index (pp->chunks, offset_chunk_index);
+      c->size = co->size - off;
+      c->next = co->next;
+      c->start = co->start + off;
+      c->prev = offset_chunk_index;
+      co->size = off;
+      co->next = alloc_chunk_index;
+    }
+
+  c->used = 1;
+  if (c->size > n_blocks)
+    {
+      u32 tail_chunk_index;
+      clib_pmalloc_chunk_t *ct;
+      pool_get (pp->chunks, ct);
+      pp->n_free_chunks++;
+      tail_chunk_index = ct - pp->chunks;
+      c = pool_elt_at_index (pp->chunks, alloc_chunk_index);
+      ct->size = c->size - n_blocks;
+      ct->next = c->next;
+      ct->prev = alloc_chunk_index;
+      ct->start = c->start + n_blocks;
+
+      c->size = n_blocks;
+      c->next = tail_chunk_index;
+      if (ct->next != ~0)
+	pool_elt_at_index (pp->chunks, ct->next)->prev = tail_chunk_index;
+    }
+  else if (c->next != ~0)
+    pool_elt_at_index (pp->chunks, c->next)->prev = alloc_chunk_index;
+
+  c = get_chunk (pp, alloc_chunk_index);
+  va = pm->base + ((pp - pm->pages) << pm->log2_page_sz) +
+    (c->start << PMALLOC_LOG2_BLOCK_SZ);
+  hash_set (pm->chunk_index_by_va, pointer_to_uword (va), alloc_chunk_index);
+  pp->n_free_blocks -= n_blocks;
+  pp->n_free_chunks--;
+  return va;
+}
+
+static inline clib_pmalloc_page_t *
+pmalloc_map_pages (clib_pmalloc_main_t * pm, clib_pmalloc_arena_t * a,
+		   u32 numa_node, u32 n_pages)
+{
+  clib_pmalloc_page_t *pp = 0;
+  u64 seek, pa, sys_page_size;
+  int pagemap_fd, status, rv, i, mmap_flags;
+  void *va;
+  int old_mpol = -1;
+  long unsigned int mask[16] = { 0 };
+  long unsigned int old_mask[16] = { 0 };
+
+  clib_error_free (pm->error);
+
+  if (pm->max_pages <= vec_len (pm->pages))
+    {
+      pm->error = clib_error_return (0, "maximum number of pages reached");
+      return 0;
+    }
+
+  pm->error = clib_sysfs_prealloc_hugepages (numa_node, pm->log2_page_sz,
+					     n_pages);
+
+  if (pm->error)
+    return 0;
+
+  rv = get_mempolicy (&old_mpol, old_mask, sizeof (old_mask) * 8 + 1, 0, 0);
+  /* failure to get mempolicy means we can only proceed with numa 0 maps */
+  if (rv == -1 && numa_node != 0)
+    {
+      pm->error = clib_error_return_unix (0, "failed to get mempolicy");
+      return 0;
+    }
+
+  mask[0] = 1 << numa_node;
+  rv = set_mempolicy (MPOL_BIND, mask, sizeof (mask) * 8 + 1);
+  if (rv == -1 && numa_node != 0)
+    {
+      pm->error = clib_error_return_unix (0, "failed to set mempolicy for "
+					  "numa node %u", numa_node);
+      return 0;
+    }
+
+  mmap_flags = MAP_FIXED | MAP_HUGETLB | MAP_LOCKED | MAP_ANONYMOUS;
+  if (a->flags & CLIB_PMALLOC_ARENA_F_SHARED_MEM)
+    {
+      mmap_flags |= MAP_SHARED;
+      pm->error = clib_mem_create_hugetlb_fd ((char *) a->name, &a->fd);
+      if (a->fd == -1)
+	goto error;
+    }
+  else
+    {
+      mmap_flags |= MAP_PRIVATE;
+      a->fd = -1;
+    }
+
+  va = pm->base + (vec_len (pm->pages) << pm->log2_page_sz);
+  if (mmap (va, n_pages << pm->log2_page_sz, PROT_READ | PROT_WRITE,
+	    mmap_flags, a->fd, 0) == MAP_FAILED)
+    {
+      pm->error = clib_error_return_unix (0, "failed to mmap %u pages at %p "
+					  "fd %d numa %d flags 0x%x", n_pages,
+					  va, a->fd, numa_node, mmap_flags);
+      goto error;
+    }
+
+  rv = set_mempolicy (old_mpol, old_mask, sizeof (old_mask) * 8 + 1);
+  if (rv == -1 && numa_node != 0)
+    {
+      pm->error = clib_error_return_unix (0, "failed to restore mempolicy");
+      goto error;
+    }
+
+  /* we tolerate move_pages failure only if request os for numa node 0
+     to support non-numa kernels */
+  rv = move_pages (0, 1, &va, 0, &status, 0);
+  if ((rv == 0 && status != numa_node) || (rv != 0 && numa_node != 0))
+    {
+      pm->error = rv == -1 ?
+	clib_error_return_unix (0, "page allocated on wrong node, numa node "
+				"%u status %d", numa_node, status) :
+	clib_error_return (0, "page allocated on wrong node, numa node "
+			   "%u status %d", numa_node, status);
+
+      /* unmap & reesrve */
+      munmap (va, n_pages << pm->log2_page_sz);
+      mmap (va, n_pages << pm->log2_page_sz, PROT_NONE,
+	    MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+      goto error;
+    }
+
+  memset (va, 0, n_pages << pm->log2_page_sz);
+  sys_page_size = sysconf (_SC_PAGESIZE);
+  pagemap_fd = open ((char *) "/proc/self/pagemap", O_RDONLY);
+
+  for (i = 0; i < n_pages; i++)
+    {
+      uword page_va = pointer_to_uword ((u8 *) va + (i << pm->log2_page_sz));
+      vec_add2 (pm->pages, pp, 1);
+      pp->n_free_blocks = 1 << (pm->log2_page_sz - PMALLOC_LOG2_BLOCK_SZ);
+      pp->index = pp - pm->pages;
+      pp->arena_index = a->index;
+
+      vec_add1 (a->page_indices, pp->index);
+      a->n_pages++;
+
+      seek = (page_va / sys_page_size) * sizeof (pa);
+      if (pagemap_fd != -1 &&
+	  lseek (pagemap_fd, seek, SEEK_SET) == seek &&
+	  read (pagemap_fd, &pa, sizeof (pa)) == (sizeof (pa)) &&
+	  pa & (1ULL << 63) /* page present bit */ )
+	{
+	  pp->pa = (pa & pow2_mask (55)) * sys_page_size;
+	}
+      vec_add1_aligned (pm->va_pa_diffs, pp->pa ? page_va - pp->pa : 0,
+			CLIB_CACHE_LINE_BYTES);
+    }
+
+  if (pagemap_fd != -1)
+    close (pagemap_fd);
+
+  /* return pointer to 1st page */
+  return pp - (n_pages - 1);
+
+error:
+  if (a->fd != -1)
+    close (a->fd);
+  return 0;
+}
+
+void *
+clib_pmalloc_create_shared_arena (clib_pmalloc_main_t * pm, char *name,
+				  uword size, u32 numa_node)
+{
+  clib_pmalloc_arena_t *a;
+  clib_pmalloc_page_t *pp;
+  u32 n_pages = round_pow2 (size, 1 << pm->log2_page_sz) >> pm->log2_page_sz;
+
+  if (n_pages + vec_len (pm->pages) > pm->max_pages)
+    return 0;
+
+  if (pmalloc_validate_numa_node (&numa_node))
+    return 0;
+
+  pool_get (pm->arenas, a);
+  a->index = a - pm->arenas;
+  a->name = format (0, "%s%c", name, 0);
+  a->numa_node = numa_node;
+  a->flags = CLIB_PMALLOC_ARENA_F_SHARED_MEM;
+  a->log2_page_sz = pm->log2_page_sz;
+
+  if ((pp = pmalloc_map_pages (pm, a, numa_node, n_pages)) == 0)
+    {
+      vec_free (a->name);
+      memset (a, 0, sizeof (*a));
+      pool_put (pm->arenas, a);
+      return 0;
+    }
+
+  return pm->base + (pp->index << pm->log2_page_sz);
+}
+
+static inline void *
+clib_pmalloc_alloc_inline (clib_pmalloc_main_t * pm, clib_pmalloc_arena_t * a,
+			   uword size, uword align, u32 numa_node)
+{
+  clib_pmalloc_page_t *pp;
+  u32 n_blocks, block_align, *page_index;
+
+  ASSERT (is_pow2 (align));
+
+  if (pmalloc_validate_numa_node (&numa_node))
+    return 0;
+
+  if (a == 0)
+    {
+      vec_validate_init_empty (pm->default_arena_for_numa_node,
+			       numa_node, ~0);
+      if (pm->default_arena_for_numa_node[numa_node] == ~0)
+	{
+	  pool_get (pm->arenas, a);
+	  pm->default_arena_for_numa_node[numa_node] = a - pm->arenas;
+	  a->name = format (0, "default-numa-%u%c", numa_node, 0);
+	  a->numa_node = numa_node;
+	}
+      else
+	a = pool_elt_at_index (pm->arenas,
+			       pm->default_arena_for_numa_node[numa_node]);
+    }
+
+  n_blocks = round_pow2 (size, PMALLOC_BLOCK_SZ) / PMALLOC_BLOCK_SZ;
+  block_align = align >> PMALLOC_LOG2_BLOCK_SZ;
+
+  vec_foreach (page_index, a->page_indices)
+  {
+    pp = vec_elt_at_index (pm->pages, *page_index);
+    void *rv = alloc_chunk_from_page (pm, pp, n_blocks, block_align,
+				      numa_node);
+
+    if (rv)
+      return rv;
+  }
+
+  if ((a->flags & CLIB_PMALLOC_ARENA_F_SHARED_MEM) == 0 &&
+      (pp = pmalloc_map_pages (pm, a, numa_node, 1)))
+    return alloc_chunk_from_page (pm, pp, n_blocks, block_align, numa_node);
+
+  return 0;
+}
+
+void *
+clib_pmalloc_alloc_aligned_on_numa (clib_pmalloc_main_t * pm, uword size,
+				    uword align, u32 numa_node)
+{
+  return clib_pmalloc_alloc_inline (pm, 0, size, align, numa_node);
+}
+
+void *
+clib_pmalloc_alloc_aligned (clib_pmalloc_main_t * pm, uword size, uword align)
+{
+  return clib_pmalloc_alloc_inline (pm, 0, size, align,
+				    CLIB_PMALLOC_NUMA_LOCAL);
+}
+
+void *
+clib_pmalloc_alloc_from_arena (clib_pmalloc_main_t * pm, void *arena_va,
+			       uword size, uword align)
+{
+  clib_pmalloc_arena_t *a = clib_pmalloc_get_arena (pm, arena_va);
+  return clib_pmalloc_alloc_inline (pm, a, size, align, 0);
+}
+
+void
+clib_pmalloc_free (clib_pmalloc_main_t * pm, void *va)
+{
+  clib_pmalloc_page_t *pp;
+  clib_pmalloc_chunk_t *c;
+  uword *p;
+  u32 chunk_index, page_index;
+
+  p = hash_get (pm->chunk_index_by_va, pointer_to_uword (va));
+
+  if (p == 0)
+    os_panic ();
+
+  chunk_index = p[0];
+  page_index = clib_pmalloc_get_page_index (pm, va);
+  hash_unset (pm->chunk_index_by_va, pointer_to_uword (va));
+
+  pp = vec_elt_at_index (pm->pages, page_index);
+  c = pool_elt_at_index (pp->chunks, chunk_index);
+  c->used = 0;
+  pp->n_free_blocks += c->size;
+  pp->n_free_chunks++;
+
+  /* merge with next if free */
+  if (c->next != ~0 && get_chunk (pp, c->next)->used == 0)
+    {
+      clib_pmalloc_chunk_t *next = get_chunk (pp, c->next);
+      c->size += next->size;
+      c->next = next->next;
+      if (next->next != ~0)
+	get_chunk (pp, next->next)->prev = chunk_index;
+      memset (next, 0, sizeof (*next));
+      pool_put (pp->chunks, next);
+      pp->n_free_chunks--;
+    }
+
+  /* merge with prev if free */
+  if (c->prev != ~0 && get_chunk (pp, c->prev)->used == 0)
+    {
+      clib_pmalloc_chunk_t *prev = get_chunk (pp, c->prev);
+      prev->size += c->size;
+      prev->next = c->next;
+      if (c->next != ~0)
+	get_chunk (pp, c->next)->prev = c->prev;
+      memset (c, 0, sizeof (*c));
+      pool_put (pp->chunks, c);
+      pp->n_free_chunks--;
+    }
+}
+
+static u8 *
+format_pmalloc_page (u8 * s, va_list * va)
+{
+  clib_pmalloc_page_t *pp = va_arg (*va, clib_pmalloc_page_t *);
+  int verbose = va_arg (*va, int);
+  u32 indent = format_get_indent (s);
+
+  s = format (s, "page %u: phys-addr %p ", pp->index, pp->pa);
+
+  if (pp->chunks == 0)
+    return s;
+
+  s = format (s, "free %u chunks %u free-chunks %d ",
+	      (pp->n_free_blocks) << PMALLOC_LOG2_BLOCK_SZ,
+	      pool_elts (pp->chunks), pp->n_free_chunks);
+
+  if (verbose >= 2)
+    {
+      clib_pmalloc_chunk_t *c;
+      c = pool_elt_at_index (pp->chunks, pp->first_chunk_index);
+      s = format (s, "\n%U%12s%12s%8s%8s%8s%8s",
+		  format_white_space, indent + 2,
+		  "chunk offset", "size", "used", "index", "prev", "next");
+      while (1)
+	{
+	  s = format (s, "\n%U%12u%12u%8s%8d%8d%8d",
+		      format_white_space, indent + 2,
+		      c->start << PMALLOC_LOG2_BLOCK_SZ,
+		      c->size << PMALLOC_LOG2_BLOCK_SZ,
+		      c->used ? "yes" : "no",
+		      c - pp->chunks, c->prev, c->next);
+	  if (c->next == ~0)
+	    break;
+	  c = pool_elt_at_index (pp->chunks, c->next);
+	}
+    }
+  return s;
+}
+
+u8 *
+format_pmalloc (u8 * s, va_list * va)
+{
+  clib_pmalloc_main_t *pm = va_arg (*va, clib_pmalloc_main_t *);
+  int verbose = va_arg (*va, int);
+  u32 indent = format_get_indent (s);
+
+  clib_pmalloc_page_t *pp;
+  clib_pmalloc_arena_t *a;
+
+  s = format (s, "used-pages %u reserved-pages %u pagesize %uKB",
+	      vec_len (pm->pages), pm->max_pages,
+	      1 << (pm->log2_page_sz - 10));
+
+  if (verbose >= 2)
+    s = format (s, " va-start %p", pm->base);
+
+  if (pm->error)
+    s = format (s, "\n%Ulast-error: %U", format_white_space, indent + 2,
+		format_clib_error, pm->error);
+
+
+  /* *INDENT-OFF* */
+  pool_foreach (a, pm->arenas,
+    {
+      u32 *page_index;
+      s = format (s, "\n%Uarena '%s' pages %u numa-node %u",
+		  format_white_space, indent + 2,
+		  a->name, vec_len (a->page_indices), a->numa_node);
+      if (a->fd != -1)
+        s = format (s, " shared fd %d", a->fd);
+      if (verbose >= 1)
+	vec_foreach (page_index, a->page_indices)
+	  {
+	    pp = vec_elt_at_index (pm->pages, *page_index);
+	    s = format (s, "\n%U%U", format_white_space, indent + 4,
+			format_pmalloc_page, pp, verbose);
+	  }
+    });
+  /* *INDENT-ON* */
+
+  return s;
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/vppinfra/pmalloc.h b/src/vppinfra/pmalloc.h
new file mode 100644
index 00000000000..4d9906ab6e7
--- /dev/null
+++ b/src/vppinfra/pmalloc.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef included_palloc_h
+#define included_palloc_h
+#include <vppinfra/format.h>
+#include <vppinfra/pool.h>
+
+#define PMALLOC_LOG2_BLOCK_SZ          CLIB_LOG2_CACHE_LINE_BYTES
+#define PMALLOC_BLOCK_SZ               (1 << 6)
+
+#define CLIB_PMALLOC_NUMA_LOCAL 0xffffffff
+
+typedef struct
+{
+  u32 start, prev, next;
+  u32 size:31;
+  u32 used:1;
+} clib_pmalloc_chunk_t;
+
+STATIC_ASSERT_SIZEOF (clib_pmalloc_chunk_t, 16);
+
+typedef struct
+{
+  u32 index;
+  u32 arena_index;
+  uword pa;
+  clib_pmalloc_chunk_t *chunks;
+  u32 first_chunk_index;
+  u32 n_free_chunks;
+  u32 n_free_blocks;
+} clib_pmalloc_page_t;
+
+typedef struct
+{
+  u32 index;
+  u32 flags;
+#define CLIB_PMALLOC_ARENA_F_SHARED_MEM (1 << 0)
+  int fd;
+  u32 numa_node;
+  u32 first_page_index;
+  u32 log2_page_sz;
+  u32 n_pages;
+  u8 *name;
+  u32 *page_indices;
+} clib_pmalloc_arena_t;
+
+typedef struct
+{
+  u8 *base;
+  uword log2_page_sz;
+  uword *va_pa_diffs;
+  u32 max_pages;
+  clib_pmalloc_page_t *pages;
+  uword *chunk_index_by_va;
+  clib_pmalloc_arena_t *arenas;
+  u32 *default_arena_for_numa_node;
+
+  clib_error_t *error;
+} clib_pmalloc_main_t;
+
+
+int clib_pmalloc_init (clib_pmalloc_main_t * pm, uword size);
+void *clib_pmalloc_alloc_aligned_on_numa (clib_pmalloc_main_t * pm,
+					  uword size, uword align,
+					  u32 numa_node);
+void *clib_pmalloc_alloc_aligned (clib_pmalloc_main_t * pm, uword size,
+				  uword align);
+void clib_pmalloc_free (clib_pmalloc_main_t * pm, void *va);
+
+void *clib_pmalloc_create_shared_arena (clib_pmalloc_main_t * pm, char *name,
+					uword size, u32 numa_node);
+
+void *clib_pmalloc_alloc_from_arena (clib_pmalloc_main_t * pm, void *arena_va,
+				     uword size, uword align);
+
+format_function_t format_pmalloc;
+
+always_inline clib_error_t *
+clib_pmalloc_last_error (clib_pmalloc_main_t * pm)
+{
+  return pm->error;
+}
+
+always_inline u32
+clib_pmalloc_get_page_index (clib_pmalloc_main_t * pm, void *va)
+{
+  uword index = (pointer_to_uword (va) - pointer_to_uword (pm->base)) >>
+    pm->log2_page_sz;
+
+  ASSERT (index < vec_len (pm->pages));
+
+  return index;
+}
+
+always_inline clib_pmalloc_arena_t *
+clib_pmalloc_get_arena (clib_pmalloc_main_t * pm, void *va)
+{
+  u32 index = clib_pmalloc_get_page_index (pm, va);
+  return pm->arenas + pm->pages[index].arena_index;
+}
+
+always_inline uword
+clib_pmalloc_get_pa (clib_pmalloc_main_t * pm, void *va)
+{
+  u32 index = clib_pmalloc_get_page_index (pm, va);
+  return pointer_to_uword (va) - pm->va_pa_diffs[index];
+}
+
+
+#endif /* included_palloc_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/vppinfra/test_pmalloc.c b/src/vppinfra/test_pmalloc.c
new file mode 100644
index 00000000000..c9ae01fc936
--- /dev/null
+++ b/src/vppinfra/test_pmalloc.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vppinfra/format.h>
+#include <vppinfra/pmalloc.h>
+#include <vppinfra/random.h>
+
+typedef struct
+{
+  uword baseva;
+  uword size;
+  uword *vas;
+  u32 nitems;
+  u32 item_size;
+  u32 align;
+  int max_numa;
+  u32 arena_pages;
+  u32 arena_numa;
+  u32 arena_items;
+  int verbose;
+  clib_pmalloc_main_t pmalloc_main;
+} test_main_t;
+
+test_main_t test_main;
+
+clib_error_t *
+test_palloc (test_main_t * tm)
+{
+  clib_pmalloc_main_t *pm = &tm->pmalloc_main;
+  void *arena;
+  int i;
+  uword *va;
+
+  if (clib_pmalloc_init (pm, 0) != 0)
+    return clib_error_return (0, "pmalloc init failure");
+
+  fformat (stdout, "Allocate %d items...\n", tm->nitems);
+
+  for (i = 0; i < tm->nitems; i++)
+    {
+      u32 size = tm->item_size ? tm->item_size : 64 + 64 * (i % 8);
+      u32 align = tm->align ? tm->align : 64 << (i % 5);
+      u32 numa = i % (tm->max_numa + 1);
+      va = clib_pmalloc_alloc_aligned_on_numa (pm, size, align, numa);
+
+      if (va == 0)
+	clib_error ("Failed to alloc %u byte chunk with align %u on numa %u,"
+		    "\nerror: %U", size, align, numa, format_clib_error,
+		    clib_pmalloc_last_error (pm));
+
+      if ((pointer_to_uword (va) & (align - 1)) != 0)
+	clib_error (0, "Alignment error: %p not aligned with %u", va, align);
+
+      vec_add1 (tm->vas, pointer_to_uword (va));
+    }
+  fformat (stdout, "%U\n", format_pmalloc, pm, tm->verbose);
+
+  /* alloc from arena */
+  if (tm->arena_items)
+    {
+      fformat (stdout, "Allocate %d items from arena ...\n", tm->arena_items);
+      arena = clib_pmalloc_create_shared_arena (pm, "test arena",
+						tm->arena_pages << 21,
+						tm->arena_numa);
+      if (arena == 0)
+	clib_error ("Failed to alloc shared arena: %U", format_clib_error,
+		    clib_pmalloc_last_error (pm));
+
+      for (i = 0; i < tm->arena_items; i++)
+	{
+	  u32 size = tm->item_size ? tm->item_size : 64 + 64 * (i % 8);
+	  u32 align = tm->align ? tm->align : 64 << (i % 5);
+	  va = clib_pmalloc_alloc_from_arena (pm, arena, size, align);
+	  vec_add1 (tm->vas, pointer_to_uword (va));
+	}
+      fformat (stdout, "\n%U\n", format_pmalloc, pm, tm->verbose);
+    }
+
+
+  fformat (stdout, "Freeing %d items ...\n", vec_len (tm->vas));
+  for (i = 0; i < vec_len (tm->vas); i++)
+    clib_pmalloc_free (pm, (void *) tm->vas[i]);
+
+  fformat (stdout, "\n%U\n", format_pmalloc, pm, tm->verbose);
+  return 0;
+}
+
+clib_error_t *
+test_palloc_main (unformat_input_t * i)
+{
+  test_main_t *tm = &test_main;
+  clib_error_t *error;
+
+  tm->nitems = 5;
+  tm->arena_pages = 2;
+  tm->arena_numa = CLIB_PMALLOC_NUMA_LOCAL;
+
+  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (i, "nitems %u", &tm->nitems))
+	;
+      else if (unformat (i, "max-numa %u", &tm->max_numa))
+	;
+      else if (unformat (i, "item-size %u", &tm->item_size))
+	;
+      else if (unformat (i, "align %u", &tm->align))
+	;
+      else if (unformat (i, "verbose %d", &tm->verbose))
+	;
+      else if (unformat (i, "arena-pages %u", &tm->arena_pages))
+	;
+      else if (unformat (i, "arena-numa %u", &tm->arena_numa))
+	;
+      else if (unformat (i, "arena-items %u", &tm->arena_items))
+	;
+      else if (unformat (i, "verbose"))
+	tm->verbose = 1;
+      else
+	return clib_error_return (0, "unknown input '%U'",
+				  format_unformat_error, i);
+    }
+
+  error = test_palloc (tm);
+
+  return error;
+}
+
+#ifdef CLIB_UNIX
+int
+main (int argc, char *argv[])
+{
+  unformat_input_t i;
+  int rv = 0;
+  clib_error_t *error;
+
+  clib_mem_init (0, 3ULL << 30);
+
+  unformat_init_command_line (&i, argv);
+  error = test_palloc_main (&i);
+  if (error)
+    {
+      clib_error_report (error);
+      rv = 1;
+    }
+  unformat_free (&i);
+
+  return rv;
+}
+#endif /* CLIB_UNIX */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */