src/vnet/interface_output.c

   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  * interface_output.c: interface output node
  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 <vnet/vnet.h>
  41 #include <vnet/feature/feature.h>
  42
  43 typedef struct
  44 {
  45   u32 sw_if_index;
  46   u8 data[128 - sizeof (u32)];
  47 }
  48 interface_output_trace_t;
  49
  50 u8 *
  51 format_vnet_interface_output_trace (u8 * s, va_list * va)
  52 {
  53   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
  54   vlib_node_t *node = va_arg (*va, vlib_node_t *);
  55   interface_output_trace_t *t = va_arg (*va, interface_output_trace_t *);
  56   vnet_main_t *vnm = vnet_get_main ();
  57   vnet_sw_interface_t *si;
  58   uword indent;
  59
  60   if (t->sw_if_index != (u32) ~ 0)
  61     {
  62       indent = format_get_indent (s);
  63
  64       if (pool_is_free_index
  65           (vnm->interface_main.sw_interfaces, t->sw_if_index))
  66         {
  67           /* the interface may have been deleted by the time the trace is printed */
  68           s = format (s, "sw_if_index: %d\n%U%U",
  69                       t->sw_if_index,
  70                       format_white_space, indent,
  71                       node->format_buffer ? node->
  72                       format_buffer : format_hex_bytes, t->data,
  73                       sizeof (t->data));
  74         }
  75       else
  76         {
  77           si = vnet_get_sw_interface (vnm, t->sw_if_index);
  78
  79           s = format (s, "%U\n%U%U",
  80                       format_vnet_sw_interface_name, vnm, si,
  81                       format_white_space, indent,
  82                       node->format_buffer ? node->
  83                       format_buffer : format_hex_bytes, t->data,
  84                       sizeof (t->data));
  85         }
  86     }
  87   return s;
  88 }
  89
  90 static void
  91 vnet_interface_output_trace (vlib_main_t * vm,
  92                              vlib_node_runtime_t * node,
  93                              vlib_frame_t * frame, uword n_buffers)
  94 {
  95   u32 n_left, *from;
  96
  97   n_left = n_buffers;
  98   from = vlib_frame_args (frame);
  99
 100   while (n_left >= 4)
 101     {
 102       u32 bi0, bi1;
 103       vlib_buffer_t *b0, *b1;
 104       interface_output_trace_t *t0, *t1;
 105
 106       /* Prefetch next iteration. */
 107       vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
 108       vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
 109
 110       bi0 = from[0];
 111       bi1 = from[1];
 112
 113       b0 = vlib_get_buffer (vm, bi0);
 114       b1 = vlib_get_buffer (vm, bi1);
 115
 116       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 117         {
 118           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 119           t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 120           clib_memcpy (t0->data, vlib_buffer_get_current (b0),
 121                        sizeof (t0->data));
 122         }
 123       if (b1->flags & VLIB_BUFFER_IS_TRACED)
 124         {
 125           t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
 126           t1->sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_TX];
 127           clib_memcpy (t1->data, vlib_buffer_get_current (b1),
 128                        sizeof (t1->data));
 129         }
 130       from += 2;
 131       n_left -= 2;
 132     }
 133
 134   while (n_left >= 1)
 135     {
 136       u32 bi0;
 137       vlib_buffer_t *b0;
 138       interface_output_trace_t *t0;
 139
 140       bi0 = from[0];
 141
 142       b0 = vlib_get_buffer (vm, bi0);
 143
 144       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 145         {
 146           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 147           t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 148           clib_memcpy (t0->data, vlib_buffer_get_current (b0),
 149                        sizeof (t0->data));
 150         }
 151       from += 1;
 152       n_left -= 1;
 153     }
 154 }
 155
 156 static never_inline u32
 157 slow_path (vlib_main_t * vm,
 158            u32 bi,
 159            vlib_buffer_t * b,
 160            u32 n_left_to_tx, u32 * to_tx, u32 * n_slow_bytes_result)
 161 {
 162   /* We've already enqueued a single buffer. */
 163   u32 n_buffers = 0;
 164   u32 n_slow_bytes = 0;
 165
 166   while (n_left_to_tx > 0)
 167     {
 168       to_tx[0] = bi;
 169       to_tx += 1;
 170       n_left_to_tx -= 1;
 171       n_buffers += 1;
 172       n_slow_bytes += vlib_buffer_length_in_chain (vm, b);
 173
 174       /* Be grumpy about zero length buffers for benefit of
 175          driver tx function. */
 176       ASSERT (b->current_length > 0);
 177
 178       if (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))
 179         break;
 180
 181       bi = b->next_buffer;
 182       b = vlib_get_buffer (vm, bi);
 183     }
 184
 185   /* Ran out of space in next frame trying to enqueue buffers? */
 186   if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 187     return 0;
 188
 189   *n_slow_bytes_result = n_slow_bytes;
 190   return n_buffers;
 191 }
 192
 193 /*
 194  * Increment TX stats. Roll up consecutive increments to the same sw_if_index
 195  * into one increment.
 196  */
 197 static_always_inline void
 198 incr_output_stats (vnet_main_t * vnm,
 199                    u32 thread_index,
 200                    u32 length,
 201                    u32 sw_if_index,
 202                    u32 * last_sw_if_index, u32 * n_packets, u32 * n_bytes)
 203 {
 204   vnet_interface_main_t *im;
 205
 206   if (PREDICT_TRUE (sw_if_index == *last_sw_if_index))
 207     {
 208       *n_packets += 1;
 209       *n_bytes += length;
 210     }
 211   else
 212     {
 213       if (PREDICT_TRUE (*last_sw_if_index != ~0))
 214         {
 215           im = &vnm->interface_main;
 216
 217           vlib_increment_combined_counter (im->combined_sw_if_counters
 218                                            + VNET_INTERFACE_COUNTER_TX,
 219                                            thread_index,
 220                                            *last_sw_if_index,
 221                                            *n_packets, *n_bytes);
 222         }
 223       *last_sw_if_index = sw_if_index;
 224       *n_packets = 1;
 225       *n_bytes = length;
 226     }
 227 }
 228
 229
 230 /* Interface output functions. */
 231 uword
 232 vnet_interface_output_node_flatten (vlib_main_t * vm,
 233                                     vlib_node_runtime_t * node,
 234                                     vlib_frame_t * frame)
 235 {
 236   vnet_main_t *vnm = vnet_get_main ();
 237   vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
 238   vnet_sw_interface_t *si;
 239   vnet_hw_interface_t *hi;
 240   u32 n_left_to_tx, *from, *from_end, *to_tx;
 241   u32 n_bytes, n_buffers, n_packets;
 242   u32 last_sw_if_index;
 243   u32 thread_index = vm->thread_index;
 244
 245   n_buffers = frame->n_vectors;
 246
 247   if (node->flags & VLIB_NODE_FLAG_TRACE)
 248     vnet_interface_output_trace (vm, node, frame, n_buffers);
 249
 250   from = vlib_frame_args (frame);
 251
 252   if (rt->is_deleted)
 253     return vlib_error_drop_buffers (vm, node, from,
 254                                     /* buffer stride */ 1,
 255                                     n_buffers,
 256                                     VNET_INTERFACE_OUTPUT_NEXT_DROP,
 257                                     node->node_index,
 258                                     VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DELETED);
 259
 260   si = vnet_get_sw_interface (vnm, rt->sw_if_index);
 261   hi = vnet_get_sup_hw_interface (vnm, rt->sw_if_index);
 262   if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ||
 263       !(hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
 264     {
 265       vlib_simple_counter_main_t *cm;
 266
 267       cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
 268                              VNET_INTERFACE_COUNTER_TX_ERROR);
 269       vlib_increment_simple_counter (cm, thread_index,
 270                                      rt->sw_if_index, n_buffers);
 271       return vlib_error_drop_buffers (vm, node, from,
 272                                       /* buffer stride */ 1,
 273                                       n_buffers,
 274                                       VNET_INTERFACE_OUTPUT_NEXT_DROP,
 275                                       node->node_index,
 276                                       VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DOWN);
 277     }
 278
 279   from_end = from + n_buffers;
 280
 281   /* Total byte count of all buffers. */
 282   n_bytes = 0;
 283   n_packets = 0;
 284   last_sw_if_index = ~0;
 285
 286   while (from < from_end)
 287     {
 288       /* Get new next frame since previous incomplete frame may have less
 289          than VNET_FRAME_SIZE vectors in it. */
 290       vlib_get_new_next_frame (vm, node, VNET_INTERFACE_OUTPUT_NEXT_TX,
 291                                to_tx, n_left_to_tx);
 292
 293       while (from + 4 <= from_end && n_left_to_tx >= 2)
 294         {
 295           u32 bi0, bi1;
 296           vlib_buffer_t *b0, *b1;
 297
 298           /* Prefetch next iteration. */
 299           vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
 300           vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
 301
 302           bi0 = from[0];
 303           bi1 = from[1];
 304           to_tx[0] = bi0;
 305           to_tx[1] = bi1;
 306           from += 2;
 307           to_tx += 2;
 308           n_left_to_tx -= 2;
 309
 310           b0 = vlib_get_buffer (vm, bi0);
 311           b1 = vlib_get_buffer (vm, bi1);
 312
 313           /* Be grumpy about zero length buffers for benefit of
 314              driver tx function. */
 315           ASSERT (b0->current_length > 0);
 316           ASSERT (b1->current_length > 0);
 317
 318           if (PREDICT_FALSE
 319               ((b0->flags | b1->flags) & VLIB_BUFFER_NEXT_PRESENT))
 320             {
 321               u32 n_buffers, n_slow_bytes, i;
 322
 323               /* Undo. */
 324               from -= 2;
 325               to_tx -= 2;
 326               n_left_to_tx += 2;
 327
 328               /* Do slow path two times. */
 329               for (i = 0; i < 2; i++)
 330                 {
 331                   u32 bi = i ? bi1 : bi0;
 332                   vlib_buffer_t *b = i ? b1 : b0;
 333
 334                   n_buffers = slow_path (vm, bi, b,
 335                                          n_left_to_tx, to_tx, &n_slow_bytes);
 336
 337                   /* Not enough room for single packet? */
 338                   if (n_buffers == 0)
 339                     goto put;
 340
 341                   from += 1;
 342                   to_tx += n_buffers;
 343                   n_left_to_tx -= n_buffers;
 344                   incr_output_stats (vnm, thread_index, n_slow_bytes,
 345                                      vnet_buffer (b)->sw_if_index[VLIB_TX],
 346                                      &last_sw_if_index, &n_packets, &n_bytes);
 347                 }
 348             }
 349           else
 350             {
 351               incr_output_stats (vnm, thread_index,
 352                                  vlib_buffer_length_in_chain (vm, b0),
 353                                  vnet_buffer (b0)->sw_if_index[VLIB_TX],
 354                                  &last_sw_if_index, &n_packets, &n_bytes);
 355               incr_output_stats (vnm, thread_index,
 356                                  vlib_buffer_length_in_chain (vm, b0),
 357                                  vnet_buffer (b1)->sw_if_index[VLIB_TX],
 358                                  &last_sw_if_index, &n_packets, &n_bytes);
 359             }
 360         }
 361
 362       while (from + 1 <= from_end && n_left_to_tx >= 1)
 363         {
 364           u32 bi0;
 365           vlib_buffer_t *b0;
 366
 367           bi0 = from[0];
 368           to_tx[0] = bi0;
 369           from += 1;
 370           to_tx += 1;
 371           n_left_to_tx -= 1;
 372
 373           b0 = vlib_get_buffer (vm, bi0);
 374
 375           /* Be grumpy about zero length buffers for benefit of
 376              driver tx function. */
 377           ASSERT (b0->current_length > 0);
 378
 379           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_NEXT_PRESENT))
 380             {
 381               u32 n_buffers, n_slow_bytes;
 382
 383               /* Undo. */
 384               from -= 1;
 385               to_tx -= 1;
 386               n_left_to_tx += 1;
 387
 388               n_buffers = slow_path (vm, bi0, b0,
 389                                      n_left_to_tx, to_tx, &n_slow_bytes);
 390
 391               /* Not enough room for single packet? */
 392               if (n_buffers == 0)
 393                 goto put;
 394
 395               from += 1;
 396               to_tx += n_buffers;
 397               n_left_to_tx -= n_buffers;
 398             }
 399           incr_output_stats (vnm, thread_index,
 400                              vlib_buffer_length_in_chain (vm, b0),
 401                              vnet_buffer (b0)->sw_if_index[VLIB_TX],
 402                              &last_sw_if_index, &n_packets, &n_bytes);
 403         }
 404
 405     put:
 406       vlib_put_next_frame (vm, node, VNET_INTERFACE_OUTPUT_NEXT_TX,
 407                            n_left_to_tx);
 408     }
 409
 410   /* Final update of interface stats. */
 411   incr_output_stats (vnm, thread_index, 0, ~0,  /* ~0 will flush stats */
 412                      &last_sw_if_index, &n_packets, &n_bytes);
 413
 414   return n_buffers;
 415 }
 416
 417 VLIB_NODE_FUNCTION_MULTIARCH_CLONE (vnet_interface_output_node_flatten);
 418 CLIB_MULTIARCH_SELECT_FN (vnet_interface_output_node_flatten);
 419
 420 uword
 421 vnet_interface_output_node (vlib_main_t * vm,
 422                             vlib_node_runtime_t * node, vlib_frame_t * frame)
 423 {
 424   vnet_main_t *vnm = vnet_get_main ();
 425   vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
 426   vnet_sw_interface_t *si;
 427   vnet_hw_interface_t *hi;
 428   u32 n_left_to_tx, *from, *from_end, *to_tx;
 429   u32 n_bytes, n_buffers, n_packets;
 430   u32 n_bytes_b0, n_bytes_b1, n_bytes_b2, n_bytes_b3;
 431   u32 thread_index = vm->thread_index;
 432   vnet_interface_main_t *im = &vnm->interface_main;
 433   u32 next_index = VNET_INTERFACE_OUTPUT_NEXT_TX;
 434   u32 current_config_index = ~0;
 435   u8 arc = im->output_feature_arc_index;
 436
 437   n_buffers = frame->n_vectors;
 438
 439   if (node->flags & VLIB_NODE_FLAG_TRACE)
 440     vnet_interface_output_trace (vm, node, frame, n_buffers);
 441
 442   from = vlib_frame_args (frame);
 443
 444   if (rt->is_deleted)
 445     return vlib_error_drop_buffers (vm, node, from,
 446                                     /* buffer stride */ 1,
 447                                     n_buffers,
 448                                     VNET_INTERFACE_OUTPUT_NEXT_DROP,
 449                                     node->node_index,
 450                                     VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DELETED);
 451
 452   si = vnet_get_sw_interface (vnm, rt->sw_if_index);
 453   hi = vnet_get_sup_hw_interface (vnm, rt->sw_if_index);
 454   if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ||
 455       !(hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
 456     {
 457       vlib_simple_counter_main_t *cm;
 458
 459       cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
 460                              VNET_INTERFACE_COUNTER_TX_ERROR);
 461       vlib_increment_simple_counter (cm, thread_index,
 462                                      rt->sw_if_index, n_buffers);
 463
 464       return vlib_error_drop_buffers (vm, node, from,
 465                                       /* buffer stride */ 1,
 466                                       n_buffers,
 467                                       VNET_INTERFACE_OUTPUT_NEXT_DROP,
 468                                       node->node_index,
 469                                       VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DOWN);
 470     }
 471
 472   from_end = from + n_buffers;
 473
 474   /* Total byte count of all buffers. */
 475   n_bytes = 0;
 476   n_packets = 0;
 477
 478   /* interface-output feature arc handling */
 479   if (PREDICT_FALSE (vnet_have_features (arc, rt->sw_if_index)))
 480     {
 481       vnet_feature_config_main_t *fcm;
 482       fcm = vnet_feature_get_config_main (arc);
 483       current_config_index = vnet_get_feature_config_index (arc,
 484                                                             rt->sw_if_index);
 485       vnet_get_config_data (&fcm->config_main, &current_config_index,
 486                             &next_index, 0);
 487     }
 488
 489   while (from < from_end)
 490     {
 491       /* Get new next frame since previous incomplete frame may have less
 492          than VNET_FRAME_SIZE vectors in it. */
 493       vlib_get_new_next_frame (vm, node, next_index, to_tx, n_left_to_tx);
 494
 495       while (from + 8 <= from_end && n_left_to_tx >= 4)
 496         {
 497           u32 bi0, bi1, bi2, bi3;
 498           vlib_buffer_t *b0, *b1, *b2, *b3;
 499           u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
 500
 501           /* Prefetch next iteration. */
 502           vlib_prefetch_buffer_with_index (vm, from[4], LOAD);
 503           vlib_prefetch_buffer_with_index (vm, from[5], LOAD);
 504           vlib_prefetch_buffer_with_index (vm, from[6], LOAD);
 505           vlib_prefetch_buffer_with_index (vm, from[7], LOAD);
 506
 507           bi0 = from[0];
 508           bi1 = from[1];
 509           bi2 = from[2];
 510           bi3 = from[3];
 511           to_tx[0] = bi0;
 512           to_tx[1] = bi1;
 513           to_tx[2] = bi2;
 514           to_tx[3] = bi3;
 515           from += 4;
 516           to_tx += 4;
 517           n_left_to_tx -= 4;
 518
 519           b0 = vlib_get_buffer (vm, bi0);
 520           b1 = vlib_get_buffer (vm, bi1);
 521           b2 = vlib_get_buffer (vm, bi2);
 522           b3 = vlib_get_buffer (vm, bi3);
 523
 524           /* Be grumpy about zero length buffers for benefit of
 525              driver tx function. */
 526           ASSERT (b0->current_length > 0);
 527           ASSERT (b1->current_length > 0);
 528           ASSERT (b2->current_length > 0);
 529           ASSERT (b3->current_length > 0);
 530
 531           n_bytes_b0 = vlib_buffer_length_in_chain (vm, b0);
 532           n_bytes_b1 = vlib_buffer_length_in_chain (vm, b1);
 533           n_bytes_b2 = vlib_buffer_length_in_chain (vm, b2);
 534           n_bytes_b3 = vlib_buffer_length_in_chain (vm, b3);
 535           tx_swif0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 536           tx_swif1 = vnet_buffer (b1)->sw_if_index[VLIB_TX];
 537           tx_swif2 = vnet_buffer (b2)->sw_if_index[VLIB_TX];
 538           tx_swif3 = vnet_buffer (b3)->sw_if_index[VLIB_TX];
 539
 540           n_bytes += n_bytes_b0 + n_bytes_b1;
 541           n_bytes += n_bytes_b2 + n_bytes_b3;
 542           n_packets += 4;
 543
 544           if (PREDICT_FALSE (current_config_index != ~0))
 545             {
 546               b0->feature_arc_index = arc;
 547               b1->feature_arc_index = arc;
 548               b2->feature_arc_index = arc;
 549               b3->feature_arc_index = arc;
 550               b0->current_config_index = current_config_index;
 551               b1->current_config_index = current_config_index;
 552               b2->current_config_index = current_config_index;
 553               b3->current_config_index = current_config_index;
 554             }
 555
 556           /* update vlan subif tx counts, if required */
 557           if (PREDICT_FALSE (tx_swif0 != rt->sw_if_index))
 558             {
 559               vlib_increment_combined_counter (im->combined_sw_if_counters +
 560                                                VNET_INTERFACE_COUNTER_TX,
 561                                                thread_index, tx_swif0, 1,
 562                                                n_bytes_b0);
 563             }
 564
 565           if (PREDICT_FALSE (tx_swif1 != rt->sw_if_index))
 566             {
 567
 568               vlib_increment_combined_counter (im->combined_sw_if_counters +
 569                                                VNET_INTERFACE_COUNTER_TX,
 570                                                thread_index, tx_swif1, 1,
 571                                                n_bytes_b1);
 572             }
 573
 574           if (PREDICT_FALSE (tx_swif2 != rt->sw_if_index))
 575             {
 576
 577               vlib_increment_combined_counter (im->combined_sw_if_counters +
 578                                                VNET_INTERFACE_COUNTER_TX,
 579                                                thread_index, tx_swif2, 1,
 580                                                n_bytes_b2);
 581             }
 582           if (PREDICT_FALSE (tx_swif3 != rt->sw_if_index))
 583             {
 584
 585               vlib_increment_combined_counter (im->combined_sw_if_counters +
 586                                                VNET_INTERFACE_COUNTER_TX,
 587                                                thread_index, tx_swif3, 1,
 588                                                n_bytes_b3);
 589             }
 590         }
 591
 592       while (from + 1 <= from_end && n_left_to_tx >= 1)
 593         {
 594           u32 bi0;
 595           vlib_buffer_t *b0;
 596           u32 tx_swif0;
 597
 598           bi0 = from[0];
 599           to_tx[0] = bi0;
 600           from += 1;
 601           to_tx += 1;
 602           n_left_to_tx -= 1;
 603
 604           b0 = vlib_get_buffer (vm, bi0);
 605
 606           /* Be grumpy about zero length buffers for benefit of
 607              driver tx function. */
 608           ASSERT (b0->current_length > 0);
 609
 610           n_bytes_b0 = vlib_buffer_length_in_chain (vm, b0);
 611           tx_swif0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 612           n_bytes += n_bytes_b0;
 613           n_packets += 1;
 614
 615           if (PREDICT_FALSE (current_config_index != ~0))
 616             {
 617               b0->feature_arc_index = arc;
 618               b0->current_config_index = current_config_index;
 619             }
 620
 621           if (PREDICT_FALSE (tx_swif0 != rt->sw_if_index))
 622             {
 623
 624               vlib_increment_combined_counter (im->combined_sw_if_counters +
 625                                                VNET_INTERFACE_COUNTER_TX,
 626                                                thread_index, tx_swif0, 1,
 627                                                n_bytes_b0);
 628             }
 629         }
 630
 631       vlib_put_next_frame (vm, node, next_index, n_left_to_tx);
 632     }
 633
 634   /* Update main interface stats. */
 635   vlib_increment_combined_counter (im->combined_sw_if_counters
 636                                    + VNET_INTERFACE_COUNTER_TX,
 637                                    thread_index,
 638                                    rt->sw_if_index, n_packets, n_bytes);
 639   return n_buffers;
 640 }
 641
 642 VLIB_NODE_FUNCTION_MULTIARCH_CLONE (vnet_interface_output_node);
 643 CLIB_MULTIARCH_SELECT_FN (vnet_interface_output_node);
 644
 645 /* Use buffer's sw_if_index[VNET_TX] to choose output interface. */
 646 static uword
 647 vnet_per_buffer_interface_output (vlib_main_t * vm,
 648                                   vlib_node_runtime_t * node,
 649                                   vlib_frame_t * frame)
 650 {
 651   vnet_main_t *vnm = vnet_get_main ();
 652   u32 n_left_to_next, *from, *to_next;
 653   u32 n_left_from, next_index;
 654
 655   n_left_from = frame->n_vectors;
 656
 657   from = vlib_frame_args (frame);
 658   next_index = node->cached_next_index;
 659
 660   while (n_left_from > 0)
 661     {
 662       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 663
 664       while (n_left_from >= 4 && n_left_to_next >= 2)
 665         {
 666           u32 bi0, bi1, next0, next1;
 667           vlib_buffer_t *b0, *b1;
 668           vnet_hw_interface_t *hi0, *hi1;
 669
 670           /* Prefetch next iteration. */
 671           vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
 672           vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
 673
 674           bi0 = from[0];
 675           bi1 = from[1];
 676           to_next[0] = bi0;
 677           to_next[1] = bi1;
 678           from += 2;
 679           to_next += 2;
 680           n_left_to_next -= 2;
 681           n_left_from -= 2;
 682
 683           b0 = vlib_get_buffer (vm, bi0);
 684           b1 = vlib_get_buffer (vm, bi1);
 685
 686           hi0 =
 687             vnet_get_sup_hw_interface (vnm,
 688                                        vnet_buffer (b0)->sw_if_index
 689                                        [VLIB_TX]);
 690           hi1 =
 691             vnet_get_sup_hw_interface (vnm,
 692                                        vnet_buffer (b1)->sw_if_index
 693                                        [VLIB_TX]);
 694
 695           next0 = hi0->hw_if_index;
 696           next1 = hi1->hw_if_index;
 697
 698           vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
 699                                            n_left_to_next, bi0, bi1, next0,
 700                                            next1);
 701         }
 702
 703       while (n_left_from > 0 && n_left_to_next > 0)
 704         {
 705           u32 bi0, next0;
 706           vlib_buffer_t *b0;
 707           vnet_hw_interface_t *hi0;
 708
 709           bi0 = from[0];
 710           to_next[0] = bi0;
 711           from += 1;
 712           to_next += 1;
 713           n_left_to_next -= 1;
 714           n_left_from -= 1;
 715
 716           b0 = vlib_get_buffer (vm, bi0);
 717
 718           hi0 =
 719             vnet_get_sup_hw_interface (vnm,
 720                                        vnet_buffer (b0)->sw_if_index
 721                                        [VLIB_TX]);
 722
 723           next0 = hi0->hw_if_index;
 724
 725           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 726                                            n_left_to_next, bi0, next0);
 727         }
 728
 729       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 730     }
 731
 732   return frame->n_vectors;
 733 }
 734
 735 always_inline u32
 736 counter_index (vlib_main_t * vm, vlib_error_t e)
 737 {
 738   vlib_node_t *n;
 739   u32 ci, ni;
 740
 741   ni = vlib_error_get_node (e);
 742   n = vlib_get_node (vm, ni);
 743
 744   ci = vlib_error_get_code (e);
 745   ASSERT (ci < n->n_errors);
 746
 747   ci += n->error_heap_index;
 748
 749   return ci;
 750 }
 751
 752 static u8 *
 753 format_vnet_error_trace (u8 * s, va_list * va)
 754 {
 755   vlib_main_t *vm = va_arg (*va, vlib_main_t *);
 756   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 757   vlib_error_t *e = va_arg (*va, vlib_error_t *);
 758   vlib_node_t *error_node;
 759   vlib_error_main_t *em = &vm->error_main;
 760   u32 i;
 761
 762   error_node = vlib_get_node (vm, vlib_error_get_node (e[0]));
 763   i = counter_index (vm, e[0]);
 764   s = format (s, "%v: %s", error_node->name, em->error_strings_heap[i]);
 765
 766   return s;
 767 }
 768
 769 static void
 770 trace_errors_with_buffers (vlib_main_t * vm,
 771                            vlib_node_runtime_t * node, vlib_frame_t * frame)
 772 {
 773   u32 n_left, *buffers;
 774
 775   buffers = vlib_frame_vector_args (frame);
 776   n_left = frame->n_vectors;
 777
 778   while (n_left >= 4)
 779     {
 780       u32 bi0, bi1;
 781       vlib_buffer_t *b0, *b1;
 782       vlib_error_t *t0, *t1;
 783
 784       /* Prefetch next iteration. */
 785       vlib_prefetch_buffer_with_index (vm, buffers[2], LOAD);
 786       vlib_prefetch_buffer_with_index (vm, buffers[3], LOAD);
 787
 788       bi0 = buffers[0];
 789       bi1 = buffers[1];
 790
 791       b0 = vlib_get_buffer (vm, bi0);
 792       b1 = vlib_get_buffer (vm, bi1);
 793
 794       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 795         {
 796           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 797           t0[0] = b0->error;
 798         }
 799       if (b1->flags & VLIB_BUFFER_IS_TRACED)
 800         {
 801           t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
 802           t1[0] = b1->error;
 803         }
 804       buffers += 2;
 805       n_left -= 2;
 806     }
 807
 808   while (n_left >= 1)
 809     {
 810       u32 bi0;
 811       vlib_buffer_t *b0;
 812       vlib_error_t *t0;
 813
 814       bi0 = buffers[0];
 815
 816       b0 = vlib_get_buffer (vm, bi0);
 817
 818       if (b0->flags & VLIB_BUFFER_IS_TRACED)
 819         {
 820           t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
 821           t0[0] = b0->error;
 822         }
 823       buffers += 1;
 824       n_left -= 1;
 825     }
 826 }
 827
 828 static u8 *
 829 validate_error (vlib_main_t * vm, vlib_error_t * e, u32 index)
 830 {
 831   uword node_index = vlib_error_get_node (e[0]);
 832   uword code = vlib_error_get_code (e[0]);
 833   vlib_node_t *n;
 834
 835   if (node_index >= vec_len (vm->node_main.nodes))
 836     return format (0, "[%d], node index out of range 0x%x, error 0x%x",
 837                    index, node_index, e[0]);
 838
 839   n = vlib_get_node (vm, node_index);
 840   if (code >= n->n_errors)
 841     return format (0, "[%d], code %d out of range for node %v",
 842                    index, code, n->name);
 843
 844   return 0;
 845 }
 846
 847 static u8 *
 848 validate_error_frame (vlib_main_t * vm,
 849                       vlib_node_runtime_t * node, vlib_frame_t * f)
 850 {
 851   u32 *buffers = vlib_frame_args (f);
 852   vlib_buffer_t *b;
 853   u8 *msg = 0;
 854   uword i;
 855
 856   for (i = 0; i < f->n_vectors; i++)
 857     {
 858       b = vlib_get_buffer (vm, buffers[i]);
 859       msg = validate_error (vm, &b->error, i);
 860       if (msg)
 861         return msg;
 862     }
 863
 864   return msg;
 865 }
 866
 867 typedef enum
 868 {
 869   VNET_ERROR_DISPOSITION_DROP,
 870   VNET_ERROR_DISPOSITION_PUNT,
 871   VNET_ERROR_N_DISPOSITION,
 872 } vnet_error_disposition_t;
 873
 874 always_inline void
 875 do_packet (vlib_main_t * vm, vlib_error_t a)
 876 {
 877   vlib_error_main_t *em = &vm->error_main;
 878   u32 i = counter_index (vm, a);
 879   em->counters[i] += 1;
 880   vlib_error_elog_count (vm, i, 1);
 881 }
 882
 883 static_always_inline uword
 884 process_drop_punt (vlib_main_t * vm,
 885                    vlib_node_runtime_t * node,
 886                    vlib_frame_t * frame, vnet_error_disposition_t disposition)
 887 {
 888   vnet_main_t *vnm = vnet_get_main ();
 889   vlib_error_main_t *em = &vm->error_main;
 890   u32 *buffers, *first_buffer;
 891   vlib_error_t current_error;
 892   u32 current_counter_index, n_errors_left;
 893   u32 current_sw_if_index, n_errors_current_sw_if_index;
 894   u64 current_counter;
 895   vlib_simple_counter_main_t *cm;
 896   u32 thread_index = vm->thread_index;
 897
 898   static vlib_error_t memory[VNET_ERROR_N_DISPOSITION];
 899   static char memory_init[VNET_ERROR_N_DISPOSITION];
 900
 901   buffers = vlib_frame_args (frame);
 902   first_buffer = buffers;
 903
 904   {
 905     vlib_buffer_t *b = vlib_get_buffer (vm, first_buffer[0]);
 906
 907     if (!memory_init[disposition])
 908       {
 909         memory_init[disposition] = 1;
 910         memory[disposition] = b->error;
 911       }
 912
 913     current_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
 914     n_errors_current_sw_if_index = 0;
 915   }
 916
 917   current_error = memory[disposition];
 918   current_counter_index = counter_index (vm, memory[disposition]);
 919   current_counter = em->counters[current_counter_index];
 920
 921   if (node->flags & VLIB_NODE_FLAG_TRACE)
 922     trace_errors_with_buffers (vm, node, frame);
 923
 924   n_errors_left = frame->n_vectors;
 925   cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
 926                          (disposition == VNET_ERROR_DISPOSITION_PUNT
 927                           ? VNET_INTERFACE_COUNTER_PUNT
 928                           : VNET_INTERFACE_COUNTER_DROP));
 929
 930   while (n_errors_left >= 2)
 931     {
 932       vlib_buffer_t *b0, *b1;
 933       vnet_sw_interface_t *sw_if0, *sw_if1;
 934       vlib_error_t e0, e1;
 935       u32 bi0, bi1;
 936       u32 sw_if_index0, sw_if_index1;
 937
 938       bi0 = buffers[0];
 939       bi1 = buffers[1];
 940
 941       buffers += 2;
 942       n_errors_left -= 2;
 943
 944       b0 = vlib_get_buffer (vm, bi0);
 945       b1 = vlib_get_buffer (vm, bi1);
 946
 947       e0 = b0->error;
 948       e1 = b1->error;
 949
 950       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 951       sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
 952
 953       /* Speculate that sw_if_index == sw_if_index[01]. */
 954       n_errors_current_sw_if_index += 2;
 955
 956       /* Speculatively assume all 2 (node, code) pairs are equal
 957          to current (node, code). */
 958       current_counter += 2;
 959
 960       if (PREDICT_FALSE (e0 != current_error
 961                          || e1 != current_error
 962                          || sw_if_index0 != current_sw_if_index
 963                          || sw_if_index1 != current_sw_if_index))
 964         {
 965           current_counter -= 2;
 966           n_errors_current_sw_if_index -= 2;
 967
 968           vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
 969           vlib_increment_simple_counter (cm, thread_index, sw_if_index1, 1);
 970
 971           /* Increment super-interface drop/punt counters for
 972              sub-interfaces. */
 973           sw_if0 = vnet_get_sw_interface (vnm, sw_if_index0);
 974           vlib_increment_simple_counter
 975             (cm, thread_index, sw_if0->sup_sw_if_index,
 976              sw_if0->sup_sw_if_index != sw_if_index0);
 977
 978           sw_if1 = vnet_get_sw_interface (vnm, sw_if_index1);
 979           vlib_increment_simple_counter
 980             (cm, thread_index, sw_if1->sup_sw_if_index,
 981              sw_if1->sup_sw_if_index != sw_if_index1);
 982
 983           em->counters[current_counter_index] = current_counter;
 984           do_packet (vm, e0);
 985           do_packet (vm, e1);
 986
 987           /* For 2 repeated errors, change current error. */
 988           if (e0 == e1 && e1 != current_error)
 989             {
 990               current_error = e0;
 991               current_counter_index = counter_index (vm, e0);
 992             }
 993           current_counter = em->counters[current_counter_index];
 994         }
 995     }
 996
 997   while (n_errors_left >= 1)
 998     {
 999       vlib_buffer_t *b0;
1000       vnet_sw_interface_t *sw_if0;
1001       vlib_error_t e0;
1002       u32 bi0, sw_if_index0;
1003
1004       bi0 = buffers[0];
1005
1006       buffers += 1;
1007       n_errors_left -= 1;
1008       current_counter += 1;
1009
1010       b0 = vlib_get_buffer (vm, bi0);
1011       e0 = b0->error;
1012
1013       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
1014
1015       /* Increment drop/punt counters. */
1016       vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
1017
1018       /* Increment super-interface drop/punt counters for sub-interfaces. */
1019       sw_if0 = vnet_get_sw_interface (vnm, sw_if_index0);
1020       vlib_increment_simple_counter (cm, thread_index,
1021                                      sw_if0->sup_sw_if_index,
1022                                      sw_if0->sup_sw_if_index != sw_if_index0);
1023
1024       if (PREDICT_FALSE (e0 != current_error))
1025         {
1026           current_counter -= 1;
1027
1028           vlib_error_elog_count (vm, current_counter_index,
1029                                  (current_counter
1030                                   - em->counters[current_counter_index]));
1031
1032           em->counters[current_counter_index] = current_counter;
1033
1034           do_packet (vm, e0);
1035           current_error = e0;
1036           current_counter_index = counter_index (vm, e0);
1037           current_counter = em->counters[current_counter_index];
1038         }
1039     }
1040
1041   if (n_errors_current_sw_if_index > 0)
1042     {
1043       vnet_sw_interface_t *si;
1044
1045       vlib_increment_simple_counter (cm, thread_index, current_sw_if_index,
1046                                      n_errors_current_sw_if_index);
1047
1048       si = vnet_get_sw_interface (vnm, current_sw_if_index);
1049       if (si->sup_sw_if_index != current_sw_if_index)
1050         vlib_increment_simple_counter (cm, thread_index, si->sup_sw_if_index,
1051                                        n_errors_current_sw_if_index);
1052     }
1053
1054   vlib_error_elog_count (vm, current_counter_index,
1055                          (current_counter
1056                           - em->counters[current_counter_index]));
1057
1058   /* Return cached counter. */
1059   em->counters[current_counter_index] = current_counter;
1060
1061   /* Save memory for next iteration. */
1062   memory[disposition] = current_error;
1063
1064   if (disposition == VNET_ERROR_DISPOSITION_DROP || !vm->os_punt_frame)
1065     {
1066       vlib_buffer_free (vm, first_buffer, frame->n_vectors);
1067
1068       /* If there is no punt function, free the frame as well. */
1069       if (disposition == VNET_ERROR_DISPOSITION_PUNT && !vm->os_punt_frame)
1070         vlib_frame_free (vm, node, frame);
1071     }
1072   else
1073     vm->os_punt_frame (vm, node, frame);
1074
1075   return frame->n_vectors;
1076 }
1077
1078 static inline void
1079 pcap_drop_trace (vlib_main_t * vm,
1080                  vnet_interface_main_t * im, vlib_frame_t * f)
1081 {
1082   u32 *from;
1083   u32 n_left = f->n_vectors;
1084   vlib_buffer_t *b0, *p1;
1085   u32 bi0;
1086   i16 save_current_data;
1087   u16 save_current_length;
1088
1089   from = vlib_frame_vector_args (f);
1090
1091   while (n_left > 0)
1092     {
1093       if (PREDICT_TRUE (n_left > 1))
1094         {
1095           p1 = vlib_get_buffer (vm, from[1]);
1096           vlib_prefetch_buffer_header (p1, LOAD);
1097         }
1098
1099       bi0 = from[0];
1100       b0 = vlib_get_buffer (vm, bi0);
1101       from++;
1102       n_left--;
1103
1104       /* See if we're pointedly ignoring this specific error */
1105       if (im->pcap_drop_filter_hash
1106           && hash_get (im->pcap_drop_filter_hash, b0->error))
1107         continue;
1108
1109       /* Trace all drops, or drops received on a specific interface */
1110       if (im->pcap_sw_if_index == 0 ||
1111           im->pcap_sw_if_index == vnet_buffer (b0)->sw_if_index[VLIB_RX])
1112         {
1113           save_current_data = b0->current_data;
1114           save_current_length = b0->current_length;
1115
1116           /*
1117            * Typically, we'll need to rewind the buffer
1118            */
1119           if (b0->current_data > 0)
1120             vlib_buffer_advance (b0, (word) - b0->current_data);
1121
1122           pcap_add_buffer (&im->pcap_main, vm, bi0, 512);
1123
1124           b0->current_data = save_current_data;
1125           b0->current_length = save_current_length;
1126         }
1127     }
1128 }
1129
1130 void
1131 vnet_pcap_drop_trace_filter_add_del (u32 error_index, int is_add)
1132 {
1133   vnet_interface_main_t *im = &vnet_get_main ()->interface_main;
1134
1135   if (im->pcap_drop_filter_hash == 0)
1136     im->pcap_drop_filter_hash = hash_create (0, sizeof (uword));
1137
1138   if (is_add)
1139     hash_set (im->pcap_drop_filter_hash, error_index, 1);
1140   else
1141     hash_unset (im->pcap_drop_filter_hash, error_index);
1142 }
1143
1144 static uword
1145 process_drop (vlib_main_t * vm,
1146               vlib_node_runtime_t * node, vlib_frame_t * frame)
1147 {
1148   vnet_interface_main_t *im = &vnet_get_main ()->interface_main;
1149
1150   if (PREDICT_FALSE (im->drop_pcap_enable))
1151     pcap_drop_trace (vm, im, frame);
1152
1153   return process_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_DROP);
1154 }
1155
1156 static uword
1157 process_punt (vlib_main_t * vm,
1158               vlib_node_runtime_t * node, vlib_frame_t * frame)
1159 {
1160   return process_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_PUNT);
1161 }
1162
1163 /* *INDENT-OFF* */
1164 VLIB_REGISTER_NODE (drop_buffers,static) = {
1165   .function = process_drop,
1166   .name = "error-drop",
1167   .flags = VLIB_NODE_FLAG_IS_DROP,
1168   .vector_size = sizeof (u32),
1169   .format_trace = format_vnet_error_trace,
1170   .validate_frame = validate_error_frame,
1171 };
1172 /* *INDENT-ON* */
1173
1174 VLIB_NODE_FUNCTION_MULTIARCH (drop_buffers, process_drop);
1175
1176 /* *INDENT-OFF* */
1177 VLIB_REGISTER_NODE (punt_buffers,static) = {
1178   .function = process_punt,
1179   .flags = (VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
1180             | VLIB_NODE_FLAG_IS_PUNT),
1181   .name = "error-punt",
1182   .vector_size = sizeof (u32),
1183   .format_trace = format_vnet_error_trace,
1184   .validate_frame = validate_error_frame,
1185 };
1186 /* *INDENT-ON* */
1187
1188 VLIB_NODE_FUNCTION_MULTIARCH (punt_buffers, process_punt);
1189
1190 /* *INDENT-OFF* */
1191 VLIB_REGISTER_NODE (vnet_per_buffer_interface_output_node,static) = {
1192   .function = vnet_per_buffer_interface_output,
1193   .name = "interface-output",
1194   .vector_size = sizeof (u32),
1195 };
1196 /* *INDENT-ON* */
1197
1198 VLIB_NODE_FUNCTION_MULTIARCH (vnet_per_buffer_interface_output_node,
1199                               vnet_per_buffer_interface_output);
1200
1201 static uword
1202 interface_tx_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
1203                       vlib_frame_t * from_frame)
1204 {
1205   vnet_main_t *vnm = vnet_get_main ();
1206   u32 last_sw_if_index = ~0;
1207   vlib_frame_t *to_frame = 0;
1208   vnet_hw_interface_t *hw = 0;
1209   u32 *from, *to_next = 0;
1210   u32 n_left_from;
1211
1212   from = vlib_frame_vector_args (from_frame);
1213   n_left_from = from_frame->n_vectors;
1214   while (n_left_from > 0)
1215     {
1216       u32 bi0;
1217       vlib_buffer_t *b0;
1218       u32 sw_if_index0;
1219
1220       bi0 = from[0];
1221       from++;
1222       n_left_from--;
1223       b0 = vlib_get_buffer (vm, bi0);
1224       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
1225
1226       if (PREDICT_FALSE ((last_sw_if_index != sw_if_index0) || to_frame == 0))
1227         {
1228           if (to_frame)
1229             {
1230               hw = vnet_get_sup_hw_interface (vnm, last_sw_if_index);
1231               vlib_put_frame_to_node (vm, hw->tx_node_index, to_frame);
1232             }
1233           last_sw_if_index = sw_if_index0;
1234           hw = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1235           to_frame = vlib_get_frame_to_node (vm, hw->tx_node_index);
1236           to_next = vlib_frame_vector_args (to_frame);
1237         }
1238
1239       to_next[0] = bi0;
1240       to_next++;
1241       to_frame->n_vectors++;
1242     }
1243   vlib_put_frame_to_node (vm, hw->tx_node_index, to_frame);
1244   return from_frame->n_vectors;
1245 }
1246
1247 /* *INDENT-OFF* */
1248 VLIB_REGISTER_NODE (interface_tx, static) = {
1249   .function = interface_tx_node_fn,
1250   .name = "interface-tx",
1251   .vector_size = sizeof (u32),
1252   .n_next_nodes = 1,
1253   .next_nodes = {
1254     [0] = "error-drop",
1255   },
1256 };
1257
1258 VNET_FEATURE_ARC_INIT (interface_output, static) =
1259 {
1260   .arc_name  = "interface-output",
1261   .start_nodes = VNET_FEATURES (0),
1262   .arc_index_ptr = &vnet_main.interface_main.output_feature_arc_index,
1263 };
1264
1265 VNET_FEATURE_INIT (span_tx, static) = {
1266   .arc_name = "interface-output",
1267   .node_name = "span-output",
1268   .runs_before = VNET_FEATURES ("interface-tx"),
1269 };
1270
1271 VNET_FEATURE_INIT (interface_tx, static) = {
1272   .arc_name = "interface-output",
1273   .node_name = "interface-tx",
1274   .runs_before = 0,
1275 };
1276 /* *INDENT-ON* */
1277
1278 clib_error_t *
1279 vnet_per_buffer_interface_output_hw_interface_add_del (vnet_main_t * vnm,
1280                                                        u32 hw_if_index,
1281                                                        u32 is_create)
1282 {
1283   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1284   u32 next_index;
1285
1286   next_index = vlib_node_add_next_with_slot
1287     (vnm->vlib_main, vnet_per_buffer_interface_output_node.index,
1288      hi->output_node_index,
1289      /* next_index */ hw_if_index);
1290
1291   ASSERT (next_index == hw_if_index);
1292
1293   return 0;
1294 }
1295
1296 VNET_HW_INTERFACE_ADD_DEL_FUNCTION
1297   (vnet_per_buffer_interface_output_hw_interface_add_del);
1298
1299 static clib_error_t *
1300 pcap_drop_trace_command_fn (vlib_main_t * vm,
1301                             unformat_input_t * input,
1302                             vlib_cli_command_t * cmd)
1303 {
1304   vnet_main_t *vnm = vnet_get_main ();
1305   vnet_interface_main_t *im = &vnm->interface_main;
1306   u8 *filename;
1307   u32 max;
1308   int matched = 0;
1309   clib_error_t *error = 0;
1310
1311   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1312     {
1313       if (unformat (input, "on"))
1314         {
1315           if (im->drop_pcap_enable == 0)
1316             {
1317               if (im->pcap_filename == 0)
1318                 im->pcap_filename = format (0, "/tmp/drop.pcap%c", 0);
1319
1320               memset (&im->pcap_main, 0, sizeof (im->pcap_main));
1321               im->pcap_main.file_name = (char *) im->pcap_filename;
1322               im->pcap_main.n_packets_to_capture = 100;
1323               if (im->pcap_pkts_to_capture)
1324                 im->pcap_main.n_packets_to_capture = im->pcap_pkts_to_capture;
1325
1326               im->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
1327               im->drop_pcap_enable = 1;
1328               matched = 1;
1329               vlib_cli_output (vm, "pcap drop capture on...");
1330             }
1331           else
1332             {
1333               vlib_cli_output (vm, "pcap drop capture already on...");
1334             }
1335           matched = 1;
1336         }
1337       else if (unformat (input, "off"))
1338         {
1339           matched = 1;
1340
1341           if (im->drop_pcap_enable)
1342             {
1343               vlib_cli_output (vm, "captured %d pkts...",
1344                                im->pcap_main.n_packets_captured);
1345               if (im->pcap_main.n_packets_captured)
1346                 {
1347                   im->pcap_main.n_packets_to_capture =
1348                     im->pcap_main.n_packets_captured;
1349                   error = pcap_write (&im->pcap_main);
1350                   if (error)
1351                     clib_error_report (error);
1352                   else
1353                     vlib_cli_output (vm, "saved to %s...", im->pcap_filename);
1354                 }
1355             }
1356           else
1357             {
1358               vlib_cli_output (vm, "pcap drop capture already off...");
1359             }
1360
1361           im->drop_pcap_enable = 0;
1362         }
1363       else if (unformat (input, "max %d", &max))
1364         {
1365           im->pcap_pkts_to_capture = max;
1366           matched = 1;
1367         }
1368
1369       else if (unformat (input, "intfc %U",
1370                          unformat_vnet_sw_interface, vnm,
1371                          &im->pcap_sw_if_index))
1372         matched = 1;
1373       else if (unformat (input, "intfc any"))
1374         {
1375           im->pcap_sw_if_index = 0;
1376           matched = 1;
1377         }
1378       else if (unformat (input, "file %s", &filename))
1379         {
1380           u8 *chroot_filename;
1381           /* Brain-police user path input */
1382           if (strstr ((char *) filename, "..")
1383               || index ((char *) filename, '/'))
1384             {
1385               vlib_cli_output (vm, "illegal characters in filename '%s'",
1386                                filename);
1387               continue;
1388             }
1389
1390           chroot_filename = format (0, "/tmp/%s%c", filename, 0);
1391           vec_free (filename);
1392
1393           if (im->pcap_filename)
1394             vec_free (im->pcap_filename);
1395           vec_add1 (filename, 0);
1396           im->pcap_filename = chroot_filename;
1397           matched = 1;
1398         }
1399       else if (unformat (input, "status"))
1400         {
1401           if (im->drop_pcap_enable == 0)
1402             {
1403               vlib_cli_output (vm, "pcap drop capture is off...");
1404               continue;
1405             }
1406
1407           vlib_cli_output (vm, "pcap drop capture: %d of %d pkts...",
1408                            im->pcap_main.n_packets_captured,
1409                            im->pcap_main.n_packets_to_capture);
1410           matched = 1;
1411         }
1412
1413       else
1414         break;
1415     }
1416
1417   if (matched == 0)
1418     return clib_error_return (0, "unknown input `%U'",
1419                               format_unformat_error, input);
1420
1421   return 0;
1422 }
1423
1424 /* *INDENT-OFF* */
1425 VLIB_CLI_COMMAND (pcap_trace_command, static) = {
1426   .path = "pcap drop trace",
1427   .short_help =
1428   "pcap drop trace on off max <nn> intfc <intfc> file <name> status",
1429   .function = pcap_drop_trace_command_fn,
1430 };
1431 /* *INDENT-ON* */
1432
1433 /*
1434  * fd.io coding-style-patch-verification: ON
1435  *
1436  * Local Variables:
1437  * eval: (c-set-style "gnu")
1438  * End:
1439  */