1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
@media only all and (prefers-color-scheme: dark) {
.highlight .hll { background-color: #49483e }
.highlight .c { color: #75715e } /* Comment */
.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
.highlight .k { color: #66d9ef } /* Keyword */
.highlight .l { color: #ae81ff } /* Literal */
.highlight .n { color: #f8f8f2 } /* Name */
.highlight .o { color: #f92672 } /* Operator */
.highlight .p { color: #f8f8f2 } /* Punctuation */
.highlight .ch { color: #75715e } /* Comment.Hashbang */
.highlight .cm { color: #75715e } /* Comment.Multiline */
.highlight .cp { color: #75715e } /* Comment.Preproc */
.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
.highlight .c1 { color: #75715e } /* Comment.Single */
.highlight .cs { color: #75715e } /* Comment.Special */
.highlight .gd { color: #f92672 } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gi { color: #a6e22e } /* Generic.Inserted */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #75715e } /* Generic.Subheading */
.highlight .kc { color: #66d9ef } /* Keyword.Constant */
.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
.highlight .kn { color: #f92672 } /* Keyword.Namespace */
.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
.highlight .kt { color: #66d9ef } /* Keyword.Type */
.highlight .ld { color: #e6db74 } /* Literal.Date */
.highlight .m { color: #ae81ff } /* Literal.Number */
.highlight .s { color: #e6db74 } /* Literal.String */
.highlight .na { color: #a6e22e } /* Name.Attribute */
.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
.highlight .nc { color: #a6e22e } /* Name.Class */
.highlight .no { color: #66d9ef } /* Name.Constant */
.highlight .nd { color: #a6e22e } /* Name.Decorator */
.highlight .ni { color: #f8f8f2 } /* Name.Entity */
.highlight .ne { color: #a6e22e } /* Name.Exception */
.highlight .nf { color: #a6e22e } /* Name.Function */
.highlight .nl { color: #f8f8f2 } /* Name.Label */
.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
.highlight .nx { color: #a6e22e } /* Name.Other */
.highlight .py { color: #f8f8f2 } /* Name.Property */
.highlight .nt { color: #f92672 } /* Name.Tag */
.highlight .nv { color: #f8f8f2 } /* Name.Variable */
.highlight .ow { color: #f92672 } /* Operator.Word */
.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
.highlight .sc { color: #e6db74 } /* Literal.String.Char */
.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
.highlight .se { color: #ae81ff } /* Literal.String.Escape */
.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
.highlight .sx { color: #e6db74 } /* Literal.String.Other */
.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
}
@media (prefers-color-scheme: light) {
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
}
# Copyright (c) 2019 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
*** Settings ***
| Resource | resources/libraries/robot/shared/default.robot
| ...
| Force Tags | 3_NODE_DOUBLE_LINK_TOPO | PERFTEST | HW_ENV | NDRPDR
| ... | NIC_Intel-X710 | DOT1Q | L2BDMACLRN | BASE | VHOST | 1VM
| ... | VHOST_1024 | LBOND | LBOND_VPP | LBOND_MODE_LACP | LBOND_LB_L34
| ... | LBOND_2L | VM_TESTPMD
| ...
| Suite Setup | Setup suite double link | performance
| Suite Teardown | Tear down suite | performance
| Test Setup | Setup test
| Test Teardown | Tear down test | performance | vhost
| ...
| Test Template | Local Template
| ...
| Documentation | *RFC2544: Pkt throughput L2BD test cases with vhost and vpp
| ... | link bonding*
| ...
| ... | *[Top] Network Topologies:* TG-DUT1=DUT2-TG 3-node circular topology
| ... | with single links between TG and DUT nodes and double link between DUT
| ... | nodes.
| ... | *[Enc] Packet Encapsulations:* Eth-IPv4 for L2 switching of IPv4. 802.1q
| ... | tagging is applied on link between DUT1 and DUT2.
| ... | *[Cfg] DUT configuration:* DUT1 and DUT2 are configured with VPP
| ... | link bonding (mode LACP, transmit policy l34) on link between DUT1 and
| ... | DUT2 and L2 bridge-domain with MAC learning enabled. Qemu VNFs are \
| ... | connected to VPP /*
* Copyright (c) 2015 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* trace.c: VLIB trace buffer.
*
* Copyright (c) 2008 Eliot Dresselhaus
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <vlib/vlib.h>
#include <vlib/threads.h>
#include <vnet/classify/vnet_classify.h>
u8 *vnet_trace_placeholder;
/* Helper function for nodes which only trace buffer data. */
void
vlib_trace_frame_buffers_only (vlib_main_t * vm,
vlib_node_runtime_t * node,
u32 * buffers,
uword n_buffers,
uword next_buffer_stride,
uword n_buffer_data_bytes_in_trace)
{
u32 n_left, *from;
n_left = n_buffers;
from = buffers;
while (n_left >= 4)
{
u32 bi0, bi1;
vlib_buffer_t *b0, *b1;
u8 *t0, *t1;
/* Prefetch next iteration. */
vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
bi0 = from[0];
bi1 = from[1];
b0 = vlib_get_buffer (vm, bi0);
b1 = vlib_get_buffer (vm, bi1);
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
t0 = vlib_add_trace (vm, node, b0, n_buffer_data_bytes_in_trace);
clib_memcpy_fast (t0, b0->data + b0->current_data,
n_buffer_data_bytes_in_trace);
}
if (b1->flags & VLIB_BUFFER_IS_TRACED)
{
t1 = vlib_add_trace (vm, node, b1, n_buffer_data_bytes_in_trace);
clib_memcpy_fast (t1, b1->data + b1->current_data,
n_buffer_data_bytes_in_trace);
}
from += 2;
n_left -= 2;
}
while (n_left >= 1)
{
u32 bi0;
vlib_buffer_t *b0;
u8 *t0;
bi0 = from[0];
b0 = vlib_get_buffer (vm, bi0);
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
t0 = vlib_add_trace (vm, node, b0, n_buffer_data_bytes_in_trace);
clib_memcpy_fast (t0, b0->data + b0->current_data,
n_buffer_data_bytes_in_trace);
}
from += 1;
n_left -= 1;
}
}
/* Free up all trace buffer memory. */
void
clear_trace_buffer (void)
{
int i;
vlib_trace_main_t *tm;
foreach_vlib_main ()
{
tm = &this_vlib_main->trace_main;
tm->trace_enable = 0;
vec_free (tm->nodes);
}
foreach_vlib_main ()
{
tm = &this_vlib_main->trace_main;
for (i = 0; i < vec_len (tm->trace_buffer_pool); i++)
if (!pool_is_free_index (tm->trace_buffer_pool, i))
vec_free (tm->trace_buffer_pool[i]);
pool_free (tm->trace_buffer_pool);
}
}
u8 *
format_vlib_trace (u8 * s, va_list * va)
{
vlib_main_t *vm = va_arg (*va, vlib_main_t *);
vlib_trace_header_t *h = va_arg (*va, vlib_trace_header_t *);
vlib_trace_header_t *e = vec_end (h);
vlib_node_t *node, *prev_node;
clib_time_t *ct = &vm->clib_time;
f64 t;
prev_node = 0;
while (h < e)
{
node = vlib_get_node (vm, h->node_index);
if (node != prev_node)
{
t =
(h->time - vm->cpu_time_main_loop_start) * ct->seconds_per_clock;
s =
format (s, "\n%U: %v", format_time_interval, "h:m:s:u", t,
node->name);
}
prev_node = node;
if (node->format_trace)
s = format (s, "\n %U", node->format_trace, vm, node, h->data);
else
s = format (s, "\n %U", node->format_buffer, h->data);
h = vlib_trace_header_next (h);
}
return s;
}
/* Root of all trace cli commands. */
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (trace_cli_command,static) = {
.path = "trace",
.short_help = "Packet tracer commands",
};
/* *INDENT-ON* */
int
trace_time_cmp (void *a1, void *a2)
{
vlib_trace_header_t **t1 = a1;
vlib_trace_header_t **t2 = a2;
i64 dt = t1[0]->time - t2[0]->time;
return dt < 0 ? -1 : (dt > 0 ? +1 : 0);
}
/*
* Return 1 if this packet passes the trace filter, or 0 otherwise
*/
u32
filter_accept (vlib_trace_main_t * tm, vlib_trace_header_t * h)
{
vlib_trace_header_t *e = vec_end (h);
if (tm->filter_flag == 0)
return 1;
/*
* When capturing a post-mortem dispatch trace,
* toss all existing traces once per dispatch cycle.
* So we can trace 4 billion pkts without running out of
* memory...
*/
if (tm->filter_flag == FILTER_FLAG_POST_MORTEM)
return 0;
if (tm->filter_flag == FILTER_FLAG_INCLUDE)
{
while (h < e)
{
if (h->node_index == tm->filter_node_index)
return 1;
h = vlib_trace_header_next (h);
}
return 0;
}
else /* FILTER_FLAG_EXCLUDE */
{
while (h < e)
{
if (h->node_index == tm->filter_node_index)
return 0;
h = vlib_trace_header_next (h);
}
return 1;
}
return 0;
}
/*
* Remove traces from the trace buffer pool that don't pass the filter
*/
void
trace_apply_filter (vlib_main_t * vm)
{
vlib_trace_main_t *tm = &vm->trace_main;
vlib_trace_header_t **h;
vlib_trace_header_t ***traces_to_remove = 0;
u32 index;
u32 trace_index;
u32 n_accepted;
u32 accept;
if (tm->filter_flag == FILTER_FLAG_NONE)
return;
/*
* Ideally we would retain the first N traces that pass the filter instead
* of any N traces.
*/
n_accepted = 0;
/* *INDENT-OFF* */
pool_foreach (h, tm->trace_buffer_pool)
{
accept = filter_accept(tm, h[0]);
if ((n_accepted == tm->filter_count) || !accept)
vec_add1 (traces_to_remove, h);
else
n_accepted++;
}
/* *INDENT-ON* */
/* remove all traces that we don't want to keep */
for (index = 0; index < vec_len (traces_to_remove); index++)
{
trace_index = traces_to_remove[index] - tm->trace_buffer_pool;
vec_set_len (tm->trace_buffer_pool[trace_index], 0);
pool_put_index (tm->trace_buffer_pool, trace_index);
}
vec_free (traces_to_remove);
}
static clib_error_t *
cli_show_trace_buffer (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
vlib_trace_main_t *tm;
vlib_trace_header_t **h, **traces;
u32 i, index = 0;
char *fmt;
u8 *s = 0;
u32 max;
/*
* By default display only this many traces. To display more, explicitly
* specify a max. This prevents unexpectedly huge outputs.
*/
max = 50;
while (unformat_check_input (input) != (uword) UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "max %d", &max))
;
else
return clib_error_create ("expected 'max COUNT', got `%U'",
format_unformat_error, input);
}
/* Get active traces from pool. */
foreach_vlib_main ()
{
fmt = "------------------- Start of thread %d %s -------------------\n";
s = format (s, fmt, index, vlib_worker_threads[index].name);
tm = &this_vlib_main->trace_main;
trace_apply_filter (this_vlib_main);
traces = 0;
pool_foreach (h, tm->trace_buffer_pool)
{
vec_add1 (traces, h[0]);
}
if (vec_len (traces) == 0)
{
s = format (s, "No packets in trace buffer\n");
goto done;
}
/* Sort them by increasing time. */
vec_sort_with_function (traces, trace_time_cmp);
for (i = 0; i < vec_len (traces); i++)
{
if (i == max)
{
char *warn = "Limiting display to %d packets."
" To display more specify max.";
vlib_cli_output (vm, warn, max);
s = format (s, warn, max);
goto done;
}
s = format (s, "Packet %d\n%U\n\n", i + 1, format_vlib_trace, vm,
traces[i]);
}
done:
vec_free (traces);
index++;
}
vlib_cli_output (vm, "%v", s);
vec_free (s);
return 0;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_trace_cli,static) = {
.path = "show trace",
.short_help = "Show trace buffer [max COUNT]",
.function = cli_show_trace_buffer,
};
/* *INDENT-ON* */
int vlib_enable_disable_pkt_trace_filter (int enable) __attribute__ ((weak));
int
vlib_enable_disable_pkt_trace_filter (int enable)
{
return 0;
}
void
vlib_trace_stop_and_clear (void)
{
vlib_enable_disable_pkt_trace_filter (0); /* disble tracing */
clear_trace_buffer ();
}
void
trace_update_capture_options (u32 add, u32 node_index, u32 filter, u8 verbose)
{
vlib_trace_main_t *tm;
vlib_trace_node_t *tn;
if (add == ~0)
add = 50;
foreach_vlib_main ()
{
tm = &this_vlib_main->trace_main;
tm->verbose = verbose;
vec_validate (tm->nodes, node_index);
tn = tm->nodes + node_index;
/*
* Adding 0 makes no real sense, and there wa no other way
* to explicilty zero-out the limits and count, so make
* an "add 0" request really be "set to 0".
*/
if (add == 0)
tn->limit = tn->count = 0;
else
tn->limit += add;
}
foreach_vlib_main ()
{
tm = &this_vlib_main->trace_main;
tm->trace_enable = 1;
}
vlib_enable_disable_pkt_trace_filter (! !filter);
}
static clib_error_t *
cli_add_trace_buffer (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
vlib_node_t *node;
u32 node_index, add;
u8 verbose = 0;
int filter = 0;
clib_error_t *error = 0;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
if (vnet_trace_placeholder == 0)
vec_validate_aligned (vnet_trace_placeholder, 2048,
CLIB_CACHE_LINE_BYTES);
while (unformat_check_input (line_input) != (uword) UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "%U %d",
unformat_vlib_node, vm, &node_index, &add))
;
else if (unformat (line_input, "verbose"))
verbose = 1;
else if (unformat (line_input, "filter"))
filter = 1;
else
{
error = clib_error_create ("expected NODE COUNT, got `%U'",
format_unformat_error, line_input);
goto done;
}
}
node = vlib_get_node (vm, node_index);
if ((node->flags & VLIB_NODE_FLAG_TRACE_SUPPORTED) == 0)
{
error = clib_error_create ("node '%U' doesn't support per-node "
"tracing. There may be another way to "
"initiate trace on this node.",
format_vlib_node_name, vm, node_index);
goto done;
}
trace_update_capture_options (add, node_index, filter, verbose);
done:
unformat_free (line_input);
return error;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (add_trace_cli,static) = {
.path = "trace add",
.short_help = "trace add <input-graph-node> <add'l-pkts-for-node-> [filter] [verbose]",
.function = cli_add_trace_buffer,
};
/* *INDENT-ON* */
/*
* Configure a filter for packet traces.
*
* This supplements the packet trace feature so that only packets matching
* the filter are included in the trace. Currently the only filter is to
* keep packets that include a certain node in the trace or exclude a certain
* node in the trace.
*
* The count of traced packets in the "trace add" command is still used to
* create a certain number of traces. The "trace filter" command specifies
* how many of those packets should be retained in the trace.
*
* For example, 1Mpps of traffic is arriving and one of those packets is being
* dropped. To capture the trace for only that dropped packet, you can do:
* trace filter include error-drop 1
* trace add dpdk-input 1000000
* <wait one second>
* show trace
*
* Note that the filter could be implemented by capturing all traces and just
* reducing traces displayed by the "show trace" function. But that would
* require a lot of memory for storing the traces, making that infeasible.
*
* To remove traces from the trace pool that do not include a certain node
* requires that the trace be "complete" before applying the filter. To
* accomplish this, the trace pool is filtered upon each iteraction of the
* main vlib loop. Doing so keeps the number of allocated traces down to a
* reasonably low number. This requires that tracing for a buffer is not
* performed after the vlib main loop interation completes. i.e. you can't
* save away a buffer temporarily then inject it back into the graph and
* expect that the trace_index is still valid (such as a traffic manager might
* do). A new trace buffer should be allocated for those types of packets.
*
* The filter can be extended to support multiple nodes and other match
* criteria (e.g. input sw_if_index, mac address) but for now just checks if
* a specified node is in the trace or not in the trace.
*/
void
trace_filter_set (u32 node_index, u32 flag, u32 count)
{
foreach_vlib_main ()
{
vlib_trace_main_t *tm;
tm = &this_vlib_main->trace_main;
tm->filter_node_index = node_index;
tm->filter_flag = flag;
tm->filter_count = count;
/*
* Clear the trace limits to stop any in-progress tracing
* Prevents runaway trace allocations when the filter changes
* (or is removed)
*/
vec_free (tm->nodes);
}
}
static clib_error_t *
cli_filter_trace (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
u32 filter_node_index;
u32 filter_flag;
u32 filter_count;
if (unformat (input, "include %U %d",
unformat_vlib_node, vm, &filter_node_index, &filter_count))
{
filter_flag = FILTER_FLAG_INCLUDE;
}
else if (unformat (input, "exclude %U %d",
unformat_vlib_node, vm, &filter_node_index,
&filter_count))
{
filter_flag = FILTER_FLAG_EXCLUDE;
}
else if (unformat (input, "none"))
{
filter_flag = FILTER_FLAG_NONE;
filter_node_index = 0;
filter_count = 0;
}
else
return
clib_error_create
("expected 'include NODE COUNT' or 'exclude NODE COUNT' or 'none', got `%U'",
format_unformat_error, input);
trace_filter_set (filter_node_index, filter_flag, filter_count);
return 0;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (filter_trace_cli,static) = {
.path = "trace filter",
.short_help = "trace filter none | [include|exclude] NODE COUNT",
.function = cli_filter_trace,
};
/* *INDENT-ON* */
static clib_error_t *
cli_clear_trace_buffer (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
vlib_trace_stop_and_clear ();
return 0;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (clear_trace_cli,static) = {
.path = "clear trace",
.short_help = "Clear trace buffer and free memory",
.function = cli_clear_trace_buffer,
};
/* *INDENT-ON* */
/* Placeholder function to get us linked in. */
void
vlib_trace_cli_reference (void)
{
}
void *
vlib_add_trace (vlib_main_t * vm,
vlib_node_runtime_t * r, vlib_buffer_t * b, u32 n_data_bytes)
{
return vlib_add_trace_inline (vm, r, b, n_data_bytes);
}
vlib_is_packet_traced_fn_t *
vlib_is_packet_traced_function_from_name (const char *name)
{
vlib_trace_filter_function_registration_t *reg =
vlib_trace_filter_main.trace_filter_registration;
while (reg)
{
if (clib_strcmp (reg->name, name) == 0)
break;
reg = reg->next;
}
if (!reg)
return 0;
return reg->function;
}
vlib_is_packet_traced_fn_t *
vlib_is_packet_traced_default_function ()
{
vlib_trace_filter_function_registration_t *reg =
vlib_trace_filter_main.trace_filter_registration;
vlib_trace_filter_function_registration_t *tmp_reg = reg;
while (reg)
{
if (reg->priority > tmp_reg->priority)
tmp_reg = reg;
reg = reg->next;
}
return tmp_reg->function;
}
static clib_error_t *
vlib_trace_filter_function_init (vlib_main_t *vm)
{
vlib_is_packet_traced_fn_t *default_fn =
vlib_is_packet_traced_default_function ();
foreach_vlib_main ()
{
vlib_trace_main_t *tm = &this_vlib_main->trace_main;
tm->current_trace_filter_function = default_fn;
}
return 0;
}
vlib_trace_filter_main_t vlib_trace_filter_main;
VLIB_INIT_FUNCTION (vlib_trace_filter_function_init);
static clib_error_t *
show_trace_filter_function (vlib_main_t *vm, unformat_input_t *input,
vlib_cli_command_t *cmd)
{
vlib_trace_filter_main_t *tfm = &vlib_trace_filter_main;
vlib_trace_main_t *tm = &vm->trace_main;
vlib_is_packet_traced_fn_t *current_trace_filter_fn =
tm->current_trace_filter_function;
vlib_trace_filter_function_registration_t *reg =
tfm->trace_filter_registration;
while (reg)
{
vlib_cli_output (vm, "%sname:%s description: %s priority: %u",
reg->function == current_trace_filter_fn ? "(*) " : "",
reg->name, reg->description, reg->priority);
reg = reg->next;
}
return 0;
}
VLIB_CLI_COMMAND (show_trace_filter_function_cli, static) = {
.path = "show trace filter function",
.short_help = "show trace filter function",
.function = show_trace_filter_function,
};
uword
unformat_vlib_trace_filter_function (unformat_input_t *input, va_list *args)
{
vlib_is_packet_traced_fn_t **res =
va_arg (*args, vlib_is_packet_traced_fn_t **);
vlib_trace_filter_main_t *tfm = &vlib_trace_filter_main;
vlib_trace_filter_function_registration_t *reg =
tfm->trace_filter_registration;
while (reg)
{
if (unformat (input, reg->name))
{
*res = reg->function;
return 1;
}
reg = reg->next;
}
return 0;
}
void
vlib_set_trace_filter_function (vlib_is_packet_traced_fn_t *x)
{
foreach_vlib_main ()
{
this_vlib_main->trace_main.current_trace_filter_function = x;
}
}
static clib_error_t *
set_trace_filter_function (vlib_main_t *vm, unformat_input_t *input,
vlib_cli_command_t *cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
vlib_is_packet_traced_fn_t *res = 0;
clib_error_t *error = 0;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
while (unformat_check_input (line_input) != (uword) UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "%U", unformat_vlib_trace_filter_function,
&res))
;
else
{
error = clib_error_create (
"expected valid trace filter function, got `%U'",
format_unformat_error, line_input);
goto done;
}
}
vlib_set_trace_filter_function (res);
done:
unformat_free (line_input);
return error;
}
VLIB_CLI_COMMAND (set_trace_filter_function_cli, static) = {
.path = "set trace filter function",
.short_help = "set trace filter function <func_name>",
.function = set_trace_filter_function,
};
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
|