FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
error.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  * error.c: VLIB error handler
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 <vlib/vlib.h>
41 #include <vppinfra/heap.h>
42 #include <vlib/stat_weak_inlines.h>
43 
44 uword
47  u32 * buffers,
48  u32 next_buffer_stride,
49  u32 n_buffers,
51  u32 drop_error_node, u32 drop_error_code)
52 {
53  u32 n_left_this_frame, n_buffers_left, *args, n_args_left;
54  vlib_error_t drop_error;
55  vlib_node_t *n;
56 
57  n = vlib_get_node (vm, drop_error_node);
58  drop_error = n->error_heap_index + drop_error_code;
59 
60  n_buffers_left = n_buffers;
61  while (n_buffers_left > 0)
62  {
63  vlib_get_next_frame (vm, node, next_index, args, n_args_left);
64 
65  n_left_this_frame = clib_min (n_buffers_left, n_args_left);
66  n_buffers_left -= n_left_this_frame;
67  n_args_left -= n_left_this_frame;
68 
69  while (n_left_this_frame >= 4)
70  {
71  u32 bi0, bi1, bi2, bi3;
72  vlib_buffer_t *b0, *b1, *b2, *b3;
73 
74  args[0] = bi0 = buffers[0];
75  args[1] = bi1 = buffers[1];
76  args[2] = bi2 = buffers[2];
77  args[3] = bi3 = buffers[3];
78 
79  b0 = vlib_get_buffer (vm, bi0);
80  b1 = vlib_get_buffer (vm, bi1);
81  b2 = vlib_get_buffer (vm, bi2);
82  b3 = vlib_get_buffer (vm, bi3);
83 
84  b0->error = drop_error;
85  b1->error = drop_error;
86  b2->error = drop_error;
87  b3->error = drop_error;
88 
89  buffers += 4;
90  args += 4;
91  n_left_this_frame -= 4;
92  }
93 
94  while (n_left_this_frame >= 1)
95  {
96  u32 bi0;
97  vlib_buffer_t *b0;
98 
99  args[0] = bi0 = buffers[0];
100 
101  b0 = vlib_get_buffer (vm, bi0);
102  b0->error = drop_error;
103 
104  buffers += 1;
105  args += 1;
106  n_left_this_frame -= 1;
107  }
108 
109  vlib_put_next_frame (vm, node, next_index, n_args_left);
110  }
111 
112  return n_buffers;
113 }
114 
115 /* Reserves given number of error codes for given node. */
116 void
118  char *error_strings[], vlib_error_desc_t counters[])
119 {
122 
124  uword l;
125  void *oldheap;
126 
127  ASSERT (vlib_get_thread_index () == 0);
128 
129  /* Free up any previous error strings. */
130  if (n->n_errors > 0)
132 
133  n->n_errors = n_errors;
134  n->error_counters = counters;
135 
136  if (n_errors == 0)
137  return;
138 
139  /* Legacy node */
140  if (!counters)
141  {
142  counters = clib_mem_alloc (sizeof (counters[0]) * n_errors);
143  int i;
144  for (i = 0; i < n_errors; i++)
145  {
146  counters[i].name = error_strings[i];
147  counters[i].desc = error_strings[i];
149  }
150  }
151 
152  n->error_heap_index =
153  heap_alloc (em->counters_heap, n_errors, n->error_heap_handle);
154  l = vec_len (em->counters_heap);
156  counters, n_errors * sizeof (counters[0]));
157 
159 
160  /* Switch to the stats segment ... */
161  oldheap = vlib_stats_push_heap (0);
162 
163  /* Allocate a counter/elog type for each error. */
164  vec_validate (em->counters, l - 1);
165 
166  /* Zero counters for re-registrations of errors. */
167  if (n->error_heap_index + n_errors <= vec_len (em->counters_last_clear))
170  n_errors * sizeof (em->counters[0]));
171  else
173  0, n_errors * sizeof (em->counters[0]));
174 
175  /* Register counter indices in the stat segment directory */
176  {
177  int i;
178  u8 *error_name = 0;
179 
180  for (i = 0; i < n_errors; i++)
181  {
182  vec_reset_length (error_name);
183  error_name =
184  format (error_name, "/err/%v/%s%c", n->name, counters[i].name, 0);
185  vlib_stats_register_error_index (oldheap, error_name, em->counters,
186  n->error_heap_index + i);
187  }
188 
189  vec_free (error_name);
190  }
191 
192  /* (re)register the em->counters base address, switch back to main heap */
193  vlib_stats_pop_heap2 (em->counters, vm->thread_index, oldheap, 1);
194 
195  {
197  uword i;
198 
199  clib_memset (&t, 0, sizeof (t));
200  if (n_errors > 0)
201  vec_validate (nm->node_by_error, n->error_heap_index + n_errors - 1);
202  for (i = 0; i < n_errors; i++)
203  {
204  t.format = (char *) format (0, "%v %s: %%d",
205  n->name, counters[i].name);
207  nm->node_by_error[n->error_heap_index + i] = n->index;
208  }
209  }
210 }
211 
212 uword
213 unformat_vlib_error (unformat_input_t *input, va_list *args)
214 {
215  vlib_main_t *vm = va_arg (*args, vlib_main_t *);
216  const vlib_error_main_t *em = &vm->error_main;
217  vlib_error_t *error_index = va_arg (*args, vlib_error_t *);
218  const vlib_node_t *node;
219  char *error_name;
220  u32 node_index;
221  vlib_error_t i;
222 
223  if (!unformat (input, "%U.%s", unformat_vlib_node, vm, &node_index,
224  &error_name))
225  return 0;
226 
228  for (i = 0; i < node->n_errors; i++)
229  {
230  vlib_error_t ei = node->error_heap_index + i;
231  if (strcmp (em->counters_heap[ei].name, error_name) == 0)
232  {
233  *error_index = ei;
234  vec_free (error_name);
235  return 1;
236  }
237  }
238 
239  vec_free (error_name);
240  return 0;
241 }
242 
243 static char *
245 {
246  switch (s)
247  {
249  return "error";
251  return "warn";
253  return "info";
254  default:
255  return "unknown";
256  }
257 }
258 
259 static clib_error_t *
261  unformat_input_t * input, vlib_cli_command_t * cmd)
262 {
264  vlib_node_t *n;
265  u32 code, i, ni;
266  u64 c;
267  int index = 0;
268  int verbose = 0;
269  u64 *sums = 0;
270 
271  if (unformat (input, "verbose %d", &verbose))
272  ;
273  else if (unformat (input, "verbose"))
274  verbose = 1;
275 
276  vec_validate (sums, vec_len (em->counters));
277 
278  if (verbose)
279  vlib_cli_output (vm, "%=10s%=35s%=35s%=10s%=6s", "Count", "Node",
280  "Reason", "Severity", "Index");
281  else
282  vlib_cli_output (vm, "%=10s%=35s%=35s%=10s", "Count", "Node", "Reason",
283  "Severity");
284 
286  {
287  em = &this_vlib_main->error_main;
288 
289  if (verbose)
290  vlib_cli_output (vm, "Thread %u (%v):", index,
292 
293  for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
294  {
295  n = vlib_get_node (this_vlib_main, ni);
296  for (code = 0; code < n->n_errors; code++)
297  {
298  i = n->error_heap_index + code;
299  c = em->counters[i];
300  if (i < vec_len (em->counters_last_clear))
301  c -= em->counters_last_clear[i];
302  sums[i] += c;
303 
304  if (c == 0 && verbose < 2)
305  continue;
306 
307  if (verbose)
308  vlib_cli_output (vm, "%10lu%=35v%=35s%=10s%=6d", c, n->name,
309  em->counters_heap[i].name,
310  sev2str (em->counters_heap[i].severity), i);
311  else
312  vlib_cli_output (vm, "%10lu%=35v%=35s%=10s", c, n->name,
313  em->counters_heap[i].name,
315  }
316  }
317  index++;
318  }
319 
320  if (verbose)
321  vlib_cli_output (vm, "Total:");
322 
323  for (ni = 0; ni < vec_len (vm->node_main.nodes); ni++)
324  {
325  n = vlib_get_node (vm, ni);
326  for (code = 0; code < n->n_errors; code++)
327  {
328  i = n->error_heap_index + code;
329  if (sums[i])
330  {
331  if (verbose)
332  vlib_cli_output (vm, "%10lu%=40v%=20s%=10d", sums[i], n->name,
333  em->counters_heap[i].name, i);
334  }
335  }
336  }
337 
338  vec_free (sums);
339 
340  return 0;
341 }
342 
343 /* *INDENT-OFF* */
345  .path = "show errors",
346  .short_help = "Show error counts",
347  .function = show_errors,
348 };
349 /* *INDENT-ON* */
350 
351 /* *INDENT-OFF* */
353  .path = "show node counters",
354  .short_help = "Show node counters",
355  .function = show_errors,
356 };
357 /* *INDENT-ON* */
358 
359 static clib_error_t *
361  unformat_input_t * input, vlib_cli_command_t * cmd)
362 {
363  vlib_error_main_t *em;
364  u32 i;
365 
367  {
368  em = &this_vlib_main->error_main;
370  for (i = 0; i < vec_len (em->counters); i++)
371  em->counters_last_clear[i] = em->counters[i];
372  }
373  return 0;
374 }
375 
376 /* *INDENT-OFF* */
378  .path = "clear errors",
379  .short_help = "Clear error counters",
380  .function = clear_error_counters,
381 };
382 /* *INDENT-ON* */
383 
384 /* *INDENT-OFF* */
386  .path = "clear node counters",
387  .short_help = "Clear node counters",
388  .function = clear_error_counters,
389 };
390 /* *INDENT-ON* */
391 
392 /*
393  * fd.io coding-style-patch-verification: ON
394  *
395  * Local Variables:
396  * eval: (c-set-style "gnu")
397  * End:
398  */
vec_reset_length
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Definition: vec_bootstrap.h:194
vlib.h
vlib_error_main_t
Definition: error.h:61
vlib_stats_push_heap
void * vlib_stats_push_heap(void *old)
Definition: stat_segment.c:50
cli_clear_error_counters
static vlib_cli_command_t cli_clear_error_counters
(constructor) VLIB_CLI_COMMAND (cli_clear_error_counters)
Definition: error.c:377
vlib_register_errors
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[], vlib_error_desc_t counters[])
Definition: error.c:117
elog_event_type_t::format
char * format
Format string.
Definition: elog.h:92
n_buffers
u32 n_buffers
Definition: interface_output.c:401
stat_weak_inlines.h
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
cli_clear_node_counters
static vlib_cli_command_t cli_clear_node_counters
(constructor) VLIB_CLI_COMMAND (cli_clear_node_counters)
Definition: error.c:385
unformat_vlib_error
uword unformat_vlib_error(unformat_input_t *input, va_list *args)
Definition: error.c:213
vlib_error_main_t::counters_heap
vlib_error_desc_t * counters_heap
Definition: error.h:71
vlib_get_buffer
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:111
name
string name[64]
Definition: fib.api:25
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
sev2str
static char * sev2str(enum vl_counter_severity_e s)
Definition: error.c:244
vlib_cli_command_t::path
char * path
Definition: cli.h:96
cli_show_node_counters
static vlib_cli_command_t cli_show_node_counters
(constructor) VLIB_CLI_COMMAND (cli_show_node_counters)
Definition: error.c:352
vlib_stats_pop_heap2
void vlib_stats_pop_heap2(u64 *error_vector, u32 thread_index, void *oldheap, int lock)
Definition: stat_segment.c:363
vlib_main_t::error_main
vlib_error_main_t error_main
Definition: main.h:177
vlib_main_t::node_main
vlib_node_main_t node_main
Definition: main.h:171
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
vlib_error_desc_t
Definition: error.h:54
node_index
node node_index
Definition: interface_output.c:420
VL_COUNTER_SEVERITY_INFO
@ VL_COUNTER_SEVERITY_INFO
Definition: error.h:51
show_errors
static clib_error_t * show_errors(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: error.c:260
unformat_input_t
struct _unformat_input_t unformat_input_t
vlib_worker_threads
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:35
clear_error_counters
static clib_error_t * clear_error_counters(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: error.c:360
VL_COUNTER_SEVERITY_ERROR
@ VL_COUNTER_SEVERITY_ERROR
Definition: error.h:49
vlib_error_desc_t::name
char * name
Definition: error.h:56
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
foreach_vlib_main
#define foreach_vlib_main()
Definition: threads.h:237
vlib_main_t::error_elog_event_types
elog_event_type_t * error_elog_event_types
Definition: main.h:204
vlib_error_desc_t::desc
char * desc
Definition: error.h:57
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
vlib_buffer_t::error
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:145
vlib_error_main_t::counters
u64 * counters
Definition: error.h:64
vlib_node_t::index
u32 index
Definition: node.h:269
vec_elt_at_index
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
Definition: vec_bootstrap.h:203
vlib_get_thread_index
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:208
unformat_vlib_node
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1241
c
svmdb_client_t * c
Definition: vpp_get_metrics.c:48
vlib_node_t::error_heap_handle
u32 error_heap_handle
Definition: node.h:314
uword
u64 uword
Definition: types.h:112
vlib_error_drop_buffers
uword vlib_error_drop_buffers(vlib_main_t *vm, vlib_node_runtime_t *node, u32 *buffers, u32 next_buffer_stride, u32 n_buffers, u32 next_index, u32 drop_error_node, u32 drop_error_code)
Definition: error.c:45
vlib_main_t::thread_index
u32 thread_index
Definition: main.h:213
vlib_get_node
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:86
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
vlib_node_t::n_errors
u16 n_errors
Definition: node.h:308
clib_min
#define clib_min(x, y)
Definition: clib.h:342
vl_counter_severity_e
vl_counter_severity_e
Definition: error.h:47
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
vlib_node_t::error_counters
vlib_error_desc_t * error_counters
Definition: node.h:318
heap_dealloc
__clib_export void heap_dealloc(void *v, uword handle)
Definition: heap.c:500
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
index
u32 index
Definition: flow_types.api:221
vlib_error_main_t::counters_last_clear
u64 * counters_last_clear
Definition: error.h:67
u64
unsigned long u64
Definition: types.h:89
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
vlib_put_next_frame
vlib_put_next_frame(vm, node, next_index, 0)
u32
unsigned int u32
Definition: types.h:88
nm
nat44_ei_main_t * nm
Definition: nat44_ei_hairpinning.c:413
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
vlib_node_t
Definition: node.h:247
heap_alloc
#define heap_alloc(v, size, handle)
Definition: heap.h:337
vlib_error_desc_t::severity
enum vl_counter_severity_e severity
Definition: error.h:58
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
vlib_node_t::error_heap_index
u32 error_heap_index
Definition: node.h:315
vlib_cli_show_errors
vlib_cli_command_t vlib_cli_show_errors
(constructor) VLIB_CLI_COMMAND (vlib_cli_show_errors)
Definition: error.c:344
vlib_node_main_t
Definition: node.h:665
vlib_error_t
u16 vlib_error_t
Definition: error.h:45
vlib_node_runtime_t
Definition: node.h:454
vlib_node_main_t::nodes
vlib_node_t ** nodes
Definition: node.h:668
elog_event_type_t
Definition: elog.h:82
vlib_cli_command_t
Definition: cli.h:92
vlib_get_next_frame
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:395
clib_mem_alloc
static void * clib_mem_alloc(uword size)
Definition: mem.h:253
vlib_stats_register_error_index
void vlib_stats_register_error_index(void *oldheap, u8 *name, u64 *em_vec, u64 index)
Definition: stat_segment.c:306
vlib_node_t::name
u8 * name
Definition: node.h:253
heap.h
VL_COUNTER_SEVERITY_WARN
@ VL_COUNTER_SEVERITY_WARN
Definition: error.h:50
vlib_buffer_t
VLIB buffer representation.
Definition: buffer.h:111