ipsec: make sure pad_bytes does not exceed pad data size

[vpp.git] / src / vlibmemory / memory_api.c

diff --git a/src/vlibmemory/memory_api.c b/src/vlibmemory/memory_api.c
index 10425dd..b5c97e9 100644 (file)
--- a/src/vlibmemory/memory_api.c
+++ b/src/vlibmemory/memory_api.c
@@ -210,6 +210,7 @@ vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp)
   regp->clib_file_index = am->shmem_hdr->clib_file_index;
 
   q = regp->vl_input_queue = (svm_queue_t *) (uword) mp->input_queue;
+  VL_MSG_API_SVM_QUEUE_UNPOISON (q);
 
   regp->name = format (0, "%s", mp->name);
   vec_add1 (regp->name, 0);
@@ -319,6 +320,9 @@ vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
            }
        }
 
+      /* No dangling references, please */
+      *regpp = 0;
+
       /* For horizontal scaling, add a hash table... */
       for (i = 0; i < vec_len (am->vlib_private_rps); i++)
        {
@@ -347,9 +351,6 @@ vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
            }
        }
 
-      /* No dangling references, please */
-      *regpp = 0;
-
       if (private_registration == 0)
        {
          pool_put_index (am->vl_clients,
@@ -420,11 +421,16 @@ vl_api_memclnt_keepalive_t_handler (vl_api_memclnt_keepalive_t * mp)
   vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
 }
 
+/*
+ * To avoid filling the API trace buffer with boring messages,
+ * don't trace memclnt_keepalive[_reply] msgs
+ */
+
 #define foreach_vlib_api_msg                            \
-_(MEMCLNT_CREATE, memclnt_create)                       \
-_(MEMCLNT_DELETE, memclnt_delete)                       \
-_(MEMCLNT_KEEPALIVE, memclnt_keepalive)                 \
-_(MEMCLNT_KEEPALIVE_REPLY, memclnt_keepalive_reply)    \
+_(MEMCLNT_CREATE, memclnt_create, 1)                    \
+_(MEMCLNT_DELETE, memclnt_delete, 1)                    \
+_(MEMCLNT_KEEPALIVE, memclnt_keepalive, 0)              \
+_(MEMCLNT_KEEPALIVE_REPLY, memclnt_keepalive_reply, 0)
 
 /*
  * memory_api_init
@@ -444,7 +450,7 @@ vl_mem_api_init (const char *region_name)
   if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
     return rv;
 
-#define _(N,n) do {                                             \
+#define _(N,n,t) do {                                            \
     c->id = VL_API_##N;                                         \
     c->name = #n;                                               \
     c->handler = vl_api_##n##_t_handler;                        \
@@ -452,7 +458,7 @@ vl_mem_api_init (const char *region_name)
     c->endian = vl_api_##n##_t_endian;                          \
     c->print = vl_api_##n##_t_print;                            \
     c->size = sizeof(vl_api_##n##_t);                           \
-    c->traced = 1; /* trace, so these msgs print */             \
+    c->traced = t; /* trace, so these msgs print */             \
     c->replay = 0; /* don't replay client create/delete msgs */ \
     c->message_bounce = 0; /* don't bounce this message */     \
     vl_msg_api_config(c);} while (0);
@@ -466,6 +472,7 @@ vl_mem_api_init (const char *region_name)
    */
   am->message_bounce[VL_API_MEMCLNT_DELETE] = 1;
   am->is_mp_safe[VL_API_MEMCLNT_KEEPALIVE_REPLY] = 1;
+  am->is_mp_safe[VL_API_MEMCLNT_KEEPALIVE] = 1;
 
   vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
 
@@ -496,10 +503,8 @@ static void
 send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
 {
   vl_api_memclnt_keepalive_t *mp;
-  svm_queue_t *q;
   api_main_t *am = &api_main;
-  svm_region_t *save_vlib_rp = am->vlib_rp;
-  vl_shmem_hdr_t *save_shmem_hdr = am->shmem_hdr;
+  svm_queue_t *q;
 
   q = regp->vl_input_queue;
 
@@ -523,10 +528,7 @@ send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
    * memory clients..
    */
 
-  am->vlib_rp = regp->vlib_rp;
-  am->shmem_hdr = regp->shmem_hdr;
-
-  mp = vl_msg_api_alloc (sizeof (*mp));
+  mp = vl_mem_api_alloc_as_if_client_w_reg (regp, sizeof (*mp));
   clib_memset (mp, 0, sizeof (*mp));
   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MEMCLNT_KEEPALIVE);
   mp->context = mp->client_index =
