zebra/zebra_mpls.h

   1 /*
   2  * Zebra MPLS Data structures and definitions
   3  * Copyright (C) 2015 Cumulus Networks, Inc.
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra 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  * GNU Zebra 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
  22 #ifndef _ZEBRA_MPLS_H
  23 #define _ZEBRA_MPLS_H
  24
  25 #include "prefix.h"
  26 #include "table.h"
  27 #include "queue.h"
  28 #include "hash.h"
  29 #include "jhash.h"
  30 #include "nexthop.h"
  31 #include "vty.h"
  32 #include "memory.h"
  33 #include "mpls.h"
  34 #include "zebra/zserv.h"
  35 #include "zebra/zebra_vrf.h"
  36 #include "hook.h"
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41
  42 /* Definitions and macros. */
  43
  44 #define NHLFE_FAMILY(nhlfe)                                                    \
  45         (((nhlfe)->nexthop->type == NEXTHOP_TYPE_IPV6                          \
  46           || (nhlfe)->nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)              \
  47                  ? AF_INET6                                                    \
  48                  : AF_INET)
  49
  50 /* Declare LSP nexthop list types */
  51 PREDECL_DLIST(nhlfe_list);
  52
  53 /*
  54  * (Outgoing) nexthop label forwarding entry
  55  */
  56 struct zebra_nhlfe {
  57         /* Type of entry - static etc. */
  58         enum lsp_types_t type;
  59
  60         /* Nexthop information (with outgoing label) */
  61         struct nexthop *nexthop;
  62
  63         /* Backpointer to base entry. */
  64         struct zebra_lsp *lsp;
  65
  66         /* Runtime info - flags, pointers etc. */
  67         uint32_t flags;
  68 #define NHLFE_FLAG_CHANGED     (1 << 0)
  69 #define NHLFE_FLAG_SELECTED    (1 << 1)
  70 #define NHLFE_FLAG_MULTIPATH   (1 << 2)
  71 #define NHLFE_FLAG_DELETED     (1 << 3)
  72 #define NHLFE_FLAG_INSTALLED   (1 << 4)
  73 #define NHLFE_FLAG_IS_BACKUP   (1 << 5)
  74
  75         uint8_t distance;
  76
  77         /* Linkage for LSPs' lists */
  78         struct nhlfe_list_item list;
  79 };
  80
  81 /*
  82  * Incoming label entry
  83  */
  84 struct zebra_ile {
  85         mpls_label_t in_label;
  86 };
  87
  88 /*
  89  * Label swap entry (ile -> list of nhlfes)
  90  */
  91 struct zebra_lsp {
  92         /* Incoming label */
  93         struct zebra_ile ile;
  94
  95         /* List of NHLFEs, pointer to best, and num equal-cost. */
  96         struct nhlfe_list_head nhlfe_list;
  97
  98         struct zebra_nhlfe *best_nhlfe;
  99         uint32_t num_ecmp;
 100
 101         /* Backup nhlfes, if present. The nexthop in a primary/active nhlfe
 102          * refers to its backup (if any) by index, so the order of this list
 103          * is significant.
 104          */
 105         struct nhlfe_list_head backup_nhlfe_list;
 106
 107         /* Flags */
 108         uint32_t flags;
 109 #define LSP_FLAG_SCHEDULED        (1 << 0)
 110 #define LSP_FLAG_INSTALLED        (1 << 1)
 111 #define LSP_FLAG_CHANGED          (1 << 2)
 112 #define LSP_FLAG_FPM              (1 << 3)
 113
 114         /* Address-family of NHLFE - saved here for delete. All NHLFEs */
 115         /* have to be of the same AF */
 116         uint8_t addr_family;
 117 };
 118
 119 /*
 120  * FEC to label binding.
 121  */
 122 struct zebra_fec {
 123         /* FEC (prefix) */
 124         struct route_node *rn;
 125
 126         /* In-label - either statically bound or derived from label block. */
 127         mpls_label_t label;
 128
 129         /* Label index (into global label block), if valid */
 130         uint32_t label_index;
 131
 132         /* Flags. */
 133         uint32_t flags;
 134 #define FEC_FLAG_CONFIGURED       (1 << 0)
 135
 136         /* Clients interested in this FEC. */
 137         struct list *client_list;
 138 };
 139
 140 /* Declare typesafe list apis/macros */
 141 DECLARE_DLIST(nhlfe_list, struct zebra_nhlfe, list);
 142
 143 /* Function declarations. */
 144
 145 /*
 146  * Add/update global label block.
 147  */
 148 int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, uint32_t start_label,
 149                                uint32_t end_label);
 150
 151 /*
 152  * Delete global label block.
 153  */
 154 int zebra_mpls_label_block_del(struct zebra_vrf *vrf);
 155
 156 /*
 157  * Display MPLS global label block configuration (VTY command handler).
 158  */
 159 int zebra_mpls_write_label_block_config(struct vty *vty, struct zebra_vrf *vrf);
 160
 161 /*
 162  * Install dynamic LSP entry.
 163  */
 164 int zebra_mpls_lsp_install(struct zebra_vrf *zvrf, struct route_node *rn,
 165                            struct route_entry *re);
 166
 167 /*
 168  * Uninstall dynamic LSP entry, if any.
 169  */
 170 int zebra_mpls_lsp_uninstall(struct zebra_vrf *zvrf, struct route_node *rn,
 171                              struct route_entry *re);
 172
 173 /* Add an NHLFE to an LSP, return the newly-added object */
 174 struct zebra_nhlfe *
 175 zebra_mpls_lsp_add_nhlfe(struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
 176                          enum nexthop_types_t gtype, const union g_addr *gate,
 177                          ifindex_t ifindex, uint8_t num_labels,
 178                          const mpls_label_t *out_labels);
 179
 180 /* Add or update a backup NHLFE for an LSP; return the object */
 181 struct zebra_nhlfe *zebra_mpls_lsp_add_backup_nhlfe(
 182         struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
 183         enum nexthop_types_t gtype, const union g_addr *gate, ifindex_t ifindex,
 184         uint8_t num_labels, const mpls_label_t *out_labels);
 185
 186 /*
 187  * Add NHLFE or backup NHLFE to an LSP based on a nexthop. These just maintain
 188  * the LSP and NHLFE objects; nothing is scheduled for processing.
 189  * Return: the newly-added object
 190  */
 191 struct zebra_nhlfe *zebra_mpls_lsp_add_nh(struct zebra_lsp *lsp,
 192                                           enum lsp_types_t lsp_type,
 193                                           const struct nexthop *nh);
 194 struct zebra_nhlfe *zebra_mpls_lsp_add_backup_nh(struct zebra_lsp *lsp,
 195                                                  enum lsp_types_t lsp_type,
 196                                                  const struct nexthop *nh);
 197
 198 /* Free an allocated NHLFE */
 199 void zebra_mpls_nhlfe_free(struct zebra_nhlfe *nhlfe);
 200
 201 int zebra_mpls_fec_register(struct zebra_vrf *zvrf, struct prefix *p,
 202                             uint32_t label, uint32_t label_index,
 203                             struct zserv *client);
 204
 205 /*
 206  * Deregistration from a client for the label binding for a FEC. The FEC
 207  * itself is deleted if no other registered clients exist and there is no
 208  * label bound to the FEC.
 209  */
 210 int zebra_mpls_fec_unregister(struct zebra_vrf *zvrf, struct prefix *p,
 211                               struct zserv *client);
 212
 213 /*
 214  * Return FEC (if any) to which this label is bound.
 215  * Note: Only works for per-prefix binding and when the label is not
 216  * implicit-null.
 217  * TODO: Currently walks entire table, can optimize later with another
 218  * hash..
 219  */
 220 struct zebra_fec *zebra_mpls_fec_for_label(struct zebra_vrf *zvrf,
 221                                            mpls_label_t label);
 222
 223 /*
 224  * Inform if specified label is currently bound to a FEC or not.
 225  */
 226 int zebra_mpls_label_already_bound(struct zebra_vrf *zvrf, mpls_label_t label);
 227
 228 /*
 229  * Add static FEC to label binding. If there are clients registered for this
 230  * FEC, notify them. If there are labeled routes for this FEC, install the
 231  * label forwarding entry.
 232  */
 233 int zebra_mpls_static_fec_add(struct zebra_vrf *zvrf, struct prefix *p,
 234                               mpls_label_t in_label);
 235
 236 /*
 237  * Remove static FEC to label binding. If there are no clients registered
 238  * for this FEC, delete the FEC; else notify clients.
 239  * Note: Upon delete of static binding, if label index exists for this FEC,
 240  * client may need to be updated with derived label.
 241  */
 242 int zebra_mpls_static_fec_del(struct zebra_vrf *zvrf, struct prefix *p);
 243
 244 /*
 245  * Display MPLS FEC to label binding configuration (VTY command handler).
 246  */
 247 int zebra_mpls_write_fec_config(struct vty *vty, struct zebra_vrf *zvrf);
 248
 249 /*
 250  * Display MPLS FEC to label binding (VTY command handler).
 251  */
 252 void zebra_mpls_print_fec_table(struct vty *vty, struct zebra_vrf *zvrf);
 253
 254 /*
 255  * Display MPLS FEC to label binding for a specific FEC (VTY command handler).
 256  */
 257 void zebra_mpls_print_fec(struct vty *vty, struct zebra_vrf *zvrf,
 258                           struct prefix *p);
 259
 260 /*
 261  * Handle zapi request to install/uninstall LSP and
 262  * (optionally) FEC-To-NHLFE (FTN) bindings.
 263  *
 264  * mpls_zapi_labels_process -> Installs for future processing
 265  *                             in the meta-q
 266  * zebra_mpls_labels_process -> called by the meta-q
 267  */
 268 void mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf,
 269                               const struct zapi_labels *zl);
 270 void zebra_mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf,
 271                                     const struct zapi_labels *zl);
 272
 273 /*
 274  * Uninstall all NHLFEs bound to a single FEC.
 275  *
 276  * mpls_ftn_uninstall -> Called to enqueue into early label processing
 277  *                       via the metaq
 278  * zebra_mpls_ftn_uninstall -> Called when we process the meta q
 279  *                             for this item
 280  */
 281 void mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type,
 282                         struct prefix *prefix, uint8_t route_type,
 283                         uint8_t route_instance);
 284 void zebra_mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type,
 285                               struct prefix *prefix, uint8_t route_type,
 286                               uint8_t route_instance);
 287 /*
 288  * Install/update a NHLFE for an LSP in the forwarding table. This may be
 289  * a new LSP entry or a new NHLFE for an existing in-label or an update of
 290  * the out-label(s) for an existing NHLFE (update case).
 291  */
 292 int mpls_lsp_install(struct zebra_vrf *zvrf, enum lsp_types_t type,
 293                      mpls_label_t in_label, uint8_t num_out_labels,
 294                      const mpls_label_t *out_labels, enum nexthop_types_t gtype,
 295                      const union g_addr *gate, ifindex_t ifindex);
 296
 297 /*
 298  * Lookup LSP by its input label.
 299  */
 300 struct zebra_lsp *mpls_lsp_find(struct zebra_vrf *zvrf, mpls_label_t in_label);
 301
 302 /*
 303  * Uninstall a particular NHLFE in the forwarding table. If this is
 304  * the only NHLFE, the entire LSP forwarding entry has to be deleted.
 305  */
 306 int mpls_lsp_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type,
 307                        mpls_label_t in_label, enum nexthop_types_t gtype,
 308                        const union g_addr *gate, ifindex_t ifindex,
 309                        bool backup_p);
 310
 311 /*
 312  * Uninstall all NHLFEs for a particular LSP forwarding entry.
 313  */
 314 int mpls_lsp_uninstall_all_vrf(struct zebra_vrf *zvrf, enum lsp_types_t type,
 315                                mpls_label_t in_label);
 316
 317 #if defined(HAVE_CUMULUS)
 318 /*
 319  * Check that the label values used in LSP creation are consistent. The
 320  * main criteria is that if there is ECMP, the label operation must still
 321  * be consistent - i.e., all paths either do a swap or do PHP. This is due
 322  * to current HW restrictions.
 323  */
 324 int zebra_mpls_lsp_label_consistent(struct zebra_vrf *zvrf,
 325                                     mpls_label_t in_label,
 326                                     mpls_label_t out_label,
 327                                     enum nexthop_types_t gtype,
 328                                     union g_addr *gate, ifindex_t ifindex);
 329 #endif /* HAVE_CUMULUS */
 330
 331 /*
 332  * Add static LSP entry. This may be the first entry for this incoming label
 333  * or an additional nexthop; an existing entry may also have outgoing label
 334  * changed.
 335  * Note: The label operation (swap or PHP) is common for the LSP entry (all
 336  * NHLFEs).
 337  */
 338 int zebra_mpls_static_lsp_add(struct zebra_vrf *zvrf, mpls_label_t in_label,
 339                               mpls_label_t out_label,
 340                               enum nexthop_types_t gtype, union g_addr *gate,
 341                               ifindex_t ifindex);
 342
 343 /*
 344  * Delete static LSP entry. This may be the delete of one particular
 345  * NHLFE for this incoming label or the delete of the entire entry (i.e.,
 346  * all NHLFEs).
 347  * NOTE: Delete of the only NHLFE will also end up deleting the entire
 348  * LSP configuration.
 349  */
 350 int zebra_mpls_static_lsp_del(struct zebra_vrf *zvrf, mpls_label_t in_label,
 351                               enum nexthop_types_t gtype, union g_addr *gate,
 352                               ifindex_t ifindex);
 353
 354 /*
 355  * Process LSP update results from zebra dataplane.
 356  */
 357 /* Forward ref of dplane update context type */
 358 struct zebra_dplane_ctx;
 359
 360 void zebra_mpls_lsp_dplane_result(struct zebra_dplane_ctx *ctx);
 361
 362 /* Process async dplane notifications. */
 363 void zebra_mpls_process_dplane_notify(struct zebra_dplane_ctx *ctx);
 364
 365 /*
 366  * Schedule all MPLS label forwarding entries for processing.
 367  * Called upon changes that may affect one or more of them such as
 368  * interface or nexthop state changes.
 369  */
 370 void zebra_mpls_lsp_schedule(struct zebra_vrf *zvrf);
 371
 372 /*
 373  * Display MPLS label forwarding table for a specific LSP
 374  * (VTY command handler).
 375  */
 376 void zebra_mpls_print_lsp(struct vty *vty, struct zebra_vrf *zvrf,
 377                           mpls_label_t label, bool use_json);
 378
 379 /*
 380  * Display MPLS label forwarding table (VTY command handler).
 381  */
 382 void zebra_mpls_print_lsp_table(struct vty *vty, struct zebra_vrf *zvrf,
 383                                 bool use_json);
 384
 385 /*
 386  * Display MPLS LSP configuration of all static LSPs (VTY command handler).
 387  */
 388 int zebra_mpls_write_lsp_config(struct vty *vty, struct zebra_vrf *zvrf);
 389
 390 /*
 391  * Called when VRF becomes inactive, cleans up information but keeps
 392  * the table itself.
 393  * NOTE: Currently supported only for default VRF.
 394  */
 395 void zebra_mpls_cleanup_tables(struct zebra_vrf *zvrf);
 396
 397 /*
 398  * Called upon process exiting, need to delete LSP forwarding
 399  * entries from the kernel.
 400  * NOTE: Currently supported only for default VRF.
 401  */
 402 void zebra_mpls_close_tables(struct zebra_vrf *zvrf);
 403
 404 /*
 405  * Allocate MPLS tables for this VRF.
 406  * NOTE: Currently supported only for default VRF.
 407  */
 408 void zebra_mpls_init_tables(struct zebra_vrf *zvrf);
 409
 410 /*
 411  * If mpls is turned on *after* FRR is brought
 412  * up let's actually notice this and turn on
 413  * the relevant bits to make it work.
 414  */
 415 void zebra_mpls_turned_on(void);
 416
 417 /*
 418  * Global MPLS initialization.
 419  */
 420 void zebra_mpls_init(void);
 421
 422 /*
 423  * MPLS VTY.
 424  */
 425 void zebra_mpls_vty_init(void);
 426
 427 /*
 428  * When cleaning up a client connection ensure that there are no
 429  * vrf labels that need cleaning up too
 430  */
 431 void zebra_mpls_client_cleanup_vrf_label(uint8_t proto);
 432
 433 /* Inline functions. */
 434
 435 /*
 436  * Distance (priority) definition for LSP NHLFE.
 437  */
 438 static inline uint8_t lsp_distance(enum lsp_types_t type)
 439 {
 440         switch (type) {
 441         case ZEBRA_LSP_STATIC:
 442                 return (route_distance(ZEBRA_ROUTE_STATIC));
 443         case ZEBRA_LSP_LDP:
 444                 return (route_distance(ZEBRA_ROUTE_LDP));
 445         case ZEBRA_LSP_BGP:
 446                 return (route_distance(ZEBRA_ROUTE_BGP));
 447         case ZEBRA_LSP_NONE:
 448         case ZEBRA_LSP_SHARP:
 449         case ZEBRA_LSP_EVPN:
 450         case ZEBRA_LSP_OSPF_SR:
 451         case ZEBRA_LSP_ISIS_SR:
 452         case ZEBRA_LSP_SRTE:
 453                 return 150;
 454         }
 455
 456         /*
 457          * For some reason certain compilers do not believe
 458          * that all the cases have been handled.  And
 459          * WTF does this work differently than when I removed
 460          * the default case????
 461          */
 462         return 150;
 463 }
 464
 465 /*
 466  * Map RIB type to LSP type. Used when labeled-routes from BGP
 467  * are converted into LSPs.
 468  */
 469 static inline enum lsp_types_t lsp_type_from_re_type(int re_type)
 470 {
 471         switch (re_type) {
 472         case ZEBRA_ROUTE_STATIC:
 473                 return ZEBRA_LSP_STATIC;
 474         case ZEBRA_ROUTE_LDP:
 475                 return ZEBRA_LSP_LDP;
 476         case ZEBRA_ROUTE_BGP:
 477                 return ZEBRA_LSP_BGP;
 478         case ZEBRA_ROUTE_OSPF:
 479                 return ZEBRA_LSP_OSPF_SR;
 480         case ZEBRA_ROUTE_ISIS:
 481                 return ZEBRA_LSP_ISIS_SR;
 482         case ZEBRA_ROUTE_SHARP:
 483                 return ZEBRA_LSP_SHARP;
 484         case ZEBRA_ROUTE_SRTE:
 485                 return ZEBRA_LSP_SRTE;
 486         default:
 487                 return ZEBRA_LSP_NONE;
 488         }
 489 }
 490
 491 /*
 492  * Map LSP type to RIB type.
 493  */
 494 static inline int re_type_from_lsp_type(enum lsp_types_t lsp_type)
 495 {
 496         switch (lsp_type) {
 497         case ZEBRA_LSP_STATIC:
 498                 return ZEBRA_ROUTE_STATIC;
 499         case ZEBRA_LSP_LDP:
 500                 return ZEBRA_ROUTE_LDP;
 501         case ZEBRA_LSP_BGP:
 502         case ZEBRA_LSP_EVPN:
 503                 return ZEBRA_ROUTE_BGP;
 504         case ZEBRA_LSP_OSPF_SR:
 505                 return ZEBRA_ROUTE_OSPF;
 506         case ZEBRA_LSP_ISIS_SR:
 507                 return ZEBRA_ROUTE_ISIS;
 508         case ZEBRA_LSP_NONE:
 509                 return ZEBRA_ROUTE_KERNEL;
 510         case ZEBRA_LSP_SHARP:
 511                 return ZEBRA_ROUTE_SHARP;
 512         case ZEBRA_LSP_SRTE:
 513                 return ZEBRA_ROUTE_SRTE;
 514         }
 515
 516         /*
 517          * For some reason certain compilers do not believe
 518          * that all the cases have been handled.  And
 519          * WTF does this work differently than when I removed
 520          * the default case????
 521          */
 522         return ZEBRA_ROUTE_KERNEL;
 523 }
 524
 525 /* NHLFE type as printable string. */
 526 static inline const char *nhlfe_type2str(enum lsp_types_t lsp_type)
 527 {
 528         switch (lsp_type) {
 529         case ZEBRA_LSP_STATIC:
 530                 return "Static";
 531         case ZEBRA_LSP_LDP:
 532                 return "LDP";
 533         case ZEBRA_LSP_BGP:
 534                 return "BGP";
 535         case ZEBRA_LSP_OSPF_SR:
 536                 return "SR (OSPF)";
 537         case ZEBRA_LSP_ISIS_SR:
 538                 return "SR (IS-IS)";
 539         case ZEBRA_LSP_SHARP:
 540                 return "SHARP";
 541         case ZEBRA_LSP_SRTE:
 542                 return "SR-TE";
 543         case ZEBRA_LSP_EVPN:
 544                 return "EVPN";
 545         case ZEBRA_LSP_NONE:
 546                 return "Unknown";
 547         }
 548
 549         /*
 550          * For some reason certain compilers do not believe
 551          * that all the cases have been handled.  And
 552          * WTF does this work differently than when I removed
 553          * the default case????
 554          */
 555         return "Unknown";
 556 }
 557
 558 static inline void mpls_mark_lsps_for_processing(struct zebra_vrf *zvrf,
 559                                                  struct prefix *p)
 560 {
 561         struct route_table *table;
 562         struct route_node *rn;
 563         rib_dest_t *dest;
 564
 565         if (!zvrf)
 566                 return;
 567
 568         table = zvrf->table[family2afi(p->family)][SAFI_UNICAST];
 569         if (!table)
 570                 return;
 571
 572         rn = route_node_match(table, p);
 573         if (!rn)
 574                 return;
 575
 576
 577         dest = rib_dest_from_rnode(rn);
 578         SET_FLAG(dest->flags, RIB_DEST_UPDATE_LSPS);
 579 }
 580
 581 static inline void mpls_unmark_lsps_for_processing(struct route_node *rn)
 582 {
 583         rib_dest_t *dest = rib_dest_from_rnode(rn);
 584
 585         UNSET_FLAG(dest->flags, RIB_DEST_UPDATE_LSPS);
 586 }
 587
 588 static inline int mpls_should_lsps_be_processed(struct route_node *rn)
 589 {
 590         rib_dest_t *dest = rib_dest_from_rnode(rn);
 591
 592         return !!CHECK_FLAG(dest->flags, RIB_DEST_UPDATE_LSPS);
 593 }
 594
 595 /* Global variables. */
 596 extern bool mpls_enabled;
 597 extern bool mpls_pw_reach_strict; /* Strict pseudowire reachability checking */
 598
 599 #ifdef __cplusplus
 600 }
 601 #endif
 602
 603 #endif /*_ZEBRA_MPLS_H */