FD.io VPP  v20.05.1-5-g09f167997
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 #include <vnet/l2/l2_vtr.h>
45 
46 u8 *
47 format_vtr (u8 * s, va_list * args)
48 {
49  u32 vtr_op = va_arg (*args, u32);
50  u32 dot1q = va_arg (*args, u32);
51  u32 tag1 = va_arg (*args, u32);
52  u32 tag2 = va_arg (*args, u32);
53  switch (vtr_op)
54  {
55  case L2_VTR_DISABLED:
56  return format (s, "none");
57  case L2_VTR_PUSH_1:
58  return format (s, "push-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
59  case L2_VTR_PUSH_2:
60  return format (s, "push-2 %s %d %d", dot1q ? "dot1q" : "dot1ad", tag1,
61  tag2);
62  case L2_VTR_POP_1:
63  return format (s, "pop-1");
64  case L2_VTR_POP_2:
65  return format (s, "pop-2");
67  return format (s, "trans-1-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
69  return format (s, "trans-1-2 %s %d %d", dot1q ? "dot1q" : "dot1ad",
70  tag1, tag2);
72  return format (s, "trans-2-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
74  return format (s, "trans-2-2 %s %d %d", dot1q ? "dot1q" : "dot1ad",
75  tag1, tag2);
76  default:
77  return format (s, "none");
78  }
79 }
80 
81 u8 *
82 format_vnet_sw_interface_flags (u8 * s, va_list * args)
83 {
84  u32 flags = va_arg (*args, u32);
85 
86  if (flags & VNET_SW_INTERFACE_FLAG_ERROR)
87  s = format (s, "error");
88  else
89  {
90  s = format (s, "%s",
91  (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "down");
92  if (flags & VNET_SW_INTERFACE_FLAG_PUNT)
93  s = format (s, "/punt");
94  }
95 
96  return s;
97 }
98 
99 u8 *
101 {
103 
105  return format (s, "polling");
106 
108  return format (s, "interrupt");
109 
111  return format (s, "adaptive");
112 
113  return format (s, "unknown");
114 }
115 
116 u8 *
118 {
119  u32 link_speed = va_arg (*args, u32);
120 
121  if (link_speed == 0)
122  return format (s, "unknown");
123 
124  if (link_speed >= 1000000)
125  return format (s, "%f Gbps", (f64) link_speed / 1000000);
126 
127  if (link_speed >= 1000)
128  return format (s, "%f Mbps", (f64) link_speed / 1000);
129 
130  return format (s, "%u Kbps", link_speed);
131 }
132 
133 
134 u8 *
135 format_vnet_hw_interface (u8 * s, va_list * args)
136 {
137  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
138  vnet_hw_interface_t *hi = va_arg (*args, vnet_hw_interface_t *);
139  vnet_hw_interface_class_t *hw_class;
140  vnet_device_class_t *dev_class;
141  int verbose = va_arg (*args, int);
142  u32 indent;
143 
144  if (!hi)
145  return format (s, "%=32s%=6s%=8s%s", "Name", "Idx", "Link", "Hardware");
146 
147  indent = format_get_indent (s);
148 
149  s = format (s, "%-32v%=6d", hi->name, hi->hw_if_index);
150 
152  s = format (s, "%=8s", "slave");
153  else
154  s = format (s, "%=8s",
155  hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP ? "up" : "down");
156 
157  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
158  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
159 
161  {
162  int hw_idx;
163  s = format (s, "Slave-Idx:");
164  clib_bitmap_foreach (hw_idx, hi->bond_info, s =
165  format (s, " %d", hw_idx));
166  }
167  else if (dev_class->format_device_name)
168  s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
169  else
170  s = format (s, "%s%d", dev_class->name, hi->dev_instance);
171 
172  s = format (s, "\n%ULink speed: %U", format_white_space, indent + 2,
174 
175  if (verbose)
176  {
177  if (hw_class->format_device)
178  s = format (s, "\n%U%U",
179  format_white_space, indent + 2,
180  hw_class->format_device, hi->hw_if_index, verbose);
181  else
182  {
183  s = format (s, "\n%U%s",
184  format_white_space, indent + 2, hw_class->name);
185  if (hw_class->format_address && vec_len (hi->hw_address) > 0)
186  s =
187  format (s, " address %U", hw_class->format_address,
188  hi->hw_address);
189  }
190 
191  if (dev_class->format_device)
192  s = format (s, "\n%U%U",
193  format_white_space, indent + 2,
194  dev_class->format_device, hi->dev_instance, verbose);
195  }
196 
197  return s;
198 }
199 
200 u8 *
201 format_vnet_sw_interface_name (u8 * s, va_list * args)
202 {
203  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
204  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
205  vnet_sw_interface_t *si_sup =
207  vnet_hw_interface_t *hi_sup;
208 
210  hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
211 
212  s = format (s, "%v", hi_sup->name);
213 
215  s = format (s, ".%d", si->sub.id);
216 
217  return s;
218 }
219 
220 u8 *
221 format_vnet_sw_if_index_name (u8 * s, va_list * args)
222 {
223  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
224  u32 sw_if_index = va_arg (*args, u32);
226 
227  si = vnet_get_sw_interface_or_null (vnm, sw_if_index);
228 
229  if (NULL == si)
230  {
231  return format (s, "DELETED");
232  }
233  return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
234 }
235 
236 u8 *
237 format_vnet_hw_if_index_name (u8 * s, va_list * args)
238 {
239  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
240  u32 hw_if_index = va_arg (*args, u32);
242 
243  hi = vnet_get_hw_interface (vnm, hw_if_index);
244 
245  if (hi == 0)
246  return format (s, "DELETED");
247 
248  return format (s, "%v", hi->name);
249 }
250 
251 u8 *
253  vnet_sw_interface_t * si, int json)
254 {
255  u32 indent, n_printed;
256  int j, n_counters;
257  char *x = "";
258  int json_need_comma_nl = 0;
259  u8 *n = 0;
260 
261  /*
262  * to output a json snippet, stick quotes in lots of places
263  * definitely deserves a one-character variable name.
264  */
265  if (json)
266  x = "\"";
267 
268  indent = format_get_indent (s);
269  n_printed = 0;
270 
271  n_counters = vec_len (im->combined_sw_if_counters);
272 
273  /* rx, tx counters... */
274  for (j = 0; j < n_counters; j++)
275  {
277  vlib_counter_t v, vtotal;
278  vtotal.packets = 0;
279  vtotal.bytes = 0;
280 
281  cm = im->combined_sw_if_counters + j;
283  vtotal.packets += v.packets;
284  vtotal.bytes += v.bytes;
285 
286  /* Only display non-zero counters. */
287  if (vtotal.packets == 0)
288  continue;
289 
290  if (json)
291  {
292  if (json_need_comma_nl)
293  {
294  vec_add1 (s, ',');
295  vec_add1 (s, '\n');
296  }
297  s = format (s, "%s%s_packets%s: %s%Ld%s,\n", x, cm->name, x, x,
298  vtotal.packets, x);
299  s = format (s, "%s%s_bytes%s: %s%Ld%s", x, cm->name, x, x,
300  vtotal.bytes, x);
301  json_need_comma_nl = 1;
302  continue;
303  }
304 
305  if (n_printed > 0)
306  s = format (s, "\n%U", format_white_space, indent);
307  n_printed += 2;
308 
309  if (n)
310  _vec_len (n) = 0;
311  n = format (n, "%s packets", cm->name);
312  s = format (s, "%-16v%16Ld", n, vtotal.packets);
313 
314  _vec_len (n) = 0;
315  n = format (n, "%s bytes", cm->name);
316  s = format (s, "\n%U%-16v%16Ld",
317  format_white_space, indent, n, vtotal.bytes);
318  }
319  vec_free (n);
320 
321  {
323  u64 v, vtotal;
324 
325  n_counters = vec_len (im->sw_if_counters);
326 
327  for (j = 0; j < n_counters; j++)
328  {
329  vtotal = 0;
330 
331  cm = im->sw_if_counters + j;
332 
333  v = vlib_get_simple_counter (cm, si->sw_if_index);
334  vtotal += v;
335 
336  /* Only display non-zero counters. */
337  if (vtotal == 0)
338  continue;
339 
340  if (json)
341  {
342  if (json_need_comma_nl)
343  {
344  vec_add1 (s, ',');
345  vec_add1 (s, '\n');
346  }
347  s = format (s, "%s%s%s: %s%Ld%s", x, cm->name, x, x, vtotal, x);
348  json_need_comma_nl = 1;
349  continue;
350  }
351 
352 
353  if (n_printed > 0)
354  s = format (s, "\n%U", format_white_space, indent);
355  n_printed += 1;
356 
357  s = format (s, "%-16s%16Ld", cm->name, vtotal);
358  }
359  }
360 
361  return s;
362 }
363 
364 static u8 *
365 format_vnet_sw_interface_mtu (u8 * s, va_list * args)
366 {
367  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
368 
369  return format (s, "%d/%d/%d/%d", si->mtu[VNET_MTU_L3],
370  si->mtu[VNET_MTU_IP4],
371  si->mtu[VNET_MTU_IP6], si->mtu[VNET_MTU_MPLS]);
372 }
373 
374 u8 *
375 format_vnet_sw_interface (u8 * s, va_list * args)
376 {
377  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
378  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
380 
381  if (!si)
382  return format (s, "%=32s%=5s%=10s%=21s%=16s%=16s",
383  "Name", "Idx", "State", "MTU (L3/IP4/IP6/MPLS)", "Counter",
384  "Count");
385 
386  s = format (s, "%-32U%=5d%=10U%=21U",
390 
391  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
392 
393  return s;
394 }
395 
396 u8 *
398 {
399  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
400  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
401  /* caller supplied display name for this interface */
402  u8 *name = va_arg (*args, u8 *);
404 
405 
406  if (!si)
407  return format (s, "%=32s%=5s%=16s%=16s%=16s",
408  "Name", "Idx", "State", "Counter", "Count");
409 
410  s = format (s, "%-32v%=5d%=16U",
411  name, si->sw_if_index,
413 
414  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
415 
416  return s;
417 }
418 
419 u8 *
420 format_vnet_buffer_flags (u8 * s, va_list * args)
421 {
422  vlib_buffer_t *buf = va_arg (*args, vlib_buffer_t *);
423 
424 #define _(a,b,c,v) if (buf->flags & VNET_BUFFER_F_##b) s = format (s, "%s ", c);
426 #undef _
427  return s;
428 }
429 
430 u8 *
431 format_vnet_buffer_opaque (u8 * s, va_list * args)
432 {
433  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
437  int i;
438 
439  s = format (s, "raw: ");
440 
441  for (i = 0; i < ARRAY_LEN (b->opaque); i++)
442  s = format (s, "%08x ", b->opaque[i]);
443 
444  vec_add1 (s, '\n');
445 
446  s = format (s,
447  "sw_if_index[VLIB_RX]: %d, sw_if_index[VLIB_TX]: %d",
448  o->sw_if_index[0], o->sw_if_index[1]);
449  vec_add1 (s, '\n');
450 
451  s = format (s,
452  "L2 offset %d, L3 offset %d, L4 offset %d, feature arc index %d",
453  (u32) (o->l2_hdr_offset),
454  (u32) (o->l3_hdr_offset),
455  (u32) (o->l4_hdr_offset), (u32) (o->feature_arc_index));
456  vec_add1 (s, '\n');
457 
458  s = format (s,
459  "ip.adj_index[VLIB_RX]: %d, ip.adj_index[VLIB_TX]: %d",
460  (u32) (o->ip.adj_index[0]), (u32) (o->ip.adj_index[1]));
461  vec_add1 (s, '\n');
462 
463  s = format (s,
464  "ip.flow_hash: 0x%x, ip.save_protocol: 0x%x, ip.fib_index: %d",
465  o->ip.flow_hash, o->ip.save_protocol, o->ip.fib_index);
466  vec_add1 (s, '\n');
467 
468  s = format (s,
469  "ip.save_rewrite_length: %d, ip.rpf_id: %d",
470  o->ip.save_rewrite_length, o->ip.rpf_id);
471  vec_add1 (s, '\n');
472 
473  s = format (s,
474  "ip.icmp.type: %d ip.icmp.code: %d, ip.icmp.data: 0x%x",
475  (u32) (o->ip.icmp.type),
476  (u32) (o->ip.icmp.code), o->ip.icmp.data);
477  vec_add1 (s, '\n');
478 
479  s = format (s,
480  "ip.reass.next_index: %d, ip.reass.estimated_mtu: %d",
481  o->ip.reass.next_index, (u32) (o->ip.reass.estimated_mtu));
482  vec_add1 (s, '\n');
483  s = format (s,
484  "ip.reass.error_next_index: %d, ip.reass.owner_thread_index: %d",
485  o->ip.reass.error_next_index,
486  (u32) (o->ip.reass.owner_thread_index));
487  vec_add1 (s, '\n');
488  s = format (s,
489  "ip.reass.ip_proto: %d, ip.reass.l4_src_port: %d",
490  o->ip.reass.ip_proto, (u32) (o->ip.reass.l4_src_port));
491  vec_add1 (s, '\n');
492  s = format (s, "ip.reass.l4_dst_port: %d", o->ip.reass.l4_dst_port);
493  vec_add1 (s, '\n');
494 
495  s = format (s,
496  "ip.reass.fragment_first: %d ip.reass.fragment_last: %d",
497  (u32) (o->ip.reass.fragment_first),
498  (u32) (o->ip.reass.fragment_last));
499  vec_add1 (s, '\n');
500 
501  s = format (s,
502  "ip.reass.range_first: %d ip.reass.range_last: %d",
503  (u32) (o->ip.reass.range_first),
504  (u32) (o->ip.reass.range_last));
505  vec_add1 (s, '\n');
506 
507  s = format (s,
508  "ip.reass.next_range_bi: 0x%x, ip.reass.ip6_frag_hdr_offset: %d",
509  o->ip.reass.next_range_bi,
510  (u32) (o->ip.reass.ip6_frag_hdr_offset));
511  vec_add1 (s, '\n');
512 
513  s = format (s,
514  "mpls.ttl: %d, mpls.exp: %d, mpls.first: %d, "
515  "mpls.save_rewrite_length: %d, mpls.bier.n_bytes: %d",
516  (u32) (o->mpls.ttl), (u32) (o->mpls.exp), (u32) (o->mpls.first),
517  o->mpls.save_rewrite_length, (u32) (o->mpls.bier.n_bytes));
518  vec_add1 (s, '\n');
519  s = format (s, "mpls.mpls_hdr_length: %d", (u32) (o->mpls.mpls_hdr_length));
520  vec_add1 (s, '\n');
521 
522  s = format (s,
523  "l2.feature_bitmap: %08x, l2.bd_index: %d, l2.l2fib_sn %d, "
524  "l2.l2_len: %d, l2.shg: %d, l2.bd_age: %d",
525  (u32) (o->l2.feature_bitmap), (u32) (o->l2.bd_index),
526  (u32) (o->l2.l2fib_sn),
527  (u32) (o->l2.l2_len), (u32) (o->l2.shg), (u32) (o->l2.bd_age));
528  vec_add1 (s, '\n');
529 
530  s = format (s,
531  "l2.feature_bitmap_input: %U, L2.feature_bitmap_output: %U",
532  format_l2_input_features, o->l2.feature_bitmap, 0,
533  format_l2_output_features, o->l2.feature_bitmap, 0);
534  vec_add1 (s, '\n');
535 
536  s = format (s,
537  "l2t.next_index: %d, l2t.session_index: %d",
538  (u32) (o->l2t.next_index), o->l2t.session_index);
539  vec_add1 (s, '\n');
540 
541  s = format (s,
542  "l2_classify.table_index: %d, l2_classify.opaque_index: %d, "
543  "l2_classify.hash: 0x%llx",
544  o->l2_classify.table_index,
545  o->l2_classify.opaque_index, o->l2_classify.hash);
546  vec_add1 (s, '\n');
547 
548  s = format (s, "policer.index: %d", o->policer.index);
549  vec_add1 (s, '\n');
550 
551  s = format (s, "ipsec.sad_index: %d, ipsec.protect_index",
552  o->ipsec.sad_index, o->ipsec.protect_index);
553  vec_add1 (s, '\n');
554 
555  s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
556  vec_add1 (s, '\n');
557 
558  s = format (s,
559  "map_t.map_domain_index: %d, map_t.v6.saddr: 0x%x, "
560  "map_t.v6.daddr: 0x%x, map_t.v6.frag_offset: %d, "
561  "map_t.v6.l4_offset: %d, map_t.v6.l4_protocol: %d, "
562  "map.t.checksum_offset: %d",
563  o->map_t.map_domain_index,
564  o->map_t.v6.saddr,
565  o->map_t.v6.daddr,
566  (u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset),
567  (u32) (o->map_t.v6.l4_protocol),
568  (u32) (o->map_t.checksum_offset));
569  vec_add1 (s, '\n');
570 
571  s = format (s,
572  "map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
573  "map_t.mtu: %d",
574  (u32) (o->map_t.v6.l4_protocol),
575  (u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
576  vec_add1 (s, '\n');
577 
578  s = format (s,
579  "ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
580  (u32) (o->ip_frag.mtu),
581  (u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
582  vec_add1 (s, '\n');
583 
584  s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
585  vec_add1 (s, '\n');
586 
587  s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
588  vec_add1 (s, '\n');
589 
590  s = format
591  (s,
592  "tcp.connection_index: %d, tcp.seq_number: %d, tcp.next_node_opaque: %d "
593  "tcp.seq_end: %d, tcp.ack_number: %d, tcp.hdr_offset: %d, "
594  "tcp.data_offset: %d", o->tcp.connection_index, o->tcp.next_node_opaque,
595  o->tcp.seq_number, o->tcp.seq_end, o->tcp.ack_number,
596  (u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
597  vec_add1 (s, '\n');
598 
599  s = format (s,
600  "tcp.data_len: %d, tcp.flags: 0x%x",
601  (u32) (o->tcp.data_len), (u32) (o->tcp.flags));
602  vec_add1 (s, '\n');
603 
604  s = format (s, "snat.flags: 0x%x", o->snat.flags);
605  vec_add1 (s, '\n');
606 
607  for (i = 0; i < vec_len (im->buffer_opaque_format_helpers); i++)
608  {
609  helper_fp = im->buffer_opaque_format_helpers[i];
610  s = (*helper_fp) (b, s);
611  }
612 
613  return s;
614 }
615 
616 u8 *
617 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
618 {
619  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
623 
624  int i;
625 
626  s = format (s, "raw: ");
627 
628  for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
629  s = format (s, "%08x ", b->opaque2[i]);
630  vec_add1 (s, '\n');
631 
632  s = format (s, "qos.bits: %x, qos.source: %x",
633  (u32) (o->qos.bits), (u32) (o->qos.source));
634  vec_add1 (s, '\n');
635  s = format (s, "loop_counter: %d", o->loop_counter);
636  vec_add1 (s, '\n');
637 
638  s = format (s, "gbp.flags: %x, gbp.sclass: %d",
639  (u32) (o->gbp.flags), (u32) (o->gbp.sclass));
640  vec_add1 (s, '\n');
641 
642  s = format (s, "gso_size: %d, gso_l4_hdr_sz: %d",
643  (u32) (o->gso_size), (u32) (o->gso_l4_hdr_sz));
644  vec_add1 (s, '\n');
645 
646  s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
647  vec_add1 (s, '\n');
648 
649  for (i = 0; i < vec_len (im->buffer_opaque2_format_helpers); i++)
650  {
651  helper_fp = im->buffer_opaque2_format_helpers[i];
652  s = (*helper_fp) (b, s);
653  }
654 
655  return s;
656 }
657 
658 void
660 {
663 }
664 
665 void
667 {
670 }
671 
672 
673 uword
675 {
676  u32 *flagp = va_arg (*args, u32 *);
677  int rv = 0;
678  u32 flags = 0;
679 
681  {
682  /* Red herring, there is no such buffer flag */
683  if (unformat (input, "avail8"))
684  return 0;
685 #define _(bit,enum,str,verbose) \
686  else if (unformat (input, str)) \
687  { \
688  flags |= (1 << LOG2_VLIB_BUFFER_FLAG_USER(bit)); \
689  rv = 1; \
690  }
692 #undef _
693  else
694  break;
695  }
696  if (rv)
697  *flagp = flags;
698  return rv;
699 }
700 
701 uword
703 {
704  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
705  u32 *hw_if_index = va_arg (*args, u32 *);
708 
709  /* Try per device class functions first. */
710  vec_foreach (c, im->device_classes)
711  {
712  if (c->unformat_device_name
713  && unformat_user (input, c->unformat_device_name, hw_if_index))
714  return 1;
715  }
716 
718  im->hw_interface_by_name, hw_if_index);
719 }
720 
721 uword
723 {
724  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
725  u32 *result = va_arg (*args, u32 *);
727  u32 hw_if_index, id, id_specified;
729  u8 *if_name = 0;
730  uword *p, error = 0;
731 
732  id = ~0;
733  if (unformat (input, "%_%v.%d%_", &if_name, &id)
734  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
735  {
736  hw_if_index = p[0];
737  id_specified = 1;
738  }
739  else
740  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
741  id_specified = 0;
742  else
743  goto done;
744 
745  hi = vnet_get_hw_interface (vnm, hw_if_index);
746  if (!id_specified)
747  {
748  sw_if_index = hi->sw_if_index;
749  }
750  else
751  {
752  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
753  goto done;
754  sw_if_index = p[0];
755  }
756  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
757  goto done;
758  *result = sw_if_index;
759  error = 1;
760 done:
761  vec_free (if_name);
762  return error;
763 }
764 
765 uword
767 {
768  u32 *result = va_arg (*args, u32 *);
769  u32 flags = 0;
770 
771  if (unformat (input, "up"))
773  else if (unformat (input, "down"))
775  else if (unformat (input, "punt"))
777  else if (unformat (input, "enable"))
778  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
779  else
780  return 0;
781 
782  *result = flags;
783  return 1;
784 }
785 
786 uword
788 {
789  u32 *result = va_arg (*args, u32 *);
790  u32 flags = 0;
791 
792  if (unformat (input, "up"))
794  else if (unformat (input, "down"))
796  else
797  return 0;
798 
799  *result = flags;
800  return 1;
801 }
802 
803 /*
804  * fd.io coding-style-patch-verification: ON
805  *
806  * Local Variables:
807  * eval: (c-set-style "gnu")
808  * End:
809  */
u32 opaque2[14]
Definition: buffer.h:170
u8 * format_l2_input_features(u8 *s, va_list *args)
Definition: l2_input.c:68
struct vnet_buffer_opaque_t::@150::@154 l2t
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
u8 * format_vnet_sw_interface_flags(u8 *s, va_list *args)
uword unformat_vnet_buffer_flags(unformat_input_t *input, 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:590
struct vnet_buffer_opaque2_t::@195 qos
QoS marking data that needs to persist from the recording nodes (nominally in the ingress path) to th...
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
static u32 format_get_indent(u8 *s)
Definition: format.h:72
uword * sub_interface_sw_if_index_by_id
Definition: interface.h:574
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
struct vnet_buffer_opaque_t::@150::@160 ip_frag
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
u8 id[64]
Definition: dhcp.api:160
double f64
Definition: types.h:142
u8 * format_vnet_hw_interface_link_speed(u8 *s, va_list *args)
u16 gso_size
The L4 payload size set on input on GSO enabled interfaces when we receive a GSO packet (a chain of b...
Definition: buffer.h:451
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
u8 * format_vtr(u8 *s, va_list *args)
vl_api_interface_index_t sw_if_index
Definition: gre.api:53
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:867
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
vnet_hw_interface_flags_t flags
Definition: interface.h:526
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:741
unsigned int u32
Definition: types.h:88
struct vnet_buffer_opaque_t::@150::@164 snat
A collection of simple counters.
Definition: counter.h:57
struct vnet_buffer_opaque_t::@150::@156 policer
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:847
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
u8 * format_vnet_sw_interface_name_override(u8 *s, va_list *args)
#define hash_get(h, key)
Definition: hash.h:249
struct vnet_buffer_opaque2_t::@196 gbp
#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:744
struct vnet_buffer_opaque_t::@150::@157 ipsec
counter_t packets
packet counter
Definition: counter_types.h:28
vnet_buffer_opquae_formatter_t * buffer_opaque_format_helpers
Definition: interface.h:879
struct _unformat_input_t unformat_input_t
u8 * format_vnet_buffer_opaque(u8 *s, va_list *args)
u8 * format_vnet_sw_if_index_name(u8 *s, va_list *args)
vnet_sw_interface_flags_t flags
Definition: interface.h:724
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:866
uword unformat_vnet_hw_interface_flags(unformat_input_t *input, va_list *args)
unformat_function_t unformat_hash_vec_string
Definition: hash.h:718
vl_api_tunnel_mode_t mode
Definition: gre.api:48
void vnet_register_format_buffer_opaque_helper(vnet_buffer_opquae_formatter_t fp)
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:586
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u32 flags
Definition: vhost_user.h:248
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
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
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:66
struct vnet_buffer_opaque_t::@150::opaque_l2 l2
string name[64]
Definition: ip.api:44
struct vnet_buffer_opaque_t::@150::@162 lisp
u8 * format_vnet_hw_if_index_name(u8 *s, va_list *args)
#define ASSERT(truth)
struct vnet_buffer_opaque_t::@150::@159 map_t
u8 * format_vnet_buffer_flags(u8 *s, va_list *args)
u8 * format_vnet_hw_interface_rx_mode(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@150::@155 l2_classify
struct vnet_buffer_opaque_t::@150::@161 cop
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:880
struct vnet_buffer_opaque_t::@150::@152 ip
vl_api_ip4_address_t hi
Definition: arp.api:37
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)
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
struct vnet_buffer_opaque_t::@150::@153 mpls
vnet_sw_interface_type_t type
Definition: interface.h:722
u8 * format_vnet_buffer_opaque2(u8 *s, va_list *args)
#define vec_foreach(var, vec)
Vector iterator.
u8 *(* vnet_buffer_opquae_formatter_t)(const vlib_buffer_t *b, u8 *s)
Definition: interface.h:838
vnet_device_class_t * device_classes
Definition: interface.h:851
struct vnet_buffer_opaque_t::@150::@158 map
u8 si
Definition: lisp_types.api:47
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
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
struct vnet_buffer_opaque_t::@150::@163 tcp
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)