src/vlib/drop.c

   1 /*
   2  * drop.c - Punt and drop nodes
   3  *
   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:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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.
  16  */
  17
  18 #include <vlib/vlib.h>
  19
  20 typedef enum
  21 {
  22   ERROR_DISPOSITION_DROP,
  23   ERROR_DISPOSITION_PUNT,
  24   ERROR_N_DISPOSITION,
  25 } error_disposition_t;
  26
  27 static u8 *
  28 validate_error (vlib_main_t * vm, vlib_error_t * e, u32 index)
  29 {
  30   uword node_index = vlib_error_get_node (&vm->node_main, e[0]);
  31   uword code = vlib_error_get_code (&vm->node_main, e[0]);
  32   vlib_node_t *n;
  33
  34   if (node_index >= vec_len (vm->node_main.nodes))
  35     return format (0, "[%d], node index out of range 0x%x, error 0x%x",
  36                    index, node_index, e[0]);
  37
  38   n = vlib_get_node (vm, node_index);
  39   if (code >= n->n_errors)
  40     return format (0, "[%d], code %d out of range for node %v",
  41                    index, code, n->name);
  42
  43   return 0;
  44 }
  45
  46 static u8 *
  47 validate_error_frame (vlib_main_t * vm,
  48                       vlib_node_runtime_t * node, vlib_frame_t * f)
  49 {
  50   u32 *buffers = vlib_frame_vector_args (f);
  51   vlib_buffer_t *b;
  52   u8 *msg = 0;
  53   uword i;
  54
  55   for (i = 0; i < f->n_vectors; i++)
  56     {
  57       b = vlib_get_buffer (vm, buffers[i]);
  58       msg = validate_error (vm, &b->error, i);
  59       if (msg)
  60         return msg;
  61     }
  62
  63   return msg;
  64 }
  65
  66 always_inline u32
  67 counter_index (vlib_main_t * vm, vlib_error_t e)
  68 {
  69   vlib_node_t *n;
  70   u32 ci, ni;
  71
  72   ni = vlib_error_get_node (&vm->node_main, e);
  73   n = vlib_get_node (vm, ni);
  74
  75   ci = vlib_error_get_code (&vm->node_main, e);
  76   ASSERT (ci < n->n_errors);
  77
  78   ci += n->error_heap_index;
  79
  80   return ci;
  81 }
  82
  83 static u8 *
  84 format_error_trace (u8 * s, va_list * va)
  85 {
  86   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
  87   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
  88   vlib_error_t *e = va_arg (*va, vlib_error_t *);
  89   vlib_node_t *error_node;
  90   vlib_error_main_t *em = &vm->error_main;
  91   u32 i;
  92
  93   error_node = vlib_get_node (vm, vlib_error_get_node (&vm->node_main, e[0]));
  94   i = counter_index (vm, vlib_error_get_code (&vm->node_main, e[0])) +
  95     error_node->error_heap_index;
  96   s = format (s, "%v: %s", error_node->name, em->counters_heap[i].name);
  97
  98   return s;
  99 }
 100
 101 static void
 102 trace_errors (vlib_main_t * vm,
 103               vlib_node_runtime_t * node, vlib_frame_t * frame)
 104 {
 105   u32 n_left, *buffers;
 106
 107   buffers = vlib_frame_vector_args (frame);
 108   n_left = frame->n_vectors;
 109
 110   while (n_left >= 4)
 111     {
 112       u32 bi0, bi1;
 113       vlib_buffer_t *b0, *b1;
 114       vlib_error_t *t0, *t1;
 115
 116       /* Prefetch next iteration. */
 117       vlib_prefetch_buffer_with_index (vm, buffers[2], LOAD);
 118       vlib_prefetch_buffer_with_index (vm, buffers[3], LOAD);
 119
 120       bi0 = buffers[0];
 121       bi1 = buffers[1];
 122
 123       b0 = vlib_get_buffer (vm, bi0);
 124       b1 = vlib_get_buffer (vm, bi1);
 125
 126       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 127         {
 128           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 129           t0[0] = b0->error;
 130         }
 131       if (b1->flags & VLIB_BUFFER_IS_TRACED)
 132         {
 133           t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
 134           t1[0] = b1->error;
 135         }
 136       buffers += 2;
 137       n_left -= 2;
 138     }
 139
 140   while (n_left >= 1)
 141     {
 142       u32 bi0;
 143       vlib_buffer_t *b0;
 144       vlib_error_t *t0;
 145
 146       bi0 = buffers[0];
 147
 148       b0 = vlib_get_buffer (vm, bi0);
 149
 150       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 151         {
 152           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 153           t0[0] = b0->error;
 154         }
 155       buffers += 1;
 156       n_left -= 1;
 157     }
 158 }
 159
 160 static_always_inline uword
 161 process_drop_punt (vlib_main_t * vm,
 162                    vlib_node_runtime_t * node,
 163                    vlib_frame_t * frame, error_disposition_t disposition)
 164 {
 165   u32 errors[VLIB_FRAME_SIZE], *error, *from, n_left;
 166   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
 167   vlib_error_main_t *em = &vm->error_main;
 168
 169   from = vlib_frame_vector_args (frame);
 170   n_left = frame->n_vectors;
 171   b = bufs;
 172   error = errors;
 173
 174   vlib_get_buffers (vm, from, bufs, n_left);
 175
 176   if (node->flags & VLIB_NODE_FLAG_TRACE)
 177     trace_errors (vm, node, frame);
 178
 179   /* collect the array of error first ... */
 180   while (n_left >= 4)
 181     {
 182       if (n_left >= 12)
 183         {
 184           /* Prefetch 8 ahead - there's not much going on in each iteration */
 185           vlib_prefetch_buffer_header (b[4], LOAD);
 186           vlib_prefetch_buffer_header (b[5], LOAD);
 187           vlib_prefetch_buffer_header (b[6], LOAD);
 188           vlib_prefetch_buffer_header (b[7], LOAD);
 189         }
 190       error[0] = b[0]->error;
 191       error[1] = b[1]->error;
 192       error[2] = b[2]->error;
 193       error[3] = b[3]->error;
 194
 195       error += 4;
 196       n_left -= 4;
 197       b += 4;
 198     }
 199   while (n_left)
 200     {
 201       error[0] = b[0]->error;
 202
 203       error += 1;
 204       n_left -= 1;
 205       b += 1;
 206     }
 207
 208   /* ... then count against them in blocks */
 209   n_left = frame->n_vectors;
 210
 211   while (n_left)
 212     {
 213       u16 off, count;
 214       u32 c_index;
 215
 216       off = frame->n_vectors - n_left;
 217
 218       error = errors + off;
 219
 220       count = clib_count_equal_u32 (error, n_left);
 221       n_left -= count;
 222
 223       c_index = counter_index (vm, error[0]);
 224       em->counters[c_index] += count;
 225
 226       vlib_error_elog_count (vm, c_index, count);
 227     }
 228
 229   if (disposition == ERROR_DISPOSITION_DROP || !vm->os_punt_frame)
 230     {
 231       vlib_buffer_free (vm, from, frame->n_vectors);
 232
 233       /* If there is no punt function, free the frame as well. */
 234       if (disposition == ERROR_DISPOSITION_PUNT && !vm->os_punt_frame)
 235         vlib_frame_free (vm, node, frame);
 236     }
 237   else
 238     vm->os_punt_frame (vm, node, frame);
 239
 240   return frame->n_vectors;
 241 }
 242
 243 VLIB_NODE_FN (error_drop_node) (vlib_main_t * vm,
 244                                 vlib_node_runtime_t * node,
 245                                 vlib_frame_t * frame)
 246 {
 247   return process_drop_punt (vm, node, frame, ERROR_DISPOSITION_DROP);
 248 }
 249
 250 VLIB_NODE_FN (error_punt_node) (vlib_main_t * vm,
 251                                 vlib_node_runtime_t * node,
 252                                 vlib_frame_t * frame)
 253 {
 254   return process_drop_punt (vm, node, frame, ERROR_DISPOSITION_PUNT);
 255 }
 256
 257 /* *INDENT-OFF* */
 258 VLIB_REGISTER_NODE (error_drop_node) = {
 259   .name = "drop",
 260   .flags = VLIB_NODE_FLAG_IS_DROP,
 261   .vector_size = sizeof (u32),
 262   .format_trace = format_error_trace,
 263   .validate_frame = validate_error_frame,
 264 };
 265 /* *INDENT-ON* */
 266
 267 /* *INDENT-OFF* */
 268 VLIB_REGISTER_NODE (error_punt_node) = {
 269   .name = "punt",
 270   .flags = (VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
 271             | VLIB_NODE_FLAG_IS_PUNT),
 272   .vector_size = sizeof (u32),
 273   .format_trace = format_error_trace,
 274   .validate_frame = validate_error_frame,
 275 };
 276 /* *INDENT-ON* */
 277
 278 /*
 279  * fd.io coding-style-patch-verification: ON
 280  *
 281  * Local Variables:
 282  * eval: (c-set-style "gnu")
 283  * End:
 284  */