FD.io VPP  v19.04.4-rc0-5-ge88582fac
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_or_null (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, "ipsec.sad_index: %d", o->ipsec.sad_index);
490  vec_add1 (s, '\n');
491 
492  s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
493  vec_add1 (s, '\n');
494 
495  s = format (s,
496  "map_t.v6.saddr: 0x%x, map_t.v6.daddr: 0x%x, "
497  "map_t.v6.frag_offset: %d, map_t.v6.l4_offset: %d",
498  o->map_t.v6.saddr,
499  o->map_t.v6.daddr,
500  (u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset));
501  vec_add1 (s, '\n');
502 
503  s = format (s,
504  "map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
505  "map_t.mtu: %d",
506  (u32) (o->map_t.v6.l4_protocol),
507  (u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
508  vec_add1 (s, '\n');
509 
510  s = format (s,
511  "ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
512  (u32) (o->ip_frag.mtu),
513  (u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
514  vec_add1 (s, '\n');
515 
516  s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
517  vec_add1 (s, '\n');
518 
519  s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
520  vec_add1 (s, '\n');
521 
522  s = format
523  (s, "tcp.connection_index: %d, tcp.seq_number: %d, tcp.seq_end: %d, "
524  "tcp.ack_number: %d, tcp.hdr_offset: %d, tcp.data_offset: %d",
525  o->tcp.connection_index,
526  o->tcp.seq_number,
527  o->tcp.seq_end,
528  o->tcp.ack_number,
529  (u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
530  vec_add1 (s, '\n');
531 
532  s = format (s,
533  "tcp.data_len: %d, tcp.flags: 0x%x",
534  (u32) (o->tcp.data_len), (u32) (o->tcp.flags));
535  vec_add1 (s, '\n');
536 
537  s = format (s,
538  "sctp.connection_index: %d, sctp.sid: %d, sctp.ssn: %d, "
539  "sctp.tsn: %d, sctp.hdr_offset: %d",
540  o->sctp.connection_index,
541  (u32) (o->sctp.sid),
542  (u32) (o->sctp.ssn),
543  (u32) (o->sctp.tsn), (u32) (o->sctp.hdr_offset));
544  vec_add1 (s, '\n');
545 
546  s = format
547  (s, "sctp.data_offset: %d, sctp.data_len: %d, sctp.subconn_idx: %d, "
548  "sctp.flags: 0x%x",
549  (u32) (o->sctp.data_offset),
550  (u32) (o->sctp.data_len),
551  (u32) (o->sctp.subconn_idx), (u32) (o->sctp.flags));
552  vec_add1 (s, '\n');
553 
554  s = format (s, "snat.flags: 0x%x", o->snat.flags);
555  vec_add1 (s, '\n');
556  return s;
557 }
558 
559 u8 *
560 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
561 {
562  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
564 
565  int i;
566 
567  s = format (s, "raw: ");
568 
569  for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
570  s = format (s, "%08x ", b->opaque2[i]);
571  vec_add1 (s, '\n');
572 
573  s = format (s, "qos.bits: %x, qos.source: %x",
574  (u32) (o->qos.bits), (u32) (o->qos.source));
575  vec_add1 (s, '\n');
576  s = format (s, "loop_counter: %d", o->loop_counter);
577  vec_add1 (s, '\n');
578 
579  s = format (s, "gbp.flags: %x, gbp.sclass: %d",
580  (u32) (o->gbp.flags), (u32) (o->gbp.sclass));
581  vec_add1 (s, '\n');
582 
583  s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
584  vec_add1 (s, '\n');
585  return s;
586 }
587 
588 uword
590 {
591  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
592  u32 *hw_if_index = va_arg (*args, u32 *);
595 
596  /* Try per device class functions first. */
597  vec_foreach (c, im->device_classes)
598  {
599  if (c->unformat_device_name
600  && unformat_user (input, c->unformat_device_name, hw_if_index))
601  return 1;
602  }
603 
605  im->hw_interface_by_name, hw_if_index);
606 }
607 
608 uword
610 {
611  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
612  u32 *result = va_arg (*args, u32 *);
614  u32 hw_if_index, id, id_specified;
616  u8 *if_name = 0;
617  uword *p, error = 0;
618 
619  id = ~0;
620  if (unformat (input, "%_%v.%d%_", &if_name, &id)
621  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
622  {
623  hw_if_index = p[0];
624  id_specified = 1;
625  }
626  else
627  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
628  id_specified = 0;
629  else
630  goto done;
631 
632  hi = vnet_get_hw_interface (vnm, hw_if_index);
633  if (!id_specified)
634  {
635  sw_if_index = hi->sw_if_index;
636  }
637  else
638  {
639  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
640  goto done;
641  sw_if_index = p[0];
642  }
643  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
644  goto done;
645  *result = sw_if_index;
646  error = 1;
647 done:
648  vec_free (if_name);
649  return error;
650 }
651 
652 uword
654 {
655  u32 *result = va_arg (*args, u32 *);
656  u32 flags = 0;
657 
658  if (unformat (input, "up"))
660  else if (unformat (input, "down"))
662  else if (unformat (input, "punt"))
664  else if (unformat (input, "enable"))
665  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
666  else
667  return 0;
668 
669  *result = flags;
670  return 1;
671 }
672 
673 uword
675 {
676  u32 *result = va_arg (*args, u32 *);
677  u32 flags = 0;
678 
679  if (unformat (input, "up"))
681  else if (unformat (input, "down"))
683  else
684  return 0;
685 
686  *result = flags;
687  return 1;
688 }
689 
690 /*
691  * fd.io coding-style-patch-verification: ON
692  *
693  * Local Variables:
694  * eval: (c-set-style "gnu")
695  * End:
696  */
u32 opaque2[14]
Definition: buffer.h:170
u32 sw_if_index
Definition: ipsec_gre.api:37
u8 * format_l2_input_features(u8 *s, va_list *args)
Definition: l2_input.c:68
vmrglw vmrglh hi
u32 flags
Definition: vhost_user.h:115
struct vnet_buffer_opaque2_t::@90 qos
QoS marking data that needs to persist from the recording nodes (nominally in the ingress path) to th...
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
vnet_interface_main_t interface_main
Definition: vnet.h:56
unsigned long u64
Definition: types.h:89
struct vnet_buffer_opaque_t::@58::@63 l2_classify
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:522
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:542
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
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)
struct vnet_buffer_opaque_t::@58::opaque_l2 l2
struct vnet_buffer_opaque_t::@58::@66 map
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
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:824
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
vnet_hw_interface_flags_t flags
Definition: interface.h:494
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:701
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)
struct vnet_buffer_opaque2_t::@91 gbp
struct vnet_buffer_opaque_t::@58::@69 cop
char * name
The counter collection&#39;s name.
Definition: counter.h:64
uword * hw_interface_by_name
Definition: interface.h:804
u8 * format_vnet_sw_interface_name_override(u8 *s, va_list *args)
#define hash_get(h, key)
Definition: hash.h:249
struct vnet_buffer_opaque_t::@58::@70 lisp
#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:704
counter_t packets
packet counter
Definition: counter_types.h:28
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:684
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:823
struct vnet_buffer_opaque_t::@58::@67 map_t
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::@58::@64 policer
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:553
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::@58::@62 l2t
struct vnet_buffer_opaque_t::@58::@71 tcp
#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)
#define ARRAY_LEN(x)
Definition: clib.h:62
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.
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
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
struct vnet_buffer_opaque_t::@58::@73 snat
char * name
The counter collection&#39;s name.
Definition: counter.h:193
struct vnet_buffer_opaque_t::@58::@68 ip_frag
A collection of combined counters.
Definition: counter.h:188
struct vnet_buffer_opaque_t::@58::@61 mpls
vnet_sw_interface_type_t type
Definition: interface.h:682
struct vnet_buffer_opaque_t::@58::@65 ipsec
#define vec_foreach(var, vec)
Vector iterator.
vnet_device_class_t * device_classes
Definition: interface.h:808
u32 id
Definition: udp.api:45
struct vnet_buffer_opaque_t::@58::@60 ip
struct vnet_buffer_opaque_t::@58::@72 sctp
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:972
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)