FD.io VPP  v17.01.1-3-gc6833f8
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 <vnet/unix/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  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  memset (&pm, 0, sizeof (pm));
228  pm.file_name = file_name;
229  error = pcap_read (&pm);
234  /* For PCAP buffers we never re-use buffers. */
236 
237  if (s->n_packets_limit == 0)
239 
240  return error;
241 #endif /* CLIB_UNIX */
242 }
243 
244 static uword
246 {
247  pg_stream_t *s = va_arg (*args, pg_stream_t *);
248  f64 x;
249 
250  if (unformat (input, "limit %f", &x))
251  s->n_packets_limit = x;
252 
253  else if (unformat (input, "rate %f", &x))
255 
256  else if (unformat (input, "size %d-%d", &s->min_packet_bytes,
257  &s->max_packet_bytes))
259 
260  else if (unformat (input, "size %d+%d", &s->min_packet_bytes,
261  &s->max_packet_bytes))
263 
264  else if (unformat (input, "buffer-size %d", &s->buffer_bytes))
265  ;
266 
267  else
268  return 0;
269 
270  return 1;
271 }
272 
273 static clib_error_t *
275 {
277  return clib_error_create ("max-size < min-size");
278 
279  if (s->buffer_bytes >= 4096 || s->buffer_bytes == 0)
280  return
281  clib_error_create ("buffer-size must be positive and < 4096, given %d",
282  s->buffer_bytes);
283 
284  if (s->rate_packets_per_second < 0)
285  return clib_error_create ("negative rate");
286 
287  return 0;
288 }
289 
290 static clib_error_t *
292  unformat_input_t * input, vlib_cli_command_t * cmd)
293 {
294  clib_error_t *error = 0;
295  u8 *tmp = 0;
296  u32 hw_if_index;
297  unformat_input_t sub_input = { 0 };
298  int sub_input_given = 0;
299  vnet_main_t *vnm = vnet_get_main ();
300  pg_main_t *pg = &pg_main;
301  pg_stream_t s = { 0 };
302  char *pcap_file_name;
303 
304  s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0;
305  s.node_index = ~0;
308  s.if_id = 0;
309  pcap_file_name = 0;
311  {
312  if (unformat (input, "name %v", &tmp))
313  {
314  if (s.name)
315  vec_free (s.name);
316  s.name = tmp;
317  }
318 
319  else if (unformat (input, "node %U",
320  unformat_vnet_hw_interface, vnm, &hw_if_index))
321  {
322  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
323 
326  }
327 
328  else if (unformat (input, "source pg%u", &s.if_id))
329  ;
330 
331  else if (unformat (input, "node %U",
333  ;
334 
335  else if (unformat (input, "worker %u", &s.worker_index))
336  ;
337 
338  else if (unformat (input, "interface %U",
340  &s.sw_if_index[VLIB_RX]))
341  ;
342 
343  else if (unformat (input, "pcap %s", &pcap_file_name))
344  ;
345 
346  else if (!sub_input_given
347  && unformat (input, "data %U", unformat_input, &sub_input))
348  sub_input_given++;
349 
350  else if (unformat_user (input, unformat_pg_stream_parameter, &s))
351  ;
352 
353  else if (unformat (input, "no-recycle"))
355 
356  else
357  {
358  error = clib_error_create ("unknown input `%U'",
359  format_unformat_error, input);
360  goto done;
361  }
362  }
363 
364  error = validate_stream (&s);
365  if (error)
366  return error;
367 
368  if (!sub_input_given && !pcap_file_name)
369  {
370  error = clib_error_create ("no packet data given");
371  goto done;
372  }
373 
374  if (s.node_index == ~0)
375  {
376  if (pcap_file_name != 0)
377  {
378  vlib_node_t *n =
379  vlib_get_node_by_name (vm, (u8 *) "ethernet-input");
380  s.node_index = n->index;
381  }
382  else
383  {
384  error = clib_error_create ("output interface or node not given");
385  goto done;
386  }
387  }
388 
389  {
390  pg_node_t *n;
391 
392  if (s.node_index < vec_len (pg->nodes))
393  n = pg->nodes + s.node_index;
394  else
395  n = 0;
396 
397  if (s.worker_index >= vlib_num_workers ())
398  s.worker_index = 0;
399 
400  if (pcap_file_name != 0)
401  {
402  error = pg_pcap_read (&s, pcap_file_name);
403  if (error)
404  goto done;
405  vec_free (pcap_file_name);
406  }
407 
408  else if (n && n->unformat_edit
409  && unformat_user (&sub_input, n->unformat_edit, &s))
410  ;
411 
412  else if (!unformat_user (&sub_input, unformat_pg_payload, &s))
413  {
414  error = clib_error_create
415  ("failed to parse packet data from `%U'",
416  format_unformat_error, &sub_input);
417  goto done;
418  }
419  }
420 
421  pg_stream_add (pg, &s);
422  return 0;
423 
424 done:
425  pg_stream_free (&s);
426  unformat_free (&sub_input);
427  return error;
428 }
429 
430 /* *INDENT-OFF* */
431 VLIB_CLI_COMMAND (new_stream_cli, static) = {
432  .path = "packet-generator new",
433  .function = new_stream,
434  .short_help = "Create packet generator stream",
435  .long_help =
436  "Create packet generator stream\n"
437  "\n"
438  "Arguments:\n"
439  "\n"
440  "name STRING sets stream name\n"
441  "interface STRING interface for stream output \n"
442  "node NODE-NAME node for stream output\n"
443  "data STRING specifies packet data\n"
444  "pcap FILENAME read packet data from pcap file\n",
445 };
446 /* *INDENT-ON* */
447 
448 static clib_error_t *
450  unformat_input_t * input, vlib_cli_command_t * cmd)
451 {
452  pg_main_t *pg = &pg_main;
453  u32 i;
454 
455  if (!unformat (input, "%U",
457  return clib_error_create ("expected stream name `%U'",
458  format_unformat_error, input);
459 
460  pg_stream_del (pg, i);
461  return 0;
462 }
463 
464 /* *INDENT-OFF* */
465 VLIB_CLI_COMMAND (del_stream_cli, static) = {
466  .path = "packet-generator delete",
467  .function = del_stream,
468  .short_help = "Delete stream with given name",
469 };
470 /* *INDENT-ON* */
471 
472 static clib_error_t *
474  unformat_input_t * input, vlib_cli_command_t * cmd)
475 {
476  pg_main_t *pg = &pg_main;
477  pg_stream_t *s, s_new;
478  u32 stream_index = ~0;
479  clib_error_t *error;
480 
481  if (unformat (input, "%U", unformat_hash_vec_string,
482  pg->stream_index_by_name, &stream_index))
483  ;
484  else
485  return clib_error_create ("expecting stream name; got `%U'",
486  format_unformat_error, input);
487 
488  s = pool_elt_at_index (pg->streams, stream_index);
489  s_new = s[0];
490 
492  {
493  if (unformat_user (input, unformat_pg_stream_parameter, &s_new))
494  ;
495 
496  else
497  return clib_error_create ("unknown input `%U'",
498  format_unformat_error, input);
499  }
500 
501  error = validate_stream (&s_new);
502  if (!error)
503  s[0] = s_new;
504 
505  return error;
506 }
507 
508 /* *INDENT-OFF* */
509 VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = {
510  .path = "packet-generator configure",
511  .short_help = "Change packet generator stream parameters",
512  .function = change_stream_parameters,
513 };
514 /* *INDENT-ON* */
515 
516 static clib_error_t *
518  unformat_input_t * input, vlib_cli_command_t * cmd)
519 {
520  clib_error_t *error = 0;
521  vnet_main_t *vnm = vnet_get_main ();
522  unformat_input_t _line_input, *line_input = &_line_input;
523  vnet_hw_interface_t *hi = 0;
524  u8 *pcap_file_name = 0;
525  u32 hw_if_index;
526  u32 is_disable = 0;
527  u32 count = ~0;
528 
529  if (!unformat_user (input, unformat_line_input, line_input))
530  return 0;
531 
532  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
533  {
534  if (unformat (line_input, "%U",
535  unformat_vnet_hw_interface, vnm, &hw_if_index))
536  {
537  hi = vnet_get_hw_interface (vnm, hw_if_index);
538  }
539 
540  else if (unformat (line_input, "pcap %s", &pcap_file_name))
541  ;
542  else if (unformat (line_input, "count %u", &count))
543  ;
544  else if (unformat (line_input, "disable"))
545  is_disable = 1;
546 
547  else
548  {
549  error = clib_error_create ("unknown input `%U'",
550  format_unformat_error, input);
551  return error;
552  }
553  }
554 
555  if (!hi)
556  return clib_error_return (0, "Please specify interface name");
557 
558  if (hi->dev_class_index != pg_dev_class.index)
559  return clib_error_return (0, "Please specify packet-generator interface");
560 
561  if (!pcap_file_name && is_disable == 0)
562  return clib_error_return (0, "Please specify pcap file name");
563 
564  unformat_free (line_input);
565 
566  pg_capture_args_t _a, *a = &_a;
567 
568  a->hw_if_index = hw_if_index;
569  a->dev_instance = hi->dev_instance;
570  a->is_enabled = !is_disable;
571  a->pcap_file_name = pcap_file_name;
572  a->count = count;
573 
574  error = pg_capture (a);
575  return error;
576 }
577 
578 /* *INDENT-OFF* */
579 VLIB_CLI_COMMAND (pg_capture_cmd, static) = {
580  .path = "packet-generator capture",
581  .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]",
582  .function = pg_capture_cmd_fn,
583 };
584 /* *INDENT-ON* */
585 
586 static clib_error_t *
588  unformat_input_t * input, vlib_cli_command_t * cmd)
589 {
590  pg_main_t *pg = &pg_main;
591  unformat_input_t _line_input, *line_input = &_line_input;
592  u32 if_id;
593 
594  if (!unformat_user (input, unformat_line_input, line_input))
595  return 0;
596 
597  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
598  {
599  if (unformat (line_input, "interface pg%u", &if_id))
600  ;
601 
602  else
603  return clib_error_create ("unknown input `%U'",
604  format_unformat_error, input);
605  }
606 
607  unformat_free (line_input);
608 
609  pg_interface_add_or_get (pg, if_id);
610  return 0;
611 }
612 
613 /* *INDENT-OFF* */
614 VLIB_CLI_COMMAND (create_pg_if_cmd, static) = {
615  .path = "create packet-generator",
616  .short_help = "create packet-generator interface <interface name>",
617  .function = create_pg_if_cmd_fn,
618 };
619 /* *INDENT-ON* */
620 
621 /* Dummy init function so that we can be linked in. */
622 static clib_error_t *
624 {
625  return 0;
626 }
627 
629 
630 /*
631  * fd.io coding-style-patch-verification: ON
632  *
633  * Local Variables:
634  * eval: (c-set-style "gnu")
635  * End:
636  */
unformat_function_t unformat_vnet_hw_interface
static int pg_stream_is_enabled(pg_stream_t *s)
Definition: pg.h:213
vmrglw vmrglh hi
void pg_enable_disable(u32 stream_index, int is_enable)
Definition: cli.c:58
u64 n_packets_limit
Definition: pg.h:159
void pg_stream_add(pg_main_t *pg, pg_stream_t *s_init)
Definition: stream.c:369
char * file_name
File name of pcap output.
Definition: pcap.h:124
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
a
Definition: bitmap.h:516
u32 n_packets_to_capture
Number of packets to capture.
Definition: pcap.h:127
static clib_error_t * show_streams(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:188
static u8 * format_pg_stream(u8 *s, va_list *va)
Definition: cli.c:149
static uword unformat_pg_stream_parameter(unformat_input_t *input, va_list *args)
Definition: cli.c:245
Definition: pg.h:310
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
PCAP utility definitions.
u32 index
Definition: node.h:237
uword * stream_index_by_name
Definition: pg.h:319
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 max_packet_bytes
Definition: pcap.h:152
u32 worker_index
Definition: pg.h:147
u32 hw_if_index
Definition: pg.h:366
unformat_function_t unformat_vnet_sw_interface
pg_edit_type_t packet_size_edit_type
Definition: pg.h:111
void pg_stream_del(pg_main_t *pg, uword index)
Definition: stream.c:469
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
PCAP main state data structure.
Definition: pcap.h:122
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:348
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
uword unformat_pg_payload(unformat_input_t *input, va_list *args)
Definition: edit.c:127
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:977
static clib_error_t * del_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:449
u8 * pcap_file_name
Definition: pg.h:369
u32 buffer_bytes
Definition: pg.h:127
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
#define VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES
Definition: buffer.h:311
#define v
Definition: acl.c:314
u8 * name
Definition: pg.h:99
static void pg_stream_free(pg_stream_t *s)
Definition: pg.h:193
pcap_main_t pcap_main
Definition: pg.h:299
#define clib_error_create(args...)
Definition: error.h:108
pg_node_t * nodes
Definition: pg.h:326
u32 pg_interface_add_or_get(pg_main_t *pg, uword stream_index)
Definition: stream.c:162
#define PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE
Definition: pg.h:105
unformat_function_t unformat_hash_vec_string
Definition: hash.h:680
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:576
static clib_error_t * validate_stream(pg_stream_t *s)
Definition: cli.c:274
clib_error_t * pcap_read(pcap_main_t *pm)
Read PCAP file.
Definition: pcap.c:170
static clib_error_t * new_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:291
uword function_arg
Definition: cli.h:105
static clib_error_t * pg_pcap_read(pg_stream_t *s, char *file_name)
Definition: cli.c:220
unformat_function_t unformat_eof
Definition: format.h:291
u8 * pcap_file_name
Definition: pg.h:300
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
u32 min_packet_bytes
Definition: pg.h:114
u32 max_packet_bytes
Definition: pg.h:114
unformat_function_t * unformat_edit
Definition: pg.h:307
u8 ** replay_packet_templates
Definition: pg.h:171
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
pg_stream_t * streams
Definition: pg.h:313
unsigned int u32
Definition: types.h:88
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static clib_error_t * pg_capture_cmd_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:517
clib_error_t * pg_capture(pg_capture_args_t *a)
Definition: cli.c:81
void pg_stream_enable_disable(pg_main_t *pg, pg_stream_t *s, int is_enable)
Definition: stream.c:49
Definition: pg.h:96
pg_main_t pg_main
Definition: init.c:44
u32 min_packet_bytes
Min/Max Packet bytes.
Definition: pcap.h:152
static clib_error_t * enable_disable_stream(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:109
static clib_error_t * change_stream_parameters(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:473
unformat_function_t unformat_input
Definition: format.h:275
u64 uword
Definition: types.h:112
pcap_packet_type_t packet_type
Packet type.
Definition: pcap.h:130
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
u32 node_index
Definition: pg.h:144
Definition: defs.h:47
u32 sw_if_index[VLIB_N_RX_TX]
Definition: pg.h:141
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:587
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
double f64
Definition: types.h:142
unsigned char u8
Definition: types.h:56
u32 if_id
Definition: pg.h:152
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1110
u32 dev_instance
Definition: pg.h:367
f64 rate_packets_per_second
Definition: pg.h:163
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static clib_error_t * pg_cli_init(vlib_main_t *vm)
Definition: cli.c:623
static u32 vlib_num_workers()
Definition: threads.h:340
u64 n_packets_generated
Definition: pg.h:155
u8 is_enabled
Definition: pg.h:368
u8 ** packets_read
Packets read from file.
Definition: pcap.h:149
#define clib_error_return(e, args...)
Definition: error.h:111
struct _unformat_input_t unformat_input_t
vnet_device_class_t pg_dev_class
unformat_function_t unformat_line_input
Definition: format.h:281
Definition: pg.h:304
pg_interface_t * interfaces
Definition: pg.h:322
Definition: defs.h:46
u32 flags
Definition: pg.h:101
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109