[aarch64] Fixes CLI crashes on dpaa2 platform.

[vpp.git] / src / vlib / buffer.c

diff --git a/src/vlib/buffer.c b/src/vlib/buffer.c
index a5c955c..d0d8f60 100644 (file)
--- a/src/vlib/buffer.c
+++ b/src/vlib/buffer.c
@@ -47,6 +47,7 @@
 #include <vlib/unix/unix.h>
 
 vlib_buffer_callbacks_t *vlib_buffer_callbacks = 0;
+static u32 vlib_buffer_physmem_sz = 32 << 20;
 
 uword
 vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
@@ -69,7 +70,7 @@ u8 *
 format_vlib_buffer (u8 * s, va_list * args)
 {
   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
-  uword indent = format_get_indent (s);
+  u32 indent = format_get_indent (s);
 
   s = format (s, "current data %d, length %d, free-list %d, clone-count %u",
              b->current_data, b->current_length,
@@ -396,6 +397,8 @@ vlib_buffer_create_free_list_helper (vlib_main_t * vm,
        hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
     }
 
+  clib_spinlock_init (&f->global_buffers_lock);
+
   for (i = 1; i < vec_len (vlib_mains); i++)
     {
       vlib_buffer_main_t *wbm = vlib_mains[i]->buffer_main;
@@ -459,7 +462,8 @@ del_free_list (vlib_main_t * vm, vlib_buffer_free_list_t * f)
   u32 i;
 
   for (i = 0; i < vec_len (f->buffer_memory_allocated); i++)
-    vm->os_physmem_free (f->buffer_memory_allocated[i]);
+    vm->os_physmem_free (vm, vm->buffer_main->physmem_region,
+                        f->buffer_memory_allocated[i]);
   vec_free (f->name);
   vec_free (f->buffer_memory_allocated);
   vec_free (f->buffers);
@@ -509,6 +513,7 @@ fill_free_list (vlib_main_t * vm,
                vlib_buffer_free_list_t * fl, uword min_free_buffers)
 {
   vlib_buffer_t *buffers, *b;
+  vlib_buffer_free_list_t *mfl;
   int n, n_bytes, i;
   u32 *bi;
   u32 n_remaining, n_alloc, n_this_chunk;
@@ -518,6 +523,22 @@ fill_free_list (vlib_main_t * vm,
   if (n <= 0)
     return min_free_buffers;
 
+  mfl = vlib_buffer_get_free_list (vlib_mains[0], fl->index);
+  if (vec_len (mfl->global_buffers) > 0)
+    {
+      int n_copy, n_left;
+      clib_spinlock_lock (&mfl->global_buffers_lock);
+      n_copy = clib_min (vec_len (mfl->global_buffers), n);
+      n_left = vec_len (mfl->global_buffers) - n_copy;
+      vec_add_aligned (fl->buffers, mfl->global_buffers + n_left, n_copy,
+                      CLIB_CACHE_LINE_BYTES);
+      _vec_len (mfl->global_buffers) = n_left;
+      clib_spinlock_unlock (&mfl->global_buffers_lock);
+      n = min_free_buffers - vec_len (fl->buffers);
+      if (n <= 0)
+       return min_free_buffers;
+    }
+
   /* Always allocate round number of buffers. */
   n = round_pow2 (n, CLIB_CACHE_LINE_BYTES / sizeof (u32));
 
@@ -533,9 +554,9 @@ fill_free_list (vlib_main_t * vm,
       n_bytes = n_this_chunk * (sizeof (b[0]) + fl->n_data_bytes);
 
       /* drb: removed power-of-2 ASSERT */
-      buffers = vm->os_physmem_alloc_aligned (&vm->physmem_main,
-                                             n_bytes,
-                                             sizeof (vlib_buffer_t));
+      buffers =
+       vm->os_physmem_alloc_aligned (vm, vm->buffer_main->physmem_region,
+                                     n_bytes, sizeof (vlib_buffer_t));
       if (!buffers)
        return n_alloc;
 
@@ -665,7 +686,7 @@ vlib_buffer_free_inline (vlib_main_t * vm,
       u32 bi = buffers[i];
 
       b = vlib_get_buffer (vm, bi);
-
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
       fl = vlib_buffer_get_buffer_free_list (vm, b, &fi);
 
       /* The only current use of this callback: multicast recycle */
@@ -1032,10 +1053,25 @@ VLIB_CLI_COMMAND (show_buffers_command, static) = {
 };
 /* *INDENT-ON* */
 
-void
-vlib_buffer_cb_init (struct vlib_main_t *vm)
+clib_error_t *
+vlib_buffer_main_init (struct vlib_main_t * vm)
 {
-  vlib_buffer_main_t *bm = vm->buffer_main;
+  vlib_buffer_main_t *bm;
+  clib_error_t *error;
+
+  vec_validate (vm->buffer_main, 0);
+  bm = vm->buffer_main;
+
+  if (vlib_buffer_callbacks)
+    {
+      /* external plugin has registered own buffer callbacks
+         so we just copy them  and quit */
+      vlib_buffer_main_t *bm = vm->buffer_main;
+      clib_memcpy (&bm->cb, vlib_buffer_callbacks,
+                  sizeof (vlib_buffer_callbacks_t));
+      bm->callbacks_registered = 1;
+      return 0;
+    }
 
   bm->cb.vlib_buffer_alloc_cb = &vlib_buffer_alloc_internal;
   bm->cb.vlib_buffer_alloc_from_free_list_cb =
@@ -1045,8 +1081,49 @@ vlib_buffer_cb_init (struct vlib_main_t *vm)
   bm->cb.vlib_buffer_delete_free_list_cb =
     &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_INIT_MHEAP |
+                                    VLIB_PHYSMEM_F_HAVE_BUFFERS,
+                                    &bm->physmem_region);
+
+  if (error == 0)
+    return 0;
+
+  clib_error_free (error);
+
+  /* we my be running unpriviledged, so try to allocate fake physmem */
+  error = vlib_physmem_region_alloc (vm, "buffers (fake)",
+                                    vlib_buffer_physmem_sz, 0,
+                                    VLIB_PHYSMEM_F_FAKE |
+                                    VLIB_PHYSMEM_F_INIT_MHEAP |
+                                    VLIB_PHYSMEM_F_HAVE_BUFFERS,
+                                    &bm->physmem_region);
+  return error;
+}
+
+static clib_error_t *
+vlib_buffers_configure (vlib_main_t * vm, unformat_input_t * input)
+{
+  u32 size_in_mb;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "memory-size-in-mb %d", &size_in_mb))
+       vlib_buffer_physmem_sz = size_in_mb << 20;
+      else
+       return unformat_parse_error (input);
+    }
+
+  unformat_free (input);
+  return 0;
 }
 
+VLIB_EARLY_CONFIG_FUNCTION (vlib_buffers_configure, "buffers");
+
+
 /** @endcond */
 /*
  * fd.io coding-style-patch-verification: ON