@@ -538,10 +540,7 @@ send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
 
   /* Failure-to-send due to a stuffed queue is absolutely expected */
   if (svm_queue_add (q, (u8 *) & mp, 1 /* nowait */ ))
-    vl_msg_api_free (mp);
-
-  am->vlib_rp = save_vlib_rp;
-  am->shmem_hdr = save_shmem_hdr;
+    vl_msg_api_free_w_region (regp->vlib_rp, mp);
 }
 
 static void
@@ -660,14 +659,18 @@ vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm, f64 now)
                        vec_delete (am->vlib_private_rps, 1, i);
                        goto found;
                      }
+                 svm_pop_heap (oldheap);
                  clib_warning ("private rp %llx AWOL", dead_rp);
+                 oldheap = svm_push_data_heap (svm);
 
                found:
                  /* Kill it, accounting for the memfd header page */
+                 svm_pop_heap (oldheap);
                  if (munmap ((void *) virtual_base, virtual_size) < 0)
                    clib_unix_warning ("munmap");
                  /* Reset the queue-length-address cache */
                  vec_reset_length (vl_api_queue_cursizes);
+                 oldheap = svm_push_data_heap (svm);
                }
              else
                {
@@ -697,13 +700,20 @@ vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm, f64 now)
 }
 
 static inline int
-void_mem_api_handle_msg_i (api_main_t * am, vlib_main_t * vm,
-                          vlib_node_runtime_t * node, svm_queue_t * q)
+void_mem_api_handle_msg_i (api_main_t * am, svm_region_t * vlib_rp,
+                          vlib_main_t * vm, vlib_node_runtime_t * node,
+                          u8 is_private)
 {
+  svm_queue_t *q;
   uword mp;
+
+  q = ((vl_shmem_hdr_t *) (void *) vlib_rp->user_ctx)->vl_input_queue;
+
   if (!svm_queue_sub2 (q, (u8 *) & mp))
     {
-      vl_msg_api_handler_with_vm_node (am, (void *) mp, vm, node);
+      VL_MSG_API_UNPOISON ((void *) mp);
+      vl_msg_api_handler_with_vm_node (am, vlib_rp, (void *) mp, vm, node,
+                                      is_private);
       return 0;
     }
   return -1;
@@ -713,8 +723,8 @@ int
 vl_mem_api_handle_msg_main (vlib_main_t * vm, vlib_node_runtime_t * node)
 {
   api_main_t *am = &api_main;
-  return void_mem_api_handle_msg_i (am, vm, node,
-                                   am->shmem_hdr->vl_input_queue);
+  return void_mem_api_handle_msg_i (am, am->vlib_rp, vm, node,
+                                   0 /* is_private */ );
 }
 
 int
@@ -752,7 +762,8 @@ vl_mem_api_handle_rpc (vlib_main_t * vm, vlib_node_runtime_t * node)
       for (i = 0; i < vec_len (vm->processing_rpc_requests); i++)
        {
          mp = vm->processing_rpc_requests[i];
-         vl_msg_api_handler_with_vm_node (am, (void *) mp, vm, node);
+         vl_msg_api_handler_with_vm_node (am, am->vlib_rp, (void *) mp, vm,
+                                          node, 0 /* is_private */ );
        }
       vl_msg_api_barrier_release ();
     }
@@ -765,22 +776,9 @@ vl_mem_api_handle_msg_private (vlib_main_t * vm, vlib_node_runtime_t * node,
                               u32 reg_index)
 {
   api_main_t *am = &api_main;
-  vl_shmem_hdr_t *save_shmem_hdr = am->shmem_hdr;
-  svm_region_t *vlib_rp, *save_vlib_rp = am->vlib_rp;
-  svm_queue_t *q;
-  int rv;
-
-  vlib_rp = am->vlib_rp = am->vlib_private_rps[reg_index];
-
-  am->shmem_hdr = (void *) vlib_rp->user_ctx;
-  q = am->shmem_hdr->vl_input_queue;
-
-  rv = void_mem_api_handle_msg_i (am, vm, node, q);
-
-  am->shmem_hdr = save_shmem_hdr;
-  am->vlib_rp = save_vlib_rp;
 
-  return rv;
+  return void_mem_api_handle_msg_i (am, am->vlib_private_rps[reg_index], vm,
+                                   node, 1 /* is_private */ );
 }
 
 vl_api_registration_t *