FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
interface_format.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  * interface_format.c: interface formatting
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 <vnet/vnet.h>
41 #include <vppinfra/bitmap.h>
42 #include <vnet/l2/l2_input.h>
43 #include <vnet/l2/l2_output.h>
44 
45 u8 *
46 format_vnet_sw_interface_flags (u8 * s, va_list * args)
47 {
48  u32 flags = va_arg (*args, u32);
49 
50  if (flags & VNET_SW_INTERFACE_FLAG_ERROR)
51  s = format (s, "error");
52  else
53  {
54  s = format (s, "%s",
55  (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "down");
56  if (flags & VNET_SW_INTERFACE_FLAG_PUNT)
57  s = format (s, "/punt");
58  }
59 
60  return s;
61 }
62 
63 u8 *
64 format_vnet_hw_interface_rx_mode (u8 * s, va_list * args)
65 {
67 
69  return format (s, "polling");
70 
72  return format (s, "interrupt");
73 
75  return format (s, "adaptive");
76 
77  return format (s, "unknown");
78 }
79 
80 u8 *
82 {
83  u32 link_speed = va_arg (*args, u32);
84 
85  if (link_speed == 0)
86  return format (s, "unknown");
87 
88  if (link_speed >= 1000000)
89  return format (s, "%f Gbps", (f64) link_speed / 1000000);
90 
91  if (link_speed >= 1000)
92  return format (s, "%f Mbps", (f64) link_speed / 1000);
93 
94  return format (s, "%u Kbps", link_speed);
95 }
96 
97 
98 u8 *
99 format_vnet_hw_interface (u8 * s, va_list * args)
100 {
101  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
102  vnet_hw_interface_t *hi = va_arg (*args, vnet_hw_interface_t *);
103  vnet_hw_interface_class_t *hw_class;
104  vnet_device_class_t *dev_class;
105  int verbose = va_arg (*args, int);
106  u32 indent;
107 
108  if (!hi)
109  return format (s, "%=32s%=6s%=8s%s", "Name", "Idx", "Link", "Hardware");
110 
111  indent = format_get_indent (s);
112 
113  s = format (s, "%-32v%=6d", hi->name, hi->hw_if_index);
114 
116  s = format (s, "%=8s", "slave");
117  else
118  s = format (s, "%=8s",
119  hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP ? "up" : "down");
120 
121  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
122  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
123 
125  {
126  int hw_idx;
127  s = format (s, "Slave-Idx:");
128  clib_bitmap_foreach (hw_idx, hi->bond_info, s =
129  format (s, " %d", hw_idx));
130  }
131  else if (dev_class->format_device_name)
132  s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
133  else
134  s = format (s, "%s%d", dev_class->name, hi->dev_instance);
135 
136  s = format (s, "\n%ULink speed: %U", format_white_space, indent + 2,
138 
139  if (verbose)
140  {
141  if (hw_class->format_device)
142  s = format (s, "\n%U%U",
143  format_white_space, indent + 2,
144  hw_class->format_device, hi->hw_if_index, verbose);
145  else
146  {
147  s = format (s, "\n%U%s",
148  format_white_space, indent + 2, hw_class->name);
149  if (hw_class->format_address && vec_len (hi->hw_address) > 0)
150  s =
151  format (s, " address %U", hw_class->format_address,
152  hi->hw_address);
153  }
154 
155  if (dev_class->format_device)
156  s = format (s, "\n%U%U",
157  format_white_space, indent + 2,
158  dev_class->format_device, hi->dev_instance, verbose);
159  }
160 
161  return s;
162 }
163 
164 u8 *
165 format_vnet_sw_interface_name (u8 * s, va_list * args)
166 {
167  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
168  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
169  vnet_sw_interface_t *si_sup =
171  vnet_hw_interface_t *hi_sup;
172 
174  hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
175 
176  s = format (s, "%v", hi_sup->name);
177 
179  s = format (s, ".%d", si->sub.id);
180 
181  return s;
182 }
183 
184 u8 *
185 format_vnet_sw_if_index_name (u8 * s, va_list * args)
186 {
187  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
188  u32 sw_if_index = va_arg (*args, u32);
190 
191  si = vnet_get_sw_interface_or_null (vnm, sw_if_index);
192 
193  if (NULL == si)
194  {
195  return format (s, "DELETED");
196  }
197  return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
198 }
199 
200 u8 *
201 format_vnet_hw_if_index_name (u8 * s, va_list * args)
202 {
203  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
204  u32 hw_if_index = va_arg (*args, u32);
206 
207  hi = vnet_get_hw_interface (vnm, hw_if_index);
208 
209  if (hi == 0)
210  return format (s, "DELETED");
211 
212  return format (s, "%v", hi->name);
213 }
214 
215 u8 *
217  vnet_sw_interface_t * si, int json)
218 {
219  u32 indent, n_printed;
220  int j, n_counters;
221  char *x = "";
222  int json_need_comma_nl = 0;
223  u8 *n = 0;
224 
225  /*
226  * to output a json snippet, stick quotes in lots of places
227  * definitely deserves a one-character variable name.
228  */
229  if (json)
230  x = "\"";
231 
232  indent = format_get_indent (s);
233  n_printed = 0;
234 
235  n_counters = vec_len (im->combined_sw_if_counters);
236 
237  /* rx, tx counters... */
238  for (j = 0; j < n_counters; j++)
239  {
241  vlib_counter_t v, vtotal;
242  vtotal.packets = 0;
243  vtotal.bytes = 0;
244 
245  cm = im->combined_sw_if_counters + j;
247  vtotal.packets += v.packets;
248  vtotal.bytes += v.bytes;
249 
250  /* Only display non-zero counters. */
251  if (vtotal.packets == 0)
252  continue;
253 
254  if (json)
255  {
256  if (json_need_comma_nl)
257  {
258  vec_add1 (s, ',');
259  vec_add1 (s, '\n');
260  }
261  s = format (s, "%s%s_packets%s: %s%Ld%s,\n", x, cm->name, x, x,
262  vtotal.packets, x);
263  s = format (s, "%s%s_bytes%s: %s%Ld%s", x, cm->name, x, x,
264  vtotal.bytes, x);
265  json_need_comma_nl = 1;
266  continue;
267  }
268 
269  if (n_printed > 0)
270  s = format (s, "\n%U", format_white_space, indent);
271  n_printed += 2;
272 
273  if (n)
274  _vec_len (n) = 0;
275  n = format (n, "%s packets", cm->name);
276  s = format (s, "%-16v%16Ld", n, vtotal.packets);
277 
278  _vec_len (n) = 0;
279  n = format (n, "%s bytes", cm->name);
280  s = format (s, "\n%U%-16v%16Ld",
281  format_white_space, indent, n, vtotal.bytes);
282  }
283  vec_free (n);
284 
285  {
287  u64 v, vtotal;
288 
289  n_counters = vec_len (im->sw_if_counters);
290 
291  for (j = 0; j < n_counters; j++)
292  {
293  vtotal = 0;
294 
295  cm = im->sw_if_counters + j;
296 
297  v = vlib_get_simple_counter (cm, si->sw_if_index);
298  vtotal += v;
299 
300  /* Only display non-zero counters. */
301  if (vtotal == 0)
302  continue;
303 
304  if (json)
305  {
306  if (json_need_comma_nl)
307  {
308  vec_add1 (s, ',');
309  vec_add1 (s, '\n');
310  }
311  s = format (s, "%s%s%s: %s%Ld%s", x, cm->name, x, x, vtotal, x);
312  json_need_comma_nl = 1;
313  continue;
314  }
315 
316 
317  if (n_printed > 0)
318  s = format (s, "\n%U", format_white_space, indent);
319  n_printed += 1;
320 
321  s = format (s, "%-16s%16Ld", cm->name, vtotal);
322  }
323  }
324 
325  return s;
326 }
327 
328 static u8 *
329 format_vnet_sw_interface_mtu (u8 * s, va_list * args)
330 {
331  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
332 
333  return format (s, "%d/%d/%d/%d", si->mtu[VNET_MTU_L3],
334  si->mtu[VNET_MTU_IP4],
335  si->mtu[VNET_MTU_IP6], si->mtu[VNET_MTU_MPLS]);
336 }
337 
338 u8 *
339 format_vnet_sw_interface (u8 * s, va_list * args)
340 {
341  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
342  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
344 
345  if (!si)
346  return format (s, "%=32s%=5s%=10s%=21s%=16s%=16s",
347  "Name", "Idx", "State", "MTU (L3/IP4/IP6/MPLS)", "Counter",
348  "Count");
349 
350  s = format (s, "%-32U%=5d%=10U%=21U",
354 
355  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
356 
357  return s;
358 }
359 
360 u8 *
362 {
363  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
364  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
365  /* caller supplied display name for this interface */
366  u8 *name = va_arg (*args, u8 *);
368 
369 
370  if (!si)
371  return format (s, "%=32s%=5s%=16s%=16s%=16s",
372  "Name", "Idx", "State", "Counter", "Count");
373 
374  s = format (s, "%-32v%=5d%=16U",
375  name, si->sw_if_index,
377 
378  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
379 
380  return s;
381 }
382 
383 u8 *
384 format_vnet_buffer_flags (u8 * s, va_list * args)
385 {
386  vlib_buffer_t *buf = va_arg (*args, vlib_buffer_t *);
387 
388 #define _(a,b,c,v) if (buf->flags & VNET_BUFFER_F_##b) s = format (s, "%s ", c);
390 #undef _
391  return s;
392 }
393 
394 u8 *
395 format_vnet_buffer_opaque (u8 * s, va_list * args)
396 {
397  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
401  int i;
402 
403  s = format (s, "raw: ");
404 
405  for (i = 0; i < ARRAY_LEN (b->opaque); i++)
406  s = format (s, "%08x ", b->opaque[i]);
407 
408  vec_add1 (s, '\n');
409 
410  s = format (s,
411  "sw_if_index[VLIB_RX]: %d, sw_if_index[VLIB_TX]: %d",
412  o->sw_if_index[0], o->sw_if_index[1]);
413  vec_add1 (s, '\n');
414 
415  s = format (s,
416  "L2 offset %d, L3 offset %d, L4 offset %d, feature arc index %d",
417  (u32) (o->l2_hdr_offset),
418  (u32) (o->l3_hdr_offset),
419  (u32) (o->l4_hdr_offset), (u32) (o->feature_arc_index));
420  vec_add1 (s, '\n');
421 
422  s = format (s,
423  "ip.adj_index[VLIB_RX]: %d, ip.adj_index[VLIB_TX]: %d",
424  (u32) (o->ip.adj_index[0]), (u32) (o->ip.adj_index[1]));
425  vec_add1 (s, '\n');
426 
427  s = format (s,
428  "ip.flow_hash: 0x%x, ip.save_protocol: 0x%x, ip.fib_index: %d",
429  o->ip.flow_hash, o->ip.save_protocol, o->ip.fib_index);
430  vec_add1 (s, '\n');
431 
432  s = format (s,
433  "ip.save_rewrite_length: %d, ip.rpf_id: %d",
434  o->ip.save_rewrite_length, o->ip.rpf_id);
435  vec_add1 (s, '\n');
436 
437  s = format (s,
438  "ip.icmp.type: %d ip.icmp.code: %d, ip.icmp.data: 0x%x",
439  (u32) (o->ip.icmp.type),
440  (u32) (o->ip.icmp.code), o->ip.icmp.data);
441  vec_add1 (s, '\n');
442 
443  s = format (s,
444  "ip.reass.next_index: %d, ip.reass.estimated_mtu: %d",
445  o->ip.reass.next_index, (u32) (o->ip.reass.estimated_mtu));
446  vec_add1 (s, '\n');
447 
448  s = format (s,
449  "ip.reass.fragment_first: %d ip.reass.fragment_last: %d",
450  (u32) (o->ip.reass.fragment_first),
451  (u32) (o->ip.reass.fragment_last));
452  vec_add1 (s, '\n');
453 
454  s = format (s,
455  "ip.reass.range_first: %d ip.reass.range_last: %d",
456  (u32) (o->ip.reass.range_first),
457  (u32) (o->ip.reass.range_last));
458  vec_add1 (s, '\n');
459 
460  s = format (s,
461  "ip.reass.next_range_bi: 0x%x, ip.reass.ip6_frag_hdr_offset: %d",
462  o->ip.reass.next_range_bi,
463  (u32) (o->ip.reass.ip6_frag_hdr_offset));
464  vec_add1 (s, '\n');
465 
466  s = format (s,
467  "mpls.ttl: %d, mpls.exp: %d, mpls.first: %d, "
468  "mpls.save_rewrite_length: %d, mpls.bier.n_bytes: %d",
469  (u32) (o->mpls.ttl), (u32) (o->mpls.exp), (u32) (o->mpls.first),
470  o->mpls.save_rewrite_length, (u32) (o->mpls.bier.n_bytes));
471  vec_add1 (s, '\n');
472 
473  s = format (s,
474  "l2.feature_bitmap: %08x, l2.bd_index: %d, l2.l2_len: %d, "
475  "l2.shg: %d, l2.l2fib_sn: %d, l2.bd_age: %d",
476  o->l2.feature_bitmap, (u32) (o->l2.bd_index),
477  (u32) (o->l2.l2_len), (u32) (o->l2.shg), (u32) (o->l2.l2fib_sn),
478  (u32) (o->l2.bd_age));
479  vec_add1 (s, '\n');
480 
481  s = format (s,
482  "l2.feature_bitmap_input: %U, L2.feature_bitmap_output: %U",
483  format_l2_input_features, o->l2.feature_bitmap, 0,
484  format_l2_output_features, o->l2.feature_bitmap, 0);
485  vec_add1 (s, '\n');
486 
487  s = format (s,
488  "l2t.next_index: %d, l2t.session_index: %d",
489  (u32) (o->l2t.next_index), o->l2t.session_index);
490  vec_add1 (s, '\n');
491 
492  s = format (s,
493  "l2_classify.table_index: %d, l2_classify.opaque_index: %d, "
494  "l2_classify.hash: 0x%llx",
495  o->l2_classify.table_index,
496  o->l2_classify.opaque_index, o->l2_classify.hash);
497  vec_add1 (s, '\n');
498 
499  s = format (s, "policer.index: %d", o->policer.index);
500  vec_add1 (s, '\n');
501 
502  s = format (s, "ipsec.sad_index: %d", o->ipsec.sad_index);
503  vec_add1 (s, '\n');
504 
505  s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
506  vec_add1 (s, '\n');
507 
508  s = format (s,
509  "map_t.v6.saddr: 0x%x, map_t.v6.daddr: 0x%x, "
510  "map_t.v6.frag_offset: %d, map_t.v6.l4_offset: %d",
511  o->map_t.v6.saddr,
512  o->map_t.v6.daddr,
513  (u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset));
514  vec_add1 (s, '\n');
515 
516  s = format (s,
517  "map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
518  "map_t.mtu: %d",
519  (u32) (o->map_t.v6.l4_protocol),
520  (u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
521  vec_add1 (s, '\n');
522 
523  s = format (s,
524  "ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
525  (u32) (o->ip_frag.mtu),
526  (u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
527  vec_add1 (s, '\n');
528 
529  s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
530  vec_add1 (s, '\n');
531 
532  s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
533  vec_add1 (s, '\n');
534 
535  s = format
536  (s, "tcp.connection_index: %d, tcp.seq_number: %d, tcp.seq_end: %d, "
537  "tcp.ack_number: %d, tcp.hdr_offset: %d, tcp.data_offset: %d",
538  o->tcp.connection_index,
539  o->tcp.seq_number,
540  o->tcp.seq_end,
541  o->tcp.ack_number,
542  (u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
543  vec_add1 (s, '\n');
544 
545  s = format (s,
546  "tcp.data_len: %d, tcp.flags: 0x%x",
547  (u32) (o->tcp.data_len), (u32) (o->tcp.flags));
548  vec_add1 (s, '\n');
549 
550  s = format (s, "snat.flags: 0x%x", o->snat.flags);
551  vec_add1 (s, '\n');
552 
553  for (i = 0; i < vec_len (im->buffer_opaque_format_helpers); i++)
554  {
555  helper_fp = im->buffer_opaque_format_helpers[i];
556  s = (*helper_fp) (b, s);
557  }
558 
559  return s;
560 }
561 
562 u8 *
563 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
564 {
565  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
569 
570  int i;
571 
572  s = format (s, "raw: ");
573 
574  for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
575  s = format (s, "%08x ", b->opaque2[i]);
576  vec_add1 (s, '\n');
577 
578  s = format (s, "qos.bits: %x, qos.source: %x",
579  (u32) (o->qos.bits), (u32) (o->qos.source));
580  vec_add1 (s, '\n');
581  s = format (s, "loop_counter: %d", o->loop_counter);
582  vec_add1 (s, '\n');
583 
584  s = format (s, "gbp.flags: %x, gbp.sclass: %d",
585  (u32) (o->gbp.flags), (u32) (o->gbp.sclass));
586  vec_add1 (s, '\n');
587 
588  s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
589  vec_add1 (s, '\n');
590 
591  for (i = 0; i < vec_len (im->buffer_opaque2_format_helpers); i++)
592  {
593  helper_fp = im->buffer_opaque2_format_helpers[i];
594  s = (*helper_fp) (b, s);
595  }
596 
597  return s;
598 }
599 
600 void
602 {
605 }
606 
607 void
609 {
612 }
613 
614 
615 uword
617 {
618  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
619  u32 *hw_if_index = va_arg (*args, u32 *);
622 
623  /* Try per device class functions first. */
624  vec_foreach (c, im->device_classes)
625  {
626  if (c->unformat_device_name
627  && unformat_user (input, c->unformat_device_name, hw_if_index))
628  return 1;
629  }
630 
632  im->hw_interface_by_name, hw_if_index);
633 }
634 
635 uword
637 {
638  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
639  u32 *result = va_arg (*args, u32 *);
641  u32 hw_if_index, id, id_specified;
643  u8 *if_name = 0;
644  uword *p, error = 0;
645 
646  id = ~0;
647  if (unformat (input, "%_%v.%d%_", &if_name, &id)
648  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
649  {
650  hw_if_index = p[0];
651  id_specified = 1;
652  }
653  else
654  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
655  id_specified = 0;
656  else
657  goto done;
658 
659  hi = vnet_get_hw_interface (vnm, hw_if_index);
660  if (!id_specified)
661  {
662  sw_if_index = hi->sw_if_index;
663  }
664  else
665  {
666  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
667  goto done;
668  sw_if_index = p[0];
669  }
670  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
671  goto done;
672  *result = sw_if_index;
673  error = 1;
674 done:
675  vec_free (if_name);
676  return error;
677 }
678 
679 uword
681 {
682  u32 *result = va_arg (*args, u32 *);
683  u32 flags = 0;
684 
685  if (unformat (input, "up"))
687  else if (unformat (input, "down"))
689  else if (unformat (input, "punt"))
691  else if (unformat (input, "enable"))
692  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
693  else
694  return 0;
695 
696  *result = flags;
697  return 1;
698 }
699 
700 uword
702 {
703  u32 *result = va_arg (*args, u32 *);
704  u32 flags = 0;
705 
706  if (unformat (input, "up"))
708  else if (unformat (input, "down"))
710  else
711  return 0;
712 
713  *result = flags;
714  return 1;
715 }
716 
717 /*
718  * fd.io coding-style-patch-verification: ON
719  *
720  * Local Variables:
721  * eval: (c-set-style "gnu")
722  * End:
723  */
u32 opaque2[14]
Definition: buffer.h:170
u8 * format_l2_input_features(u8 *s, va_list *args)
Definition: l2_input.c:68
vmrglw vmrglh hi
u32 flags
Definition: vhost_user.h:141
struct vnet_buffer_opaque_t::@60::@67 ipsec
uword unformat_vnet_hw_interface(unformat_input_t *input, va_list *args)
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
u8 * format_l2_output_features(u8 *s, va_list *args)
Definition: l2_output.c:45
vnet_interface_main_t interface_main
Definition: vnet.h:56
unsigned long u64
Definition: types.h:89
struct vnet_buffer_opaque_t::@60::@69 map_t
u8 * format_vnet_sw_interface_flags(u8 *s, va_list *args)
u8 * format_vnet_sw_interface_cntrs(u8 *s, vnet_interface_main_t *im, vnet_sw_interface_t *si, int json)
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
int i
struct vnet_buffer_opaque_t::@60::@74 snat
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
struct vnet_buffer_opaque_t::@60::@71 cop
static u32 format_get_indent(u8 *s)
Definition: format.h:72
uword * sub_interface_sw_if_index_by_id
Definition: interface.h:554
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
void vnet_register_format_buffer_opaque2_helper(vnet_buffer_opquae_formatter_t fp)
u8 * format_vnet_hw_interface(u8 *s, va_list *args)
struct _vnet_device_class vnet_device_class_t
static u8 * format_vnet_sw_interface_mtu(u8 *s, va_list *args)
unsigned char u8
Definition: types.h:56
double f64
Definition: types.h:142
u8 * format_vnet_hw_interface_link_speed(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@60::opaque_l2 l2
static counter_t vlib_get_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Get the value of a simple counter Scrapes the entire set of per-thread counters.
Definition: counter.h:113
vnet_hw_interface_rx_mode
Definition: interface.h:53
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
struct vnet_buffer_opaque_t::@60::@68 map
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:846
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
struct vnet_buffer_opaque_t::@60::@63 mpls
struct vnet_buffer_opaque_t::@60::@62 ip
vnet_hw_interface_flags_t flags
Definition: interface.h:506
static vnet_sw_interface_t * vnet_get_sup_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
u32 mtu[VNET_N_MTU]
Definition: interface.h:720
unsigned int u32
Definition: types.h:88
A collection of simple counters.
Definition: counter.h:57
u8 * format_vnet_sw_interface(u8 *s, va_list *args)
char * name
The counter collection&#39;s name.
Definition: counter.h:64
uword * hw_interface_by_name
Definition: interface.h:826
vnet_crypto_main_t * cm
Definition: quic_crypto.c:41
u8 * format_vnet_sw_interface_name_override(u8 *s, va_list *args)
#define hash_get(h, key)
Definition: hash.h:249
#define clib_bitmap_foreach(i, ai, body)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
vnet_sub_interface_t sub
Definition: interface.h:723
counter_t packets
packet counter
Definition: counter_types.h:28
struct vnet_buffer_opaque_t::@60::@66 policer
vnet_buffer_opquae_formatter_t * buffer_opaque_format_helpers
Definition: interface.h:858
struct _unformat_input_t unformat_input_t
u8 * format_vnet_sw_if_index_name(u8 *s, va_list *args)
u8 * format_vnet_buffer_flags(u8 *s, va_list *args)
vnet_sw_interface_flags_t flags
Definition: interface.h:703
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:845
uword unformat_vnet_hw_interface_flags(unformat_input_t *input, va_list *args)
unformat_function_t unformat_hash_vec_string
Definition: hash.h:718
u8 name[64]
Definition: memclnt.api:152
void vnet_register_format_buffer_opaque_helper(vnet_buffer_opquae_formatter_t fp)
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:565
struct vnet_buffer_opaque2_t::@94 gbp
svmdb_client_t * c
static void vlib_get_combined_counter(const vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thr...
Definition: counter.h:259
struct vnet_buffer_opaque_t::@60::@70 ip_frag
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
u32 sw_if_index[VLIB_N_RX_TX]
Definition: buffer.h:136
u8 * format_vnet_sw_interface_name(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@60::@64 l2t
#define ARRAY_LEN(x)
Definition: clib.h:63
vl_api_vxlan_gbp_api_tunnel_mode_t mode
Definition: vxlan_gbp.api:44
u8 * format_vnet_hw_if_index_name(u8 *s, va_list *args)
#define ASSERT(truth)
u8 * format_vnet_hw_interface_rx_mode(u8 *s, va_list *args)
static vnet_hw_interface_class_t * vnet_get_hw_interface_class(vnet_main_t *vnm, u32 hw_class_index)
Bitmaps built as vectors of machine words.
vnet_buffer_opquae_formatter_t * buffer_opaque2_format_helpers
Definition: interface.h:859
u8 * format_vnet_buffer_opaque(u8 *s, va_list *args)
counter_t bytes
byte counter
Definition: counter_types.h:29
struct _vnet_hw_interface_class vnet_hw_interface_class_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 * format_vnet_buffer_opaque2(u8 *s, va_list *args)
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
char * name
The counter collection&#39;s name.
Definition: counter.h:193
A collection of combined counters.
Definition: counter.h:188
vnet_sw_interface_type_t type
Definition: interface.h:701
#define vec_foreach(var, vec)
Vector iterator.
u8 *(* vnet_buffer_opquae_formatter_t)(const vlib_buffer_t *b, u8 *s)
Definition: interface.h:817
vnet_device_class_t * device_classes
Definition: interface.h:830
u32 id
Definition: udp.api:45
struct vnet_buffer_opaque_t::@60::@73 tcp
struct vnet_buffer_opaque_t::@60::@72 lisp
uword unformat_vnet_sw_interface(unformat_input_t *input, va_list *args)
static vnet_sw_interface_t * vnet_get_sw_interface_or_null(vnet_main_t *vnm, u32 sw_if_index)
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:153
uword unformat_vnet_sw_interface_flags(unformat_input_t *input, va_list *args)
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
struct vnet_buffer_opaque_t::@60::@65 l2_classify
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)
struct vnet_buffer_opaque2_t::@93 qos
QoS marking data that needs to persist from the recording nodes (nominally in the ingress path) to th...