* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+ /*
+ * To be honest, the packet generator needs an extreme
+ * makeover. Two key assumptions which drove the current implementation
+ * are no longer true. First, buffer managers implement a
+ * post-TX recycle list. Second, that packet generator performance
+ * is first-order important.
+ */
+
#include <vlib/vlib.h>
#include <vnet/pg/pg.h>
#include <vnet/vnet.h>
+#include <vnet/ethernet/ethernet.h>
#include <vnet/feature/feature.h>
#include <vnet/devices/devices.h>
}
}
-static_always_inline void
-init_replay_buffers_inline (vlib_main_t * vm,
- pg_stream_t * s,
- u32 * buffers,
- u32 n_buffers, u32 data_offset, u32 n_data)
-{
- u32 n_left, *b, i, l;
-
- n_left = n_buffers;
- b = buffers;
- i = s->current_replay_packet_index;
- l = vec_len (s->replay_packet_templates);
-
- while (n_left >= 1)
- {
- u32 bi0, n0;
- vlib_buffer_t *b0;
- u8 *d0;
-
- bi0 = b[0];
- b += 1;
- n_left -= 1;
-
- b0 = vlib_get_buffer (vm, bi0);
-
- vnet_buffer (b0)->sw_if_index[VLIB_RX] = s->sw_if_index[VLIB_RX];
- /* was s->sw_if_index[VLIB_TX]; */
- vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
-
- d0 = vec_elt (s->replay_packet_templates, i);
- vnet_buffer2 (b0)->pg_replay_timestamp = s->replay_packet_timestamps[i];
-
- n0 = n_data;
- if (data_offset + n_data >= vec_len (d0))
- n0 = vec_len (d0) > data_offset ? vec_len (d0) - data_offset : 0;
-
- b0->current_length = n0;
-
- clib_memcpy (b0->data, d0 + data_offset, n0);
- i = i + 1 == l ? 0 : i + 1;
- }
-}
-
static_always_inline void
init_buffers_inline (vlib_main_t * vm,
pg_stream_t * s,
u32 n_left, *b;
u8 *data, *mask;
- if (vec_len (s->replay_packet_templates) > 0)
- return init_replay_buffers_inline (vm, s, buffers, n_buffers, data_offset,
- n_data);
+ ASSERT (s->replay_packet_templates == 0);
data = s->fixed_packet_data + data_offset;
mask = s->fixed_packet_data_mask + data_offset;
if (set_data)
{
- clib_memcpy (b0->data, data, n_data);
- clib_memcpy (b1->data, data, n_data);
+ clib_memcpy_fast (b0->data, data, n_data);
+ clib_memcpy_fast (b1->data, data, n_data);
}
else
{
vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
if (set_data)
- clib_memcpy (b0->data, data, n_data);
+ clib_memcpy_fast (b0->data, data, n_data);
else
ASSERT (validate_buffer_data2 (b0, s, data_offset, n_data));
}
uword is_start_of_packet = bi == s->buffer_indices;
u32 n_allocated;
- n_allocated = vlib_buffer_alloc_from_free_list (vm,
- buffers,
- n_alloc,
- bi->free_list_index);
+ ASSERT (vec_len (s->replay_packet_templates) == 0);
+
+ n_allocated = vlib_buffer_alloc (vm, buffers, n_alloc);
if (n_allocated == 0)
return 0;
if (is_start_of_packet)
{
- if (vec_len (s->replay_packet_templates) > 0)
+ pg_generate_set_lengths (pg, s, buffers, n_alloc);
+ if (vec_len (s->buffer_indices) > 1)
+ pg_generate_fix_multi_buffer_lengths (pg, s, buffers, n_alloc);
+
+ pg_generate_edit (pg, s, buffers, n_alloc);
+ }
+
+ return n_alloc;
+}
+
+static u32
+pg_stream_fill_replay (pg_main_t * pg, pg_stream_t * s, u32 n_alloc)
+{
+ pg_buffer_index_t *bi;
+ u32 n_left, i, l;
+ u32 buffer_alloc_request = 0;
+ u32 buffer_alloc_result;
+ u32 current_buffer_index;
+ u32 *buffers;
+ vlib_main_t *vm = vlib_get_main ();
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *im = &vnm->interface_main;
+ vnet_sw_interface_t *si;
+
+ buffers = pg->replay_buffers_by_thread[vm->thread_index];
+ vec_reset_length (buffers);
+ bi = s->buffer_indices;
+
+ n_left = n_alloc;
+ i = s->current_replay_packet_index;
+ l = vec_len (s->replay_packet_templates);
+
+ /* Figure out how many buffers we need */
+ while (n_left > 0)
+ {
+ u8 *d0;
+
+ d0 = vec_elt (s->replay_packet_templates, i);
+ buffer_alloc_request += (vec_len (d0) + (VLIB_BUFFER_DATA_SIZE - 1))
+ / VLIB_BUFFER_DATA_SIZE;
+
+ i = ((i + 1) == l) ? 0 : i + 1;
+ n_left--;
+ }
+
+ ASSERT (buffer_alloc_request > 0);
+ vec_validate (buffers, buffer_alloc_request - 1);
+
+ /* Allocate that many buffers */
+ buffer_alloc_result = vlib_buffer_alloc (vm, buffers, buffer_alloc_request);
+ if (buffer_alloc_result < buffer_alloc_request)
+ {
+ clib_warning ("alloc failure, got %d not %d", buffer_alloc_result,
+ buffer_alloc_request);
+ vlib_buffer_free_no_next (vm, buffers, buffer_alloc_result);
+ pg->replay_buffers_by_thread[vm->thread_index] = buffers;
+ return 0;
+ }
+
+ /* Now go generate the buffers, and add them to the FIFO */
+ n_left = n_alloc;
+
+ current_buffer_index = 0;
+ i = s->current_replay_packet_index;
+ l = vec_len (s->replay_packet_templates);
+ while (n_left > 0)
+ {
+ u8 *d0;
+ int not_last;
+ u32 data_offset;
+ u32 bytes_to_copy, bytes_this_chunk;
+ vlib_buffer_t *b;
+
+ d0 = vec_elt (s->replay_packet_templates, i);
+ data_offset = 0;
+ bytes_to_copy = vec_len (d0);
+
+ /* Add head chunk to pg fifo */
+ clib_fifo_add1 (bi->buffer_fifo, buffers[current_buffer_index]);
+
+ /* Copy the data */
+ while (bytes_to_copy)
{
- vnet_main_t *vnm = vnet_get_main ();
- vnet_interface_main_t *im = &vnm->interface_main;
- vnet_sw_interface_t *si =
- vnet_get_sw_interface (vnm, s->sw_if_index[VLIB_RX]);
- u32 l = 0;
- u32 i;
- for (i = 0; i < n_alloc; i++)
- l += vlib_buffer_index_length_in_chain (vm, buffers[i]);
- vlib_increment_combined_counter (im->combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- vlib_get_thread_index (),
- si->sw_if_index, n_alloc, l);
- s->current_replay_packet_index += n_alloc;
- s->current_replay_packet_index %=
- vec_len (s->replay_packet_templates);
+ bytes_this_chunk = clib_min (bytes_to_copy, VLIB_BUFFER_DATA_SIZE);
+ ASSERT (current_buffer_index < vec_len (buffers));
+ b = vlib_get_buffer (vm, buffers[current_buffer_index]);
+ clib_memcpy_fast (b->data, d0 + data_offset, bytes_this_chunk);
+ vnet_buffer (b)->sw_if_index[VLIB_RX] = s->sw_if_index[VLIB_RX];
+ vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32) ~ 0;
+ b->flags = 0;
+ b->next_buffer = 0;
+ b->current_data = 0;
+ b->current_length = bytes_this_chunk;
+
+ not_last = bytes_this_chunk < bytes_to_copy;
+ if (not_last)
+ {
+ ASSERT (current_buffer_index < (vec_len (buffers) - 1));
+ b->flags |= VLIB_BUFFER_NEXT_PRESENT;
+ b->next_buffer = buffers[current_buffer_index + 1];
+ }
+ bytes_to_copy -= bytes_this_chunk;
+ data_offset += bytes_this_chunk;
+ current_buffer_index++;
}
- else
- {
- pg_generate_set_lengths (pg, s, buffers, n_alloc);
- if (vec_len (s->buffer_indices) > 1)
- pg_generate_fix_multi_buffer_lengths (pg, s, buffers, n_alloc);
- pg_generate_edit (pg, s, buffers, n_alloc);
- }
+ i = ((i + 1) == l) ? 0 : i + 1;
+ n_left--;
}
+ /* Update the interface counters */
+ si = vnet_get_sw_interface (vnm, s->sw_if_index[VLIB_RX]);
+ l = 0;
+ for (i = 0; i < n_alloc; i++)
+ l += vlib_buffer_index_length_in_chain (vm, buffers[i]);
+ vlib_increment_combined_counter (im->combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ vlib_get_thread_index (),
+ si->sw_if_index, n_alloc, l);
+
+ s->current_replay_packet_index += n_alloc;
+ s->current_replay_packet_index %= vec_len (s->replay_packet_templates);
+
+ pg->replay_buffers_by_thread[vm->thread_index] = buffers;
return n_alloc;
}
+
static u32
pg_stream_fill (pg_main_t * pg, pg_stream_t * s, u32 n_buffers)
{
n_alloc = 0;
}
+ /*
+ * Handle pcap replay directly
+ */
+ if (s->replay_packet_templates)
+ return pg_stream_fill_replay (pg, s, n_alloc);
+
/* All buffer fifos should have the same size. */
if (CLIB_DEBUG > 0)
{
t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
t1->sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_RX];
- clib_memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data));
- clib_memcpy (&t1->buffer, b1, sizeof (b1[0]) - sizeof (b1->pre_data));
+ clib_memcpy_fast (&t0->buffer, b0,
+ sizeof (b0[0]) - sizeof (b0->pre_data));
+ clib_memcpy_fast (&t1->buffer, b1,
+ sizeof (b1[0]) - sizeof (b1->pre_data));
- clib_memcpy (t0->buffer.pre_data, b0->data,
- sizeof (t0->buffer.pre_data));
- clib_memcpy (t1->buffer.pre_data, b1->data,
- sizeof (t1->buffer.pre_data));
+ clib_memcpy_fast (t0->buffer.pre_data, b0->data,
+ sizeof (t0->buffer.pre_data));
+ clib_memcpy_fast (t1->buffer.pre_data, b1->data,
+ sizeof (t1->buffer.pre_data));
}
while (n_left >= 1)
t0->stream_index = stream_index;
t0->packet_length = vlib_buffer_length_in_chain (vm, b0);
t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
- clib_memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data));
- clib_memcpy (t0->buffer.pre_data, b0->data,
- sizeof (t0->buffer.pre_data));
+ clib_memcpy_fast (&t0->buffer, b0,
+ sizeof (b0[0]) - sizeof (b0->pre_data));
+ clib_memcpy_fast (t0->buffer.pre_data, b0->data,
+ sizeof (t0->buffer.pre_data));
}
}
{
u32 *head, *start, *end;
- vlib_get_next_frame (vm, node, next_index, to_next, n_left);
+ if (PREDICT_TRUE (next_index == VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT))
+ {
+ vlib_next_frame_t *nf;
+ vlib_frame_t *f;
+ ethernet_input_frame_t *ef;
+ pg_interface_t *pi;
+ vlib_get_new_next_frame (vm, node, next_index, to_next, n_left);
+ nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
+ f = vlib_get_frame (vm, nf->frame_index);
+ f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
+
+ ef = vlib_frame_scalar_args (f);
+ pi = pool_elt_at_index (pg->interfaces, s->pg_if_index);
+ ef->sw_if_index = pi->sw_if_index;
+ ef->hw_if_index = pi->hw_if_index;
+ }
+ else
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left);
n_this_frame = n_packets_to_generate;
if (n_this_frame > n_left)
head = clib_fifo_head (bi0->buffer_fifo);
if (head + n_this_frame <= end)
- vlib_copy_buffers (to_next, head, n_this_frame);
+ clib_memcpy_fast (to_next, head, n_this_frame * sizeof (u32));
else
{
u32 n = end - head;
- vlib_copy_buffers (to_next + 0, head, n);
- vlib_copy_buffers (to_next + n, start, n_this_frame - n);
+ clib_memcpy_fast (to_next + 0, head, n * sizeof (u32));
+ clib_memcpy_fast (to_next + n, start,
+ (n_this_frame - n) * sizeof (u32));
}
- vec_foreach (bi, s->buffer_indices)
- clib_fifo_advance_head (bi->buffer_fifo, n_this_frame);
+ if (s->replay_packet_templates == 0)
+ {
+ vec_foreach (bi, s->buffer_indices)
+ clib_fifo_advance_head (bi->buffer_fifo, n_this_frame);
+ }
+ else
+ {
+ clib_fifo_advance_head (bi0->buffer_fifo, n_this_frame);
+ }
if (current_config_index != ~(u32) 0)
for (i = 0; i < n_this_frame; i++)
{
vlib_buffer_t *b;
b = vlib_get_buffer (vm, to_next[i]);
- vnet_buffer (b)->device_input_feat.saved_next_index =
- s->next_index;
- vnet_buffer (b)->device_input_feat.buffer_advance = 0;
b->current_config_index = current_config_index;
vnet_buffer (b)->feature_arc_index = feature_arc_index;
}
n_packets_to_generate -= n_this_frame;
n_packets_generated += n_this_frame;
n_left -= n_this_frame;
+ if (CLIB_DEBUG > 0)
+ {
+ int i;
+ vlib_buffer_t *b;
+
+ for (i = 0; i < VLIB_FRAME_SIZE - n_left; i++)
+ {
+ b = vlib_get_buffer (vm, to_next[i]);
+ ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0 ||
+ b->current_length >= VLIB_BUFFER_MIN_CHAIN_SEG_SIZE);
+ }
+ }
vlib_put_next_frame (vm, node, next_index, n_left);
}
Code Review / vpp.git / blobdiff