FD.io VPP  v19.01.3-6-g70449b9b9
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 if (flags & VNET_SW_INTERFACE_FLAG_BOND_SLAVE)
53  s = format (s, "bond-slave");
54  else
55  {
56  s = format (s, "%s",
57  (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "down");
58  if (flags & VNET_SW_INTERFACE_FLAG_PUNT)
59  s = format (s, "/punt");
60  }
61 
62  return s;
63 }
64 
65 u8 *
66 format_vnet_hw_interface_rx_mode (u8 * s, va_list * args)
67 {
69 
71  return format (s, "polling");
72 
74  return format (s, "interrupt");
75 
77  return format (s, "adaptive");
78 
79  return format (s, "unknown");
80 }
81 
82 u8 *
84 {
85  u32 link_speed = va_arg (*args, u32);
86 
87  if (link_speed == 0)
88  return format (s, "unknown");
89 
90  if (link_speed >= 1000000)
91  return format (s, "%f Gbps", (f64) link_speed / 1000000);
92 
93  if (link_speed >= 1000)
94  return format (s, "%f Mbps", (f64) link_speed / 1000);
95 
96  return format (s, "%u Kbps", link_speed);
97 }
98 
99 
100 u8 *
101 format_vnet_hw_interface (u8 * s, va_list * args)
102 {
103  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
104  vnet_hw_interface_t *hi = va_arg (*args, vnet_hw_interface_t *);
105  vnet_hw_interface_class_t *hw_class;
106  vnet_device_class_t *dev_class;
107  int verbose = va_arg (*args, int);
108  u32 indent;
109 
110  if (!hi)
111  return format (s, "%=32s%=6s%=8s%s", "Name", "Idx", "Link", "Hardware");
112 
113  indent = format_get_indent (s);
114 
115  s = format (s, "%-32v%=6d", hi->name, hi->hw_if_index);
116 
118  s = format (s, "%=8s", "slave");
119  else
120  s = format (s, "%=8s",
121  hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP ? "up" : "down");
122 
123  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
124  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
125 
127  {
128  int hw_idx;
129  s = format (s, "Slave-Idx:");
130  clib_bitmap_foreach (hw_idx, hi->bond_info, s =
131  format (s, " %d", hw_idx));
132  }
133  else if (dev_class->format_device_name)
134  s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
135  else
136  s = format (s, "%s%d", dev_class->name, hi->dev_instance);
137 
138  s = format (s, "\n%ULink speed: %U", format_white_space, indent + 2,
140 
141  if (verbose)
142  {
143  if (hw_class->format_device)
144  s = format (s, "\n%U%U",
145  format_white_space, indent + 2,
146  hw_class->format_device, hi->hw_if_index, verbose);
147  else
148  {
149  s = format (s, "\n%U%s",
150  format_white_space, indent + 2, hw_class->name);
151  if (hw_class->format_address && vec_len (hi->hw_address) > 0)
152  s =
153  format (s, " address %U", hw_class->format_address,
154  hi->hw_address);
155  }
156 
157  if (dev_class->format_device)
158  s = format (s, "\n%U%U",
159  format_white_space, indent + 2,
160  dev_class->format_device, hi->dev_instance, verbose);
161  }
162 
163  return s;
164 }
165 
166 u8 *
167 format_vnet_sw_interface_name (u8 * s, va_list * args)
168 {
169  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
170  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
171  vnet_sw_interface_t *si_sup =
173  vnet_hw_interface_t *hi_sup;
174 
176  hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
177 
178  s = format (s, "%v", hi_sup->name);
179 
181  s = format (s, ".%d", si->sub.id);
182 
183  return s;
184 }
185 
186 u8 *
187 format_vnet_sw_if_index_name (u8 * s, va_list * args)
188 {
189  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
190  u32 sw_if_index = va_arg (*args, u32);
192 
193  si = vnet_get_sw_interface_safe (vnm, sw_if_index);
194 
195  if (NULL == si)
196  {
197  return format (s, "DELETED");
198  }
199  return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
200 }
201 
202 u8 *
203 format_vnet_hw_if_index_name (u8 * s, va_list * args)
204 {
205  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
206  u32 hw_if_index = va_arg (*args, u32);
208 
209  hi = vnet_get_hw_interface (vnm, hw_if_index);
210 
211  if (hi == 0)
212  return format (s, "DELETED");
213 
214  return format (s, "%v", hi->name);
215 }
216 
217 u8 *
219  vnet_sw_interface_t * si)
220 {
221  u32 indent, n_printed;
222  int i, j, n_counters;
223  static vnet_main_t **my_vnet_mains;
224 
225  vec_reset_length (my_vnet_mains);
226 
227  indent = format_get_indent (s);
228  n_printed = 0;
229 
230  {
232  vlib_counter_t v, vtotal;
233  u8 *n = 0;
234 
235  for (i = 0; i < vec_len (vnet_mains); i++)
236  {
237  if (vnet_mains[i])
238  vec_add1 (my_vnet_mains, vnet_mains[i]);
239  }
240 
241  if (vec_len (my_vnet_mains) == 0)
242  vec_add1 (my_vnet_mains, &vnet_main);
243 
244  /* Each vnet_main_t has its own copy of the interface counters */
245  n_counters = vec_len (im->combined_sw_if_counters);
246 
247  /* rx, tx counters... */
248  for (j = 0; j < n_counters; j++)
249  {
250  vtotal.packets = 0;
251  vtotal.bytes = 0;
252 
253  for (i = 0; i < vec_len (my_vnet_mains); i++)
254  {
255  im = &my_vnet_mains[i]->interface_main;
256  cm = im->combined_sw_if_counters + j;
258  vtotal.packets += v.packets;
259  vtotal.bytes += v.bytes;
260  }
261 
262  /* Only display non-zero counters. */
263  if (vtotal.packets == 0)
264  continue;
265 
266  if (n_printed > 0)
267  s = format (s, "\n%U", format_white_space, indent);
268  n_printed += 2;
269 
270  if (n)
271  _vec_len (n) = 0;
272  n = format (n, "%s packets", cm->name);
273  s = format (s, "%-16v%16Ld", n, vtotal.packets);
274 
275  _vec_len (n) = 0;
276  n = format (n, "%s bytes", cm->name);
277  s = format (s, "\n%U%-16v%16Ld",
278  format_white_space, indent, n, vtotal.bytes);
279  }
280  vec_free (n);
281  }
282 
283  {
285  u64 v, vtotal;
286 
287  n_counters = vec_len (im->sw_if_counters);
288 
289  for (j = 0; j < n_counters; j++)
290  {
291  vtotal = 0;
292 
293  for (i = 0; i < vec_len (my_vnet_mains); i++)
294  {
295  im = &my_vnet_mains[i]->interface_main;
296  cm = im->sw_if_counters + j;
297 
298  v = vlib_get_simple_counter (cm, si->sw_if_index);
299  vtotal += v;
300  }
301 
302  /* Only display non-zero counters. */
303  if (vtotal == 0)
304  continue;
305 
306  if (n_printed > 0)
307  s = format (s, "\n%U", format_white_space, indent);
308  n_printed += 1;
309 
310  s = format (s, "%-16s%16Ld", cm->name, vtotal);
311  }
312  }
313 
314  return s;
315 }
316 
317 static u8 *
318 format_vnet_sw_interface_mtu (u8 * s, va_list * args)
319 {
320  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
321 
322  return format (s, "%d/%d/%d/%d", si->mtu[VNET_MTU_L3],
323  si->mtu[VNET_MTU_IP4],
324  si->mtu[VNET_MTU_IP6], si->mtu[VNET_MTU_MPLS]);
325 }
326 
327 u8 *
328 format_vnet_sw_interface (u8 * s, va_list * args)
329 {
330  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
331  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
333 
334  if (!si)
335  return format (s, "%=32s%=5s%=10s%=21s%=16s%=16s",
336  "Name", "Idx", "State", "MTU (L3/IP4/IP6/MPLS)", "Counter",
337  "Count");
338 
339  s = format (s, "%-32U%=5d%=10U%=21U",
343 
344  s = format_vnet_sw_interface_cntrs (s, im, si);
345 
346  return s;
347 }
348 
349 u8 *
351 {
352  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
353  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
354  /* caller supplied display name for this interface */
355  u8 *name = va_arg (*args, u8 *);
357 
358 
359  if (!si)
360  return format (s, "%=32s%=5s%=16s%=16s%=16s",
361  "Name", "Idx", "State", "Counter", "Count");
362 
363  s = format (s, "%-32v%=5d%=16U",
364  name, si->sw_if_index,
366 
367  s = format_vnet_sw_interface_cntrs (s, im, si);
368 
369  return s;
370 }
371 
372 u8 *
373 format_vnet_buffer_flags (u8 * s, va_list * args)
374 {
375  vlib_buffer_t *buf = va_arg (*args, vlib_buffer_t *);
376 
377 #define _(a,b,c,v) if (buf->flags & VNET_BUFFER_F_##b) s = format (s, "%s ", c);
379 #undef _
380  return s;
381 }
382 
383 u8 *
384 format_vnet_buffer_opaque (u8 * s, va_list * args)
385 {
386  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
388  int i;
389 
390  s = format (s, "raw: ");
391 
392  for (i = 0; i < ARRAY_LEN (b->opaque); i++)
393  s = format (s, "%08x ", b->opaque[i]);
394 
395  vec_add1 (s, '\n');
396 
397  s = format (s,
398  "sw_if_index[VLIB_RX]: %d, sw_if_index[VLIB_TX]: %d",
399  o->sw_if_index[0], o->sw_if_index[1]);
400  vec_add1 (s, '\n');
401 
402  s = format (s,
403  "L2 offset %d, L3 offset %d, L4 offset %d, feature arc index %d",
404  (u32) (o->l2_hdr_offset),
405  (u32) (o->l3_hdr_offset),
406  (u32) (o->l4_hdr_offset), (u32) (o->feature_arc_index));
407  vec_add1 (s, '\n');
408 
409  s = format (s,
410  "ip.adj_index[VLIB_RX]: %d, ip.adj_index[VLIB_TX]: %d",
411  (u32) (o->ip.adj_index[0]), (u32) (o->ip.adj_index[1]));
412  vec_add1 (s, '\n');
413 
414  s = format (s,
415  "ip.flow_hash: 0x%x, ip.save_protocol: 0x%x, ip.fib_index: %d",
416  o->ip.flow_hash, o->ip.save_protocol, o->ip.fib_index);
417  vec_add1 (s, '\n');
418 
419  s = format (s,
420  "ip.save_rewrite_length: %d, ip.rpf_id: %d",
421  o->ip.save_rewrite_length, o->ip.rpf_id);
422  vec_add1 (s, '\n');
423 
424  s = format (s,
425  "ip.icmp.type: %d ip.icmp.code: %d, ip.icmp.data: 0x%x",
426  (u32) (o->ip.icmp.type),
427  (u32) (o->ip.icmp.code), o->ip.icmp.data);
428  vec_add1 (s, '\n');
429 
430  s = format (s,
431  "ip.reass.next_index: %d, ip.reass.estimated_mtu: %d",
432  o->ip.reass.next_index, (u32) (o->ip.reass.estimated_mtu));
433  vec_add1 (s, '\n');
434 
435  s = format (s,
436  "ip.reass.fragment_first: %d ip.reass.fragment_last: %d",
437  (u32) (o->ip.reass.fragment_first),
438  (u32) (o->ip.reass.fragment_last));
439  vec_add1 (s, '\n');
440 
441  s = format (s,
442  "ip.reass.range_first: %d ip.reass.range_last: %d",
443  (u32) (o->ip.reass.range_first),
444  (u32) (o->ip.reass.range_last));
445  vec_add1 (s, '\n');
446 
447  s = format (s,
448  "ip.reass.next_range_bi: 0x%x, ip.reass.ip6_frag_hdr_offset: %d",
449  o->ip.reass.next_range_bi,
450  (u32) (o->ip.reass.ip6_frag_hdr_offset));
451  vec_add1 (s, '\n');
452 
453  s = format (s,
454  "mpls.ttl: %d, mpls.exp: %d, mpls.first: %d, "
455  "mpls.save_rewrite_length: %d, mpls.bier.n_bytes: %d",
456  (u32) (o->mpls.ttl), (u32) (o->mpls.exp), (u32) (o->mpls.first),
457  o->mpls.save_rewrite_length, (u32) (o->mpls.bier.n_bytes));
458  vec_add1 (s, '\n');
459 
460  s = format (s,
461  "l2.feature_bitmap: %08x, l2.bd_index: %d, l2.l2_len: %d, "
462  "l2.shg: %d, l2.l2fib_sn: %d, l2.bd_age: %d",
463  o->l2.feature_bitmap, (u32) (o->l2.bd_index),
464  (u32) (o->l2.l2_len), (u32) (o->l2.shg), (u32) (o->l2.l2fib_sn),
465  (u32) (o->l2.bd_age));
466  vec_add1 (s, '\n');
467 
468  s = format (s,
469  "l2.feature_bitmap_input: %U, L2.feature_bitmap_output: %U",
470  format_l2_input_features, o->l2.feature_bitmap, 0,
471  format_l2_output_features, o->l2.feature_bitmap, 0);
472  vec_add1 (s, '\n');
473 
474  s = format (s,
475  "l2t.next_index: %d, l2t.session_index: %d",
476  (u32) (o->l2t.next_index), o->l2t.session_index);
477  vec_add1 (s, '\n');
478 
479  s = format (s,
480  "l2_classify.table_index: %d, l2_classify.opaque_index: %d, "
481  "l2_classify.hash: 0x%llx",
482  o->l2_classify.table_index,
483  o->l2_classify.opaque_index, o->l2_classify.hash);
484  vec_add1 (s, '\n');
485 
486  s = format (s, "policer.index: %d", o->policer.index);
487  vec_add1 (s, '\n');
488 
489  s = format (s,
490  "ipsec.flags: 0x%x, ipsec.sad_index: %d",
491  o->ipsec.flags, o->ipsec.sad_index);
492  vec_add1 (s, '\n');
493 
494  s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
495  vec_add1 (s, '\n');
496 
497  s = format (s,
498  "map_t.v6.saddr: 0x%x, map_t.v6.daddr: 0x%x, "
499  "map_t.v6.frag_offset: %d, map_t.v6.l4_offset: %d",
500  o->map_t.v6.saddr,
501  o->map_t.v6.daddr,
502  (u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset));
503  vec_add1 (s, '\n');
504 
505  s = format (s,
506  "map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
507  "map_t.mtu: %d",
508  (u32) (o->map_t.v6.l4_protocol),
509  (u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
510  vec_add1 (s, '\n');
511 
512  s = format (s,
513  "ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
514  (u32) (o->ip_frag.mtu),
515  (u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
516  vec_add1 (s, '\n');
517 
518  s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
519  vec_add1 (s, '\n');
520 
521  s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
522  vec_add1 (s, '\n');
523 
524  s = format
525  (s, "tcp.connection_index: %d, tcp.seq_number: %d, tcp.seq_end: %d, "
526  "tcp.ack_number: %d, tcp.hdr_offset: %d, tcp.data_offset: %d",
527  o->tcp.connection_index,
528  o->tcp.seq_number,
529  o->tcp.seq_end,
530  o->tcp.ack_number,
531  (u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
532  vec_add1 (s, '\n');
533 
534  s = format (s,
535  "tcp.data_len: %d, tcp.flags: 0x%x",
536  (u32) (o->tcp.data_len), (u32) (o->tcp.flags));
537  vec_add1 (s, '\n');
538 
539  s = format (s,
540  "sctp.connection_index: %d, sctp.sid: %d, sctp.ssn: %d, "
541  "sctp.tsn: %d, sctp.hdr_offset: %d",
542  o->sctp.connection_index,
543  (u32) (o->sctp.sid),
544  (u32) (o->sctp.ssn),
545  (u32) (o->sctp.tsn), (u32) (o->sctp.hdr_offset));
546  vec_add1 (s, '\n');
547 
548  s = format
549  (s, "sctp.data_offset: %d, sctp.data_len: %d, sctp.subconn_idx: %d, "
550  "sctp.flags: 0x%x",
551  (u32) (o->sctp.data_offset),
552  (u32) (o->sctp.data_len),
553  (u32) (o->sctp.subconn_idx), (u32) (o->sctp.flags));
554  vec_add1 (s, '\n');
555 
556  s = format (s, "snat.flags: 0x%x", o->snat.flags);
557  vec_add1 (s, '\n');
558  return s;
559 }
560 
561 u8 *
562 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
563 {
564  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
566 
567  int i;
568 
569  s = format (s, "raw: ");
570 
571  for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
572  s = format (s, "%08x ", b->opaque2[i]);
573  vec_add1 (s, '\n');
574 
575  s = format (s, "qos.bits: %x, qos.source: %x",
576  (u32) (o->qos.bits), (u32) (o->qos.source));
577  vec_add1 (s, '\n');
578  s = format (s, "loop_counter: %d", o->loop_counter);
579  vec_add1 (s, '\n');
580 
581  s = format (s, "gbp.flags: %x, gbp.src_epg: %d",
582  (u32) (o->gbp.flags), (u32) (o->gbp.src_epg));
583  vec_add1 (s, '\n');
584 
585  s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
586  vec_add1 (s, '\n');
587  return s;
588 }
589 
590 uword
592 {
593  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
594  u32 *hw_if_index = va_arg (*args, u32 *);
597 
598  /* Try per device class functions first. */
599  vec_foreach (c, im->device_classes)
600  {
601  if (c->unformat_device_name
602  && unformat_user (input, c->unformat_device_name, hw_if_index))
603  return 1;
604  }
605 
607  im->hw_interface_by_name, hw_if_index);
608 }
609 
610 uword
612 {
613  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
614  u32 *result = va_arg (*args, u32 *);
616  u32 hw_if_index, id, id_specified;
618  u8 *if_name = 0;
619  uword *p, error = 0;
620 
621  id = ~0;
622  if (unformat (input, "%_%v.%d%_", &if_name, &id)
623  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
624  {
625  hw_if_index = p[0];
626  id_specified = 1;
627  }
628  else
629  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
630  id_specified = 0;
631  else
632  goto done;
633 
634  hi = vnet_get_hw_interface (vnm, hw_if_index);
635  if (!id_specified)
636  {
637  sw_if_index = hi->sw_if_index;
638  }
639  else
640  {
641  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
642  goto done;
643  sw_if_index = p[0];
644  }
645  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
646  goto done;
647  *result = sw_if_index;
648  error = 1;
649 done:
650  vec_free (if_name);
651  return error;
652 }
653 
654 uword
656 {
657  u32 *result = va_arg (*args, u32 *);
658  u32 flags = 0;
659 
660  if (unformat (input, "up"))
662  else if (unformat (input, "down"))
664  else if (unformat (input, "punt"))
666  else if (unformat (input, "enable"))
667  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
668  else
669  return 0;
670 
671  *result = flags;
672  return 1;
673 }
674 
675 uword
677 {
678  u32 *result = va_arg (*args, u32 *);
679  u32 flags = 0;
680 
681  if (unformat (input, "up"))
683  else if (unformat (input, "down"))
685  else
686  return 0;
687 
688  *result = flags;
689  return 1;
690 }
691 
692 /*
693  * fd.io coding-style-patch-verification: ON
694  *
695  * Local Variables:
696  * eval: (c-set-style "gnu")
697  * End:
698  */
struct vnet_buffer_opaque2_t::@89 gbp
u8 * format_l2_input_features(u8 *s, va_list *args)
Definition: l2_input.c:66
vmrglw vmrglh hi
u32 flags
Definition: vhost_user.h:115
struct vnet_buffer_opaque_t::@56::@64 map
struct vnet_buffer_opaque_t::@56::@61 l2_classify
uword unformat_vnet_hw_interface(unformat_input_t *input, va_list *args)
u8 * format_l2_output_features(u8 *s, va_list *args)
Definition: l2_output.c:45
struct vnet_buffer_opaque_t::@56::@71 snat
vnet_interface_main_t interface_main
Definition: vnet.h:56
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:146
unsigned long u64
Definition: types.h:89
u8 * format_vnet_sw_interface_flags(u8 *s, va_list *args)
#define NULL
Definition: clib.h:58
vnet_main_t ** vnet_mains
Definition: misc.c:44
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:525
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
static u32 format_get_indent(u8 *s)
Definition: format.h:72
uword * sub_interface_sw_if_index_by_id
Definition: interface.h:564
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
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
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
u8 * format_vnet_hw_interface_link_speed(u8 *s, va_list *args)
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:52
u32 sw_if_index
Definition: vxlan_gbp.api:37
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
struct vnet_buffer_opaque_t::@56::@68 lisp
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:839
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
vnet_hw_interface_flags_t flags
Definition: interface.h:516
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:723
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:819
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:726
counter_t packets
packet counter
Definition: counter_types.h:28
struct vnet_buffer_opaque_t::@56::@60 l2t
struct vnet_buffer_opaque_t::@56::opaque_l2 l2
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:706
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:838
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
struct vnet_buffer_opaque_t::@56::@70 sctp
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:575
struct vnet_buffer_opaque_t::@56::@67 cop
svmdb_client_t * c
struct vnet_buffer_opaque2_t::@88 qos
QoS marking data that needs to persist from the recording nodes (nominally in the ingress path) to th...
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
#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
static vnet_sw_interface_t * vnet_get_sw_interface_safe(vnet_main_t *vnm, u32 sw_if_index)
u8 * format_vnet_sw_interface_name(u8 *s, va_list *args)
#define ARRAY_LEN(x)
Definition: clib.h:62
struct vnet_buffer_opaque_t::@56::@65 map_t
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.
struct vnet_buffer_opaque_t::@56::@63 ipsec
u8 * format_vnet_sw_interface_cntrs(u8 *s, vnet_interface_main_t *im, vnet_sw_interface_t *si)
u8 * format_vnet_buffer_opaque(u8 *s, va_list *args)
counter_t bytes
byte counter
Definition: counter_types.h:29
u32 opaque2[12]
More opaque data, see ../vnet/vnet/buffer.h.
Definition: buffer.h:164
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)
u64 uword
Definition: types.h:112
char * name
The counter collection&#39;s name.
Definition: counter.h:193
struct vnet_buffer_opaque_t::@56::@69 tcp
A collection of combined counters.
Definition: counter.h:188
struct vnet_buffer_opaque_t::@56::@62 policer
struct vnet_buffer_opaque_t::@56::@66 ip_frag
vl_api_gbp_vxlan_tunnel_mode_t mode
Definition: gbp.api:349
vnet_sw_interface_type_t type
Definition: interface.h:704
#define vec_foreach(var, vec)
Vector iterator.
vnet_device_class_t * device_classes
Definition: interface.h:823
u32 id
Definition: udp.api:45
uword unformat_vnet_sw_interface(unformat_input_t *input, va_list *args)
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:972
struct vnet_buffer_opaque_t::@56::@59 mpls
struct vnet_buffer_opaque_t::@56::@58 ip
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)