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
  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, 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_vrf (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, 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, 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             }
 268         }
 269     }
 270
 271   /* release allocated memory */
 272   for (afi = AFI_IP; afi <= AFI_IP6; afi++)
 273     {
 274       void *table_info;
 275
 276       for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 277         {
 278           table = zvrf->table[afi][safi];
 279           table_info = table->info;
 280           route_table_finish (table);
 281           XFREE (MTYPE_RIB_TABLE_INFO, table_info);
 282
 283           table = zvrf->stable[afi][safi];
 284           route_table_finish (table);
 285         }
 286
 287       for (table_id = 0; table_id < ZEBRA_KERNEL_TABLE_MAX; table_id++)
 288         if (zvrf->other_table[afi][table_id])
 289           {
 290             table = zvrf->other_table[afi][table_id];
 291             table_info = table->info;
 292             route_table_finish (table);
 293             XFREE (MTYPE_RIB_TABLE_INFO, table_info);
 294           }
 295
 296       route_table_finish (zvrf->rnh_table[afi]);
 297       route_table_finish (zvrf->import_check_table[afi]);
 298     }
 299   list_delete_all_node (zvrf->rid_all_sorted_list);
 300   list_delete_all_node (zvrf->rid_lo_sorted_list);
 301   XFREE (MTYPE_ZEBRA_VRF, zvrf);
 302   vrf->info = NULL;
 303
 304   return 0;
 305 }
 306
 307 /* Lookup the routing table in a VRF based on both VRF-Id and table-id.
 308  * NOTE: Table-id is relevant only in the Default VRF.
 309  */
 310 struct route_table *
 311 zebra_vrf_table_with_table_id (afi_t afi, safi_t safi,
 312                                vrf_id_t vrf_id, u_int32_t table_id)
 313 {
 314   struct route_table *table = NULL;
 315
 316   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 317     return NULL;
 318
 319   if (vrf_id == VRF_DEFAULT)
 320     {
 321       if (table_id == RT_TABLE_MAIN ||
 322           table_id == zebrad.rtm_table_default)
 323         table = zebra_vrf_table (afi, safi, vrf_id);
 324       else
 325         table = zebra_vrf_other_route_table (afi, table_id, vrf_id);
 326     }
 327   else
 328       table = zebra_vrf_table (afi, safi, vrf_id);
 329
 330   return table;
 331 }
 332
 333 static void
 334 zebra_rtable_node_destroy (route_table_delegate_t *delegate,
 335                            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   route_node_destroy (delegate, table, node);
 346 }
 347
 348 static void
 349 zebra_stable_node_destroy (route_table_delegate_t *delegate,
 350                            struct route_table *table, struct route_node *node)
 351 {
 352   struct static_route *si, *next;
 353
 354   if (node->info)
 355     for (si = node->info; si; si = next)
 356       {
 357         next = si->next;
 358         XFREE (MTYPE_STATIC_ROUTE, si);
 359       }
 360
 361   route_node_destroy (delegate, table, node);
 362 }
 363
 364 static void
 365 zebra_rnhtable_node_destroy (route_table_delegate_t *delegate,
 366                              struct route_table *table, struct route_node *node)
 367 {
 368   if (node->info)
 369     zebra_free_rnh (node->info);
 370
 371   route_node_destroy (delegate, table, node);
 372 }
 373
 374 route_table_delegate_t zebra_rtable_delegate = {
 375   .create_node = route_node_create,
 376   .destroy_node = zebra_rtable_node_destroy
 377 };
 378
 379 route_table_delegate_t zebra_stable_delegate = {
 380   .create_node = route_node_create,
 381   .destroy_node = zebra_stable_node_destroy
 382 };
 383
 384 route_table_delegate_t zebra_rnhtable_delegate = {
 385   .create_node = route_node_create,
 386   .destroy_node = zebra_rnhtable_node_destroy
 387 };
 388
 389 /*
 390  * Create a routing table for the specific AFI/SAFI in the given VRF.
 391  */
 392 static void
 393 zebra_vrf_table_create (struct zebra_vrf *zvrf, afi_t afi, safi_t safi)
 394 {
 395   rib_table_info_t *info;
 396   struct route_table *table;
 397
 398   assert (!zvrf->table[afi][safi]);
 399
 400   table = route_table_init_with_delegate (&zebra_rtable_delegate);
 401   zvrf->table[afi][safi] = table;
 402
 403   info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info));
 404   info->zvrf = zvrf;
 405   info->afi = afi;
 406   info->safi = safi;
 407   table->info = info;
 408 }
 409
 410 /* Allocate new zebra VRF. */
 411 struct zebra_vrf *
 412 zebra_vrf_alloc (void)
 413 {
 414   struct zebra_vrf *zvrf;
 415   afi_t afi;
 416   safi_t safi;
 417
 418   zvrf = XCALLOC (MTYPE_ZEBRA_VRF, sizeof (struct zebra_vrf));
 419
 420   for (afi = AFI_IP; afi <= AFI_IP6; afi++)
 421     {
 422       for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 423         {
 424           zebra_vrf_table_create (zvrf, afi, safi);
 425           zvrf->stable[afi][safi] =
 426                 route_table_init_with_delegate (&zebra_stable_delegate);
 427         }
 428
 429       zvrf->rnh_table[afi] =
 430         route_table_init_with_delegate (&zebra_rnhtable_delegate);
 431       zvrf->import_check_table[afi] =
 432         route_table_init_with_delegate (&zebra_rnhtable_delegate);
 433     }
 434
 435   zebra_mpls_init_tables (zvrf);
 436
 437   return zvrf;
 438 }
 439
 440 /* Lookup VRF by identifier.  */
 441 struct zebra_vrf *
 442 zebra_vrf_lookup_by_id (vrf_id_t vrf_id)
 443 {
 444   return vrf_info_lookup (vrf_id);
 445 }
 446
 447 /* Lookup VRF by name.  */
 448 struct zebra_vrf *
 449 zebra_vrf_lookup_by_name (const char *name)
 450 {
 451   struct vrf *vrf;
 452
 453   if (!name)
 454     name = VRF_DEFAULT_NAME;
 455
 456   vrf = vrf_lookup_by_name (name);
 457   if (vrf)
 458     return ((struct zebra_vrf *) vrf->info);
 459
 460   return NULL;
 461 }
 462
 463 /* Lookup the routing table in an enabled VRF. */
 464 struct route_table *
 465 zebra_vrf_table (afi_t afi, safi_t safi, vrf_id_t vrf_id)
 466 {
 467   struct zebra_vrf *zvrf = vrf_info_lookup (vrf_id);
 468
 469   if (!zvrf)
 470     return NULL;
 471
 472   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 473     return NULL;
 474
 475   return zvrf->table[afi][safi];
 476 }
 477
 478 /* Lookup the static routing table in a VRF. */
 479 struct route_table *
 480 zebra_vrf_static_table (afi_t afi, safi_t safi, struct zebra_vrf *zvrf)
 481 {
 482   if (!zvrf)
 483     return NULL;
 484
 485   if (afi >= AFI_MAX || safi >= SAFI_MAX)
 486     return NULL;
 487
 488   return zvrf->stable[afi][safi];
 489 }
 490
 491 struct route_table *
 492 zebra_vrf_other_route_table (afi_t afi, u_int32_t table_id, vrf_id_t vrf_id)
 493 {
 494   struct zebra_vrf *zvrf;
 495   rib_table_info_t *info;
 496   struct route_table *table;
 497
 498   zvrf = vrf_info_lookup (vrf_id);
 499   if (! zvrf)
 500     return NULL;
 501
 502   if(afi >= AFI_MAX)
 503     return NULL;
 504
 505   if (table_id >= ZEBRA_KERNEL_TABLE_MAX)
 506     return NULL;
 507
 508   if ((vrf_id == VRF_DEFAULT) && (table_id != RT_TABLE_MAIN) && (table_id != zebrad.rtm_table_default))
 509     {
 510       if (zvrf->other_table[afi][table_id] == NULL)
 511         {
 512           table = route_table_init();
 513           info = XCALLOC (MTYPE_RIB_TABLE_INFO, sizeof (*info));
 514           info->zvrf = zvrf;
 515           info->afi = afi;
 516           info->safi = SAFI_UNICAST;
 517           table->info = info;
 518           zvrf->other_table[afi][table_id] = table;
 519         }
 520
 521       return (zvrf->other_table[afi][table_id]);
 522     }
 523
 524   return zvrf->table[afi][SAFI_UNICAST];
 525 }
 526
 527 static int
 528 vrf_config_write (struct vty *vty)
 529 {
 530   struct vrf *vrf;
 531   struct zebra_vrf *zvrf;
 532
 533   RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
 534     {
 535       zvrf = vrf->info;
 536       if (! zvrf || strcmp (zvrf_name (zvrf), VRF_DEFAULT_NAME))
 537         {
 538           vty_out (vty, "vrf %s%s", zvrf_name (zvrf), VTY_NEWLINE);
 539           vty_out (vty, "!%s", VTY_NEWLINE);
 540         }
 541     }
 542   return 0;
 543 }
 544
 545 /* Zebra VRF initialization. */
 546 void
 547 zebra_vrf_init (void)
 548 {
 549   vrf_add_hook (VRF_NEW_HOOK, zebra_vrf_new);
 550   vrf_add_hook (VRF_ENABLE_HOOK, zebra_vrf_enable);
 551   vrf_add_hook (VRF_DISABLE_HOOK, zebra_vrf_disable);
 552   vrf_add_hook (VRF_DELETE_HOOK, zebra_vrf_delete);
 553
 554   vrf_init ();
 555   vrf_cmd_init (vrf_config_write);
 556 }