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