src/vnet/interface.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.c: VNET interfaces/sub-interfaces
  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/plugin/plugin.h>
  42 #include <vnet/adj/adj.h>
  43 #include <vnet/adj/adj_mcast.h>
  44 #include <vnet/ip/ip.h>
  45 #include <vnet/interface/rx_queue_funcs.h>
  46 #include <vnet/interface/tx_queue_funcs.h>
  47
  48 VLIB_REGISTER_LOG_CLASS (if_default_log, static) = {
  49   .class_name = "interface",
  50 };
  51
  52 #define log_debug(fmt,...) vlib_log_debug(if_default_log.class, fmt, __VA_ARGS__)
  53 #define log_err(fmt,...) vlib_log_err(if_default_log.class, fmt, __VA_ARGS__)
  54
  55 typedef enum vnet_interface_helper_flags_t_
  56 {
  57   VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE = (1 << 0),
  58   VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE = (1 << 1),
  59 } vnet_interface_helper_flags_t;
  60
  61 static clib_error_t *vnet_hw_interface_set_flags_helper (vnet_main_t * vnm,
  62                                                          u32 hw_if_index,
  63                                                          vnet_hw_interface_flags_t
  64                                                          flags,
  65                                                          vnet_interface_helper_flags_t
  66                                                          helper_flags);
  67
  68 static clib_error_t *vnet_sw_interface_set_flags_helper (vnet_main_t * vnm,
  69                                                          u32 sw_if_index,
  70                                                          vnet_sw_interface_flags_t
  71                                                          flags,
  72                                                          vnet_interface_helper_flags_t
  73                                                          helper_flags);
  74
  75 static clib_error_t *vnet_hw_interface_set_class_helper (vnet_main_t * vnm,
  76                                                          u32 hw_if_index,
  77                                                          u32 hw_class_index,
  78                                                          u32 redistribute);
  79
  80 typedef struct
  81 {
  82   /* Either sw or hw interface index. */
  83   u32 sw_hw_if_index;
  84
  85   /* Flags. */
  86   u32 flags;
  87 } vnet_sw_hw_interface_state_t;
  88
  89 static void
  90 serialize_vec_vnet_sw_hw_interface_state (serialize_main_t * m, va_list * va)
  91 {
  92   vnet_sw_hw_interface_state_t *s =
  93     va_arg (*va, vnet_sw_hw_interface_state_t *);
  94   u32 n = va_arg (*va, u32);
  95   u32 i;
  96   for (i = 0; i < n; i++)
  97     {
  98       serialize_integer (m, s[i].sw_hw_if_index,
  99                          sizeof (s[i].sw_hw_if_index));
 100       serialize_integer (m, s[i].flags, sizeof (s[i].flags));
 101     }
 102 }
 103
 104 static void
 105 unserialize_vec_vnet_sw_hw_interface_state (serialize_main_t * m,
 106                                             va_list * va)
 107 {
 108   vnet_sw_hw_interface_state_t *s =
 109     va_arg (*va, vnet_sw_hw_interface_state_t *);
 110   u32 n = va_arg (*va, u32);
 111   u32 i;
 112   for (i = 0; i < n; i++)
 113     {
 114       unserialize_integer (m, &s[i].sw_hw_if_index,
 115                            sizeof (s[i].sw_hw_if_index));
 116       unserialize_integer (m, &s[i].flags, sizeof (s[i].flags));
 117     }
 118 }
 119
 120 static vnet_sw_interface_flags_t
 121 vnet_hw_interface_flags_to_sw (vnet_hw_interface_flags_t hwf)
 122 {
 123   vnet_sw_interface_flags_t swf = VNET_SW_INTERFACE_FLAG_NONE;
 124
 125   if (hwf & VNET_HW_INTERFACE_FLAG_LINK_UP)
 126     swf |= VNET_SW_INTERFACE_FLAG_ADMIN_UP;
 127
 128   return (swf);
 129 }
 130
 131 void
 132 serialize_vnet_interface_state (serialize_main_t * m, va_list * va)
 133 {
 134   vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
 135   vnet_sw_hw_interface_state_t *sts = 0, *st;
 136   vnet_sw_interface_t *sif;
 137   vnet_hw_interface_t *hif;
 138   vnet_interface_main_t *im = &vnm->interface_main;
 139
 140   /* Serialize hardware interface classes since they may have changed.
 141      Must do this before sending up/down flags. */
 142   pool_foreach (hif, im->hw_interfaces)  {
 143     vnet_hw_interface_class_t * hw_class = vnet_get_hw_interface_class (vnm, hif->hw_class_index);
 144     serialize_cstring (m, hw_class->name);
 145   }
 146
 147   /* Send sw/hw interface state when non-zero. */
 148   pool_foreach (sif, im->sw_interfaces)  {
 149     if (sif->flags != 0)
 150       {
 151         vec_add2 (sts, st, 1);
 152         st->sw_hw_if_index = sif->sw_if_index;
 153         st->flags = sif->flags;
 154       }
 155   }
 156
 157   vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state);
 158
 159   if (sts)
 160     vec_set_len (sts, 0);
 161
 162   pool_foreach (hif, im->hw_interfaces)  {
 163     if (hif->flags != 0)
 164       {
 165         vec_add2 (sts, st, 1);
 166         st->sw_hw_if_index = hif->hw_if_index;
 167         st->flags = vnet_hw_interface_flags_to_sw(hif->flags);
 168       }
 169   }
 170
 171   vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state);
 172
 173   vec_free (sts);
 174 }
 175
 176 static vnet_hw_interface_flags_t
 177 vnet_sw_interface_flags_to_hw (vnet_sw_interface_flags_t swf)
 178 {
 179   vnet_hw_interface_flags_t hwf = VNET_HW_INTERFACE_FLAG_NONE;
 180
 181   if (swf & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 182     hwf |= VNET_HW_INTERFACE_FLAG_LINK_UP;
 183
 184   return (hwf);
 185 }
 186
 187 void
 188 unserialize_vnet_interface_state (serialize_main_t * m, va_list * va)
 189 {
 190   vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
 191   vnet_sw_hw_interface_state_t *sts = 0, *st;
 192
 193   /* First set interface hardware class. */
 194   {
 195     vnet_interface_main_t *im = &vnm->interface_main;
 196     vnet_hw_interface_t *hif;
 197     char *class_name;
 198     uword *p;
 199     clib_error_t *error;
 200
 201     pool_foreach (hif, im->hw_interfaces)  {
 202       unserialize_cstring (m, &class_name);
 203       p = hash_get_mem (im->hw_interface_class_by_name, class_name);
 204       if (p)
 205         {
 206           error = vnet_hw_interface_set_class_helper
 207             (vnm, hif->hw_if_index, p[0], /* redistribute */ 0);
 208         }
 209       else
 210         error = clib_error_return (0, "hw class %s AWOL?", class_name);
 211
 212       if (error)
 213         clib_error_report (error);
 214       vec_free (class_name);
 215     }
 216   }
 217
 218   vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state);
 219   vec_foreach (st, sts)
 220     vnet_sw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags,
 221                                         /* no distribute */ 0);
 222   vec_free (sts);
 223
 224   vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state);
 225   vec_foreach (st, sts)
 226   {
 227     vnet_hw_interface_set_flags_helper
 228       (vnm, st->sw_hw_if_index, vnet_sw_interface_flags_to_hw (st->flags),
 229        /* no distribute */ 0);
 230   }
 231   vec_free (sts);
 232 }
 233
 234 static clib_error_t *
 235 call_elf_section_interface_callbacks (vnet_main_t * vnm, u32 if_index,
 236                                       u32 flags,
 237                                       _vnet_interface_function_list_elt_t **
 238                                       elts)
 239 {
 240   _vnet_interface_function_list_elt_t *elt;
 241   vnet_interface_function_priority_t prio;
 242   clib_error_t *error = 0;
 243
 244   for (prio = VNET_ITF_FUNC_PRIORITY_LOW;
 245        prio <= VNET_ITF_FUNC_PRIORITY_HIGH; prio++)
 246     {
 247       elt = elts[prio];
 248
 249       while (elt)
 250         {
 251           error = elt->fp (vnm, if_index, flags);
 252           if (error)
 253             return error;
 254           elt = elt->next_interface_function;
 255         }
 256     }
 257   return error;
 258 }
 259
 260 static clib_error_t *
 261 call_hw_interface_add_del_callbacks (vnet_main_t * vnm, u32 hw_if_index,
 262                                      u32 is_create)
 263 {
 264   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 265   vnet_hw_interface_class_t *hw_class =
 266     vnet_get_hw_interface_class (vnm, hi->hw_class_index);
 267   vnet_device_class_t *dev_class =
 268     vnet_get_device_class (vnm, hi->dev_class_index);
 269   clib_error_t *error = 0;
 270
 271   if (hw_class->interface_add_del_function
 272       && (error =
 273           hw_class->interface_add_del_function (vnm, hw_if_index, is_create)))
 274     return error;
 275
 276   if (dev_class->interface_add_del_function
 277       && (error =
 278           dev_class->interface_add_del_function (vnm, hw_if_index,
 279                                                  is_create)))
 280     return error;
 281
 282   error = call_elf_section_interface_callbacks
 283     (vnm, hw_if_index, is_create, vnm->hw_interface_add_del_functions);
 284
 285   return error;
 286 }
 287
 288 static clib_error_t *
 289 call_sw_interface_add_del_callbacks (vnet_main_t * vnm, u32 sw_if_index,
 290                                      u32 is_create)
 291 {
 292   return call_elf_section_interface_callbacks
 293     (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions);
 294 }
 295
 296 static clib_error_t *
 297 vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index,
 298                                     vnet_hw_interface_flags_t flags,
 299                                     vnet_interface_helper_flags_t
 300                                     helper_flags)
 301 {
 302   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 303   vnet_hw_interface_class_t *hw_class =
 304     vnet_get_hw_interface_class (vnm, hi->hw_class_index);
 305   u32 mask;
 306   clib_error_t *error = 0;
 307   u32 is_create =
 308     (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
 309
 310   mask =
 311     (VNET_HW_INTERFACE_FLAG_LINK_UP | VNET_HW_INTERFACE_FLAG_DUPLEX_MASK);
 312   flags &= mask;
 313
 314   /* Call hardware interface add/del callbacks. */
 315   if (is_create)
 316     call_hw_interface_add_del_callbacks (vnm, hw_if_index, is_create);
 317
 318   /* Already in the desired state? */
 319   if (!is_create && (hi->flags & mask) == flags)
 320     goto done;
 321
 322   if ((hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) !=
 323       (flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
 324     {
 325       /* Do hardware class (e.g. ethernet). */
 326       if (hw_class->link_up_down_function
 327           && (error = hw_class->link_up_down_function (vnm, hw_if_index,
 328                                                        flags)))
 329         goto done;
 330
 331       error = call_elf_section_interface_callbacks
 332         (vnm, hw_if_index, flags, vnm->hw_interface_link_up_down_functions);
 333
 334       if (error)
 335         goto done;
 336     }
 337
 338   hi->flags &= ~mask;
 339   hi->flags |= flags;
 340
 341 done:
 342   if (error)
 343     log_err ("hw_set_flags_helper: %U", format_clib_error, error);
 344   return error;
 345 }
 346
 347 static clib_error_t *
 348 vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index,
 349                                     vnet_sw_interface_flags_t flags,
 350                                     vnet_interface_helper_flags_t
 351                                     helper_flags)
 352 {
 353   vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
 354   u32 mask;
 355   clib_error_t *error = 0;
 356   u32 is_create =
 357     (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
 358   u32 old_flags;
 359
 360   mask = VNET_SW_INTERFACE_FLAG_ADMIN_UP | VNET_SW_INTERFACE_FLAG_PUNT;
 361   flags &= mask;
 362
 363   if (is_create)
 364     {
 365       error =
 366         call_sw_interface_add_del_callbacks (vnm, sw_if_index, is_create);
 367       if (error)
 368         goto done;
 369
 370       if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 371         {
 372           /* Notify everyone when the interface is created as admin up */
 373           error = call_elf_section_interface_callbacks (vnm, sw_if_index,
 374                                                         flags,
 375                                                         vnm->
 376                                                         sw_interface_admin_up_down_functions);
 377           if (error)
 378             goto done;
 379         }
 380     }
 381   else
 382     {
 383       vnet_sw_interface_t *si_sup = si;
 384
 385       /* Check that super interface is in correct state. */
 386       if (si->type == VNET_SW_INTERFACE_TYPE_SUB)
 387         {
 388           si_sup = vnet_get_sw_interface (vnm, si->sup_sw_if_index);
 389
 390           /* Check to see if we're bringing down the soft interface and if it's parent is up */
 391           if ((flags != (si_sup->flags & mask)) &&
 392               (!((flags == 0)
 393                  && ((si_sup->flags & mask) ==
 394                      VNET_SW_INTERFACE_FLAG_ADMIN_UP))))
 395             {
 396               error = clib_error_return (0, "super-interface %U must be %U",
 397                                          format_vnet_sw_interface_name, vnm,
 398                                          si_sup,
 399                                          format_vnet_sw_interface_flags,
 400                                          flags);
 401               goto done;
 402             }
 403         }
 404
 405       /* Already in the desired state? */
 406       if ((si->flags & mask) == flags)
 407         goto done;
 408
 409       /* Sub-interfaces of hardware interfaces that do no redistribute,
 410          do not redistribute themselves. */
 411       if (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
 412         {
 413           vnet_hw_interface_t *hi =
 414             vnet_get_hw_interface (vnm, si_sup->hw_if_index);
 415           vnet_device_class_t *dev_class =
 416             vnet_get_device_class (vnm, hi->dev_class_index);
 417           if (!dev_class->redistribute)
 418             helper_flags &=
 419               ~VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE;
 420         }
 421
 422       /* set the flags now before invoking the registered clients
 423        * so that the state they query is consistent with the state here notified */
 424       old_flags = si->flags;
 425       si->flags &= ~mask;
 426       si->flags |= flags;
 427       if ((flags | old_flags) & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 428         error = call_elf_section_interface_callbacks
 429           (vnm, sw_if_index, flags,
 430            vnm->sw_interface_admin_up_down_functions);
 431
 432       if (error)
 433         {
 434           /* restore flags on error */
 435           si->flags = old_flags;
 436           goto done;
 437         }
 438
 439       if (si->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
 440         {
 441           vnet_hw_interface_t *hi =
 442             vnet_get_hw_interface (vnm, si->hw_if_index);
 443           vnet_hw_interface_class_t *hw_class =
 444             vnet_get_hw_interface_class (vnm, hi->hw_class_index);
 445           vnet_device_class_t *dev_class =
 446             vnet_get_device_class (vnm, hi->dev_class_index);
 447
 448           if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
 449               (si->flags & VNET_SW_INTERFACE_FLAG_ERROR))
 450             {
 451               error = clib_error_return (0, "Interface in the error state");
 452               goto done;
 453             }
 454
 455           /* update si admin up flag in advance if we are going admin down */
 456           if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 457             si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
 458
 459           if (dev_class->admin_up_down_function
 460               && (error = dev_class->admin_up_down_function (vnm,
 461                                                              si->hw_if_index,
 462                                                              flags)))
 463             {
 464               /* restore si admin up flag to it's original state on errors */
 465               si->flags = old_flags;
 466               goto done;
 467             }
 468
 469           if (hw_class->admin_up_down_function
 470               && (error = hw_class->admin_up_down_function (vnm,
 471                                                             si->hw_if_index,
 472                                                             flags)))
 473             {
 474               /* restore si admin up flag to it's original state on errors */
 475               si->flags = old_flags;
 476               goto done;
 477             }
 478
 479           /* Admin down implies link down. */
 480           if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 481               && (hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
 482             vnet_hw_interface_set_flags_helper (vnm, si->hw_if_index,
 483                                                 hi->flags &
 484                                                 ~VNET_HW_INTERFACE_FLAG_LINK_UP,
 485                                                 helper_flags);
 486           vnet_hw_if_update_runtime_data (vnm, si->hw_if_index);
 487         }
 488     }
 489
 490   si->flags &= ~mask;
 491   si->flags |= flags;
 492
 493 done:
 494   if (error)
 495     log_err ("sw_set_flags_helper: %U", format_clib_error, error);
 496   return error;
 497 }
 498
 499 clib_error_t *
 500 vnet_hw_interface_set_flags (vnet_main_t * vnm, u32 hw_if_index,
 501                              vnet_hw_interface_flags_t flags)
 502 {
 503   log_debug ("hw_set_flags: hw_if_index %u flags 0x%x", hw_if_index, flags);
 504   return vnet_hw_interface_set_flags_helper
 505     (vnm, hw_if_index, flags,
 506      VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE);
 507 }
 508
 509 clib_error_t *
 510 vnet_sw_interface_set_flags (vnet_main_t * vnm, u32 sw_if_index,
 511                              vnet_sw_interface_flags_t flags)
 512 {
 513   log_debug ("sw_set_flags: sw_if_index %u flags 0x%x", sw_if_index, flags);
 514   return vnet_sw_interface_set_flags_helper
 515     (vnm, sw_if_index, flags,
 516      VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE);
 517 }
 518
 519 void
 520 vnet_sw_interface_admin_up (vnet_main_t * vnm, u32 sw_if_index)
 521 {
 522   u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
 523   log_debug ("sw_admin_up: sw_if_index %u", sw_if_index);
 524
 525   if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 526     {
 527       flags |= VNET_SW_INTERFACE_FLAG_ADMIN_UP;
 528       vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
 529     }
 530 }
 531
 532 void
 533 vnet_sw_interface_admin_down (vnet_main_t * vnm, u32 sw_if_index)
 534 {
 535   u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
 536   log_debug ("sw_admin_down: sw_if_index %u", sw_if_index);
 537
 538   if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
 539     {
 540       flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP);
 541       vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
 542     }
 543 }
 544
 545 static void
 546 vnet_if_update_lookup_tables (vnet_main_t *vnm, u32 sw_if_index)
 547 {
 548   vnet_interface_main_t *im = &vnm->interface_main;
 549   vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
 550
 551   vec_validate_init_empty (im->hw_if_index_by_sw_if_index, sw_if_index, ~0);
 552   vec_validate_init_empty (im->if_out_arc_end_next_index_by_sw_if_index,
 553                            sw_if_index, ~0);
 554
 555   im->hw_if_index_by_sw_if_index[sw_if_index] = hi->hw_if_index;
 556   im->if_out_arc_end_next_index_by_sw_if_index[sw_if_index] =
 557     hi->if_out_arc_end_node_next_index;
 558 }
 559
 560 static u32
 561 vnet_create_sw_interface_no_callbacks (vnet_main_t * vnm,
 562                                        vnet_sw_interface_t * template)
 563 {
 564   vnet_interface_main_t *im = &vnm->interface_main;
 565   vnet_sw_interface_t *sw;
 566   u32 sw_if_index;
 567
 568   pool_get (im->sw_interfaces, sw);
 569   sw_if_index = sw - im->sw_interfaces;
 570
 571   sw[0] = template[0];
 572
 573   sw->flags = 0;
 574   sw->sw_if_index = sw_if_index;
 575   if (sw->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
 576     sw->sup_sw_if_index = sw->sw_if_index;
 577
 578   /* Allocate counters for this interface. */
 579   {
 580     u32 i;
 581
 582     vnet_interface_counter_lock (im);
 583
 584     for (i = 0; i < vec_len (im->sw_if_counters); i++)
 585       {
 586         vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
 587         vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
 588       }
 589
 590     for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
 591       {
 592         vlib_validate_combined_counter (&im->combined_sw_if_counters[i],
 593                                         sw_if_index);
 594         vlib_zero_combined_counter (&im->combined_sw_if_counters[i],
 595                                     sw_if_index);
 596       }
 597
 598     vnet_interface_counter_unlock (im);
 599   }
 600
 601   vnet_if_update_lookup_tables (vnm, sw_if_index);
 602   return sw_if_index;
 603 }
 604
 605 clib_error_t *
 606 vnet_create_sw_interface (vnet_main_t * vnm, vnet_sw_interface_t * template,
 607                           u32 * sw_if_index)
 608 {
 609   vnet_interface_main_t *im = &vnm->interface_main;
 610   clib_error_t *error;
 611   vnet_hw_interface_t *hi;
 612   vnet_device_class_t *dev_class;
 613
 614   if (template->sub.eth.flags.two_tags == 1
 615       && template->sub.eth.flags.exact_match == 1
 616       && (template->sub.eth.flags.inner_vlan_id_any == 1
 617           || template->sub.eth.flags.outer_vlan_id_any == 1))
 618     {
 619       char *str = "inner-dot1q any exact-match is unsupported";
 620       error = clib_error_return (0, str);
 621       log_err ("create_sw_interface: %s", str);
 622       return error;
 623     }
 624
 625   hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
 626   dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
 627
 628   if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
 629       dev_class->subif_add_del_function)
 630     {
 631       error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
 632                                                  (struct vnet_sw_interface_t
 633                                                   *) template, 1);
 634       if (error)
 635         return error;
 636     }
 637
 638   *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
 639   error = vnet_sw_interface_set_flags_helper
 640     (vnm, *sw_if_index, template->flags,
 641      VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE);
 642
 643   if (error)
 644     {
 645       /* undo the work done by vnet_create_sw_interface_no_callbacks() */
 646       log_err ("create_sw_interface: set flags failed\n  %U",
 647                format_clib_error, error);
 648       call_sw_interface_add_del_callbacks (vnm, *sw_if_index, 0);
 649       vnet_sw_interface_t *sw =
 650         pool_elt_at_index (im->sw_interfaces, *sw_if_index);
 651       pool_put (im->sw_interfaces, sw);
 652     }
 653   else
 654     {
 655       vnet_sw_interface_t *sw =
 656         pool_elt_at_index (im->sw_interfaces, *sw_if_index);
 657       log_debug ("create_sw_interface: interface %U (sw_if_index %u) created",
 658                  format_vnet_sw_interface_name, vnm, sw, *sw_if_index);
 659     }
 660
 661   return error;
 662 }
 663
 664 void
 665 vnet_delete_sw_interface (vnet_main_t * vnm, u32 sw_if_index)
 666 {
 667   vnet_interface_main_t *im = &vnm->interface_main;
 668   vnet_sw_interface_t *sw =
 669     pool_elt_at_index (im->sw_interfaces, sw_if_index);
 670
 671   log_debug ("delete_sw_interface: sw_if_index %u, name '%U'",
 672              sw_if_index, format_vnet_sw_if_index_name, vnm, sw_if_index);
 673
 674   /* Check if the interface has config and is removed from L2 BD or XConnect */
 675   vnet_clear_sw_interface_tag (vnm, sw_if_index);
 676
 677   /* Bring down interface in case it is up. */
 678   if (sw->flags != 0)
 679     vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
 680
 681   call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
 682
 683   pool_put (im->sw_interfaces, sw);
 684 }
 685
 686 static clib_error_t *
 687 call_sw_interface_mtu_change_callbacks (vnet_main_t * vnm, u32 sw_if_index)
 688 {
 689   return call_elf_section_interface_callbacks
 690     (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions);
 691 }
 692
 693 void
 694 vnet_sw_interface_set_mtu (vnet_main_t * vnm, u32 sw_if_index, u32 mtu)
 695 {
 696   vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
 697
 698   if (si->mtu[VNET_MTU_L3] != mtu)
 699     {
 700       si->mtu[VNET_MTU_L3] = mtu;
 701       log_debug ("set_mtu: interface %U, new mtu %u",
 702                  format_vnet_sw_if_index_name, vnm, sw_if_index, mtu);
 703
 704       call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
 705     }
 706 }
 707
 708 void
 709 vnet_sw_interface_set_protocol_mtu (vnet_main_t * vnm, u32 sw_if_index,
 710                                     u32 mtu[])
 711 {
 712   vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
 713   bool changed = false;
 714   int i;
 715
 716   for (i = 0; i < VNET_N_MTU; i++)
 717     {
 718       if (si->mtu[i] != mtu[i])
 719         {
 720           si->mtu[i] = mtu[i];
 721           changed = true;
 722         }
 723     }
 724   /* Notify interested parties */
 725   if (changed)
 726     {
 727       log_debug ("set_protocol_mtu: interface %U l3 %u ip4 %u ip6 %u mpls %u",
 728                  format_vnet_sw_if_index_name, vnm, sw_if_index,
 729                  mtu[VNET_MTU_L3], mtu[VNET_MTU_IP4], mtu[VNET_MTU_IP6],
 730                  mtu[VNET_MTU_MPLS]);
 731       call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
 732     }
 733 }
 734
 735 void
 736 vnet_sw_interface_ip_directed_broadcast (vnet_main_t * vnm,
 737                                          u32 sw_if_index, u8 enable)
 738 {
 739   vnet_sw_interface_t *si;
 740
 741   si = vnet_get_sw_interface (vnm, sw_if_index);
 742
 743   if (enable)
 744     si->flags |= VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST;
 745   else
 746     si->flags &= ~VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST;
 747
 748   ip4_directed_broadcast (sw_if_index, enable);
 749 }
 750
 751 /*
 752  * Reflect a change in hardware MTU on protocol MTUs
 753  */
 754 static walk_rc_t
 755 sw_interface_walk_callback (vnet_main_t * vnm, u32 sw_if_index, void *ctx)
 756 {
 757   u32 *link_mtu = ctx;
 758   vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu);
 759   return WALK_CONTINUE;
 760 }
 761
 762 clib_error_t *
 763 vnet_hw_interface_set_max_frame_size (vnet_main_t *vnm, u32 hw_if_index,
 764                                       u32 fs)
 765 {
 766   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 767   vnet_hw_interface_class_t *hw_if_class =
 768     vnet_get_hw_interface_class (vnm, hi->hw_class_index);
 769   clib_error_t *err = 0;
 770   log_debug ("set_max_frame_size: interface %v, max_frame_size %u -> %u",
 771              hi->name, hi->max_frame_size, fs);
 772
 773   if (hw_if_class->set_max_frame_size == 0)
 774     return vnet_error (VNET_ERR_UNSUPPORTED,
 775                        "hw class doesn't support changing Max Frame Size");
 776
 777   if (hi->max_frame_size != fs)
 778     {
 779       u32 mtu;
 780       if (hw_if_class->set_max_frame_size)
 781         if ((err = hw_if_class->set_max_frame_size (vnm, hi, fs)))
 782           return err;
 783       hi->max_frame_size = fs;
 784       mtu = fs - hi->frame_overhead;
 785       vnet_hw_interface_walk_sw (vnm, hw_if_index, sw_interface_walk_callback,
 786                                  &mtu);
 787     }
 788   return 0;
 789 }
 790 clib_error_t *
 791 vnet_hw_interface_set_mtu (vnet_main_t *vnm, u32 hw_if_index, u32 mtu)
 792 {
 793   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 794   return vnet_hw_interface_set_max_frame_size (vnm, hw_if_index,
 795                                                mtu + hi->frame_overhead);
 796 }
 797
 798 static void
 799 setup_tx_node (vlib_main_t * vm,
 800                u32 node_index, vnet_device_class_t * dev_class)
 801 {
 802   vlib_node_t *n = vlib_get_node (vm, node_index);
 803
 804   n->format_trace = dev_class->format_tx_trace;
 805
 806   vlib_register_errors (vm, node_index, dev_class->tx_function_n_errors,
 807                         dev_class->tx_function_error_strings,
 808                         dev_class->tx_function_error_counters);
 809 }
 810
 811 static void
 812 setup_output_node (vlib_main_t * vm,
 813                    u32 node_index, vnet_hw_interface_class_t * hw_class)
 814 {
 815   vlib_node_t *n = vlib_get_node (vm, node_index);
 816   n->format_buffer = hw_class->format_header;
 817   n->unformat_buffer = hw_class->unformat_header;
 818 }
 819
 820 void
 821 vnet_reset_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index)
 822 {
 823   vnet_set_interface_l3_output_node (vm, sw_if_index,
 824                                      (u8 *) "interface-output");
 825 }
 826
 827 void
 828 vnet_set_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index,
 829                                    u8 *output_node)
 830 {
 831   vlib_node_t *l3_node;
 832
 833   l3_node = vlib_get_node_by_name (vm, output_node);
 834
 835   static char *arcs[] = {
 836     "ip4-output",
 837     "ip6-output",
 838     "mpls-output",
 839     "ethernet-output",
 840   };
 841   u8 a;
 842
 843   for (a = 0; a < ARRAY_LEN (arcs); a++)
 844     {
 845       u8 arc = vnet_get_feature_arc_index (arcs[a]);
 846       vnet_feature_modify_end_node (arc, sw_if_index, l3_node->index);
 847     }
 848 }
 849
 850 /* Register an interface instance. */
 851 u32
 852 vnet_register_interface (vnet_main_t * vnm,
 853                          u32 dev_class_index,
 854                          u32 dev_instance,
 855                          u32 hw_class_index, u32 hw_instance)
 856 {
 857   vnet_interface_main_t *im = &vnm->interface_main;
 858   vnet_hw_interface_t *hw;
 859   vnet_device_class_t *dev_class =
 860     vnet_get_device_class (vnm, dev_class_index);
 861   vnet_hw_interface_class_t *hw_class =
 862     vnet_get_hw_interface_class (vnm, hw_class_index);
 863   vlib_main_t *vm = vnm->vlib_main;
 864   vnet_feature_config_main_t *fcm;
 865   vnet_config_main_t *cm;
 866   u32 hw_index, i;
 867   vlib_node_t *if_out_node =
 868     vlib_get_node (vm, vnet_interface_output_node.index);
 869
 870   pool_get (im->hw_interfaces, hw);
 871   clib_memset (hw, 0, sizeof (*hw));
 872   hw->trace_classify_table_index = ~0;
 873
 874   hw_index = hw - im->hw_interfaces;
 875   hw->hw_if_index = hw_index;
 876   hw->default_rx_mode = VNET_HW_IF_RX_MODE_POLLING;
 877
 878   if (hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_ETHERNET ||
 879       hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_IP)
 880     hw->hf = vnet_hash_default_function (hw_class->tx_hash_fn_type);
 881
 882   if (dev_class->format_device_name)
 883     hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
 884   else if (hw_class->format_interface_name)
 885     hw->name = format (0, "%U", hw_class->format_interface_name,
 886                        dev_instance);
 887   else
 888     hw->name = format (0, "%s%x", hw_class->name, dev_instance);
 889
 890   if (!im->hw_interface_by_name)
 891     im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
 892                                                 sizeof (hw->name[0]),
 893                                                 sizeof (uword));
 894
 895   hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
 896
 897   /* Make hardware interface point to software interface. */
 898   {
 899     vnet_sw_interface_t sw = {
 900       .type = VNET_SW_INTERFACE_TYPE_HARDWARE,
 901       .flood_class = VNET_FLOOD_CLASS_NORMAL,
 902       .hw_if_index = hw_index
 903     };
 904     hw->sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, &sw);
 905   }
 906
 907   hw->dev_class_index = dev_class_index;
 908   hw->dev_instance = dev_instance;
 909   hw->hw_class_index = hw_class_index;
 910   hw->hw_instance = hw_instance;
 911
 912   hw->max_rate_bits_per_sec = 0;
 913   vnet_sw_interface_set_mtu (vnm, hw->sw_if_index, 0);
 914
 915   if (dev_class->tx_function == 0 && dev_class->tx_fn_registrations == 0)
 916     goto no_output_nodes;       /* No output/tx nodes to create */
 917
 918   /* If we have previously deleted interface nodes, re-use them. */
 919   if (vec_len (im->deleted_hw_interface_nodes) > 0)
 920     {
 921       vnet_hw_interface_nodes_t *hn;
 922       vlib_node_t *node;
 923       vlib_node_runtime_t *nrt;
 924
 925       hn = vec_end (im->deleted_hw_interface_nodes) - 1;
 926
 927       hw->tx_node_index = hn->tx_node_index;
 928       hw->output_node_index = hn->output_node_index;
 929
 930       vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
 931       vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
 932
 933       foreach_vlib_main ()
 934         {
 935           vnet_interface_output_runtime_t *rt;
 936
 937           rt =
 938             vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
 939           ASSERT (rt->is_deleted == 1);
 940           rt->is_deleted = 0;
 941           rt->hw_if_index = hw_index;
 942           rt->sw_if_index = hw->sw_if_index;
 943           rt->dev_instance = hw->dev_instance;
 944
 945           rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index);
 946           rt->hw_if_index = hw_index;
 947           rt->sw_if_index = hw->sw_if_index;
 948           rt->dev_instance = hw->dev_instance;
 949         }
 950
 951       /* The new class may differ from the old one.
 952        * Functions have to be updated. */
 953       node = vlib_get_node (vm, hw->output_node_index);
 954       node->format_trace = format_vnet_interface_output_trace;
 955       node->node_fn_registrations = if_out_node->node_fn_registrations;
 956       node->function = if_out_node->function;
 957
 958       foreach_vlib_main ()
 959         {
 960           nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index);
 961           nrt->function = node->function;
 962           vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0,
 963                                           VLIB_NODE_RUNTIME_PERF_RESET);
 964         }
 965
 966       node = vlib_get_node (vm, hw->tx_node_index);
 967       if (dev_class->tx_fn_registrations)
 968         {
 969           node->node_fn_registrations = dev_class->tx_fn_registrations;
 970           node->function = vlib_node_get_preferred_node_fn_variant (
 971             vm, dev_class->tx_fn_registrations);
 972         }
 973       else
 974         node->function = dev_class->tx_function;
 975       node->format_trace = dev_class->format_tx_trace;
 976
 977       foreach_vlib_main ()
 978         {
 979           nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index);
 980           nrt->function = node->function;
 981           vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0,
 982                                           VLIB_NODE_RUNTIME_PERF_RESET);
 983         }
 984
 985       vec_dec_len (im->deleted_hw_interface_nodes, 1);
 986     }
 987   else
 988     {
 989       vlib_node_registration_t r;
 990       vnet_interface_output_runtime_t rt = {
 991         .hw_if_index = hw_index,
 992         .sw_if_index = hw->sw_if_index,
 993         .dev_instance = hw->dev_instance,
 994         .is_deleted = 0,
 995       };
 996
 997       clib_memset (&r, 0, sizeof (r));
 998       r.type = VLIB_NODE_TYPE_INTERNAL;
 999       r.runtime_data = &rt;
1000       r.runtime_data_bytes = sizeof (rt);
1001       r.scalar_size = sizeof (vnet_hw_if_tx_frame_t);
1002       r.vector_size = sizeof (u32);
1003
1004       r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
1005       if (dev_class->tx_fn_registrations)
1006         {
1007           r.function = 0;
1008           r.node_fn_registrations = dev_class->tx_fn_registrations;
1009         }
1010       else
1011         r.function = dev_class->tx_function;
1012
1013       hw->tx_node_index = vlib_register_node (vm, &r, "%v-tx", hw->name);
1014
1015       vlib_node_add_named_next_with_slot (vm, hw->tx_node_index,
1016                                           "error-drop",
1017                                           VNET_INTERFACE_TX_NEXT_DROP);
1018
1019       r.flags = 0;
1020       r.format_trace = format_vnet_interface_output_trace;
1021       if (if_out_node->node_fn_registrations)
1022         {
1023           r.function = 0;
1024           r.node_fn_registrations = if_out_node->node_fn_registrations;
1025         }
1026       else
1027         r.function = if_out_node->function;
1028
1029       {
1030         static char *e[] = {
1031           "interface is down",
1032           "interface is deleted",
1033           "no tx queue available",
1034         };
1035
1036         r.n_errors = ARRAY_LEN (e);
1037         r.error_strings = e;
1038       }
1039       hw->output_node_index =
1040         vlib_register_node (vm, &r, "%v-output", hw->name);
1041
1042       vlib_node_add_named_next_with_slot (vm, hw->output_node_index,
1043                                           "error-drop",
1044                                           VNET_INTERFACE_OUTPUT_NEXT_DROP);
1045       vlib_node_add_next_with_slot (vm, hw->output_node_index,
1046                                     hw->tx_node_index,
1047                                     VNET_INTERFACE_OUTPUT_NEXT_TX);
1048       /* add interface to the list of "output-interface" feature arc start nodes
1049          and clone nexts from 1st interface if it exists */
1050       fcm = vnet_feature_get_config_main (im->output_feature_arc_index);
1051       cm = &fcm->config_main;
1052       i = vec_len (cm->start_node_indices);
1053       vec_validate (cm->start_node_indices, i);
1054       cm->start_node_indices[i] = hw->output_node_index;
1055       if (hw_index)
1056         {
1057           /* copy nexts from 1st interface */
1058           vnet_hw_interface_t *first_hw;
1059           vlib_node_t *first_node;
1060
1061           first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
1062           first_node = vlib_get_node (vm, first_hw->output_node_index);
1063
1064           /* 1st 2 nexts are already added above */
1065           for (i = 2; i < vec_len (first_node->next_nodes); i++)
1066             vlib_node_add_next_with_slot (vm, hw->output_node_index,
1067                                           first_node->next_nodes[i], i);
1068         }
1069     }
1070
1071   hw->if_out_arc_end_node_next_index = vlib_node_add_next (
1072     vm, vnet_interface_output_arc_end_node.index, hw->tx_node_index);
1073   vnet_if_update_lookup_tables (vnm, hw->sw_if_index);
1074   setup_output_node (vm, hw->output_node_index, hw_class);
1075   setup_tx_node (vm, hw->tx_node_index, dev_class);
1076
1077 no_output_nodes:
1078   /* Call all up/down callbacks with zero flags when interface is created. */
1079   vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
1080                                       VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE);
1081   vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
1082                                       VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE);
1083   return hw_index;
1084 }
1085
1086 void
1087 vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index)
1088 {
1089   vnet_interface_main_t *im = &vnm->interface_main;
1090   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
1091   vlib_main_t *vm = vnm->vlib_main;
1092   vnet_device_class_t *dev_class = vnet_get_device_class (vnm,
1093                                                           hw->dev_class_index);
1094   /* If it is up, mark it down. */
1095   if (hw->flags != 0)
1096     vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
1097
1098   /* Call delete callbacks. */
1099   call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
1100
1101   /* delete rx & tx queues */
1102   vnet_hw_if_unregister_all_rx_queues (vnm, hw_if_index);
1103   vnet_hw_if_unregister_all_tx_queues (vnm, hw_if_index);
1104   vnet_hw_if_update_runtime_data (vnm, hw_if_index);
1105
1106   /* Delete any sub-interfaces. */
1107   {
1108     u32 id, sw_if_index;
1109     hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id,
1110     ({
1111       vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1112       u64 sup_and_sub_key =
1113         ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id;
1114       hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
1115       vnet_delete_sw_interface (vnm, sw_if_index);
1116     }));
1117     hash_free (hw->sub_interface_sw_if_index_by_id);
1118   }
1119
1120   /* Delete software interface corresponding to hardware interface. */
1121   vnet_delete_sw_interface (vnm, hw->sw_if_index);
1122
1123   if (dev_class->tx_function)
1124     {
1125       /* Put output/tx nodes into recycle pool */
1126       vnet_hw_interface_nodes_t *dn;
1127
1128       foreach_vlib_main ()
1129         {
1130           vnet_interface_output_runtime_t *rt =
1131             vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
1132
1133           /* Mark node runtime as deleted so output node (if called)
1134            * will drop packets. */
1135           rt->is_deleted = 1;
1136         }
1137
1138       vlib_node_rename (vm, hw->output_node_index,
1139                         "interface-%d-output-deleted", hw_if_index);
1140       vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
1141                         hw_if_index);
1142       vlib_unregister_errors (vm, hw->output_node_index);
1143       vlib_unregister_errors (vm, hw->tx_node_index);
1144       vec_add2 (im->deleted_hw_interface_nodes, dn, 1);
1145       dn->tx_node_index = hw->tx_node_index;
1146       dn->output_node_index = hw->output_node_index;
1147     }
1148   hash_unset_mem (im->hw_interface_by_name, hw->name);
1149   vec_free (hw->name);
1150   vec_free (hw->hw_address);
1151   vec_free (hw->output_node_thread_runtimes);
1152   pool_put (im->hw_interfaces, hw);
1153 }
1154
1155 void
1156 vnet_hw_interface_walk_sw (vnet_main_t * vnm,
1157                            u32 hw_if_index,
1158                            vnet_hw_sw_interface_walk_t fn, void *ctx)
1159 {
1160   vnet_hw_interface_t *hi;
1161   u32 id, sw_if_index;
1162
1163   hi = vnet_get_hw_interface (vnm, hw_if_index);
1164   /* the super first, then the sub interfaces */
1165   if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx))
1166     return;
1167
1168   hash_foreach (id, sw_if_index,
1169                 hi->sub_interface_sw_if_index_by_id,
1170   ({
1171     if (WALK_STOP == fn (vnm, sw_if_index, ctx))
1172       break;
1173   }));
1174 }
1175
1176 void
1177 vnet_hw_interface_walk (vnet_main_t * vnm,
1178                         vnet_hw_interface_walk_t fn, void *ctx)
1179 {
1180   vnet_interface_main_t *im;
1181   vnet_hw_interface_t *hi;
1182
1183   im = &vnm->interface_main;
1184
1185   pool_foreach (hi, im->hw_interfaces)
1186    {
1187     if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx))
1188       break;
1189   }
1190 }
1191
1192 void
1193 vnet_sw_interface_walk (vnet_main_t * vnm,
1194                         vnet_sw_interface_walk_t fn, void *ctx)
1195 {
1196   vnet_interface_main_t *im;
1197   vnet_sw_interface_t *si;
1198
1199   im = &vnm->interface_main;
1200
1201   pool_foreach (si, im->sw_interfaces)
1202   {
1203     if (WALK_STOP == fn (vnm, si, ctx))
1204       break;
1205   }
1206 }
1207
1208 void
1209 vnet_hw_interface_init_for_class (vnet_main_t * vnm, u32 hw_if_index,
1210                                   u32 hw_class_index, u32 hw_instance)
1211 {
1212   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1213   vnet_hw_interface_class_t *hc =
1214     vnet_get_hw_interface_class (vnm, hw_class_index);
1215
1216   hi->hw_class_index = hw_class_index;
1217   hi->hw_instance = hw_instance;
1218   setup_output_node (vnm->vlib_main, hi->output_node_index, hc);
1219 }
1220
1221 static clib_error_t *
1222 vnet_hw_interface_set_class_helper (vnet_main_t * vnm, u32 hw_if_index,
1223                                     u32 hw_class_index, u32 redistribute)
1224 {
1225   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1226   vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, hi->sw_if_index);
1227   vnet_hw_interface_class_t *old_class =
1228     vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1229   vnet_hw_interface_class_t *new_class =
1230     vnet_get_hw_interface_class (vnm, hw_class_index);
1231   vnet_device_class_t *dev_class =
1232     vnet_get_device_class (vnm, hi->dev_class_index);
1233   clib_error_t *error = 0;
1234
1235   /* New class equals old class?  Nothing to do. */
1236   if (hi->hw_class_index == hw_class_index)
1237     return 0;
1238
1239   /* No need (and incorrect since admin up flag may be set) to do error checking when
1240      receiving unserialize message. */
1241   if (redistribute)
1242     {
1243       if (si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
1244         return clib_error_return (0,
1245                                   "%v must be admin down to change class from %s to %s",
1246                                   hi->name, old_class->name, new_class->name);
1247
1248       /* Make sure interface supports given class. */
1249       if ((new_class->is_valid_class_for_interface
1250            && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1251                                                         hw_class_index))
1252           || (dev_class->is_valid_class_for_interface
1253               && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1254                                                            hw_class_index)))
1255         return clib_error_return (0,
1256                                   "%v class cannot be changed from %s to %s",
1257                                   hi->name, old_class->name, new_class->name);
1258
1259     }
1260
1261   if (old_class->hw_class_change)
1262     old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1263                                 new_class->index);
1264
1265   vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1266                                     /* instance */ ~0);
1267
1268   if (new_class->hw_class_change)
1269     new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1270                                 new_class->index);
1271
1272   if (dev_class->hw_class_change)
1273     dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1274
1275   return error;
1276 }
1277
1278 clib_error_t *
1279 vnet_hw_interface_set_class (vnet_main_t * vnm, u32 hw_if_index,
1280                              u32 hw_class_index)
1281 {
1282   return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1283                                              /* redistribute */ 1);
1284 }
1285
1286 static int
1287 vnet_hw_interface_rx_redirect_to_node_helper (vnet_main_t * vnm,
1288                                               u32 hw_if_index,
1289                                               u32 node_index,
1290                                               u32 redistribute)
1291 {
1292   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1293   vnet_device_class_t *dev_class = vnet_get_device_class
1294     (vnm, hi->dev_class_index);
1295
1296   if (dev_class->rx_redirect_to_node)
1297     {
1298       dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1299       return 0;
1300     }
1301
1302   return VNET_API_ERROR_UNIMPLEMENTED;
1303 }
1304
1305 int
1306 vnet_hw_interface_rx_redirect_to_node (vnet_main_t * vnm, u32 hw_if_index,
1307                                        u32 node_index)
1308 {
1309   return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1310                                                        node_index,
1311                                                        1 /* redistribute */ );
1312 }
1313
1314 word
1315 vnet_sw_interface_compare (vnet_main_t * vnm,
1316                            uword sw_if_index0, uword sw_if_index1)
1317 {
1318   vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1319   vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1320   vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, sup0->hw_if_index);
1321   vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, sup1->hw_if_index);
1322
1323   if (h0 != h1)
1324     return vec_cmp (h0->name, h1->name);
1325   return (word) h0->hw_instance - (word) h1->hw_instance;
1326 }
1327
1328 word
1329 vnet_hw_interface_compare (vnet_main_t * vnm,
1330                            uword hw_if_index0, uword hw_if_index1)
1331 {
1332   vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1333   vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1);
1334
1335   if (h0 != h1)
1336     return vec_cmp (h0->name, h1->name);
1337   return (word) h0->hw_instance - (word) h1->hw_instance;
1338 }
1339
1340 int
1341 vnet_sw_interface_is_p2p (vnet_main_t * vnm, u32 sw_if_index)
1342 {
1343   vnet_sw_interface_t *si = vnet_get_sw_interface_or_null (vnm, sw_if_index);
1344   if (si == NULL)
1345     return -1;
1346
1347   if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) ||
1348       (si->type == VNET_SW_INTERFACE_TYPE_PIPE))
1349     return 1;
1350
1351   vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1352   vnet_hw_interface_class_t *hc =
1353     vnet_get_hw_interface_class (vnm, hw->hw_class_index);
1354
1355   return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1356 }
1357
1358 int
1359 vnet_sw_interface_is_nbma (vnet_main_t * vnm, u32 sw_if_index)
1360 {
1361   vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1362   vnet_hw_interface_class_t *hc =
1363     vnet_get_hw_interface_class (vnm, hw->hw_class_index);
1364
1365   return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_NBMA);
1366 }
1367
1368 clib_error_t *
1369 vnet_sw_interface_supports_addressing (vnet_main_t *vnm, u32 sw_if_index)
1370 {
1371   if (sw_if_index == 0)
1372     {
1373       return clib_error_create (
1374         "local0 interface doesn't support IP addressing");
1375     }
1376
1377   if (vnet_sw_interface_is_sub (vnm, sw_if_index))
1378     {
1379       vnet_sw_interface_t *si;
1380       si = vnet_get_sw_interface_or_null (vnm, sw_if_index);
1381       if (si && si->type == VNET_SW_INTERFACE_TYPE_SUB &&
1382           si->sub.eth.flags.exact_match == 0)
1383         {
1384           return clib_error_create (
1385             "sub-interface without exact-match doesn't support IP addressing");
1386         }
1387     }
1388   return NULL;
1389 }
1390
1391 u32
1392 vnet_register_device_class (vlib_main_t *vm, vnet_device_class_t *c)
1393 {
1394   vnet_main_t *vnm = vnet_get_main ();
1395   vnet_interface_main_t *im = &vnm->interface_main;
1396   c->index = vec_len (im->device_classes);
1397   hash_set_mem (im->device_class_by_name, c->name, c->index);
1398
1399   /* to avoid confusion, please remove ".tx_function" statement
1400     from VNET_DEVICE_CLASS() if using function candidates */
1401   ASSERT (c->tx_fn_registrations == 0 || c->tx_function == 0);
1402
1403   if (c->tx_fn_registrations)
1404     c->tx_function =
1405       vlib_node_get_preferred_node_fn_variant (vm, c->tx_fn_registrations);
1406
1407   vec_add1 (im->device_classes, c[0]);
1408   return c->index;
1409 }
1410
1411 clib_error_t *
1412 vnet_interface_init (vlib_main_t * vm)
1413 {
1414   vnet_main_t *vnm = vnet_get_main ();
1415   vnet_interface_main_t *im = &vnm->interface_main;
1416   vlib_buffer_t *b = 0;
1417   vnet_buffer_opaque_t *o = 0;
1418   clib_error_t *error;
1419
1420   /*
1421    * Keep people from shooting themselves in the foot.
1422    */
1423   if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1424     {
1425 #define _(a) if (sizeof(o->a) > sizeof (o->unused))                     \
1426       clib_warning                                                      \
1427         ("FATAL: size of opaque union subtype %s is %d (max %d)",       \
1428          #a, sizeof(o->a), sizeof (o->unused));
1429       foreach_buffer_opaque_union_subtype;
1430 #undef _
1431
1432       return clib_error_return
1433         (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1434          sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1435     }
1436
1437   clib_spinlock_init (&im->sw_if_counter_lock);
1438   clib_spinlock_lock (&im->sw_if_counter_lock); /* should be no need */
1439
1440   vec_validate (im->sw_if_counters, VNET_N_SIMPLE_INTERFACE_COUNTER - 1);
1441 #define _(E,n,p)                                                        \
1442   im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n;             \
1443   im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1444   foreach_simple_interface_counter_name
1445 #undef _
1446     vec_validate (im->combined_sw_if_counters,
1447                   VNET_N_COMBINED_INTERFACE_COUNTER - 1);
1448 #define _(E,n,p)                                                        \
1449   im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n;    \
1450   im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1451   foreach_combined_interface_counter_name
1452 #undef _
1453     clib_spinlock_unlock (&im->sw_if_counter_lock);
1454
1455   im->device_class_by_name = hash_create_string ( /* size */ 0,
1456                                                  sizeof (uword));
1457
1458   for (vnet_device_class_t *c = vnm->device_class_registrations; c;
1459        c = c->next_class_registration)
1460     vnet_register_device_class (vm, c);
1461
1462   im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1463                                                        sizeof (uword));
1464
1465   im->rxq_index_by_hw_if_index_and_queue_id =
1466     hash_create_mem (0, sizeof (u64), sizeof (u32));
1467   im->txq_index_by_hw_if_index_and_queue_id =
1468     hash_create_mem (0, sizeof (u64), sizeof (u32));
1469   im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1470                                                     sizeof (uword));
1471   {
1472     vnet_hw_interface_class_t *c;
1473
1474     c = vnm->hw_interface_class_registrations;
1475
1476     while (c)
1477       {
1478         c->index = vec_len (im->hw_interface_classes);
1479         hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1480
1481         if (NULL == c->build_rewrite)
1482           c->build_rewrite = default_build_rewrite;
1483         if (NULL == c->update_adjacency)
1484           c->update_adjacency = default_update_adjacency;
1485
1486         vec_add1 (im->hw_interface_classes, c[0]);
1487         c = c->next_class_registration;
1488       }
1489   }
1490
1491   /* init per-thread data */
1492   vec_validate_aligned (im->per_thread_data, vlib_num_workers (),
1493                         CLIB_CACHE_LINE_BYTES);
1494
1495   if ((error = vlib_call_init_function (vm, vnet_interface_cli_init)))
1496     return error;
1497
1498   vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1499
1500   return 0;
1501 }
1502
1503 VLIB_INIT_FUNCTION (vnet_interface_init);
1504
1505 /* Kludge to renumber interface names [only!] */
1506 int
1507 vnet_interface_name_renumber (u32 sw_if_index, u32 new_show_dev_instance)
1508 {
1509   int rv;
1510   vnet_main_t *vnm = vnet_get_main ();
1511   vnet_interface_main_t *im = &vnm->interface_main;
1512   vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1513
1514   vnet_device_class_t *dev_class = vnet_get_device_class
1515     (vnm, hi->dev_class_index);
1516
1517   if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1518     return VNET_API_ERROR_UNIMPLEMENTED;
1519
1520   rv = dev_class->name_renumber (hi, new_show_dev_instance);
1521
1522   if (rv)
1523     return rv;
1524
1525   hash_unset_mem (im->hw_interface_by_name, hi->name);
1526   vec_free (hi->name);
1527   /* Use the mapping we set up to call it Ishmael */
1528   hi->name = format (0, "%U", dev_class->format_device_name,
1529                      hi->dev_instance);
1530
1531   hash_set_mem (im->hw_interface_by_name, hi->name, hi->hw_if_index);
1532   return rv;
1533 }
1534
1535 clib_error_t *
1536 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1537 {
1538   vnet_interface_main_t *im = &vnm->interface_main;
1539   vlib_main_t *vm = vnm->vlib_main;
1540   vnet_hw_interface_t *hw;
1541   u8 *old_name;
1542   clib_error_t *error = 0;
1543
1544   hw = vnet_get_hw_interface (vnm, hw_if_index);
1545   if (!hw)
1546     {
1547       return clib_error_return (0,
1548                                 "unable to find hw interface for index %u",
1549                                 hw_if_index);
1550     }
1551
1552   old_name = hw->name;
1553
1554   /* set new hw->name */
1555   hw->name = format (0, "%s", new_name);
1556
1557   /* remove the old name to hw_if_index mapping and install the new one */
1558   hash_unset_mem (im->hw_interface_by_name, old_name);
1559   hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1560
1561   /* rename tx/output nodes */
1562   vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1563   vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1564
1565   /* free the old name vector */
1566   vec_free (old_name);
1567
1568   return error;
1569 }
1570
1571 clib_error_t *
1572 vnet_hw_interface_add_del_mac_address (vnet_main_t * vnm,
1573                                        u32 hw_if_index,
1574                                        const u8 * mac_address, u8 is_add)
1575 {
1576   clib_error_t *error = 0;
1577   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1578
1579   vnet_device_class_t *dev_class =
1580     vnet_get_device_class (vnm, hi->dev_class_index);
1581
1582   if (!hi->hw_address)
1583     {
1584       error =
1585         clib_error_return
1586         (0, "Secondary MAC Addresses not supported for interface index %u",
1587          hw_if_index);
1588       goto done;
1589     }
1590
1591   if (dev_class->mac_addr_add_del_function)
1592     error = dev_class->mac_addr_add_del_function (hi, mac_address, is_add);
1593
1594   if (!error)
1595     {
1596       vnet_hw_interface_class_t *hw_class;
1597
1598       hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1599
1600       if (NULL != hw_class->mac_addr_add_del_function)
1601         error = hw_class->mac_addr_add_del_function (hi, mac_address, is_add);
1602     }
1603
1604   /* If no errors, add to the list of secondary MACs on the ethernet intf */
1605   if (!error)
1606     ethernet_interface_add_del_address (&ethernet_main, hw_if_index,
1607                                         mac_address, is_add);
1608
1609 done:
1610   if (error)
1611     log_err ("hw_add_del_mac_address: %U", format_clib_error, error);
1612   return error;
1613 }
1614
1615 static clib_error_t *
1616 vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm,
1617                                              u32 hw_if_index,
1618                                              const u8 * mac_address)
1619 {
1620   clib_error_t *error = 0;
1621   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1622
1623   if (hi->hw_address)
1624     {
1625       u8 *old_address = vec_dup (hi->hw_address);
1626       vnet_device_class_t *dev_class =
1627         vnet_get_device_class (vnm, hi->dev_class_index);
1628       if (dev_class->mac_addr_change_function)
1629         {
1630           error =
1631             dev_class->mac_addr_change_function (hi, old_address,
1632                                                  mac_address);
1633         }
1634       if (!error)
1635         {
1636           vnet_hw_interface_class_t *hw_class;
1637
1638           hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1639
1640           if (NULL != hw_class->mac_addr_change_function)
1641             hw_class->mac_addr_change_function (hi, old_address, mac_address);
1642         }
1643       else
1644         {
1645           error =
1646             clib_error_return (0,
1647                                "MAC Address Change is not supported on this interface");
1648         }
1649       vec_free (old_address);
1650     }
1651   else
1652     {
1653       error =
1654         clib_error_return (0,
1655                            "mac address change is not supported for interface index %u",
1656                            hw_if_index);
1657     }
1658   return error;
1659 }
1660
1661 clib_error_t *
1662 vnet_hw_interface_change_mac_address (vnet_main_t * vnm, u32 hw_if_index,
1663                                       const u8 * mac_address)
1664 {
1665   return vnet_hw_interface_change_mac_address_helper
1666     (vnm, hw_if_index, mac_address);
1667 }
1668
1669 static int
1670 vnet_sw_interface_check_table_same (u32 unnumbered_sw_if_index,
1671                                     u32 ip_sw_if_index)
1672 {
1673   if (ip4_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] !=
1674       ip4_main.fib_index_by_sw_if_index[ip_sw_if_index])
1675     return VNET_API_ERROR_UNEXPECTED_INTF_STATE;
1676
1677   if (ip4_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] !=
1678       ip4_main.mfib_index_by_sw_if_index[ip_sw_if_index])
1679     return VNET_API_ERROR_UNEXPECTED_INTF_STATE;
1680
1681   if (ip6_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] !=
1682       ip6_main.fib_index_by_sw_if_index[ip_sw_if_index])
1683     return VNET_API_ERROR_UNEXPECTED_INTF_STATE;
1684
1685   if (ip6_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] !=
1686       ip6_main.mfib_index_by_sw_if_index[ip_sw_if_index])
1687     return VNET_API_ERROR_UNEXPECTED_INTF_STATE;
1688
1689   return 0;
1690 }
1691
1692 /* update the unnumbered state of an interface*/
1693 int
1694 vnet_sw_interface_update_unnumbered (u32 unnumbered_sw_if_index,
1695                                      u32 ip_sw_if_index, u8 enable)
1696 {
1697   vnet_main_t *vnm = vnet_get_main ();
1698   vnet_sw_interface_t *si;
1699   u32 was_unnum;
1700   int rv = 0;
1701
1702   si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index);
1703   was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED);
1704
1705   if (enable)
1706     {
1707       rv = vnet_sw_interface_check_table_same (unnumbered_sw_if_index,
1708                                                ip_sw_if_index);
1709       if (rv != 0)
1710         return rv;
1711       si->flags |= VNET_SW_INTERFACE_FLAG_UNNUMBERED;
1712       si->unnumbered_sw_if_index = ip_sw_if_index;
1713
1714       ip4_main.lookup_main.if_address_pool_index_by_sw_if_index
1715         [unnumbered_sw_if_index] =
1716         ip4_main.
1717         lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1718       ip6_main.
1719         lookup_main.if_address_pool_index_by_sw_if_index
1720         [unnumbered_sw_if_index] =
1721         ip6_main.
1722         lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1723     }
1724   else
1725     {
1726       /*
1727        * Unless the interface is actually unnumbered, don't
1728        * smash e.g. if_address_pool_index_by_sw_if_index
1729        */
1730       if (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
1731         {
1732           si->flags &= ~(VNET_SW_INTERFACE_FLAG_UNNUMBERED);
1733           si->unnumbered_sw_if_index = (u32) ~0;
1734
1735           ip4_main.lookup_main
1736             .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0;
1737           ip6_main.lookup_main
1738             .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0;
1739         }
1740     }
1741
1742   if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
1743     {
1744       ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1745       ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1746     }
1747
1748   return 0;
1749 }
1750
1751 vnet_l3_packet_type_t
1752 vnet_link_to_l3_proto (vnet_link_t link)
1753 {
1754   switch (link)
1755     {
1756     case VNET_LINK_IP4:
1757       return (VNET_L3_PACKET_TYPE_IP4);
1758     case VNET_LINK_IP6:
1759       return (VNET_L3_PACKET_TYPE_IP6);
1760     case VNET_LINK_MPLS:
1761       return (VNET_L3_PACKET_TYPE_MPLS);
1762     case VNET_LINK_ARP:
1763       return (VNET_L3_PACKET_TYPE_ARP);
1764     case VNET_LINK_ETHERNET:
1765     case VNET_LINK_NSH:
1766       ASSERT (0);
1767       break;
1768     }
1769   ASSERT (0);
1770   return (0);
1771 }
1772
1773 vnet_mtu_t
1774 vnet_link_to_mtu (vnet_link_t link)
1775 {
1776   switch (link)
1777     {
1778     case VNET_LINK_IP4:
1779       return (VNET_MTU_IP4);
1780     case VNET_LINK_IP6:
1781       return (VNET_MTU_IP6);
1782     case VNET_LINK_MPLS:
1783       return (VNET_MTU_MPLS);
1784     default:
1785       return (VNET_MTU_L3);
1786     }
1787 }
1788
1789 u8 *
1790 default_build_rewrite (vnet_main_t * vnm,
1791                        u32 sw_if_index,
1792                        vnet_link_t link_type, const void *dst_address)
1793 {
1794   return (NULL);
1795 }
1796
1797 void
1798 default_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai)
1799 {
1800   ip_adjacency_t *adj;
1801
1802   adj = adj_get (ai);
1803
1804   switch (adj->lookup_next_index)
1805     {
1806     case IP_LOOKUP_NEXT_GLEAN:
1807       adj_glean_update_rewrite (ai);
1808       break;
1809     case IP_LOOKUP_NEXT_ARP:
1810     case IP_LOOKUP_NEXT_BCAST:
1811       /*
1812        * default rewrite in neighbour adj
1813        */
1814       adj_nbr_update_rewrite
1815         (ai,
1816          ADJ_NBR_REWRITE_FLAG_COMPLETE,
1817          vnet_build_rewrite_for_sw_interface (vnm,
1818                                               sw_if_index,
1819                                               adj_get_link_type (ai), NULL));
1820       break;
1821     case IP_LOOKUP_NEXT_MCAST:
1822       /*
1823        * mcast traffic also uses default rewrite string with no mcast
1824        * switch time updates.
1825        */
1826       adj_mcast_update_rewrite
1827         (ai,
1828          vnet_build_rewrite_for_sw_interface (vnm,
1829                                               sw_if_index,
1830                                               adj_get_link_type (ai),
1831                                               NULL), 0);
1832       break;
1833     case IP_LOOKUP_NEXT_DROP:
1834     case IP_LOOKUP_NEXT_PUNT:
1835     case IP_LOOKUP_NEXT_LOCAL:
1836     case IP_LOOKUP_NEXT_REWRITE:
1837     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
1838     case IP_LOOKUP_NEXT_MIDCHAIN:
1839     case IP_LOOKUP_NEXT_ICMP_ERROR:
1840     case IP_LOOKUP_N_NEXT:
1841       ASSERT (0);
1842       break;
1843     }
1844 }
1845
1846 clib_error_t *
1847 vnet_hw_interface_set_rss_queues (vnet_main_t * vnm,
1848                                   vnet_hw_interface_t * hi,
1849                                   clib_bitmap_t * bitmap)
1850 {
1851   clib_error_t *error = 0;
1852   vnet_device_class_t *dev_class =
1853     vnet_get_device_class (vnm, hi->dev_class_index);
1854
1855   if (dev_class->set_rss_queues_function)
1856     {
1857       if (clib_bitmap_count_set_bits (bitmap) == 0)
1858         {
1859           error = clib_error_return (0,
1860                                      "must assign at least one valid rss queue");
1861           goto done;
1862         }
1863
1864       error = dev_class->set_rss_queues_function (vnm, hi, bitmap);
1865     }
1866   else
1867     {
1868       error = clib_error_return (0,
1869                                  "setting rss queues is not supported on this interface");
1870     }
1871
1872   if (!error)
1873     {
1874       clib_bitmap_free (hi->rss_queues);
1875       hi->rss_queues = clib_bitmap_dup (bitmap);
1876     }
1877
1878 done:
1879   if (error)
1880     log_err ("hw_set_rss_queues: %U", format_clib_error, error);
1881   return error;
1882 }
1883
1884 int collect_detailed_interface_stats_flag = 0;
1885
1886 void
1887 collect_detailed_interface_stats_flag_set (void)
1888 {
1889   collect_detailed_interface_stats_flag = 1;
1890 }
1891
1892 void
1893 collect_detailed_interface_stats_flag_clear (void)
1894 {
1895   collect_detailed_interface_stats_flag = 0;
1896 }
1897
1898 static clib_error_t *
1899 collect_detailed_interface_stats_cli (vlib_main_t * vm,
1900                                       unformat_input_t * input,
1901                                       vlib_cli_command_t * cmd)
1902 {
1903   unformat_input_t _line_input, *line_input = &_line_input;
1904   clib_error_t *error = NULL;
1905
1906   /* Get a line of input. */
1907   if (!unformat_user (input, unformat_line_input, line_input))
1908     return clib_error_return (0, "expected enable | disable");
1909
1910   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1911     {
1912       if (unformat (line_input, "enable") || unformat (line_input, "on"))
1913         collect_detailed_interface_stats_flag_set ();
1914       else if (unformat (line_input, "disable")
1915                || unformat (line_input, "off"))
1916         collect_detailed_interface_stats_flag_clear ();
1917       else
1918         {
1919           error = clib_error_return (0, "unknown input `%U'",
1920                                      format_unformat_error, line_input);
1921           goto done;
1922         }
1923     }
1924
1925 done:
1926   unformat_free (line_input);
1927   return error;
1928 }
1929
1930 VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = {
1931   .path = "interface collect detailed-stats",
1932   .short_help = "interface collect detailed-stats <enable|disable>",
1933   .function = collect_detailed_interface_stats_cli,
1934 };
1935
1936 /*
1937  * fd.io coding-style-patch-verification: ON
1938  *
1939  * Local Variables:
1940  * eval: (c-set-style "gnu")
1941  * End:
1942  */