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 #include "vrf.h"
  29 #include "vty.h"
  30
  31 #include "zebra/debug.h"
  32 #include "zebra/zapi_msg.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/interface.h"
  39 #include "zebra/zebra_mpls.h"
  40 #include "zebra/zebra_vxlan.h"
  41 #include "zebra/zebra_netns_notify.h"
  42
  43 extern struct zebra_t zebrad;
  44
  45 static void zebra_vrf_table_create(struct zebra_vrf *zvrf, afi_t afi,
  46                                    safi_t safi);
  47 static void zebra_rnhtable_node_cleanup(struct route_table *table,
  48                                         struct route_node *node);
  49
  50 /* VRF information update. */
  51 static void zebra_vrf_add_update(struct zebra_vrf *zvrf)
  52 {
  53         struct listnode *node, *nnode;
  54         struct zserv *client;
  55
  56         if (IS_ZEBRA_DEBUG_EVENT)
  57                 zlog_debug("MESSAGE: ZEBRA_VRF_ADD %s", zvrf_name(zvrf));
  58
  59         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
  60                 zsend_vrf_add(client, zvrf);
  61 }
  62
  63 static void zebra_vrf_delete_update(struct zebra_vrf *zvrf)
  64 {
  65         struct listnode *node, *nnode;
  66         struct zserv *client;
  67
  68         if (IS_ZEBRA_DEBUG_EVENT)
  69                 zlog_debug("MESSAGE: ZEBRA_VRF_DELETE %s", zvrf_name(zvrf));
  70
  71         for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
  72                 zsend_vrf_delete(client, zvrf);
  73 }
  74
  75 void zebra_vrf_update_all(struct zserv *client)
  76 {
  77         struct vrf *vrf;
  78
  79         RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
  80                 if (vrf->vrf_id != VRF_UNKNOWN)
  81                         zsend_vrf_add(client, vrf_info_lookup(vrf->vrf_id));
  82         }
  83 }
  84
  85 /* Callback upon creating a new VRF. */
  86 static int zebra_vrf_new(struct vrf *vrf)
  87 {
  88         struct zebra_vrf *zvrf;
  89
  90         if (IS_ZEBRA_DEBUG_EVENT)
  91                 zlog_info("VRF %s created, id %u", vrf->name, vrf->vrf_id);
  92
  93         zvrf = zebra_vrf_alloc();
  94         vrf->info = zvrf;
  95         zvrf->vrf = vrf;
  96         router_id_init(zvrf);
  97         return 0;
  98 }
  99
 100 /* Callback upon enabling a VRF. */
 101 static int zebra_vrf_enable(struct vrf *vrf)
 102 {
 103         struct zebra_vrf *zvrf = vrf->info;
 104         struct route_table *table;
 105         afi_t afi;
 106         safi_t safi;
 107
 108         assert(zvrf);
 109         if (IS_ZEBRA_DEBUG_EVENT)
 110                 zlog_debug("VRF %s id %u is now active", zvrf_name(zvrf),
 111                            zvrf_id(zvrf));
 112
 113         if (vrf_is_backend_netns())
 114                 zvrf->zns = zebra_ns_lookup((ns_id_t)vrf->vrf_id);
 115         else
 116                 zvrf->zns = zebra_ns_lookup(NS_DEFAULT);
 117         /* Inform clients that the VRF is now active. This is an
 118          * add for the clients.
 119          */
 120
 121         zebra_vrf_add_update(zvrf);
 122         /* Allocate tables */
 123         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 124                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 125                         zebra_vrf_table_create(zvrf, afi, safi);
 126
 127                 table = route_table_init();
 128                 table->cleanup = zebra_rnhtable_node_cleanup;
 129                 zvrf->rnh_table[afi] = table;
 130
 131                 table = route_table_init();
 132                 table->cleanup = zebra_rnhtable_node_cleanup;
 133                 zvrf->import_check_table[afi] = table;
 134         }
 135
 136         /* Kick off any VxLAN-EVPN processing. */
 137         zebra_vxlan_vrf_enable(zvrf);
 138
 139         return 0;
 140 }
 141
 142 /* Callback upon disabling a VRF. */
 143 static int zebra_vrf_disable(struct vrf *vrf)
 144 {
 145         struct zebra_vrf *zvrf = vrf->info;
 146         struct route_table *table;
 147         struct interface *ifp;
 148         afi_t afi;
 149         safi_t safi;
 150         unsigned i;
 151
 152         assert(zvrf);
 153         if (IS_ZEBRA_DEBUG_EVENT)
 154                 zlog_debug("VRF %s id %u is now inactive", zvrf_name(zvrf),
 155                            zvrf_id(zvrf));
 156
 157         /* Stop any VxLAN-EVPN processing. */
 158         zebra_vxlan_vrf_disable(zvrf);
 159
 160         /* Inform clients that the VRF is now inactive. This is a
 161          * delete for the clients.
 162          */
 163         zebra_vrf_delete_update(zvrf);
 164
 165         /* If asked to retain routes, there's nothing more to do. */
 166         if (CHECK_FLAG(zvrf->flags, ZEBRA_VRF_RETAIN))
 167                 return 0;
 168
 169         /* Remove all routes. */
 170         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 171                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++)
 172                         rib_close_table(zvrf->table[afi][safi]);
 173         }
 174
 175         /* Cleanup Vxlan, MPLS and PW tables. */
 176         zebra_vxlan_cleanup_tables(zvrf);
 177         zebra_mpls_cleanup_tables(zvrf);
 178         zebra_pw_exit(zvrf);
 179
 180         /* Remove link-local IPv4 addresses created for BGP unnumbered peering.
 181          */
 182         FOR_ALL_INTERFACES (vrf, ifp)
 183                 if_nbr_ipv6ll_to_ipv4ll_neigh_del_all(ifp);
 184
 185         /* clean-up work queues */
 186         for (i = 0; i < MQ_SIZE; i++) {
 187                 struct listnode *lnode, *nnode;
 188                 struct route_node *rnode;
 189                 rib_dest_t *dest;
 190
 191                 for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i], lnode, nnode,
 192                                        rnode)) {
 193                         dest = rib_dest_from_rnode(rnode);
 194                         if (dest && rib_dest_vrf(dest) == zvrf) {
 195                                 route_unlock_node(rnode);
 196                                 list_delete_node(zebrad.mq->subq[i], lnode);
 197                                 zebrad.mq->size--;
 198                         }
 199                 }
 200         }
 201
 202         /* Cleanup (free) routing tables and NHT tables. */
 203         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 204                 void *table_info;
 205
 206                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
 207                         table = zvrf->table[afi][safi];
 208                         table_info = table->info;
 209                         route_table_finish(table);
 210                         XFREE(MTYPE_RIB_TABLE_INFO, table_info);
 211                         zvrf->table[afi][safi] = NULL;
 212                 }
 213
 214                 route_table_finish(zvrf->rnh_table[afi]);
 215                 zvrf->rnh_table[afi] = NULL;
 216                 route_table_finish(zvrf->import_check_table[afi]);
 217                 zvrf->import_check_table[afi] = NULL;
 218         }
 219
 220         return 0;
 221 }
 222
 223 static int zebra_vrf_delete(struct vrf *vrf)
 224 {
 225         struct zebra_vrf *zvrf = vrf->info;
 226         struct route_table *table;
 227         afi_t afi;
 228         safi_t safi;
 229         unsigned i;
 230
 231         assert(zvrf);
 232         if (IS_ZEBRA_DEBUG_EVENT)
 233                 zlog_debug("VRF %s id %u deleted", zvrf_name(zvrf),
 234                            zvrf_id(zvrf));
 235
 236         /* clean-up work queues */
 237         for (i = 0; i < MQ_SIZE; i++) {
 238                 struct listnode *lnode, *nnode;
 239                 struct route_node *rnode;
 240                 rib_dest_t *dest;
 241
 242                 for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i], lnode, nnode,
 243                                        rnode)) {
 244                         dest = rib_dest_from_rnode(rnode);
 245                         if (dest && rib_dest_vrf(dest) == zvrf) {
 246                                 route_unlock_node(rnode);
 247                                 list_delete_node(zebrad.mq->subq[i], lnode);
 248                                 zebrad.mq->size--;
 249                         }
 250                 }
 251         }
 252
 253         /* Free Vxlan and MPLS. */
 254         zebra_vxlan_close_tables(zvrf);
 255         zebra_mpls_close_tables(zvrf);
 256
 257         /* release allocated memory */
 258         for (afi = AFI_IP; afi <= AFI_IP6; afi++) {
 259                 void *table_info;
 260
 261                 for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) {
 262                         table = zvrf->table[afi][safi];
 263                         if (table) {
 264                                 table_info = table->info;
 265                                 route_table_finish(table);
 266                                 XFREE(MTYPE_RIB_TABLE_INFO, table_info);
 267                         }
 268                 }
 269
 270                 route_table_finish(zvrf->rnh_table[afi]);
 271                 route_table_finish(zvrf->import_check_table[afi]);
 272         }
 273
 274         /* Cleanup EVPN states for vrf */
 275         zebra_vxlan_vrf_delete(zvrf);
 276
 277         list_delete_all_node(zvrf->rid_all_sorted_list);
 278         list_delete_all_node(zvrf->rid_lo_sorted_list);
 279         XFREE(MTYPE_ZEBRA_VRF, zvrf);
 280         vrf->info = NULL;
 281
 282         return 0;
 283 }
 284
 285 /* Return if this VRF has any FRR configuration or not.
 286  * IMPORTANT: This function needs to be updated when additional configuration
 287  * is added for a VRF.
 288  */
 289 int zebra_vrf_has_config(struct zebra_vrf *zvrf)
 290 {
 291         /* EVPN L3-VNI? */
 292         if (zvrf->l3vni)
 293                 return 1;
 294
 295         return 0;
 296 }
 297
 298 /* Lookup the routing table in a VRF based on both VRF-Id and table-id.
 299  * NOTE: Table-id is relevant on two modes:
 300  * - case VRF backend is default : on default VRF only
 301  * - case VRF backend is netns : on all VRFs
 302  */
 303 struct route_table *zebra_vrf_table_with_table_id(afi_t afi, safi_t safi,
 304                                                   vrf_id_t vrf_id,
 305                                                   uint32_t table_id)
 306 {
 307         struct route_table *table = NULL;
 308
 309         if (afi >= AFI_MAX || safi >= SAFI_MAX)
 310                 return NULL;
 311
 312         if (vrf_id == VRF_DEFAULT) {
 313                 if (table_id == RT_TABLE_MAIN
 314                     || table_id == zebrad.rtm_table_default)
 315                         table = zebra_vrf_table(afi, safi, vrf_id);
 316                 else
 317                         table = zebra_vrf_other_route_table(afi, table_id,
 318                                                             vrf_id);
 319         } else if (vrf_is_backend_netns()) {
 320                 if (table_id == RT_TABLE_MAIN
 321                     || table_id == zebrad.rtm_table_default)
 322                         table = zebra_vrf_table(afi, safi, vrf_id);
 323                 else
 324                         table = zebra_vrf_other_route_table(afi, table_id,
 325                                                             vrf_id);
 326         } else
 327                 table = zebra_vrf_table(afi, safi, vrf_id);
 328
 329         return table;
 330 }
 331
 332 void zebra_rtable_node_cleanup(struct route_table *table,
 333                                struct route_node *node)
 334 {
 335         struct route_entry *re, *next;
 336
 337         RNODE_FOREACH_RE_SAFE (node, re, next) {
 338                 rib_unlink(node, re);
 339         }
 340
 341         if (node->info)
 342                 XFREE(MTYPE_RIB_DEST, node->info);
 343 }
 344
 345 static void zebra_rnhtable_node_cleanup(struct route_table *table,
 346                                         struct route_node *node)
 347 {
 348         if (node->info)
 349                 zebra_free_rnh(node->info);
 350 }
 351
 352 /*
 353  * Create a routing table for the specific AFI/SAFI in the given VRF.
 354  */
 355 static void zebra_vrf_table_create(struct zebra_vrf *zvrf, afi_t afi,
 356                                    safi_t safi)
 357 {
 358         rib_table_info_t *info;
 359         struct route_table *table;
 360
 361         assert(!zvrf->table[afi][safi]);
 362
 363         if (afi == AFI_IP6)
 364                 table = srcdest_table_init();
 365         else
 366                 table = route_table_init();
 367         table->cleanup = zebra_rtable_node_cleanup;
 368         zvrf->table[afi][safi] = table;
 369
 370         info = XCALLOC(MTYPE_RIB_TABLE_INFO, sizeof(*info));
 371         info->zvrf = zvrf;
 372         info->afi = afi;
 373         info->safi = safi;
 374         table->info = info;
 375 }
 376
 377 /* Allocate new zebra VRF. */
 378 struct zebra_vrf *zebra_vrf_alloc(void)
 379 {
 380         struct zebra_vrf *zvrf;
 381
 382         zvrf = XCALLOC(MTYPE_ZEBRA_VRF, sizeof(struct zebra_vrf));
 383
 384         zebra_vxlan_init_tables(zvrf);
 385         zebra_mpls_init_tables(zvrf);
 386         zebra_pw_init(zvrf);
 387         zvrf->table_id = RT_TABLE_MAIN;
 388         /* by default table ID is default one */
 389         return zvrf;
 390 }
 391
 392 /* Lookup VRF by identifier.  */
 393 struct zebra_vrf *zebra_vrf_lookup_by_id(vrf_id_t vrf_id)
 394 {
 395         return vrf_info_lookup(vrf_id);
 396 }
 397
 398 /* Lookup VRF by name.  */
 399 struct zebra_vrf *zebra_vrf_lookup_by_name(const char *name)
 400 {
 401         struct vrf *vrf;
 402
 403         if (!name)
 404                 name = VRF_DEFAULT_NAME;
 405
 406         vrf = vrf_lookup_by_name(name);
 407         if (vrf)
 408                 return ((struct zebra_vrf *)vrf->info);
 409
 410         return NULL;
 411 }
 412
 413 /* Lookup the routing table in an enabled VRF. */
 414 struct route_table *zebra_vrf_table(afi_t afi, safi_t safi, vrf_id_t vrf_id)
 415 {
 416         struct zebra_vrf *zvrf = vrf_info_lookup(vrf_id);
 417
 418         if (!zvrf)
 419                 return NULL;
 420
 421         if (afi >= AFI_MAX || safi >= SAFI_MAX)
 422                 return NULL;
 423
 424         return zvrf->table[afi][safi];
 425 }
 426
 427 struct route_table *zebra_vrf_other_route_table(afi_t afi, uint32_t table_id,
 428                                                 vrf_id_t vrf_id)
 429 {
 430         struct zebra_vrf *zvrf;
 431         struct zebra_ns *zns;
 432
 433         zvrf = vrf_info_lookup(vrf_id);
 434         if (!zvrf)
 435                 return NULL;
 436
 437         zns = zvrf->zns;
 438
 439         if (afi >= AFI_MAX)
 440                 return NULL;
 441
 442         if ((table_id != RT_TABLE_MAIN)
 443             && (table_id != zebrad.rtm_table_default)) {
 444                 if (zvrf->table_id == RT_TABLE_MAIN ||
 445                     zvrf->table_id == zebrad.rtm_table_default) {
 446                         /* this VRF use default table
 447                          * so in all cases, it does not use specific table
 448                          * so it is possible to configure tables in this VRF
 449                          */
 450                         return zebra_ns_get_table(zns, zvrf, table_id, afi);
 451                 }
 452         }
 453
 454         return zvrf->table[afi][SAFI_UNICAST];
 455 }
 456
 457 static int vrf_config_write(struct vty *vty)
 458 {
 459         struct vrf *vrf;
 460         struct zebra_vrf *zvrf;
 461
 462         RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
 463                 zvrf = vrf->info;
 464
 465                 if (!zvrf)
 466                         continue;
 467
 468                 if (zvrf_id(zvrf) == VRF_DEFAULT) {
 469                         if (zvrf->l3vni)
 470                                 vty_out(vty, "vni %u\n", zvrf->l3vni);
 471                         vty_out(vty, "!\n");
 472                 } else {
 473                         vty_frame(vty, "vrf %s\n", zvrf_name(zvrf));
 474                         if (zvrf->l3vni)
 475                                 vty_out(vty, " vni %u%s\n", zvrf->l3vni,
 476                                         is_l3vni_for_prefix_routes_only(
 477                                                 zvrf->l3vni)
 478                                                 ? " prefix-routes-only"
 479                                                 : "");
 480                         zebra_ns_config_write(vty, (struct ns *)vrf->ns_ctxt);
 481
 482                 }
 483
 484                 if (zvrf_id(zvrf) != VRF_DEFAULT)
 485                         vty_endframe(vty, " exit-vrf\n!\n");
 486         }
 487         return 0;
 488 }
 489
 490 /* Zebra VRF initialization. */
 491 void zebra_vrf_init(void)
 492 {
 493         vrf_init(zebra_vrf_new, zebra_vrf_enable, zebra_vrf_disable,
 494                  zebra_vrf_delete);
 495
 496         vrf_cmd_init(vrf_config_write, &zserv_privs);
 497 }