zebra/zebra_vrf.c

   1 /*
   2  * Copyright (C) 2016 CumulusNetworks
   3  *                    Donald Sharp
   4  *
   5  * This file is part of Quagga
   6  *
   7  * Quagga is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * Quagga is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20  * 02111-1307, USA.
  21  */
  22 #include <zebra.h>
  23
  24 #include "log.h"
  25 #include "linklist.h"
  26 #include "command.h"
  27 #include "memory.h"
  28 #include "srcdest_table.h"
  29
  30 #include "vty.h"
  31 #include "zebra/debug.h"
  32 #include "zebra/zserv.h"
  33 #include "zebra/rib.h"
  34 #include "zebra/zebra_vrf.h"
  35 #include "zebra/zebra_rnh.h"
  36 #include "zebra/router-id.h"
  37 #include "zebra/zebra_memory.h"
  38 #include "zebra/zebra_static.h"
  39 #include "zebra/interface.h"
  40 #include "zebra/zebra_mpls.h"
  41
  42 extern struct zebra_t zebrad;
  43
  44 /* VRF information update. */
  45 static void
  46 zebra_vrf_add_update (struct zebra_vrf *zvrf)
  47 {
  48   struct listnode *node, *nnode;
  49   struct zserv *client;
  50
  51   if (IS_ZEBRA_DEBUG_EVENT)
  52     zlog_debug ("MESSAGE: ZEBRA_VRF_ADD %s", zvrf_name (zvrf));
  53
  54   for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
  55     zsend_vrf_add (client, zvrf);
  56 }
  57
  58 static void
  59 zebra_vrf_delete_update (struct zebra_vrf *zvrf)
  60 {
  61   struct listnode *node, *nnode;
  62   struct zserv *client;
  63
  64   if (IS_ZEBRA_DEBUG_EVENT)
  65     zlog_debug ("MESSAGE: ZEBRA_VRF_DELETE %s", zvrf_name (zvrf));
  66
  67   for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
  68     zsend_vrf_delete (client, zvrf);
  69 }
  70
  71 void
  72 zebra_vrf_update_all (struct zserv *client)
  73 {
  74   struct vrf *vrf;
  75
  76   RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
  77     {
  78       if (vrf->vrf_id)
  79         zsend_vrf_add (client, vrf_info_lookup (vrf->vrf_id));
  80     }
  81 }
  82
  83 /* Callback upon creating a new VRF. */
  84 static int
  85 zebra_vrf_new (struct vrf *vrf)
  86 {
  87   struct zebra_vrf *zvrf;
  88
  89   if (IS_ZEBRA_DEBUG_EVENT)
  90     zlog_info ("ZVRF %s with id %u", vrf->name, vrf->vrf_id);
  91
  92   zvrf = zebra_vrf_alloc ();
  93   zvrf->zns = zebra_ns_lookup (NS_DEFAULT); /* Point to the global (single) NS */
  94   router_id_init (zvrf);
  95   vrf->info = zvrf;
  96   zvrf->vrf = vrf;
  97
  98   return 0;
  99 }
 100
 101 /*
 102  * Moving an interface amongst different vrf's
 103  * causes the interface to get a new ifindex
 104  * so we need to find static routes with
 105  * the old ifindex and replace with new
 106  * ifindex to insert back into the table
 107  */
 108 void
 109 zebra_vrf_static_route_interface_fixup (struct interface *ifp)
 110 {
 111   afi_t afi;
 112   safi_t safi;
 113   struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id (ifp->vrf_id);
 114   struct route_table *stable = NULL;
 115   struct route_node *rn = NULL;
 116   struct static_route *si = NULL;
 117
 118   if (!zvrf)
 119     return;
 120
 121   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 122     {
 123       for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 124         {
 125           stable = zvrf->stable[afi][safi];
 126           if (stable)
 127             for (rn = route_top (stable); rn; rn = route_next (rn))
 128               {
 129                 if (rn->info)
 130                   {
 131                     si = rn->info;
 132                     if ((strcmp (si->ifname, ifp->name) == 0) &&
 133                         (si->ifindex != ifp->ifindex))
 134                       {
 135                         si->ifindex = ifp->ifindex;
 136                         static_install_route (afi, safi, &rn->p, NULL, si);
 137                       }
 138                   }
 139               }
 140         }
 141     }
 142
 143 }
 144
 145 /* Callback upon enabling a VRF. */
 146 static int
 147 zebra_vrf_enable (struct vrf *vrf)
 148 {
 149   struct zebra_vrf *zvrf = vrf->info;
 150   struct route_table *stable;
 151   struct route_node *rn;
 152   struct static_route *si;
 153   struct interface *ifp;
 154   afi_t afi;
 155   safi_t safi;
 156
 157   assert (zvrf);
 158
 159   zebra_vrf_add_update (zvrf);
 160
 161   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 162     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 163       {
 164         stable = zvrf->stable[afi][safi];
 165         if (! stable)
 166           continue;
 167
 168         for (rn = route_top (stable); rn; rn = route_next (rn))
 169           for (si = rn->info; si; si = si->next)
 170             {
 171               si->vrf_id = vrf->vrf_id;
 172               if (si->ifindex)
 173                 {
 174                   ifp = if_lookup_by_name (si->ifname, si->vrf_id);
 175                   if (ifp)
 176                     si->ifindex = ifp->ifindex;
 177                   else
 178                     continue;
 179                 }
 180               static_install_route (afi, safi, &rn->p, NULL, si);
 181             }
 182       }
 183
 184   return 0;
 185 }
 186
 187 /* Callback upon disabling a VRF. */
 188 static int
 189 zebra_vrf_disable (struct vrf *vrf)
 190 {
 191   struct zebra_vrf *zvrf = vrf->info;
 192   struct route_table *stable;
 193   struct route_node *rn;
 194   struct static_route *si;
 195   afi_t afi;
 196   safi_t safi;
 197
 198   if (IS_ZEBRA_DEBUG_KERNEL)
 199     zlog_debug ("VRF %s id %u is now disabled.",
 200                 zvrf_name (zvrf), zvrf_id (zvrf));
 201
 202   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 203     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
 204       {
 205         stable = zvrf->stable[afi][safi];
 206         if (! stable)
 207           continue;
 208
 209         for (rn = route_top (stable); rn; rn = route_next (rn))
 210           for (si = rn->info; si; si = si->next)
 211             static_uninstall_route(afi, safi, &rn->p, NULL, si);
 212       }
 213
 214   return 0;
 215 }
 216
 217 static int
 218 zebra_vrf_delete (struct vrf *vrf)
 219 {
 220   struct zebra_vrf *zvrf = vrf->info;
 221   struct route_table *table;
 222   u_int32_t table_id;
 223   afi_t afi;
 224   safi_t safi;
 225   unsigned i;
 226
 227   assert (zvrf);
 228
 229   zebra_vrf_delete_update (zvrf);
 230
 231   /* uninstall everything */
 232   if (! CHECK_FLAG (zvrf->flags, ZEBRA_VRF_RETAIN))
 233     {
 234       struct listnode *node;
 235       struct interface *ifp;
 236
 237       for (afi = AFI_IP; afi <= AFI_IP6; afi++)
 238         {
 239           for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 240             rib_close_table (zvrf->table[afi][safi]);
 241
 242           if (vrf->vrf_id == VRF_DEFAULT)
 243             for (table_id = 0; table_id < ZEBRA_KERNEL_TABLE_MAX; table_id++)
 244               if (zvrf->other_table[afi][table_id])
 245                 rib_close_table (zvrf->other_table[afi][table_id]);
 246         }
 247
 248       zebra_mpls_close_tables (zvrf);
 249
 250       for (ALL_LIST_ELEMENTS_RO (vrf->iflist, node, ifp))
 251         if_nbr_ipv6ll_to_ipv4ll_neigh_del_all (ifp);
 252     }
 253
 254   /* clean-up work queues */
 255   for (i = 0; i < MQ_SIZE; i++)
 256     {
 257       struct listnode *lnode, *nnode;
 258       struct route_node *rnode;
 259       rib_dest_t *dest;
 260
 261       for (ALL_LIST_ELEMENTS (zebrad.mq->subq[i], lnode, nnode, rnode))
 262         {
 263           dest = rib_dest_from_rnode (rnode);
 264           if (dest && rib_dest_vrf (dest) == zvrf)
 265             {
 266               route_unlock_node (rnode);
 267               list_delete_node (zebrad.mq->subq[i], lnode);
 268               zebrad.mq->size--;
 269             }
 270         }
 271     }
 272
 273   /* release allocated memory */
 274   for (afi = AFI_IP; afi <= AFI_IP6; afi++)
 275     {
 276       void *table_info;
 277
 278       for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 279         {
 280           table = zvrf->table[afi][safi];
 281           table_info = table->info;
 282           route_table_finish (table);
 283           XFREE (MTYPE_RIB_TABLE_INFO, table_info);
 284
 285           table = zvrf->stable[afi][safi];
 286           route_table_finish (table);
 287         }
 288
 289       for (table_id = 0; table_id < ZEBRA_KERNEL_TABLE_MAX; table_id++)
 290         if (zvrf->other_table[afi][table_id])
 291           {
 292             table = zvrf->other_table[afi][table_id];
 293             table_info = table->info;
 294             route_table_finish (table);
 295             XFREE (MTYPE_RIB_TABLE_INFO, table_info);
 296           }
 297
 298       route_table_finish (zvrf->rnh_table[afi]);
 299       route_table_finish (zvrf->import_check_table[afi]);
 300     }
 301   list_delete_all_node (zvrf->rid_all_sorted_list);
 302   list_delete_all_node (zvrf->rid_lo_sorted_list);
 303   XFREE (MTYPE_ZEBRA_VRF, zvrf);
 304   vrf->info = NULL;
 305
 306   return 0;
 307 }
 308
 309 /* Lookup the routing table in a VRF based on both VRF-Id and table-id.
 310  * NOTE: Table-id is relevant only in the Default VRF.
 311  */
 312 struct route_table *
 313 zebra_vrf_table_with_table_id (afi_t afi, safi_t safi,
 314                                vrf_id_t vrf_id, u_int32_t table_id)
 315 {
 316   struct route_table *table = NULL;
 317
 318   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 319     return NULL;
 320
 321   if (vrf_id == VRF_DEFAULT)
 322     {
 323       if (table_id == RT_TABLE_MAIN ||
 324           table_id == zebrad.rtm_table_default)
 325         table = zebra_vrf_table (afi, safi, vrf_id);
 326       else
 327         table = zebra_vrf_other_route_table (afi, table_id, vrf_id);
 328     }
 329   else
 330       table = zebra_vrf_table (afi, safi, vrf_id);
 331
 332   return table;
 333 }
 334
 335 static void
 336 zebra_rtable_node_cleanup (struct route_table *table, struct route_node *node)
 337 {
 338   struct rib *rib, *next;
 339
 340   RNODE_FOREACH_RIB_SAFE (node, rib, next)
 341     rib_unlink (node, rib);
 342
 343   if (node->info)
 344     XFREE (MTYPE_RIB_DEST, node->info);
 345 }
 346
 347 static void
 348 zebra_stable_node_cleanup (struct route_table *table, struct route_node *node)
 349 {
 350   struct static_route *si, *next;
 351
 352   if (node->info)
 353     for (si = node->info; si; si = next)
 354       {
 355         next = si->next;
 356         XFREE (MTYPE_STATIC_ROUTE, si);
 357       }
 358 }
 359
 360 static void
 361 zebra_rnhtable_node_cleanup (struct route_table *table, struct route_node *node)
 362 {
 363   if (node->info)
 364     zebra_free_rnh (node->info);
 365 }
 366
 367 /*
 368  * Create a routing table for the specific AFI/SAFI in the given VRF.
 369  */
 370 static void
 371 zebra_vrf_table_create (struct zebra_vrf *zvrf, afi_t afi, safi_t safi)
 372 {
 373   rib_table_info_t *info;
 374   struct route_table *table;
 375
 376   assert (!zvrf->table[afi][safi]);
 377
 378   if (afi == AFI_IP6)
 379     table = srcdest_table_init();
 380   else
 381     table = route_table_init();
 382   table->cleanup = zebra_rtable_node_cleanup;
 383   zvrf->table[afi][safi] = table;
 384
 385   info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info));
 386   info->zvrf = zvrf;
 387   info->afi = afi;
 388   info->safi = safi;
 389   table->info = info;
 390 }
 391
 392 /* Allocate new zebra VRF. */
 393 struct zebra_vrf *
 394 zebra_vrf_alloc (void)
 395 {
 396   struct zebra_vrf *zvrf;
 397   afi_t afi;
 398   safi_t safi;
 399   struct route_table *table;
 400
 401   zvrf = XCALLOC (MTYPE_ZEBRA_VRF, sizeof (struct zebra_vrf));
 402
 403   for (afi = AFI_IP; afi <= AFI_IP6; afi++)
 404     {
 405       for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 406         {
 407           zebra_vrf_table_create (zvrf, afi, safi);
 408           if (afi == AFI_IP6)
 409             table = srcdest_table_init();
 410           else
 411             table = route_table_init();
 412           table->cleanup = zebra_stable_node_cleanup;
 413           zvrf->stable[afi][safi] = table;
 414         }
 415
 416       table = route_table_init();
 417       table->cleanup = zebra_rnhtable_node_cleanup;
 418       zvrf->rnh_table[afi] = table;
 419
 420       table = route_table_init();
 421       table->cleanup = zebra_rnhtable_node_cleanup;
 422       zvrf->import_check_table[afi] = table;
 423     }
 424
 425   zebra_mpls_init_tables (zvrf);
 426
 427   return zvrf;
 428 }
 429
 430 /* Lookup VRF by identifier.  */
 431 struct zebra_vrf *
 432 zebra_vrf_lookup_by_id (vrf_id_t vrf_id)
 433 {
 434   return vrf_info_lookup (vrf_id);
 435 }
 436
 437 /* Lookup VRF by name.  */
 438 struct zebra_vrf *
 439 zebra_vrf_lookup_by_name (const char *name)
 440 {
 441   struct vrf *vrf;
 442
 443   if (!name)
 444     name = VRF_DEFAULT_NAME;
 445
 446   vrf = vrf_lookup_by_name (name);
 447   if (vrf)
 448     return ((struct zebra_vrf *) vrf->info);
 449
 450   return NULL;
 451 }
 452
 453 /* Lookup the routing table in an enabled VRF. */
 454 struct route_table *
 455 zebra_vrf_table (afi_t afi, safi_t safi, vrf_id_t vrf_id)
 456 {
 457   struct zebra_vrf *zvrf = vrf_info_lookup (vrf_id);
 458
 459   if (!zvrf)
 460     return NULL;
 461
 462   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 463     return NULL;
 464
 465   return zvrf->table[afi][safi];
 466 }
 467
 468 /* Lookup the static routing table in a VRF. */
 469 struct route_table *
 470 zebra_vrf_static_table (afi_t afi, safi_t safi, struct zebra_vrf *zvrf)
 471 {
 472   if (!zvrf)
 473     return NULL;
 474
 475   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 476     return NULL;
 477
 478   return zvrf->stable[afi][safi];
 479 }
 480
 481 struct route_table *
 482 zebra_vrf_other_route_table (afi_t afi, u_int32_t table_id, vrf_id_t vrf_id)
 483 {
 484   struct zebra_vrf *zvrf;
 485   rib_table_info_t *info;
 486   struct route_table *table;
 487
 488   zvrf = vrf_info_lookup (vrf_id);
 489   if (! zvrf)
 490     return NULL;
 491
 492   if(afi >= AFI_MAX)
 493     return NULL;
 494
 495   if (table_id >= ZEBRA_KERNEL_TABLE_MAX)
 496     return NULL;
 497
 498   if ((vrf_id == VRF_DEFAULT) && (table_id != RT_TABLE_MAIN) && (table_id != zebrad.rtm_table_default))
 499     {
 500       if (zvrf->other_table[afi][table_id] == NULL)
 501         {
 502           table = (afi == AFI_IP6) ? srcdest_table_init() : route_table_init();
 503           info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info));
 504           info->zvrf = zvrf;
 505           info->afi = afi;
 506           info->safi = SAFI_UNICAST;
 507           table->info = info;
 508           zvrf->other_table[afi][table_id] = table;
 509         }
 510
 511       return (zvrf->other_table[afi][table_id]);
 512     }
 513
 514   return zvrf->table[afi][SAFI_UNICAST];
 515 }
 516
 517 static int
 518 vrf_config_write (struct vty *vty)
 519 {
 520   struct vrf *vrf;
 521   struct zebra_vrf *zvrf;
 522
 523   RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
 524     {
 525       zvrf = vrf->info;
 526       if (! zvrf || strcmp (zvrf_name (zvrf), VRF_DEFAULT_NAME))
 527         {
 528           vty_out (vty, "vrf %s%s", zvrf_name (zvrf), VTY_NEWLINE);
 529           vty_out (vty, "!%s", VTY_NEWLINE);
 530         }
 531     }
 532   return 0;
 533 }
 534
 535 /* Zebra VRF initialization. */
 536 void
 537 zebra_vrf_init (void)
 538 {
 539   vrf_add_hook (VRF_NEW_HOOK, zebra_vrf_new);
 540   vrf_add_hook (VRF_ENABLE_HOOK, zebra_vrf_enable);
 541   vrf_add_hook (VRF_DISABLE_HOOK, zebra_vrf_disable);
 542   vrf_add_hook (VRF_DELETE_HOOK, zebra_vrf_delete);
 543
 544   vrf_init ();
 545   vrf_cmd_init (vrf_config_write);
 546 }