crypto crypto-openssl: support hashing operations

[vpp.git] / src / plugins / unittest / segment_manager_test.c

diff --git a/src/plugins/unittest/segment_manager_test.c b/src/plugins/unittest/segment_manager_test.c
index 4992e2e..31b417a 100644 (file)
--- a/src/plugins/unittest/segment_manager_test.c
+++ b/src/plugins/unittest/segment_manager_test.c
@@ -30,64 +30,64 @@
 
 #define SEGMENT_MANAGER_GET_INDEX_FROM_HANDLE(x) (x >> 32)
 
-/* dummy callback functions */
+/* placeholder callback functions */
 static void
-dummy_session_reset_callback (session_t * s)
+placeholder_session_reset_callback (session_t * s)
 {
   clib_warning ("called...");
 }
 
 static int
-dummy_session_connected_callback (u32 app_index, u32 api_context,
-                                 session_t * s, session_error_t err)
+placeholder_session_connected_callback (u32 app_index, u32 api_context,
+                                       session_t * s, session_error_t err)
 {
   clib_warning ("called...");
   return 0;
 }
 
 static int
-dummy_add_segment_callback (u32 client_index, u64 segment_handle)
+placeholder_add_segment_callback (u32 client_index, u64 segment_handle)
 {
   clib_warning ("called...");
   return 0;
 }
 
 static int
-dummy_del_segment_callback (u32 client_index, u64 segment_handle)
+placeholder_del_segment_callback (u32 client_index, u64 segment_handle)
 {
   clib_warning ("called...");
   return 0;
 }
 
 static void
-dummy_session_disconnect_callback (session_t * s)
+placeholder_session_disconnect_callback (session_t * s)
 {
   clib_warning ("called...");
 }
 
 static int
-dummy_session_accept_callback (session_t * s)
+placeholder_session_accept_callback (session_t * s)
 {
   clib_warning ("called...");
   return 0;
 }
 
 static int
-dummy_server_rx_callback (session_t * s)
+placeholder_server_rx_callback (session_t * s)
 {
   clib_warning ("called...");
   return -1;
 }
 
 /* *INDENT-OFF* */
-static session_cb_vft_t dummy_session_cbs = {
-  .session_reset_callback = dummy_session_reset_callback,
-  .session_connected_callback = dummy_session_connected_callback,
-  .session_accept_callback = dummy_session_accept_callback,
-  .session_disconnect_callback = dummy_session_disconnect_callback,
-  .builtin_app_rx_callback = dummy_server_rx_callback,
-  .add_segment_callback = dummy_add_segment_callback,
-  .del_segment_callback = dummy_del_segment_callback,
+static session_cb_vft_t placeholder_session_cbs = {
+  .session_reset_callback = placeholder_session_reset_callback,
+  .session_connected_callback = placeholder_session_connected_callback,
+  .session_accept_callback = placeholder_session_accept_callback,
+  .session_disconnect_callback = placeholder_session_disconnect_callback,
+  .builtin_app_rx_callback = placeholder_server_rx_callback,
+  .add_segment_callback = placeholder_add_segment_callback,
+  .del_segment_callback = placeholder_del_segment_callback,
 };
 /* *INDENT-ON* */
 
@@ -128,7 +128,7 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
     .api_client_index = ~0,
     .options = options,
     .namespace_id = 0,
-    .session_cb_vft = &dummy_session_cbs,
+    .session_cb_vft = &placeholder_session_cbs,
     .name = format (0, "segment_manager_test_pressure_1"),
   };
 
