FD.io VPP  v19.01.1-17-ge106252
Vector Packet Processing
cli.c
Go to the documentation of this file.
1 /*
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:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
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.
14  */
15 /*
16  * pg_cli.c: packet generator cli
17  *
18  * Copyright (c) 2008 Eliot Dresselhaus
19  *
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:
27  *
28  * The above copyright notice and this permission notice shall be
29  * included in all copies or substantial portions of the Software.
30  *
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.
38  */
39 
40 #include <sys/stat.h>
41 
42 #include <vnet/vnet.h>
43 #include <vnet/pg/pg.h>
44 
45 #ifdef CLIB_UNIX
46 #include <vppinfra/pcap.h>
47 #endif
48 
49 /* Root of all packet generator cli commands. */
50 /* *INDENT-OFF* */
51 VLIB_CLI_COMMAND (vlib_cli_pg_command, static) = {
52  .path = "packet-generator",
53  .short_help = "Packet generator commands",
54 };
55 /* *INDENT-ON* */
56 
57 void
58 pg_enable_disable (u32 stream_index, int is_enable)
59 {
60  pg_main_t *pg = &pg_main;
61  pg_stream_t *s;
62 
63  if (stream_index == ~0)
64  {
65  /* No stream specified: enable/disable all streams. */
66  /* *INDENT-OFF* */
67  pool_foreach (s, pg->streams, ({
68  pg_stream_enable_disable (pg, s, is_enable);
69  }));
70  /* *INDENT-ON* */
71  }
72  else
73  {
74  /* enable/disable specified stream. */
75  s = pool_elt_at_index (pg->streams, stream_index);
76  pg_stream_enable_disable (pg, s, is_enable);
77  }
78 }
79 
82 {
83  pg_main_t *pg = &pg_main;
84  pg_interface_t *pi;
85 
86  if (a->is_enabled == 1)
87  {
88  struct stat sb;
89  if (stat ((char *) a->pcap_file_name, &sb) != -1)
90  return clib_error_return (0, "Cannot create pcap file");
91  }
92 
95  clib_memset (&pi->pcap_main, 0, sizeof (pi->pcap_main));
96 
97  if (a->is_enabled == 0)
98  return 0;
99 
101  pi->pcap_main.file_name = (char *) pi->pcap_file_name;
103  pi->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
104 
105  return 0;
106 }
107 
108 static clib_error_t *
110  unformat_input_t * input, vlib_cli_command_t * cmd)
111 {
112  pg_main_t *pg = &pg_main;
113  int is_enable = cmd->function_arg != 0;
114  u32 stream_index = ~0;
115 
116  if (unformat (input, "%U", unformat_eof))
117  ;
118  else if (unformat (input, "%U", unformat_hash_vec_string,
119  pg->stream_index_by_name, &stream_index))
120  ;
121  else
122  return clib_error_create ("unknown input `%U'",
123  format_unformat_error, input);
124 
125  pg_enable_disable (stream_index, is_enable);
126 
127  return 0;
128 }
129 
130 /* *INDENT-OFF* */
131 VLIB_CLI_COMMAND (enable_streams_cli, static) = {
132  .path = "packet-generator enable-stream",
133  .short_help = "Enable packet generator streams",
134  .function = enable_disable_stream,
135  .function_arg = 1, /* is_enable */
136 };
137 /* *INDENT-ON* */
138 
139 /* *INDENT-OFF* */
140 VLIB_CLI_COMMAND (disable_streams_cli, static) = {
141  .path = "packet-generator disable-stream",
142  .short_help = "Disable packet generator streams",
143  .function = enable_disable_stream,
144  .function_arg = 0, /* is_enable */
145 };
146 /* *INDENT-ON* */
147 
148 static u8 *
149 format_pg_stream (u8 * s, va_list * va)
150 {
151  pg_stream_t *t = va_arg (*va, pg_stream_t *);
152  u8 *v;
153 
154  if (!t)
155  return format (s, "%=16s%=12s%=16s%s",
156  "Name", "Enabled", "Count", "Parameters");
157 
158  s = format (s, "%-16v%=12s%16Ld",
159  t->name,
160  pg_stream_is_enabled (t) ? "Yes" : "No",
162 
163  v = 0;
164 
165  v = format (v, "limit %Ld, ", t->n_packets_limit);
166 
167  v = format (v, "rate %.2e pps, ", t->rate_packets_per_second);
168 
169  v = format (v, "size %d%c%d, ",
170  t->min_packet_bytes,
171  t->packet_size_edit_type == PG_EDIT_RANDOM ? '+' : '-',
172  t->max_packet_bytes);
173 
174  v = format (v, "buffer-size %d, ", t->buffer_bytes);
175 
176  v = format (v, "worker %d, ", t->worker_index);
177 
178  if (v)
179  {
180  s = format (s, " %v", v);
181  vec_free (v);
182  }
183 
184  return s;
185 }
186 
187 static clib_error_t *
189  unformat_input_t * input, vlib_cli_command_t * cmd)
190 {
191  pg_main_t *pg = &pg_main;
192  pg_stream_t *s;
193 
194  if (pool_elts (pg->streams) == 0)
195  {
196  vlib_cli_output (vm, "no streams currently defined");
197  goto done;
198  }
199 
200  vlib_cli_output (vm, "%U", format_pg_stream, 0);
201  /* *INDENT-OFF* */
202  pool_foreach (s, pg->streams, ({
203  vlib_cli_output (vm, "%U", format_pg_stream, s);
204  }));
205  /* *INDENT-ON* */
206 
207 done:
208  return 0;
209 }
210 
211 /* *INDENT-OFF* */
212 VLIB_CLI_COMMAND (show_streams_cli, static) = {
213  .path = "show packet-generator",
214  .short_help = "Show packet generator streams",
215  .function = show_streams,
216 };
217 /* *INDENT-ON* */
218 
219 static clib_error_t *
220 pg_pcap_read (pg_stream_t * s, char *file_name)
221 {
222 #ifndef CLIB_UNIX
223  return clib_error_return (0, "no pcap support");
224 #else
225  pcap_main_t pm;
226  clib_error_t *error;
227  clib_memset (&pm, 0, sizeof (pm));
228  pm.file_name = file_name;
229  error = pcap_read (&pm);
235  /* For PCAP buffers we never re-use buffers. */
237 
238  if (s->n_packets_limit == 0)
240 
241  return error;
242 #endif /* CLIB_UNIX */
243 }
244 
245 static uword
247 {
248  pg_stream_t *s = va_arg (*args, pg_stream_t *);
249  f64 x;
250 
251  if (unformat (input, "limit %f", &x))
252  s->n_packets_limit = x;
253 
254  else if (unformat (input, "rate %f", &x))
256 
257  else if (unformat (input, "size %d-%d", &s->min_packet_bytes,
258  &s->max_packet_bytes))
260 
261  else if (unformat (input, "size %d+%d", &s->min_packet_bytes,
262  &s->max_packet_bytes))
264 
265  else if (unformat (input, "buffer-size %d", &s->buffer_bytes))
266  ;
267 
268  else
269  return 0;
270 
271  return 1;
272 }
273 
274 static clib_error_t *
276 {
278  return clib_error_create ("max-size < min-size");
279 
280  if (s->buffer_bytes >= 4096 || s->buffer_bytes == 0)
281  return
282  clib_error_create ("buffer-size must be positive and < 4096, given %d",
283  s->buffer_bytes);
284 
285  if (s->rate_packets_per_second < 0)
286  return clib_error_create ("negative rate");
287 
288  return 0;
289 }
290 
291 static clib_error_t *
293  unformat_input_t * input, vlib_cli_command_t * cmd)
294 {
295  clib_error_t *error = 0;
296  u8 *tmp = 0;
297  u32 hw_if_index;
298  unformat_input_t sub_input = { 0 };
299  int sub_input_given = 0;
300  vnet_main_t *vnm = vnet_get_main ();
301  pg_main_t *pg = &pg_main;
302  pg_stream_t s = { 0 };
303  char *pcap_file_name;
304 
305  s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0;
306  s.node_index = ~0;
309  s.if_id = 0;
310  pcap_file_name = 0;
312  {
313  if (unformat (input, "name %v", &tmp))
314  {
315  if (s.name)
316  vec_free (s.name);
317  s.name = tmp;
318  }
319 
320  else if (unformat (input, "node %U",
321  unformat_vnet_hw_interface, vnm, &hw_if_index))
322  {
323  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
324 
327  }
328 
329  else if (unformat (input, "source pg%u", &s.if_id))
330  ;
331 
332  else if (unformat (input, "node %U",
334  ;
335 
336  else if (unformat (input, "worker %u", &s.worker_index))
337  ;
338 
339  else if (unformat (input, "interface %U",
341  &s.sw_if_index[VLIB_RX]))
342  ;
343 
344  else if (unformat (input, "pcap %s", &pcap_file_name))
345  ;
346 
347  else if (!sub_input_given
348  && unformat (input, "data %U", unformat_input, &sub_input))
349  sub_input_given++;
350 
351  else if (unformat_user (input, unformat_pg_stream_parameter, &s))
352  ;
353 
354  else if (unformat (input, "no-recycle"))
356 
357  else
358  {
359  error = clib_error_create ("unknown input `%U'",
360  format_unformat_error, input);
361  goto done;
362  }
363  }
364 
365  error = validate_stream (&s);
366  if (error)
367  return error;
368 
369  if (!sub_input_given && !pcap_file_name)
370  {
371  error = clib_error_create ("no packet data given");
372  goto done;
373  }
374 
375  if (s.node_index == ~0)
376  {
377  if (pcap_file_name != 0)
378  {
379  vlib_node_t *n =
380  vlib_get_node_by_name (vm, (u8 *) "ethernet-input");
381  s.node_index = n->index;
382  }
383  else
384  {
385  error = clib_error_create ("output interface or node not given");
386  goto done;
387  }
388  }
389 
390  {
391  pg_node_t *n;
392 
393  if (s.node_index < vec_len (pg->nodes))
394  n = pg->nodes + s.node_index;
395  else
396  n = 0;
397 
398  if (s.worker_index >= vlib_num_workers ())
399  s.worker_index = 0;
400 
401  if (pcap_file_name != 0)
402  {
403  error = pg_pcap_read (&s, pcap_file_name);
404  if (error)
405  goto done;
406  vec_free (pcap_file_name);
407  }
408 
409  else if (n && n->unformat_edit
410  && unformat_user (&sub_input, n->unformat_edit, &s))
411  ;
412 
413  else if (!unformat_user (&sub_input, unformat_pg_payload, &s))
414  {
415  error = clib_error_create
416  ("failed to parse packet data from `%U'",
417  format_unformat_error, &sub_input);
418  goto done;
419  }
420  }
421 
422  pg_stream_add (pg, &s);
423  return 0;
424 
425 done:
426  pg_stream_free (&s);
427  unformat_free (&sub_input);
428  return error;
429 }
430 
431 /* *INDENT-OFF* */
432 VLIB_CLI_COMMAND (new_stream_cli, static) = {
433  .path = "packet-generator new",
434  .function = new_stream,
435  .short_help = "Create packet generator stream",
436  .long_help =
437  "Create packet generator stream\n"
438  "\n"
439  "Arguments:\n"
440  "\n"
441  "name STRING sets stream name\n"
442  "interface STRING interface for stream output \n"
443  "node NODE-NAME node for stream output\n"
444  "data STRING specifies packet data\n"
445  "pcap FILENAME read packet data from pcap file\n",
446 };
447 /* *INDENT-ON* */
448 
449 static clib_error_t *
451  unformat_input_t * input, vlib_cli_command_t * cmd)
452 {
453  pg_main_t *pg = &pg_main;
454  u32 i;
455 
456  if (!unformat (input, "%U",
458  return clib_error_create ("expected stream name `%U'",
459  format_unformat_error, input);
460 
461  pg_stream_del (pg, i);
462  return 0;
463 }
464 
465 /* *INDENT-OFF* */
466 VLIB_CLI_COMMAND (del_stream_cli, static) = {
467  .path = "packet-generator delete",
468  .function = del_stream,
469  .short_help = "Delete stream with given name",
470 };
471 /* *INDENT-ON* */
472 
473 static clib_error_t *
475  unformat_input_t * input, vlib_cli_command_t * cmd)
476 {
477  pg_main_t *pg = &pg_main;
478  pg_stream_t *s, s_new;
479  u32 stream_index = ~0;
480  clib_error_t *error;
481 
482  if (unformat (input, "%U", unformat_hash_vec_string,
483  pg->stream_index_by_name, &stream_index))
484  ;
485  else
486  return clib_error_create ("expecting stream name; got `%U'",
487  format_unformat_error, input);
488 
489  s = pool_elt_at_index (pg->streams, stream_index);
490  s_new = s[0];
491 
493  {
494  if (unformat_user (input, unformat_pg_stream_parameter, &s_new))
495  ;
496 
497  else
498  return clib_error_create ("unknown input `%U'",
499  format_unformat_error, input);
500  }
501 
502  error = validate_stream (&s_new);
503  if (!error)
504  s[0] = s_new;
505 
506  return error;
507 }
508 
509 /* *INDENT-OFF* */
510 VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = {
511  .path = "packet-generator configure",
512  .short_help = "Change packet generator stream parameters",
513  .function = change_stream_parameters,
514 };
515 /* *INDENT-ON* */
516 
517 static clib_error_t *
519  unformat_input_t * input, vlib_cli_command_t * cmd)
520 {
521  clib_error_t *error = 0;
522  vnet_main_t *vnm = vnet_get_main ();
523  unformat_input_t _line_input, *line_input = &_line_input;
524  vnet_hw_interface_t *hi = 0;
525  u8 *pcap_file_name = 0;
526  u32 hw_if_index;
527  u32 is_disable = 0;
528  u32 count = ~0;
529 
530  if (!unformat_user (input, unformat_line_input, line_input))
531  return 0;
532 
533  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
534  {
535  if (unformat (line_input, "%U",
536  unformat_vnet_hw_interface, vnm, &hw_if_index))
537  {
538  hi = vnet_get_hw_interface (vnm, hw_if_index);
539  }
540 
541  else if (unformat (line_input, "pcap %s", &pcap_file_name))
542  ;
543  else if (unformat (line_input, "count %u", &count))
544  ;
545  else if (unformat (line_input, "disable"))
546  is_disable = 1;
547 
548  else
549  {
550  error = clib_error_create ("unknown input `%U'",
551  format_unformat_error, line_input);
552  goto done;
553  }
554  }
555 
556  if (!hi)
557  {
558  error = clib_error_return (0, "Please specify interface name");
559  goto done;
560  }
561 
562  if (hi->dev_class_index != pg_dev_class.index)
563  {
564  error =
565  clib_error_return (0, "Please specify packet-generator interface");
566  goto done;
567  }
568 
569  if (!pcap_file_name && is_disable == 0)
570  {
571  error = clib_error_return (0, "Please specify pcap file name");
572  goto done;
573  }
574 
575 
576  pg_capture_args_t _a, *a = &_a;
577 
578  a->hw_if_index = hw_if_index;
579  a->dev_instance = hi->dev_instance;
580  a->is_enabled = !is_disable;
581  a->pcap_file_name = pcap_file_name;
582  a->count = count;
583 
584  error = pg_capture (a);
585 
586 done:
587  unformat_free (line_input);
588 
589  return error;
590 }
591 
592 /* *INDENT-OFF* */
593 VLIB_CLI_COMMAND (pg_capture_cmd, static) = {
594  .path = "packet-generator capture",
595  .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]",
596  .function = pg_capture_cmd_fn,
597 };
598 /* *INDENT-ON* */
599 
600 static clib_error_t *
602  unformat_input_t * input, vlib_cli_command_t * cmd)
603 {
604  pg_main_t *pg = &pg_main;
605  unformat_input_t _line_input, *line_input = &_line_input;
606  u32 if_id;
607  clib_error_t *error = NULL;
608 
609  if (!unformat_user (input, unformat_line_input, line_input))
610  return 0;
611 
612  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
613  {
614  if (unformat (line_input, "interface pg%u", &if_id))
615  ;
616 
617  else
618  {
619  error = clib_error_create ("unknown input `%U'",
620  format_unformat_error, line_input);
621  goto done;
622  }
623  }
624 
625  pg_interface_add_or_get (pg, if_id);
626 
627 done:
628  unformat_free (line_input);
629 
630  return error;
631 }
632 
633 /* *INDENT-OFF* */
634 VLIB_CLI_COMMAND (create_pg_if_cmd, static) = {
635  .path = "create packet-generator",
636  .short_help = "create packet-generator interface <interface name>",
637  .function = create_pg_if_cmd_fn,
638 };
639 /* *INDENT-ON* */
640 
641 /* Dummy init function so that we can be linked in. */
642 static clib_error_t *
644 {
645  return 0;
646 }
647 
649 
650 /*
651  * fd.io coding-style-patch-verification: ON
652  *
653  * Local Variables:
654  * eval: (c-set-style "gnu")
655  * End:
656  */
unformat_function_t unformat_vnet_hw_interface
static int pg_stream_is_enabled(pg_stream_t *s)
Definition: pg.h:217
vmrglw vmrglh hi
clib_error_t * pg_capture(pg_capture_args_t *a)
Definition: cli.c:81
u64 n_packets_limit
Definition: pg.h:157
void pg_stream_add(pg_main_t *pg, pg_stream_t *s_init)
Definition: stream.c:385
char * file_name
File name of pcap output.
Definition: pcap.h:162
a
Definition: bitmap.h:538
u32 n_packets_to_capture
Number of packets to capture.
Definition: pcap.h:165
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
Definition: pg.h:314
unformat_function_t unformat_eof
Definition: format.h:292
unformat_function_t unformat_input
Definition: format.h:276
static clib_error_t * pg_cli_init(vlib_main_t *vm)
Definition: cli.c:643
#define NULL
Definition: clib.h:58
PCAP utility definitions.
u32 index
Definition: node.h:304
uword * stream_index_by_name
Definition: pg.h:323
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 max_packet_bytes
Definition: pcap.h:193
u32 worker_index
Definition: pg.h:145
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
u32 hw_if_index
Definition: pg.h:373
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
pg_edit_type_t packet_size_edit_type
Definition: pg.h:109
void pg_stream_del(pg_main_t *pg, uword index)
Definition: stream.c:467
unsigned char u8
Definition: types.h:56
double f64
Definition: types.h:142
PCAP main state data structure.
Definition: pcap.h:156
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:490
static uword unformat_pg_stream_parameter(unformat_input_t *input, va_list *args)
Definition: cli.c:246
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
uword unformat_pg_payload(unformat_input_t *input, va_list *args)
Definition: edit.c:127
static clib_error_t * del_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:450
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned int u32
Definition: types.h:88
#define clib_error_create(args...)
Definition: error.h:96
static clib_error_t * new_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:292
static clib_error_t * enable_disable_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:109
u8 * pcap_file_name
Definition: pg.h:376
unformat_function_t unformat_line_input
Definition: format.h:282
u32 buffer_bytes
Definition: pg.h:125
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:511
u8 * name
Definition: pg.h:97
struct _unformat_input_t unformat_input_t
static void pg_stream_free(pg_stream_t *s)
Definition: pg.h:192
pcap_main_t pcap_main
Definition: pg.h:303
pg_node_t * nodes
Definition: pg.h:333
u32 pg_interface_add_or_get(pg_main_t *pg, uword stream_index)
Definition: stream.c:182
#define PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE
Definition: pg.h:103
unformat_function_t unformat_hash_vec_string
Definition: hash.h:718
clib_error_t * pcap_read(pcap_main_t *pm)
Read PCAP file.
Definition: pcap.c:179
uword function_arg
Definition: cli.h:105
static clib_error_t * create_pg_if_cmd_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:601
u8 * pcap_file_name
Definition: pg.h:304
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
vlib_main_t * vm
Definition: buffer.c:301
u64 * replay_packet_timestamps
Definition: pg.h:170
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
u32 min_packet_bytes
Definition: pg.h:112
u32 max_packet_bytes
Definition: pg.h:112
static clib_error_t * pg_pcap_read(pg_stream_t *s, char *file_name)
Definition: cli.c:220
unformat_function_t * unformat_edit
Definition: pg.h:311
static u8 * format_pg_stream(u8 *s, va_list *va)
Definition: cli.c:149
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
u8 ** replay_packet_templates
Definition: pg.h:169
#define VLIB_BUFFER_DATA_SIZE
Definition: buffer.h:51
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
pg_stream_t * streams
Definition: pg.h:317
static clib_error_t * validate_stream(pg_stream_t *s)
Definition: cli.c:275
static clib_error_t * pg_capture_cmd_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:518
void pg_enable_disable(u32 stream_index, int is_enable)
Definition: cli.c:58
void pg_stream_enable_disable(pg_main_t *pg, pg_stream_t *s, int is_enable)
Definition: stream.c:49
static clib_error_t * show_streams(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:188
size_t count
Definition: vapi.c:47
Definition: pg.h:94
u32 min_packet_bytes
Min/Max Packet bytes.
Definition: pcap.h:193
u64 * timestamps
Timestamps.
Definition: pcap.h:190
pcap_packet_type_t packet_type
Packet type.
Definition: pcap.h:168
u32 node_index
Definition: pg.h:142
Definition: defs.h:47
u32 sw_if_index[VLIB_N_RX_TX]
Definition: pg.h:139
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 if_id
Definition: pg.h:150
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1177
u32 dev_instance
Definition: pg.h:374
f64 rate_packets_per_second
Definition: pg.h:161
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static u32 vlib_num_workers()
Definition: threads.h:366
u64 n_packets_generated
Definition: pg.h:153
pg_main_t pg_main
Definition: init.c:44
u8 is_enabled
Definition: pg.h:375
u8 ** packets_read
Packets read from file.
Definition: pcap.h:187
vnet_device_class_t pg_dev_class
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:725
static clib_error_t * change_stream_parameters(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:474
Definition: pg.h:308
pg_interface_t * interfaces
Definition: pg.h:326
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
Definition: defs.h:46
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
u32 flags
Definition: pg.h:99
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128