FD.io VPP  v18.10-34-gcce845e
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 
43 u8 *
44 format_vnet_sw_interface_flags (u8 * s, va_list * args)
45 {
46  u32 flags = va_arg (*args, u32);
47 
48  if (flags & VNET_SW_INTERFACE_FLAG_ERROR)
49  s = format (s, "error");
50  else if (flags & VNET_SW_INTERFACE_FLAG_BOND_SLAVE)
51  s = format (s, "bond-slave");
52  else
53  {
54  s = format (s, "%s",
55  (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "down");
56  if (flags & VNET_SW_INTERFACE_FLAG_PUNT)
57  s = format (s, "/punt");
58  }
59 
60  return s;
61 }
62 
63 u8 *
64 format_vnet_hw_interface_rx_mode (u8 * s, va_list * args)
65 {
67 
69  return format (s, "polling");
70 
72  return format (s, "interrupt");
73 
75  return format (s, "adaptive");
76 
77  return format (s, "unknown");
78 }
79 
80 u8 *
81 format_vnet_hw_interface (u8 * s, va_list * args)
82 {
83  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
84  vnet_hw_interface_t *hi = va_arg (*args, vnet_hw_interface_t *);
85  vnet_hw_interface_class_t *hw_class;
86  vnet_device_class_t *dev_class;
87  int verbose = va_arg (*args, int);
88  u32 indent;
89 
90  if (!hi)
91  return format (s, "%=32s%=6s%=8s%s", "Name", "Idx", "Link", "Hardware");
92 
93  indent = format_get_indent (s);
94 
95  s = format (s, "%-32v%=6d", hi->name, hi->hw_if_index);
96 
98  s = format (s, "%=8s", "slave");
99  else
100  s = format (s, "%=8s",
101  hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP ? "up" : "down");
102 
103  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
104  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
105 
107  {
108  int hw_idx;
109  s = format (s, "Slave-Idx:");
110  clib_bitmap_foreach (hw_idx, hi->bond_info, s =
111  format (s, " %d", hw_idx));
112  }
113  else if (dev_class->format_device_name)
114  s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
115  else
116  s = format (s, "%s%d", dev_class->name, hi->dev_instance);
117 
118  if (verbose)
119  {
120  if (hw_class->format_device)
121  s = format (s, "\n%U%U",
122  format_white_space, indent + 2,
123  hw_class->format_device, hi->hw_if_index, verbose);
124  else
125  {
126  s = format (s, "\n%U%s",
127  format_white_space, indent + 2, hw_class->name);
128  if (hw_class->format_address && vec_len (hi->hw_address) > 0)
129  s =
130  format (s, " address %U", hw_class->format_address,
131  hi->hw_address);
132  }
133 
134  if (dev_class->format_device)
135  s = format (s, "\n%U%U",
136  format_white_space, indent + 2,
137  dev_class->format_device, hi->dev_instance, verbose);
138  }
139 
140  return s;
141 }
142 
143 u8 *
144 format_vnet_sw_interface_name (u8 * s, va_list * args)
145 {
146  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
147  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
148  vnet_sw_interface_t *si_sup =
150  vnet_hw_interface_t *hi_sup;
151 
153  hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
154 
155  s = format (s, "%v", hi_sup->name);
156 
158  s = format (s, ".%d", si->sub.id);
159 
160  return s;
161 }
162 
163 u8 *
164 format_vnet_sw_if_index_name (u8 * s, va_list * args)
165 {
166  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
167  u32 sw_if_index = va_arg (*args, u32);
169 
170  si = vnet_get_sw_interface_safe (vnm, sw_if_index);
171 
172  if (NULL == si)
173  {
174  return format (s, "DELETED");
175  }
176  return format (s, "%U", format_vnet_sw_interface_name, vnm, si);
177 }
178 
179 u8 *
180 format_vnet_hw_if_index_name (u8 * s, va_list * args)
181 {
182  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
183  u32 hw_if_index = va_arg (*args, u32);
185 
186  hi = vnet_get_hw_interface (vnm, hw_if_index);
187 
188  if (hi == 0)
189  return format (s, "DELETED");
190 
191  return format (s, "%v", hi->name);
192 }
193 
194 u8 *
196  vnet_sw_interface_t * si)
197 {
198  u32 indent, n_printed;
199  int i, j, n_counters;
200  static vnet_main_t **my_vnet_mains;
201 
202  vec_reset_length (my_vnet_mains);
203 
204  indent = format_get_indent (s);
205  n_printed = 0;
206 
207  {
209  vlib_counter_t v, vtotal;
210  u8 *n = 0;
211 
212  for (i = 0; i < vec_len (vnet_mains); i++)
213  {
214  if (vnet_mains[i])
215  vec_add1 (my_vnet_mains, vnet_mains[i]);
216  }
217 
218  if (vec_len (my_vnet_mains) == 0)
219  vec_add1 (my_vnet_mains, &vnet_main);
220 
221  /* Each vnet_main_t has its own copy of the interface counters */
222  n_counters = vec_len (im->combined_sw_if_counters);
223 
224  /* rx, tx counters... */
225  for (j = 0; j < n_counters; j++)
226  {
227  vtotal.packets = 0;
228  vtotal.bytes = 0;
229 
230  for (i = 0; i < vec_len (my_vnet_mains); i++)
231  {
232  im = &my_vnet_mains[i]->interface_main;
233  cm = im->combined_sw_if_counters + j;
235  vtotal.packets += v.packets;
236  vtotal.bytes += v.bytes;
237  }
238 
239  /* Only display non-zero counters. */
240  if (vtotal.packets == 0)
241  continue;
242 
243  if (n_printed > 0)
244  s = format (s, "\n%U", format_white_space, indent);
245  n_printed += 2;
246 
247  if (n)
248  _vec_len (n) = 0;
249  n = format (n, "%s packets", cm->name);
250  s = format (s, "%-16v%16Ld", n, vtotal.packets);
251 
252  _vec_len (n) = 0;
253  n = format (n, "%s bytes", cm->name);
254  s = format (s, "\n%U%-16v%16Ld",
255  format_white_space, indent, n, vtotal.bytes);
256  }
257  vec_free (n);
258  }
259 
260  {
262  u64 v, vtotal;
263 
264  n_counters = vec_len (im->sw_if_counters);
265 
266  for (j = 0; j < n_counters; j++)
267  {
268  vtotal = 0;
269 
270  for (i = 0; i < vec_len (my_vnet_mains); i++)
271  {
272  im = &my_vnet_mains[i]->interface_main;
273  cm = im->sw_if_counters + j;
274 
275  v = vlib_get_simple_counter (cm, si->sw_if_index);
276  vtotal += v;
277  }
278 
279  /* Only display non-zero counters. */
280  if (vtotal == 0)
281  continue;
282 
283  if (n_printed > 0)
284  s = format (s, "\n%U", format_white_space, indent);
285  n_printed += 1;
286 
287  s = format (s, "%-16s%16Ld", cm->name, vtotal);
288  }
289  }
290 
291  return s;
292 }
293 
294 static u8 *
295 format_vnet_sw_interface_mtu (u8 * s, va_list * args)
296 {
297  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
298 
299  return format (s, "%d/%d/%d/%d", si->mtu[VNET_MTU_L3],
300  si->mtu[VNET_MTU_IP4],
301  si->mtu[VNET_MTU_IP6], si->mtu[VNET_MTU_MPLS]);
302 }
303 
304 u8 *
305 format_vnet_sw_interface (u8 * s, va_list * args)
306 {
307  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
308  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
310 
311  if (!si)
312  return format (s, "%=32s%=5s%=10s%=21s%=16s%=16s",
313  "Name", "Idx", "State", "MTU (L3/IP4/IP6/MPLS)", "Counter",
314  "Count");
315 
316  s = format (s, "%-32U%=5d%=10U%=21U",
320 
321  s = format_vnet_sw_interface_cntrs (s, im, si);
322 
323  return s;
324 }
325 
326 u8 *
328 {
329  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
330  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
331  /* caller supplied display name for this interface */
332  u8 *name = va_arg (*args, u8 *);
334 
335 
336  if (!si)
337  return format (s, "%=32s%=5s%=16s%=16s%=16s",
338  "Name", "Idx", "State", "Counter", "Count");
339 
340  s = format (s, "%-32v%=5d%=16U",
341  name, si->sw_if_index,
343 
344  s = format_vnet_sw_interface_cntrs (s, im, si);
345 
346  return s;
347 }
348 
349 uword
351 {
352  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
353  u32 *hw_if_index = va_arg (*args, u32 *);
356 
357  /* Try per device class functions first. */
358  vec_foreach (c, im->device_classes)
359  {
360  if (c->unformat_device_name
361  && unformat_user (input, c->unformat_device_name, hw_if_index))
362  return 1;
363  }
364 
366  im->hw_interface_by_name, hw_if_index);
367 }
368 
369 uword
371 {
372  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
373  u32 *result = va_arg (*args, u32 *);
375  u32 hw_if_index, id, id_specified;
377  u8 *if_name = 0;
378  uword *p, error = 0;
379 
380  id = ~0;
381  if (unformat (input, "%_%v.%d%_", &if_name, &id)
382  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
383  {
384  hw_if_index = p[0];
385  id_specified = 1;
386  }
387  else
388  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
389  id_specified = 0;
390  else
391  goto done;
392 
393  hi = vnet_get_hw_interface (vnm, hw_if_index);
394  if (!id_specified)
395  {
396  sw_if_index = hi->sw_if_index;
397  }
398  else
399  {
400  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
401  goto done;
402  sw_if_index = p[0];
403  }
404  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
405  goto done;
406  *result = sw_if_index;
407  error = 1;
408 done:
409  vec_free (if_name);
410  return error;
411 }
412 
413 uword
415 {
416  u32 *result = va_arg (*args, u32 *);
417  u32 flags = 0;
418 
419  if (unformat (input, "up"))
421  else if (unformat (input, "down"))
423  else if (unformat (input, "punt"))
425  else if (unformat (input, "enable"))
426  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
427  else
428  return 0;
429 
430  *result = flags;
431  return 1;
432 }
433 
434 uword
436 {
437  u32 *result = va_arg (*args, u32 *);
438  u32 flags = 0;
439 
440  if (unformat (input, "up"))
442  else if (unformat (input, "down"))
444  else
445  return 0;
446 
447  *result = flags;
448  return 1;
449 }
450 
451 /*
452  * fd.io coding-style-patch-verification: ON
453  *
454  * Local Variables:
455  * eval: (c-set-style "gnu")
456  * End:
457  */
vmrglw vmrglh hi
uword unformat_vnet_hw_interface(unformat_input_t *input, va_list *args)
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)
#define NULL
Definition: clib.h:57
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:523
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:579
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:494
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.
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:97
vnet_hw_interface_rx_mode
Definition: interface.h:51
u32 sw_if_index
Definition: vxlan_gbp.api:39
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:855
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
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:739
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:835
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:742
counter_t packets
packet counter
Definition: counter_types.h:28
#define v
Definition: acl.c:496
struct _unformat_input_t unformat_input_t
u8 * format_vnet_sw_if_index_name(u8 *s, va_list *args)
vnet_sw_interface_flags_t flags
Definition: interface.h:720
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:854
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:151
u32 flags
Definition: vhost_user.h:115
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:590
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:243
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
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)
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)
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)
u64 uword
Definition: types.h:112
char * name
The counter collection&#39;s name.
Definition: counter.h:177
A collection of combined counters.
Definition: counter.h:172
vnet_sw_interface_type_t type
Definition: interface.h:718
#define vec_foreach(var, vec)
Vector iterator.
vnet_device_class_t * device_classes
Definition: interface.h:839
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
static uword vnet_sw_interface_is_api_visible(vnet_main_t *vnm, u32 sw_if_index)