2 * drop.c - Punt and drop nodes
4 * Copyright (c) 2015 Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <vlib/vlib.h>
19 #include <vppinfra/vector/count_equal.h>
23 ERROR_DISPOSITION_DROP,
24 ERROR_DISPOSITION_PUNT,
26 } error_disposition_t;
29 validate_error (vlib_main_t * vm, vlib_error_t * e, u32 index)
31 uword node_index = vlib_error_get_node (&vm->node_main, e[0]);
32 uword code = vlib_error_get_code (&vm->node_main, e[0]);
35 if (node_index >= vec_len (vm->node_main.nodes))
36 return format (0, "[%d], node index out of range 0x%x, error 0x%x",
37 index, node_index, e[0]);
39 n = vlib_get_node (vm, node_index);
40 if (code >= n->n_errors)
41 return format (0, "[%d], code %d out of range for node %v",
42 index, code, n->name);
48 validate_error_frame (vlib_main_t * vm,
49 vlib_node_runtime_t * node, vlib_frame_t * f)
51 u32 *buffers = vlib_frame_vector_args (f);
56 for (i = 0; i < f->n_vectors; i++)
58 b = vlib_get_buffer (vm, buffers[i]);
59 msg = validate_error (vm, &b->error, i);
68 counter_index (vlib_main_t * vm, vlib_error_t e)
73 ni = vlib_error_get_node (&vm->node_main, e);
74 n = vlib_get_node (vm, ni);
76 ci = vlib_error_get_code (&vm->node_main, e);
77 if (ci >= n->n_errors)
80 ci += n->error_heap_index;
86 format_error_trace (u8 * s, va_list * va)
88 vlib_main_t *vm = va_arg (*va, vlib_main_t *);
89 CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
90 vlib_error_t *e = va_arg (*va, vlib_error_t *);
91 vlib_node_t *error_node;
92 vlib_error_main_t *em = &vm->error_main;
95 error_node = vlib_get_node (vm, vlib_error_get_node (&vm->node_main, e[0]));
96 i = counter_index (vm, vlib_error_get_code (&vm->node_main, e[0])) +
97 error_node->error_heap_index;
98 if (i != CLIB_U32_MAX)
99 s = format (s, "%v: %s", error_node->name, em->counters_heap[i].desc);
105 trace_errors (vlib_main_t * vm,
106 vlib_node_runtime_t * node, vlib_frame_t * frame)
108 u32 n_left, *buffers;
110 buffers = vlib_frame_vector_args (frame);
111 n_left = frame->n_vectors;
116 vlib_buffer_t *b0, *b1;
117 vlib_error_t *t0, *t1;
119 /* Prefetch next iteration. */
120 vlib_prefetch_buffer_with_index (vm, buffers[2], LOAD);
121 vlib_prefetch_buffer_with_index (vm, buffers[3], LOAD);
126 b0 = vlib_get_buffer (vm, bi0);
127 b1 = vlib_get_buffer (vm, bi1);
129 if (b0->flags & VLIB_BUFFER_IS_TRACED)
131 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
134 if (b1->flags & VLIB_BUFFER_IS_TRACED)
136 t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
151 b0 = vlib_get_buffer (vm, bi0);
153 if (b0->flags & VLIB_BUFFER_IS_TRACED)
155 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
163 static_always_inline uword
164 process_drop_punt (vlib_main_t * vm,
165 vlib_node_runtime_t * node,
166 vlib_frame_t * frame, error_disposition_t disposition)
168 u32 errors[VLIB_FRAME_SIZE], *error, *from, n_left;
169 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
170 vlib_error_main_t *em = &vm->error_main;
172 from = vlib_frame_vector_args (frame);
173 n_left = frame->n_vectors;
177 vlib_get_buffers (vm, from, bufs, n_left);
179 if (node->flags & VLIB_NODE_FLAG_TRACE)
180 trace_errors (vm, node, frame);
182 /* collect the array of error first ... */
187 /* Prefetch 8 ahead - there's not much going on in each iteration */
188 vlib_prefetch_buffer_header (b[4], LOAD);
189 vlib_prefetch_buffer_header (b[5], LOAD);
190 vlib_prefetch_buffer_header (b[6], LOAD);
191 vlib_prefetch_buffer_header (b[7], LOAD);
193 error[0] = b[0]->error;
194 error[1] = b[1]->error;
195 error[2] = b[2]->error;
196 error[3] = b[3]->error;
204 error[0] = b[0]->error;
211 /* ... then count against them in blocks */
212 n_left = frame->n_vectors;
219 off = frame->n_vectors - n_left;
221 error = errors + off;
223 count = clib_count_equal_u32 (error, n_left);
226 c_index = counter_index (vm, error[0]);
227 if (c_index != CLIB_U32_MAX)
228 em->counters[c_index] += count;
230 vlib_error_elog_count (vm, c_index, count);
233 if (disposition == ERROR_DISPOSITION_DROP || !vm->os_punt_frame)
235 vlib_buffer_free (vm, from, frame->n_vectors);
237 /* If there is no punt function, free the frame as well. */
238 if (disposition == ERROR_DISPOSITION_PUNT && !vm->os_punt_frame)
239 vlib_frame_free (vm, frame);
242 vm->os_punt_frame (vm, node, frame);
244 return frame->n_vectors;
247 VLIB_NODE_FN (error_drop_node) (vlib_main_t * vm,
248 vlib_node_runtime_t * node,
249 vlib_frame_t * frame)
251 return process_drop_punt (vm, node, frame, ERROR_DISPOSITION_DROP);
254 VLIB_NODE_FN (error_punt_node) (vlib_main_t * vm,
255 vlib_node_runtime_t * node,
256 vlib_frame_t * frame)
258 return process_drop_punt (vm, node, frame, ERROR_DISPOSITION_PUNT);
262 VLIB_REGISTER_NODE (error_drop_node) = {
264 .flags = VLIB_NODE_FLAG_IS_DROP,
265 .vector_size = sizeof (u32),
266 .format_trace = format_error_trace,
267 .validate_frame = validate_error_frame,
272 VLIB_REGISTER_NODE (error_punt_node) = {
274 .flags = (VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
275 | VLIB_NODE_FLAG_IS_PUNT),
276 .vector_size = sizeof (u32),
277 .format_trace = format_error_trace,
278 .validate_frame = validate_error_frame,
283 * fd.io coding-style-patch-verification: ON
286 * eval: (c-set-style "gnu")