2 * Copyright (C) 2013 Cumulus Networks, Inc.
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "sockunion.h"
32 #include "workqueue.h"
37 #include "termtable.h"
40 #include "zebra/rib.h"
42 #include "zebra/interface.h"
43 #include "zebra/zserv.h"
44 #include "zebra/zebra_router.h"
45 #include "zebra/redistribute.h"
46 #include "zebra/debug.h"
47 #include "zebra/zebra_vrf.h"
48 #include "zebra/zebra_mpls.h"
49 #include "zebra/zebra_srte.h"
50 #include "zebra/zebra_errors.h"
52 DEFINE_MTYPE_STATIC(ZEBRA
, LSP
, "MPLS LSP object");
53 DEFINE_MTYPE_STATIC(ZEBRA
, FEC
, "MPLS FEC object");
54 DEFINE_MTYPE_STATIC(ZEBRA
, NHLFE
, "MPLS nexthop object");
57 bool mpls_pw_reach_strict
; /* Strict reachability checking */
59 /* static function declarations */
61 static void fec_evaluate(struct zebra_vrf
*zvrf
);
62 static uint32_t fec_derive_label_from_index(struct zebra_vrf
*vrf
,
63 struct zebra_fec
*fec
);
64 static int lsp_install(struct zebra_vrf
*zvrf
, mpls_label_t label
,
65 struct route_node
*rn
, struct route_entry
*re
);
66 static int lsp_uninstall(struct zebra_vrf
*zvrf
, mpls_label_t label
);
67 static int fec_change_update_lsp(struct zebra_vrf
*zvrf
, struct zebra_fec
*fec
,
68 mpls_label_t old_label
);
69 static int fec_send(struct zebra_fec
*fec
, struct zserv
*client
);
70 static void fec_update_clients(struct zebra_fec
*fec
);
71 static void fec_print(struct zebra_fec
*fec
, struct vty
*vty
);
72 static struct zebra_fec
*fec_find(struct route_table
*table
, struct prefix
*p
);
73 static struct zebra_fec
*fec_add(struct route_table
*table
, struct prefix
*p
,
74 mpls_label_t label
, uint32_t flags
,
75 uint32_t label_index
);
76 static int fec_del(struct zebra_fec
*fec
);
78 static unsigned int label_hash(const void *p
);
79 static bool label_cmp(const void *p1
, const void *p2
);
80 static int nhlfe_nexthop_active_ipv4(struct zebra_nhlfe
*nhlfe
,
81 struct nexthop
*nexthop
);
82 static int nhlfe_nexthop_active_ipv6(struct zebra_nhlfe
*nhlfe
,
83 struct nexthop
*nexthop
);
84 static int nhlfe_nexthop_active(struct zebra_nhlfe
*nhlfe
);
86 static void lsp_select_best_nhlfe(struct zebra_lsp
*lsp
);
87 static void lsp_uninstall_from_kernel(struct hash_bucket
*bucket
, void *ctxt
);
88 static void lsp_schedule(struct hash_bucket
*bucket
, void *ctxt
);
89 static wq_item_status
lsp_process(struct work_queue
*wq
, void *data
);
90 static void lsp_processq_del(struct work_queue
*wq
, void *data
);
91 static void lsp_processq_complete(struct work_queue
*wq
);
92 static int lsp_processq_add(struct zebra_lsp
*lsp
);
93 static void *lsp_alloc(void *p
);
95 /* Check whether lsp can be freed - no nhlfes, e.g., and call free api */
96 static void lsp_check_free(struct hash
*lsp_table
, struct zebra_lsp
**plsp
);
98 /* Free lsp; sets caller's pointer to NULL */
99 static void lsp_free(struct hash
*lsp_table
, struct zebra_lsp
**plsp
);
101 static char *nhlfe2str(const struct zebra_nhlfe
*nhlfe
, char *buf
, int size
);
102 static char *nhlfe_config_str(const struct zebra_nhlfe
*nhlfe
, char *buf
,
104 static int nhlfe_nhop_match(struct zebra_nhlfe
*nhlfe
,
105 enum nexthop_types_t gtype
,
106 const union g_addr
*gate
, ifindex_t ifindex
);
107 static struct zebra_nhlfe
*nhlfe_find(struct nhlfe_list_head
*list
,
108 enum lsp_types_t lsp_type
,
109 enum nexthop_types_t gtype
,
110 const union g_addr
*gate
,
112 static struct zebra_nhlfe
*
113 nhlfe_add(struct zebra_lsp
*lsp
, enum lsp_types_t lsp_type
,
114 enum nexthop_types_t gtype
, const union g_addr
*gate
,
115 ifindex_t ifindex
, uint8_t num_labels
, const mpls_label_t
*labels
,
117 static int nhlfe_del(struct zebra_nhlfe
*nhlfe
);
118 static void nhlfe_free(struct zebra_nhlfe
*nhlfe
);
119 static void nhlfe_out_label_update(struct zebra_nhlfe
*nhlfe
,
120 struct mpls_label_stack
*nh_label
);
121 static int mpls_lsp_uninstall_all(struct hash
*lsp_table
, struct zebra_lsp
*lsp
,
122 enum lsp_types_t type
);
123 static int mpls_static_lsp_uninstall_all(struct zebra_vrf
*zvrf
,
124 mpls_label_t in_label
);
125 static void nhlfe_print(struct zebra_nhlfe
*nhlfe
, struct vty
*vty
,
127 static void lsp_print(struct vty
*vty
, struct zebra_lsp
*lsp
);
128 static void mpls_lsp_uninstall_all_type(struct hash_bucket
*bucket
, void *ctxt
);
129 static void mpls_ftn_uninstall_all(struct zebra_vrf
*zvrf
,
130 int afi
, enum lsp_types_t lsp_type
);
131 static int lsp_znh_install(struct zebra_lsp
*lsp
, enum lsp_types_t type
,
132 const struct zapi_nexthop
*znh
);
133 static int lsp_backup_znh_install(struct zebra_lsp
*lsp
, enum lsp_types_t type
,
134 const struct zapi_nexthop
*znh
);
136 /* Static functions */
139 * Handle failure in LSP install, clear flags for NHLFE.
141 static void clear_nhlfe_installed(struct zebra_lsp
*lsp
)
143 struct zebra_nhlfe
*nhlfe
;
144 struct nexthop
*nexthop
;
146 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
147 nexthop
= nhlfe
->nexthop
;
151 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
152 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
155 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
156 nexthop
= nhlfe
->nexthop
;
160 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
161 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
166 * Install label forwarding entry based on labeled-route entry.
168 static int lsp_install(struct zebra_vrf
*zvrf
, mpls_label_t label
,
169 struct route_node
*rn
, struct route_entry
*re
)
171 struct hash
*lsp_table
;
172 struct zebra_ile tmp_ile
;
173 struct zebra_lsp
*lsp
;
174 struct zebra_nhlfe
*nhlfe
;
175 struct nexthop
*nexthop
;
176 enum lsp_types_t lsp_type
;
181 lsp_table
= zvrf
->lsp_table
;
185 lsp_type
= lsp_type_from_re_type(re
->type
);
188 /* Locate or allocate LSP entry. */
189 tmp_ile
.in_label
= label
;
190 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
192 /* For each active nexthop, create NHLFE. Note that we deliberately skip
193 * recursive nexthops right now, because intermediate hops won't
195 * the label advertised by the recursive nexthop (plus we don't have the
196 * logic yet to push multiple labels).
198 for (nexthop
= re
->nhe
->nhg
.nexthop
;
199 nexthop
; nexthop
= nexthop
->next
) {
200 /* Skip inactive and recursive entries. */
201 if (!CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
))
203 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_RECURSIVE
))
206 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, lsp_type
,
207 nexthop
->type
, &nexthop
->gate
,
210 /* Clear deleted flag (in case it was set) */
211 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
212 if (nexthop_labels_match(nhlfe
->nexthop
, nexthop
))
217 if (IS_ZEBRA_DEBUG_MPLS
) {
218 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
220 "LSP in-label %u type %d nexthop %s out-label changed",
221 lsp
->ile
.in_label
, lsp_type
, buf
);
224 /* Update out label, trigger processing. */
225 nhlfe_out_label_update(nhlfe
, nexthop
->nh_label
);
226 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
229 /* Add LSP entry to this nexthop */
230 nhlfe
= nhlfe_add(lsp
, lsp_type
, nexthop
->type
,
231 &nexthop
->gate
, nexthop
->ifindex
,
232 nexthop
->nh_label
->num_labels
,
233 nexthop
->nh_label
->label
,
238 if (IS_ZEBRA_DEBUG_MPLS
) {
239 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
241 "Add LSP in-label %u type %d nexthop %s out-label %u",
242 lsp
->ile
.in_label
, lsp_type
, buf
,
243 nexthop
->nh_label
->label
[0]);
246 lsp
->addr_family
= NHLFE_FAMILY(nhlfe
);
248 /* Mark NHLFE as changed. */
249 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
254 /* Queue LSP for processing if necessary. If no NHLFE got added (special
255 * case), delete the LSP entry; this case results in somewhat ugly
258 if (added
|| changed
) {
259 if (lsp_processq_add(lsp
))
262 lsp_check_free(lsp_table
, &lsp
);
269 * Uninstall all non-static NHLFEs of a label forwarding entry. If all
270 * NHLFEs are removed, the entire entry is deleted.
272 static int lsp_uninstall(struct zebra_vrf
*zvrf
, mpls_label_t label
)
274 struct hash
*lsp_table
;
275 struct zebra_ile tmp_ile
;
276 struct zebra_lsp
*lsp
;
277 struct zebra_nhlfe
*nhlfe
;
281 lsp_table
= zvrf
->lsp_table
;
285 /* If entry is not present, exit. */
286 tmp_ile
.in_label
= label
;
287 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
288 if (!lsp
|| (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
))
291 /* Mark NHLFEs for delete or directly delete, as appropriate. */
292 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
294 /* Skip static NHLFEs */
295 if (nhlfe
->type
== ZEBRA_LSP_STATIC
)
298 if (IS_ZEBRA_DEBUG_MPLS
) {
299 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
301 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
302 label
, nhlfe
->type
, buf
, nhlfe
->flags
);
305 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
)) {
306 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
307 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
313 /* Queue LSP for processing, if needed, else delete. */
314 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
)) {
315 if (lsp_processq_add(lsp
))
318 lsp_check_free(lsp_table
, &lsp
);
325 * This function is invoked upon change to label block configuration; it
326 * will walk all registered FECs with label-index and appropriately update
327 * their local labels and trigger client updates.
329 static void fec_evaluate(struct zebra_vrf
*zvrf
)
331 struct route_node
*rn
;
332 struct zebra_fec
*fec
;
333 uint32_t old_label
, new_label
;
336 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
337 if (zvrf
->fec_table
[af
] == NULL
)
340 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
341 rn
= route_next(rn
)) {
342 if ((fec
= rn
->info
) == NULL
)
345 /* Skip configured FECs and those without a label index.
347 if (fec
->flags
& FEC_FLAG_CONFIGURED
348 || fec
->label_index
== MPLS_INVALID_LABEL_INDEX
)
351 /* Save old label, determine new label. */
352 old_label
= fec
->label
;
354 zvrf
->mpls_srgb
.start_label
+ fec
->label_index
;
355 if (new_label
>= zvrf
->mpls_srgb
.end_label
)
356 new_label
= MPLS_INVALID_LABEL
;
358 /* If label has changed, update FEC and clients. */
359 if (new_label
== old_label
)
362 if (IS_ZEBRA_DEBUG_MPLS
)
364 "Update fec %pRN new label %u upon label block",
367 fec
->label
= new_label
;
368 fec_update_clients(fec
);
370 /* Update label forwarding entries appropriately */
371 fec_change_update_lsp(zvrf
, fec
, old_label
);
377 * Derive (if possible) and update the local label for the FEC based on
378 * its label index. The index is "acceptable" if it falls within the
379 * globally configured label block (SRGB).
381 static uint32_t fec_derive_label_from_index(struct zebra_vrf
*zvrf
,
382 struct zebra_fec
*fec
)
386 if (fec
->label_index
!= MPLS_INVALID_LABEL_INDEX
387 && zvrf
->mpls_srgb
.start_label
388 && ((label
= zvrf
->mpls_srgb
.start_label
+ fec
->label_index
)
389 < zvrf
->mpls_srgb
.end_label
))
392 fec
->label
= MPLS_INVALID_LABEL
;
398 * There is a change for this FEC. Install or uninstall label forwarding
399 * entries, as appropriate.
401 static int fec_change_update_lsp(struct zebra_vrf
*zvrf
, struct zebra_fec
*fec
,
402 mpls_label_t old_label
)
404 struct route_table
*table
;
405 struct route_node
*rn
;
406 struct route_entry
*re
;
409 /* Uninstall label forwarding entry, if previously installed. */
410 if (old_label
!= MPLS_INVALID_LABEL
411 && old_label
!= MPLS_LABEL_IMPLICIT_NULL
)
412 lsp_uninstall(zvrf
, old_label
);
414 /* Install label forwarding entry corr. to new label, if needed. */
415 if (fec
->label
== MPLS_INVALID_LABEL
416 || fec
->label
== MPLS_LABEL_IMPLICIT_NULL
)
419 afi
= family2afi(PREFIX_FAMILY(&fec
->rn
->p
));
420 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
424 /* See if labeled route exists. */
425 rn
= route_node_lookup(table
, &fec
->rn
->p
);
429 RNODE_FOREACH_RE (rn
, re
) {
430 if (CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
))
434 if (!re
|| !zebra_rib_labeled_unicast(re
))
437 if (lsp_install(zvrf
, fec
->label
, rn
, re
))
444 * Inform about FEC to a registered client.
446 static int fec_send(struct zebra_fec
*fec
, struct zserv
*client
)
449 struct route_node
*rn
;
453 /* Get output stream. */
454 s
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
456 zclient_create_header(s
, ZEBRA_FEC_UPDATE
, VRF_DEFAULT
);
458 stream_putw(s
, rn
->p
.family
);
459 stream_put_prefix(s
, &rn
->p
);
460 stream_putl(s
, fec
->label
);
461 stream_putw_at(s
, 0, stream_get_endp(s
));
462 return zserv_send_message(client
, s
);
466 * Update all registered clients about this FEC. Caller should've updated
467 * FEC and ensure no duplicate updates.
469 static void fec_update_clients(struct zebra_fec
*fec
)
471 struct listnode
*node
;
472 struct zserv
*client
;
474 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
, client
)) {
475 if (IS_ZEBRA_DEBUG_MPLS
)
476 zlog_debug("Update client %s",
477 zebra_route_string(client
->proto
));
478 fec_send(fec
, client
);
484 * Print a FEC-label binding entry.
486 static void fec_print(struct zebra_fec
*fec
, struct vty
*vty
)
488 struct route_node
*rn
;
489 struct listnode
*node
;
490 struct zserv
*client
;
494 vty_out(vty
, "%pRN\n", rn
);
495 vty_out(vty
, " Label: %s", label2str(fec
->label
, 0, buf
, BUFSIZ
));
496 if (fec
->label_index
!= MPLS_INVALID_LABEL_INDEX
)
497 vty_out(vty
, ", Label Index: %u", fec
->label_index
);
499 if (!list_isempty(fec
->client_list
)) {
500 vty_out(vty
, " Client list:");
501 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
, client
))
502 vty_out(vty
, " %s(fd %d)",
503 zebra_route_string(client
->proto
),
510 * Locate FEC-label binding that matches with passed info.
512 static struct zebra_fec
*fec_find(struct route_table
*table
, struct prefix
*p
)
514 struct route_node
*rn
;
517 rn
= route_node_lookup(table
, p
);
521 route_unlock_node(rn
);
526 * Add a FEC. This may be upon a client registering for a binding
527 * or when a binding is configured.
529 static struct zebra_fec
*fec_add(struct route_table
*table
, struct prefix
*p
,
530 mpls_label_t label
, uint32_t flags
,
531 uint32_t label_index
)
533 struct route_node
*rn
;
534 struct zebra_fec
*fec
;
538 /* Lookup (or add) route node.*/
539 rn
= route_node_get(table
, p
);
546 fec
= XCALLOC(MTYPE_FEC
, sizeof(struct zebra_fec
));
551 fec
->client_list
= list_new();
553 route_unlock_node(rn
); /* for the route_node_get */
555 fec
->label_index
= label_index
;
562 * Delete a FEC. This may be upon the last client deregistering for
563 * a FEC and no binding exists or when the binding is deleted and there
564 * are no registered clients.
566 static int fec_del(struct zebra_fec
*fec
)
568 list_delete(&fec
->client_list
);
569 fec
->rn
->info
= NULL
;
570 route_unlock_node(fec
->rn
);
571 XFREE(MTYPE_FEC
, fec
);
576 * Hash function for label.
578 static unsigned int label_hash(const void *p
)
580 const struct zebra_ile
*ile
= p
;
582 return (jhash_1word(ile
->in_label
, 0));
586 * Compare 2 LSP hash entries based on in-label.
588 static bool label_cmp(const void *p1
, const void *p2
)
590 const struct zebra_ile
*ile1
= p1
;
591 const struct zebra_ile
*ile2
= p2
;
593 return (ile1
->in_label
== ile2
->in_label
);
597 * Check if an IPv4 nexthop for a NHLFE is active. Update nexthop based on
599 * NOTE: Looking only for connected routes right now.
601 static int nhlfe_nexthop_active_ipv4(struct zebra_nhlfe
*nhlfe
,
602 struct nexthop
*nexthop
)
604 struct route_table
*table
;
605 struct prefix_ipv4 p
;
606 struct route_node
*rn
;
607 struct route_entry
*match
;
608 struct nexthop
*match_nh
;
610 table
= zebra_vrf_table(AFI_IP
, SAFI_UNICAST
, nexthop
->vrf_id
);
614 /* Lookup nexthop in IPv4 routing table. */
615 memset(&p
, 0, sizeof(p
));
617 p
.prefixlen
= IPV4_MAX_BITLEN
;
618 p
.prefix
= nexthop
->gate
.ipv4
;
620 rn
= route_node_match(table
, (struct prefix
*)&p
);
624 route_unlock_node(rn
);
626 /* Locate a valid connected route. */
627 RNODE_FOREACH_RE (rn
, match
) {
628 if (CHECK_FLAG(match
->status
, ROUTE_ENTRY_REMOVED
)
629 || !CHECK_FLAG(match
->flags
, ZEBRA_FLAG_SELECTED
))
632 for (match_nh
= match
->nhe
->nhg
.nexthop
; match_nh
;
633 match_nh
= match_nh
->next
) {
634 if (match
->type
== ZEBRA_ROUTE_CONNECT
635 || nexthop
->ifindex
== match_nh
->ifindex
) {
636 nexthop
->ifindex
= match_nh
->ifindex
;
647 * Check if an IPv6 nexthop for a NHLFE is active. Update nexthop based on
649 * NOTE: Looking only for connected routes right now.
651 static int nhlfe_nexthop_active_ipv6(struct zebra_nhlfe
*nhlfe
,
652 struct nexthop
*nexthop
)
654 struct route_table
*table
;
655 struct prefix_ipv6 p
;
656 struct route_node
*rn
;
657 struct route_entry
*match
;
659 table
= zebra_vrf_table(AFI_IP6
, SAFI_UNICAST
, nexthop
->vrf_id
);
663 /* Lookup nexthop in IPv6 routing table. */
664 memset(&p
, 0, sizeof(p
));
666 p
.prefixlen
= IPV6_MAX_BITLEN
;
667 p
.prefix
= nexthop
->gate
.ipv6
;
669 rn
= route_node_match(table
, (struct prefix
*)&p
);
673 route_unlock_node(rn
);
675 /* Locate a valid connected route. */
676 RNODE_FOREACH_RE (rn
, match
) {
677 if ((match
->type
== ZEBRA_ROUTE_CONNECT
)
678 && !CHECK_FLAG(match
->status
, ROUTE_ENTRY_REMOVED
)
679 && CHECK_FLAG(match
->flags
, ZEBRA_FLAG_SELECTED
))
683 if (!match
|| !match
->nhe
->nhg
.nexthop
)
686 nexthop
->ifindex
= match
->nhe
->nhg
.nexthop
->ifindex
;
692 * Check the nexthop reachability for a NHLFE and return if valid (reachable)
694 * NOTE: Each NHLFE points to only 1 nexthop.
696 static int nhlfe_nexthop_active(struct zebra_nhlfe
*nhlfe
)
698 struct nexthop
*nexthop
;
699 struct interface
*ifp
;
700 struct zebra_ns
*zns
;
702 nexthop
= nhlfe
->nexthop
;
703 if (!nexthop
) // unexpected
706 /* Check on nexthop based on type. */
707 switch (nexthop
->type
) {
708 case NEXTHOP_TYPE_IFINDEX
:
710 * Lookup if this type is special. The
711 * NEXTHOP_TYPE_IFINDEX is a pop and
712 * forward into a different table for
713 * processing. As such this ifindex
714 * passed to us may be a VRF device
715 * which will not be in the default
716 * VRF. So let's look in all of them
718 zns
= zebra_ns_lookup(NS_DEFAULT
);
719 ifp
= if_lookup_by_index_per_ns(zns
, nexthop
->ifindex
);
720 if (ifp
&& if_is_operative(ifp
))
721 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
723 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
725 case NEXTHOP_TYPE_IPV4
:
726 case NEXTHOP_TYPE_IPV4_IFINDEX
:
727 if (nhlfe_nexthop_active_ipv4(nhlfe
, nexthop
))
728 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
730 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
733 case NEXTHOP_TYPE_IPV6
:
734 if (nhlfe_nexthop_active_ipv6(nhlfe
, nexthop
))
735 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
737 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
740 case NEXTHOP_TYPE_IPV6_IFINDEX
:
741 if (IN6_IS_ADDR_LINKLOCAL(&nexthop
->gate
.ipv6
)) {
742 ifp
= if_lookup_by_index(nexthop
->ifindex
,
744 if (ifp
&& if_is_operative(ifp
))
745 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
747 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
749 if (nhlfe_nexthop_active_ipv6(nhlfe
, nexthop
))
750 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
752 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
756 case NEXTHOP_TYPE_BLACKHOLE
:
760 return CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
764 * Walk through NHLFEs for a LSP forwarding entry, verify nexthop
765 * reachability and select the best. Multipath entries are also
766 * marked. This is invoked when an LSP scheduled for processing (due
767 * to some change) is examined.
769 static void lsp_select_best_nhlfe(struct zebra_lsp
*lsp
)
771 struct zebra_nhlfe
*nhlfe
;
772 struct zebra_nhlfe
*best
;
773 struct nexthop
*nexthop
;
781 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
784 * First compute the best path, after checking nexthop status. We are
785 * only concerned with non-deleted NHLFEs.
787 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
788 /* Clear selection flags. */
789 UNSET_FLAG(nhlfe
->flags
,
790 (NHLFE_FLAG_SELECTED
| NHLFE_FLAG_MULTIPATH
));
792 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
)
793 && nhlfe_nexthop_active(nhlfe
)) {
794 if (!best
|| (nhlfe
->distance
< best
->distance
))
799 lsp
->best_nhlfe
= best
;
800 if (!lsp
->best_nhlfe
)
804 * Check the active status of backup nhlfes also
806 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
807 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
808 (void)nhlfe_nexthop_active(nhlfe
);
811 /* Mark best NHLFE as selected. */
812 SET_FLAG(lsp
->best_nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
815 * If best path exists, see if there is ECMP. While doing this, note if
817 * new (uninstalled) NHLFE has been selected, an installed entry that is
818 * still selected has a change or an installed entry is to be removed.
820 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
821 int nh_chg
, nh_sel
, nh_inst
;
823 nexthop
= nhlfe
->nexthop
;
824 if (!nexthop
) // unexpected
827 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
)
828 && CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
)
829 && (nhlfe
->distance
== lsp
->best_nhlfe
->distance
)) {
830 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
831 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_MULTIPATH
);
835 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) && !changed
) {
836 nh_chg
= CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
837 nh_sel
= CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
839 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
841 if ((nh_sel
&& !nh_inst
)
842 || (nh_sel
&& nh_inst
&& nh_chg
)
843 || (nh_inst
&& !nh_sel
))
847 /* We have finished examining, clear changed flag. */
848 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
852 SET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
856 * Delete LSP forwarding entry from kernel, if installed. Called upon
859 static void lsp_uninstall_from_kernel(struct hash_bucket
*bucket
, void *ctxt
)
861 struct zebra_lsp
*lsp
;
863 lsp
= (struct zebra_lsp
*)bucket
->data
;
864 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
865 (void)dplane_lsp_delete(lsp
);
869 * Schedule LSP forwarding entry for processing. Called upon changes
870 * that may impact LSPs such as nexthop / connected route changes.
872 static void lsp_schedule(struct hash_bucket
*bucket
, void *ctxt
)
874 struct zebra_lsp
*lsp
;
876 lsp
= (struct zebra_lsp
*)bucket
->data
;
878 /* In the common flow, this is used when external events occur. For
879 * LSPs with backup nhlfes, we'll assume that the forwarding
880 * plane will use the backups to handle these events, until the
881 * owning protocol can react.
884 /* Skip LSPs with backups */
885 if (nhlfe_list_first(&lsp
->backup_nhlfe_list
) != NULL
) {
886 if (IS_ZEBRA_DEBUG_MPLS_DETAIL
)
887 zlog_debug("%s: skip LSP in-label %u",
888 __func__
, lsp
->ile
.in_label
);
893 (void)lsp_processq_add(lsp
);
897 * Process a LSP entry that is in the queue. Recalculate best NHLFE and
898 * any multipaths and update or delete from the kernel, as needed.
900 static wq_item_status
lsp_process(struct work_queue
*wq
, void *data
)
902 struct zebra_lsp
*lsp
;
903 struct zebra_nhlfe
*oldbest
, *newbest
;
904 char buf
[BUFSIZ
], buf2
[BUFSIZ
];
905 struct zebra_vrf
*zvrf
= vrf_info_lookup(VRF_DEFAULT
);
906 enum zebra_dplane_result res
;
908 lsp
= (struct zebra_lsp
*)data
;
909 if (!lsp
) // unexpected
912 oldbest
= lsp
->best_nhlfe
;
914 /* Select best NHLFE(s) */
915 lsp_select_best_nhlfe(lsp
);
917 newbest
= lsp
->best_nhlfe
;
919 if (IS_ZEBRA_DEBUG_MPLS
) {
921 nhlfe2str(oldbest
, buf
, sizeof(buf
));
923 nhlfe2str(newbest
, buf2
, sizeof(buf2
));
925 "Process LSP in-label %u oldbest %s newbest %s flags 0x%x ecmp# %d",
926 lsp
->ile
.in_label
, oldbest
? buf
: "NULL",
927 newbest
? buf2
: "NULL", lsp
->flags
, lsp
->num_ecmp
);
930 if (!CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
)) {
931 /* Not already installed */
934 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
936 switch (dplane_lsp_add(lsp
)) {
937 case ZEBRA_DPLANE_REQUEST_QUEUED
:
938 /* Set 'installed' flag so we will know
939 * that an install is in-flight.
941 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
943 zvrf
->lsp_installs_queued
++;
945 case ZEBRA_DPLANE_REQUEST_FAILURE
:
946 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
947 "LSP Install Failure: %u",
950 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
951 zvrf
->lsp_installs
++;
956 /* Installed, may need an update and/or delete. */
958 res
= dplane_lsp_delete(lsp
);
960 /* We do some of the lsp cleanup immediately for
963 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
964 clear_nhlfe_installed(lsp
);
967 case ZEBRA_DPLANE_REQUEST_QUEUED
:
968 zvrf
->lsp_removals_queued
++;
970 case ZEBRA_DPLANE_REQUEST_FAILURE
:
971 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE
,
972 "LSP Deletion Failure: %u",
975 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
976 zvrf
->lsp_removals
++;
979 } else if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
)) {
980 struct zebra_nhlfe
*nhlfe
;
981 struct nexthop
*nexthop
;
983 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
985 /* We leave the INSTALLED flag set here
986 * so we know an update is in-flight.
990 * Any NHLFE that was installed but is not
991 * selected now needs to have its flags updated.
993 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
994 nexthop
= nhlfe
->nexthop
;
998 if (CHECK_FLAG(nhlfe
->flags
,
999 NHLFE_FLAG_INSTALLED
)
1000 && !CHECK_FLAG(nhlfe
->flags
,
1001 NHLFE_FLAG_SELECTED
)) {
1002 UNSET_FLAG(nhlfe
->flags
,
1003 NHLFE_FLAG_INSTALLED
);
1004 UNSET_FLAG(nexthop
->flags
,
1009 switch (dplane_lsp_update(lsp
)) {
1010 case ZEBRA_DPLANE_REQUEST_QUEUED
:
1011 zvrf
->lsp_installs_queued
++;
1013 case ZEBRA_DPLANE_REQUEST_FAILURE
:
1014 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
1015 "LSP Update Failure: %u",
1018 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
1019 zvrf
->lsp_installs
++;
1030 * Callback upon processing completion of a LSP forwarding entry.
1032 static void lsp_processq_del(struct work_queue
*wq
, void *data
)
1034 struct zebra_vrf
*zvrf
;
1035 struct zebra_lsp
*lsp
;
1036 struct hash
*lsp_table
;
1037 struct zebra_nhlfe
*nhlfe
;
1039 /* If zebra is shutting down, don't delete any structs,
1040 * just ignore this callback. The LSPs will be cleaned up
1041 * during the shutdown processing.
1043 if (zebra_router_in_shutdown())
1046 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
1049 lsp_table
= zvrf
->lsp_table
;
1050 if (!lsp_table
) // unexpected
1053 lsp
= (struct zebra_lsp
*)data
;
1054 if (!lsp
) // unexpected
1057 /* Clear flag, remove any NHLFEs marked for deletion. If no NHLFEs
1059 * delete LSP entry also.
1061 UNSET_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
);
1063 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1064 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
1068 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1069 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
1073 lsp_check_free(lsp_table
, &lsp
);
1077 * Callback upon finishing the processing of all scheduled
1078 * LSP forwarding entries.
1080 static void lsp_processq_complete(struct work_queue
*wq
)
1082 /* Nothing to do for now. */
1086 * Add LSP forwarding entry to queue for subsequent processing.
1088 static int lsp_processq_add(struct zebra_lsp
*lsp
)
1090 /* If already scheduled, exit. */
1091 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
))
1094 if (zrouter
.lsp_process_q
== NULL
) {
1095 flog_err(EC_ZEBRA_WQ_NONEXISTENT
,
1096 "%s: work_queue does not exist!", __func__
);
1100 work_queue_add(zrouter
.lsp_process_q
, lsp
);
1101 SET_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
);
1106 * Callback to allocate LSP forwarding table entry.
1108 static void *lsp_alloc(void *p
)
1110 const struct zebra_ile
*ile
= p
;
1111 struct zebra_lsp
*lsp
;
1113 lsp
= XCALLOC(MTYPE_LSP
, sizeof(struct zebra_lsp
));
1115 nhlfe_list_init(&lsp
->nhlfe_list
);
1116 nhlfe_list_init(&lsp
->backup_nhlfe_list
);
1118 if (IS_ZEBRA_DEBUG_MPLS
)
1119 zlog_debug("Alloc LSP in-label %u", lsp
->ile
.in_label
);
1121 return ((void *)lsp
);
1125 * Check whether lsp can be freed - no nhlfes, e.g., and call free api
1127 static void lsp_check_free(struct hash
*lsp_table
, struct zebra_lsp
**plsp
)
1129 struct zebra_lsp
*lsp
;
1131 if (plsp
== NULL
|| *plsp
== NULL
)
1136 if ((nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
) &&
1137 (nhlfe_list_first(&lsp
->backup_nhlfe_list
) == NULL
) &&
1138 !CHECK_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
))
1139 lsp_free(lsp_table
, plsp
);
1142 static void lsp_free_nhlfe(struct zebra_lsp
*lsp
)
1144 struct zebra_nhlfe
*nhlfe
;
1146 while ((nhlfe
= nhlfe_list_first(&lsp
->nhlfe_list
))) {
1147 nhlfe_list_del(&lsp
->nhlfe_list
, nhlfe
);
1151 while ((nhlfe
= nhlfe_list_first(&lsp
->backup_nhlfe_list
))) {
1152 nhlfe_list_del(&lsp
->backup_nhlfe_list
, nhlfe
);
1158 * Dtor for an LSP: remove from ile hash, release any internal allocations,
1161 static void lsp_free(struct hash
*lsp_table
, struct zebra_lsp
**plsp
)
1163 struct zebra_lsp
*lsp
;
1165 if (plsp
== NULL
|| *plsp
== NULL
)
1170 if (IS_ZEBRA_DEBUG_MPLS
)
1171 zlog_debug("Free LSP in-label %u flags 0x%x",
1172 lsp
->ile
.in_label
, lsp
->flags
);
1174 lsp_free_nhlfe(lsp
);
1176 hash_release(lsp_table
, &lsp
->ile
);
1177 XFREE(MTYPE_LSP
, lsp
);
1183 * Create printable string for NHLFE entry.
1185 static char *nhlfe2str(const struct zebra_nhlfe
*nhlfe
, char *buf
, int size
)
1187 const struct nexthop
*nexthop
;
1190 nexthop
= nhlfe
->nexthop
;
1191 switch (nexthop
->type
) {
1192 case NEXTHOP_TYPE_IPV4
:
1193 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1194 inet_ntop(AF_INET
, &nexthop
->gate
.ipv4
, buf
, size
);
1196 case NEXTHOP_TYPE_IPV6
:
1197 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1198 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, size
);
1200 case NEXTHOP_TYPE_IFINDEX
:
1201 snprintf(buf
, size
, "Ifindex: %u", nexthop
->ifindex
);
1202 case NEXTHOP_TYPE_BLACKHOLE
:
1210 * Check if NHLFE matches with search info passed.
1212 static int nhlfe_nhop_match(struct zebra_nhlfe
*nhlfe
,
1213 enum nexthop_types_t gtype
,
1214 const union g_addr
*gate
, ifindex_t ifindex
)
1216 struct nexthop
*nhop
;
1219 nhop
= nhlfe
->nexthop
;
1223 if (nhop
->type
!= gtype
)
1226 switch (nhop
->type
) {
1227 case NEXTHOP_TYPE_IPV4
:
1228 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1229 cmp
= memcmp(&(nhop
->gate
.ipv4
), &(gate
->ipv4
),
1230 sizeof(struct in_addr
));
1231 if (!cmp
&& nhop
->type
== NEXTHOP_TYPE_IPV4_IFINDEX
)
1232 cmp
= !(nhop
->ifindex
== ifindex
);
1234 case NEXTHOP_TYPE_IPV6
:
1235 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1236 cmp
= memcmp(&(nhop
->gate
.ipv6
), &(gate
->ipv6
),
1237 sizeof(struct in6_addr
));
1238 if (!cmp
&& nhop
->type
== NEXTHOP_TYPE_IPV6_IFINDEX
)
1239 cmp
= !(nhop
->ifindex
== ifindex
);
1241 case NEXTHOP_TYPE_IFINDEX
:
1242 cmp
= !(nhop
->ifindex
== ifindex
);
1244 case NEXTHOP_TYPE_BLACKHOLE
:
1253 * Locate NHLFE that matches with passed info.
1255 static struct zebra_nhlfe
*nhlfe_find(struct nhlfe_list_head
*list
,
1256 enum lsp_types_t lsp_type
,
1257 enum nexthop_types_t gtype
,
1258 const union g_addr
*gate
,
1261 struct zebra_nhlfe
*nhlfe
;
1263 frr_each_safe(nhlfe_list
, list
, nhlfe
) {
1264 if (nhlfe
->type
!= lsp_type
)
1266 if (!nhlfe_nhop_match(nhlfe
, gtype
, gate
, ifindex
))
1274 * Allocate and init new NHLFE.
1276 static struct zebra_nhlfe
*
1277 nhlfe_alloc(struct zebra_lsp
*lsp
, enum lsp_types_t lsp_type
,
1278 enum nexthop_types_t gtype
, const union g_addr
*gate
,
1279 ifindex_t ifindex
, uint8_t num_labels
, const mpls_label_t
*labels
)
1281 struct zebra_nhlfe
*nhlfe
;
1282 struct nexthop
*nexthop
;
1286 nhlfe
= XCALLOC(MTYPE_NHLFE
, sizeof(struct zebra_nhlfe
));
1289 nhlfe
->type
= lsp_type
;
1290 nhlfe
->distance
= lsp_distance(lsp_type
);
1292 nexthop
= nexthop_new();
1294 nexthop_add_labels(nexthop
, lsp_type
, num_labels
, labels
);
1296 nexthop
->vrf_id
= VRF_DEFAULT
;
1297 nexthop
->type
= gtype
;
1298 switch (nexthop
->type
) {
1299 case NEXTHOP_TYPE_IPV4
:
1300 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1301 nexthop
->gate
.ipv4
= gate
->ipv4
;
1303 nexthop
->ifindex
= ifindex
;
1305 case NEXTHOP_TYPE_IPV6
:
1306 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1307 nexthop
->gate
.ipv6
= gate
->ipv6
;
1309 nexthop
->ifindex
= ifindex
;
1311 case NEXTHOP_TYPE_IFINDEX
:
1312 nexthop
->ifindex
= ifindex
;
1314 case NEXTHOP_TYPE_BLACKHOLE
:
1315 if (IS_ZEBRA_DEBUG_MPLS
)
1316 zlog_debug("%s: invalid: blackhole nexthop", __func__
);
1318 nexthop_free(nexthop
);
1319 XFREE(MTYPE_NHLFE
, nhlfe
);
1322 nhlfe
->nexthop
= nexthop
;
1328 * Add primary or backup NHLFE. Base entry must have been created and
1329 * duplicate check done.
1331 static struct zebra_nhlfe
*nhlfe_add(struct zebra_lsp
*lsp
,
1332 enum lsp_types_t lsp_type
,
1333 enum nexthop_types_t gtype
,
1334 const union g_addr
*gate
,
1335 ifindex_t ifindex
, uint8_t num_labels
,
1336 const mpls_label_t
*labels
, bool is_backup
)
1338 struct zebra_nhlfe
*nhlfe
;
1343 /* Must have labels */
1344 if (num_labels
== 0 || labels
== NULL
) {
1345 if (IS_ZEBRA_DEBUG_MPLS
)
1346 zlog_debug("%s: invalid nexthop: no labels", __func__
);
1351 /* Allocate new object */
1352 nhlfe
= nhlfe_alloc(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
1358 /* Enqueue to LSP: primaries at head of list, backups at tail */
1360 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
);
1361 nhlfe_list_add_tail(&lsp
->backup_nhlfe_list
, nhlfe
);
1363 nhlfe_list_add_head(&lsp
->nhlfe_list
, nhlfe
);
1369 * Common delete for NHLFEs.
1371 static void nhlfe_free(struct zebra_nhlfe
*nhlfe
)
1378 nexthop_free(nhlfe
->nexthop
);
1380 nhlfe
->nexthop
= NULL
;
1382 XFREE(MTYPE_NHLFE
, nhlfe
);
1387 * Disconnect NHLFE from LSP, and free. Entry must be present on LSP's list.
1389 static int nhlfe_del(struct zebra_nhlfe
*nhlfe
)
1391 struct zebra_lsp
*lsp
;
1400 if (nhlfe
== lsp
->best_nhlfe
)
1401 lsp
->best_nhlfe
= NULL
;
1403 /* Unlink from LSP */
1404 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
))
1405 nhlfe_list_del(&lsp
->backup_nhlfe_list
, nhlfe
);
1407 nhlfe_list_del(&lsp
->nhlfe_list
, nhlfe
);
1417 * Update label for NHLFE entry.
1419 static void nhlfe_out_label_update(struct zebra_nhlfe
*nhlfe
,
1420 struct mpls_label_stack
*nh_label
)
1422 nhlfe
->nexthop
->nh_label
->label
[0] = nh_label
->label
[0];
1425 static int mpls_lsp_uninstall_all(struct hash
*lsp_table
, struct zebra_lsp
*lsp
,
1426 enum lsp_types_t type
)
1428 struct zebra_nhlfe
*nhlfe
;
1429 int schedule_lsp
= 0;
1432 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
1435 /* Mark NHLFEs for delete or directly delete, as appropriate. */
1436 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1437 /* Skip non-static NHLFEs */
1438 if (nhlfe
->type
!= type
)
1441 if (IS_ZEBRA_DEBUG_MPLS
) {
1442 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
1444 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
1445 lsp
->ile
.in_label
, type
, buf
, nhlfe
->flags
);
1448 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
)) {
1449 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
1450 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
1457 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1458 /* Skip non-static NHLFEs */
1459 if (nhlfe
->type
!= type
)
1462 if (IS_ZEBRA_DEBUG_MPLS
) {
1463 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
1465 "Del backup LSP in-label %u type %d nexthop %s flags 0x%x",
1466 lsp
->ile
.in_label
, type
, buf
, nhlfe
->flags
);
1469 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
)) {
1470 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
1471 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
1478 /* Queue LSP for processing, if needed, else delete. */
1480 if (IS_ZEBRA_DEBUG_MPLS
) {
1481 zlog_debug("Schedule LSP in-label %u flags 0x%x",
1482 lsp
->ile
.in_label
, lsp
->flags
);
1484 if (lsp_processq_add(lsp
))
1487 lsp_check_free(lsp_table
, &lsp
);
1494 * Uninstall all static NHLFEs for a particular LSP forwarding entry.
1495 * If no other NHLFEs exist, the entry would be deleted.
1497 static int mpls_static_lsp_uninstall_all(struct zebra_vrf
*zvrf
,
1498 mpls_label_t in_label
)
1500 struct hash
*lsp_table
;
1501 struct zebra_ile tmp_ile
;
1502 struct zebra_lsp
*lsp
;
1505 lsp_table
= zvrf
->lsp_table
;
1509 /* If entry is not present, exit. */
1510 tmp_ile
.in_label
= in_label
;
1511 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
1512 if (!lsp
|| (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
))
1515 return mpls_lsp_uninstall_all(lsp_table
, lsp
, ZEBRA_LSP_STATIC
);
1518 static json_object
*nhlfe_json(struct zebra_nhlfe
*nhlfe
)
1520 json_object
*json_nhlfe
= NULL
;
1521 json_object
*json_backups
= NULL
;
1522 json_object
*json_label_stack
;
1523 struct nexthop
*nexthop
= nhlfe
->nexthop
;
1526 json_nhlfe
= json_object_new_object();
1527 json_object_string_add(json_nhlfe
, "type", nhlfe_type2str(nhlfe
->type
));
1528 json_object_int_add(json_nhlfe
, "outLabel",
1529 nexthop
->nh_label
->label
[0]);
1531 json_label_stack
= json_object_new_array();
1532 json_object_object_add(json_nhlfe
, "outLabelStack", json_label_stack
);
1533 for (i
= 0; i
< nexthop
->nh_label
->num_labels
; i
++)
1534 json_object_array_add(
1536 json_object_new_int(nexthop
->nh_label
->label
[i
]));
1538 json_object_int_add(json_nhlfe
, "distance", nhlfe
->distance
);
1540 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
))
1541 json_object_boolean_true_add(json_nhlfe
, "installed");
1543 switch (nexthop
->type
) {
1544 case NEXTHOP_TYPE_IPV4
:
1545 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1546 json_object_string_addf(json_nhlfe
, "nexthop", "%pI4",
1547 &nexthop
->gate
.ipv4
);
1549 case NEXTHOP_TYPE_IPV6
:
1550 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1551 json_object_string_addf(json_nhlfe
, "nexthop", "%pI6",
1552 &nexthop
->gate
.ipv6
);
1554 if (nexthop
->ifindex
)
1555 json_object_string_add(json_nhlfe
, "interface",
1556 ifindex2ifname(nexthop
->ifindex
,
1559 case NEXTHOP_TYPE_IFINDEX
:
1560 if (nexthop
->ifindex
)
1561 json_object_string_add(json_nhlfe
, "interface",
1562 ifindex2ifname(nexthop
->ifindex
,
1565 case NEXTHOP_TYPE_BLACKHOLE
:
1569 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
)) {
1570 json_backups
= json_object_new_array();
1571 for (i
= 0; i
< nexthop
->backup_num
; i
++) {
1572 json_object_array_add(
1574 json_object_new_int(nexthop
->backup_idx
[i
]));
1577 json_object_object_add(json_nhlfe
, "backupIndex",
1585 * Print the NHLFE for a LSP forwarding entry.
1587 static void nhlfe_print(struct zebra_nhlfe
*nhlfe
, struct vty
*vty
,
1590 struct nexthop
*nexthop
;
1591 char buf
[MPLS_LABEL_STRLEN
];
1593 nexthop
= nhlfe
->nexthop
;
1594 if (!nexthop
|| !nexthop
->nh_label
) // unexpected
1597 vty_out(vty
, " type: %s remote label: %s distance: %d\n",
1598 nhlfe_type2str(nhlfe
->type
),
1599 mpls_label2str(nexthop
->nh_label
->num_labels
,
1600 nexthop
->nh_label
->label
, buf
, sizeof(buf
),
1601 nexthop
->nh_label_type
, 0),
1605 vty_out(vty
, "%s", indent
);
1607 switch (nexthop
->type
) {
1608 case NEXTHOP_TYPE_IPV4
:
1609 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1610 vty_out(vty
, " via %pI4", &nexthop
->gate
.ipv4
);
1611 if (nexthop
->ifindex
)
1612 vty_out(vty
, " dev %s",
1613 ifindex2ifname(nexthop
->ifindex
,
1616 case NEXTHOP_TYPE_IPV6
:
1617 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1618 vty_out(vty
, " via %s",
1619 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
,
1621 if (nexthop
->ifindex
)
1622 vty_out(vty
, " dev %s",
1623 ifindex2ifname(nexthop
->ifindex
,
1626 case NEXTHOP_TYPE_IFINDEX
:
1627 if (nexthop
->ifindex
)
1628 vty_out(vty
, " dev %s",
1629 ifindex2ifname(nexthop
->ifindex
,
1632 case NEXTHOP_TYPE_BLACKHOLE
:
1636 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
) ? " (backup)"
1639 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
) ? " (installed)"
1645 * Print an LSP forwarding entry.
1647 static void lsp_print(struct vty
*vty
, struct zebra_lsp
*lsp
)
1649 struct zebra_nhlfe
*nhlfe
, *backup
;
1652 vty_out(vty
, "Local label: %u%s\n", lsp
->ile
.in_label
,
1653 CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) ? " (installed)"
1656 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1657 nhlfe_print(nhlfe
, vty
, NULL
);
1659 if (nhlfe
->nexthop
== NULL
||
1660 !CHECK_FLAG(nhlfe
->nexthop
->flags
,
1661 NEXTHOP_FLAG_HAS_BACKUP
))
1664 /* Backup nhlfes: find backups in backup list */
1666 for (j
= 0; j
< nhlfe
->nexthop
->backup_num
; j
++) {
1669 frr_each(nhlfe_list
, &lsp
->backup_nhlfe_list
, backup
) {
1670 if (i
== nhlfe
->nexthop
->backup_idx
[j
])
1676 vty_out(vty
, " [backup %d]", i
);
1677 nhlfe_print(backup
, vty
, " ");
1684 * JSON objects for an LSP forwarding entry.
1686 static json_object
*lsp_json(struct zebra_lsp
*lsp
)
1688 struct zebra_nhlfe
*nhlfe
= NULL
;
1689 json_object
*json
= json_object_new_object();
1690 json_object
*json_nhlfe_list
= json_object_new_array();
1692 json_object_int_add(json
, "inLabel", lsp
->ile
.in_label
);
1694 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
1695 json_object_boolean_true_add(json
, "installed");
1697 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
)
1698 json_object_array_add(json_nhlfe_list
, nhlfe_json(nhlfe
));
1700 json_object_object_add(json
, "nexthops", json_nhlfe_list
);
1701 json_nhlfe_list
= NULL
;
1704 frr_each(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1705 if (json_nhlfe_list
== NULL
)
1706 json_nhlfe_list
= json_object_new_array();
1708 json_object_array_add(json_nhlfe_list
, nhlfe_json(nhlfe
));
1711 if (json_nhlfe_list
)
1712 json_object_object_add(json
, "backupNexthops", json_nhlfe_list
);
1718 /* Return a sorted linked list of the hash contents */
1719 static struct list
*hash_get_sorted_list(struct hash
*hash
, void *cmp
)
1722 struct hash_bucket
*hb
;
1723 struct list
*sorted_list
= list_new();
1725 sorted_list
->cmp
= (int (*)(void *, void *))cmp
;
1727 for (i
= 0; i
< hash
->size
; i
++)
1728 for (hb
= hash
->index
[i
]; hb
; hb
= hb
->next
)
1729 listnode_add_sort(sorted_list
, hb
->data
);
1735 * Compare two LSPs based on their label values.
1737 static int lsp_cmp(const struct zebra_lsp
*lsp1
, const struct zebra_lsp
*lsp2
)
1739 if (lsp1
->ile
.in_label
< lsp2
->ile
.in_label
)
1742 if (lsp1
->ile
.in_label
> lsp2
->ile
.in_label
)
1749 * Initialize work queue for processing changed LSPs.
1751 static void mpls_processq_init(void)
1753 zrouter
.lsp_process_q
= work_queue_new(zrouter
.master
, "LSP processing");
1755 zrouter
.lsp_process_q
->spec
.workfunc
= &lsp_process
;
1756 zrouter
.lsp_process_q
->spec
.del_item_data
= &lsp_processq_del
;
1757 zrouter
.lsp_process_q
->spec
.completion_func
= &lsp_processq_complete
;
1758 zrouter
.lsp_process_q
->spec
.max_retries
= 0;
1759 zrouter
.lsp_process_q
->spec
.hold
= 10;
1764 * Process LSP update results from zebra dataplane.
1766 void zebra_mpls_lsp_dplane_result(struct zebra_dplane_ctx
*ctx
)
1768 struct zebra_vrf
*zvrf
;
1770 struct zebra_ile tmp_ile
;
1771 struct hash
*lsp_table
;
1772 struct zebra_lsp
*lsp
;
1773 struct zebra_nhlfe
*nhlfe
;
1774 struct nexthop
*nexthop
;
1775 enum dplane_op_e op
;
1776 enum zebra_dplane_result status
;
1777 enum zebra_sr_policy_update_label_mode update_mode
;
1779 op
= dplane_ctx_get_op(ctx
);
1780 status
= dplane_ctx_get_status(ctx
);
1782 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
1783 zlog_debug("LSP dplane ctx %p, op %s, in-label %u, result %s",
1784 ctx
, dplane_op2str(op
),
1785 dplane_ctx_get_in_label(ctx
),
1786 dplane_res2str(status
));
1788 label
= dplane_ctx_get_in_label(ctx
);
1791 case DPLANE_OP_LSP_INSTALL
:
1792 case DPLANE_OP_LSP_UPDATE
:
1793 /* Look for zebra LSP object */
1794 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
1798 lsp_table
= zvrf
->lsp_table
;
1800 tmp_ile
.in_label
= label
;
1801 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
1803 if (IS_ZEBRA_DEBUG_DPLANE
)
1804 zlog_debug("LSP ctx %p: in-label %u not found",
1805 ctx
, dplane_ctx_get_in_label(ctx
));
1809 /* TODO -- Confirm that this result is still 'current' */
1811 if (status
!= ZEBRA_DPLANE_REQUEST_SUCCESS
) {
1812 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
1813 clear_nhlfe_installed(lsp
);
1814 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
1815 "LSP Install Failure: in-label %u",
1820 /* Update zebra object */
1821 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
1822 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1823 nexthop
= nhlfe
->nexthop
;
1827 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
) &&
1828 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
)) {
1829 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
1830 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
1834 update_mode
= (op
== DPLANE_OP_LSP_INSTALL
)
1835 ? ZEBRA_SR_POLICY_LABEL_CREATED
1836 : ZEBRA_SR_POLICY_LABEL_UPDATED
;
1837 zebra_sr_policy_label_update(label
, update_mode
);
1840 case DPLANE_OP_LSP_DELETE
:
1841 if (status
!= ZEBRA_DPLANE_REQUEST_SUCCESS
) {
1842 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE
,
1843 "LSP Deletion Failure: in-label %u",
1844 dplane_ctx_get_in_label(ctx
));
1847 zebra_sr_policy_label_update(label
,
1848 ZEBRA_SR_POLICY_LABEL_REMOVED
);
1851 case DPLANE_OP_LSP_NOTIFY
:
1852 case DPLANE_OP_NONE
:
1853 case DPLANE_OP_ROUTE_INSTALL
:
1854 case DPLANE_OP_ROUTE_UPDATE
:
1855 case DPLANE_OP_ROUTE_DELETE
:
1856 case DPLANE_OP_ROUTE_NOTIFY
:
1857 case DPLANE_OP_NH_INSTALL
:
1858 case DPLANE_OP_NH_UPDATE
:
1859 case DPLANE_OP_NH_DELETE
:
1860 case DPLANE_OP_PW_INSTALL
:
1861 case DPLANE_OP_PW_UNINSTALL
:
1862 case DPLANE_OP_SYS_ROUTE_ADD
:
1863 case DPLANE_OP_SYS_ROUTE_DELETE
:
1864 case DPLANE_OP_ADDR_INSTALL
:
1865 case DPLANE_OP_ADDR_UNINSTALL
:
1866 case DPLANE_OP_MAC_INSTALL
:
1867 case DPLANE_OP_MAC_DELETE
:
1868 case DPLANE_OP_NEIGH_INSTALL
:
1869 case DPLANE_OP_NEIGH_UPDATE
:
1870 case DPLANE_OP_NEIGH_DELETE
:
1871 case DPLANE_OP_VTEP_ADD
:
1872 case DPLANE_OP_VTEP_DELETE
:
1873 case DPLANE_OP_RULE_ADD
:
1874 case DPLANE_OP_RULE_DELETE
:
1875 case DPLANE_OP_RULE_UPDATE
:
1876 case DPLANE_OP_NEIGH_DISCOVER
:
1877 case DPLANE_OP_BR_PORT_UPDATE
:
1878 case DPLANE_OP_IPTABLE_ADD
:
1879 case DPLANE_OP_IPTABLE_DELETE
:
1880 case DPLANE_OP_IPSET_ADD
:
1881 case DPLANE_OP_IPSET_DELETE
:
1882 case DPLANE_OP_IPSET_ENTRY_ADD
:
1883 case DPLANE_OP_IPSET_ENTRY_DELETE
:
1884 case DPLANE_OP_NEIGH_IP_INSTALL
:
1885 case DPLANE_OP_NEIGH_IP_DELETE
:
1886 case DPLANE_OP_NEIGH_TABLE_UPDATE
:
1887 case DPLANE_OP_GRE_SET
:
1888 case DPLANE_OP_INTF_ADDR_ADD
:
1889 case DPLANE_OP_INTF_ADDR_DEL
:
1890 case DPLANE_OP_INTF_NETCONFIG
:
1891 case DPLANE_OP_INTF_INSTALL
:
1892 case DPLANE_OP_INTF_UPDATE
:
1893 case DPLANE_OP_INTF_DELETE
:
1894 case DPLANE_OP_TC_QDISC_INSTALL
:
1895 case DPLANE_OP_TC_QDISC_UNINSTALL
:
1896 case DPLANE_OP_TC_CLASS_ADD
:
1897 case DPLANE_OP_TC_CLASS_DELETE
:
1898 case DPLANE_OP_TC_CLASS_UPDATE
:
1899 case DPLANE_OP_TC_FILTER_ADD
:
1900 case DPLANE_OP_TC_FILTER_DELETE
:
1901 case DPLANE_OP_TC_FILTER_UPDATE
:
1908 * Process LSP installation info from two sets of nhlfes: a set from
1909 * a dplane notification, and a set from the zebra LSP object. Update
1910 * counters of installed nexthops, and return whether the LSP has changed.
1912 static bool compare_notif_nhlfes(const struct nhlfe_list_head
*ctx_head
,
1913 struct nhlfe_list_head
*nhlfe_head
,
1914 int *start_counter
, int *end_counter
)
1916 struct zebra_nhlfe
*nhlfe
;
1917 const struct zebra_nhlfe
*ctx_nhlfe
;
1918 struct nexthop
*nexthop
;
1919 const struct nexthop
*ctx_nexthop
;
1920 int start_count
= 0, end_count
= 0;
1921 bool changed_p
= false;
1922 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
1924 frr_each_safe(nhlfe_list
, nhlfe_head
, nhlfe
) {
1925 char buf
[NEXTHOP_STRLEN
];
1927 nexthop
= nhlfe
->nexthop
;
1931 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
))
1936 frr_each(nhlfe_list_const
, ctx_head
, ctx_nhlfe
) {
1937 ctx_nexthop
= ctx_nhlfe
->nexthop
;
1941 if ((ctx_nexthop
->type
== nexthop
->type
) &&
1942 nexthop_same(ctx_nexthop
, nexthop
)) {
1949 nexthop2str(nexthop
, buf
, sizeof(buf
));
1951 if (ctx_nhlfe
&& ctx_nexthop
) {
1953 const char *tstr
= "";
1955 if (!CHECK_FLAG(ctx_nhlfe
->flags
,
1956 NHLFE_FLAG_INSTALLED
))
1959 zlog_debug("LSP dplane notif: matched nh %s (%sinstalled)",
1963 /* Test zebra nhlfe install state */
1964 if (CHECK_FLAG(ctx_nhlfe
->flags
,
1965 NHLFE_FLAG_INSTALLED
)) {
1967 if (!CHECK_FLAG(nhlfe
->flags
,
1968 NHLFE_FLAG_INSTALLED
))
1971 /* Update counter */
1975 if (CHECK_FLAG(nhlfe
->flags
,
1976 NHLFE_FLAG_INSTALLED
))
1981 /* Not mentioned in lfib set -> uninstalled */
1982 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
) ||
1983 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
) ||
1984 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
)) {
1989 zlog_debug("LSP dplane notif: no match, nh %s",
1995 *start_counter
+= start_count
;
1997 *end_counter
+= end_count
;
2003 * Update an lsp nhlfe list from a dplane context, typically an async
2004 * notification context. Update the LSP list to match the installed
2005 * status from the context's list.
2007 static int update_nhlfes_from_ctx(struct nhlfe_list_head
*nhlfe_head
,
2008 const struct nhlfe_list_head
*ctx_head
)
2011 struct zebra_nhlfe
*nhlfe
;
2012 const struct zebra_nhlfe
*ctx_nhlfe
;
2013 struct nexthop
*nexthop
;
2014 const struct nexthop
*ctx_nexthop
;
2015 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
2017 frr_each_safe(nhlfe_list
, nhlfe_head
, nhlfe
) {
2018 char buf
[NEXTHOP_STRLEN
];
2020 nexthop
= nhlfe
->nexthop
;
2026 frr_each(nhlfe_list_const
, ctx_head
, ctx_nhlfe
) {
2027 ctx_nexthop
= ctx_nhlfe
->nexthop
;
2031 if ((ctx_nexthop
->type
== nexthop
->type
) &&
2032 nexthop_same(ctx_nexthop
, nexthop
)) {
2039 nexthop2str(nexthop
, buf
, sizeof(buf
));
2041 if (ctx_nhlfe
&& ctx_nexthop
) {
2043 /* Bring zebra nhlfe install state into sync */
2044 if (CHECK_FLAG(ctx_nhlfe
->flags
,
2045 NHLFE_FLAG_INSTALLED
)) {
2047 zlog_debug("%s: matched lsp nhlfe %s (installed)",
2050 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
2051 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
2055 zlog_debug("%s: matched lsp nhlfe %s (not installed)",
2058 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
2059 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
2062 if (CHECK_FLAG(ctx_nhlfe
->nexthop
->flags
,
2063 NEXTHOP_FLAG_FIB
)) {
2064 SET_FLAG(nhlfe
->nexthop
->flags
,
2065 NEXTHOP_FLAG_ACTIVE
);
2066 SET_FLAG(nhlfe
->nexthop
->flags
,
2069 UNSET_FLAG(nhlfe
->nexthop
->flags
,
2070 NEXTHOP_FLAG_ACTIVE
);
2071 UNSET_FLAG(nhlfe
->nexthop
->flags
,
2076 /* Not mentioned in lfib set -> uninstalled */
2078 zlog_debug("%s: no match for lsp nhlfe %s",
2080 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
2081 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
2082 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
2083 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
2091 * Process async dplane notifications.
2093 void zebra_mpls_process_dplane_notify(struct zebra_dplane_ctx
*ctx
)
2095 struct zebra_vrf
*zvrf
;
2096 struct zebra_ile tmp_ile
;
2097 struct hash
*lsp_table
;
2098 struct zebra_lsp
*lsp
;
2099 const struct nhlfe_list_head
*ctx_list
;
2100 int start_count
= 0, end_count
= 0; /* Installed counts */
2101 bool changed_p
= false;
2102 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
2103 enum zebra_sr_policy_update_label_mode update_mode
;
2106 zlog_debug("LSP dplane notif, in-label %u",
2107 dplane_ctx_get_in_label(ctx
));
2109 /* Look for zebra LSP object */
2110 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
2114 lsp_table
= zvrf
->lsp_table
;
2116 tmp_ile
.in_label
= dplane_ctx_get_in_label(ctx
);
2117 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
2120 zlog_debug("dplane LSP notif: in-label %u not found",
2121 dplane_ctx_get_in_label(ctx
));
2126 * The dataplane/forwarding plane is notifying zebra about the state
2127 * of the nexthops associated with this LSP. First, we take a
2128 * pre-scan pass to determine whether the LSP has transitioned
2129 * from installed -> uninstalled. In that case, we need to have
2130 * the existing state of the LSP objects available before making
2133 ctx_list
= dplane_ctx_get_nhlfe_list(ctx
);
2135 changed_p
= compare_notif_nhlfes(ctx_list
, &lsp
->nhlfe_list
,
2136 &start_count
, &end_count
);
2139 zlog_debug("LSP dplane notif: lfib start_count %d, end_count %d%s",
2140 start_count
, end_count
,
2141 changed_p
? ", changed" : "");
2143 ctx_list
= dplane_ctx_get_backup_nhlfe_list(ctx
);
2145 if (compare_notif_nhlfes(ctx_list
, &lsp
->backup_nhlfe_list
,
2146 &start_count
, &end_count
))
2147 /* Avoid accidentally setting back to 'false' */
2151 zlog_debug("LSP dplane notif: lfib backups, start_count %d, end_count %d%s",
2152 start_count
, end_count
,
2153 changed_p
? ", changed" : "");
2156 * Has the LSP become uninstalled? We need the existing state of the
2157 * nexthops/nhlfes at this point so we know what to delete.
2159 if (start_count
> 0 && end_count
== 0) {
2160 /* Inform other lfibs */
2161 dplane_lsp_notif_update(lsp
, DPLANE_OP_LSP_DELETE
, ctx
);
2165 * Now we take a second pass and bring the zebra
2166 * nexthop state into sync with the forwarding-plane state.
2168 ctx_list
= dplane_ctx_get_nhlfe_list(ctx
);
2169 update_nhlfes_from_ctx(&lsp
->nhlfe_list
, ctx_list
);
2171 ctx_list
= dplane_ctx_get_backup_nhlfe_list(ctx
);
2172 update_nhlfes_from_ctx(&lsp
->backup_nhlfe_list
, ctx_list
);
2174 if (end_count
> 0) {
2175 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
2177 /* SR-TE update too */
2178 if (start_count
== 0)
2179 update_mode
= ZEBRA_SR_POLICY_LABEL_CREATED
;
2181 update_mode
= ZEBRA_SR_POLICY_LABEL_UPDATED
;
2182 zebra_sr_policy_label_update(lsp
->ile
.in_label
, update_mode
);
2185 dplane_lsp_notif_update(lsp
, DPLANE_OP_LSP_UPDATE
, ctx
);
2188 /* SR-TE update too */
2189 zebra_sr_policy_label_update(lsp
->ile
.in_label
,
2190 ZEBRA_SR_POLICY_LABEL_REMOVED
);
2192 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
2193 clear_nhlfe_installed(lsp
);
2198 * Install dynamic LSP entry.
2200 int zebra_mpls_lsp_install(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
2201 struct route_entry
*re
)
2203 struct route_table
*table
;
2204 struct zebra_fec
*fec
;
2206 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(&rn
->p
))];
2210 /* See if there is a configured label binding for this FEC. */
2211 fec
= fec_find(table
, &rn
->p
);
2212 if (!fec
|| fec
->label
== MPLS_INVALID_LABEL
)
2215 /* We cannot install a label forwarding entry if local label is the
2216 * implicit-null label.
2218 if (fec
->label
== MPLS_LABEL_IMPLICIT_NULL
)
2221 if (lsp_install(zvrf
, fec
->label
, rn
, re
))
2228 * Uninstall dynamic LSP entry, if any.
2230 int zebra_mpls_lsp_uninstall(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
2231 struct route_entry
*re
)
2233 struct route_table
*table
;
2234 struct zebra_fec
*fec
;
2236 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(&rn
->p
))];
2240 /* See if there is a configured label binding for this FEC. */
2241 fec
= fec_find(table
, &rn
->p
);
2242 if (!fec
|| fec
->label
== MPLS_INVALID_LABEL
)
2245 /* Uninstall always removes all dynamic NHLFEs. */
2246 return lsp_uninstall(zvrf
, fec
->label
);
2250 * Add an NHLFE to an LSP, return the newly-added object. This path only changes
2251 * the LSP object - nothing is scheduled for processing, for example.
2253 struct zebra_nhlfe
*
2254 zebra_mpls_lsp_add_nhlfe(struct zebra_lsp
*lsp
, enum lsp_types_t lsp_type
,
2255 enum nexthop_types_t gtype
, const union g_addr
*gate
,
2256 ifindex_t ifindex
, uint8_t num_labels
,
2257 const mpls_label_t
*out_labels
)
2259 /* Just a public pass-through to the internal implementation */
2260 return nhlfe_add(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
2261 out_labels
, false /*backup*/);
2265 * Add a backup NHLFE to an LSP, return the newly-added object.
2266 * This path only changes the LSP object - nothing is scheduled for
2267 * processing, for example.
2269 struct zebra_nhlfe
*zebra_mpls_lsp_add_backup_nhlfe(
2270 struct zebra_lsp
*lsp
, enum lsp_types_t lsp_type
,
2271 enum nexthop_types_t gtype
, const union g_addr
*gate
, ifindex_t ifindex
,
2272 uint8_t num_labels
, const mpls_label_t
*out_labels
)
2274 /* Just a public pass-through to the internal implementation */
2275 return nhlfe_add(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
2280 * Add an NHLFE to an LSP based on a nexthop; return the newly-added object
2282 struct zebra_nhlfe
*zebra_mpls_lsp_add_nh(struct zebra_lsp
*lsp
,
2283 enum lsp_types_t lsp_type
,
2284 const struct nexthop
*nh
)
2286 struct zebra_nhlfe
*nhlfe
;
2288 if (nh
->nh_label
== NULL
|| nh
->nh_label
->num_labels
== 0)
2291 nhlfe
= nhlfe_add(lsp
, lsp_type
, nh
->type
, &nh
->gate
, nh
->ifindex
,
2292 nh
->nh_label
->num_labels
, nh
->nh_label
->label
,
2299 * Add a backup NHLFE to an LSP based on a nexthop;
2300 * return the newly-added object.
2302 struct zebra_nhlfe
*zebra_mpls_lsp_add_backup_nh(struct zebra_lsp
*lsp
,
2303 enum lsp_types_t lsp_type
,
2304 const struct nexthop
*nh
)
2306 struct zebra_nhlfe
*nhlfe
;
2308 if (nh
->nh_label
== NULL
|| nh
->nh_label
->num_labels
== 0)
2311 nhlfe
= nhlfe_add(lsp
, lsp_type
, nh
->type
, &nh
->gate
,
2312 nh
->ifindex
, nh
->nh_label
->num_labels
,
2313 nh
->nh_label
->label
, true);
2319 * Free an allocated NHLFE
2321 void zebra_mpls_nhlfe_free(struct zebra_nhlfe
*nhlfe
)
2323 /* Just a pass-through to the internal implementation */
2328 * Registration from a client for the label binding for a FEC. If a binding
2329 * already exists, it is informed to the client.
2330 * NOTE: If there is a manually configured label binding, that is used.
2331 * Otherwise, if a label index is specified, it means we have to allocate the
2332 * label from a locally configured label block (SRGB), if one exists and index
2333 * is acceptable. If no label index then just register the specified label.
2334 * NOTE2: Either label or label_index is expected to be set to MPLS_INVALID_*
2335 * by the calling function. Register requests with both will be rejected.
2337 int zebra_mpls_fec_register(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2338 uint32_t label
, uint32_t label_index
,
2339 struct zserv
*client
)
2341 struct route_table
*table
;
2342 struct zebra_fec
*fec
;
2344 bool label_change
= false;
2346 bool have_label_index
= (label_index
!= MPLS_INVALID_LABEL_INDEX
);
2347 bool is_configured_fec
= false; /* indicate statically configured FEC */
2349 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2353 if (label
!= MPLS_INVALID_LABEL
&& have_label_index
) {
2355 EC_ZEBRA_FEC_LABEL_INDEX_LABEL_CONFLICT
,
2356 "Rejecting FEC register for %pFX with both label %u and Label Index %u specified, client %s",
2357 p
, label
, label_index
,
2358 zebra_route_string(client
->proto
));
2363 fec
= fec_find(table
, p
);
2365 fec
= fec_add(table
, p
, label
, 0, label_index
);
2368 EC_ZEBRA_FEC_ADD_FAILED
,
2369 "Failed to add FEC %pFX upon register, client %s",
2370 p
, zebra_route_string(client
->proto
));
2374 old_label
= MPLS_INVALID_LABEL
;
2377 /* Check if the FEC has been statically defined in the config */
2378 is_configured_fec
= fec
->flags
& FEC_FLAG_CONFIGURED
;
2379 /* Client may register same FEC with different label index. */
2381 (listnode_lookup(fec
->client_list
, client
) == NULL
);
2382 if (!new_client
&& fec
->label_index
== label_index
2383 && fec
->label
== label
)
2384 /* Duplicate register */
2387 /* Save current label, update the FEC */
2388 old_label
= fec
->label
;
2389 fec
->label_index
= label_index
;
2393 listnode_add(fec
->client_list
, client
);
2395 if (IS_ZEBRA_DEBUG_MPLS
)
2396 zlog_debug("FEC %pFX label%s %u %s by client %s%s", p
,
2397 have_label_index
? " index" : "",
2398 have_label_index
? label_index
: label
,
2399 new_client
? "registered" : "updated",
2400 zebra_route_string(client
->proto
),
2402 ? ", but using statically configured label"
2405 /* If not a statically configured FEC, derive the local label
2406 * from label index or use the provided label
2408 if (!is_configured_fec
) {
2409 if (have_label_index
)
2410 fec_derive_label_from_index(zvrf
, fec
);
2414 /* If no label change, exit. */
2415 if (fec
->label
== old_label
)
2418 label_change
= true;
2421 /* If new client or label change, update client and install or uninstall
2422 * label forwarding entry as needed.
2424 /* Inform client of label, if needed. */
2425 if ((new_client
&& fec
->label
!= MPLS_INVALID_LABEL
) || label_change
) {
2426 if (IS_ZEBRA_DEBUG_MPLS
)
2427 zlog_debug("Update client label %u", fec
->label
);
2428 fec_send(fec
, client
);
2431 if (new_client
|| label_change
)
2432 return fec_change_update_lsp(zvrf
, fec
, old_label
);
2438 * Deregistration from a client for the label binding for a FEC. The FEC
2439 * itself is deleted if no other registered clients exist and there is no
2440 * label bound to the FEC.
2442 int zebra_mpls_fec_unregister(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2443 struct zserv
*client
)
2445 struct route_table
*table
;
2446 struct zebra_fec
*fec
;
2448 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2452 fec
= fec_find(table
, p
);
2454 flog_err(EC_ZEBRA_FEC_RM_FAILED
,
2455 "Failed to find FEC %pFX upon unregister, client %s",
2456 p
, zebra_route_string(client
->proto
));
2460 listnode_delete(fec
->client_list
, client
);
2462 if (IS_ZEBRA_DEBUG_MPLS
)
2463 zlog_debug("FEC %pFX unregistered by client %s", p
,
2464 zebra_route_string(client
->proto
));
2466 /* If not a configured entry, delete the FEC if no other clients. Before
2467 * deleting, see if any LSP needs to be uninstalled.
2469 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
)
2470 && list_isempty(fec
->client_list
)) {
2471 mpls_label_t old_label
= fec
->label
;
2472 fec
->label
= MPLS_INVALID_LABEL
; /* reset */
2473 fec_change_update_lsp(zvrf
, fec
, old_label
);
2481 * Cleanup any FECs registered by this client.
2483 static int zebra_mpls_cleanup_fecs_for_client(struct zserv
*client
)
2485 struct zebra_vrf
*zvrf
= vrf_info_lookup(VRF_DEFAULT
);
2486 struct route_node
*rn
;
2487 struct zebra_fec
*fec
;
2488 struct listnode
*node
;
2489 struct zserv
*fec_client
;
2492 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2493 if (zvrf
->fec_table
[af
] == NULL
)
2496 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2497 rn
= route_next(rn
)) {
2499 if (!fec
|| list_isempty(fec
->client_list
))
2502 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
,
2504 if (fec_client
== client
) {
2505 listnode_delete(fec
->client_list
,
2507 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
)
2508 && list_isempty(fec
->client_list
))
2519 struct lsp_uninstall_args
{
2520 struct hash
*lsp_table
;
2521 enum lsp_types_t type
;
2525 * Cleanup MPLS labels registered by this client.
2527 static int zebra_mpls_cleanup_zclient_labels(struct zserv
*client
)
2530 struct zebra_vrf
*zvrf
;
2532 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
2533 struct lsp_uninstall_args args
;
2540 args
.lsp_table
= zvrf
->lsp_table
;
2541 args
.type
= lsp_type_from_re_type(client
->proto
);
2542 hash_iterate(zvrf
->lsp_table
, mpls_lsp_uninstall_all_type
,
2546 mpls_ftn_uninstall_all(zvrf
, AFI_IP
,
2547 lsp_type_from_re_type(client
->proto
));
2548 mpls_ftn_uninstall_all(zvrf
, AFI_IP6
,
2549 lsp_type_from_re_type(client
->proto
));
2556 * Return FEC (if any) to which this label is bound.
2557 * Note: Only works for per-prefix binding and when the label is not
2559 * TODO: Currently walks entire table, can optimize later with another
2562 struct zebra_fec
*zebra_mpls_fec_for_label(struct zebra_vrf
*zvrf
,
2565 struct route_node
*rn
;
2566 struct zebra_fec
*fec
;
2569 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2570 if (zvrf
->fec_table
[af
] == NULL
)
2573 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2574 rn
= route_next(rn
)) {
2578 if (fec
->label
== label
)
2587 * Inform if specified label is currently bound to a FEC or not.
2589 int zebra_mpls_label_already_bound(struct zebra_vrf
*zvrf
, mpls_label_t label
)
2591 return (zebra_mpls_fec_for_label(zvrf
, label
) ? 1 : 0);
2595 * Add static FEC to label binding. If there are clients registered for this
2596 * FEC, notify them. If there are labeled routes for this FEC, install the
2597 * label forwarding entry.
2599 int zebra_mpls_static_fec_add(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2600 mpls_label_t in_label
)
2602 struct route_table
*table
;
2603 struct zebra_fec
*fec
;
2604 mpls_label_t old_label
;
2607 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2611 /* Update existing FEC or create a new one. */
2612 fec
= fec_find(table
, p
);
2614 fec
= fec_add(table
, p
, in_label
, FEC_FLAG_CONFIGURED
,
2615 MPLS_INVALID_LABEL_INDEX
);
2617 flog_err(EC_ZEBRA_FEC_ADD_FAILED
,
2618 "Failed to add FEC %pFX upon config", p
);
2622 if (IS_ZEBRA_DEBUG_MPLS
)
2623 zlog_debug("Add fec %pFX label %u", p
, in_label
);
2625 fec
->flags
|= FEC_FLAG_CONFIGURED
;
2626 if (fec
->label
== in_label
)
2627 /* Duplicate config */
2630 /* Label change, update clients. */
2631 old_label
= fec
->label
;
2632 if (IS_ZEBRA_DEBUG_MPLS
)
2633 zlog_debug("Update fec %pFX new label %u", p
, in_label
);
2635 fec
->label
= in_label
;
2636 fec_update_clients(fec
);
2638 /* Update label forwarding entries appropriately */
2639 ret
= fec_change_update_lsp(zvrf
, fec
, old_label
);
2646 * Remove static FEC to label binding. If there are no clients registered
2647 * for this FEC, delete the FEC; else notify clients
2648 * Note: Upon delete of static binding, if label index exists for this FEC,
2649 * client may need to be updated with derived label.
2651 int zebra_mpls_static_fec_del(struct zebra_vrf
*zvrf
, struct prefix
*p
)
2653 struct route_table
*table
;
2654 struct zebra_fec
*fec
;
2655 mpls_label_t old_label
;
2657 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2661 fec
= fec_find(table
, p
);
2663 flog_err(EC_ZEBRA_FEC_RM_FAILED
,
2664 "Failed to find FEC %pFX upon delete", p
);
2668 if (IS_ZEBRA_DEBUG_MPLS
) {
2669 zlog_debug("Delete fec %pFX label %u label index %u", p
,
2670 fec
->label
, fec
->label_index
);
2673 old_label
= fec
->label
;
2674 fec
->flags
&= ~FEC_FLAG_CONFIGURED
;
2675 fec
->label
= MPLS_INVALID_LABEL
;
2677 /* If no client exists, just delete the FEC. */
2678 if (list_isempty(fec
->client_list
)) {
2683 /* Derive the local label (from label index) or reset it. */
2684 fec_derive_label_from_index(zvrf
, fec
);
2686 /* If there is a label change, update clients. */
2687 if (fec
->label
== old_label
)
2689 fec_update_clients(fec
);
2691 /* Update label forwarding entries appropriately */
2692 return fec_change_update_lsp(zvrf
, fec
, old_label
);
2696 * Display MPLS FEC to label binding configuration (VTY command handler).
2698 int zebra_mpls_write_fec_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
2700 struct route_node
*rn
;
2702 struct zebra_fec
*fec
;
2705 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2706 if (zvrf
->fec_table
[af
] == NULL
)
2709 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2710 rn
= route_next(rn
)) {
2717 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
))
2721 vty_out(vty
, "mpls label bind %pFX %s\n", &rn
->p
,
2722 label2str(fec
->label
, 0, lstr
, BUFSIZ
));
2730 * Display MPLS FEC to label binding (VTY command handler).
2732 void zebra_mpls_print_fec_table(struct vty
*vty
, struct zebra_vrf
*zvrf
)
2734 struct route_node
*rn
;
2737 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2738 if (zvrf
->fec_table
[af
] == NULL
)
2741 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2742 rn
= route_next(rn
)) {
2745 fec_print(rn
->info
, vty
);
2751 * Display MPLS FEC to label binding for a specific FEC (VTY command handler).
2753 void zebra_mpls_print_fec(struct vty
*vty
, struct zebra_vrf
*zvrf
,
2756 struct route_table
*table
;
2757 struct route_node
*rn
;
2759 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2764 rn
= route_node_lookup(table
, p
);
2768 route_unlock_node(rn
);
2772 fec_print(rn
->info
, vty
);
2775 static void mpls_zebra_nhe_update(struct route_entry
*re
, afi_t afi
,
2776 struct nhg_hash_entry
*new_nhe
)
2778 struct nhg_hash_entry
*nhe
;
2780 nhe
= zebra_nhg_rib_find_nhe(new_nhe
, afi
);
2782 route_entry_update_nhe(re
, nhe
);
2785 static bool ftn_update_nexthop(bool add_p
, struct nexthop
*nexthop
,
2786 enum lsp_types_t type
,
2787 const struct zapi_nexthop
*znh
)
2789 if (add_p
&& nexthop
->nh_label_type
== ZEBRA_LSP_NONE
)
2790 nexthop_add_labels(nexthop
, type
, znh
->label_num
, znh
->labels
);
2791 else if (!add_p
&& nexthop
->nh_label_type
== type
)
2792 nexthop_del_labels(nexthop
);
2799 void zebra_mpls_ftn_uninstall(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
2800 struct prefix
*prefix
, uint8_t route_type
,
2801 uint8_t route_instance
)
2803 struct route_table
*table
;
2804 struct route_node
*rn
;
2805 struct route_entry
*re
;
2806 struct nexthop
*nexthop
;
2807 struct nhg_hash_entry
*new_nhe
;
2808 afi_t afi
= family2afi(prefix
->family
);
2811 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
2815 /* Lookup existing route */
2816 rn
= route_node_get(table
, prefix
);
2817 RNODE_FOREACH_RE (rn
, re
) {
2818 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
2820 if (re
->type
== route_type
&& re
->instance
== route_instance
)
2827 * Nexthops are now shared by multiple routes, so we have to make
2828 * a local copy, modify the copy, then update the route.
2830 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
2832 for (nexthop
= new_nhe
->nhg
.nexthop
; nexthop
; nexthop
= nexthop
->next
)
2833 nexthop_del_labels(nexthop
);
2835 /* Update backup routes/nexthops also, if present. */
2836 if (zebra_nhg_get_backup_nhg(new_nhe
) != NULL
) {
2837 for (nexthop
= new_nhe
->backup_info
->nhe
->nhg
.nexthop
; nexthop
;
2838 nexthop
= nexthop
->next
)
2839 nexthop_del_labels(nexthop
);
2842 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
2843 SET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
2845 /* This will create (or ref) a new nhe, so we will discard the local
2848 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
2850 zebra_nhg_free(new_nhe
);
2856 * Iterate through a list of nexthops, for a match for 'znh'. If found,
2857 * update its labels according to 'add_p', and return 'true' if successful.
2859 static bool ftn_update_znh(bool add_p
, enum lsp_types_t type
,
2860 struct nexthop
*head
, const struct zapi_nexthop
*znh
)
2862 bool found
= false, success
= false;
2863 struct nexthop
*nexthop
;
2865 for (nexthop
= head
; nexthop
; nexthop
= nexthop
->next
) {
2866 switch (nexthop
->type
) {
2867 case NEXTHOP_TYPE_IPV4
:
2868 case NEXTHOP_TYPE_IPV4_IFINDEX
:
2869 if (znh
->type
!= NEXTHOP_TYPE_IPV4
2870 && znh
->type
!= NEXTHOP_TYPE_IPV4_IFINDEX
)
2872 if (!IPV4_ADDR_SAME(&nexthop
->gate
.ipv4
,
2875 if (nexthop
->type
== NEXTHOP_TYPE_IPV4_IFINDEX
2876 && nexthop
->ifindex
!= znh
->ifindex
)
2881 if (!ftn_update_nexthop(add_p
, nexthop
, type
, znh
))
2886 case NEXTHOP_TYPE_IPV6
:
2887 case NEXTHOP_TYPE_IPV6_IFINDEX
:
2888 if (znh
->type
!= NEXTHOP_TYPE_IPV6
2889 && znh
->type
!= NEXTHOP_TYPE_IPV6_IFINDEX
)
2891 if (!IPV6_ADDR_SAME(&nexthop
->gate
.ipv6
,
2894 if (nexthop
->type
== NEXTHOP_TYPE_IPV6_IFINDEX
2895 && nexthop
->ifindex
!= znh
->ifindex
)
2900 if (!ftn_update_nexthop(add_p
, nexthop
, type
, znh
))
2904 case NEXTHOP_TYPE_IFINDEX
:
2905 if (znh
->type
!= NEXTHOP_TYPE_IFINDEX
)
2907 if (nexthop
->ifindex
!= znh
->ifindex
)
2912 if (!ftn_update_nexthop(add_p
, nexthop
, type
, znh
))
2916 case NEXTHOP_TYPE_BLACKHOLE
:
2929 * Install/uninstall LSP and (optionally) FEC-To-NHLFE (FTN) bindings,
2930 * using zapi message info.
2931 * There are several changes that need to be made, in several zebra
2932 * data structures, so we want to do all the work required at once.
2934 void zebra_mpls_zapi_labels_process(bool add_p
, struct zebra_vrf
*zvrf
,
2935 const struct zapi_labels
*zl
)
2937 int i
, counter
, ret
= 0;
2938 char buf
[NEXTHOP_STRLEN
];
2939 const struct zapi_nexthop
*znh
;
2940 struct route_table
*table
;
2941 struct route_node
*rn
= NULL
;
2942 struct route_entry
*re
= NULL
;
2943 struct nhg_hash_entry
*new_nhe
= NULL
;
2946 const struct prefix
*prefix
= NULL
;
2947 struct hash
*lsp_table
;
2948 struct zebra_ile tmp_ile
;
2949 struct zebra_lsp
*lsp
= NULL
;
2951 /* Prep LSP for add case */
2954 lsp_table
= zvrf
->lsp_table
;
2958 /* Find or create LSP object */
2959 tmp_ile
.in_label
= zl
->local_label
;
2960 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
2963 /* Prep for route/FEC update if requested */
2964 if (CHECK_FLAG(zl
->message
, ZAPI_LABELS_FTN
)) {
2965 prefix
= &zl
->route
.prefix
;
2967 afi
= family2afi(prefix
->family
);
2970 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
2972 /* Lookup existing route */
2973 rn
= route_node_get(table
, prefix
);
2974 RNODE_FOREACH_RE(rn
, re
) {
2975 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
2977 if (re
->type
== zl
->route
.type
&&
2978 re
->instance
== zl
->route
.instance
)
2985 * Copy over current nexthops into a temporary group.
2986 * We can't just change the values here since the nhgs
2987 * are shared and if the labels change, we'll need
2988 * to find or create a new nhg. We need to create
2989 * a whole temporary group, make changes to it,
2990 * then attach that to the route.
2992 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
2996 * The old version of the zapi code
2997 * attempted to manage LSPs before trying to
2998 * find a route/FEC, so we'll continue that way.
3000 if (IS_ZEBRA_DEBUG_RECV
|| IS_ZEBRA_DEBUG_MPLS
)
3002 "%s: FTN update requested: no route for prefix %pFX",
3008 * Use info from the zapi nexthops to add/replace/remove LSP/FECs
3012 for (i
= 0; i
< zl
->nexthop_num
; i
++) {
3014 znh
= &zl
->nexthops
[i
];
3016 /* Attempt LSP update */
3018 ret
= lsp_znh_install(lsp
, zl
->type
, znh
);
3020 ret
= mpls_lsp_uninstall(zvrf
, zl
->type
,
3021 zl
->local_label
, znh
->type
,
3022 &znh
->gate
, znh
->ifindex
,
3025 if (IS_ZEBRA_DEBUG_RECV
|| IS_ZEBRA_DEBUG_MPLS
) {
3026 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
3027 zlog_debug("%s: Unable to %sinstall LSP: label %u, znh %s",
3028 __func__
, (add_p
? "" : "un"),
3029 zl
->local_label
, buf
);
3034 /* Attempt route/FEC update if requested */
3038 /* Search the route's nexthops for a match, and update it. */
3039 found
= ftn_update_znh(add_p
, zl
->type
, new_nhe
->nhg
.nexthop
,
3043 } else if (IS_ZEBRA_DEBUG_RECV
| IS_ZEBRA_DEBUG_MPLS
) {
3044 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
3046 "%s: Unable to update FEC: prefix %pFX, label %u, znh %s",
3047 __func__
, prefix
, zl
->local_label
, buf
);
3052 * Process backup LSPs/nexthop entries also. We associate backup
3053 * LSP info with backup nexthops.
3055 if (!CHECK_FLAG(zl
->message
, ZAPI_LABELS_HAS_BACKUPS
))
3058 for (i
= 0; i
< zl
->backup_nexthop_num
; i
++) {
3060 znh
= &zl
->backup_nexthops
[i
];
3063 ret
= lsp_backup_znh_install(lsp
, zl
->type
, znh
);
3065 ret
= mpls_lsp_uninstall(zvrf
, zl
->type
,
3067 znh
->type
, &znh
->gate
,
3068 znh
->ifindex
, true);
3071 if (IS_ZEBRA_DEBUG_RECV
||
3072 IS_ZEBRA_DEBUG_MPLS
) {
3073 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
3074 zlog_debug("%s: Unable to %sinstall backup LSP: label %u, znh %s",
3075 __func__
, (add_p
? "" : "un"),
3076 zl
->local_label
, buf
);
3081 /* Attempt backup nexthop/FEC update if requested */
3082 if (re
== NULL
|| zebra_nhg_get_backup_nhg(new_nhe
) == NULL
)
3085 /* Search the route's backup nexthops for a match
3088 found
= ftn_update_znh(add_p
, zl
->type
,
3089 new_nhe
->backup_info
->nhe
->nhg
.nexthop
,
3093 } else if (IS_ZEBRA_DEBUG_RECV
| IS_ZEBRA_DEBUG_MPLS
) {
3094 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
3096 "%s: Unable to update backup FEC: prefix %pFX, label %u, znh %s",
3097 __func__
, prefix
, zl
->local_label
, buf
);
3104 * If we made changes, update the route, and schedule it
3105 * for rib processing
3107 if (re
!= NULL
&& counter
> 0) {
3110 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
3111 SET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
3113 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
3119 zebra_nhg_free(new_nhe
);
3123 * Install/update a NHLFE for an LSP in the forwarding table. This may be
3124 * a new LSP entry or a new NHLFE for an existing in-label or an update of
3125 * the out-label for an existing NHLFE (update case).
3127 static struct zebra_nhlfe
*
3128 lsp_add_nhlfe(struct zebra_lsp
*lsp
, enum lsp_types_t type
,
3129 uint8_t num_out_labels
, const mpls_label_t
*out_labels
,
3130 enum nexthop_types_t gtype
, const union g_addr
*gate
,
3131 ifindex_t ifindex
, bool is_backup
)
3133 struct zebra_nhlfe
*nhlfe
;
3134 char buf
[MPLS_LABEL_STRLEN
];
3135 const char *backup_str
;
3138 nhlfe
= nhlfe_find(&lsp
->backup_nhlfe_list
, type
, gtype
,
3140 backup_str
= "backup ";
3142 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, type
, gtype
, gate
,
3148 struct nexthop
*nh
= nhlfe
->nexthop
;
3151 assert(nh
->nh_label
);
3153 /* Clear deleted flag (in case it was set) */
3154 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
3155 if (nh
->nh_label
->num_labels
== num_out_labels
3156 && !memcmp(nh
->nh_label
->label
, out_labels
,
3157 sizeof(mpls_label_t
) * num_out_labels
))
3161 if (IS_ZEBRA_DEBUG_MPLS
) {
3162 char buf2
[MPLS_LABEL_STRLEN
];
3163 char buf3
[MPLS_LABEL_STRLEN
];
3165 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3166 mpls_label2str(num_out_labels
, out_labels
, buf2
,
3167 sizeof(buf2
), 0, 0);
3168 mpls_label2str(nh
->nh_label
->num_labels
,
3169 nh
->nh_label
->label
, buf3
, sizeof(buf3
),
3170 nh
->nh_label_type
, 0);
3172 zlog_debug("LSP in-label %u type %d %snexthop %s out-label(s) changed to %s (old %s)",
3173 lsp
->ile
.in_label
, type
, backup_str
, buf
,
3177 /* Update out label(s), trigger processing. */
3178 if (nh
->nh_label
->num_labels
== num_out_labels
)
3179 memcpy(nh
->nh_label
->label
, out_labels
,
3180 sizeof(mpls_label_t
) * num_out_labels
);
3182 nexthop_del_labels(nh
);
3183 nexthop_add_labels(nh
, type
, num_out_labels
,
3187 /* Add LSP entry to this nexthop */
3188 nhlfe
= nhlfe_add(lsp
, type
, gtype
, gate
, ifindex
,
3189 num_out_labels
, out_labels
, is_backup
);
3193 if (IS_ZEBRA_DEBUG_MPLS
) {
3194 char buf2
[MPLS_LABEL_STRLEN
];
3196 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3197 mpls_label2str(num_out_labels
, out_labels
, buf2
,
3198 sizeof(buf2
), 0, 0);
3200 zlog_debug("Add LSP in-label %u type %d %snexthop %s out-label(s) %s",
3201 lsp
->ile
.in_label
, type
, backup_str
, buf
,
3205 lsp
->addr_family
= NHLFE_FAMILY(nhlfe
);
3208 /* Mark NHLFE, queue LSP for processing. */
3209 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
3215 * Install an LSP and forwarding entry; used primarily
3216 * from vrf zapi message processing.
3218 int mpls_lsp_install(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3219 mpls_label_t in_label
, uint8_t num_out_labels
,
3220 const mpls_label_t
*out_labels
, enum nexthop_types_t gtype
,
3221 const union g_addr
*gate
, ifindex_t ifindex
)
3223 struct hash
*lsp_table
;
3224 struct zebra_ile tmp_ile
;
3225 struct zebra_lsp
*lsp
;
3226 struct zebra_nhlfe
*nhlfe
;
3229 lsp_table
= zvrf
->lsp_table
;
3233 /* Find or create LSP object */
3234 tmp_ile
.in_label
= in_label
;
3235 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
3237 nhlfe
= lsp_add_nhlfe(lsp
, type
, num_out_labels
, out_labels
, gtype
,
3238 gate
, ifindex
, false /*backup*/);
3242 /* Queue LSP for processing. */
3243 if (lsp_processq_add(lsp
))
3250 * Install or replace NHLFE, using info from zapi nexthop
3252 static int lsp_znh_install(struct zebra_lsp
*lsp
, enum lsp_types_t type
,
3253 const struct zapi_nexthop
*znh
)
3255 struct zebra_nhlfe
*nhlfe
;
3257 nhlfe
= lsp_add_nhlfe(lsp
, type
, znh
->label_num
, znh
->labels
,
3258 znh
->type
, &znh
->gate
, znh
->ifindex
,
3263 /* Update backup info if present */
3264 if (CHECK_FLAG(znh
->flags
, ZAPI_NEXTHOP_FLAG_HAS_BACKUP
)) {
3265 if (znh
->backup_num
> NEXTHOP_MAX_BACKUPS
) {
3270 nhlfe
->nexthop
->backup_num
= znh
->backup_num
;
3271 memcpy(nhlfe
->nexthop
->backup_idx
, znh
->backup_idx
,
3273 SET_FLAG(nhlfe
->nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
);
3275 /* Ensure there's no stale backup info */
3276 UNSET_FLAG(nhlfe
->nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
);
3277 nhlfe
->nexthop
->backup_num
= 0;
3280 /* Queue LSP for processing. */
3281 if (lsp_processq_add(lsp
))
3288 * Install/update backup NHLFE for an LSP, using info from a zapi message.
3290 static int lsp_backup_znh_install(struct zebra_lsp
*lsp
, enum lsp_types_t type
,
3291 const struct zapi_nexthop
*znh
)
3293 struct zebra_nhlfe
*nhlfe
;
3295 nhlfe
= lsp_add_nhlfe(lsp
, type
, znh
->label_num
,
3296 znh
->labels
, znh
->type
, &znh
->gate
,
3297 znh
->ifindex
, true /*backup*/);
3298 if (nhlfe
== NULL
) {
3299 if (IS_ZEBRA_DEBUG_MPLS
)
3300 zlog_debug("%s: unable to add backup nhlfe, label: %u",
3301 __func__
, lsp
->ile
.in_label
);
3305 /* Queue LSP for processing. */
3306 if (lsp_processq_add(lsp
))
3312 struct zebra_lsp
*mpls_lsp_find(struct zebra_vrf
*zvrf
, mpls_label_t in_label
)
3314 struct hash
*lsp_table
;
3315 struct zebra_ile tmp_ile
;
3318 lsp_table
= zvrf
->lsp_table
;
3322 /* If entry is not present, exit. */
3323 tmp_ile
.in_label
= in_label
;
3324 return hash_lookup(lsp_table
, &tmp_ile
);
3328 * Uninstall a particular NHLFE in the forwarding table. If this is
3329 * the only NHLFE, the entire LSP forwarding entry has to be deleted.
3331 int mpls_lsp_uninstall(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3332 mpls_label_t in_label
, enum nexthop_types_t gtype
,
3333 const union g_addr
*gate
, ifindex_t ifindex
,
3336 struct hash
*lsp_table
;
3337 struct zebra_ile tmp_ile
;
3338 struct zebra_lsp
*lsp
;
3339 struct zebra_nhlfe
*nhlfe
;
3340 char buf
[NEXTHOP_STRLEN
];
3341 bool schedule_lsp
= false;
3344 lsp_table
= zvrf
->lsp_table
;
3348 /* If entry is not present, exit. */
3349 tmp_ile
.in_label
= in_label
;
3350 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3355 nhlfe
= nhlfe_find(&lsp
->backup_nhlfe_list
, type
, gtype
,
3358 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, type
, gtype
, gate
,
3363 if (IS_ZEBRA_DEBUG_MPLS
) {
3364 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3365 zlog_debug("Del LSP in-label %u type %d nexthop %s flags 0x%x",
3366 in_label
, type
, buf
, nhlfe
->flags
);
3369 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) ||
3370 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
))
3371 schedule_lsp
= true;
3373 /* Mark NHLFE for delete or directly delete, as appropriate. */
3375 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
3376 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
3378 if (IS_ZEBRA_DEBUG_MPLS
)
3379 zlog_debug("Schedule LSP in-label %u flags 0x%x",
3380 lsp
->ile
.in_label
, lsp
->flags
);
3381 if (lsp_processq_add(lsp
))
3386 /* Free LSP entry if no other NHLFEs and not scheduled. */
3387 lsp_check_free(lsp_table
, &lsp
);
3392 int mpls_lsp_uninstall_all_vrf(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3393 mpls_label_t in_label
)
3395 struct hash
*lsp_table
;
3396 struct zebra_ile tmp_ile
;
3397 struct zebra_lsp
*lsp
;
3400 lsp_table
= zvrf
->lsp_table
;
3404 /* If entry is not present, exit. */
3405 tmp_ile
.in_label
= in_label
;
3406 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3410 return mpls_lsp_uninstall_all(lsp_table
, lsp
, type
);
3414 * Uninstall all NHLFEs for a particular LSP forwarding entry.
3415 * If no other NHLFEs exist, the entry would be deleted.
3417 static void mpls_lsp_uninstall_all_type(struct hash_bucket
*bucket
, void *ctxt
)
3419 struct lsp_uninstall_args
*args
= ctxt
;
3420 struct zebra_lsp
*lsp
;
3421 struct hash
*lsp_table
;
3423 lsp
= (struct zebra_lsp
*)bucket
->data
;
3424 if (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
)
3427 lsp_table
= args
->lsp_table
;
3431 mpls_lsp_uninstall_all(lsp_table
, lsp
, args
->type
);
3435 * Uninstall all FEC-To-NHLFE (FTN) bindings of the given address-family and
3438 static void mpls_ftn_uninstall_all(struct zebra_vrf
*zvrf
,
3439 int afi
, enum lsp_types_t lsp_type
)
3441 struct route_table
*table
;
3442 struct route_node
*rn
;
3443 struct route_entry
*re
;
3444 struct nexthop
*nexthop
;
3445 struct nexthop_group
*nhg
;
3448 /* Process routes of interested address-families. */
3449 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
3453 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
3456 RNODE_FOREACH_RE (rn
, re
) {
3457 struct nhg_hash_entry
*new_nhe
;
3459 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
3461 nhg
= &new_nhe
->nhg
;
3462 for (nexthop
= nhg
->nexthop
; nexthop
;
3463 nexthop
= nexthop
->next
) {
3464 if (nexthop
->nh_label_type
!= lsp_type
)
3467 nexthop_del_labels(nexthop
);
3468 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
3469 SET_FLAG(re
->status
,
3470 ROUTE_ENTRY_LABELS_CHANGED
);
3474 /* Check for backup info and update that also */
3475 nhg
= zebra_nhg_get_backup_nhg(new_nhe
);
3477 for (nexthop
= nhg
->nexthop
; nexthop
;
3478 nexthop
= nexthop
->next
) {
3479 if (nexthop
->nh_label_type
!= lsp_type
)
3482 nexthop_del_labels(nexthop
);
3483 SET_FLAG(re
->status
,
3484 ROUTE_ENTRY_CHANGED
);
3485 SET_FLAG(re
->status
,
3486 ROUTE_ENTRY_LABELS_CHANGED
);
3491 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
))
3492 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
3494 zebra_nhg_free(new_nhe
);
3502 #if defined(HAVE_CUMULUS)
3504 * Check that the label values used in LSP creation are consistent. The
3505 * main criteria is that if there is ECMP, the label operation must still
3506 * be consistent - i.e., all paths either do a swap or do PHP. This is due
3507 * to current HW restrictions.
3509 int zebra_mpls_lsp_label_consistent(struct zebra_vrf
*zvrf
,
3510 mpls_label_t in_label
,
3511 mpls_label_t out_label
,
3512 enum nexthop_types_t gtype
,
3513 union g_addr
*gate
, ifindex_t ifindex
)
3515 struct hash
*slsp_table
;
3516 struct zebra_ile tmp_ile
;
3517 struct zebra_lsp
*lsp
;
3518 struct zebra_nhlfe
*nhlfe
;
3519 const struct nexthop
*nh
;
3522 slsp_table
= zvrf
->slsp_table
;
3526 /* If entry is not present, exit. */
3527 tmp_ile
.in_label
= in_label
;
3528 lsp
= hash_lookup(slsp_table
, &tmp_ile
);
3532 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
,
3533 gtype
, gate
, ifindex
);
3535 nh
= nhlfe
->nexthop
;
3537 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3540 if (nh
->nh_label
->label
[0] == out_label
)
3543 /* If not only NHLFE, cannot allow label change. */
3544 if (nhlfe
!= nhlfe_list_first(&lsp
->nhlfe_list
) ||
3545 nhlfe_list_next(&lsp
->nhlfe_list
, nhlfe
) != NULL
)
3548 /* If other NHLFEs exist, label operation must match. */
3549 nhlfe
= nhlfe_list_first(&lsp
->nhlfe_list
);
3550 if (nhlfe
!= NULL
) {
3553 nh
= nhlfe
->nexthop
;
3555 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3558 cur_op
= (nh
->nh_label
->label
[0] ==
3559 MPLS_LABEL_IMPLICIT_NULL
);
3560 new_op
= (out_label
== MPLS_LABEL_IMPLICIT_NULL
);
3561 if (cur_op
!= new_op
)
3566 /* Label values are good. */
3569 #endif /* HAVE_CUMULUS */
3572 * Add static LSP entry. This may be the first entry for this incoming label
3573 * or an additional nexthop; an existing entry may also have outgoing label
3575 * Note: The label operation (swap or PHP) is common for the LSP entry (all
3578 int zebra_mpls_static_lsp_add(struct zebra_vrf
*zvrf
, mpls_label_t in_label
,
3579 mpls_label_t out_label
,
3580 enum nexthop_types_t gtype
, union g_addr
*gate
,
3583 struct hash
*slsp_table
;
3584 struct zebra_ile tmp_ile
;
3585 struct zebra_lsp
*lsp
;
3586 struct zebra_nhlfe
*nhlfe
;
3590 slsp_table
= zvrf
->slsp_table
;
3594 /* Find or create LSP. */
3595 tmp_ile
.in_label
= in_label
;
3596 lsp
= hash_get(slsp_table
, &tmp_ile
, lsp_alloc
);
3598 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
, gtype
, gate
,
3601 struct nexthop
*nh
= nhlfe
->nexthop
;
3604 assert(nh
->nh_label
);
3606 /* Compare existing nexthop */
3607 if (nh
->nh_label
->num_labels
== 1 &&
3608 nh
->nh_label
->label
[0] == out_label
)
3612 if (IS_ZEBRA_DEBUG_MPLS
) {
3613 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3615 "Upd static LSP in-label %u nexthop %s out-label %u (old %u)",
3616 in_label
, buf
, out_label
,
3617 nh
->nh_label
->label
[0]);
3619 if (nh
->nh_label
->num_labels
== 1)
3620 nh
->nh_label
->label
[0] = out_label
;
3622 nexthop_del_labels(nh
);
3623 nexthop_add_labels(nh
, ZEBRA_LSP_STATIC
, 1, &out_label
);
3627 /* Add static LSP entry to this nexthop */
3628 nhlfe
= nhlfe_add(lsp
, ZEBRA_LSP_STATIC
, gtype
, gate
,
3629 ifindex
, 1, &out_label
, false /*backup*/);
3633 if (IS_ZEBRA_DEBUG_MPLS
) {
3634 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3636 "Add static LSP in-label %u nexthop %s out-label %u",
3637 in_label
, buf
, out_label
);
3641 /* (Re)Install LSP in the main table. */
3642 if (mpls_lsp_install(zvrf
, ZEBRA_LSP_STATIC
, in_label
, 1, &out_label
,
3643 gtype
, gate
, ifindex
))
3650 * Delete static LSP entry. This may be the delete of one particular
3651 * NHLFE for this incoming label or the delete of the entire entry (i.e.,
3653 * NOTE: Delete of the only NHLFE will also end up deleting the entire
3654 * LSP configuration.
3656 int zebra_mpls_static_lsp_del(struct zebra_vrf
*zvrf
, mpls_label_t in_label
,
3657 enum nexthop_types_t gtype
, union g_addr
*gate
,
3660 struct hash
*slsp_table
;
3661 struct zebra_ile tmp_ile
;
3662 struct zebra_lsp
*lsp
;
3663 struct zebra_nhlfe
*nhlfe
;
3666 slsp_table
= zvrf
->slsp_table
;
3670 /* If entry is not present, exit. */
3671 tmp_ile
.in_label
= in_label
;
3672 lsp
= hash_lookup(slsp_table
, &tmp_ile
);
3676 /* Is it delete of entire LSP or a specific NHLFE? */
3677 if (gtype
== NEXTHOP_TYPE_BLACKHOLE
) {
3678 if (IS_ZEBRA_DEBUG_MPLS
)
3679 zlog_debug("Del static LSP in-label %u", in_label
);
3681 /* Uninstall entire LSP from the main table. */
3682 mpls_static_lsp_uninstall_all(zvrf
, in_label
);
3684 /* Delete all static NHLFEs */
3685 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3689 /* Find specific NHLFE, exit if not found. */
3690 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
,
3691 gtype
, gate
, ifindex
);
3695 if (IS_ZEBRA_DEBUG_MPLS
) {
3697 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3698 zlog_debug("Del static LSP in-label %u nexthop %s",
3702 /* Uninstall LSP from the main table. */
3703 mpls_lsp_uninstall(zvrf
, ZEBRA_LSP_STATIC
, in_label
, gtype
,
3704 gate
, ifindex
, false);
3706 /* Delete static LSP NHLFE */
3710 /* Remove entire static LSP entry if no NHLFE - valid in either case
3713 if (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
) {
3714 lsp
= hash_release(slsp_table
, &tmp_ile
);
3715 lsp_free_nhlfe(lsp
);
3716 XFREE(MTYPE_LSP
, lsp
);
3723 * Schedule all MPLS label forwarding entries for processing.
3724 * Called upon changes that may affect one or more of them such as
3725 * interface or nexthop state changes.
3727 void zebra_mpls_lsp_schedule(struct zebra_vrf
*zvrf
)
3731 hash_iterate(zvrf
->lsp_table
, lsp_schedule
, NULL
);
3735 * Display MPLS label forwarding table for a specific LSP
3736 * (VTY command handler).
3738 void zebra_mpls_print_lsp(struct vty
*vty
, struct zebra_vrf
*zvrf
,
3739 mpls_label_t label
, bool use_json
)
3741 struct hash
*lsp_table
;
3742 struct zebra_lsp
*lsp
;
3743 struct zebra_ile tmp_ile
;
3744 json_object
*json
= NULL
;
3747 lsp_table
= zvrf
->lsp_table
;
3751 /* If entry is not present, exit. */
3752 tmp_ile
.in_label
= label
;
3753 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3758 json
= lsp_json(lsp
);
3759 vty_json(vty
, json
);
3761 lsp_print(vty
, lsp
);
3765 * Display MPLS label forwarding table (VTY command handler).
3767 void zebra_mpls_print_lsp_table(struct vty
*vty
, struct zebra_vrf
*zvrf
,
3771 json_object
*json
= NULL
;
3772 struct zebra_lsp
*lsp
= NULL
;
3773 struct zebra_nhlfe
*nhlfe
= NULL
;
3774 struct listnode
*node
= NULL
;
3775 struct list
*lsp_list
= hash_get_sorted_list(zvrf
->lsp_table
, lsp_cmp
);
3778 json
= json_object_new_object();
3780 for (ALL_LIST_ELEMENTS_RO(lsp_list
, node
, lsp
))
3781 json_object_object_add(json
,
3782 label2str(lsp
->ile
.in_label
, 0,
3786 vty_json(vty
, json
);
3790 /* Prepare table. */
3791 tt
= ttable_new(&ttable_styles
[TTSTYLE_BLANK
]);
3792 ttable_add_row(tt
, "Inbound Label|Type|Nexthop|Outbound Label");
3793 tt
->style
.cell
.rpad
= 2;
3794 tt
->style
.corner
= '+';
3796 ttable_rowseps(tt
, 0, BOTTOM
, true, '-');
3798 for (ALL_LIST_ELEMENTS_RO(lsp_list
, node
, lsp
)) {
3799 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3800 struct nexthop
*nexthop
;
3801 const char *out_label_str
;
3802 char nh_buf
[NEXTHOP_STRLEN
];
3804 nexthop
= nhlfe
->nexthop
;
3806 switch (nexthop
->type
) {
3807 case NEXTHOP_TYPE_IFINDEX
: {
3808 struct zebra_ns
*zns
;
3809 struct interface
*ifp
;
3811 zns
= zebra_ns_lookup(NS_DEFAULT
);
3812 ifp
= if_lookup_by_index_per_ns(
3813 zns
, nexthop
->ifindex
);
3814 snprintf(nh_buf
, sizeof(nh_buf
), "%s",
3815 ifp
? ifp
->name
: "Null");
3818 case NEXTHOP_TYPE_IPV4
:
3819 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3820 inet_ntop(AF_INET
, &nexthop
->gate
.ipv4
,
3821 nh_buf
, sizeof(nh_buf
));
3823 case NEXTHOP_TYPE_IPV6
:
3824 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3825 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
,
3826 nh_buf
, sizeof(nh_buf
));
3828 case NEXTHOP_TYPE_BLACKHOLE
:
3832 if (nexthop
->type
!= NEXTHOP_TYPE_IFINDEX
)
3833 out_label_str
= mpls_label2str(
3834 nexthop
->nh_label
->num_labels
,
3835 &nexthop
->nh_label
->label
[0],
3837 nexthop
->nh_label_type
, 1);
3839 out_label_str
= "-";
3841 ttable_add_row(tt
, "%u|%s|%s|%s",
3843 nhlfe_type2str(nhlfe
->type
),
3844 nh_buf
, out_label_str
);
3848 /* Dump the generated table. */
3849 if (tt
->nrows
> 1) {
3850 char *table
= ttable_dump(tt
, "\n");
3851 vty_out(vty
, "%s\n", table
);
3852 XFREE(MTYPE_TMP
, table
);
3857 list_delete(&lsp_list
);
3861 * Create printable string for static LSP configuration.
3863 static char *nhlfe_config_str(const struct zebra_nhlfe
*nhlfe
, char *buf
,
3866 const struct nexthop
*nh
;
3868 nh
= nhlfe
->nexthop
;
3872 case NEXTHOP_TYPE_IPV4
:
3873 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3874 inet_ntop(AF_INET
, &nh
->gate
.ipv4
, buf
, size
);
3876 strlcat(buf
, ifindex2ifname(nh
->ifindex
, VRF_DEFAULT
),
3879 case NEXTHOP_TYPE_IPV6
:
3880 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3881 inet_ntop(AF_INET6
, &nh
->gate
.ipv6
, buf
, size
);
3884 ifindex2ifname(nh
->ifindex
, VRF_DEFAULT
),
3887 case NEXTHOP_TYPE_IFINDEX
:
3890 ifindex2ifname(nh
->ifindex
, VRF_DEFAULT
),
3893 case NEXTHOP_TYPE_BLACKHOLE
:
3901 * Display MPLS LSP configuration of all static LSPs (VTY command handler).
3903 int zebra_mpls_write_lsp_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
3905 struct zebra_lsp
*lsp
;
3906 struct zebra_nhlfe
*nhlfe
;
3908 struct listnode
*node
;
3909 struct list
*slsp_list
=
3910 hash_get_sorted_list(zvrf
->slsp_table
, lsp_cmp
);
3912 for (ALL_LIST_ELEMENTS_RO(slsp_list
, node
, lsp
)) {
3913 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3917 nh
= nhlfe
->nexthop
;
3918 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3921 nhlfe_config_str(nhlfe
, buf
, sizeof(buf
));
3923 switch (nh
->nh_label
->label
[0]) {
3924 case MPLS_LABEL_IPV4_EXPLICIT_NULL
:
3925 case MPLS_LABEL_IPV6_EXPLICIT_NULL
:
3926 strlcpy(lstr
, "explicit-null", sizeof(lstr
));
3928 case MPLS_LABEL_IMPLICIT_NULL
:
3929 strlcpy(lstr
, "implicit-null", sizeof(lstr
));
3932 snprintf(lstr
, sizeof(lstr
), "%u",
3933 nh
->nh_label
->label
[0]);
3937 vty_out(vty
, "mpls lsp %u %s %s\n", lsp
->ile
.in_label
,
3942 list_delete(&slsp_list
);
3943 return (zvrf
->slsp_table
->count
? 1 : 0);
3947 * Add/update global label block.
3949 int zebra_mpls_label_block_add(struct zebra_vrf
*zvrf
, uint32_t start_label
,
3952 zvrf
->mpls_srgb
.start_label
= start_label
;
3953 zvrf
->mpls_srgb
.end_label
= end_label
;
3955 /* Evaluate registered FECs to see if any get a label or not. */
3961 * Delete global label block.
3963 int zebra_mpls_label_block_del(struct zebra_vrf
*zvrf
)
3965 zvrf
->mpls_srgb
.start_label
= MPLS_DEFAULT_MIN_SRGB_LABEL
;
3966 zvrf
->mpls_srgb
.end_label
= MPLS_DEFAULT_MAX_SRGB_LABEL
;
3968 /* Process registered FECs to clear their local label, if needed. */
3974 * Display MPLS global label block configuration (VTY command handler).
3976 int zebra_mpls_write_label_block_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
3978 if (zvrf
->mpls_srgb
.start_label
== 0)
3981 if ((zvrf
->mpls_srgb
.start_label
!= MPLS_DEFAULT_MIN_SRGB_LABEL
)
3982 || (zvrf
->mpls_srgb
.end_label
!= MPLS_DEFAULT_MAX_SRGB_LABEL
)) {
3983 vty_out(vty
, "mpls label global-block %u %u\n",
3984 zvrf
->mpls_srgb
.start_label
, zvrf
->mpls_srgb
.end_label
);
3991 * Called when VRF becomes inactive, cleans up information but keeps
3994 void zebra_mpls_cleanup_tables(struct zebra_vrf
*zvrf
)
3996 struct zebra_vrf
*def_zvrf
;
3999 if (zvrf_id(zvrf
) == VRF_DEFAULT
)
4000 hash_iterate(zvrf
->lsp_table
, lsp_uninstall_from_kernel
, NULL
);
4003 * For other vrfs, we try to remove associated LSPs; we locate
4004 * the LSPs in the default vrf.
4006 def_zvrf
= zebra_vrf_lookup_by_id(VRF_DEFAULT
);
4008 /* At shutdown, the default may be gone already */
4009 if (def_zvrf
== NULL
)
4012 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
4013 if (zvrf
->label
[afi
] != MPLS_LABEL_NONE
)
4014 lsp_uninstall(def_zvrf
, zvrf
->label
[afi
]);
4020 * When a vrf label is assigned and the client goes away
4021 * we should cleanup the vrf labels associated with
4024 void zebra_mpls_client_cleanup_vrf_label(uint8_t proto
)
4027 struct zebra_vrf
*def_zvrf
= zebra_vrf_lookup_by_id(VRF_DEFAULT
);
4029 if (def_zvrf
== NULL
)
4032 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
4033 struct zebra_vrf
*zvrf
= vrf
->info
;
4039 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
4040 if (zvrf
->label_proto
[afi
] == proto
4041 && zvrf
->label
[afi
] != MPLS_LABEL_NONE
)
4042 lsp_uninstall(def_zvrf
, zvrf
->label
[afi
]);
4045 * Cleanup data structures by fiat
4047 zvrf
->label_proto
[afi
] = 0;
4048 zvrf
->label
[afi
] = MPLS_LABEL_NONE
;
4053 static void lsp_table_free(void *p
)
4055 struct zebra_lsp
*lsp
= p
;
4057 lsp_free_nhlfe(lsp
);
4059 XFREE(MTYPE_LSP
, lsp
);
4063 * Called upon process exiting, need to delete LSP forwarding
4064 * entries from the kernel.
4065 * NOTE: Currently supported only for default VRF.
4067 void zebra_mpls_close_tables(struct zebra_vrf
*zvrf
)
4069 hash_iterate(zvrf
->lsp_table
, lsp_uninstall_from_kernel
, NULL
);
4070 hash_clean(zvrf
->lsp_table
, lsp_table_free
);
4071 hash_free(zvrf
->lsp_table
);
4072 hash_clean(zvrf
->slsp_table
, lsp_table_free
);
4073 hash_free(zvrf
->slsp_table
);
4074 route_table_finish(zvrf
->fec_table
[AFI_IP
]);
4075 route_table_finish(zvrf
->fec_table
[AFI_IP6
]);
4079 * Allocate MPLS tables for this VRF and do other initialization.
4080 * NOTE: Currently supported only for default VRF.
4082 void zebra_mpls_init_tables(struct zebra_vrf
*zvrf
)
4089 snprintf(buffer
, sizeof(buffer
), "ZEBRA SLSP table: %s",
4091 zvrf
->slsp_table
= hash_create_size(8, label_hash
, label_cmp
, buffer
);
4093 snprintf(buffer
, sizeof(buffer
), "ZEBRA LSP table: %s",
4095 zvrf
->lsp_table
= hash_create_size(8, label_hash
, label_cmp
, buffer
);
4096 zvrf
->fec_table
[AFI_IP
] = route_table_init();
4097 zvrf
->fec_table
[AFI_IP6
] = route_table_init();
4098 zvrf
->mpls_flags
= 0;
4099 zvrf
->mpls_srgb
.start_label
= MPLS_DEFAULT_MIN_SRGB_LABEL
;
4100 zvrf
->mpls_srgb
.end_label
= MPLS_DEFAULT_MAX_SRGB_LABEL
;
4103 void zebra_mpls_turned_on(void)
4105 if (!mpls_enabled
) {
4106 mpls_processq_init();
4107 mpls_enabled
= true;
4110 hook_register(zserv_client_close
, zebra_mpls_cleanup_fecs_for_client
);
4111 hook_register(zserv_client_close
, zebra_mpls_cleanup_zclient_labels
);
4115 * Global MPLS initialization.
4117 void zebra_mpls_init(void)
4119 mpls_enabled
= false;
4120 mpls_pw_reach_strict
= false;
4122 if (mpls_kernel_init() < 0) {
4123 flog_warn(EC_ZEBRA_MPLS_SUPPORT_DISABLED
,
4124 "Disabling MPLS support (no kernel support)");
4128 zebra_mpls_turned_on();