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