2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 * pg_cli.c: packet generator cli
18 * Copyright (c) 2008 Eliot Dresselhaus
20 * Permission is hereby granted, free of charge, to any person obtaining
21 * a copy of this software and associated documentation files (the
22 * "Software"), to deal in the Software without restriction, including
23 * without limitation the rights to use, copy, modify, merge, publish,
24 * distribute, sublicense, and/or sell copies of the Software, and to
25 * permit persons to whom the Software is furnished to do so, subject to
26 * the following conditions:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
31 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
42 #include <vnet/vnet.h>
43 #include <vnet/pg/pg.h>
46 #include <vnet/unix/pcap.h>
49 /* Root of all packet generator cli commands. */
50 VLIB_CLI_COMMAND (vlib_cli_pg_command, static) = {
51 .path = "packet-generator",
52 .short_help = "Packet generator commands",
55 void pg_enable_disable (u32 stream_index, int is_enable)
57 pg_main_t * pg = &pg_main;
60 if (stream_index == ~0) {
61 /* No stream specified: enable/disable all streams. */
62 pool_foreach (s, pg->streams, ({
63 pg_stream_enable_disable (pg, s, is_enable);
68 /* enable/disable specified stream. */
69 s = pool_elt_at_index (pg->streams, stream_index);
70 pg_stream_enable_disable (pg, s, is_enable);
74 clib_error_t * pg_capture (pg_capture_args_t *a)
76 pg_main_t * pg = &pg_main;
79 if (a->is_enabled == 1)
82 if (stat ((char *) a->pcap_file_name, &sb) != -1)
83 return clib_error_return (0, "Cannot create pcap file");
86 pi = pool_elt_at_index (pg->interfaces, a->dev_instance);
87 vec_free (pi->pcap_file_name);
88 memset (&pi->pcap_main, 0, sizeof (pi->pcap_main));
90 if (a->is_enabled == 0)
93 pi->pcap_file_name = a->pcap_file_name;
94 pi->pcap_main.file_name = (char *) pi->pcap_file_name;
95 pi->pcap_main.n_packets_to_capture = a->count;
96 pi->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
101 static clib_error_t *
102 enable_disable_stream (vlib_main_t * vm,
103 unformat_input_t * input,
104 vlib_cli_command_t * cmd)
106 pg_main_t * pg = &pg_main;
107 int is_enable = cmd->function_arg != 0;
108 u32 stream_index = ~0;
110 if (unformat (input, "%U", unformat_eof))
112 else if (unformat (input, "%U", unformat_hash_vec_string,
113 pg->stream_index_by_name, &stream_index))
116 return clib_error_create ("unknown input `%U'",
117 format_unformat_error, input);
119 pg_enable_disable (stream_index, is_enable);
124 VLIB_CLI_COMMAND (enable_streams_cli, static) = {
125 .path = "packet-generator enable-stream",
126 .short_help = "Enable packet generator streams",
127 .function = enable_disable_stream,
128 .function_arg = 1, /* is_enable */
131 VLIB_CLI_COMMAND (disable_streams_cli, static) = {
132 .path = "packet-generator disable-stream",
133 .short_help = "Disable packet generator streams",
134 .function = enable_disable_stream,
135 .function_arg = 0, /* is_enable */
138 static u8 * format_pg_stream (u8 * s, va_list * va)
140 pg_stream_t * t = va_arg (*va, pg_stream_t *);
144 return format (s, "%=16s%=12s%=16s%s",
145 "Name", "Enabled", "Count", "Parameters");
147 s = format (s, "%-16v%=12s%16Ld",
149 pg_stream_is_enabled (t) ? "Yes" : "No",
150 t->n_packets_generated);
154 v = format (v, "limit %Ld, ", t->n_packets_limit);
156 v = format (v, "rate %.2e pps, ", t->rate_packets_per_second);
158 v = format (v, "size %d%c%d, ",
160 t->packet_size_edit_type == PG_EDIT_RANDOM ? '+' : '-',
161 t->max_packet_bytes);
163 v = format (v, "buffer-size %d, ", t->buffer_bytes);
167 s = format (s, " %v", v);
174 static clib_error_t *
175 show_streams (vlib_main_t * vm,
176 unformat_input_t * input,
177 vlib_cli_command_t * cmd)
179 pg_main_t * pg = &pg_main;
182 if (pool_elts (pg->streams) == 0)
184 vlib_cli_output (vm, "no streams currently defined");
188 vlib_cli_output (vm, "%U", format_pg_stream, 0);
189 pool_foreach (s, pg->streams, ({
190 vlib_cli_output (vm, "%U", format_pg_stream, s);
197 VLIB_CLI_COMMAND (show_streams_cli, static) = {
198 .path = "show packet-generator",
199 .short_help = "Show packet generator streams",
200 .function = show_streams,
203 static clib_error_t *
204 pg_pcap_read (pg_stream_t * s, char * file_name)
207 return clib_error_return (0, "no pcap support");
210 clib_error_t * error;
211 memset (&pm, 0, sizeof (pm));
212 pm.file_name = file_name;
213 error = pcap_read (&pm);
214 s->replay_packet_templates = pm.packets_read;
215 s->min_packet_bytes = pm.min_packet_bytes;
216 s->max_packet_bytes = pm.max_packet_bytes;
217 s->buffer_bytes = pm.max_packet_bytes;
218 /* For PCAP buffers we never re-use buffers. */
219 s->flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE;
221 if (s->n_packets_limit == 0)
222 s->n_packets_limit = vec_len (pm.packets_read);
225 #endif /* CLIB_UNIX */
229 unformat_pg_stream_parameter (unformat_input_t * input, va_list * args)
231 pg_stream_t * s = va_arg (*args, pg_stream_t *);
234 if (unformat (input, "limit %f", &x))
235 s->n_packets_limit = x;
237 else if (unformat (input, "rate %f", &x))
238 s->rate_packets_per_second = x;
240 else if (unformat (input, "size %d-%d", &s->min_packet_bytes,
241 &s->max_packet_bytes))
242 s->packet_size_edit_type = PG_EDIT_INCREMENT;
244 else if (unformat (input, "size %d+%d", &s->min_packet_bytes,
245 &s->max_packet_bytes))
246 s->packet_size_edit_type = PG_EDIT_RANDOM;
248 else if (unformat (input, "buffer-size %d", &s->buffer_bytes))
257 static clib_error_t *
258 validate_stream (pg_stream_t * s)
260 if (s->max_packet_bytes < s->min_packet_bytes)
261 return clib_error_create ("max-size < min-size");
263 if (s->buffer_bytes >= 4096 || s->buffer_bytes == 0)
264 return clib_error_create ("buffer-size must be positive and < 4096, given %d",
267 if (s->rate_packets_per_second < 0)
268 return clib_error_create ("negative rate");
273 static clib_error_t *
274 new_stream (vlib_main_t * vm,
275 unformat_input_t * input,
276 vlib_cli_command_t * cmd)
278 clib_error_t * error = 0;
281 unformat_input_t sub_input = {0};
282 int sub_input_given = 0;
283 vnet_main_t * vnm = vnet_get_main();
284 pg_main_t * pg = &pg_main;
286 char * pcap_file_name;
288 s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0;
290 s.max_packet_bytes = s.min_packet_bytes = 64;
291 s.buffer_bytes = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES;
294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
296 if (unformat (input, "name %v", &tmp))
303 else if (unformat (input, "node %U",
304 unformat_vnet_hw_interface, vnm, &hw_if_index))
306 vnet_hw_interface_t * hi = vnet_get_hw_interface (vnm, hw_if_index);
308 s.node_index = hi->output_node_index;
309 s.sw_if_index[VLIB_TX] = hi->sw_if_index;
312 else if (unformat (input, "source pg%u",&s.if_id))
315 else if (unformat (input, "node %U",
316 unformat_vlib_node, vm, &s.node_index))
319 else if (unformat (input, "interface %U",
320 unformat_vnet_sw_interface, vnm, &s.sw_if_index[VLIB_RX]))
323 else if (unformat (input, "pcap %s", &pcap_file_name))
326 else if (! sub_input_given
327 && unformat (input, "data %U", unformat_input, &sub_input))
330 else if (unformat_user (input, unformat_pg_stream_parameter, &s))
333 else if (unformat (input, "no-recycle"))
334 s.flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE;
338 error = clib_error_create ("unknown input `%U'",
339 format_unformat_error, input);
344 error = validate_stream (&s);
348 if (! sub_input_given && ! pcap_file_name)
350 error = clib_error_create ("no packet data given");
354 if (s.node_index == ~0)
356 if (pcap_file_name != 0)
358 vlib_node_t * n = vlib_get_node_by_name(vm, (u8 *) "ethernet-input");
359 s.node_index = n->index;
363 error = clib_error_create ("output interface or node not given");
371 if (s.node_index < vec_len (pg->nodes))
372 n = pg->nodes + s.node_index;
376 if (pcap_file_name != 0)
378 error = pg_pcap_read (&s, pcap_file_name);
381 vec_free (pcap_file_name);
384 else if (n && n->unformat_edit
385 && unformat_user (&sub_input, n->unformat_edit, &s))
388 else if (! unformat_user (&sub_input, unformat_pg_payload, &s))
390 error = clib_error_create
391 ("failed to parse packet data from `%U'",
392 format_unformat_error, &sub_input);
397 pg_stream_add (pg, &s);
402 unformat_free (&sub_input);
406 VLIB_CLI_COMMAND (new_stream_cli, static) = {
407 .path = "packet-generator new",
408 .function = new_stream,
409 .short_help = "Create packet generator stream",
411 "Create packet generator stream\n"
415 "name STRING sets stream name\n"
416 "interface STRING interface for stream output \n"
417 "node NODE-NAME node for stream output\n"
418 "data STRING specifies packet data\n"
419 "pcap FILENAME read packet data from pcap file\n",
422 static clib_error_t *
423 del_stream (vlib_main_t * vm,
424 unformat_input_t * input,
425 vlib_cli_command_t * cmd)
427 pg_main_t * pg = &pg_main;
430 if (! unformat (input, "%U",
431 &unformat_hash_vec_string, pg->stream_index_by_name, &i))
432 return clib_error_create ("expected stream name `%U'",
433 format_unformat_error, input);
435 pg_stream_del (pg, i);
439 VLIB_CLI_COMMAND (del_stream_cli, static) = {
440 .path = "packet-generator delete",
441 .function = del_stream,
442 .short_help = "Delete stream with given name",
445 static clib_error_t *
446 change_stream_parameters (vlib_main_t * vm,
447 unformat_input_t * input,
448 vlib_cli_command_t * cmd)
450 pg_main_t * pg = &pg_main;
451 pg_stream_t * s, s_new;
452 u32 stream_index = ~0;
453 clib_error_t * error;
455 if (unformat (input, "%U", unformat_hash_vec_string,
456 pg->stream_index_by_name, &stream_index))
459 return clib_error_create ("expecting stream name; got `%U'",
460 format_unformat_error, input);
462 s = pool_elt_at_index (pg->streams, stream_index);
465 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
467 if (unformat_user (input, unformat_pg_stream_parameter, &s_new))
471 return clib_error_create ("unknown input `%U'",
472 format_unformat_error, input);
475 error = validate_stream (&s_new);
482 VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = {
483 .path = "packet-generator configure",
484 .short_help = "Change packet generator stream parameters",
485 .function = change_stream_parameters,
488 static clib_error_t *
489 pg_capture_cmd_fn (vlib_main_t * vm,
490 unformat_input_t * input,
491 vlib_cli_command_t * cmd)
493 clib_error_t * error = 0;
494 vnet_main_t * vnm = vnet_get_main();
495 unformat_input_t _line_input, * line_input = &_line_input;
496 vnet_hw_interface_t * hi = 0;
497 u8 * pcap_file_name = 0;
502 if (! unformat_user (input, unformat_line_input, line_input))
505 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
507 if (unformat (line_input, "%U",
508 unformat_vnet_hw_interface, vnm, &hw_if_index))
510 hi = vnet_get_hw_interface (vnm, hw_if_index);
513 else if (unformat (line_input, "pcap %s", &pcap_file_name))
515 else if (unformat (line_input, "count %u", &count))
517 else if (unformat (line_input, "disable"))
522 error = clib_error_create ("unknown input `%U'",
523 format_unformat_error, input);
529 return clib_error_return (0, "Please specify interface name");
531 if (hi->dev_class_index != pg_dev_class.index)
532 return clib_error_return (0, "Please specify packet-generator interface");
534 if (!pcap_file_name && is_disable == 0)
535 return clib_error_return (0, "Please specify pcap file name");
537 unformat_free (line_input);
539 pg_capture_args_t _a, *a=&_a;
541 a->hw_if_index = hw_if_index;
542 a->dev_instance = hi->dev_instance;
543 a->is_enabled = !is_disable;
544 a->pcap_file_name = pcap_file_name;
547 error = pg_capture (a);
551 VLIB_CLI_COMMAND (pg_capture_cmd, static) = {
552 .path = "packet-generator capture",
553 .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]",
554 .function = pg_capture_cmd_fn,
557 static clib_error_t *
558 create_pg_if_cmd_fn (vlib_main_t * vm,
559 unformat_input_t * input,
560 vlib_cli_command_t * cmd)
562 pg_main_t * pg = &pg_main;
563 unformat_input_t _line_input, * line_input = &_line_input;
566 if (! unformat_user (input, unformat_line_input, line_input))
569 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
571 if (unformat (line_input, "interface pg%u", &if_id))
575 return clib_error_create ("unknown input `%U'",
576 format_unformat_error, input);
579 unformat_free (line_input);
581 pg_interface_add_or_get (pg, if_id);
585 VLIB_CLI_COMMAND (create_pg_if_cmd, static) = {
586 .path = "create packet-generator",
587 .short_help = "create packet-generator interface <interface name>",
588 .function = create_pg_if_cmd_fn,
591 /* Dummy init function so that we can be linked in. */
592 static clib_error_t * pg_cli_init (vlib_main_t * vm)
595 VLIB_INIT_FUNCTION (pg_cli_init);