FD.io VPP  v19.04.4-rc0-5-ge88582fac
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 
43 uword
45  vlib_node_runtime_t * node,
46  u32 * buffers,
47  u32 next_buffer_stride,
48  u32 n_buffers,
49  u32 next_index,
50  u32 drop_error_node, u32 drop_error_code)
51 {
52  u32 n_left_this_frame, n_buffers_left, *args, n_args_left;
53  vlib_error_t drop_error;
54  vlib_node_t *n;
55 
56  n = vlib_get_node (vm, drop_error_node);
57  drop_error = n->error_heap_index + drop_error_code;
58 
59  n_buffers_left = n_buffers;
60  while (n_buffers_left > 0)
61  {
62  vlib_get_next_frame (vm, node, next_index, args, n_args_left);
63 
64  n_left_this_frame = clib_min (n_buffers_left, n_args_left);
65  n_buffers_left -= n_left_this_frame;
66  n_args_left -= n_left_this_frame;
67 
68  while (n_left_this_frame >= 4)
69  {
70  u32 bi0, bi1, bi2, bi3;
71  vlib_buffer_t *b0, *b1, *b2, *b3;
72 
73  args[0] = bi0 = buffers[0];
74  args[1] = bi1 = buffers[1];
75  args[2] = bi2 = buffers[2];
76  args[3] = bi3 = buffers[3];
77 
78  b0 = vlib_get_buffer (vm, bi0);
79  b1 = vlib_get_buffer (vm, bi1);
80  b2 = vlib_get_buffer (vm, bi2);
81  b3 = vlib_get_buffer (vm, bi3);
82 
83  b0->error = drop_error;
84  b1->error = drop_error;
85  b2->error = drop_error;
86  b3->error = drop_error;
87 
88  buffers += 4;
89  args += 4;
90  n_left_this_frame -= 4;
91  }
92 
93  while (n_left_this_frame >= 1)
94  {
95  u32 bi0;
96  vlib_buffer_t *b0;
97 
98  args[0] = bi0 = buffers[0];
99 
100  b0 = vlib_get_buffer (vm, bi0);
101  b0->error = drop_error;
102 
103  buffers += 1;
104  args += 1;
105  n_left_this_frame -= 1;
106  }
107 
108  vlib_put_next_frame (vm, node, next_index, n_args_left);
109  }
110 
111  return n_buffers;
112 }
113 
114 void vlib_stats_register_error_index (void *, u8 *, u64 *, u64)
115  __attribute__ ((weak));
116 void
117 vlib_stats_register_error_index (void *noutused, u8 * notused2,
118  u64 * notused3, u64 notused4)
119 {
120 };
121 
122 void vlib_stats_pop_heap2 (void *, u32, void *) __attribute__ ((weak));
123 void
124 vlib_stats_pop_heap2 (void *notused, u32 notused2, void *notused3)
125 {
126 };
127 
128 
129 /* Reserves given number of error codes for given node. */
130 void
132  u32 node_index, u32 n_errors, char *error_strings[])
133 {
134  vlib_error_main_t *em = &vm->error_main;
135  vlib_node_main_t *nm = &vm->node_main;
136 
137  vlib_node_t *n = vlib_get_node (vm, node_index);
138  uword l;
139  void *oldheap;
140  void *vlib_stats_push_heap (void) __attribute__ ((weak));
141 
142  ASSERT (vlib_get_thread_index () == 0);
143 
144  /* Free up any previous error strings. */
145  if (n->n_errors > 0)
147 
148  n->n_errors = n_errors;
149  n->error_strings = error_strings;
150 
151  if (n_errors == 0)
152  return;
153 
154  n->error_heap_index =
155  heap_alloc (em->error_strings_heap, n_errors, n->error_heap_handle);
156 
157  l = vec_len (em->error_strings_heap);
158 
160  error_strings, n_errors * sizeof (error_strings[0]));
161 
163 
164  /* Switch to the stats segment ... */
165  oldheap = vlib_stats_push_heap ();
166 
167  /* Allocate a counter/elog type for each error. */
168  vec_validate (em->counters, l - 1);
169 
170  /* Zero counters for re-registrations of errors. */
171  if (n->error_heap_index + n_errors <= vec_len (em->counters_last_clear))
174  n_errors * sizeof (em->counters[0]));
175  else
177  0, n_errors * sizeof (em->counters[0]));
178 
179  /* Register counter indices in the stat segment directory */
180  {
181  int i;
182  u8 *error_name;
183 
184  for (i = 0; i < n_errors; i++)
185  {
186  error_name = format (0, "/err/%v/%s%c", n->name, error_strings[i], 0);
187  /* Note: error_name consumed by the following call */
188  vlib_stats_register_error_index (oldheap, error_name, em->counters,
189  n->error_heap_index + i);
190  }
191  }
192 
193  /* (re)register the em->counters base address, switch back to main heap */
194  vlib_stats_pop_heap2 (em->counters, vm->thread_index, oldheap);
195 
196  {
198  uword i;
199 
200  clib_memset (&t, 0, sizeof (t));
201  if (n_errors > 0)
202  vec_validate (nm->node_by_error, n->error_heap_index + n_errors - 1);
203  for (i = 0; i < n_errors; i++)
204  {
205  t.format = (char *) format (0, "%v %s: %%d",
206  n->name, error_strings[i]);
208  nm->node_by_error[n->error_heap_index + i] = n->index;
209  }
210  }
211 }
212 
213 static clib_error_t *
215  unformat_input_t * input, vlib_cli_command_t * cmd)
216 {
217  vlib_error_main_t *em = &vm->error_main;
218  vlib_node_t *n;
219  u32 code, i, ni;
220  u64 c;
221  int index = 0;
222  int verbose = 0;
223  u64 *sums = 0;
224 
225  if (unformat (input, "verbose %d", &verbose))
226  ;
227  else if (unformat (input, "verbose"))
228  verbose = 1;
229 
230  vec_validate (sums, vec_len (em->counters));
231 
232  if (verbose)
233  vlib_cli_output (vm, "%=10s%=40s%=20s%=6s", "Count", "Node", "Reason",
234  "Index");
235  else
236  vlib_cli_output (vm, "%=10s%=40s%=6s", "Count", "Node", "Reason");
237 
238 
239  /* *INDENT-OFF* */
241  em = &this_vlib_main->error_main;
242 
243  if (verbose)
244  vlib_cli_output(vm, "Thread %u (%v):", index,
245  vlib_worker_threads[index].name);
246 
247  for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
248  {
249  n = vlib_get_node (this_vlib_main, ni);
250  for (code = 0; code < n->n_errors; code++)
251  {
252  i = n->error_heap_index + code;
253  c = em->counters[i];
254  if (i < vec_len (em->counters_last_clear))
255  c -= em->counters_last_clear[i];
256  sums[i] += c;
257 
258  if (c == 0 && verbose < 2)
259  continue;
260 
261  if (verbose)
262  vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name,
263  em->error_strings_heap[i], i);
264  else
265  vlib_cli_output (vm, "%10d%=40v%s", c, n->name,
266  em->error_strings_heap[i]);
267  }
268  }
269  index++;
270  }));
271  /* *INDENT-ON* */
272 
273  if (verbose)
274  vlib_cli_output (vm, "Total:");
275 
276  for (ni = 0; ni < vec_len (vm->node_main.nodes); ni++)
277  {
278  n = vlib_get_node (vm, ni);
279  for (code = 0; code < n->n_errors; code++)
280  {
281  i = n->error_heap_index + code;
282  if (sums[i])
283  {
284  if (verbose)
285  vlib_cli_output (vm, "%10Ld%=40v%=20s%=10d", sums[i], n->name,
286  em->error_strings_heap[i], i);
287  }
288  }
289  }
290 
291  vec_free (sums);
292 
293  return 0;
294 }
295 
296 /* *INDENT-OFF* */
297 VLIB_CLI_COMMAND (vlib_cli_show_errors) = {
298  .path = "show errors",
299  .short_help = "Show error counts",
300  .function = show_errors,
301 };
302 /* *INDENT-ON* */
303 
304 /* *INDENT-OFF* */
305 VLIB_CLI_COMMAND (cli_show_node_counters, static) = {
306  .path = "show node counters",
307  .short_help = "Show node counters",
308  .function = show_errors,
309 };
310 /* *INDENT-ON* */
311 
312 static clib_error_t *
314  unformat_input_t * input, vlib_cli_command_t * cmd)
315 {
316  vlib_error_main_t *em;
317  u32 i;
318 
319  /* *INDENT-OFF* */
321  em = &this_vlib_main->error_main;
323  for (i = 0; i < vec_len (em->counters); i++)
324  em->counters_last_clear[i] = em->counters[i];
325  }));
326  /* *INDENT-ON* */
327  return 0;
328 }
329 
330 /* *INDENT-OFF* */
331 VLIB_CLI_COMMAND (cli_clear_error_counters, static) = {
332  .path = "clear errors",
333  .short_help = "Clear error counters",
334  .function = clear_error_counters,
335 };
336 /* *INDENT-ON* */
337 
338 /* *INDENT-OFF* */
339 VLIB_CLI_COMMAND (cli_clear_node_counters, static) = {
340  .path = "clear node counters",
341  .short_help = "Clear node counters",
342  .function = clear_error_counters,
343 };
344 /* *INDENT-ON* */
345 
346 /*
347  * fd.io coding-style-patch-verification: ON
348  *
349  * Local Variables:
350  * eval: (c-set-style "gnu")
351  * End:
352  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
void vlib_stats_register_error_index(void *, u8 *, u64 *, u64)
Definition: error.c:117
void * vlib_stats_push_heap(void *)
Definition: cli.c:799
u32 error_heap_index
Definition: node.h:323
#define clib_min(x, y)
Definition: clib.h:295
unsigned long u64
Definition: types.h:89
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
u32 index
Definition: node.h:279
static clib_error_t * show_errors(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: error.c:214
u32 thread_index
Definition: main.h:197
char ** error_strings
Definition: node.h:326
u16 vlib_error_t
Definition: error.h:43
int i
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
char * format
Format string.
Definition: elog.h:92
unsigned char u8
Definition: types.h:56
#define clib_memcpy(d, s, n)
Definition: string.h:180
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
Definition: error.c:131
u64 * counters_last_clear
Definition: error.h:51
void vlib_stats_pop_heap2(void *, u32, void *)
Definition: error.c:124
vlib_node_t ** nodes
Definition: node.h:697
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
elog_event_type_t * error_elog_event_types
Definition: main.h:185
unsigned int u32
Definition: types.h:88
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:36
u32 error_heap_handle
Definition: node.h:322
vlib_error_main_t error_main
Definition: main.h:158
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:44
struct _unformat_input_t unformat_input_t
u32 * node_by_error
Definition: node.h:765
#define foreach_vlib_main(body)
Definition: threads.h:235
#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:338
u8 name[64]
Definition: memclnt.api:152
u8 * name
Definition: node.h:263
u64 * counters
Definition: error.h:48
char ** error_strings_heap
Definition: error.h:55
svmdb_client_t * c
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:212
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:458
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
#define ASSERT(truth)
void heap_dealloc(void *v, uword handle)
Definition: heap.c:496
#define heap_alloc(v, size, handle)
Definition: heap.h:337
static clib_error_t * clear_error_counters(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: error.c:313
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vlib_node_main_t node_main
Definition: main.h:135
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
u16 n_errors
Definition: node.h:316
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972