FD.io VPP  v21.06-1-gbb7418cf9
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>
47 
48 u8 *
49 format_vtr (u8 * s, va_list * args)
50 {
51  u32 vtr_op = va_arg (*args, u32);
52  u32 dot1q = va_arg (*args, u32);
53  u32 tag1 = va_arg (*args, u32);
54  u32 tag2 = va_arg (*args, u32);
55  switch (vtr_op)
56  {
57  case L2_VTR_DISABLED:
58  return format (s, "none");
59  case L2_VTR_PUSH_1:
60  return format (s, "push-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
61  case L2_VTR_PUSH_2:
62  return format (s, "push-2 %s %d %d", dot1q ? "dot1q" : "dot1ad", tag1,
63  tag2);
64  case L2_VTR_POP_1:
65  return format (s, "pop-1");
66  case L2_VTR_POP_2:
67  return format (s, "pop-2");
69  return format (s, "trans-1-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
71  return format (s, "trans-1-2 %s %d %d", dot1q ? "dot1q" : "dot1ad",
72  tag1, tag2);
74  return format (s, "trans-2-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1);
76  return format (s, "trans-2-2 %s %d %d", dot1q ? "dot1q" : "dot1ad",
77  tag1, tag2);
78  default:
79  return format (s, "none");
80  }
81 }
82 
83 u8 *
84 format_vnet_sw_interface_flags (u8 * s, va_list * args)
85 {
86  u32 flags = va_arg (*args, u32);
87 
88  if (flags & VNET_SW_INTERFACE_FLAG_ERROR)
89  s = format (s, "error");
90  else
91  {
92  s = format (s, "%s",
93  (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "down");
94  if (flags & VNET_SW_INTERFACE_FLAG_PUNT)
95  s = format (s, "/punt");
96  }
97 
98  return s;
99 }
100 
101 u8 *
102 format_vnet_hw_if_rx_mode (u8 * s, va_list * args)
103 {
104  vnet_hw_if_rx_mode mode = va_arg (*args, vnet_hw_if_rx_mode);
105 
106  if (mode == VNET_HW_IF_RX_MODE_POLLING)
107  return format (s, "polling");
108 
109  if (mode == VNET_HW_IF_RX_MODE_INTERRUPT)
110  return format (s, "interrupt");
111 
112  if (mode == VNET_HW_IF_RX_MODE_ADAPTIVE)
113  return format (s, "adaptive");
114 
115  return format (s, "unknown");
116 }
117 
118 u8 *
120 {
121  u32 link_speed = va_arg (*args, u32);
122 
123  if (link_speed == 0)
124  return format (s, "unknown");
125 
126  if (link_speed >= 1000000)
127  return format (s, "%f Gbps", (f64) link_speed / 1000000);
128 
129  if (link_speed >= 1000)
130  return format (s, "%f Mbps", (f64) link_speed / 1000);
131 
132  return format (s, "%u Kbps", link_speed);
133 }
134 
135 u8 *
137 {
138  clib_bitmap_t *bitmap = va_arg (*args, clib_bitmap_t *);
139  int i;
140 
141  if (bitmap == NULL)
142  return s;
143 
144  if (bitmap)
145  {
146  /* *INDENT-OFF* */
147  clib_bitmap_foreach (i, bitmap) {
148  s = format (s, "%u ", i);
149  }
150  /* *INDENT-ON* */
151  }
152 
153  return s;
154 }
155 
156 u8 *
157 format_vnet_hw_interface (u8 * s, va_list * args)
158 {
159  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
160  vnet_hw_interface_t *hi = va_arg (*args, vnet_hw_interface_t *);
161  vnet_hw_interface_class_t *hw_class;
162  vnet_device_class_t *dev_class;
163  int verbose = va_arg (*args, int);
164  u32 indent;
165 
166  if (!hi)
167  return format (s, "%=32s%=6s%=8s%s", "Name", "Idx", "Link", "Hardware");
168 
169  indent = format_get_indent (s);
170 
171  s = format (s, "%-32v%=6d", hi->name, hi->hw_if_index);
172 
174  s = format (s, "%=8s", "slave");
175  else
176  s = format (s, "%=8s",
177  hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP ? "up" : "down");
178 
179  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
180  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
181 
183  {
184  int hw_idx;
185  s = format (s, "Slave-Idx:");
186  clib_bitmap_foreach (hw_idx, hi->bond_info)
187  s = format (s, " %d", hw_idx);
188  }
189  else if (dev_class->format_device_name)
190  s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
191  else
192  s = format (s, "%s%d", dev_class->name, hi->dev_instance);
193 
194  s = format (s, "\n%ULink speed: %U", format_white_space, indent + 2,
196 
197  if (vec_len (hi->rx_queue_indices))
198  {
199  s = format (s, "\n%URX Queues:", format_white_space, indent + 2);
200  s = format (s, "\n%U%-6s%-15s%-10s", format_white_space, indent + 4,
201  "queue", "thread", "mode");
202  for (int i = 0; i < vec_len (hi->rx_queue_indices); i++)
203  {
205  rxq = vnet_hw_if_get_rx_queue (vnm, hi->rx_queue_indices[i]);
206  s = format (s, "\n%U%-6u%-15U%-10U", format_white_space, indent + 4,
209  }
210  }
211 
212  if (vec_len (hi->tx_queue_indices))
213  {
214  s = format (s, "\n%UTX Queues:", format_white_space, indent + 2);
215  s = format (s, "\n%U%-6s%-7s%-15s", format_white_space, indent + 4,
216  "queue", "shared", "thread(s)");
217  for (int i = 0; i < vec_len (hi->tx_queue_indices); i++)
218  {
220  txq = vnet_hw_if_get_tx_queue (vnm, hi->tx_queue_indices[i]);
221  s = format (
222  s, "\n%U%-6u%-7s%U", format_white_space, indent + 4, txq->queue_id,
223  clib_bitmap_count_set_bits (txq->threads) > 1 ? "yes" : "no",
225  }
226  }
227 
228  if (hi->rss_queues)
229  {
230  s = format (s, "\n%URSS queues: %U", format_white_space, indent + 2,
232  }
233 
234  if (verbose)
235  {
236  if (hw_class->format_device)
237  s = format (s, "\n%U%U",
238  format_white_space, indent + 2,
239  hw_class->format_device, hi->hw_if_index, verbose);
240  else
241  {
242  s = format (s, "\n%U%s",
243  format_white_space, indent + 2, hw_class->name);
244  if (hw_class->format_address && vec_len (hi->hw_address) > 0)
245  s =
246  format (s, " address %U", hw_class->format_address,
247  hi->hw_address);
248  }
249 
250  if (dev_class->format_device)
251  s = format (s, "\n%U%U",
252  format_white_space, indent + 2,
253  dev_class->format_device, hi->dev_instance, verbose);
254  }
255 
256  return s;
257 }
258 
259 u8 *
260 format_vnet_sw_interface_name (u8 * s, va_list * args)
261 {
262  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
263  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
264  vnet_sw_interface_t *si_sup =
266  vnet_hw_interface_t *hi_sup;
267 
269  hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
270 
271  s = format (s, "%v", hi_sup->name);
272 
274  s = format (s, ".%d", si->sub.id);
275 
276  return s;
277 }
278 
279 u8 *
280 format_vnet_sw_if_index_name (u8 * s, va_list * args)
281 {
282  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
283  u32 sw_if_index = va_arg (*args, u32);
285 
286  si = vnet_get_sw_interface_or_null (vnm, sw_if_index);
287 
288  if (NULL == si)
289  {
290  return format (s, "DELETED");
291  }
292  return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
293 }
294 
295 u8 *
296 format_vnet_hw_if_index_name (u8 * s, va_list * args)
297 {
298  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
299  u32 hw_if_index = va_arg (*args, u32);
301 
302  hi = vnet_get_hw_interface (vnm, hw_if_index);
303 
304  if (hi == 0)
305  return format (s, "DELETED");
306 
307  return format (s, "%v", hi->name);
308 }
309 
310 u8 *
312  vnet_sw_interface_t * si, int json)
313 {
314  u32 indent, n_printed;
315  int j, n_counters;
316  char *x = "";
317  int json_need_comma_nl = 0;
318  u8 *n = 0;
319 
320  /*
321  * to output a json snippet, stick quotes in lots of places
322  * definitely deserves a one-character variable name.
323  */
324  if (json)
325  x = "\"";
326 
327  indent = format_get_indent (s);
328  n_printed = 0;
329 
330  n_counters = vec_len (im->combined_sw_if_counters);
331 
332  /* rx, tx counters... */
333  for (j = 0; j < n_counters; j++)
334  {
336  vlib_counter_t v, vtotal;
337  vtotal.packets = 0;
338  vtotal.bytes = 0;
339 
340  cm = im->combined_sw_if_counters + j;
342  vtotal.packets += v.packets;
343  vtotal.bytes += v.bytes;
344 
345  /* Only display non-zero counters. */
346  if (vtotal.packets == 0)
347  continue;
348 
349  if (json)
350  {
351  if (json_need_comma_nl)
352  {
353  vec_add1 (s, ',');
354  vec_add1 (s, '\n');
355  }
356  s = format (s, "%s%s_packets%s: %s%Ld%s,\n", x, cm->name, x, x,
357  vtotal.packets, x);
358  s = format (s, "%s%s_bytes%s: %s%Ld%s", x, cm->name, x, x,
359  vtotal.bytes, x);
360  json_need_comma_nl = 1;
361  continue;
362  }
363 
364  if (n_printed > 0)
365  s = format (s, "\n%U", format_white_space, indent);
366  n_printed += 2;
367 
368  if (n)
369  _vec_len (n) = 0;
370  n = format (n, "%s packets", cm->name);
371  s = format (s, "%-16v%16Ld", n, vtotal.packets);
372 
373  _vec_len (n) = 0;
374  n = format (n, "%s bytes", cm->name);
375  s = format (s, "\n%U%-16v%16Ld",
376  format_white_space, indent, n, vtotal.bytes);
377  }
378  vec_free (n);
379 
380  {
382  u64 v, vtotal;
383 
384  n_counters = vec_len (im->sw_if_counters);
385 
386  for (j = 0; j < n_counters; j++)
387  {
388  vtotal = 0;
389 
390  cm = im->sw_if_counters + j;
391 
392  v = vlib_get_simple_counter (cm, si->sw_if_index);
393  vtotal += v;
394 
395  /* Only display non-zero counters. */
396  if (vtotal == 0)
397  continue;
398 
399  if (json)
400  {
401  if (json_need_comma_nl)
402  {
403  vec_add1 (s, ',');
404  vec_add1 (s, '\n');
405  }
406  s = format (s, "%s%s%s: %s%Ld%s", x, cm->name, x, x, vtotal, x);
407  json_need_comma_nl = 1;
408  continue;
409  }
410 
411 
412  if (n_printed > 0)
413  s = format (s, "\n%U", format_white_space, indent);
414  n_printed += 1;
415 
416  s = format (s, "%-16s%16Ld", cm->name, vtotal);
417  }
418  }
419 
420  return s;
421 }
422 
423 static u8 *
424 format_vnet_sw_interface_mtu (u8 * s, va_list * args)
425 {
426  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
427 
428  return format (s, "%d/%d/%d/%d", si->mtu[VNET_MTU_L3],
429  si->mtu[VNET_MTU_IP4],
430  si->mtu[VNET_MTU_IP6], si->mtu[VNET_MTU_MPLS]);
431 }
432 
433 u8 *
434 format_vnet_sw_interface (u8 * s, va_list * args)
435 {
436  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
437  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
439 
440  if (!si)
441  return format (s, "%=32s%=5s%=10s%=21s%=16s%=16s",
442  "Name", "Idx", "State", "MTU (L3/IP4/IP6/MPLS)", "Counter",
443  "Count");
444 
445  s = format (s, "%-32U%=5d%=10U%=21U",
449 
450  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
451 
452  return s;
453 }
454 
455 u8 *
457 {
458  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
459  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
460  /* caller supplied display name for this interface */
461  u8 *name = va_arg (*args, u8 *);
463 
464 
465  if (!si)
466  return format (s, "%=32s%=5s%=16s%=16s%=16s",
467  "Name", "Idx", "State", "Counter", "Count");
468 
469  s = format (s, "%-32v%=5d%=16U",
470  name, si->sw_if_index,
472 
473  s = format_vnet_sw_interface_cntrs (s, im, si, 0 /* want json */ );
474 
475  return s;
476 }
477 
478 u8 *
479 format_vnet_buffer_flags (u8 * s, va_list * args)
480 {
481  vlib_buffer_t *buf = va_arg (*args, vlib_buffer_t *);
482 
483 #define _(a,b,c,v) if (buf->flags & VNET_BUFFER_F_##b) s = format (s, "%s ", c);
485 #undef _
486  return s;
487 }
488 
489 u8 *
490 format_vnet_buffer_opaque (u8 * s, va_list * args)
491 {
492  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
496  int i;
497 
498  s = format (s, "raw: ");
499 
500  for (i = 0; i < ARRAY_LEN (b->opaque); i++)
501  s = format (s, "%08x ", b->opaque[i]);
502 
503  vec_add1 (s, '\n');
504 
505  s = format (s,
506  "sw_if_index[VLIB_RX]: %d, sw_if_index[VLIB_TX]: %d",
507  o->sw_if_index[0], o->sw_if_index[1]);
508  vec_add1 (s, '\n');
509 
510  s = format (s,
511  "L2 offset %d, L3 offset %d, L4 offset %d, feature arc index %d",
512  (u32) (o->l2_hdr_offset),
513  (u32) (o->l3_hdr_offset),
514  (u32) (o->l4_hdr_offset), (u32) (o->feature_arc_index));
515  vec_add1 (s, '\n');
516 
517  s = format (s,
518  "ip.adj_index[VLIB_RX]: %d, ip.adj_index[VLIB_TX]: %d",
519  (u32) (o->ip.adj_index[0]), (u32) (o->ip.adj_index[1]));
520  vec_add1 (s, '\n');
521 
522  s = format (s,
523  "ip.flow_hash: 0x%x, ip.save_protocol: 0x%x, ip.fib_index: %d",
524  o->ip.flow_hash, o->ip.save_protocol, o->ip.fib_index);
525  vec_add1 (s, '\n');
526 
527  s = format (s,
528  "ip.save_rewrite_length: %d, ip.rpf_id: %d",
529  o->ip.save_rewrite_length, o->ip.rpf_id);
530  vec_add1 (s, '\n');
531 
532  s = format (s,
533  "ip.icmp.type: %d ip.icmp.code: %d, ip.icmp.data: 0x%x",
534  (u32) (o->ip.icmp.type),
535  (u32) (o->ip.icmp.code), o->ip.icmp.data);
536  vec_add1 (s, '\n');
537 
538  s = format (s,
539  "ip.reass.next_index: %d, ip.reass.estimated_mtu: %d",
540  o->ip.reass.next_index, (u32) (o->ip.reass.estimated_mtu));
541  vec_add1 (s, '\n');
542  s = format (s,
543  "ip.reass.error_next_index: %d, ip.reass.owner_thread_index: %d",
544  o->ip.reass.error_next_index,
545  (u32) (o->ip.reass.owner_thread_index));
546  vec_add1 (s, '\n');
547  s = format (s,
548  "ip.reass.ip_proto: %d, ip.reass.l4_src_port: %d",
549  o->ip.reass.ip_proto, (u32) (o->ip.reass.l4_src_port));
550  vec_add1 (s, '\n');
551  s = format (s, "ip.reass.l4_dst_port: %d", o->ip.reass.l4_dst_port);
552  vec_add1 (s, '\n');
553 
554  s = format (s,
555  "ip.reass.fragment_first: %d ip.reass.fragment_last: %d",
556  (u32) (o->ip.reass.fragment_first),
557  (u32) (o->ip.reass.fragment_last));
558  vec_add1 (s, '\n');
559 
560  s = format (s,
561  "ip.reass.range_first: %d ip.reass.range_last: %d",
562  (u32) (o->ip.reass.range_first),
563  (u32) (o->ip.reass.range_last));
564  vec_add1 (s, '\n');
565 
566  s = format (s,
567  "ip.reass.next_range_bi: 0x%x, ip.reass.ip6_frag_hdr_offset: %d",
568  o->ip.reass.next_range_bi,
569  (u32) (o->ip.reass.ip6_frag_hdr_offset));
570  vec_add1 (s, '\n');
571 
572  s = format (s,
573  "mpls.ttl: %d, mpls.exp: %d, mpls.first: %d, "
574  "mpls.save_rewrite_length: %d, mpls.bier.n_bytes: %d",
575  (u32) (o->mpls.ttl), (u32) (o->mpls.exp), (u32) (o->mpls.first),
576  o->mpls.save_rewrite_length, (u32) (o->mpls.bier.n_bytes));
577  vec_add1 (s, '\n');
578  s = format (s, "mpls.mpls_hdr_length: %d", (u32) (o->mpls.mpls_hdr_length));
579  vec_add1 (s, '\n');
580 
581  s = format (s,
582  "l2.feature_bitmap: %08x, l2.bd_index: %d, l2.l2fib_sn %d, "
583  "l2.l2_len: %d, l2.shg: %d, l2.bd_age: %d",
584  (u32) (o->l2.feature_bitmap), (u32) (o->l2.bd_index),
585  (u32) (o->l2.l2fib_sn),
586  (u32) (o->l2.l2_len), (u32) (o->l2.shg), (u32) (o->l2.bd_age));
587  vec_add1 (s, '\n');
588 
589  s = format (s,
590  "l2.feature_bitmap_input: %U, L2.feature_bitmap_output: %U",
591  format_l2_input_feature_bitmap, o->l2.feature_bitmap, 0,
592  format_l2_output_features, o->l2.feature_bitmap, 0);
593  vec_add1 (s, '\n');
594 
595  s = format (s,
596  "l2t.next_index: %d, l2t.session_index: %d",
597  (u32) (o->l2t.next_index), o->l2t.session_index);
598  vec_add1 (s, '\n');
599 
600  s = format (s,
601  "l2_classify.table_index: %d, l2_classify.opaque_index: %d, "
602  "l2_classify.hash: 0x%llx",
603  o->l2_classify.table_index,
604  o->l2_classify.opaque_index, o->l2_classify.hash);
605  vec_add1 (s, '\n');
606 
607  s = format (s, "policer.index: %d", o->policer.index);
608  vec_add1 (s, '\n');
609 
610  s = format (s, "ipsec.sad_index: %d, ipsec.protect_index",
611  o->ipsec.sad_index, o->ipsec.protect_index);
612  vec_add1 (s, '\n');
613 
614  s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
615  vec_add1 (s, '\n');
616 
617  s = format (s,
618  "map_t.map_domain_index: %d, map_t.v6.saddr: 0x%x, "
619  "map_t.v6.daddr: 0x%x, map_t.v6.frag_offset: %d, "
620  "map_t.v6.l4_offset: %d, map_t.v6.l4_protocol: %d, "
621  "map.t.checksum_offset: %d",
622  o->map_t.map_domain_index,
623  o->map_t.v6.saddr,
624  o->map_t.v6.daddr,
625  (u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset),
626  (u32) (o->map_t.v6.l4_protocol),
627  (u32) (o->map_t.checksum_offset));
628  vec_add1 (s, '\n');
629 
630  s = format (s,
631  "map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
632  "map_t.mtu: %d",
633  (u32) (o->map_t.v6.l4_protocol),
634  (u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
635  vec_add1 (s, '\n');
636 
637  s = format (s,
638  "ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
639  (u32) (o->ip_frag.mtu),
640  (u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
641  vec_add1 (s, '\n');
642 
643  s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
644  vec_add1 (s, '\n');
645 
646  s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
647  vec_add1 (s, '\n');
648 
649  s = format
650  (s,
651  "tcp.connection_index: %d, tcp.seq_number: %d, tcp.next_node_opaque: %d "
652  "tcp.seq_end: %d, tcp.ack_number: %d, tcp.hdr_offset: %d, "
653  "tcp.data_offset: %d", o->tcp.connection_index, o->tcp.next_node_opaque,
654  o->tcp.seq_number, o->tcp.seq_end, o->tcp.ack_number,
655  (u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
656  vec_add1 (s, '\n');
657 
658  s = format (s,
659  "tcp.data_len: %d, tcp.flags: 0x%x",
660  (u32) (o->tcp.data_len), (u32) (o->tcp.flags));
661  vec_add1 (s, '\n');
662 
663  s = format (s, "snat.flags: 0x%x", o->snat.flags);
664  vec_add1 (s, '\n');
665 
666  for (i = 0; i < vec_len (im->buffer_opaque_format_helpers); i++)
667  {
668  helper_fp = im->buffer_opaque_format_helpers[i];
669  s = (*helper_fp) (b, s);
670  }
671 
672  return s;
673 }
674 
675 u8 *
676 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
677 {
678  vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
682 
683  int i;
684 
685  s = format (s, "raw: ");
686 
687  for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
688  s = format (s, "%08x ", b->opaque2[i]);
689  vec_add1 (s, '\n');
690 
691  s = format (s, "qos.bits: %x, qos.source: %x",
692  (u32) (o->qos.bits), (u32) (o->qos.source));
693  vec_add1 (s, '\n');
694  s = format (s, "loop_counter: %d", o->loop_counter);
695  vec_add1 (s, '\n');
696 
697  s = format (s, "gbp.flags: %x, gbp.sclass: %d",
698  (u32) (o->gbp.flags), (u32) (o->gbp.sclass));
699  vec_add1 (s, '\n');
700 
701  s = format (s, "gso_size: %d, gso_l4_hdr_sz: %d",
702  (u32) (o->gso_size), (u32) (o->gso_l4_hdr_sz));
703  vec_add1 (s, '\n');
704 
705  s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
706  vec_add1 (s, '\n');
707 
708  for (i = 0; i < vec_len (im->buffer_opaque2_format_helpers); i++)
709  {
710  helper_fp = im->buffer_opaque2_format_helpers[i];
711  s = (*helper_fp) (b, s);
712  }
713 
714  return s;
715 }
716 
717 void
719 {
722 }
723 
724 void
726 {
729 }
730 
731 
732 uword
734 {
735  u32 *flagp = va_arg (*args, u32 *);
736  int rv = 0;
737  u32 flags = 0;
738 
740  {
741  /* Red herring, there is no such buffer flag */
742  if (unformat (input, "avail10"))
743  return 0;
744 #define _(bit,enum,str,verbose) \
745  else if (unformat (input, str)) \
746  { \
747  flags |= (1 << LOG2_VLIB_BUFFER_FLAG_USER(bit)); \
748  rv = 1; \
749  }
751 #undef _
752  else
753  break;
754  }
755  if (rv)
756  *flagp = flags;
757  return rv;
758 }
759 
760 uword
762 {
763  u32 *flagp = va_arg (*args, u32 *);
764  int rv = 0;
765  vnet_buffer_oflags_t oflags = 0;
766 
768  {
769  if (0)
770  ;
771 #define _(bit, enum, str, verbose) \
772  else if (unformat (input, str)) \
773  { \
774  oflags |= (1 << bit); \
775  rv = 1; \
776  }
778 #undef _
779  else break;
780  }
781  if (rv)
782  *flagp = (u32) oflags;
783  return rv;
784 }
785 
786 uword
788 {
789  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
790  u32 *hw_if_index = va_arg (*args, u32 *);
793 
794  /* Try per device class functions first. */
795  vec_foreach (c, im->device_classes)
796  {
797  if (c->unformat_device_name
798  && unformat_user (input, c->unformat_device_name, hw_if_index))
799  return 1;
800  }
801 
803  im->hw_interface_by_name, hw_if_index);
804 }
805 
806 uword
808 {
809  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
810  u32 *result = va_arg (*args, u32 *);
812  u32 hw_if_index, id, id_specified;
814  u8 *if_name = 0;
815  uword *p, error = 0;
816 
817  id = ~0;
818  if (unformat (input, "%_%v.%d%_", &if_name, &id)
819  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
820  {
821  hw_if_index = p[0];
822  id_specified = 1;
823  }
824  else
825  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
826  id_specified = 0;
827  else
828  goto done;
829 
830  hi = vnet_get_hw_interface (vnm, hw_if_index);
831  if (!id_specified)
832  {
833  sw_if_index = hi->sw_if_index;
834  }
835  else
836  {
837  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
838  goto done;
839  sw_if_index = p[0];
840  }
841  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
842  goto done;
843  *result = sw_if_index;
844  error = 1;
845 done:
846  vec_free (if_name);
847  return error;
848 }
849 
850 uword
852 {
853  u32 *result = va_arg (*args, u32 *);
854  u32 flags = 0;
855 
856  if (unformat (input, "up"))
858  else if (unformat (input, "down"))
860  else if (unformat (input, "punt"))
862  else if (unformat (input, "enable"))
863  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
864  else
865  return 0;
866 
867  *result = flags;
868  return 1;
869 }
870 
871 uword
873 {
874  u32 *result = va_arg (*args, u32 *);
875  u32 flags = 0;
876 
877  if (unformat (input, "up"))
879  else if (unformat (input, "down"))
881  else
882  return 0;
883 
884  *result = flags;
885  return 1;
886 }
887 
888 /*
889  * fd.io coding-style-patch-verification: ON
890  *
891  * Local Variables:
892  * eval: (c-set-style "gnu")
893  * End:
894  */
u32 opaque2[14]
Definition: buffer.h:179
vnet_buffer_oflags_t
Definition: buffer.h:118
clib_bitmap_t * threads
Definition: interface.h:612
struct vnet_buffer_opaque_t::@157::@164 ipsec
struct vnet_buffer_opaque_t::@157::@167 ip_frag
static_always_inline vnet_hw_if_tx_queue_t * vnet_hw_if_get_tx_queue(vnet_main_t *vnm, u32 queue_index)
struct vnet_buffer_opaque_t::@157::@169 lisp
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
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:44
vnet_interface_main_t interface_main
Definition: vnet.h:81
unsigned long u64
Definition: types.h:89
struct vnet_buffer_opaque_t::@157::opaque_l2 l2
u8 * format_vnet_sw_interface_flags(u8 *s, va_list *args)
uword unformat_vnet_buffer_flags(unformat_input_t *input, va_list *args)
vnet_feature_config_main_t * cm
#define clib_bitmap_foreach(i, ai)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
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)
struct vnet_buffer_opaque_t::@157::@170 tcp
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:607
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:703
string name[64]
Definition: fib.api:25
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
vlib_buffer_t ** b
struct vnet_buffer_opaque2_t::@203 gbp
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)
unsigned int u32
Definition: types.h:88
struct vnet_buffer_opaque_t::@157::@162 l2_classify
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:128
u8 * format_vtr(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@157::@166 map_t
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
struct vnet_buffer_opaque_t::@157::@165 map
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:1023
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
description fragment has unexpected format
Definition: map.api:433
vnet_hw_interface_flags_t flags
Definition: interface.h:642
static vnet_sw_interface_t * vnet_get_sup_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
vnet_main_t * vnet_get_main(void)
u32 mtu[VNET_N_MTU]
Definition: interface.h:889
int __clib_unused rv
Definition: application.c:491
A collection of simple counters.
Definition: counter.h:57
u8 * format_vnet_sw_interface(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@157::@161 l2t
char * name
The counter collection&#39;s name.
Definition: counter.h:60
uword * hw_interface_by_name
Definition: interface.h:1003
Definition: cJSON.c:88
u8 * format_vnet_sw_interface_name_override(u8 *s, va_list *args)
#define hash_get(h, key)
Definition: hash.h:249
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
vnet_sub_interface_t sub
Definition: interface.h:892
counter_t packets
packet counter
Definition: counter_types.h:28
u8 * format_vnet_hw_if_rx_mode(u8 *s, va_list *args)
vnet_buffer_opquae_formatter_t * buffer_opaque_format_helpers
Definition: interface.h:1035
static_always_inline vnet_hw_if_rx_queue_t * vnet_hw_if_get_rx_queue(vnet_main_t *vnm, u32 queue_index)
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_hw_if_rx_mode mode
Definition: interface.h:597
vnet_sw_interface_flags_t flags
Definition: interface.h:872
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:1022
uword unformat_vnet_hw_interface_flags(unformat_input_t *input, va_list *args)
unformat_function_t unformat_hash_vec_string
Definition: hash.h:718
uword unformat_vnet_buffer_offload_flags(unformat_input_t *input, va_list *args)
u8 * format_l2_input_feature_bitmap(u8 *s, va_list *args)
Definition: l2_input.c:65
vl_api_tunnel_mode_t mode
Definition: gre.api:48
struct vnet_buffer_opaque_t::@157::@159 ip
void vnet_register_format_buffer_opaque_helper(vnet_buffer_opquae_formatter_t fp)
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:715
u8 * format_vlib_thread_name_and_index(u8 *s, va_list *args)
Definition: format.c:227
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
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:272
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:395
u8 * format_vnet_hw_interface_rss_queues(u8 *s, va_list *args)
struct vnet_buffer_opaque_t::@157::@163 policer
u32 sw_if_index[VLIB_N_RX_TX]
Definition: buffer.h:151
vnet_interface_main_t * im
u8 * format_vnet_sw_interface_name(u8 *s, va_list *args)
u64 buf
Definition: application.c:493
#define ARRAY_LEN(x)
Definition: clib.h:70
struct vnet_buffer_opaque2_t::@202 qos
QoS marking data that needs to persist from the recording nodes (nominally in the ingress path) to th...
struct vnet_buffer_opaque_t::@157::@171 snat
__clib_export u8 * format_bitmap_list(u8 *s, va_list *args)
Format a bitmap as a list.
Definition: bitmap.c:143
u8 * format_vnet_hw_if_index_name(u8 *s, va_list *args)
#define ASSERT(truth)
vnet_sw_interface_t * si
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::@157::@160 mpls
vnet_buffer_opquae_formatter_t * buffer_opaque2_format_helpers
Definition: interface.h:1036
vl_api_ip4_address_t hi
Definition: arp.api:37
u8 * format_vnet_buffer_opaque(u8 *s, va_list *args)
static uword clib_bitmap_count_set_bits(uword *ai)
Return the number of set bits in a bitmap.
Definition: bitmap.h:468
counter_t bytes
byte counter
Definition: counter_types.h:29
clib_bitmap_t * rss_queues
Definition: interface.h:735
struct vnet_buffer_opaque_t::@157::@168 cop
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:111
u64 uword
Definition: types.h:112
char * name
The counter collection&#39;s name.
Definition: counter.h:206
A collection of combined counters.
Definition: counter.h:203
vnet_sw_interface_type_t type
Definition: interface.h:870
uword clib_bitmap_t
Definition: bitmap.h:50
vnet_hw_if_rx_mode
Definition: interface.h:53
#define vec_foreach(var, vec)
Vector iterator.
u8 *(* vnet_buffer_opquae_formatter_t)(const vlib_buffer_t *b, u8 *s)
Definition: interface.h:986
vnet_device_class_t * device_classes
Definition: interface.h:1007
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:162
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:163
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)