* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+/**
+ * @cond DPDK
+ * @file
+ *
+ * Allocate/free network buffers with DPDK.
+ */
+
#include <rte_config.h>
#include <rte_common.h>
#include <rte_log.h>
#include <rte_memory.h>
-#include <rte_memcpy.h>
#include <rte_memzone.h>
#include <rte_tailq.h>
#include <rte_eal.h>
#include <rte_ring.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
+#include <rte_version.h>
#include <vlib/vlib.h>
-phys_addr_t __attribute__ ((weak)) rte_mem_virt2phy();
-int __attribute__ ((weak)) rte_eal_has_hugepages();
-unsigned __attribute__ ((weak)) rte_socket_id();
-struct rte_mempool * __attribute__ ((weak)) rte_mempool_create();
-void __attribute__ ((weak)) rte_pktmbuf_init();
-void __attribute__ ((weak)) rte_pktmbuf_pool_init();
+#pragma weak rte_mem_virt2phy
+#pragma weak rte_eal_has_hugepages
+#pragma weak rte_socket_id
+#pragma weak rte_pktmbuf_pool_create
-uword vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm, vlib_buffer_t * b_first)
+uword
+vlib_buffer_length_in_chain_slow_path (vlib_main_t * vm,
+ vlib_buffer_t * b_first)
{
- vlib_buffer_t * b = b_first;
+ vlib_buffer_t *b = b_first;
uword l_first = b_first->current_length;
uword l = 0;
while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
return l + l_first;
}
-u8 * format_vlib_buffer (u8 * s, va_list * args)
+u8 *
+format_vlib_buffer (u8 * s, va_list * args)
{
- vlib_buffer_t * b = va_arg (*args, vlib_buffer_t *);
+ vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
uword indent = format_get_indent (s);
s = format (s, "current data %d, length %d, free-list %d",
- b->current_data, b->current_length,
- b->free_list_index);
+ b->current_data, b->current_length, b->free_list_index);
if (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID)
s = format (s, ", totlen-nifb %d",
while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
{
- vlib_main_t * vm = vlib_get_main();
+ vlib_main_t *vm = vlib_get_main ();
u32 next_buffer = b->next_buffer;
- b = vlib_get_buffer(vm, next_buffer);
+ b = vlib_get_buffer (vm, next_buffer);
s = format (s, "\n%Unext-buffer 0x%x, segment length %d",
format_white_space, indent, next_buffer, b->current_length);
return s;
}
-u8 * format_vlib_buffer_and_data (u8 * s, va_list * args)
+u8 *
+format_vlib_buffer_and_data (u8 * s, va_list * args)
{
- vlib_buffer_t * b = va_arg (*args, vlib_buffer_t *);
-
+ vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
+
s = format (s, "%U, %U",
format_vlib_buffer, b,
format_hex_bytes, vlib_buffer_get_current (b), 64);
return s;
}
-u8 * format_vlib_buffer_contents (u8 * s, va_list * va)
+u8 *
+format_vlib_buffer_contents (u8 * s, va_list * va)
{
- vlib_main_t * vm = va_arg (*va, vlib_main_t *);
- vlib_buffer_t * b = va_arg (*va, vlib_buffer_t *);
-
+ vlib_main_t *vm = va_arg (*va, vlib_main_t *);
+ vlib_buffer_t *b = va_arg (*va, vlib_buffer_t *);
+
while (1)
{
- vec_add (s, vlib_buffer_get_current (b),
- b->current_length);
- if (! (b->flags & VLIB_BUFFER_NEXT_PRESENT))
+ vec_add (s, vlib_buffer_get_current (b), b->current_length);
+ if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
break;
b = vlib_get_buffer (vm, b->next_buffer);
}
/* Aligned copy routine. */
void
-vlib_aligned_memcpy (void * _dst, void * _src, int n_bytes)
+vlib_aligned_memcpy (void *_dst, void *_src, int n_bytes)
{
- vlib_copy_unit_t * dst = _dst;
- vlib_copy_unit_t * src = _src;
+ vlib_copy_unit_t *dst = _dst;
+ vlib_copy_unit_t *src = _src;
/* Arguments must be naturally aligned. */
ASSERT (pointer_to_uword (dst) % sizeof (dst[0]) == 0);
}
}
else
- /* Cache line size unknown: fall back to slow version. */;
+ /* Cache line size unknown: fall back to slow version. */ ;
while (n_bytes > 0)
{
vlib_buffer_free_list_t * src)
{
uword l;
- u32 * d;
-
+ u32 *d;
+
trim_aligned (src);
trim_aligned (dst);
always_inline u32
vlib_buffer_get_free_list_with_size (vlib_main_t * vm, u32 size)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
+ vlib_buffer_main_t *bm = vm->buffer_main;
size = vlib_buffer_round_size (size);
- uword * p = hash_get (bm->free_list_by_size, size);
+ uword *p = hash_get (bm->free_list_by_size, size);
return p ? p[0] : ~0;
}
static u32
vlib_buffer_create_free_list_helper (vlib_main_t * vm,
u32 n_data_bytes,
- u32 is_public,
- u32 is_default,
- u8 * name)
+ u32 is_public, u32 is_default, u8 * name)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- vlib_buffer_free_list_t * f;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ vlib_buffer_free_list_t *f;
- if (! is_default && pool_elts (bm->buffer_free_list_pool) == 0)
+ if (!is_default && pool_elts (bm->buffer_free_list_pool) == 0)
{
u32 default_free_free_list_index;
+ /* *INDENT-OFF* */
default_free_free_list_index =
- vlib_buffer_create_free_list_helper (vm,
- /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
- /* is_public */ 1,
- /* is_default */ 1,
- (u8 *) "default");
- ASSERT (default_free_free_list_index == VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+ vlib_buffer_create_free_list_helper
+ (vm,
+ /* default buffer size */ VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES,
+ /* is_public */ 1,
+ /* is_default */ 1,
+ (u8 *) "default");
+ /* *INDENT-ON* */
+ ASSERT (default_free_free_list_index ==
+ VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
if (n_data_bytes == VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES && is_public)
return default_free_free_list_index;
if (is_public)
{
- uword * p = hash_get (bm->free_list_by_size, f->n_data_bytes);
- if (! p)
+ uword *p = hash_get (bm->free_list_by_size, f->n_data_bytes);
+ if (!p)
hash_set (bm->free_list_by_size, f->n_data_bytes, f->index);
}
return f->index;
}
-u32 vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
- char * fmt, ...)
+u32
+vlib_buffer_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
+ char *fmt, ...)
{
va_list va;
- u8 * name;
+ u8 *name;
va_start (va, fmt);
name = va_format (0, fmt, &va);
name);
}
-u32 vlib_buffer_get_or_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
- char * fmt, ...)
+u32
+vlib_buffer_get_or_create_free_list (vlib_main_t * vm, u32 n_data_bytes,
+ char *fmt, ...)
{
u32 i = vlib_buffer_get_free_list_with_size (vm, n_data_bytes);
if (i == ~0)
{
va_list va;
- u8 * name;
+ u8 *name;
va_start (va, fmt);
name = va_format (0, fmt, &va);
/* is_default */ 0,
name);
}
-
+
return i;
}
struct rte_mbuf *mb;
vlib_buffer_t *b;
- for (i = 0; i < vec_len (f->unaligned_buffers); i++) {
+ for (i = 0; i < vec_len (f->unaligned_buffers); i++)
+ {
b = vlib_get_buffer (vm, f->unaligned_buffers[i]);
- mb = ((struct rte_mbuf *)b)-1;
- ASSERT(rte_mbuf_refcnt_read(mb) == 1);
+ mb = rte_mbuf_from_vlib_buffer (b);
+ ASSERT (rte_mbuf_refcnt_read (mb) == 1);
rte_pktmbuf_free (mb);
- }
- for (i = 0; i < vec_len (f->aligned_buffers); i++) {
+ }
+ for (i = 0; i < vec_len (f->aligned_buffers); i++)
+ {
b = vlib_get_buffer (vm, f->aligned_buffers[i]);
- mb = ((struct rte_mbuf *)b)-1;
- ASSERT(rte_mbuf_refcnt_read(mb) == 1);
+ mb = rte_mbuf_from_vlib_buffer (b);
+ ASSERT (rte_mbuf_refcnt_read (mb) == 1);
rte_pktmbuf_free (mb);
- }
+ }
vec_free (f->name);
vec_free (f->unaligned_buffers);
vec_free (f->aligned_buffers);
}
/* Add buffer free list. */
-void vlib_buffer_delete_free_list (vlib_main_t * vm, u32 free_list_index)
+void
+vlib_buffer_delete_free_list (vlib_main_t * vm, u32 free_list_index)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- vlib_buffer_free_list_t * f;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ vlib_buffer_free_list_t *f;
u32 merge_index;
f = vlib_buffer_get_free_list (vm, free_list_index);
/* Make sure free list has at least given number of free buffers. */
static uword
fill_free_list (vlib_main_t * vm,
- vlib_buffer_free_list_t * fl,
- uword min_free_buffers)
+ vlib_buffer_free_list_t * fl, uword min_free_buffers)
{
- vlib_buffer_t * b;
+ vlib_buffer_t *b;
int n, i;
u32 bi;
u32 n_remaining = 0, n_alloc = 0;
- unsigned socket_id = rte_socket_id ? rte_socket_id() : 0;
+ unsigned socket_id = rte_socket_id ? rte_socket_id () : 0;
struct rte_mempool *rmp = vm->buffer_main->pktmbuf_pools[socket_id];
struct rte_mbuf *mb;
-
+
/* Too early? */
- if (PREDICT_FALSE(rmp == 0))
+ if (PREDICT_FALSE (rmp == 0))
return 0;
trim_aligned (fl);
/* Always allocate new buffers in reasonably large sized chunks. */
n = clib_max (n, fl->min_n_buffers_each_physmem_alloc);
- vec_validate (vm->mbuf_alloc_list, n-1);
-
+ vec_validate (vm->mbuf_alloc_list, n - 1);
+
if (rte_mempool_get_bulk (rmp, vm->mbuf_alloc_list, n) < 0)
return 0;
{
mb = vm->mbuf_alloc_list[i];
- ASSERT(rte_mbuf_refcnt_read(mb) == 0);
- rte_mbuf_refcnt_set(mb, 1);
+ ASSERT (rte_mbuf_refcnt_read (mb) == 0);
+ rte_mbuf_refcnt_set (mb, 1);
mb->next = NULL;
mb->data_off = RTE_PKTMBUF_HEADROOM;
mb->nb_segs = 1;
- b = (vlib_buffer_t *)(mb+1);
+ b = vlib_buffer_from_rte_mbuf (mb);
bi = vlib_get_buffer_index (vm, b);
-
+
vec_add1_aligned (fl->aligned_buffers, bi, sizeof (vlib_copy_unit_t));
n_alloc++;
n_remaining--;
vlib_buffer_init_for_free_list (b, fl);
-
+
if (fl->buffer_init_function)
- fl->buffer_init_function (vm, fl, &bi, 1);
+ fl->buffer_init_function (vm, fl, &bi, 1);
}
fl->n_alloc += n;
always_inline uword
copy_alignment (u32 * x)
-{ return (pointer_to_uword (x) / sizeof (x[0])) % BUFFERS_PER_COPY; }
+{
+ return (pointer_to_uword (x) / sizeof (x[0])) % BUFFERS_PER_COPY;
+}
static u32
alloc_from_free_list (vlib_main_t * vm,
vlib_buffer_free_list_t * free_list,
- u32 * alloc_buffers,
- u32 n_alloc_buffers)
+ u32 * alloc_buffers, u32 n_alloc_buffers)
{
- u32 * dst, * u_src;
+ u32 *dst, *u_src;
uword u_len, n_left;
uword n_unaligned_start, n_unaligned_end, n_filled;
n_filled = fill_free_list (vm, free_list, n_alloc_buffers);
if (n_filled == 0)
return 0;
-
+
n_left = n_filled < n_left ? n_filled : n_left;
n_alloc_buffers = n_left;
/* Aligned copy. */
{
- vlib_copy_unit_t * d, * s;
+ vlib_copy_unit_t *d, *s;
uword n_copy;
- if (vec_len(free_list->aligned_buffers) < ((n_left/BUFFERS_PER_COPY)*BUFFERS_PER_COPY))
- abort();
+ if (vec_len (free_list->aligned_buffers) <
+ ((n_left / BUFFERS_PER_COPY) * BUFFERS_PER_COPY))
+ abort ();
n_copy = n_left / BUFFERS_PER_COPY;
n_left = n_left % BUFFERS_PER_COPY;
u_len--;
}
- if (! free_list->unaligned_buffers)
+ if (!free_list->unaligned_buffers)
ASSERT (u_len == 0);
else
_vec_len (free_list->unaligned_buffers) = u_len;
/* Allocate a given number of buffers into given array.
Returns number actually allocated which will be either zero or
number requested. */
-u32 vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
+u32
+vlib_buffer_alloc (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
+ vlib_buffer_main_t *bm = vm->buffer_main;
return alloc_from_free_list
(vm,
buffers, n_buffers);
}
-u32 vlib_buffer_alloc_from_free_list (vlib_main_t * vm,
- u32 * buffers,
- u32 n_buffers,
- u32 free_list_index)
+u32
+vlib_buffer_alloc_from_free_list (vlib_main_t * vm,
+ u32 * buffers,
+ u32 n_buffers, u32 free_list_index)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- vlib_buffer_free_list_t * f;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ vlib_buffer_free_list_t *f;
f = pool_elt_at_index (bm->buffer_free_list_pool, free_list_index);
return alloc_from_free_list (vm, f, buffers, n_buffers);
}
always_inline void
add_buffer_to_free_list (vlib_main_t * vm,
- vlib_buffer_free_list_t * f,
+ vlib_buffer_free_list_t * f,
u32 buffer_index, u8 do_init)
{
- vlib_buffer_t * b;
+ vlib_buffer_t *b;
b = vlib_get_buffer (vm, buffer_index);
- if (PREDICT_TRUE(do_init))
- vlib_buffer_init_for_free_list (b, f);
- vec_add1_aligned (f->aligned_buffers, buffer_index, sizeof (vlib_copy_unit_t));
+ if (PREDICT_TRUE (do_init))
+ vlib_buffer_init_for_free_list (b, f);
+ vec_add1_aligned (f->aligned_buffers, buffer_index,
+ sizeof (vlib_copy_unit_t));
}
always_inline vlib_buffer_free_list_t *
buffer_get_free_list (vlib_main_t * vm, vlib_buffer_t * b, u32 * index)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
+ vlib_buffer_main_t *bm = vm->buffer_main;
u32 i;
*index = i = b->free_list_index;
return pool_elt_at_index (bm->buffer_free_list_pool, i);
}
-void *vlib_set_buffer_free_callback (vlib_main_t *vm, void *fp)
+void *
+vlib_set_buffer_free_callback (vlib_main_t * vm, void *fp)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- void * rv = bm->buffer_free_callback;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ void *rv = bm->buffer_free_callback;
bm->buffer_free_callback = fp;
return rv;
static_always_inline void
vlib_buffer_free_inline (vlib_main_t * vm,
- u32 * buffers,
- u32 n_buffers,
- u32 follow_buffer_next)
+ u32 * buffers, u32 n_buffers, u32 follow_buffer_next)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- vlib_buffer_free_list_t * fl;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ vlib_buffer_free_list_t *fl;
u32 fi;
int i;
- u32 (*cb)(vlib_main_t * vm, u32 * buffers, u32 n_buffers,
- u32 follow_buffer_next);
+ u32 (*cb) (vlib_main_t * vm, u32 * buffers, u32 n_buffers,
+ u32 follow_buffer_next);
cb = bm->buffer_free_callback;
if (PREDICT_FALSE (cb != 0))
- n_buffers = (*cb)(vm, buffers, n_buffers, follow_buffer_next);
+ n_buffers = (*cb) (vm, buffers, n_buffers, follow_buffer_next);
- if (! n_buffers)
+ if (!n_buffers)
return;
- for (i = 0; i < n_buffers; i++)
+ for (i = 0; i < n_buffers; i++)
{
- vlib_buffer_t * b;
- struct rte_mbuf * mb;
-
+ vlib_buffer_t *b;
+ struct rte_mbuf *mb;
+
b = vlib_get_buffer (vm, buffers[i]);
fl = buffer_get_free_list (vm, b, &fi);
-
+
/* The only current use of this callback: multicast recycle */
- if (PREDICT_FALSE (fl->buffers_added_to_freelist_function != 0))
- {
- int j;
-
- add_buffer_to_free_list (vm, fl, buffers[i], b->clone_count == 0);
-
- for (j = 0; j < vec_len (bm->announce_list); j++)
- {
- if (fl == bm->announce_list[j])
- goto already_announced;
- }
- vec_add1 (bm->announce_list, fl);
- already_announced:
- ;
- }
+ if (PREDICT_FALSE (fl->buffers_added_to_freelist_function != 0))
+ {
+ int j;
+
+ add_buffer_to_free_list
+ (vm, fl, buffers[i], (b->flags & VLIB_BUFFER_RECYCLE) == 0);
+
+ for (j = 0; j < vec_len (bm->announce_list); j++)
+ {
+ if (fl == bm->announce_list[j])
+ goto already_announced;
+ }
+ vec_add1 (bm->announce_list, fl);
+ already_announced:
+ ;
+ }
else
- {
- mb = ((struct rte_mbuf *)b)-1;
- ASSERT(rte_mbuf_refcnt_read(mb) == 1);
- rte_pktmbuf_free (mb);
- }
+ {
+ if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_RECYCLE) == 0))
+ {
+ mb = rte_mbuf_from_vlib_buffer (b);
+ ASSERT (rte_mbuf_refcnt_read (mb) == 1);
+ rte_pktmbuf_free (mb);
+ }
+ }
}
- if (vec_len(bm->announce_list))
+ if (vec_len (bm->announce_list))
{
- vlib_buffer_free_list_t * fl;
+ vlib_buffer_free_list_t *fl;
for (i = 0; i < vec_len (bm->announce_list); i++)
- {
- fl = bm->announce_list[i];
- fl->buffers_added_to_freelist_function (vm, fl);
- }
- _vec_len(bm->announce_list) = 0;
+ {
+ fl = bm->announce_list[i];
+ fl->buffers_added_to_freelist_function (vm, fl);
+ }
+ _vec_len (bm->announce_list) = 0;
}
}
-void vlib_buffer_free (vlib_main_t * vm,
- u32 * buffers,
- u32 n_buffers)
+void
+vlib_buffer_free (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
{
- vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */ 1);
+ vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */
+ 1);
}
-void vlib_buffer_free_no_next (vlib_main_t * vm,
- u32 * buffers,
- u32 n_buffers)
+void
+vlib_buffer_free_no_next (vlib_main_t * vm, u32 * buffers, u32 n_buffers)
{
- vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */ 0);
+ vlib_buffer_free_inline (vm, buffers, n_buffers, /* follow_buffer_next */
+ 0);
}
/* Copy template packet data into buffers as they are allocated. */
-__attribute__((unused)) static void
-vlib_packet_template_buffer_init (vlib_main_t * vm,
- vlib_buffer_free_list_t * fl,
- u32 * buffers,
- u32 n_buffers)
+__attribute__ ((unused))
+ static void
+ vlib_packet_template_buffer_init (vlib_main_t * vm,
+ vlib_buffer_free_list_t * fl,
+ u32 * buffers, u32 n_buffers)
{
- vlib_packet_template_t * t = uword_to_pointer (fl->buffer_init_function_opaque,
- vlib_packet_template_t *);
+ vlib_packet_template_t *t =
+ uword_to_pointer (fl->buffer_init_function_opaque,
+ vlib_packet_template_t *);
uword i;
for (i = 0; i < n_buffers; i++)
{
- vlib_buffer_t * b = vlib_get_buffer (vm, buffers[i]);
+ vlib_buffer_t *b = vlib_get_buffer (vm, buffers[i]);
ASSERT (b->current_length == vec_len (t->packet_data));
- memcpy (vlib_buffer_get_current (b), t->packet_data, b->current_length);
+ clib_memcpy (vlib_buffer_get_current (b), t->packet_data,
+ b->current_length);
}
}
-void vlib_packet_template_init (vlib_main_t * vm,
- vlib_packet_template_t * t,
- void * packet_data,
- uword n_packet_data_bytes,
- uword min_n_buffers_each_physmem_alloc,
- char * fmt,
- ...)
+void
+vlib_packet_template_init (vlib_main_t * vm,
+ vlib_packet_template_t * t,
+ void *packet_data,
+ uword n_packet_data_bytes,
+ uword min_n_buffers_each_physmem_alloc,
+ char *fmt, ...)
{
va_list va;
- __attribute__((unused)) u8 * name;
+ __attribute__ ((unused)) u8 *name;
va_start (va, fmt);
name = va_format (0, fmt, &va);
va_end (va);
- vlib_worker_thread_barrier_sync(vm);
+ vlib_worker_thread_barrier_sync (vm);
memset (t, 0, sizeof (t[0]));
vec_add (t->packet_data, packet_data, n_packet_data_bytes);
- vlib_worker_thread_barrier_release(vm);
+ vlib_worker_thread_barrier_release (vm);
}
void *
-vlib_packet_template_get_packet (vlib_main_t * vm,
- vlib_packet_template_t * t,
- u32 * bi_result)
+vlib_packet_template_get_packet (vlib_main_t * vm,
+ vlib_packet_template_t * t, u32 * bi_result)
{
u32 bi;
- vlib_buffer_t * b;
+ vlib_buffer_t *b;
if (vlib_buffer_alloc (vm, &bi, 1) != 1)
return 0;
*bi_result = bi;
b = vlib_get_buffer (vm, bi);
- memcpy (vlib_buffer_get_current (b),
- t->packet_data, vec_len(t->packet_data));
- b->current_length = vec_len(t->packet_data);
+ clib_memcpy (vlib_buffer_get_current (b),
+ t->packet_data, vec_len (t->packet_data));
+ b->current_length = vec_len (t->packet_data);
/* Fix up mbuf header length fields */
- struct rte_mbuf * mb;
- mb = ((struct rte_mbuf *)b) - 1;
+ struct rte_mbuf *mb;
+ mb = rte_mbuf_from_vlib_buffer (b);
mb->data_len = b->current_length;
mb->pkt_len = b->current_length;
}
/* Append given data to end of buffer, possibly allocating new buffers. */
-u32 vlib_buffer_add_data (vlib_main_t * vm,
- u32 free_list_index,
- u32 buffer_index,
- void * data, u32 n_data_bytes)
+u32
+vlib_buffer_add_data (vlib_main_t * vm,
+ u32 free_list_index,
+ u32 buffer_index, void *data, u32 n_data_bytes)
{
u32 n_buffer_bytes, n_left, n_left_this_buffer, bi;
- vlib_buffer_t * b;
- void * d;
+ vlib_buffer_t *b;
+ void *d;
bi = buffer_index;
if (bi == 0
d = data;
n_left = n_data_bytes;
n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, free_list_index);
-
+
b = vlib_get_buffer (vm, bi);
b->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
- /* Get to the end of the chain before we try to append data...*/
+ /* Get to the end of the chain before we try to append data... */
while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
b = vlib_get_buffer (vm, b->next_buffer);
u32 n;
ASSERT (n_buffer_bytes >= b->current_length);
- n_left_this_buffer = n_buffer_bytes - (b->current_data + b->current_length);
+ n_left_this_buffer =
+ n_buffer_bytes - (b->current_data + b->current_length);
n = clib_min (n_left_this_buffer, n_left);
- memcpy (vlib_buffer_get_current (b) + b->current_length, d, n);
+ clib_memcpy (vlib_buffer_get_current (b) + b->current_length, d, n);
b->current_length += n;
n_left -= n;
if (n_left == 0)
break;
d += n;
- if (1 != vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1, free_list_index))
+ if (1 !=
+ vlib_buffer_alloc_from_free_list (vm, &b->next_buffer, 1,
+ free_list_index))
goto out_of_buffers;
b->flags |= VLIB_BUFFER_NEXT_PRESENT;
return bi;
- out_of_buffers:
+out_of_buffers:
clib_error ("out of buffers");
return bi;
}
+u16
+vlib_buffer_chain_append_data_with_alloc (vlib_main_t * vm,
+ u32 free_list_index,
+ vlib_buffer_t * first,
+ vlib_buffer_t ** last,
+ void *data, u16 data_len)
+{
+ vlib_buffer_t *l = *last;
+ u32 n_buffer_bytes =
+ vlib_buffer_free_list_buffer_size (vm, free_list_index);
+ u16 copied = 0;
+ ASSERT (n_buffer_bytes >= l->current_length + l->current_data);
+ while (data_len)
+ {
+ u16 max = n_buffer_bytes - l->current_length - l->current_data;
+ if (max == 0)
+ {
+ if (1 !=
+ vlib_buffer_alloc_from_free_list (vm, &l->next_buffer, 1,
+ free_list_index))
+ return copied;
+ *last = l = vlib_buffer_chain_buffer (vm, first, l, l->next_buffer);
+ max = n_buffer_bytes - l->current_length - l->current_data;
+ }
+
+ u16 len = (data_len > max) ? max : data_len;
+ clib_memcpy (vlib_buffer_get_current (l) + l->current_length,
+ data + copied, len);
+ vlib_buffer_chain_increase_length (first, l, len);
+ data_len -= len;
+ copied += len;
+ }
+ return copied;
+}
+
+/*
+ * Fills in the required rte_mbuf fields for chained buffers given a VLIB chain.
+ */
+void
+vlib_buffer_chain_validate (vlib_main_t * vm, vlib_buffer_t * b_first)
+{
+ vlib_buffer_t *b = b_first, *prev = b_first;
+ struct rte_mbuf *mb_prev, *mb, *mb_first;
+
+ mb_first = rte_mbuf_from_vlib_buffer (b_first);
+
+ mb_first->pkt_len = mb_first->data_len = b_first->current_length;
+ while (b->flags & VLIB_BUFFER_NEXT_PRESENT)
+ {
+ b = vlib_get_buffer (vm, b->next_buffer);
+ mb = rte_mbuf_from_vlib_buffer (b);
+ mb_prev = rte_mbuf_from_vlib_buffer (prev);
+ mb_first->nb_segs++;
+ mb_first->pkt_len += b->current_length;
+ mb_prev->next = mb;
+ mb->data_len = b->current_length;
+ prev = b;
+ }
+}
+
clib_error_t *
-vlib_buffer_pool_create(vlib_main_t * vm, unsigned num_mbufs,
- unsigned mbuf_size, unsigned socket_id)
+vlib_buffer_pool_create (vlib_main_t * vm, unsigned num_mbufs,
+ unsigned socket_id)
{
- vlib_buffer_main_t * bm = vm->buffer_main;
- vlib_physmem_main_t * vpm = &vm->physmem_main;
- struct rte_mempool * rmp;
- uword new_start, new_size;
+ vlib_buffer_main_t *bm = vm->buffer_main;
+ vlib_physmem_main_t *vpm = &vm->physmem_main;
+ struct rte_mempool *rmp;
int i;
- if (!rte_mempool_create)
+ if (!rte_pktmbuf_pool_create)
return clib_error_return (0, "not linked with DPDK");
- vec_validate_aligned(bm->pktmbuf_pools, socket_id, CLIB_CACHE_LINE_BYTES);
+ vec_validate_aligned (bm->pktmbuf_pools, socket_id, CLIB_CACHE_LINE_BYTES);
/* pool already exists, nothing to do */
if (bm->pktmbuf_pools[socket_id])
return 0;
- u8 * pool_name = format(0, "mbuf_pool_socket%u%c",socket_id, 0);
- rmp = rte_mempool_create((char *) pool_name,
- num_mbufs, mbuf_size, 512,
- sizeof(struct rte_pktmbuf_pool_private),
- rte_pktmbuf_pool_init, NULL,
- rte_pktmbuf_init, NULL,
- socket_id, 0);
- vec_free(pool_name);
+ u8 *pool_name = format (0, "mbuf_pool_socket%u%c", socket_id, 0);
- if (rmp)
- {
- new_start = pointer_to_uword(rmp);
- new_size = rmp->elt_va_end - new_start;
-
- if (vpm->virtual.size > 0)
- {
- ASSERT(new_start != vpm->virtual.start);
- if (new_start < vpm->virtual.start)
- {
- new_size = vpm->virtual.size + vpm->virtual.start - new_start;
- }
- else
- {
- new_size += new_start - vpm->virtual.start;
- new_start = vpm->virtual.start;
- }
-
- /* check if fits into buffer index range */
- if (new_size > ( (uword) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
- rmp = 0;
- }
- }
+ rmp = rte_pktmbuf_pool_create ((char *) pool_name, /* pool name */
+ num_mbufs, /* number of mbufs */
+ 512, /* cache size */
+ VLIB_BUFFER_HDR_SIZE, /* priv size */
+ VLIB_BUFFER_PRE_DATA_SIZE + VLIB_BUFFER_DATA_SIZE, /* dataroom size */
+ socket_id); /* cpu socket */
if (rmp)
{
- bm->pktmbuf_pools[socket_id] = rmp;
- vpm->virtual.start = new_start;
- vpm->virtual.size = new_size;
- vpm->virtual.end = new_start + new_size;
- return 0;
+ {
+ uword this_pool_end;
+ uword this_pool_start;
+ uword this_pool_size;
+ uword save_vpm_start, save_vpm_end, save_vpm_size;
+ struct rte_mempool_memhdr *memhdr;
+
+ this_pool_start = ~0ULL;
+ this_pool_end = 0LL;
+
+ STAILQ_FOREACH (memhdr, &rmp->mem_list, next)
+ {
+ if (((uword) (memhdr->addr + memhdr->len)) > this_pool_end)
+ this_pool_end = (uword) (memhdr->addr + memhdr->len);
+ if (((uword) memhdr->addr) < this_pool_start)
+ this_pool_start = (uword) (memhdr->addr);
+ }
+ ASSERT (this_pool_start < ~0ULL && this_pool_end > 0);
+ this_pool_size = this_pool_end - this_pool_start;
+
+ if (CLIB_DEBUG > 1)
+ {
+ clib_warning ("%s: pool start %llx pool end %llx pool size %lld",
+ pool_name, this_pool_start, this_pool_end,
+ this_pool_size);
+ clib_warning
+ ("before: virtual.start %llx virtual.end %llx virtual.size %lld",
+ vpm->virtual.start, vpm->virtual.end, vpm->virtual.size);
+ }
+
+ save_vpm_start = vpm->virtual.start;
+ save_vpm_end = vpm->virtual.end;
+ save_vpm_size = vpm->virtual.size;
+
+ if ((this_pool_start < vpm->virtual.start) || vpm->virtual.start == 0)
+ vpm->virtual.start = this_pool_start;
+ if (this_pool_end > vpm->virtual.end)
+ vpm->virtual.end = this_pool_end;
+
+ vpm->virtual.size = vpm->virtual.end - vpm->virtual.start;
+
+ if (CLIB_DEBUG > 1)
+ {
+ clib_warning
+ ("after: virtual.start %llx virtual.end %llx virtual.size %lld",
+ vpm->virtual.start, vpm->virtual.end, vpm->virtual.size);
+ }
+
+ /* check if fits into buffer index range */
+ if ((u64) vpm->virtual.size >
+ ((u64) 1 << (32 + CLIB_LOG2_CACHE_LINE_BYTES)))
+ {
+ clib_warning ("physmem: virtual size out of range!");
+ vpm->virtual.start = save_vpm_start;
+ vpm->virtual.end = save_vpm_end;
+ vpm->virtual.size = save_vpm_size;
+ rmp = 0;
+ }
+ }
+ if (rmp)
+ {
+ bm->pktmbuf_pools[socket_id] = rmp;
+ vec_free (pool_name);
+ return 0;
+ }
}
+ vec_free (pool_name);
+
/* no usable pool for this socket, try to use pool from another one */
- for (i = 0; i < vec_len(bm->pktmbuf_pools); i++)
+ for (i = 0; i < vec_len (bm->pktmbuf_pools); i++)
{
- if(bm->pktmbuf_pools[i])
- {
- clib_warning("WARNING: Failed to allocate mempool for CPU socket %u. "
- "Threads running on socket %u will use socket %u mempool.",
- socket_id, socket_id, i);
- bm->pktmbuf_pools[socket_id] = bm->pktmbuf_pools[i];
- return 0;
- }
+ if (bm->pktmbuf_pools[i])
+ {
+ clib_warning
+ ("WARNING: Failed to allocate mempool for CPU socket %u. "
+ "Threads running on socket %u will use socket %u mempool.",
+ socket_id, socket_id, i);
+ bm->pktmbuf_pools[socket_id] = bm->pktmbuf_pools[i];
+ return 0;
+ }
}
return clib_error_return (0, "failed to allocate mempool on socket %u",
- socket_id);
+ socket_id);
}
-static void vlib_serialize_tx (serialize_main_header_t * m, serialize_stream_t * s)
+static void
+vlib_serialize_tx (serialize_main_header_t * m, serialize_stream_t * s)
{
- vlib_main_t * vm;
- vlib_serialize_buffer_main_t * sm;
+ vlib_main_t *vm;
+ vlib_serialize_buffer_main_t *sm;
uword n, n_bytes_to_write;
- vlib_buffer_t * last;
+ vlib_buffer_t *last;
n_bytes_to_write = s->current_buffer_index;
- sm = uword_to_pointer (s->data_function_opaque, vlib_serialize_buffer_main_t *);
+ sm =
+ uword_to_pointer (s->data_function_opaque,
+ vlib_serialize_buffer_main_t *);
vm = sm->vlib_main;
ASSERT (sm->tx.max_n_data_bytes_per_chain > 0);
if (serialize_stream_is_end_of_stream (s)
- || sm->tx.n_total_data_bytes + n_bytes_to_write > sm->tx.max_n_data_bytes_per_chain)
+ || sm->tx.n_total_data_bytes + n_bytes_to_write >
+ sm->tx.max_n_data_bytes_per_chain)
{
- vlib_process_t * p = vlib_get_current_process (vm);
+ vlib_process_t *p = vlib_get_current_process (vm);
last = vlib_get_buffer (vm, sm->last_buffer);
last->current_length = n_bytes_to_write;
- vlib_set_next_frame_buffer (vm, &p->node_runtime, sm->tx.next_index, sm->first_buffer);
+ vlib_set_next_frame_buffer (vm, &p->node_runtime, sm->tx.next_index,
+ sm->first_buffer);
sm->first_buffer = sm->last_buffer = ~0;
sm->tx.n_total_data_bytes = 0;
{
ASSERT (sm->first_buffer == ~0);
ASSERT (sm->last_buffer == ~0);
- n = vlib_buffer_alloc_from_free_list (vm, &sm->first_buffer, 1, sm->tx.free_list_index);
+ n =
+ vlib_buffer_alloc_from_free_list (vm, &sm->first_buffer, 1,
+ sm->tx.free_list_index);
if (n != 1)
- serialize_error (m, clib_error_create ("vlib_buffer_alloc_from_free_list fails"));
+ serialize_error (m,
+ clib_error_create
+ ("vlib_buffer_alloc_from_free_list fails"));
sm->last_buffer = sm->first_buffer;
- s->n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm, sm->tx.free_list_index);
+ s->n_buffer_bytes =
+ vlib_buffer_free_list_buffer_size (vm, sm->tx.free_list_index);
}
if (n_bytes_to_write > 0)
{
- vlib_buffer_t * prev = vlib_get_buffer (vm, sm->last_buffer);
- n = vlib_buffer_alloc_from_free_list (vm, &sm->last_buffer, 1, sm->tx.free_list_index);
+ vlib_buffer_t *prev = vlib_get_buffer (vm, sm->last_buffer);
+ n =
+ vlib_buffer_alloc_from_free_list (vm, &sm->last_buffer, 1,
+ sm->tx.free_list_index);
if (n != 1)
- serialize_error (m, clib_error_create ("vlib_buffer_alloc_from_free_list fails"));
+ serialize_error (m,
+ clib_error_create
+ ("vlib_buffer_alloc_from_free_list fails"));
sm->tx.n_total_data_bytes += n_bytes_to_write;
prev->current_length = n_bytes_to_write;
prev->next_buffer = sm->last_buffer;
}
}
-static void vlib_serialize_rx (serialize_main_header_t * m, serialize_stream_t * s)
+static void
+vlib_serialize_rx (serialize_main_header_t * m, serialize_stream_t * s)
{
- vlib_main_t * vm;
- vlib_serialize_buffer_main_t * sm;
- vlib_buffer_t * last;
+ vlib_main_t *vm;
+ vlib_serialize_buffer_main_t *sm;
+ vlib_buffer_t *last;
- sm = uword_to_pointer (s->data_function_opaque, vlib_serialize_buffer_main_t *);
+ sm =
+ uword_to_pointer (s->data_function_opaque,
+ vlib_serialize_buffer_main_t *);
vm = sm->vlib_main;
if (serialize_stream_is_end_of_stream (s))
{
while (clib_fifo_elts (sm->rx.buffer_fifo) == 0)
{
- sm->rx.ready_one_time_event = vlib_process_create_one_time_event (vm, vlib_current_process (vm), ~0);
- vlib_process_wait_for_one_time_event (vm, /* no event data */ 0, sm->rx.ready_one_time_event);
+ sm->rx.ready_one_time_event =
+ vlib_process_create_one_time_event (vm, vlib_current_process (vm),
+ ~0);
+ vlib_process_wait_for_one_time_event (vm, /* no event data */ 0,
+ sm->rx.ready_one_time_event);
}
clib_fifo_sub1 (sm->rx.buffer_fifo, sm->first_buffer);
static void
serialize_open_vlib_helper (serialize_main_t * m,
vlib_main_t * vm,
- vlib_serialize_buffer_main_t * sm,
- uword is_read)
+ vlib_serialize_buffer_main_t * sm, uword is_read)
{
/* Initialize serialize main but save overflow buffer for re-use between calls. */
{
- u8 * save = m->stream.overflow_buffer;
+ u8 *save = m->stream.overflow_buffer;
memset (m, 0, sizeof (m[0]));
m->stream.overflow_buffer = save;
if (save)
m->stream.data_function_opaque = pointer_to_uword (sm);
}
-void serialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm, vlib_serialize_buffer_main_t * sm)
-{ serialize_open_vlib_helper (m, vm, sm, /* is_read */ 0); }
+void
+serialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm,
+ vlib_serialize_buffer_main_t * sm)
+{
+ serialize_open_vlib_helper (m, vm, sm, /* is_read */ 0);
+}
-void unserialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm, vlib_serialize_buffer_main_t * sm)
-{ serialize_open_vlib_helper (m, vm, sm, /* is_read */ 1); }
+void
+unserialize_open_vlib_buffer (serialize_main_t * m, vlib_main_t * vm,
+ vlib_serialize_buffer_main_t * sm)
+{
+ serialize_open_vlib_helper (m, vm, sm, /* is_read */ 1);
+}
-u32 serialize_close_vlib_buffer (serialize_main_t * m)
+u32
+serialize_close_vlib_buffer (serialize_main_t * m)
{
- vlib_serialize_buffer_main_t * sm
- = uword_to_pointer (m->stream.data_function_opaque, vlib_serialize_buffer_main_t *);
- vlib_buffer_t * last;
- serialize_stream_t * s = &m->stream;
+ vlib_serialize_buffer_main_t *sm
+ = uword_to_pointer (m->stream.data_function_opaque,
+ vlib_serialize_buffer_main_t *);
+ vlib_buffer_t *last;
+ serialize_stream_t *s = &m->stream;
last = vlib_get_buffer (sm->vlib_main, sm->last_buffer);
last->current_length = s->current_buffer_index;
return sm->first_buffer;
}
-void unserialize_close_vlib_buffer (serialize_main_t * m)
+void
+unserialize_close_vlib_buffer (serialize_main_t * m)
{
- vlib_serialize_buffer_main_t * sm
- = uword_to_pointer (m->stream.data_function_opaque, vlib_serialize_buffer_main_t *);
+ vlib_serialize_buffer_main_t *sm
+ = uword_to_pointer (m->stream.data_function_opaque,
+ vlib_serialize_buffer_main_t *);
if (sm->first_buffer != ~0)
vlib_buffer_free_one (sm->vlib_main, sm->first_buffer);
clib_fifo_reset (sm->rx.buffer_fifo);
_vec_len (m->stream.overflow_buffer) = 0;
}
-static u8 * format_vlib_buffer_free_list (u8 * s, va_list * va)
+static u8 *
+format_vlib_buffer_free_list (u8 * s, va_list * va)
{
- vlib_buffer_free_list_t * f = va_arg (*va, vlib_buffer_free_list_t *);
- u32 threadnum= va_arg (*va, u32);
+ vlib_buffer_free_list_t *f = va_arg (*va, vlib_buffer_free_list_t *);
+ u32 threadnum = va_arg (*va, u32);
uword bytes_alloc, bytes_free, n_free, size;
- if (! f)
+ if (!f)
return format (s, "%=7s%=30s%=12s%=12s%=12s%=12s%=12s%=12s",
- "Thread", "Name", "Index", "Size", "Alloc", "Free", "#Alloc", "#Free");
+ "Thread", "Name", "Index", "Size", "Alloc", "Free",
+ "#Alloc", "#Free");
size = sizeof (vlib_buffer_t) + f->n_data_bytes;
n_free = vec_len (f->aligned_buffers) + vec_len (f->unaligned_buffers);
bytes_free = size * n_free;
s = format (s, "%7d%30s%12d%12d%=12U%=12U%=12d%=12d",
- threadnum,
+ threadnum,
f->name, f->index, f->n_data_bytes,
format_memory_size, bytes_alloc,
- format_memory_size, bytes_free,
- f->n_alloc, n_free);
+ format_memory_size, bytes_free, f->n_alloc, n_free);
return s;
}
static clib_error_t *
show_buffers (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- vlib_buffer_main_t * bm;
- vlib_buffer_free_list_t * f;
+ vlib_buffer_main_t *bm;
+ vlib_buffer_free_list_t *f;
vlib_main_t *curr_vm;
u32 vm_index = 0;
vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, 0, 0);
- do {
- curr_vm = vec_len(vlib_mains) ? vlib_mains[vm_index] : vm;
- bm = curr_vm->buffer_main;
-
+ do
+ {
+ curr_vm = vec_len (vlib_mains) ? vlib_mains[vm_index] : vm;
+ bm = curr_vm->buffer_main;
+
+ /* *INDENT-OFF* */
pool_foreach (f, bm->buffer_free_list_pool, ({
vlib_cli_output (vm, "%U", format_vlib_buffer_free_list, f, vm_index);
}));
+ /* *INDENT-ON* */
- vm_index++;
- } while (vm_index < vec_len(vlib_mains));
+ vm_index++;
+ }
+ while (vm_index < vec_len (vlib_mains));
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_buffers_command, static) = {
.path = "show buffers",
.short_help = "Show packet buffer allocation",
.function = show_buffers,
};
+/* *INDENT-ON* */
#if CLIB_DEBUG > 0
-u32 * vlib_buffer_state_validation_lock;
-uword * vlib_buffer_state_validation_hash;
-void * vlib_buffer_state_heap;
+u32 *vlib_buffer_state_validation_lock;
+uword *vlib_buffer_state_validation_hash;
+void *vlib_buffer_state_heap;
-static clib_error_t *
+static clib_error_t *
buffer_state_validation_init (vlib_main_t * vm)
{
- void * oldheap;
+ void *oldheap;
- vlib_buffer_state_heap = mheap_alloc (0, 10<<20);
+ vlib_buffer_state_heap = mheap_alloc (0, 10 << 20);
oldheap = clib_mem_set_heap (vlib_buffer_state_heap);
- vlib_buffer_state_validation_hash = hash_create (0, sizeof(uword));
- vec_validate_aligned (vlib_buffer_state_validation_lock, 0,
- CLIB_CACHE_LINE_BYTES);
+ vlib_buffer_state_validation_hash = hash_create (0, sizeof (uword));
+ vec_validate_aligned (vlib_buffer_state_validation_lock, 0,
+ CLIB_CACHE_LINE_BYTES);
clib_mem_set_heap (oldheap);
return 0;
}
VLIB_INIT_FUNCTION (buffer_state_validation_init);
#endif
+
+/** @endcond */
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
Code Review / vpp.git / blobdiff