@@ -168,7 +168,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_enqueue (tx_fifo, fifo_size - 1, data);
 
   /* 256KB+ / 2048KB+ => ~12% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -182,7 +181,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_enqueue (tx_fifo, fifo_size, data);
 
   /* 8 chunks : 49% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -192,7 +190,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_enqueue (tx_fifo, fifo_size, data);
 
   /* 10 chunks : 61% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_LOW_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -204,7 +201,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_enqueue (tx_fifo, fifo_size, data);
 
   /* 14 chunks : 85% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_HIGH_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -217,7 +213,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_dequeue_drop (tx_fifo, fifo_size);
 
   /* 10 chunks : 61% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_LOW_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -230,7 +225,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_enqueue (tx_fifo, fifo_size, data);
 
   /* 14 chunks : 85% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_HIGH_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -242,7 +236,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
 
 
   /* 10 chunks : 61% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_LOW_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -258,7 +251,6 @@ segment_manager_test_pressure_1 (vlib_main_t * vm, unformat_input_t * input)
   svm_fifo_dequeue_drop (tx_fifo, fifo_size);
 
   /* 2 chunks : 12% */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -292,7 +284,7 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
     .api_client_index = ~0,
     .options = options,
     .namespace_id = 0,
-    .session_cb_vft = &dummy_session_cbs,
+    .session_cb_vft = &placeholder_session_cbs,
     .name = format (0, "segment_manager_test_pressure_1"),
   };
 
@@ -310,7 +302,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
 
   /* initial status : (0 / 2MB) */
   fs0 = segment_manager_get_segment (sm, 0);
-  fifo_segment_update_free_bytes (fs0);
   rv = fifo_segment_get_mem_status (fs0);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -338,7 +329,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
     }
 
   /* 510 chunks : 100% of 2MB */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_HIGH_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -348,7 +338,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
   SEG_MGR_TEST ((rv == SVM_FIFO_EGROW), "svm_fifo_enqueue %d", rv);
 
   /* then, no-memory is detected */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_MEMORY),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -363,7 +352,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
    * but the reached-mem-limit record is not reset
    * so the no-memory state lasts.
    */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_MEMORY),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -375,7 +363,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
     }
 
   /* 356 chunks : 70% of 2MB */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_LOW_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -387,7 +374,6 @@ segment_manager_test_pressure_2 (vlib_main_t * vm, unformat_input_t * input)
     }
 
   /* 2 chunks : 3% of 2MB */
-  fifo_segment_update_free_bytes (fs);
   rv = fifo_segment_get_mem_status (fs);
   SEG_MGR_TEST ((rv == MEMORY_PRESSURE_NO_PRESSURE),
                "fifo_segment_get_mem_status %s", states_str[rv]);
@@ -422,7 +408,7 @@ segment_manager_test_fifo_balanced_alloc (vlib_main_t * vm,
     .api_client_index = ~0,
     .options = options,
     .namespace_id = 0,
-    .session_cb_vft = &dummy_session_cbs,
+    .session_cb_vft = &placeholder_session_cbs,
     .name = format (0, "segment_manager_test_pressure_1"),
   };
 
@@ -462,7 +448,7 @@ segment_manager_test_fifo_balanced_alloc (vlib_main_t * vm,
     }
 
   /* add another 2MB segment */
-  fs_index = segment_manager_add_segment (sm, size_2MB);
+  fs_index = segment_manager_add_segment (sm, size_2MB, 0);
   SEG_MGR_TEST ((fs_index == 1), "fs_index %d", fs_index);
 
   /* allocate fifos : 4KB x2
@@ -542,7 +528,7 @@ segment_manager_test_fifo_ops (vlib_main_t * vm, unformat_input_t * input)
     .api_client_index = ~0,
     .options = options,
     .namespace_id = 0,
-    .session_cb_vft = &dummy_session_cbs,
+    .session_cb_vft = &placeholder_session_cbs,
     .name = format (0, "segment_manager_test_pressure_1"),
   };
 
@@ -684,8 +670,8 @@ segment_manager_test_fifo_ops (vlib_main_t * vm, unformat_input_t * input)
                "fifo_segment_get_mem_status %s", states_str[rv]);
 
   /* (virtual) fifo size is still large as it is not updated */
-  SEG_MGR_TEST ((rx_fifo->size == most_grown), "rx_fifo->size %u",
-               rx_fifo->size);
+  SEG_MGR_TEST ((rx_fifo->shr->size == most_grown), "rx_fifo->size %u",
+               rx_fifo->shr->size);
 
   vnet_app_detach_args_t detach_args = {
     .app_index = attach_args.app_index,
@@ -697,6 +683,58 @@ segment_manager_test_fifo_ops (vlib_main_t * vm, unformat_input_t * input)
   return 0;
 }
 
