diff options
Diffstat (limited to 'vpp/vnet/vnet/pg')
| -rw-r--r-- | vpp/vnet/vnet/pg/cli.c | 636 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/edit.c | 186 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/edit.h | 210 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/example.script | 6 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/init.c | 72 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/input.c | 1667 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/output.c | 85 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/pg.h | 383 | ||||
| -rw-r--r-- | vpp/vnet/vnet/pg/stream.c | 497 |
9 files changed, 3742 insertions, 0 deletions
diff --git a/vpp/vnet/vnet/pg/cli.c b/vpp/vnet/vnet/pg/cli.c new file mode 100644 index 00000000..f5896b43 --- /dev/null +++ b/vpp/vnet/vnet/pg/cli.c @@ -0,0 +1,636 @@ +/* + * 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 <sys/stat.h> + +#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. */ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (vlib_cli_pg_command, static) = { + .path = "packet-generator", + .short_help = "Packet generator commands", +}; +/* *INDENT-ON* */ + +void +pg_enable_disable (u32 stream_index, int is_enable) +{ + pg_main_t *pg = &pg_main; + pg_stream_t *s; + + if (stream_index == ~0) + { + /* No stream specified: enable/disable all streams. */ + /* *INDENT-OFF* */ + pool_foreach (s, pg->streams, ({ + pg_stream_enable_disable (pg, s, is_enable); + })); + /* *INDENT-ON* */ + } + else + { + /* enable/disable specified stream. */ + s = pool_elt_at_index (pg->streams, stream_index); + pg_stream_enable_disable (pg, s, is_enable); + } +} + +clib_error_t * +pg_capture (pg_capture_args_t * a) +{ + pg_main_t *pg = &pg_main; + pg_interface_t *pi; + + if (a->is_enabled == 1) + { + struct stat sb; + if (stat ((char *) a->pcap_file_name, &sb) != -1) + return clib_error_return (0, "Cannot create pcap file"); + } + + pi = pool_elt_at_index (pg->interfaces, a->dev_instance); + vec_free (pi->pcap_file_name); + memset (&pi->pcap_main, 0, sizeof (pi->pcap_main)); + + if (a->is_enabled == 0) + return 0; + + pi->pcap_file_name = a->pcap_file_name; + pi->pcap_main.file_name = (char *) pi->pcap_file_name; + pi->pcap_main.n_packets_to_capture = a->count; + pi->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet; + + return 0; +} + +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; + 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); + + pg_enable_disable (stream_index, is_enable); + + return 0; +} + +/* *INDENT-OFF* */ +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 */ +}; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +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 */ +}; +/* *INDENT-ON* */ + +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); + + v = format (v, "worker %d, ", t->worker_index); + + 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); + /* *INDENT-OFF* */ + pool_foreach (s, pg->streams, ({ + vlib_cli_output (vm, "%U", format_pg_stream, s); + })); + /* *INDENT-ON* */ + +done: + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_streams_cli, static) = { + .path = "show packet-generator", + .short_help = "Show packet generator streams", + .function = show_streams, +}; +/* *INDENT-ON* */ + +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; + + if (s->n_packets_limit == 0) + s->n_packets_limit = vec_len (pm.packets_read); + + 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; + s.if_id = 0; + 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, "source pg%u", &s.if_id)) + ; + + else if (unformat (input, "node %U", + unformat_vlib_node, vm, &s.node_index)) + ; + + else if (unformat (input, "worker %u", &s.worker_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) + { + if (pcap_file_name != 0) + { + vlib_node_t *n = + vlib_get_node_by_name (vm, (u8 *) "ethernet-input"); + s.node_index = n->index; + } + else + { + 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 (s.worker_index >= vlib_num_workers ()) + s.worker_index = 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; +} + +/* *INDENT-OFF* */ +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" + "pcap FILENAME read packet data from pcap file\n", +}; +/* *INDENT-ON* */ + +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; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (del_stream_cli, static) = { + .path = "packet-generator delete", + .function = del_stream, + .short_help = "Delete stream with given name", +}; +/* *INDENT-ON* */ + +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; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = { + .path = "packet-generator configure", + .short_help = "Change packet generator stream parameters", + .function = change_stream_parameters, +}; +/* *INDENT-ON* */ + +static clib_error_t * +pg_capture_cmd_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + clib_error_t *error = 0; + vnet_main_t *vnm = vnet_get_main (); + unformat_input_t _line_input, *line_input = &_line_input; + vnet_hw_interface_t *hi = 0; + u8 *pcap_file_name = 0; + u32 hw_if_index; + u32 is_disable = 0; + u32 count = ~0; + + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "%U", + unformat_vnet_hw_interface, vnm, &hw_if_index)) + { + hi = vnet_get_hw_interface (vnm, hw_if_index); + } + + else if (unformat (line_input, "pcap %s", &pcap_file_name)) + ; + else if (unformat (line_input, "count %u", &count)) + ; + else if (unformat (line_input, "disable")) + is_disable = 1; + + else + { + error = clib_error_create ("unknown input `%U'", + format_unformat_error, input); + return error; + } + } + + if (!hi) + return clib_error_return (0, "Please specify interface name"); + + if (hi->dev_class_index != pg_dev_class.index) + return clib_error_return (0, "Please specify packet-generator interface"); + + if (!pcap_file_name && is_disable == 0) + return clib_error_return (0, "Please specify pcap file name"); + + unformat_free (line_input); + + pg_capture_args_t _a, *a = &_a; + + a->hw_if_index = hw_if_index; + a->dev_instance = hi->dev_instance; + a->is_enabled = !is_disable; + a->pcap_file_name = pcap_file_name; + a->count = count; + + error = pg_capture (a); + return error; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (pg_capture_cmd, static) = { + .path = "packet-generator capture", + .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]", + .function = pg_capture_cmd_fn, +}; +/* *INDENT-ON* */ + +static clib_error_t * +create_pg_if_cmd_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + pg_main_t *pg = &pg_main; + unformat_input_t _line_input, *line_input = &_line_input; + u32 if_id; + + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "interface pg%u", &if_id)) + ; + + else + return clib_error_create ("unknown input `%U'", + format_unformat_error, input); + } + + unformat_free (line_input); + + pg_interface_add_or_get (pg, if_id); + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (create_pg_if_cmd, static) = { + .path = "create packet-generator", + .short_help = "create packet-generator interface <interface name>", + .function = create_pg_if_cmd_fn, +}; +/* *INDENT-ON* */ + +/* 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); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/edit.c b/vpp/vnet/vnet/pg/edit.c new file mode 100644 index 00000000..cb4d070f --- /dev/null +++ b/vpp/vnet/vnet/pg/edit.c @@ -0,0 +1,186 @@ +/* + * 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 *); + vlib_main_t *vm = vlib_get_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; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/edit.h b/vpp/vnet/vnet/pg/edit.h new file mode 100644 index 00000000..3bfdad57 --- /dev/null +++ b/vpp/vnet/vnet/pg/edit.h @@ -0,0 +1,210 @@ +/* + * 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 */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/example.script b/vpp/vnet/vnet/pg/example.script new file mode 100644 index 00000000..0e29b9ec --- /dev/null +++ b/vpp/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/vpp/vnet/vnet/pg/init.c b/vpp/vnet/vnet/pg/init.c new file mode 100644 index 00000000..631be25e --- /dev/null +++ b/vpp/vnet/vnet/pg/init.c @@ -0,0 +1,72 @@ +/* + * 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; + + pg->if_index_by_if_id = hash_create (0, sizeof (uword)); + + if ((error = vlib_call_init_function (vm, vnet_main_init))) + goto done; + + if ((error = vlib_call_init_function (vm, pg_cli_init))) + goto done; + +done: + return error; +} + +VLIB_INIT_FUNCTION (pg_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/input.c b/vpp/vnet/vnet/pg/input.c new file mode 100644 index 00000000..e15faeb8 --- /dev/null +++ b/vpp/vnet/vnet/pg/input.c @@ -0,0 +1,1667 @@ +/* + * 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> +#include <vnet/feature/feature.h> +#include <vnet/devices/devices.h> + +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 = vlib_get_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 = vlib_get_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 = vlib_get_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 = vlib_get_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 = vlib_get_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 = vlib_get_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); + } + +} + +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 = vlib_get_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 = vlib_get_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; + + 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 * 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) + { + clib_memcpy (b0->data, data, n_data); + clib_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) + clib_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 = vlib_get_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); + + 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 */ + } + + 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 = vlib_get_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); + + 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 (t0->buffer.pre_data, b0->data, + sizeof (t0->buffer.pre_data)); + clib_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); + 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)); + } +} + +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 = vlib_get_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; + u32 next_index = s->next_index; + vnet_feature_main_t *fm = &feature_main; + vnet_feature_config_main_t *cm; + u8 feature_arc_index = fm->device_input_feature_arc_index; + cm = &fm->feature_config_mains[feature_arc_index]; + u32 current_config_index = ~(u32) 0; + int i; + + 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; + + if (PREDICT_FALSE + (vnet_have_features (feature_arc_index, s->sw_if_index[VLIB_RX]))) + { + current_config_index = + vec_elt (cm->config_index_by_sw_if_index, s->sw_if_index[VLIB_RX]); + vnet_get_config_data (&cm->config_main, ¤t_config_index, + &next_index, 0); + } + + while (n_packets_to_generate > 0) + { + u32 *head, *start, *end; + + 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) + 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); + + 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; + b->feature_arc_index = feature_arc_index; + } + + 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, 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 = vlib_get_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; + u32 worker_index = 0; + + if (vlib_num_workers ()) + worker_index = vlib_get_current_worker_index (); + + /* *INDENT-OFF* */ + clib_bitmap_foreach (i, pg->enabled_streams[worker_index], ({ + pg_stream_t *s = vec_elt_at_index (pg->streams, i); + n_packets += pg_input_stream (node, pg, s); + })); + /* *INDENT-ON* */ + + return n_packets; +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (pg_input_node) = { + .function = pg_input, + .name = "pg-input", + .sibling_of = "device-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, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/output.c b/vpp/vnet/vnet/pg/output.c new file mode 100644 index 00000000..3d1f2660 --- /dev/null +++ b/vpp/vnet/vnet/pg/output.c @@ -0,0 +1,85 @@ +/* + * 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/vnet.h> +#include <vnet/pg/pg.h> +#include <vnet/ethernet/ethernet.h> + +uword +pg_output (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + pg_main_t *pg = &pg_main; + u32 *buffers = vlib_frame_args (frame); + uword n_buffers = frame->n_vectors; + uword n_left = n_buffers; + vnet_interface_output_runtime_t *rd = (void *) node->runtime_data; + pg_interface_t *pif = pool_elt_at_index (pg->interfaces, rd->dev_instance); + + if (PREDICT_FALSE (pif->lockp != 0)) + while (__sync_lock_test_and_set (pif->lockp, 1)) + ; + + if (pif->pcap_file_name != 0) + { + while (n_left > 0) + { + n_left--; + u32 bi0 = buffers[0]; + buffers++; + + pcap_add_buffer (&pif->pcap_main, vm, bi0, + ETHERNET_MAX_PACKET_BYTES); + } + pcap_write (&pif->pcap_main); + } + + vlib_buffer_free (vm, vlib_frame_args (frame), n_buffers); + if (PREDICT_FALSE (pif->lockp != 0)) + *pif->lockp = 0; + return n_buffers; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/pg.h b/vpp/vnet/vnet/pg/pg.h new file mode 100644 index 00000000..a4027834 --- /dev/null +++ b/vpp/vnet/vnet/pg/pg.h @@ -0,0 +1,383 @@ +/* + * 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 */ +#include <vnet/unix/pcap.h> +#include <vnet/interface.h> + +extern vnet_device_class_t pg_dev_class; + +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; + + /* Worker thread index */ + u32 worker_index; + + /* Output next index to reach output node from stream input node. */ + u32 next_index; + + u32 if_id; + + /* 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 +{ + /* TX lock */ + volatile u32 *lockp; + + /* VLIB interface indices. */ + u32 hw_if_index, sw_if_index; + + /* Identifies stream for this interface. */ + u32 id; + + pcap_main_t pcap_main; + u8 *pcap_file_name; +} 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 +{ + /* 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; + + /* Pool of interfaces. */ + pg_interface_t *interfaces; + uword *if_index_by_if_id; + + /* Per VLIB node information. */ + pg_node_t *nodes; +} 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_add_or_get (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); + +void pg_enable_disable (u32 stream_index, int is_enable); + +typedef struct +{ + u32 hw_if_index; + u32 dev_instance; + u8 is_enabled; + u8 *pcap_file_name; + u32 count; +} pg_capture_args_t; + +clib_error_t *pg_capture (pg_capture_args_t * a); + +#endif /* included_vlib_pg_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vnet/vnet/pg/stream.c b/vpp/vnet/vnet/pg/stream.c new file mode 100644 index 00000000..1ed7189f --- /dev/null +++ b/vpp/vnet/vnet/pg/stream.c @@ -0,0 +1,497 @@ +/* + * 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> +#include <vnet/ethernet/ethernet.h> +#include <vnet/ip/ip.h> +#include <vnet/mpls/mpls.h> +#include <vnet/devices/devices.h> + +/* Mark stream active or inactive. */ +void +pg_stream_enable_disable (pg_main_t * pg, pg_stream_t * s, int want_enabled) +{ + vlib_main_t *vm; + vnet_main_t *vnm = vnet_get_main (); + pg_interface_t *pi = pool_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)); + + vec_validate (pg->enabled_streams, s->worker_index); + pg->enabled_streams[s->worker_index] = + clib_bitmap_set (pg->enabled_streams[s->worker_index], s - pg->streams, + want_enabled); + + if (want_enabled) + { + vnet_hw_interface_set_flags (vnm, pi->hw_if_index, + VNET_HW_INTERFACE_FLAG_LINK_UP); + + vnet_sw_interface_set_flags (vnm, pi->sw_if_index, + VNET_SW_INTERFACE_FLAG_ADMIN_UP); + } + + if (vlib_num_workers ()) + vm = vlib_get_worker_vlib_main (s->worker_index); + else + vm = vlib_get_main (); + + vlib_node_set_state (vm, pg_input_node.index, + (clib_bitmap_is_zero + (pg->enabled_streams[s->worker_index]) ? + 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 = pool_elt_at_index (pg->interfaces, if_index); + s = format (s, "pg%d", pi->id); + + return s; +} + +static clib_error_t * +pg_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags) +{ + u32 hw_flags = 0; + + if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) + hw_flags = VNET_HW_INTERFACE_FLAG_LINK_UP; + + vnet_hw_interface_set_flags (vnm, hw_if_index, hw_flags); + + return 0; +} + +/* *INDENT-OFF* */ +VNET_DEVICE_CLASS (pg_dev_class) = { + .name = "pg", + .tx_function = pg_output, + .format_device_name = format_pg_interface_name, + .admin_up_down_function = pg_interface_admin_up_down, +}; +/* *INDENT-ON* */ + +static u8 * +pg_build_rewrite (vnet_main_t * vnm, + u32 sw_if_index, + vnet_link_t link_type, const void *dst_address) +{ + u8 *rewrite = NULL; + u16 *h; + + vec_validate (rewrite, sizeof (*h) - 1); + h = (u16 *) rewrite; + h[0] = clib_host_to_net_u16 (vnet_link_to_l3_proto (link_type)); + + return (rewrite); +} + +/* *INDENT-OFF* */ +VNET_HW_INTERFACE_CLASS (pg_interface_class,static) = { + .name = "Packet generator", + .build_rewrite = pg_build_rewrite, +}; +/* *INDENT-ON* */ + +static u32 +pg_eth_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags) +{ + /* nothing for now */ + return 0; +} + +u32 +pg_interface_add_or_get (pg_main_t * pg, uword if_id) +{ + vnet_main_t *vnm = vnet_get_main (); + vlib_main_t *vm = vlib_get_main (); + pg_interface_t *pi; + vnet_hw_interface_t *hi; + uword *p; + u32 i; + + p = hash_get (pg->if_index_by_if_id, if_id); + + if (p) + { + return p[0]; + } + else + { + u8 hw_addr[6]; + f64 now = vlib_time_now (vm); + u32 rnd; + + pool_get (pg->interfaces, pi); + i = pi - pg->interfaces; + + rnd = (u32) (now * 1e6); + rnd = random_u32 (&rnd); + clib_memcpy (hw_addr + 2, &rnd, sizeof (rnd)); + hw_addr[0] = 2; + hw_addr[1] = 0xfe; + + pi->id = if_id; + ethernet_register_interface (vnm, pg_dev_class.index, i, hw_addr, + &pi->hw_if_index, pg_eth_flag_change); + hi = vnet_get_hw_interface (vnm, pi->hw_if_index); + pi->sw_if_index = hi->sw_if_index; + + hash_set (pg->if_index_by_if_id, if_id, i); + + if (vlib_num_workers ()) + { + pi->lockp = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, + CLIB_CACHE_LINE_BYTES); + *pi->lockp = 0; + } + + ip4_sw_interface_enable_disable (pi->hw_if_index, 1); + ip6_sw_interface_enable_disable (pi->hw_if_index, 1); + mpls_sw_interface_enable_disable (&mpls_main, pi->hw_if_index, 1); + } + + 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); + + clib_memcpy (packet_data, g->fixed_packet_data, + vec_len (g->fixed_packet_data)); + clib_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 = vlib_get_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. */ + if (s->edit_groups) + 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 DPDK > 0 + s->buffer_bytes = VLIB_BUFFER_DATA_SIZE; +#endif + + 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_add_or_get (pg, s->if_id); + + { + pg_interface_t *pi = pool_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, device_input_node.index, + s->node_index); +} + +void +pg_stream_del (pg_main_t * pg, uword index) +{ + vlib_main_t *vm = vlib_get_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); + 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); +} + + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |