diff options
author | Ed Warnicke <eaw@cisco.com> | 2015-12-08 15:45:58 -0700 |
---|---|---|
committer | Ed Warnicke <eaw@cisco.com> | 2015-12-08 15:47:27 -0700 |
commit | cb9cadad578297ffd78fa8a33670bdf1ab669e7e (patch) | |
tree | 6ac2be912482cc7849a26f0ab845561c3d7f4e26 /vnet/vnet/pg | |
parent | fb0815d4ae4bb0fe27bd9313f34b45c8593b907e (diff) |
Initial commit of vpp code.v1.0.0
Change-Id: Ib246f1fbfce93274020ee93ce461e3d8bd8b9f17
Signed-off-by: Ed Warnicke <eaw@cisco.com>
Diffstat (limited to 'vnet/vnet/pg')
-rw-r--r-- | vnet/vnet/pg/cli.c | 438 | ||||
-rw-r--r-- | vnet/vnet/pg/edit.c | 179 | ||||
-rw-r--r-- | vnet/vnet/pg/edit.h | 198 | ||||
-rw-r--r-- | vnet/vnet/pg/example.script | 6 | ||||
-rw-r--r-- | vnet/vnet/pg/init.c | 78 | ||||
-rw-r--r-- | vnet/vnet/pg/input.c | 1745 | ||||
-rw-r--r-- | vnet/vnet/pg/output.c | 52 | ||||
-rw-r--r-- | vnet/vnet/pg/pg.h | 347 | ||||
-rw-r--r-- | vnet/vnet/pg/stream.c | 420 |
9 files changed, 3463 insertions, 0 deletions
diff --git a/vnet/vnet/pg/cli.c b/vnet/vnet/pg/cli.c new file mode 100644 index 00000000000..495eac2d0b1 --- /dev/null +++ b/vnet/vnet/pg/cli.c @@ -0,0 +1,438 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_cli.c: packet generator cli + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> + +#ifdef CLIB_UNIX +#include <vnet/unix/pcap.h> +#endif + +/* Root of all packet generator cli commands. */ +VLIB_CLI_COMMAND (vlib_cli_pg_command, static) = { + .path = "packet-generator", + .short_help = "Packet generator commands", +}; + +static clib_error_t * +enable_disable_stream (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + pg_main_t * pg = &pg_main; + pg_stream_t * s; + int is_enable = cmd->function_arg != 0; + u32 stream_index = ~0; + + if (unformat (input, "%U", unformat_eof)) + ; + else if (unformat (input, "%U", unformat_hash_vec_string, + pg->stream_index_by_name, &stream_index)) + ; + else + return clib_error_create ("unknown input `%U'", + format_unformat_error, input); + + /* No stream specified: enable/disable all streams. */ + if (stream_index == ~0) + pool_foreach (s, pg->streams, ({ + pg_stream_enable_disable (pg, s, is_enable); + })); + else + { + /* enable/disable specified stream. */ + s = pool_elt_at_index (pg->streams, stream_index); + pg_stream_enable_disable (pg, s, is_enable); + } + + return 0; +} + +VLIB_CLI_COMMAND (enable_streams_cli, static) = { + .path = "packet-generator enable-stream", + .short_help = "Enable packet generator streams", + .function = enable_disable_stream, + .function_arg = 1, /* is_enable */ +}; + +VLIB_CLI_COMMAND (disable_streams_cli, static) = { + .path = "packet-generator disable-stream", + .short_help = "Disable packet generator streams", + .function = enable_disable_stream, + .function_arg = 0, /* is_enable */ +}; + +static u8 * format_pg_stream (u8 * s, va_list * va) +{ + pg_stream_t * t = va_arg (*va, pg_stream_t *); + u8 * v; + + if (! t) + return format (s, "%=16s%=12s%=16s%s", + "Name", "Enabled", "Count", "Parameters"); + + s = format (s, "%-16v%=12s%16Ld", + t->name, + pg_stream_is_enabled (t) ? "Yes" : "No", + t->n_packets_generated); + + v = 0; + + v = format (v, "limit %Ld, ", t->n_packets_limit); + + v = format (v, "rate %.2e pps, ", t->rate_packets_per_second); + + v = format (v, "size %d%c%d, ", + t->min_packet_bytes, + t->packet_size_edit_type == PG_EDIT_RANDOM ? '+' : '-', + t->max_packet_bytes); + + v = format (v, "buffer-size %d, ", t->buffer_bytes); + + if (v) + { + s = format (s, " %v", v); + vec_free (v); + } + + return s; +} + +static clib_error_t * +show_streams (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + pg_main_t * pg = &pg_main; + pg_stream_t * s; + + if (pool_elts (pg->streams) == 0) + { + vlib_cli_output (vm, "no streams currently defined"); + goto done; + } + + vlib_cli_output (vm, "%U", format_pg_stream, 0); + pool_foreach (s, pg->streams, ({ + vlib_cli_output (vm, "%U", format_pg_stream, s); + })); + + done: + return 0; +} + +VLIB_CLI_COMMAND (show_streams_cli, static) = { + .path = "show packet-generator", + .short_help = "Show packet generator streams", + .function = show_streams, +}; + +static clib_error_t * +pg_pcap_read (pg_stream_t * s, char * file_name) +{ +#ifndef CLIB_UNIX + return clib_error_return (0, "no pcap support"); +#else + pcap_main_t pm; + clib_error_t * error; + memset (&pm, 0, sizeof (pm)); + pm.file_name = file_name; + error = pcap_read (&pm); + s->replay_packet_templates = pm.packets_read; + s->min_packet_bytes = pm.min_packet_bytes; + s->max_packet_bytes = pm.max_packet_bytes; + s->buffer_bytes = pm.max_packet_bytes; + /* For PCAP buffers we never re-use buffers. */ + s->flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE; + return error; +#endif /* CLIB_UNIX */ +} + +static uword +unformat_pg_stream_parameter (unformat_input_t * input, va_list * args) +{ + pg_stream_t * s = va_arg (*args, pg_stream_t *); + f64 x; + + if (unformat (input, "limit %f", &x)) + s->n_packets_limit = x; + + else if (unformat (input, "rate %f", &x)) + s->rate_packets_per_second = x; + + else if (unformat (input, "size %d-%d", &s->min_packet_bytes, + &s->max_packet_bytes)) + s->packet_size_edit_type = PG_EDIT_INCREMENT; + + else if (unformat (input, "size %d+%d", &s->min_packet_bytes, + &s->max_packet_bytes)) + s->packet_size_edit_type = PG_EDIT_RANDOM; + + else if (unformat (input, "buffer-size %d", &s->buffer_bytes)) + ; + + else + return 0; + + return 1; +} + +static clib_error_t * +validate_stream (pg_stream_t * s) +{ + if (s->max_packet_bytes < s->min_packet_bytes) + return clib_error_create ("max-size < min-size"); + + if (s->buffer_bytes >= 4096 || s->buffer_bytes == 0) + return clib_error_create ("buffer-size must be positive and < 4096, given %d", + s->buffer_bytes); + + if (s->rate_packets_per_second < 0) + return clib_error_create ("negative rate"); + + return 0; +} + +static clib_error_t * +new_stream (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + clib_error_t * error = 0; + u8 * tmp = 0; + u32 hw_if_index; + unformat_input_t sub_input = {0}; + int sub_input_given = 0; + vnet_main_t * vnm = vnet_get_main(); + pg_main_t * pg = &pg_main; + pg_stream_t s = {0}; + char * pcap_file_name; + + s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0; + s.node_index = ~0; + s.max_packet_bytes = s.min_packet_bytes = 64; + s.buffer_bytes = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES; + pcap_file_name = 0; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "name %v", &tmp)) + { + if (s.name) + vec_free (s.name); + s.name = tmp; + } + + else if (unformat (input, "node %U", + unformat_vnet_hw_interface, vnm, &hw_if_index)) + { + vnet_hw_interface_t * hi = vnet_get_hw_interface (vnm, hw_if_index); + + s.node_index = hi->output_node_index; + s.sw_if_index[VLIB_TX] = hi->sw_if_index; + } + + else if (unformat (input, "node %U", + unformat_vlib_node, vm, &s.node_index)) + ; + + else if (unformat (input, "interface %U", + unformat_vnet_sw_interface, vnm, &s.sw_if_index[VLIB_RX])) + ; + + else if (unformat (input, "pcap %s", &pcap_file_name)) + ; + + else if (! sub_input_given + && unformat (input, "data %U", unformat_input, &sub_input)) + sub_input_given++; + + else if (unformat_user (input, unformat_pg_stream_parameter, &s)) + ; + + else if (unformat (input, "no-recycle")) + s.flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE; + + else + { + error = clib_error_create ("unknown input `%U'", + format_unformat_error, input); + goto done; + } + } + + error = validate_stream (&s); + if (error) + return error; + + if (! sub_input_given && ! pcap_file_name) + { + error = clib_error_create ("no packet data given"); + goto done; + } + + if (s.node_index == ~0) + { + error = clib_error_create ("output interface or node not given"); + goto done; + } + + { + pg_node_t * n; + + if (s.node_index < vec_len (pg->nodes)) + n = pg->nodes + s.node_index; + else + n = 0; + + if (pcap_file_name != 0) + { + error = pg_pcap_read (&s, pcap_file_name); + if (error) + goto done; + vec_free (pcap_file_name); + } + + else if (n && n->unformat_edit + && unformat_user (&sub_input, n->unformat_edit, &s)) + ; + + else if (! unformat_user (&sub_input, unformat_pg_payload, &s)) + { + error = clib_error_create + ("failed to parse packet data from `%U'", + format_unformat_error, &sub_input); + goto done; + } + } + + pg_stream_add (pg, &s); + return 0; + + done: + pg_stream_free (&s); + unformat_free (&sub_input); + return error; +} + +VLIB_CLI_COMMAND (new_stream_cli, static) = { + .path = "packet-generator new", + .function = new_stream, + .short_help = "Create packet generator stream", + .long_help = + "Create packet generator stream\n" + "\n" + "Arguments:\n" + "\n" + "name STRING sets stream name\n" + "interface STRING interface for stream output \n" + "node NODE-NAME node for stream output\n" + "data STRING specifies packet data\n", +}; + +static clib_error_t * +del_stream (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + pg_main_t * pg = &pg_main; + u32 i; + + if (! unformat (input, "%U", + &unformat_hash_vec_string, pg->stream_index_by_name, &i)) + return clib_error_create ("expected stream name `%U'", + format_unformat_error, input); + + pg_stream_del (pg, i); + return 0; +} + +VLIB_CLI_COMMAND (del_stream_cli, static) = { + .path = "packet-generator delete", + .function = del_stream, + .short_help = "Delete stream with given name", +}; + +static clib_error_t * +change_stream_parameters (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + pg_main_t * pg = &pg_main; + pg_stream_t * s, s_new; + u32 stream_index = ~0; + clib_error_t * error; + + if (unformat (input, "%U", unformat_hash_vec_string, + pg->stream_index_by_name, &stream_index)) + ; + else + return clib_error_create ("expecting stream name; got `%U'", + format_unformat_error, input); + + s = pool_elt_at_index (pg->streams, stream_index); + s_new = s[0]; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat_user (input, unformat_pg_stream_parameter, &s_new)) + ; + + else + return clib_error_create ("unknown input `%U'", + format_unformat_error, input); + } + + error = validate_stream (&s_new); + if (! error) + s[0] = s_new; + + return error; +} + +VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = { + .path = "packet-generator configure", + .short_help = "Change packet generator stream parameters", + .function = change_stream_parameters, +}; + +/* Dummy init function so that we can be linked in. */ +static clib_error_t * pg_cli_init (vlib_main_t * vm) +{ return 0; } + +VLIB_INIT_FUNCTION (pg_cli_init); diff --git a/vnet/vnet/pg/edit.c b/vnet/vnet/pg/edit.c new file mode 100644 index 00000000000..9c49cef8903 --- /dev/null +++ b/vnet/vnet/pg/edit.c @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_edit.c: packet generator edits + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/pg/pg.h> + +static void +pg_edit_set_value_helper (pg_edit_t * e, u64 value, u8 * result) +{ + int i, j, n_bits_left; + u8 * v, tmp[8]; + + v = tmp; + + n_bits_left = e->n_bits; + i = 0; + j = e->lsb_bit_offset % BITS (v[0]); + + if (n_bits_left > 0 && j != 0) + { + v[i] = (value & 0xff) << j; + value >>= BITS (v[0]) - j; + n_bits_left -= BITS (v[0]) - j; + i += 1; + } + + while (n_bits_left > 0) + { + v[i] = value & 0xff; + value >>= 8; + n_bits_left -= 8; + i += 1; + } + + /* Convert to network byte order. */ + for (j = 0; j < i; j++) + result[j] = v[i - 1 - j]; +} + +void +pg_edit_set_value (pg_edit_t * e, int hi_or_lo, u64 value) +{ + pg_edit_alloc_value (e, hi_or_lo); + pg_edit_set_value_helper (e, value, e->values[hi_or_lo]); +} + +/* Parse an int either %d or 0x%x into network byte order. */ +uword unformat_pg_number (unformat_input_t * input, va_list * args) +{ + u8 * result = va_arg (*args, u8 *); + pg_edit_t * e = va_arg (*args, pg_edit_t *); + u64 value; + + ASSERT (BITS (value) >= e->n_bits); + + if (! unformat (input, "0x%X", sizeof (value), &value) + && ! unformat (input, "%D", sizeof (value), &value)) + return 0; + + /* Number given does not fit into bit field. */ + if (e->n_bits < 64 + && value >= (u64) 1 << (u64) e->n_bits) + return 0; + + pg_edit_set_value_helper (e, value, result); + return 1; +} + +uword +unformat_pg_edit (unformat_input_t * input, va_list * args) +{ + unformat_function_t * f = va_arg (*args, unformat_function_t *); + pg_edit_t * e = va_arg (*args, pg_edit_t *); + + pg_edit_alloc_value (e, PG_EDIT_LO); + if (! unformat_user (input, f, e->values[PG_EDIT_LO], e)) + return 0; + + pg_edit_alloc_value (e, PG_EDIT_HI); + if (unformat (input, "-%U", f, e->values[PG_EDIT_HI], e)) + e->type = PG_EDIT_INCREMENT; + else if (unformat (input, "+%U", f, e->values[PG_EDIT_HI], e)) + e->type = PG_EDIT_RANDOM; + else + e->type = PG_EDIT_FIXED; + + return 1; +} + +uword +unformat_pg_payload (unformat_input_t * input, va_list * args) +{ + pg_stream_t * s = va_arg (*args, pg_stream_t *); + pg_main_t * pg = &pg_main; + vlib_main_t * vm = pg->vlib_main; + pg_edit_t * e; + u32 i, node_index, len, max_len; + u8 * v; + + v = 0; + + if (unformat (input, "incrementing %d", &len)) + { + vec_resize (v, len); + for (i = 0; i < len; i++) + v[i] = i; + } + else if (unformat (input, "hex 0x%U", unformat_hex_string, &v)) + ; + + else if (unformat (input, "%U", unformat_vlib_node, vm, &node_index)) + { + pg_node_t * pn = pg_get_node (node_index); + if (! pn->unformat_edit) + return 0; + return unformat (input, "%U", pn->unformat_edit, s); + } + + else + return 0; + + /* Length not including this payload. */ + max_len = pg_edit_group_n_bytes (s, 0); + if (max_len + vec_len (v) >= s->max_packet_bytes) + { + if (s->max_packet_bytes >= max_len) + _vec_len (v) = s->max_packet_bytes - max_len; + else + _vec_len (v) = 0; + } + + e = pg_create_edit_group (s, sizeof (e[0]), vec_len (v), 0); + + e->type = PG_EDIT_FIXED; + e->n_bits = vec_len (v) * BITS (v[0]); + + /* Least significant bit is at end of bitstream, since everything is always bigendian. */ + e->lsb_bit_offset = e->n_bits - BITS (v[0]); + + e->values[PG_EDIT_LO] = v; + + return 1; +} diff --git a/vnet/vnet/pg/edit.h b/vnet/vnet/pg/edit.h new file mode 100644 index 00000000000..07c14a2a203 --- /dev/null +++ b/vnet/vnet/pg/edit.h @@ -0,0 +1,198 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_edit.h: packet generator edits + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef included_packet_generator_pg_edit_h +#define included_packet_generator_pg_edit_h + +#include <vppinfra/format.h> +#include <vppinfra/vec.h> + +typedef enum { + /* Invalid type used to poison edits. */ + PG_EDIT_INVALID_TYPE, + + /* Value is fixed: does not change for all packets in sequence. */ + PG_EDIT_FIXED, + + /* Value v increments between low and high values v_low <= v <= v_high. */ + PG_EDIT_INCREMENT, + + /* Random value between low and high values v_low <= v <= v_high. */ + PG_EDIT_RANDOM, + + /* Unspecified value; will be specified by some edit function. */ + PG_EDIT_UNSPECIFIED, +} pg_edit_type_t; + +typedef struct { + pg_edit_type_t type; + + /* Bit offset within packet where value is to be written. + Bits are written in network byte order: high bits first. + This is the bit offset of the least significant bit: i.e. the + highest numbered byte * 8 plus bit offset within that byte. + Negative offsets encode special edits. */ + i32 lsb_bit_offset; + + /* Special offset indicating this edit is for packet length. */ +#define PG_EDIT_PACKET_LENGTH (-1) + + /* Number of bits in edit. */ + u32 n_bits; + + /* Low and high values for this edit. Network byte order. */ + u8 * values[2]; +#define PG_EDIT_LO 0 +#define PG_EDIT_HI 1 + + /* Last value used for increment edit type. */ + u64 last_increment_value; +} pg_edit_t; + +always_inline void +pg_edit_free (pg_edit_t * e) +{ + int i; + for (i = 0; i < ARRAY_LEN (e->values); i++) + vec_free (e->values[i]); +} + +#define pg_edit_init_bitfield(e,type,field,field_offset,field_n_bits) \ +do { \ + u32 _bo; \ + \ + ASSERT ((field_offset) < STRUCT_BITS_OF (type, field)); \ + \ + /* Start byte offset. */ \ + _bo = STRUCT_OFFSET_OF (type, field); \ + \ + /* Adjust for big endian byte order. */ \ + _bo += ((STRUCT_BITS_OF (type, field) \ + - (field_offset) - 1) / BITS (u8)); \ + \ + (e)->lsb_bit_offset = _bo * BITS (u8) + ((field_offset) % BITS (u8)); \ + (e)->n_bits = (field_n_bits); \ +} while (0) + +/* Initialize edit for byte aligned fields. */ +#define pg_edit_init(e,type,field) \ + pg_edit_init_bitfield(e,type,field,0,STRUCT_BITS_OF(type,field)) + +static inline uword +pg_edit_n_alloc_bytes (pg_edit_t * e) +{ + int i0, i1, n_bytes, n_bits_left; + + i0 = e->lsb_bit_offset; + i1 = i0 % BITS (u8); + + n_bytes = 0; + n_bits_left = e->n_bits; + + if (n_bits_left > 0 && i1 != 0) + { + n_bytes++; + n_bits_left -= i1; + if (n_bits_left < 0) + n_bits_left = 0; + } + + n_bytes += (n_bits_left / BITS (u8)); + n_bytes += (n_bits_left % BITS (u8)) != 0; + + return n_bytes; +} + +static inline void +pg_edit_alloc_value (pg_edit_t * e, int i) +{ vec_validate (e->values[i], e->lsb_bit_offset / BITS (u8)); } + +extern void pg_edit_set_value (pg_edit_t * e, int hi_or_lo, u64 value); + +static inline void +pg_edit_set_fixed (pg_edit_t * e, u64 value) +{ + e->type = PG_EDIT_FIXED; + pg_edit_set_value (e, PG_EDIT_LO, value); +} + +static inline void +pg_edit_copy_type_and_values (pg_edit_t * dst, pg_edit_t * src) +{ + int i; + dst->type = src->type; + src->type = PG_EDIT_INVALID_TYPE; + for (i = 0; i < ARRAY_LEN (dst->values); i++) + { + dst->values[i] = src->values[i]; + src->values[i] = 0; + } +} + +static inline u64 +pg_edit_get_value (pg_edit_t * e, int hi_or_lo) +{ + u64 r = 0; + int i, n; + u8 * v = e->values[hi_or_lo]; + + n = round_pow2 (e->n_bits, BITS (u8)) / BITS (u8); + + ASSERT (n <= vec_len (v)); + ASSERT (n <= sizeof (r)); + + for (i = 0; i < n; i++) + r = (r << BITS (v[i])) + v[i]; + + return r; +} + +static inline uword +pg_edit_is_fixed_with_value (pg_edit_t * e, u64 value) +{ + return (e->type == PG_EDIT_FIXED + && value == pg_edit_get_value (e, PG_EDIT_LO)); +} + +uword unformat_pg_edit (unformat_input_t * input, va_list * args); +uword unformat_pg_payload (unformat_input_t * input, va_list * args); +uword unformat_pg_number (unformat_input_t * input, va_list * args); +uword unformat_pg_interface (unformat_input_t * input, va_list * args); + +#endif /* included_packet_generator_pg_edit_h */ diff --git a/vnet/vnet/pg/example.script b/vnet/vnet/pg/example.script new file mode 100644 index 00000000000..0e29b9ecae6 --- /dev/null +++ b/vnet/vnet/pg/example.script @@ -0,0 +1,6 @@ +packet-generator new { + name x + limit 1 + node ethernet-input + data { IP: 1.2.3 -> 4.5.6 incrementing 100 } +} diff --git a/vnet/vnet/pg/init.c b/vnet/vnet/pg/init.c new file mode 100644 index 00000000000..f598050c28d --- /dev/null +++ b/vnet/vnet/pg/init.c @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_init.c: VLIB packet generator + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/pg/pg.h> + +/* Global main structure. */ +pg_main_t pg_main; + +static clib_error_t * pg_init (vlib_main_t * vm) +{ + clib_error_t * error; + pg_main_t * pg = &pg_main; + int i, j; + + pg->vlib_main = vm; + + if ((error = vlib_call_init_function (vm, vnet_main_init))) + goto done; + + if ((error = vlib_call_init_function (vm, pg_cli_init))) + goto done; + + /* Create/free interfaces so that they exist and can be + used as a destination interface for streams. Also, create + a fixed number of pg interfaces so that interface numbering can + be made to be deterministic (at least if <= 4 streams are ever used). */ + for (i = 0; i < 4; i++) + { + j = pg_interface_find_free (pg, i); + ASSERT (j == i); + } + + /* Free interfaces. */ + for (i = j; i >= 0; i--) + vec_add1 (pg->free_interfaces, i); + + done: + return error; +} + +VLIB_INIT_FUNCTION (pg_init); diff --git a/vnet/vnet/pg/input.c b/vnet/vnet/pg/input.c new file mode 100644 index 00000000000..4ec61ca7b96 --- /dev/null +++ b/vnet/vnet/pg/input.c @@ -0,0 +1,1745 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_input.c: buffer generator input + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/pg/pg.h> +#include <vnet/vnet.h> + +#if DPDK==1 +#include <vnet/devices/dpdk/dpdk.h> +#endif + +static inline void +pg_set_mbuf_metadata (pg_main_t * pg, u32 * buffers, u32 n_alloc) +{ +#if DPDK == 1 + vlib_main_t * vm = vlib_get_main(); + vlib_buffer_t * b; + struct rte_mbuf * mb; + i16 delta; + u16 new_data_len; + u16 new_pkt_len; + + int i; + + for (i = 0; i < n_alloc; i++) + { + b = vlib_get_buffer (vm, buffers[i]); + mb = ((struct rte_mbuf *)b) - 1; + + delta = vlib_buffer_length_in_chain (vm, b) - (i16) mb->pkt_len; + new_data_len = (u16)((i16) mb->data_len + delta); + new_pkt_len = (u16)((i16) mb->pkt_len + delta); + + mb->data_len = new_data_len; + mb->pkt_len = new_pkt_len; + mb->data_off = (u16)((RTE_PKTMBUF_HEADROOM) + b->current_data); + } +#endif +} + +static int +validate_buffer_data2 (vlib_buffer_t * b, pg_stream_t * s, + u32 data_offset, u32 n_bytes) +{ + u8 * bd, * pd, * pm; + u32 i; + + bd = b->data; + pd = s->fixed_packet_data + data_offset; + pm = s->fixed_packet_data_mask + data_offset; + + if (pd + n_bytes >= vec_end (s->fixed_packet_data)) + n_bytes = (pd < vec_end (s->fixed_packet_data) + ? vec_end (s->fixed_packet_data) - pd + : 0); + + for (i = 0; i < n_bytes; i++) + if ((bd[i] & pm[i]) != pd[i]) + break; + + if (i >= n_bytes) + return 1; + + clib_warning ("buffer %U", format_vlib_buffer, b); + clib_warning ("differ at index %d", i); + clib_warning ("is %U", format_hex_bytes, bd, n_bytes); + clib_warning ("mask %U", format_hex_bytes, pm, n_bytes); + clib_warning ("expect %U", format_hex_bytes, pd, n_bytes); + return 0; +} + +static int +validate_buffer_data (vlib_buffer_t * b, pg_stream_t * s) +{ return validate_buffer_data2 (b, s, 0, s->buffer_bytes); } + +always_inline void +set_1 (void * a0, + u64 v0, + u64 v_min, u64 v_max, + u32 n_bits, + u32 is_net_byte_order) +{ + ASSERT (v0 >= v_min && v0 <= v_max); + if (n_bits == BITS (u8)) + { + ((u8 *) a0)[0] = v0; + } + else if (n_bits == BITS (u16)) + { + if (is_net_byte_order) + v0 = clib_host_to_net_u16 (v0); + clib_mem_unaligned (a0, u16) = v0; + } + else if (n_bits == BITS (u32)) + { + if (is_net_byte_order) + v0 = clib_host_to_net_u32 (v0); + clib_mem_unaligned (a0, u32) = v0; + } + else if (n_bits == BITS (u64)) + { + if (is_net_byte_order) + v0 = clib_host_to_net_u64 (v0); + clib_mem_unaligned (a0, u64) = v0; + } +} + +always_inline void +set_2 (void * a0, void * a1, + u64 v0, u64 v1, + u64 v_min, u64 v_max, + u32 n_bits, + u32 is_net_byte_order, + u32 is_increment) +{ + ASSERT (v0 >= v_min && v0 <= v_max); + ASSERT (v1 >= v_min && v1 <= (v_max + is_increment)); + if (n_bits == BITS (u8)) + { + ((u8 *) a0)[0] = v0; + ((u8 *) a1)[0] = v1; + } + else if (n_bits == BITS (u16)) + { + if (is_net_byte_order) + { + v0 = clib_host_to_net_u16 (v0); + v1 = clib_host_to_net_u16 (v1); + } + clib_mem_unaligned (a0, u16) = v0; + clib_mem_unaligned (a1, u16) = v1; + } + else if (n_bits == BITS (u32)) + { + if (is_net_byte_order) + { + v0 = clib_host_to_net_u32 (v0); + v1 = clib_host_to_net_u32 (v1); + } + clib_mem_unaligned (a0, u32) = v0; + clib_mem_unaligned (a1, u32) = v1; + } + else if (n_bits == BITS (u64)) + { + if (is_net_byte_order) + { + v0 = clib_host_to_net_u64 (v0); + v1 = clib_host_to_net_u64 (v1); + } + clib_mem_unaligned (a0, u64) = v0; + clib_mem_unaligned (a1, u64) = v1; + } +} + +static_always_inline void +do_set_fixed (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 n_bits, + u32 byte_offset, + u32 is_net_byte_order, + u64 v_min, u64 v_max) + +{ + vlib_main_t * vm = pg->vlib_main; + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + set_2 (a0, a1, v_min, v_min, + v_min, v_max, + n_bits, is_net_byte_order, + /* is_increment */ 0); + + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + set_1 (a0, v_min, + v_min, v_max, + n_bits, is_net_byte_order); + + ASSERT (validate_buffer_data (b0, s)); + } +} + +static_always_inline u64 +do_set_increment (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 n_bits, + u32 byte_offset, + u32 is_net_byte_order, + u32 want_sum, + u64 * sum_result, + u64 v_min, u64 v_max, + u64 v) +{ + vlib_main_t * vm = pg->vlib_main; + u64 sum = 0; + + ASSERT (v >= v_min && v <= v_max); + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + u64 v_old; + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + v_old = v; + v = v_old + 2; + v = v > v_max ? v_min : v; + set_2 (a0, a1, + v_old + 0, v_old + 1, + v_min, v_max, + n_bits, is_net_byte_order, + /* is_increment */ 1); + + if (want_sum) + sum += 2*v_old + 1; + + if (PREDICT_FALSE (v_old + 1 > v_max)) + { + if (want_sum) + sum -= 2*v_old + 1; + + v = v_old; + set_1 (a0, v + 0, v_min, v_max, n_bits, is_net_byte_order); + if (want_sum) + sum += v; + v += 1; + + v = v > v_max ? v_min : v; + set_1 (a1, v + 0, v_min, v_max, n_bits, is_net_byte_order); + if (want_sum) + sum += v; + v += 1; + } + + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + u64 v_old; + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + v_old = v; + if (want_sum) + sum += v_old; + v += 1; + v = v > v_max ? v_min : v; + + ASSERT (v_old >= v_min && v_old <= v_max); + set_1 (a0, v_old, v_min, v_max, n_bits, is_net_byte_order); + + ASSERT (validate_buffer_data (b0, s)); + } + + if (want_sum) + *sum_result = sum; + + return v; +} + +static_always_inline void +do_set_random (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 n_bits, + u32 byte_offset, + u32 is_net_byte_order, + u32 want_sum, + u64 * sum_result, + u64 v_min, u64 v_max) + +{ + vlib_main_t * vm = pg->vlib_main; + u64 v_diff = v_max - v_min + 1; + u64 r_mask = max_pow2 (v_diff) - 1; + u64 v0, v1; + u64 sum = 0; + void * random_data; + + random_data = clib_random_buffer_get_data + (&vm->random_buffer, n_buffers * n_bits / BITS (u8)); + + v0 = v1 = v_min; + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + u64 r0=0, r1=0; /* warnings be gone */ + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + switch (n_bits) + { +#define _(n) \ + case BITS (u##n): \ + { \ + u##n * r = random_data; \ + r0 = r[0]; \ + r1 = r[1]; \ + random_data = r + 2; \ + } \ + break; + + _ (8); + _ (16); + _ (32); + _ (64); + +#undef _ + } + + /* Add power of 2 sized random number which may be out of range. */ + v0 += r0 & r_mask; + v1 += r1 & r_mask; + + /* Twice should be enough to reduce to v_min .. v_max range. */ + v0 = v0 > v_max ? v0 - v_diff : v0; + v1 = v1 > v_max ? v1 - v_diff : v1; + v0 = v0 > v_max ? v0 - v_diff : v0; + v1 = v1 > v_max ? v1 - v_diff : v1; + + if (want_sum) + sum += v0 + v1; + + set_2 (a0, a1, + v0, v1, + v_min, v_max, + n_bits, is_net_byte_order, + /* is_increment */ 0); + + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + u64 r0 = 0; /* warnings be gone */ + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + switch (n_bits) + { +#define _(n) \ + case BITS (u##n): \ + { \ + u##n * r = random_data; \ + r0 = r[0]; \ + random_data = r + 1; \ + } \ + break; + + _ (8); + _ (16); + _ (32); + _ (64); + +#undef _ + } + + /* Add power of 2 sized random number which may be out of range. */ + v0 += r0 & r_mask; + + /* Twice should be enough to reduce to v_min .. v_max range. */ + v0 = v0 > v_max ? v0 - v_diff : v0; + v0 = v0 > v_max ? v0 - v_diff : v0; + + if (want_sum) + sum += v0; + + set_1 (a0, v0, v_min, v_max, n_bits, is_net_byte_order); + + ASSERT (validate_buffer_data (b0, s)); + } + + if (want_sum) + *sum_result = sum; +} + +#define _(i,t) \ + clib_mem_unaligned (a##i, t) = \ + clib_host_to_net_##t ((clib_net_to_host_mem_##t (a##i) &~ mask) \ + | (v##i << shift)) + +always_inline void +setbits_1 (void * a0, + u64 v0, + u64 v_min, u64 v_max, + u32 max_bits, + u32 n_bits, + u64 mask, + u32 shift) +{ + ASSERT (v0 >= v_min && v0 <= v_max); + if (max_bits == BITS (u8)) + ((u8 *) a0)[0] = (((u8 *) a0)[0] &~ mask) | (v0 << shift); + + else if (max_bits == BITS (u16)) + { + _ (0, u16); + } + else if (max_bits == BITS (u32)) + { + _ (0, u32); + } + else if (max_bits == BITS (u64)) + { + _ (0, u64); + } +} + +always_inline void +setbits_2 (void * a0, void * a1, + u64 v0, u64 v1, + u64 v_min, u64 v_max, + u32 max_bits, + u32 n_bits, + u64 mask, + u32 shift, + u32 is_increment) +{ + ASSERT (v0 >= v_min && v0 <= v_max); + ASSERT (v1 >= v_min && v1 <= v_max + is_increment); + if (max_bits == BITS (u8)) + { + ((u8 *) a0)[0] = (((u8 *) a0)[0] &~ mask) | (v0 << shift); + ((u8 *) a1)[0] = (((u8 *) a1)[0] &~ mask) | (v1 << shift); + } + + else if (max_bits == BITS (u16)) + { + _ (0, u16); + _ (1, u16); + } + else if (max_bits == BITS (u32)) + { + _ (0, u32); + _ (1, u32); + } + else if (max_bits == BITS (u64)) + { + _ (0, u64); + _ (1, u64); + } +} + +#undef _ + +static_always_inline void +do_setbits_fixed (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 max_bits, + u32 n_bits, + u32 byte_offset, + u64 v_min, u64 v_max, + u64 mask, + u32 shift) + +{ + vlib_main_t * vm = pg->vlib_main; + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + setbits_2 (a0, a1, + v_min, v_min, + v_min, v_max, + max_bits, n_bits, mask, shift, + /* is_increment */ 0); + + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + setbits_1 (a0, v_min, v_min, v_max, max_bits, n_bits, mask, shift); + ASSERT (validate_buffer_data (b0, s)); + } +} + +static_always_inline u64 +do_setbits_increment (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 max_bits, + u32 n_bits, + u32 byte_offset, + u64 v_min, u64 v_max, + u64 v, + u64 mask, + u32 shift) +{ + vlib_main_t * vm = pg->vlib_main; + + ASSERT (v >= v_min && v <= v_max); + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + u64 v_old; + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + v_old = v; + v = v_old + 2; + v = v > v_max ? v_min : v; + setbits_2 (a0, a1, + v_old + 0, v_old + 1, + v_min, v_max, + max_bits, n_bits, mask, shift, + /* is_increment */ 1); + + if (PREDICT_FALSE (v_old + 1 > v_max)) + { + v = v_old; + setbits_1 (a0, v + 0, v_min, v_max, max_bits, n_bits, mask, shift); + v += 1; + + v = v > v_max ? v_min : v; + setbits_1 (a1, v + 0, v_min, v_max, max_bits, n_bits, mask, shift); + v += 1; + } + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + u64 v_old; + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + v_old = v; + v = v_old + 1; + v = v > v_max ? v_min : v; + + ASSERT (v_old >= v_min && v_old <= v_max); + setbits_1 (a0, v_old, v_min, v_max, max_bits, n_bits, mask, shift); + + ASSERT (validate_buffer_data (b0, s)); + } + + return v; +} + +static_always_inline void +do_setbits_random (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 max_bits, + u32 n_bits, + u32 byte_offset, + u64 v_min, u64 v_max, + u64 mask, + u32 shift) +{ + vlib_main_t * vm = pg->vlib_main; + u64 v_diff = v_max - v_min + 1; + u64 r_mask = max_pow2 (v_diff) - 1; + u64 v0, v1; + void * random_data; + + random_data = clib_random_buffer_get_data + (&vm->random_buffer, n_buffers * max_bits / BITS (u8)); + v0 = v1 = v_min; + + while (n_buffers >= 4) + { + vlib_buffer_t * b0, * b1, * b2, * b3; + void * a0, * a1; + u64 r0=0, r1=0; /* warnings be gone */ + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + b2 = vlib_get_buffer (vm, buffers[2]); + b3 = vlib_get_buffer (vm, buffers[3]); + buffers += 2; + n_buffers -= 2; + + a0 = (void *) b0 + byte_offset; + a1 = (void *) b1 + byte_offset; + CLIB_PREFETCH ((void *) b2 + byte_offset, sizeof (v_min), WRITE); + CLIB_PREFETCH ((void *) b3 + byte_offset, sizeof (v_min), WRITE); + + switch (max_bits) + { +#define _(n) \ + case BITS (u##n): \ + { \ + u##n * r = random_data; \ + r0 = r[0]; \ + r1 = r[1]; \ + random_data = r + 2; \ + } \ + break; + + _ (8); + _ (16); + _ (32); + _ (64); + +#undef _ + } + + /* Add power of 2 sized random number which may be out of range. */ + v0 += r0 & r_mask; + v1 += r1 & r_mask; + + /* Twice should be enough to reduce to v_min .. v_max range. */ + v0 = v0 > v_max ? v0 - v_diff : v0; + v1 = v1 > v_max ? v1 - v_diff : v1; + v0 = v0 > v_max ? v0 - v_diff : v0; + v1 = v1 > v_max ? v1 - v_diff : v1; + + setbits_2 (a0, a1, + v0, v1, + v_min, v_max, + max_bits, n_bits, mask, shift, + /* is_increment */ 0); + + ASSERT (validate_buffer_data (b0, s)); + ASSERT (validate_buffer_data (b1, s)); + } + + while (n_buffers > 0) + { + vlib_buffer_t * b0; + void * a0; + u64 r0 = 0; /* warnings be gone */ + + b0 = vlib_get_buffer (vm, buffers[0]); + buffers += 1; + n_buffers -= 1; + + a0 = (void *) b0 + byte_offset; + + switch (max_bits) + { +#define _(n) \ + case BITS (u##n): \ + { \ + u##n * r = random_data; \ + r0 = r[0]; \ + random_data = r + 1; \ + } \ + break; + + _ (8); + _ (16); + _ (32); + _ (64); + +#undef _ + } + + /* Add power of 2 sized random number which may be out of range. */ + v0 += r0 & r_mask; + + /* Twice should be enough to reduce to v_min .. v_max range. */ + v0 = v0 > v_max ? v0 - v_diff : v0; + v0 = v0 > v_max ? v0 - v_diff : v0; + + setbits_1 (a0, v0, v_min, v_max, max_bits, n_bits, mask, shift); + + ASSERT (validate_buffer_data (b0, s)); + } +} + +static u64 do_it (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers, + u32 lo_bit, u32 hi_bit, + u64 v_min, u64 v_max, + u64 v, + pg_edit_type_t edit_type) +{ + u32 max_bits, l0, l1, h1, start_bit; + + if (v_min == v_max) + edit_type = PG_EDIT_FIXED; + + l0 = lo_bit / BITS (u8); + l1 = lo_bit % BITS (u8); + h1 = hi_bit % BITS (u8); + + start_bit = l0 * BITS (u8); + + max_bits = hi_bit - start_bit; + ASSERT (max_bits <= 64); + +#define _(n) \ + case (n): \ + if (edit_type == PG_EDIT_INCREMENT) \ + v = do_set_increment (pg, s, buffers, n_buffers, \ + BITS (u##n), \ + l0, \ + /* is_net_byte_order */ 1, \ + /* want sum */ 0, 0, \ + v_min, v_max, \ + v); \ + else if (edit_type == PG_EDIT_RANDOM) \ + do_set_random (pg, s, buffers, n_buffers, \ + BITS (u##n), \ + l0, \ + /* is_net_byte_order */ 1, \ + /* want sum */ 0, 0, \ + v_min, v_max); \ + else /* edit_type == PG_EDIT_FIXED */ \ + do_set_fixed (pg, s, buffers, n_buffers, \ + BITS (u##n), \ + l0, \ + /* is_net_byte_order */ 1, \ + v_min, v_max); \ + goto done; + + if (l1 == 0 && h1 == 0) + { + switch (max_bits) + { + _ (8); + _ (16); + _ (32); + _ (64); + } + } + +#undef _ + + { + u64 mask; + u32 shift = l1; + u32 n_bits = max_bits; + + max_bits = clib_max (max_pow2 (n_bits), 8); + + mask = ((u64) 1 << (u64) n_bits) - 1; + mask &= ~(((u64) 1 << (u64) shift) - 1); + + mask <<= max_bits - n_bits; + shift += max_bits - n_bits; + + switch (max_bits) + { +#define _(n) \ + case (n): \ + if (edit_type == PG_EDIT_INCREMENT) \ + v = do_setbits_increment (pg, s, buffers, n_buffers, \ + BITS (u##n), n_bits, \ + l0, v_min, v_max, v, \ + mask, shift); \ + else if (edit_type == PG_EDIT_RANDOM) \ + do_setbits_random (pg, s, buffers, n_buffers, \ + BITS (u##n), n_bits, \ + l0, v_min, v_max, \ + mask, shift); \ + else /* edit_type == PG_EDIT_FIXED */ \ + do_setbits_fixed (pg, s, buffers, n_buffers, \ + BITS (u##n), n_bits, \ + l0, v_min, v_max, \ + mask, shift); \ + goto done; + + _ (8); + _ (16); + _ (32); + _ (64); + +#undef _ + } + } + + done: + return v; +} + +static void +pg_generate_set_lengths (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers) +{ + u64 v_min, v_max, length_sum; + pg_edit_type_t edit_type; + + v_min = s->min_packet_bytes; + v_max = s->max_packet_bytes; + edit_type = s->packet_size_edit_type; + + if (edit_type == PG_EDIT_INCREMENT) + s->last_increment_packet_size + = do_set_increment (pg, s, buffers, n_buffers, + 8 * STRUCT_SIZE_OF (vlib_buffer_t, current_length), + STRUCT_OFFSET_OF (vlib_buffer_t, current_length), + /* is_net_byte_order */ 0, + /* want sum */ 1, &length_sum, + v_min, v_max, + s->last_increment_packet_size); + + else if (edit_type == PG_EDIT_RANDOM) + do_set_random (pg, s, buffers, n_buffers, + 8 * STRUCT_SIZE_OF (vlib_buffer_t, current_length), + STRUCT_OFFSET_OF (vlib_buffer_t, current_length), + /* is_net_byte_order */ 0, + /* want sum */ 1, &length_sum, + v_min, v_max); + + else /* edit_type == PG_EDIT_FIXED */ + { + do_set_fixed (pg, s, buffers, n_buffers, + 8 * STRUCT_SIZE_OF (vlib_buffer_t, current_length), + STRUCT_OFFSET_OF (vlib_buffer_t, current_length), + /* is_net_byte_order */ 0, + v_min, v_max); + length_sum = v_min * n_buffers; + } + + { + 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]); + + vlib_increment_combined_counter (im->combined_sw_if_counters + + VNET_INTERFACE_COUNTER_RX, + os_get_cpu_number(), + si->sw_if_index, + n_buffers, + length_sum); + } + + pg_set_mbuf_metadata (pg, buffers, n_buffers); +} + +static void +pg_generate_fix_multi_buffer_lengths (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers) +{ + vlib_main_t * vm = pg->vlib_main; + pg_buffer_index_t * pbi; + uword n_bytes_left; + static u32 * unused_buffers = 0; + + while (n_buffers > 0) + { + vlib_buffer_t * b; + u32 bi; + + bi = buffers[0]; + b = vlib_get_buffer (vm, bi); + + /* Current length here is length of whole packet. */ + n_bytes_left = b->current_length; + + pbi = s->buffer_indices; + while (1) + { + uword n = clib_min (n_bytes_left, s->buffer_bytes); + + b->current_length = n; + n_bytes_left -= n; + if (n_bytes_left > 0) + b->flags |= VLIB_BUFFER_NEXT_PRESENT; + else + b->flags &= ~VLIB_BUFFER_NEXT_PRESENT; + + /* Return unused buffers to fifos. */ + if (n == 0) + vec_add1 (unused_buffers, bi); + + pbi++; + if (pbi >= vec_end (s->buffer_indices)) + break; + + bi = b->next_buffer; + b = vlib_get_buffer (vm, bi); + } + ASSERT (n_bytes_left == 0); + + buffers += 1; + n_buffers -= 1; + } + + if (vec_len (unused_buffers) > 0) + { + vlib_buffer_free_no_next (vm, unused_buffers, + vec_len (unused_buffers)); + _vec_len (unused_buffers) = 0; + } +} + +static void +pg_generate_edit (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers) +{ + pg_edit_t * e; + + vec_foreach (e, s->non_fixed_edits) + { + switch (e->type) + { + case PG_EDIT_RANDOM: + case PG_EDIT_INCREMENT: + { + u32 lo_bit, hi_bit; + u64 v_min, v_max; + + v_min = pg_edit_get_value (e, PG_EDIT_LO); + v_max = pg_edit_get_value (e, PG_EDIT_HI); + + hi_bit = (BITS (u8) * STRUCT_OFFSET_OF (vlib_buffer_t, data) + + BITS (u8) + + e->lsb_bit_offset); + lo_bit = hi_bit - e->n_bits; + + e->last_increment_value + = do_it (pg, s, buffers, n_buffers, lo_bit, hi_bit, v_min, v_max, + e->last_increment_value, + e->type); + } + break; + + case PG_EDIT_UNSPECIFIED: + break; + + default: + /* Should not be any fixed edits left. */ + ASSERT (0); + break; + } + } + + /* Call any edit functions to e.g. completely IP lengths, checksums, ... */ + { + int i; + for (i = vec_len (s->edit_groups) - 1; i >= 0; i--) + { + pg_edit_group_t * g = s->edit_groups + i; + if (g->edit_function) + g->edit_function (pg, s, g, buffers, n_buffers); + } + } +} + +static void +pg_set_next_buffer_pointers (pg_main_t * pg, + pg_stream_t * s, + u32 * buffers, + u32 * next_buffers, + u32 n_buffers) +{ + vlib_main_t * vm = pg->vlib_main; + + while (n_buffers >= 4) + { + u32 ni0, ni1; + vlib_buffer_t * b0, * b1; + + b0 = vlib_get_buffer (vm, buffers[0]); + b1 = vlib_get_buffer (vm, buffers[1]); + ni0 = next_buffers[0]; + ni1 = next_buffers[1]; + + vlib_prefetch_buffer_with_index (vm, buffers[2], WRITE); + vlib_prefetch_buffer_with_index (vm, buffers[3], WRITE); + + b0->flags |= VLIB_BUFFER_NEXT_PRESENT; + b1->flags |= VLIB_BUFFER_NEXT_PRESENT; + b0->next_buffer = ni0; + b1->next_buffer = ni1; + + buffers += 2; + next_buffers += 2; + n_buffers -= 2; + } + + while (n_buffers > 0) + { + u32 ni0; + vlib_buffer_t * b0; + + b0 = vlib_get_buffer (vm, buffers[0]); + ni0 = next_buffers[0]; + buffers += 1; + next_buffers += 1; + n_buffers -= 1; + + b0->flags |= VLIB_BUFFER_NEXT_PRESENT; + b0->next_buffer = ni0; + } +} + +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); + + 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; + + 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 * buffers, + u32 n_buffers, + u32 data_offset, + u32 n_data, + u32 set_data) +{ + 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); + + data = s->fixed_packet_data + data_offset; + mask = s->fixed_packet_data_mask + data_offset; + if (data + n_data >= vec_end (s->fixed_packet_data)) + n_data = (data < vec_end (s->fixed_packet_data) + ? vec_end (s->fixed_packet_data) - data + : 0); + if (n_data > 0) + { + ASSERT (data + n_data <= vec_end (s->fixed_packet_data)); + ASSERT (mask + n_data <= vec_end (s->fixed_packet_data_mask)); + } + + n_left = n_buffers; + b = buffers; + + while (n_left >= 4) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + + /* Prefetch next iteration. */ + vlib_prefetch_buffer_with_index (vm, b[2], STORE); + vlib_prefetch_buffer_with_index (vm, b[3], STORE); + + bi0 = b[0]; + bi1 = b[1]; + b += 2; + n_left -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + + vnet_buffer (b0)->sw_if_index[VLIB_RX] = + vnet_buffer (b1)->sw_if_index[VLIB_RX] = s->sw_if_index[VLIB_RX]; + + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + vnet_buffer (b1)->sw_if_index[VLIB_TX] = (u32)~0; + + if (set_data) + { + memcpy (b0->data, data, n_data); + memcpy (b1->data, data, n_data); + } + else + { + ASSERT (validate_buffer_data2 (b0, s, data_offset, n_data)); + ASSERT (validate_buffer_data2 (b1, s, data_offset, n_data)); + } + } + + while (n_left >= 1) + { + u32 bi0; + vlib_buffer_t * b0; + + 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]; + /* s->sw_if_index[VLIB_TX]; */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32)~0; + + if (set_data) + memcpy (b0->data, data, n_data); + else + ASSERT (validate_buffer_data2 (b0, s, data_offset, n_data)); + } +} + +static void pg_buffer_init (vlib_main_t * vm, + vlib_buffer_free_list_t * fl, + u32 * buffers, + u32 n_buffers) +{ + pg_main_t * pg = &pg_main; + pg_stream_t * s; + uword bi, si; + + si = fl->buffer_init_function_opaque & pow2_mask (24); + bi = fl->buffer_init_function_opaque >> 24; + + s = pool_elt_at_index (pg->streams, si); + + init_buffers_inline (vm, s, buffers, n_buffers, + /* data_offset */ bi * s->buffer_bytes, + /* n_data */ s->buffer_bytes, + /* set_data */ 1); +} + +static u32 +pg_stream_fill_helper (pg_main_t * pg, + pg_stream_t * s, + pg_buffer_index_t * bi, + u32 * buffers, + u32 * next_buffers, + u32 n_alloc) +{ + vlib_main_t * vm = pg->vlib_main; + vlib_buffer_free_list_t * f; + uword is_start_of_packet = bi == s->buffer_indices; + u32 n_allocated; + + f = vlib_buffer_get_free_list (vm, bi->free_list_index); + + /* + * Historically, the pg maintained its own free lists and + * device drivers tx paths would return pkts. With the DPDK, + * that doesn't happen. + */ + if (DPDK == 0 && ! (s->flags & PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE)) + f->buffer_init_function = pg_buffer_init; + f->buffer_init_function_opaque = + (s - pg->streams) | ((bi - s->buffer_indices) << 24); + + if (is_start_of_packet) + vnet_buffer (&f->buffer_init_template)->sw_if_index[VLIB_RX] + = vnet_main.local_interface_sw_if_index; + + n_allocated = vlib_buffer_alloc_from_free_list (vm, + buffers, + n_alloc, + bi->free_list_index); + if (n_allocated == 0) + return 0; + + /* + * We can't assume we got all the buffers we asked for... + * This never worked until recently. + */ + n_alloc = n_allocated; + + /* Reinitialize buffers */ + if (DPDK == 0 || CLIB_DEBUG > 0 + || (s->flags & PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE)) + init_buffers_inline + (vm, s, + buffers, + n_alloc, + (bi - s->buffer_indices) * s->buffer_bytes /* data offset */, + s->buffer_bytes, + /* set_data */ + DPDK == 1 || (s->flags & PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE) != 0); + + /* $$$ this doesn't work at the moment */ + ASSERT(next_buffers == 0); + if (next_buffers) + pg_set_next_buffer_pointers (pg, s, buffers, next_buffers, n_alloc); + + if (is_start_of_packet) + { + if (vec_len (s->replay_packet_templates) > 0) + { + 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, + os_get_cpu_number(), + 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); + } + 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); + } + } + + return n_alloc; +} + +static u32 +pg_stream_fill (pg_main_t * pg, pg_stream_t * s, u32 n_buffers) +{ + pg_buffer_index_t * bi; + word i, n_in_fifo, n_alloc, n_free, n_added; + u32 * tail, * start, * end, * last_tail, * last_start; + + bi = s->buffer_indices; + + n_in_fifo = clib_fifo_elts (bi->buffer_fifo); + if (n_in_fifo >= n_buffers) + return n_in_fifo; + + n_alloc = n_buffers - n_in_fifo; + + /* Round up, but never generate more than limit. */ + n_alloc = clib_max (VLIB_FRAME_SIZE, n_alloc); + + if (s->n_packets_limit > 0 + && s->n_packets_generated + n_in_fifo + n_alloc >= s->n_packets_limit) + { + n_alloc = s->n_packets_limit - s->n_packets_generated - n_in_fifo; + if (n_alloc < 0) + n_alloc = 0; + } + + /* All buffer fifos should have the same size. */ + if (CLIB_DEBUG > 0) + { + uword l = ~0, e; + vec_foreach (bi, s->buffer_indices) + { + e = clib_fifo_elts (bi->buffer_fifo); + if (bi == s->buffer_indices) + l = e; + ASSERT (l == e); + } + } + + last_tail = last_start = 0; + n_added = n_alloc; + + for (i = vec_len (s->buffer_indices) - 1; i >= 0; i--) + { + bi = vec_elt_at_index (s->buffer_indices, i); + + n_free = clib_fifo_free_elts (bi->buffer_fifo); + if (n_free < n_alloc) + clib_fifo_resize (bi->buffer_fifo, n_alloc - n_free); + + tail = clib_fifo_advance_tail (bi->buffer_fifo, n_alloc); + start = bi->buffer_fifo; + end = clib_fifo_end (bi->buffer_fifo); + + if (tail + n_alloc <= end) + { + n_added = pg_stream_fill_helper (pg, s, bi, tail, last_tail, n_alloc); + } + else + { + u32 n = clib_min (end - tail, n_alloc); + n_added = pg_stream_fill_helper (pg, s, bi, tail, last_tail, n); + + if (n_added == n && n_alloc > n_added) + { + n_added += pg_stream_fill_helper + (pg, s, bi, start, last_start, n_alloc - n_added); + } + } + + if (PREDICT_FALSE (n_added < n_alloc)) + tail = clib_fifo_advance_tail (bi->buffer_fifo, n_added - n_alloc); + + last_tail = tail; + last_start = start; + + /* Verify that pkts in the fifo are properly allocated */ +#if DPDK == 1 + if (CLIB_DEBUG > 0) + { + u32 *bi0; + vlib_main_t * vm = vlib_get_main(); + clib_fifo_foreach (bi0, bi->buffer_fifo, + ({ + vlib_buffer_t * b; + struct rte_mbuf *mb; + + b = vlib_get_buffer(vm, bi0[0]); + mb = (struct rte_mbuf *)b - 1; + ASSERT(rte_mbuf_refcnt_read(mb) == 1); + })); + } +#endif + } + + return n_in_fifo + n_added; +} + +typedef struct { + u32 stream_index; + + u32 packet_length; + + /* Use pre data for packet data. */ + vlib_buffer_t buffer; +} pg_input_trace_t; + +static u8 * format_pg_input_trace (u8 * s, va_list * va) +{ + vlib_main_t * vm = va_arg (*va, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *); + pg_input_trace_t * t = va_arg (*va, pg_input_trace_t *); + pg_main_t * pg = &pg_main; + pg_stream_t * stream; + vlib_node_t * n; + uword indent = format_get_indent (s); + + stream = 0; + if (! pool_is_free_index (pg->streams, t->stream_index)) + stream = pool_elt_at_index (pg->streams, t->stream_index); + + if (stream) + s = format (s, "stream %v", pg->streams[t->stream_index].name); + else + s = format (s, "stream %d", t->stream_index); + + s = format (s, ", %d bytes", t->packet_length); + + s = format (s, "\n%U%U", + format_white_space, indent, + format_vlib_buffer, &t->buffer); + + s = format (s, "\n%U", + format_white_space, indent); + + n = 0; + if (stream) + n = vlib_get_node (vm, stream->node_index); + + if (n && n->format_buffer) + s = format (s, "%U", n->format_buffer, + t->buffer.pre_data, + sizeof (t->buffer.pre_data)); + else + s = format (s, "%U", + format_hex_bytes, t->buffer.pre_data, + ARRAY_LEN (t->buffer.pre_data)); + return s; +} + +static void +pg_input_trace (pg_main_t * pg, + vlib_node_runtime_t * node, + pg_stream_t * s, + u32 * buffers, + u32 n_buffers) +{ + vlib_main_t * vm = pg->vlib_main; + u32 * b, n_left, stream_index, next_index; + + n_left = n_buffers; + b = buffers; + stream_index = s - pg->streams; + next_index = s->next_index; + + while (n_left >= 2) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + pg_input_trace_t * t0, * t1; + + bi0 = b[0]; + bi1 = b[1]; + b += 2; + n_left -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + + vlib_trace_buffer (vm, node, next_index, b0, /* follow_chain */ 1); + vlib_trace_buffer (vm, node, next_index, b1, /* follow_chain */ 1); + + t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0])); + t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0])); + + t0->stream_index = stream_index; + t1->stream_index = stream_index; + + t0->packet_length = vlib_buffer_length_in_chain (vm, b0); + t1->packet_length = vlib_buffer_length_in_chain (vm, b1); + + memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data)); + memcpy (&t1->buffer, b1, sizeof (b1[0]) - sizeof (b1->pre_data)); + + memcpy (t0->buffer.pre_data, b0->data, sizeof (t0->buffer.pre_data)); + memcpy (t1->buffer.pre_data, b1->data, sizeof (t1->buffer.pre_data)); + } + + while (n_left >= 1) + { + u32 bi0; + vlib_buffer_t * b0; + pg_input_trace_t * t0; + + bi0 = b[0]; + b += 1; + n_left -= 1; + + b0 = vlib_get_buffer (vm, bi0); + + vlib_trace_buffer (vm, node, next_index, b0, /* follow_chain */ 1); + t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0])); + + t0->stream_index = stream_index; + t0->packet_length = vlib_buffer_length_in_chain (vm, b0); + memcpy (&t0->buffer, b0, sizeof (b0[0]) - sizeof (b0->pre_data)); + memcpy (t0->buffer.pre_data, b0->data, sizeof (t0->buffer.pre_data)); + } +} + +static uword +pg_generate_packets (vlib_node_runtime_t * node, + pg_main_t * pg, + pg_stream_t * s, + uword n_packets_to_generate) +{ + vlib_main_t * vm = pg->vlib_main; + u32 * to_next, n_this_frame, n_left, n_trace, n_packets_in_fifo; + uword n_packets_generated; + pg_buffer_index_t * bi, * bi0; + + bi0 = s->buffer_indices; + + n_packets_in_fifo = pg_stream_fill (pg, s, n_packets_to_generate); + n_packets_to_generate = clib_min (n_packets_in_fifo, n_packets_to_generate); + n_packets_generated = 0; + + while (n_packets_to_generate > 0) + { + u32 * head, * start, * end; + + vlib_get_next_frame (vm, node, s->next_index, to_next, n_left); + + n_this_frame = n_packets_to_generate; + if (n_this_frame > n_left) + n_this_frame = n_left; + + start = bi0->buffer_fifo; + end = clib_fifo_end (bi0->buffer_fifo); + head = clib_fifo_head (bi0->buffer_fifo); + + if (head + n_this_frame <= end) + vlib_copy_buffers (to_next, head, n_this_frame); + else + { + u32 n = end - head; + vlib_copy_buffers (to_next + 0, head, n); + vlib_copy_buffers (to_next + n, start, n_this_frame - n); + } + + vec_foreach (bi, s->buffer_indices) + clib_fifo_advance_head (bi->buffer_fifo, n_this_frame); + + n_trace = vlib_get_trace_count (vm, node); + if (n_trace > 0) + { + u32 n = clib_min (n_trace, n_this_frame); + pg_input_trace (pg, node, s, to_next, n); + vlib_set_trace_count (vm, node, n_trace - n); + } + n_packets_to_generate -= n_this_frame; + n_packets_generated += n_this_frame; + n_left -= n_this_frame; + vlib_put_next_frame (vm, node, s->next_index, n_left); + } + + return n_packets_generated; +} + +static uword +pg_input_stream (vlib_node_runtime_t * node, + pg_main_t * pg, + pg_stream_t * s) +{ + vlib_main_t * vm = pg->vlib_main; + uword n_packets; + f64 time_now, dt; + + if (s->n_packets_limit > 0 + && s->n_packets_generated >= s->n_packets_limit) + { + pg_stream_enable_disable (pg, s, /* want_enabled */ 0); + return 0; + } + + /* Apply rate limit. */ + time_now = vlib_time_now (vm); + if (s->time_last_generate == 0) + s->time_last_generate = time_now; + + dt = time_now - s->time_last_generate; + s->time_last_generate = time_now; + + n_packets = VLIB_FRAME_SIZE; + if (s->rate_packets_per_second > 0) + { + s->packet_accumulator += dt * s->rate_packets_per_second; + n_packets = s->packet_accumulator; + + /* Never allow accumulator to grow if we get behind. */ + s->packet_accumulator -= n_packets; + } + + /* Apply fixed limit. */ + if (s->n_packets_limit > 0 + && s->n_packets_generated + n_packets > s->n_packets_limit) + n_packets = s->n_packets_limit - s->n_packets_generated; + + /* Generate up to one frame's worth of packets. */ + if (n_packets > VLIB_FRAME_SIZE) + n_packets = VLIB_FRAME_SIZE; + + if (n_packets > 0) + n_packets = pg_generate_packets (node, pg, s, n_packets); + + s->n_packets_generated += n_packets; + + return n_packets; +} + +uword +pg_input (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + uword i; + pg_main_t * pg = &pg_main; + uword n_packets = 0; + + clib_bitmap_foreach (i, pg->enabled_streams, ({ + n_packets += pg_input_stream (node, pg, vec_elt_at_index (pg->streams, i)); + })); + + return n_packets; +} + +VLIB_REGISTER_NODE (pg_input_node) = { + .function = pg_input, + .name = "pg-input", + .type = VLIB_NODE_TYPE_INPUT, + + .format_trace = format_pg_input_trace, + + /* Input node will be left disabled until a stream is active. */ + .state = VLIB_NODE_STATE_DISABLED, +}; diff --git a/vnet/vnet/pg/output.c b/vnet/vnet/pg/output.c new file mode 100644 index 00000000000..cc098da21c6 --- /dev/null +++ b/vnet/vnet/pg/output.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_output.c: packet generator output + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/pg/pg.h> + +uword +pg_output (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 * buffers = vlib_frame_args (frame); + uword n_buffers = frame->n_vectors; + vlib_buffer_free_no_next (vm, buffers, n_buffers); + return n_buffers; +} diff --git a/vnet/vnet/pg/pg.h b/vnet/vnet/pg/pg.h new file mode 100644 index 00000000000..63bfb18abca --- /dev/null +++ b/vnet/vnet/pg/pg.h @@ -0,0 +1,347 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg.h: VLIB packet generator + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef included_vlib_pg_h +#define included_vlib_pg_h + +#include <vlib/vlib.h> /* for VLIB_N_RX_TX */ +#include <vnet/pg/edit.h> +#include <vppinfra/fifo.h> /* for buffer_fifo */ + +struct pg_main_t; +struct pg_stream_t; + +typedef struct pg_edit_group_t { + /* Edits in this group. */ + pg_edit_t * edits; + + /* Vector of non-fixed edits for this group. */ + pg_edit_t * non_fixed_edits; + + /* Fixed edits for this group. */ + u8 * fixed_packet_data; + u8 * fixed_packet_data_mask; + + /* Byte offset where packet data begins. */ + u32 start_byte_offset; + + /* Number of packet bytes for this edit group. */ + u32 n_packet_bytes; + + /* Function to perform miscellaneous edits (e.g. set IP checksum, ...). */ + void (* edit_function) (struct pg_main_t * pg, + struct pg_stream_t * s, + struct pg_edit_group_t * g, + u32 * buffers, + u32 n_buffers); + + /* Opaque data for edit function's use. */ + uword edit_function_opaque; +} pg_edit_group_t; + +/* Packets are made of multiple buffers chained together. + This struct keeps track of data per-chain index. */ +typedef struct { + /* Vector of buffer edits for this stream and buffer index. */ + pg_edit_t * edits; + + /* Buffers pre-initialized with fixed buffer data for this stream. */ + u32 * buffer_fifo; + + /* Buffer free list for this buffer index in stream. */ + u32 free_list_index; +} pg_buffer_index_t; + +typedef struct pg_stream_t { + /* Stream name. */ + u8 * name; + + u32 flags; + + /* Stream is currently enabled. */ +#define PG_STREAM_FLAGS_IS_ENABLED (1 << 0) +#define PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE (1 << 1) + + /* Edit groups are created by each protocol level (e.g. ethernet, + ip4, tcp, ...). */ + pg_edit_group_t * edit_groups; + + pg_edit_type_t packet_size_edit_type; + + /* Min/max packet size. */ + u32 min_packet_bytes, max_packet_bytes; + + /* Vector of non-fixed edits for this stream. + All fixed edits are performed and placed into fixed_packet_data. */ + pg_edit_t * non_fixed_edits; + + /* Packet data with all fixed edits performed. + All packets in stream are initialized according with this data. + Mask specifies which bits of packet data are covered by fixed edits. */ + u8 * fixed_packet_data, * fixed_packet_data_mask; + + /* Size to use for buffers. 0 means use buffers big enough + for max_packet_bytes. */ + u32 buffer_bytes; + + /* Last packet length if packet size edit type is increment. */ + u32 last_increment_packet_size; + + /* Index into main interface pool for this stream. */ + u32 pg_if_index; + + /* Interface used to mark packets for this stream. May be different + than hw/sw index from pg main interface pool. They will be + different if this stream is being used generate buffers as if + they were received on a non-pg interface. For example, suppose you + are trying to test vlan code and you want to generate buffers that + appear to come from an ethernet interface. */ + u32 sw_if_index[VLIB_N_RX_TX]; + + /* Node where stream's buffers get put. */ + u32 node_index; + + /* Output next index to reach output node from stream input node. */ + u32 next_index; + + /* Number of packets currently generated. */ + u64 n_packets_generated; + + /* Stream is disabled when packet limit is reached. + Zero means no packet limit. */ + u64 n_packets_limit; + + /* Rate for this stream in packets/second. + Zero means unlimited rate. */ + f64 rate_packets_per_second; + + f64 time_last_generate; + + f64 packet_accumulator; + + pg_buffer_index_t * buffer_indices; + + u8 ** replay_packet_templates; + u32 current_replay_packet_index; +} pg_stream_t; + +always_inline void +pg_buffer_index_free (pg_buffer_index_t * bi) +{ + vec_free (bi->edits); + clib_fifo_free (bi->buffer_fifo); +} + +always_inline void +pg_edit_group_free (pg_edit_group_t * g) +{ + pg_edit_t * e; + vec_foreach (e, g->edits) + pg_edit_free (e); + vec_free (g->edits); + vec_free (g->fixed_packet_data); + vec_free (g->fixed_packet_data_mask); +} + +always_inline void +pg_stream_free (pg_stream_t * s) +{ + pg_edit_group_t * g; + pg_edit_t * e; + vec_foreach (e, s->non_fixed_edits) + pg_edit_free (e); + vec_free (s->non_fixed_edits); + vec_foreach (g, s->edit_groups) + pg_edit_group_free (g); + vec_free (s->edit_groups); + vec_free (s->fixed_packet_data); + vec_free (s->fixed_packet_data_mask); + vec_free (s->name); + + { + pg_buffer_index_t * bi; + vec_foreach (bi, s->buffer_indices) + pg_buffer_index_free (bi); + vec_free (s->buffer_indices); + } +} + +always_inline int +pg_stream_is_enabled (pg_stream_t * s) +{ return (s->flags & PG_STREAM_FLAGS_IS_ENABLED) != 0; } + +always_inline pg_edit_group_t * +pg_stream_get_group (pg_stream_t * s, u32 group_index) +{ return vec_elt_at_index (s->edit_groups, group_index); } + +always_inline void * +pg_create_edit_group (pg_stream_t * s, + int n_edit_bytes, + int n_packet_bytes, + u32 * group_index) +{ + pg_edit_group_t * g; + int n_edits; + + vec_add2 (s->edit_groups, g, 1); + if (group_index) + *group_index = g - s->edit_groups; + + ASSERT (n_edit_bytes % sizeof (pg_edit_t) == 0); + n_edits = n_edit_bytes / sizeof (pg_edit_t); + vec_resize (g->edits, n_edits); + + g->n_packet_bytes = n_packet_bytes; + + return g->edits; +} + +always_inline void * +pg_add_edits (pg_stream_t * s, int n_edit_bytes, int n_packet_bytes, + u32 group_index) +{ + pg_edit_group_t * g = pg_stream_get_group (s, group_index); + pg_edit_t * e; + int n_edits; + ASSERT (n_edit_bytes % sizeof (pg_edit_t) == 0); + n_edits = n_edit_bytes / sizeof (pg_edit_t); + vec_add2 (g->edits, e, n_edits); + g->n_packet_bytes += n_packet_bytes; + return e; +} + +always_inline void * +pg_get_edit_group (pg_stream_t * s, u32 group_index) +{ + pg_edit_group_t * g = pg_stream_get_group (s, group_index); + return g->edits; +} + +/* Number of bytes for all groups >= given group. */ +always_inline uword +pg_edit_group_n_bytes (pg_stream_t * s, u32 group_index) +{ + pg_edit_group_t * g; + uword n_bytes = 0; + + for (g = s->edit_groups + group_index; g < vec_end (s->edit_groups); g++) + n_bytes += g->n_packet_bytes; + return n_bytes; +} + +always_inline void +pg_free_edit_group (pg_stream_t * s) +{ + uword i = vec_len (s->edit_groups) - 1; + pg_edit_group_t * g = pg_stream_get_group (s, i); + + pg_edit_group_free (g); + memset (g, 0, sizeof (g[0])); + _vec_len (s->edit_groups) = i; +} + +typedef struct { + /* VLIB interface indices. */ + u32 hw_if_index, sw_if_index; + + /* Identifies stream for this interface. */ + u32 stream_index; +} pg_interface_t; + +/* Per VLIB node data. */ +typedef struct { + /* Parser function indexed by node index. */ + unformat_function_t * unformat_edit; +} pg_node_t; + +typedef struct pg_main_t { + /* Back pointer to main structure. */ + vlib_main_t * vlib_main; + + /* Pool of streams. */ + pg_stream_t * streams; + + /* Bitmap indicating which streams are currently enabled. */ + uword * enabled_streams; + + /* Hash mapping name -> stream index. */ + uword * stream_index_by_name; + + /* Vector of interfaces. */ + pg_interface_t * interfaces; + + /* Per VLIB node information. */ + pg_node_t * nodes; + + u32 * free_interfaces; +} pg_main_t; + +/* Global main structure. */ +extern pg_main_t pg_main; + +/* Global node. */ +extern vlib_node_registration_t pg_input_node; + +/* Buffer generator input, output node functions. */ +vlib_node_function_t pg_input, pg_output; + +/* Stream add/delete. */ +void pg_stream_del (pg_main_t * pg, uword index); +void pg_stream_add (pg_main_t * pg, pg_stream_t * s_init); + +/* Enable/disable stream. */ +void pg_stream_enable_disable (pg_main_t * pg, pg_stream_t * s, int is_enable); + +/* Find/create free packet-generator interface index. */ +u32 pg_interface_find_free (pg_main_t * pg, uword stream_index); + +always_inline pg_node_t * +pg_get_node (uword node_index) +{ + pg_main_t * pg = &pg_main; + vec_validate (pg->nodes, node_index); + return pg->nodes + node_index; +} + +void pg_edit_group_get_fixed_packet_data (pg_stream_t * s, + u32 group_index, + void * fixed_packet_data, + void * fixed_packet_data_mask); + +#endif /* included_vlib_pg_h */ diff --git a/vnet/vnet/pg/stream.c b/vnet/vnet/pg/stream.c new file mode 100644 index 00000000000..1dd5624338f --- /dev/null +++ b/vnet/vnet/pg/stream.c @@ -0,0 +1,420 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * pg_stream.c: packet generator streams + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> + +/* Mark stream active or inactive. */ +void pg_stream_enable_disable (pg_main_t * pg, pg_stream_t * s, int want_enabled) +{ + vnet_main_t * vnm = vnet_get_main(); + pg_interface_t * pi = vec_elt_at_index (pg->interfaces, s->pg_if_index); + + want_enabled = want_enabled != 0; + + if (pg_stream_is_enabled (s) == want_enabled) + /* No change necessary. */ + return; + + if (want_enabled) + s->n_packets_generated = 0; + + /* Toggle enabled flag. */ + s->flags ^= PG_STREAM_FLAGS_IS_ENABLED; + + ASSERT (! pool_is_free (pg->streams, s)); + + pg->enabled_streams + = clib_bitmap_set (pg->enabled_streams, s - pg->streams, want_enabled); + + vnet_hw_interface_set_flags (vnm, pi->hw_if_index, + (want_enabled + ? VNET_HW_INTERFACE_FLAG_LINK_UP + : 0)); + + vnet_sw_interface_set_flags (vnm, pi->sw_if_index, + (want_enabled + ? VNET_SW_INTERFACE_FLAG_ADMIN_UP + : 0)); + + vlib_node_set_state (pg->vlib_main, + pg_input_node.index, + (clib_bitmap_is_zero (pg->enabled_streams) + ? VLIB_NODE_STATE_DISABLED + : VLIB_NODE_STATE_POLLING)); + + s->packet_accumulator = 0; + s->time_last_generate = 0; +} + +static u8 * format_pg_interface_name (u8 * s, va_list * args) +{ + pg_main_t * pg = &pg_main; + u32 if_index = va_arg (*args, u32); + pg_interface_t * pi; + + pi = vec_elt_at_index (pg->interfaces, if_index); + s = format (s, "pg/stream-%d", pi->stream_index); + + return s; +} + +VNET_DEVICE_CLASS (pg_dev_class,static) = { + .name = "pg", + .tx_function = pg_output, + .format_device_name = format_pg_interface_name, +}; + +static uword pg_set_rewrite (vnet_main_t * vnm, + u32 sw_if_index, + u32 l3_type, + void * dst_address, + void * rewrite, + uword max_rewrite_bytes) +{ + u16 * h = rewrite; + + if (max_rewrite_bytes < sizeof (h[0])) + return 0; + + h[0] = clib_host_to_net_u16 (l3_type); + return sizeof (h[0]); +} + +VNET_HW_INTERFACE_CLASS (pg_interface_class,static) = { + .name = "Packet generator", + .set_rewrite = pg_set_rewrite, +}; + +u32 pg_interface_find_free (pg_main_t * pg, uword stream_index) +{ + vnet_main_t * vnm = vnet_get_main(); + pg_interface_t * pi; + vnet_hw_interface_t * hi; + u32 i, l; + + if ((l = vec_len (pg->free_interfaces)) > 0) + { + i = pg->free_interfaces[l - 1]; + _vec_len (pg->free_interfaces) = l - 1; + pi = vec_elt_at_index (pg->interfaces, i); + pi->stream_index = stream_index; + } + else + { + i = vec_len (pg->interfaces); + vec_add2 (pg->interfaces, pi, 1); + + pi->stream_index = stream_index; + pi->hw_if_index = vnet_register_interface (vnm, + pg_dev_class.index, i, + pg_interface_class.index, stream_index); + hi = vnet_get_hw_interface (vnm, pi->hw_if_index); + pi->sw_if_index = hi->sw_if_index; + } + + return i; +} + +static void do_edit (pg_stream_t * stream, + pg_edit_group_t * g, + pg_edit_t * e, + uword want_commit) +{ + u32 i, i0, i1, mask, n_bits_left; + u8 * v, * s, * m; + + i0 = e->lsb_bit_offset / BITS (u8); + + /* Make space for edit in value and mask. */ + vec_validate (g->fixed_packet_data, i0); + vec_validate (g->fixed_packet_data_mask, i0); + + if (e->type != PG_EDIT_FIXED) + { + switch (e->type) + { + case PG_EDIT_RANDOM: + case PG_EDIT_INCREMENT: + e->last_increment_value = pg_edit_get_value (e, PG_EDIT_LO); + break; + + default: + break; + } + + if (want_commit) + { + ASSERT(e->type != PG_EDIT_INVALID_TYPE); + vec_add1 (g->non_fixed_edits, e[0]); + } + return; + } + + s = g->fixed_packet_data; + m = g->fixed_packet_data_mask; + + n_bits_left = e->n_bits; + i0 = e->lsb_bit_offset / BITS (u8); + i1 = e->lsb_bit_offset % BITS (u8); + + v = e->values[PG_EDIT_LO]; + i = pg_edit_n_alloc_bytes (e) - 1; + + /* Odd low order bits?. */ + if (i1 != 0 && n_bits_left > 0) + { + u32 n = clib_min (n_bits_left, BITS (u8) - i1); + + mask = pow2_mask (n) << i1; + + ASSERT (i0 < vec_len (s)); + ASSERT (i < vec_len (v)); + ASSERT ((v[i] &~ mask) == 0); + + s[i0] |= v[i] & mask; + m[i0] |= mask; + + i0--; + i--; + n_bits_left -= n; + } + + /* Even bytes. */ + while (n_bits_left >= 8) + { + ASSERT (i0 < vec_len (s)); + ASSERT (i < vec_len (v)); + + s[i0] = v[i]; + m[i0] = ~0; + + i0--; + i--; + n_bits_left -= 8; + } + + /* Odd high order bits. */ + if (n_bits_left > 0) + { + mask = pow2_mask (n_bits_left); + + ASSERT (i0 < vec_len (s)); + ASSERT (i < vec_len (v)); + ASSERT ((v[i] &~ mask) == 0); + + s[i0] |= v[i] & mask; + m[i0] |= mask; + } + + if (want_commit) + pg_edit_free (e); +} + +void pg_edit_group_get_fixed_packet_data (pg_stream_t * s, + u32 group_index, + void * packet_data, + void * packet_data_mask) +{ + pg_edit_group_t * g = pg_stream_get_group (s, group_index); + pg_edit_t * e; + + vec_foreach (e, g->edits) + do_edit (s, g, e, /* want_commit */ 0); + + memcpy (packet_data, g->fixed_packet_data, vec_len (g->fixed_packet_data)); + memcpy (packet_data_mask, g->fixed_packet_data_mask, vec_len (g->fixed_packet_data_mask)); +} + +static void perform_fixed_edits (pg_stream_t * s) +{ + pg_edit_group_t * g; + pg_edit_t * e; + word i; + + for (i = vec_len (s->edit_groups) - 1; i >= 0; i--) + { + g = vec_elt_at_index (s->edit_groups, i); + vec_foreach (e, g->edits) + do_edit (s, g, e, /* want_commit */ 1); + + /* All edits have either been performed or added to + g->non_fixed_edits. So, we can delete the vector. */ + vec_free (g->edits); + } + + vec_free (s->fixed_packet_data_mask); + vec_free (s->fixed_packet_data); + vec_foreach (g, s->edit_groups) + { + int i; + g->start_byte_offset = vec_len (s->fixed_packet_data); + + /* Relocate and copy non-fixed edits from group to stream. */ + vec_foreach (e, g->non_fixed_edits) + e->lsb_bit_offset += g->start_byte_offset * BITS (u8); + + for (i = 0; i < vec_len (g->non_fixed_edits); i++) + ASSERT(g->non_fixed_edits[i].type != PG_EDIT_INVALID_TYPE); + + vec_add (s->non_fixed_edits, + g->non_fixed_edits, + vec_len (g->non_fixed_edits)); + vec_free (g->non_fixed_edits); + + vec_add (s->fixed_packet_data, + g->fixed_packet_data, + vec_len (g->fixed_packet_data)); + vec_add (s->fixed_packet_data_mask, + g->fixed_packet_data_mask, + vec_len (g->fixed_packet_data_mask)); + } +} + +void pg_stream_add (pg_main_t * pg, pg_stream_t * s_init) +{ + vlib_main_t * vm = pg->vlib_main; + pg_stream_t * s; + uword * p; + + if (! pg->stream_index_by_name) + pg->stream_index_by_name + = hash_create_vec (0, sizeof (s->name[0]), sizeof (uword)); + + /* Delete any old stream with the same name. */ + if (s_init->name + && (p = hash_get_mem (pg->stream_index_by_name, s_init->name))) + { + pg_stream_del (pg, p[0]); + } + + pool_get (pg->streams, s); + s[0] = s_init[0]; + + /* Give it a name. */ + if (! s->name) + s->name = format (0, "stream%d", s - pg->streams); + else + s->name = vec_dup (s->name); + + hash_set_mem (pg->stream_index_by_name, s->name, s - pg->streams); + + /* Get fixed part of buffer data. */ + perform_fixed_edits (s); + + /* Determine packet size. */ + switch (s->packet_size_edit_type) + { + case PG_EDIT_INCREMENT: + case PG_EDIT_RANDOM: + if (s->min_packet_bytes == s->max_packet_bytes) + s->packet_size_edit_type = PG_EDIT_FIXED; + break; + + default: + /* Get packet size from fixed edits. */ + s->packet_size_edit_type = PG_EDIT_FIXED; + if (! s->replay_packet_templates) + s->min_packet_bytes = s->max_packet_bytes = vec_len (s->fixed_packet_data); + break; + } + + s->last_increment_packet_size = s->min_packet_bytes; + + { + pg_buffer_index_t * bi; + int n; + + if (! s->buffer_bytes) + s->buffer_bytes = s->max_packet_bytes; + + s->buffer_bytes = vlib_buffer_round_size (s->buffer_bytes); + + n = s->max_packet_bytes / s->buffer_bytes; + n += (s->max_packet_bytes % s->buffer_bytes) != 0; + + vec_resize (s->buffer_indices, n); + + vec_foreach (bi, s->buffer_indices) + bi->free_list_index = vlib_buffer_create_free_list (vm, s->buffer_bytes, + "pg stream %d buffer #%d", + s - pg->streams, + 1 + (bi - s->buffer_indices)); + } + + /* Find an interface to use. */ + s->pg_if_index = pg_interface_find_free (pg, s - pg->streams); + + { + pg_interface_t * pi = vec_elt_at_index (pg->interfaces, s->pg_if_index); + vlib_rx_or_tx_t rx_or_tx; + + vlib_foreach_rx_tx (rx_or_tx) + { + if (s->sw_if_index[rx_or_tx] == ~0) + s->sw_if_index[rx_or_tx] = pi->sw_if_index; + } + } + + /* Connect the graph. */ + s->next_index = vlib_node_add_next (vm, pg_input_node.index, s->node_index); +} + +void pg_stream_del (pg_main_t * pg, uword index) +{ + vlib_main_t * vm = pg->vlib_main; + pg_stream_t * s; + pg_buffer_index_t * bi; + + s = pool_elt_at_index (pg->streams, index); + + pg_stream_enable_disable (pg, s, /* want_enabled */ 0); + vec_add1 (pg->free_interfaces, s->pg_if_index); + hash_unset_mem (pg->stream_index_by_name, s->name); + + vec_foreach (bi, s->buffer_indices) + { + vlib_buffer_delete_free_list (vm, bi->free_list_index); + clib_fifo_free (bi->buffer_fifo); + } + + pg_stream_free (s); + pool_put (pg->streams, s); +} + |