+static int
+segment_manager_test_prealloc_hdrs (vlib_main_t * vm,
+                                   unformat_input_t * input)
+{
+  u32 fifo_size = size_4KB, prealloc_hdrs, sm_index, fs_index;
+  u64 options[APP_OPTIONS_N_OPTIONS];
+  uword app_seg_size = size_2MB;
+  segment_manager_t *sm;
+  fifo_segment_t *fs;
+  int rv;
+
+  memset (&options, 0, sizeof (options));
+
+  vnet_app_attach_args_t attach_args = {
+    .api_client_index = ~0,
+    .options = options,
+    .namespace_id = 0,
+    .session_cb_vft = &placeholder_session_cbs,
+    .name = format (0, "segment_manager_prealloc_hdrs"),
+  };
+
+  prealloc_hdrs = (app_seg_size - (16 << 10)) / sizeof (svm_fifo_t);
+
+  attach_args.options[APP_OPTIONS_SEGMENT_SIZE] = app_seg_size;
+  attach_args.options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
+  attach_args.options[APP_OPTIONS_RX_FIFO_SIZE] = fifo_size;
+  attach_args.options[APP_OPTIONS_TX_FIFO_SIZE] = fifo_size;
+  attach_args.options[APP_OPTIONS_PREALLOC_FIFO_HDRS] = prealloc_hdrs;
+
+  rv = vnet_application_attach (&attach_args);
+  vec_free (attach_args.name);
+
+  SEG_MGR_TEST ((rv == 0), "vnet_application_attach %d", rv);
+
+  segment_manager_parse_segment_handle (attach_args.segment_handle, &sm_index,
+                                       &fs_index);
+  sm = segment_manager_get (sm_index);
+
+  SEG_MGR_TEST ((sm != 0), "seg manager is valid", sm);
+
+  fs = segment_manager_get_segment (sm, fs_index);
+  SEG_MGR_TEST (fifo_segment_num_free_fifos (fs) == prealloc_hdrs,
+               "prealloc should be %u", prealloc_hdrs);
+
+  vnet_app_detach_args_t detach_args = {
+    .app_index = attach_args.app_index,
+    .api_client_index = ~0,
+  };
+  rv = vnet_application_detach (&detach_args);
+  SEG_MGR_TEST ((rv == 0), "vnet_application_detach %d", rv);
+  return 0;
+}
 
 static clib_error_t *
 segment_manager_test (vlib_main_t * vm,
@@ -716,6 +754,8 @@ segment_manager_test (vlib_main_t * vm,
        res = segment_manager_test_fifo_balanced_alloc (vm, input);
       else if (unformat (input, "fifo_ops"))
        res = segment_manager_test_fifo_ops (vm, input);
+      else if (unformat (input, "prealloc_hdrs"))
+       res = segment_manager_test_prealloc_hdrs (vm, input);
 
       else if (unformat (input, "all"))
        {
@@ -727,6 +767,8 @@ segment_manager_test (vlib_main_t * vm,
            goto done;
          if ((res = segment_manager_test_fifo_ops (vm, input)))
            goto done;
+         if ((res = segment_manager_test_prealloc_hdrs (vm, input)))
+           goto done;
        }
       else
        break;
@@ -743,7 +785,7 @@ VLIB_CLI_COMMAND (tcp_test_command, static) =
 {
   .path = "test segment-manager",
   .short_help = "test segment manager [pressure_levels_1]"
-                "[pressure_level_2][alloc][fifo_ops][all]",
+                "[pressure_level_2][alloc][fifo_ops][prealloc_hdrs][all]",
   .function = segment_manager_test,
 };
 
@@ -754,4 +796,3 @@ VLIB_CLI_COMMAND (tcp_test_command, static) =
  * eval: (c-set-style "gnu")
  * End:
  */
-