FD.io VPP  v18.04-17-g3a0d853
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 *
181  vnet_sw_interface_t * si)
182 {
183  u32 indent, n_printed;
184  int i, j, n_counters;
185  static vnet_main_t **my_vnet_mains;
186 
187  vec_reset_length (my_vnet_mains);
188 
189  indent = format_get_indent (s);
190  n_printed = 0;
191 
192  {
194  vlib_counter_t v, vtotal;
195  u8 *n = 0;
196 
197  for (i = 0; i < vec_len (vnet_mains); i++)
198  {
199  if (vnet_mains[i])
200  vec_add1 (my_vnet_mains, vnet_mains[i]);
201  }
202 
203  if (vec_len (my_vnet_mains) == 0)
204  vec_add1 (my_vnet_mains, &vnet_main);
205 
206  /* Each vnet_main_t has its own copy of the interface counters */
207  n_counters = vec_len (im->combined_sw_if_counters);
208 
209  /* rx, tx counters... */
210  for (j = 0; j < n_counters; j++)
211  {
212  vtotal.packets = 0;
213  vtotal.bytes = 0;
214 
215  for (i = 0; i < vec_len (my_vnet_mains); i++)
216  {
217  im = &my_vnet_mains[i]->interface_main;
218  cm = im->combined_sw_if_counters + j;
220  vtotal.packets += v.packets;
221  vtotal.bytes += v.bytes;
222  }
223 
224  /* Only display non-zero counters. */
225  if (vtotal.packets == 0)
226  continue;
227 
228  if (n_printed > 0)
229  s = format (s, "\n%U", format_white_space, indent);
230  n_printed += 2;
231 
232  if (n)
233  _vec_len (n) = 0;
234  n = format (n, "%s packets", cm->name);
235  s = format (s, "%-16v%16Ld", n, vtotal.packets);
236 
237  _vec_len (n) = 0;
238  n = format (n, "%s bytes", cm->name);
239  s = format (s, "\n%U%-16v%16Ld",
240  format_white_space, indent, n, vtotal.bytes);
241  }
242  vec_free (n);
243  }
244 
245  {
247  u64 v, vtotal;
248 
249  n_counters = vec_len (im->sw_if_counters);
250 
251  for (j = 0; j < n_counters; j++)
252  {
253  vtotal = 0;
254 
255  for (i = 0; i < vec_len (my_vnet_mains); i++)
256  {
257  im = &my_vnet_mains[i]->interface_main;
258  cm = im->sw_if_counters + j;
259 
260  v = vlib_get_simple_counter (cm, si->sw_if_index);
261  vtotal += v;
262  }
263 
264  /* Only display non-zero counters. */
265  if (vtotal == 0)
266  continue;
267 
268  if (n_printed > 0)
269  s = format (s, "\n%U", format_white_space, indent);
270  n_printed += 1;
271 
272  s = format (s, "%-16s%16Ld", cm->name, vtotal);
273  }
274  }
275 
276  return s;
277 }
278 
279 u8 *
280 format_vnet_sw_interface (u8 * s, va_list * args)
281 {
282  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
283  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
285 
286  if (!si)
287  return format (s, "%=32s%=5s%=16s%=16s%=16s",
288  "Name", "Idx", "State", "Counter", "Count");
289 
290  s = format (s, "%-32U%=5d%=16U",
293 
294  s = format_vnet_sw_interface_cntrs (s, im, si);
295 
296  return s;
297 }
298 
299 u8 *
301 {
302  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
303  vnet_sw_interface_t *si = va_arg (*args, vnet_sw_interface_t *);
304  /* caller supplied display name for this interface */
305  u8 *name = va_arg (*args, u8 *);
307 
308 
309  if (!si)
310  return format (s, "%=32s%=5s%=16s%=16s%=16s",
311  "Name", "Idx", "State", "Counter", "Count");
312 
313  s = format (s, "%-32v%=5d%=16U",
314  name, si->sw_if_index,
316 
317  s = format_vnet_sw_interface_cntrs (s, im, si);
318 
319  return s;
320 }
321 
322 uword
324 {
325  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
326  u32 *hw_if_index = va_arg (*args, u32 *);
329 
330  /* Try per device class functions first. */
331  vec_foreach (c, im->device_classes)
332  {
333  if (c->unformat_device_name
334  && unformat_user (input, c->unformat_device_name, hw_if_index))
335  return 1;
336  }
337 
339  im->hw_interface_by_name, hw_if_index);
340 }
341 
342 uword
344 {
345  vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
346  u32 *result = va_arg (*args, u32 *);
348  u32 hw_if_index, id, id_specified;
349  u32 sw_if_index;
350  u8 *if_name = 0;
351  uword *p, error = 0;
352 
353  id = ~0;
354  if (unformat (input, "%_%v.%d%_", &if_name, &id)
355  && ((p = hash_get (vnm->interface_main.hw_interface_by_name, if_name))))
356  {
357  hw_if_index = p[0];
358  id_specified = 1;
359  }
360  else
361  if (unformat (input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
362  id_specified = 0;
363  else
364  goto done;
365 
366  hi = vnet_get_hw_interface (vnm, hw_if_index);
367  if (!id_specified)
368  {
369  sw_if_index = hi->sw_if_index;
370  }
371  else
372  {
373  if (!(p = hash_get (hi->sub_interface_sw_if_index_by_id, id)))
374  goto done;
375  sw_if_index = p[0];
376  }
377  if (!vnet_sw_interface_is_api_visible (vnm, sw_if_index))
378  goto done;
379  *result = sw_if_index;
380  error = 1;
381 done:
382  vec_free (if_name);
383  return error;
384 }
385 
386 uword
388 {
389  u32 *result = va_arg (*args, u32 *);
390  u32 flags = 0;
391 
392  if (unformat (input, "up"))
394  else if (unformat (input, "down"))
396  else if (unformat (input, "punt"))
398  else if (unformat (input, "enable"))
399  flags &= ~VNET_SW_INTERFACE_FLAG_PUNT;
400  else
401  return 0;
402 
403  *result = flags;
404  return 1;
405 }
406 
407 uword
409 {
410  u32 *result = va_arg (*args, u32 *);
411  u32 flags = 0;
412 
413  if (unformat (input, "up"))
415  else if (unformat (input, "down"))
417  else
418  return 0;
419 
420  *result = flags;
421  return 1;
422 }
423 
424 /*
425  * fd.io coding-style-patch-verification: ON
426  *
427  * Local Variables:
428  * eval: (c-set-style "gnu")
429  * End:
430  */
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
u8 * format_vnet_sw_interface_flags(u8 *s, va_list *args)
#define NULL
Definition: clib.h:55
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:520
Combined counter to hold both packets and byte differences.
Definition: counter.h:139
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:483
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:390
u8 * format_vnet_hw_interface(u8 *s, va_list *args)
struct _vnet_device_class vnet_device_class_t
#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
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:718
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)
unsigned long u64
Definition: types.h:89
A collection of simple counters.
Definition: counter.h:58
u8 * format_vnet_sw_interface(u8 *s, va_list *args)
char * name
The counter collection&#39;s name.
Definition: counter.h:65
uword * hw_interface_by_name
Definition: interface.h:698
u8 * format_vnet_sw_interface_name_override(u8 *s, va_list *args)
#define hash_get(h, key)
Definition: hash.h:248
#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:624
counter_t packets
packet counter
Definition: counter.h:141
#define VNET_SW_INTERFACE_FLAG_BOND_SLAVE
Definition: interface.h:597
#define v
Definition: acl.c:495
struct _unformat_input_t unformat_input_t
u8 * format_vnet_sw_if_index_name(u8 *s, va_list *args)
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:717
uword unformat_vnet_hw_interface_flags(unformat_input_t *input, va_list *args)
unformat_function_t unformat_hash_vec_string
Definition: hash.h:703
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:494
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:250
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
static vnet_sw_interface_t * vnet_get_sw_interface_safe(vnet_main_t *vnm, u32 sw_if_index)
u8 * format_vnet_sw_interface_name(u8 *s, va_list *args)
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:588
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
#define VNET_SW_INTERFACE_FLAG_PUNT
Definition: interface.h:591
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)
u64 uword
Definition: types.h:112
counter_t bytes
byte counter
Definition: counter.h:142
struct _vnet_hw_interface_class vnet_hw_interface_class_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define VNET_SW_INTERFACE_FLAG_ERROR
Definition: interface.h:603
unsigned char u8
Definition: types.h:56
char * name
The counter collection&#39;s name.
Definition: counter.h:185
A collection of combined counters.
Definition: counter.h:180
vnet_sw_interface_type_t type
Definition: interface.h:583
#define vec_foreach(var, vec)
Vector iterator.
vnet_device_class_t * device_classes
Definition: interface.h:702
u32 flags
Definition: vhost-user.h:77
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)