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");
58 /* static function declarations */
60 static void fec_evaluate(struct zebra_vrf
*zvrf
);
61 static uint32_t fec_derive_label_from_index(struct zebra_vrf
*vrf
,
63 static int lsp_install(struct zebra_vrf
*zvrf
, mpls_label_t label
,
64 struct route_node
*rn
, struct route_entry
*re
);
65 static int lsp_uninstall(struct zebra_vrf
*zvrf
, mpls_label_t label
);
66 static int fec_change_update_lsp(struct zebra_vrf
*zvrf
, zebra_fec_t
*fec
,
67 mpls_label_t old_label
);
68 static int fec_send(zebra_fec_t
*fec
, struct zserv
*client
);
69 static void fec_update_clients(zebra_fec_t
*fec
);
70 static void fec_print(zebra_fec_t
*fec
, struct vty
*vty
);
71 static zebra_fec_t
*fec_find(struct route_table
*table
, struct prefix
*p
);
72 static zebra_fec_t
*fec_add(struct route_table
*table
, struct prefix
*p
,
73 mpls_label_t label
, uint32_t flags
,
74 uint32_t label_index
);
75 static int fec_del(zebra_fec_t
*fec
);
77 static unsigned int label_hash(const void *p
);
78 static bool label_cmp(const void *p1
, const void *p2
);
79 static int nhlfe_nexthop_active_ipv4(zebra_nhlfe_t
*nhlfe
,
80 struct nexthop
*nexthop
);
81 static int nhlfe_nexthop_active_ipv6(zebra_nhlfe_t
*nhlfe
,
82 struct nexthop
*nexthop
);
83 static int nhlfe_nexthop_active(zebra_nhlfe_t
*nhlfe
);
85 static void lsp_select_best_nhlfe(zebra_lsp_t
*lsp
);
86 static void lsp_uninstall_from_kernel(struct hash_bucket
*bucket
, void *ctxt
);
87 static void lsp_schedule(struct hash_bucket
*bucket
, void *ctxt
);
88 static wq_item_status
lsp_process(struct work_queue
*wq
, void *data
);
89 static void lsp_processq_del(struct work_queue
*wq
, void *data
);
90 static void lsp_processq_complete(struct work_queue
*wq
);
91 static int lsp_processq_add(zebra_lsp_t
*lsp
);
92 static void *lsp_alloc(void *p
);
94 /* Check whether lsp can be freed - no nhlfes, e.g., and call free api */
95 static void lsp_check_free(struct hash
*lsp_table
, zebra_lsp_t
**plsp
);
97 /* Free lsp; sets caller's pointer to NULL */
98 static void lsp_free(struct hash
*lsp_table
, zebra_lsp_t
**plsp
);
100 static char *nhlfe2str(const zebra_nhlfe_t
*nhlfe
, char *buf
, int size
);
101 static char *nhlfe_config_str(const zebra_nhlfe_t
*nhlfe
, char *buf
, int size
);
102 static int nhlfe_nhop_match(zebra_nhlfe_t
*nhlfe
, enum nexthop_types_t gtype
,
103 const union g_addr
*gate
, ifindex_t ifindex
);
104 static zebra_nhlfe_t
*nhlfe_find(struct nhlfe_list_head
*list
,
105 enum lsp_types_t lsp_type
,
106 enum nexthop_types_t gtype
,
107 const union g_addr
*gate
, ifindex_t ifindex
);
108 static zebra_nhlfe_t
*nhlfe_add(zebra_lsp_t
*lsp
, enum lsp_types_t lsp_type
,
109 enum nexthop_types_t gtype
,
110 const union g_addr
*gate
, ifindex_t ifindex
,
111 uint8_t num_labels
, const mpls_label_t
*labels
,
113 static int nhlfe_del(zebra_nhlfe_t
*nhlfe
);
114 static void nhlfe_free(zebra_nhlfe_t
*nhlfe
);
115 static void nhlfe_out_label_update(zebra_nhlfe_t
*nhlfe
,
116 struct mpls_label_stack
*nh_label
);
117 static int mpls_lsp_uninstall_all(struct hash
*lsp_table
, zebra_lsp_t
*lsp
,
118 enum lsp_types_t type
);
119 static int mpls_static_lsp_uninstall_all(struct zebra_vrf
*zvrf
,
120 mpls_label_t in_label
);
121 static void nhlfe_print(zebra_nhlfe_t
*nhlfe
, struct vty
*vty
,
123 static void lsp_print(struct vty
*vty
, zebra_lsp_t
*lsp
);
124 static void mpls_lsp_uninstall_all_type(struct hash_bucket
*bucket
, void *ctxt
);
125 static void mpls_ftn_uninstall_all(struct zebra_vrf
*zvrf
,
126 int afi
, enum lsp_types_t lsp_type
);
127 static int lsp_znh_install(zebra_lsp_t
*lsp
, enum lsp_types_t type
,
128 const struct zapi_nexthop
*znh
);
129 static int lsp_backup_znh_install(zebra_lsp_t
*lsp
, enum lsp_types_t type
,
130 const struct zapi_nexthop
*znh
);
132 /* Static functions */
135 * Handle failure in LSP install, clear flags for NHLFE.
137 static void clear_nhlfe_installed(zebra_lsp_t
*lsp
)
139 zebra_nhlfe_t
*nhlfe
;
140 struct nexthop
*nexthop
;
142 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
143 nexthop
= nhlfe
->nexthop
;
147 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
148 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
151 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
152 nexthop
= nhlfe
->nexthop
;
156 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
157 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
162 * Install label forwarding entry based on labeled-route entry.
164 static int lsp_install(struct zebra_vrf
*zvrf
, mpls_label_t label
,
165 struct route_node
*rn
, struct route_entry
*re
)
167 struct hash
*lsp_table
;
170 zebra_nhlfe_t
*nhlfe
;
171 struct nexthop
*nexthop
;
172 enum lsp_types_t lsp_type
;
177 lsp_table
= zvrf
->lsp_table
;
181 lsp_type
= lsp_type_from_re_type(re
->type
);
184 /* Locate or allocate LSP entry. */
185 tmp_ile
.in_label
= label
;
186 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
190 /* For each active nexthop, create NHLFE. Note that we deliberately skip
191 * recursive nexthops right now, because intermediate hops won't
193 * the label advertised by the recursive nexthop (plus we don't have the
194 * logic yet to push multiple labels).
196 for (nexthop
= re
->nhe
->nhg
.nexthop
;
197 nexthop
; nexthop
= nexthop
->next
) {
198 /* Skip inactive and recursive entries. */
199 if (!CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
))
201 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_RECURSIVE
))
204 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, lsp_type
,
205 nexthop
->type
, &nexthop
->gate
,
208 /* Clear deleted flag (in case it was set) */
209 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
210 if (nexthop_labels_match(nhlfe
->nexthop
, nexthop
))
215 if (IS_ZEBRA_DEBUG_MPLS
) {
216 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
218 "LSP in-label %u type %d nexthop %s out-label changed",
219 lsp
->ile
.in_label
, lsp_type
, buf
);
222 /* Update out label, trigger processing. */
223 nhlfe_out_label_update(nhlfe
, nexthop
->nh_label
);
224 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
227 /* Add LSP entry to this nexthop */
228 nhlfe
= nhlfe_add(lsp
, lsp_type
, nexthop
->type
,
229 &nexthop
->gate
, nexthop
->ifindex
,
230 nexthop
->nh_label
->num_labels
,
231 nexthop
->nh_label
->label
,
236 if (IS_ZEBRA_DEBUG_MPLS
) {
237 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
239 "Add LSP in-label %u type %d nexthop %s out-label %u",
240 lsp
->ile
.in_label
, lsp_type
, buf
,
241 nexthop
->nh_label
->label
[0]);
244 lsp
->addr_family
= NHLFE_FAMILY(nhlfe
);
246 /* Mark NHLFE as changed. */
247 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
252 /* Queue LSP for processing if necessary. If no NHLFE got added (special
253 * case), delete the LSP entry; this case results in somewhat ugly
256 if (added
|| changed
) {
257 if (lsp_processq_add(lsp
))
260 lsp_check_free(lsp_table
, &lsp
);
267 * Uninstall all non-static NHLFEs of a label forwarding entry. If all
268 * NHLFEs are removed, the entire entry is deleted.
270 static int lsp_uninstall(struct zebra_vrf
*zvrf
, mpls_label_t label
)
272 struct hash
*lsp_table
;
275 zebra_nhlfe_t
*nhlfe
;
279 lsp_table
= zvrf
->lsp_table
;
283 /* If entry is not present, exit. */
284 tmp_ile
.in_label
= label
;
285 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
286 if (!lsp
|| (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
))
289 /* Mark NHLFEs for delete or directly delete, as appropriate. */
290 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
292 /* Skip static NHLFEs */
293 if (nhlfe
->type
== ZEBRA_LSP_STATIC
)
296 if (IS_ZEBRA_DEBUG_MPLS
) {
297 nhlfe2str(nhlfe
, buf
, BUFSIZ
);
299 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
300 label
, nhlfe
->type
, buf
, nhlfe
->flags
);
303 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
)) {
304 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
305 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
311 /* Queue LSP for processing, if needed, else delete. */
312 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
)) {
313 if (lsp_processq_add(lsp
))
316 lsp_check_free(lsp_table
, &lsp
);
323 * This function is invoked upon change to label block configuration; it
324 * will walk all registered FECs with label-index and appropriately update
325 * their local labels and trigger client updates.
327 static void fec_evaluate(struct zebra_vrf
*zvrf
)
329 struct route_node
*rn
;
331 uint32_t old_label
, new_label
;
334 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
335 if (zvrf
->fec_table
[af
] == NULL
)
338 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
339 rn
= route_next(rn
)) {
340 if ((fec
= rn
->info
) == NULL
)
343 /* Skip configured FECs and those without a label index.
345 if (fec
->flags
& FEC_FLAG_CONFIGURED
346 || fec
->label_index
== MPLS_INVALID_LABEL_INDEX
)
349 /* Save old label, determine new label. */
350 old_label
= fec
->label
;
352 zvrf
->mpls_srgb
.start_label
+ fec
->label_index
;
353 if (new_label
>= zvrf
->mpls_srgb
.end_label
)
354 new_label
= MPLS_INVALID_LABEL
;
356 /* If label has changed, update FEC and clients. */
357 if (new_label
== old_label
)
360 if (IS_ZEBRA_DEBUG_MPLS
)
362 "Update fec %pRN new label %u upon label block",
365 fec
->label
= new_label
;
366 fec_update_clients(fec
);
368 /* Update label forwarding entries appropriately */
369 fec_change_update_lsp(zvrf
, fec
, old_label
);
375 * Derive (if possible) and update the local label for the FEC based on
376 * its label index. The index is "acceptable" if it falls within the
377 * globally configured label block (SRGB).
379 static uint32_t fec_derive_label_from_index(struct zebra_vrf
*zvrf
,
384 if (fec
->label_index
!= MPLS_INVALID_LABEL_INDEX
385 && zvrf
->mpls_srgb
.start_label
386 && ((label
= zvrf
->mpls_srgb
.start_label
+ fec
->label_index
)
387 < zvrf
->mpls_srgb
.end_label
))
390 fec
->label
= MPLS_INVALID_LABEL
;
396 * There is a change for this FEC. Install or uninstall label forwarding
397 * entries, as appropriate.
399 static int fec_change_update_lsp(struct zebra_vrf
*zvrf
, zebra_fec_t
*fec
,
400 mpls_label_t old_label
)
402 struct route_table
*table
;
403 struct route_node
*rn
;
404 struct route_entry
*re
;
407 /* Uninstall label forwarding entry, if previously installed. */
408 if (old_label
!= MPLS_INVALID_LABEL
409 && old_label
!= MPLS_LABEL_IMPLICIT_NULL
)
410 lsp_uninstall(zvrf
, old_label
);
412 /* Install label forwarding entry corr. to new label, if needed. */
413 if (fec
->label
== MPLS_INVALID_LABEL
414 || fec
->label
== MPLS_LABEL_IMPLICIT_NULL
)
417 afi
= family2afi(PREFIX_FAMILY(&fec
->rn
->p
));
418 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
422 /* See if labeled route exists. */
423 rn
= route_node_lookup(table
, &fec
->rn
->p
);
427 RNODE_FOREACH_RE (rn
, re
) {
428 if (CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
))
432 if (!re
|| !zebra_rib_labeled_unicast(re
))
435 if (lsp_install(zvrf
, fec
->label
, rn
, re
))
442 * Inform about FEC to a registered client.
444 static int fec_send(zebra_fec_t
*fec
, struct zserv
*client
)
447 struct route_node
*rn
;
451 /* Get output stream. */
452 s
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
454 zclient_create_header(s
, ZEBRA_FEC_UPDATE
, VRF_DEFAULT
);
456 stream_putw(s
, rn
->p
.family
);
457 stream_put_prefix(s
, &rn
->p
);
458 stream_putl(s
, fec
->label
);
459 stream_putw_at(s
, 0, stream_get_endp(s
));
460 return zserv_send_message(client
, s
);
464 * Update all registered clients about this FEC. Caller should've updated
465 * FEC and ensure no duplicate updates.
467 static void fec_update_clients(zebra_fec_t
*fec
)
469 struct listnode
*node
;
470 struct zserv
*client
;
472 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
, client
)) {
473 if (IS_ZEBRA_DEBUG_MPLS
)
474 zlog_debug("Update client %s",
475 zebra_route_string(client
->proto
));
476 fec_send(fec
, client
);
482 * Print a FEC-label binding entry.
484 static void fec_print(zebra_fec_t
*fec
, struct vty
*vty
)
486 struct route_node
*rn
;
487 struct listnode
*node
;
488 struct zserv
*client
;
492 vty_out(vty
, "%pRN\n", rn
);
493 vty_out(vty
, " Label: %s", label2str(fec
->label
, buf
, BUFSIZ
));
494 if (fec
->label_index
!= MPLS_INVALID_LABEL_INDEX
)
495 vty_out(vty
, ", Label Index: %u", fec
->label_index
);
497 if (!list_isempty(fec
->client_list
)) {
498 vty_out(vty
, " Client list:");
499 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
, client
))
500 vty_out(vty
, " %s(fd %d)",
501 zebra_route_string(client
->proto
),
508 * Locate FEC-label binding that matches with passed info.
510 static zebra_fec_t
*fec_find(struct route_table
*table
, struct prefix
*p
)
512 struct route_node
*rn
;
515 rn
= route_node_lookup(table
, p
);
519 route_unlock_node(rn
);
524 * Add a FEC. This may be upon a client registering for a binding
525 * or when a binding is configured.
527 static zebra_fec_t
*fec_add(struct route_table
*table
, struct prefix
*p
,
528 mpls_label_t label
, uint32_t flags
,
529 uint32_t label_index
)
531 struct route_node
*rn
;
536 /* Lookup (or add) route node.*/
537 rn
= route_node_get(table
, p
);
544 fec
= XCALLOC(MTYPE_FEC
, sizeof(zebra_fec_t
));
549 fec
->client_list
= list_new();
551 route_unlock_node(rn
); /* for the route_node_get */
553 fec
->label_index
= label_index
;
560 * Delete a FEC. This may be upon the last client deregistering for
561 * a FEC and no binding exists or when the binding is deleted and there
562 * are no registered clients.
564 static int fec_del(zebra_fec_t
*fec
)
566 list_delete(&fec
->client_list
);
567 fec
->rn
->info
= NULL
;
568 route_unlock_node(fec
->rn
);
569 XFREE(MTYPE_FEC
, fec
);
574 * Hash function for label.
576 static unsigned int label_hash(const void *p
)
578 const zebra_ile_t
*ile
= p
;
580 return (jhash_1word(ile
->in_label
, 0));
584 * Compare 2 LSP hash entries based on in-label.
586 static bool label_cmp(const void *p1
, const void *p2
)
588 const zebra_ile_t
*ile1
= p1
;
589 const zebra_ile_t
*ile2
= p2
;
591 return (ile1
->in_label
== ile2
->in_label
);
595 * Check if an IPv4 nexthop for a NHLFE is active. Update nexthop based on
597 * NOTE: Looking only for connected routes right now.
599 static int nhlfe_nexthop_active_ipv4(zebra_nhlfe_t
*nhlfe
,
600 struct nexthop
*nexthop
)
602 struct route_table
*table
;
603 struct prefix_ipv4 p
;
604 struct route_node
*rn
;
605 struct route_entry
*match
;
606 struct nexthop
*match_nh
;
608 table
= zebra_vrf_table(AFI_IP
, SAFI_UNICAST
, nexthop
->vrf_id
);
612 /* Lookup nexthop in IPv4 routing table. */
613 memset(&p
, 0, sizeof(struct prefix_ipv4
));
615 p
.prefixlen
= IPV4_MAX_PREFIXLEN
;
616 p
.prefix
= nexthop
->gate
.ipv4
;
618 rn
= route_node_match(table
, (struct prefix
*)&p
);
622 route_unlock_node(rn
);
624 /* Locate a valid connected route. */
625 RNODE_FOREACH_RE (rn
, match
) {
626 if (CHECK_FLAG(match
->status
, ROUTE_ENTRY_REMOVED
)
627 || !CHECK_FLAG(match
->flags
, ZEBRA_FLAG_SELECTED
))
630 for (match_nh
= match
->nhe
->nhg
.nexthop
; match_nh
;
631 match_nh
= match_nh
->next
) {
632 if (match
->type
== ZEBRA_ROUTE_CONNECT
633 || nexthop
->ifindex
== match_nh
->ifindex
) {
634 nexthop
->ifindex
= match_nh
->ifindex
;
645 * Check if an IPv6 nexthop for a NHLFE is active. Update nexthop based on
647 * NOTE: Looking only for connected routes right now.
649 static int nhlfe_nexthop_active_ipv6(zebra_nhlfe_t
*nhlfe
,
650 struct nexthop
*nexthop
)
652 struct route_table
*table
;
653 struct prefix_ipv6 p
;
654 struct route_node
*rn
;
655 struct route_entry
*match
;
657 table
= zebra_vrf_table(AFI_IP6
, SAFI_UNICAST
, nexthop
->vrf_id
);
661 /* Lookup nexthop in IPv6 routing table. */
662 memset(&p
, 0, sizeof(struct prefix_ipv6
));
664 p
.prefixlen
= IPV6_MAX_PREFIXLEN
;
665 p
.prefix
= nexthop
->gate
.ipv6
;
667 rn
= route_node_match(table
, (struct prefix
*)&p
);
671 route_unlock_node(rn
);
673 /* Locate a valid connected route. */
674 RNODE_FOREACH_RE (rn
, match
) {
675 if ((match
->type
== ZEBRA_ROUTE_CONNECT
)
676 && !CHECK_FLAG(match
->status
, ROUTE_ENTRY_REMOVED
)
677 && CHECK_FLAG(match
->flags
, ZEBRA_FLAG_SELECTED
))
681 if (!match
|| !match
->nhe
->nhg
.nexthop
)
684 nexthop
->ifindex
= match
->nhe
->nhg
.nexthop
->ifindex
;
690 * Check the nexthop reachability for a NHLFE and return if valid (reachable)
692 * NOTE: Each NHLFE points to only 1 nexthop.
694 static int nhlfe_nexthop_active(zebra_nhlfe_t
*nhlfe
)
696 struct nexthop
*nexthop
;
697 struct interface
*ifp
;
698 struct zebra_ns
*zns
;
700 nexthop
= nhlfe
->nexthop
;
701 if (!nexthop
) // unexpected
704 /* Check on nexthop based on type. */
705 switch (nexthop
->type
) {
706 case NEXTHOP_TYPE_IFINDEX
:
708 * Lookup if this type is special. The
709 * NEXTHOP_TYPE_IFINDEX is a pop and
710 * forward into a different table for
711 * processing. As such this ifindex
712 * passed to us may be a VRF device
713 * which will not be in the default
714 * VRF. So let's look in all of them
716 zns
= zebra_ns_lookup(NS_DEFAULT
);
717 ifp
= if_lookup_by_index_per_ns(zns
, nexthop
->ifindex
);
718 if (ifp
&& if_is_operative(ifp
))
719 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
721 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
723 case NEXTHOP_TYPE_IPV4
:
724 case NEXTHOP_TYPE_IPV4_IFINDEX
:
725 if (nhlfe_nexthop_active_ipv4(nhlfe
, nexthop
))
726 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
728 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
731 case NEXTHOP_TYPE_IPV6
:
732 if (nhlfe_nexthop_active_ipv6(nhlfe
, nexthop
))
733 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
735 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
738 case NEXTHOP_TYPE_IPV6_IFINDEX
:
739 if (IN6_IS_ADDR_LINKLOCAL(&nexthop
->gate
.ipv6
)) {
740 ifp
= if_lookup_by_index(nexthop
->ifindex
,
742 if (ifp
&& if_is_operative(ifp
))
743 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
745 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
747 if (nhlfe_nexthop_active_ipv6(nhlfe
, nexthop
))
748 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
750 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
758 return CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
762 * Walk through NHLFEs for a LSP forwarding entry, verify nexthop
763 * reachability and select the best. Multipath entries are also
764 * marked. This is invoked when an LSP scheduled for processing (due
765 * to some change) is examined.
767 static void lsp_select_best_nhlfe(zebra_lsp_t
*lsp
)
769 zebra_nhlfe_t
*nhlfe
;
771 struct nexthop
*nexthop
;
779 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
782 * First compute the best path, after checking nexthop status. We are
783 * only concerned with non-deleted NHLFEs.
785 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
786 /* Clear selection flags. */
787 UNSET_FLAG(nhlfe
->flags
,
788 (NHLFE_FLAG_SELECTED
| NHLFE_FLAG_MULTIPATH
));
790 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
)
791 && nhlfe_nexthop_active(nhlfe
)) {
792 if (!best
|| (nhlfe
->distance
< best
->distance
))
797 lsp
->best_nhlfe
= best
;
798 if (!lsp
->best_nhlfe
)
802 * Check the active status of backup nhlfes also
804 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
805 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
806 (void)nhlfe_nexthop_active(nhlfe
);
809 /* Mark best NHLFE as selected. */
810 SET_FLAG(lsp
->best_nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
813 * If best path exists, see if there is ECMP. While doing this, note if
815 * new (uninstalled) NHLFE has been selected, an installed entry that is
816 * still selected has a change or an installed entry is to be removed.
818 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
819 int nh_chg
, nh_sel
, nh_inst
;
821 nexthop
= nhlfe
->nexthop
;
822 if (!nexthop
) // unexpected
825 if (!CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
)
826 && CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
)
827 && (nhlfe
->distance
== lsp
->best_nhlfe
->distance
)) {
828 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
829 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_MULTIPATH
);
833 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) && !changed
) {
834 nh_chg
= CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
835 nh_sel
= CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
837 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
839 if ((nh_sel
&& !nh_inst
)
840 || (nh_sel
&& nh_inst
&& nh_chg
)
841 || (nh_inst
&& !nh_sel
))
845 /* We have finished examining, clear changed flag. */
846 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
850 SET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
854 * Delete LSP forwarding entry from kernel, if installed. Called upon
857 static void lsp_uninstall_from_kernel(struct hash_bucket
*bucket
, void *ctxt
)
861 lsp
= (zebra_lsp_t
*)bucket
->data
;
862 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
863 (void)dplane_lsp_delete(lsp
);
867 * Schedule LSP forwarding entry for processing. Called upon changes
868 * that may impact LSPs such as nexthop / connected route changes.
870 static void lsp_schedule(struct hash_bucket
*bucket
, void *ctxt
)
874 lsp
= (zebra_lsp_t
*)bucket
->data
;
876 /* In the common flow, this is used when external events occur. For
877 * LSPs with backup nhlfes, we'll assume that the forwarding
878 * plane will use the backups to handle these events, until the
879 * owning protocol can react.
882 /* Skip LSPs with backups */
883 if (nhlfe_list_first(&lsp
->backup_nhlfe_list
) != NULL
) {
884 if (IS_ZEBRA_DEBUG_MPLS_DETAIL
)
885 zlog_debug("%s: skip LSP in-label %u",
886 __func__
, lsp
->ile
.in_label
);
891 (void)lsp_processq_add(lsp
);
895 * Process a LSP entry that is in the queue. Recalculate best NHLFE and
896 * any multipaths and update or delete from the kernel, as needed.
898 static wq_item_status
lsp_process(struct work_queue
*wq
, void *data
)
901 zebra_nhlfe_t
*oldbest
, *newbest
;
902 char buf
[BUFSIZ
], buf2
[BUFSIZ
];
903 struct zebra_vrf
*zvrf
= vrf_info_lookup(VRF_DEFAULT
);
904 enum zebra_dplane_result res
;
906 lsp
= (zebra_lsp_t
*)data
;
907 if (!lsp
) // unexpected
910 oldbest
= lsp
->best_nhlfe
;
912 /* Select best NHLFE(s) */
913 lsp_select_best_nhlfe(lsp
);
915 newbest
= lsp
->best_nhlfe
;
917 if (IS_ZEBRA_DEBUG_MPLS
) {
919 nhlfe2str(oldbest
, buf
, sizeof(buf
));
921 nhlfe2str(newbest
, buf2
, sizeof(buf2
));
923 "Process LSP in-label %u oldbest %s newbest %s flags 0x%x ecmp# %d",
924 lsp
->ile
.in_label
, oldbest
? buf
: "NULL",
925 newbest
? buf2
: "NULL", lsp
->flags
, lsp
->num_ecmp
);
928 if (!CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
)) {
929 /* Not already installed */
932 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
934 switch (dplane_lsp_add(lsp
)) {
935 case ZEBRA_DPLANE_REQUEST_QUEUED
:
936 /* Set 'installed' flag so we will know
937 * that an install is in-flight.
939 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
941 zvrf
->lsp_installs_queued
++;
943 case ZEBRA_DPLANE_REQUEST_FAILURE
:
944 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
945 "LSP Install Failure: %u",
948 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
949 zvrf
->lsp_installs
++;
954 /* Installed, may need an update and/or delete. */
956 res
= dplane_lsp_delete(lsp
);
958 /* We do some of the lsp cleanup immediately for
961 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
962 clear_nhlfe_installed(lsp
);
965 case ZEBRA_DPLANE_REQUEST_QUEUED
:
966 zvrf
->lsp_removals_queued
++;
968 case ZEBRA_DPLANE_REQUEST_FAILURE
:
969 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE
,
970 "LSP Deletion Failure: %u",
973 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
974 zvrf
->lsp_removals
++;
977 } else if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
)) {
978 zebra_nhlfe_t
*nhlfe
;
979 struct nexthop
*nexthop
;
981 UNSET_FLAG(lsp
->flags
, LSP_FLAG_CHANGED
);
983 /* We leave the INSTALLED flag set here
984 * so we know an update is in-flight.
988 * Any NHLFE that was installed but is not
989 * selected now needs to have its flags updated.
991 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
992 nexthop
= nhlfe
->nexthop
;
996 if (CHECK_FLAG(nhlfe
->flags
,
997 NHLFE_FLAG_INSTALLED
)
998 && !CHECK_FLAG(nhlfe
->flags
,
999 NHLFE_FLAG_SELECTED
)) {
1000 UNSET_FLAG(nhlfe
->flags
,
1001 NHLFE_FLAG_INSTALLED
);
1002 UNSET_FLAG(nexthop
->flags
,
1007 switch (dplane_lsp_update(lsp
)) {
1008 case ZEBRA_DPLANE_REQUEST_QUEUED
:
1009 zvrf
->lsp_installs_queued
++;
1011 case ZEBRA_DPLANE_REQUEST_FAILURE
:
1012 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
1013 "LSP Update Failure: %u",
1016 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
1017 zvrf
->lsp_installs
++;
1028 * Callback upon processing completion of a LSP forwarding entry.
1030 static void lsp_processq_del(struct work_queue
*wq
, void *data
)
1032 struct zebra_vrf
*zvrf
;
1034 struct hash
*lsp_table
;
1035 zebra_nhlfe_t
*nhlfe
;
1037 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
1040 lsp_table
= zvrf
->lsp_table
;
1041 if (!lsp_table
) // unexpected
1044 lsp
= (zebra_lsp_t
*)data
;
1045 if (!lsp
) // unexpected
1048 /* Clear flag, remove any NHLFEs marked for deletion. If no NHLFEs
1050 * delete LSP entry also.
1052 UNSET_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
);
1054 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1055 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
1059 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1060 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
))
1064 lsp_check_free(lsp_table
, &lsp
);
1068 * Callback upon finishing the processing of all scheduled
1069 * LSP forwarding entries.
1071 static void lsp_processq_complete(struct work_queue
*wq
)
1073 /* Nothing to do for now. */
1077 * Add LSP forwarding entry to queue for subsequent processing.
1079 static int lsp_processq_add(zebra_lsp_t
*lsp
)
1081 /* If already scheduled, exit. */
1082 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
))
1085 if (zrouter
.lsp_process_q
== NULL
) {
1086 flog_err(EC_ZEBRA_WQ_NONEXISTENT
,
1087 "%s: work_queue does not exist!", __func__
);
1091 work_queue_add(zrouter
.lsp_process_q
, lsp
);
1092 SET_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
);
1097 * Callback to allocate LSP forwarding table entry.
1099 static void *lsp_alloc(void *p
)
1101 const zebra_ile_t
*ile
= p
;
1104 lsp
= XCALLOC(MTYPE_LSP
, sizeof(zebra_lsp_t
));
1106 nhlfe_list_init(&lsp
->nhlfe_list
);
1107 nhlfe_list_init(&lsp
->backup_nhlfe_list
);
1109 if (IS_ZEBRA_DEBUG_MPLS
)
1110 zlog_debug("Alloc LSP in-label %u", lsp
->ile
.in_label
);
1112 return ((void *)lsp
);
1116 * Check whether lsp can be freed - no nhlfes, e.g., and call free api
1118 static void lsp_check_free(struct hash
*lsp_table
, zebra_lsp_t
**plsp
)
1122 if (plsp
== NULL
|| *plsp
== NULL
)
1127 if ((nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
) &&
1128 (nhlfe_list_first(&lsp
->backup_nhlfe_list
) == NULL
) &&
1129 !CHECK_FLAG(lsp
->flags
, LSP_FLAG_SCHEDULED
))
1130 lsp_free(lsp_table
, plsp
);
1134 * Dtor for an LSP: remove from ile hash, release any internal allocations,
1137 static void lsp_free(struct hash
*lsp_table
, zebra_lsp_t
**plsp
)
1140 zebra_nhlfe_t
*nhlfe
;
1142 if (plsp
== NULL
|| *plsp
== NULL
)
1147 if (IS_ZEBRA_DEBUG_MPLS
)
1148 zlog_debug("Free LSP in-label %u flags 0x%x",
1149 lsp
->ile
.in_label
, lsp
->flags
);
1151 /* Free nhlfes, if any. */
1152 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
)
1155 /* Free backup nhlfes, if any. */
1156 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
)
1159 hash_release(lsp_table
, &lsp
->ile
);
1160 XFREE(MTYPE_LSP
, lsp
);
1166 * Create printable string for NHLFE entry.
1168 static char *nhlfe2str(const zebra_nhlfe_t
*nhlfe
, char *buf
, int size
)
1170 const struct nexthop
*nexthop
;
1173 nexthop
= nhlfe
->nexthop
;
1174 switch (nexthop
->type
) {
1175 case NEXTHOP_TYPE_IPV4
:
1176 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1177 inet_ntop(AF_INET
, &nexthop
->gate
.ipv4
, buf
, size
);
1179 case NEXTHOP_TYPE_IPV6
:
1180 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1181 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, size
);
1183 case NEXTHOP_TYPE_IFINDEX
:
1184 snprintf(buf
, size
, "Ifindex: %u", nexthop
->ifindex
);
1193 * Check if NHLFE matches with search info passed.
1195 static int nhlfe_nhop_match(zebra_nhlfe_t
*nhlfe
, enum nexthop_types_t gtype
,
1196 const union g_addr
*gate
, ifindex_t ifindex
)
1198 struct nexthop
*nhop
;
1201 nhop
= nhlfe
->nexthop
;
1205 if (nhop
->type
!= gtype
)
1208 switch (nhop
->type
) {
1209 case NEXTHOP_TYPE_IPV4
:
1210 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1211 cmp
= memcmp(&(nhop
->gate
.ipv4
), &(gate
->ipv4
),
1212 sizeof(struct in_addr
));
1213 if (!cmp
&& nhop
->type
== NEXTHOP_TYPE_IPV4_IFINDEX
)
1214 cmp
= !(nhop
->ifindex
== ifindex
);
1216 case NEXTHOP_TYPE_IPV6
:
1217 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1218 cmp
= memcmp(&(nhop
->gate
.ipv6
), &(gate
->ipv6
),
1219 sizeof(struct in6_addr
));
1220 if (!cmp
&& nhop
->type
== NEXTHOP_TYPE_IPV6_IFINDEX
)
1221 cmp
= !(nhop
->ifindex
== ifindex
);
1223 case NEXTHOP_TYPE_IFINDEX
:
1224 cmp
= !(nhop
->ifindex
== ifindex
);
1235 * Locate NHLFE that matches with passed info.
1237 static zebra_nhlfe_t
*nhlfe_find(struct nhlfe_list_head
*list
,
1238 enum lsp_types_t lsp_type
,
1239 enum nexthop_types_t gtype
,
1240 const union g_addr
*gate
, ifindex_t ifindex
)
1242 zebra_nhlfe_t
*nhlfe
;
1244 frr_each_safe(nhlfe_list
, list
, nhlfe
) {
1245 if (nhlfe
->type
!= lsp_type
)
1247 if (!nhlfe_nhop_match(nhlfe
, gtype
, gate
, ifindex
))
1255 * Allocate and init new NHLFE.
1257 static zebra_nhlfe_t
*nhlfe_alloc(zebra_lsp_t
*lsp
, enum lsp_types_t lsp_type
,
1258 enum nexthop_types_t gtype
,
1259 const union g_addr
*gate
, ifindex_t ifindex
,
1261 const mpls_label_t
*labels
)
1263 zebra_nhlfe_t
*nhlfe
;
1264 struct nexthop
*nexthop
;
1268 nhlfe
= XCALLOC(MTYPE_NHLFE
, sizeof(zebra_nhlfe_t
));
1271 nhlfe
->type
= lsp_type
;
1272 nhlfe
->distance
= lsp_distance(lsp_type
);
1274 nexthop
= nexthop_new();
1276 nexthop_add_labels(nexthop
, lsp_type
, num_labels
, labels
);
1278 nexthop
->vrf_id
= VRF_DEFAULT
;
1279 nexthop
->type
= gtype
;
1280 switch (nexthop
->type
) {
1281 case NEXTHOP_TYPE_IPV4
:
1282 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1283 nexthop
->gate
.ipv4
= gate
->ipv4
;
1285 nexthop
->ifindex
= ifindex
;
1287 case NEXTHOP_TYPE_IPV6
:
1288 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1289 nexthop
->gate
.ipv6
= gate
->ipv6
;
1291 nexthop
->ifindex
= ifindex
;
1293 case NEXTHOP_TYPE_IFINDEX
:
1294 nexthop
->ifindex
= ifindex
;
1297 nexthop_free(nexthop
);
1298 XFREE(MTYPE_NHLFE
, nhlfe
);
1301 nhlfe
->nexthop
= nexthop
;
1307 * Add primary or backup NHLFE. Base entry must have been created and
1308 * duplicate check done.
1310 static zebra_nhlfe_t
*nhlfe_add(zebra_lsp_t
*lsp
, enum lsp_types_t lsp_type
,
1311 enum nexthop_types_t gtype
,
1312 const union g_addr
*gate
, ifindex_t ifindex
,
1313 uint8_t num_labels
, const mpls_label_t
*labels
,
1316 zebra_nhlfe_t
*nhlfe
;
1321 /* Allocate new object */
1322 nhlfe
= nhlfe_alloc(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
1325 /* Enqueue to LSP: primaries at head of list, backups at tail */
1327 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
);
1328 nhlfe_list_add_tail(&lsp
->backup_nhlfe_list
, nhlfe
);
1330 nhlfe_list_add_head(&lsp
->nhlfe_list
, nhlfe
);
1336 * Common delete for NHLFEs.
1338 static void nhlfe_free(zebra_nhlfe_t
*nhlfe
)
1345 nexthop_free(nhlfe
->nexthop
);
1347 nhlfe
->nexthop
= NULL
;
1349 XFREE(MTYPE_NHLFE
, nhlfe
);
1354 * Disconnect NHLFE from LSP, and free. Entry must be present on LSP's list.
1356 static int nhlfe_del(zebra_nhlfe_t
*nhlfe
)
1367 if (nhlfe
== lsp
->best_nhlfe
)
1368 lsp
->best_nhlfe
= NULL
;
1370 /* Unlink from LSP */
1371 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
))
1372 nhlfe_list_del(&lsp
->backup_nhlfe_list
, nhlfe
);
1374 nhlfe_list_del(&lsp
->nhlfe_list
, nhlfe
);
1384 * Update label for NHLFE entry.
1386 static void nhlfe_out_label_update(zebra_nhlfe_t
*nhlfe
,
1387 struct mpls_label_stack
*nh_label
)
1389 nhlfe
->nexthop
->nh_label
->label
[0] = nh_label
->label
[0];
1392 static int mpls_lsp_uninstall_all(struct hash
*lsp_table
, zebra_lsp_t
*lsp
,
1393 enum lsp_types_t type
)
1395 zebra_nhlfe_t
*nhlfe
;
1396 int schedule_lsp
= 0;
1399 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
1402 /* Mark NHLFEs for delete or directly delete, as appropriate. */
1403 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1404 /* Skip non-static NHLFEs */
1405 if (nhlfe
->type
!= type
)
1408 if (IS_ZEBRA_DEBUG_MPLS
) {
1409 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
1411 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
1412 lsp
->ile
.in_label
, type
, buf
, nhlfe
->flags
);
1415 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
)) {
1416 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
1417 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
1424 frr_each_safe(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1425 /* Skip non-static NHLFEs */
1426 if (nhlfe
->type
!= type
)
1429 if (IS_ZEBRA_DEBUG_MPLS
) {
1430 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
1432 "Del backup LSP in-label %u type %d nexthop %s flags 0x%x",
1433 lsp
->ile
.in_label
, type
, buf
, nhlfe
->flags
);
1436 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
)) {
1437 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
1438 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
1445 /* Queue LSP for processing, if needed, else delete. */
1447 if (IS_ZEBRA_DEBUG_MPLS
) {
1448 zlog_debug("Schedule LSP in-label %u flags 0x%x",
1449 lsp
->ile
.in_label
, lsp
->flags
);
1451 if (lsp_processq_add(lsp
))
1454 lsp_check_free(lsp_table
, &lsp
);
1461 * Uninstall all static NHLFEs for a particular LSP forwarding entry.
1462 * If no other NHLFEs exist, the entry would be deleted.
1464 static int mpls_static_lsp_uninstall_all(struct zebra_vrf
*zvrf
,
1465 mpls_label_t in_label
)
1467 struct hash
*lsp_table
;
1468 zebra_ile_t tmp_ile
;
1472 lsp_table
= zvrf
->lsp_table
;
1476 /* If entry is not present, exit. */
1477 tmp_ile
.in_label
= in_label
;
1478 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
1479 if (!lsp
|| (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
))
1482 return mpls_lsp_uninstall_all(lsp_table
, lsp
, ZEBRA_LSP_STATIC
);
1485 static json_object
*nhlfe_json(zebra_nhlfe_t
*nhlfe
)
1488 json_object
*json_nhlfe
= NULL
;
1489 json_object
*json_backups
= NULL
;
1490 json_object
*json_label_stack
;
1491 struct nexthop
*nexthop
= nhlfe
->nexthop
;
1494 json_nhlfe
= json_object_new_object();
1495 json_object_string_add(json_nhlfe
, "type", nhlfe_type2str(nhlfe
->type
));
1496 json_object_int_add(json_nhlfe
, "outLabel",
1497 nexthop
->nh_label
->label
[0]);
1499 json_label_stack
= json_object_new_array();
1500 json_object_object_add(json_nhlfe
, "outLabelStack", json_label_stack
);
1501 for (i
= 0; i
< nexthop
->nh_label
->num_labels
; i
++)
1502 json_object_array_add(
1504 json_object_new_int(nexthop
->nh_label
->label
[i
]));
1506 json_object_int_add(json_nhlfe
, "distance", nhlfe
->distance
);
1508 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
))
1509 json_object_boolean_true_add(json_nhlfe
, "installed");
1511 switch (nexthop
->type
) {
1512 case NEXTHOP_TYPE_IPV4
:
1513 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1514 json_object_string_add(json_nhlfe
, "nexthop",
1515 inet_ntop(AF_INET
, &nexthop
->gate
.ipv4
,
1518 case NEXTHOP_TYPE_IPV6
:
1519 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1520 json_object_string_add(
1521 json_nhlfe
, "nexthop",
1522 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
, BUFSIZ
));
1524 if (nexthop
->ifindex
)
1525 json_object_string_add(json_nhlfe
, "interface",
1526 ifindex2ifname(nexthop
->ifindex
,
1533 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
)) {
1534 json_backups
= json_object_new_array();
1535 for (i
= 0; i
< nexthop
->backup_num
; i
++) {
1536 json_object_array_add(
1538 json_object_new_int(nexthop
->backup_idx
[i
]));
1541 json_object_object_add(json_nhlfe
, "backupIndex",
1549 * Print the NHLFE for a LSP forwarding entry.
1551 static void nhlfe_print(zebra_nhlfe_t
*nhlfe
, struct vty
*vty
,
1554 struct nexthop
*nexthop
;
1555 char buf
[MPLS_LABEL_STRLEN
];
1557 nexthop
= nhlfe
->nexthop
;
1558 if (!nexthop
|| !nexthop
->nh_label
) // unexpected
1561 vty_out(vty
, " type: %s remote label: %s distance: %d\n",
1562 nhlfe_type2str(nhlfe
->type
),
1563 mpls_label2str(nexthop
->nh_label
->num_labels
,
1564 nexthop
->nh_label
->label
,
1565 buf
, sizeof(buf
), 0),
1569 vty_out(vty
, "%s", indent
);
1571 switch (nexthop
->type
) {
1572 case NEXTHOP_TYPE_IPV4
:
1573 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1574 vty_out(vty
, " via %pI4", &nexthop
->gate
.ipv4
);
1575 if (nexthop
->ifindex
)
1576 vty_out(vty
, " dev %s",
1577 ifindex2ifname(nexthop
->ifindex
,
1580 case NEXTHOP_TYPE_IPV6
:
1581 case NEXTHOP_TYPE_IPV6_IFINDEX
:
1582 vty_out(vty
, " via %s",
1583 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
, buf
,
1585 if (nexthop
->ifindex
)
1586 vty_out(vty
, " dev %s",
1587 ifindex2ifname(nexthop
->ifindex
,
1594 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_IS_BACKUP
) ? " (backup)"
1597 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
) ? " (installed)"
1603 * Print an LSP forwarding entry.
1605 static void lsp_print(struct vty
*vty
, zebra_lsp_t
*lsp
)
1607 zebra_nhlfe_t
*nhlfe
, *backup
;
1610 vty_out(vty
, "Local label: %u%s\n", lsp
->ile
.in_label
,
1611 CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) ? " (installed)"
1614 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1615 nhlfe_print(nhlfe
, vty
, NULL
);
1617 if (nhlfe
->nexthop
== NULL
||
1618 !CHECK_FLAG(nhlfe
->nexthop
->flags
,
1619 NEXTHOP_FLAG_HAS_BACKUP
))
1622 /* Backup nhlfes: find backups in backup list */
1624 for (j
= 0; j
< nhlfe
->nexthop
->backup_num
; j
++) {
1627 frr_each(nhlfe_list
, &lsp
->backup_nhlfe_list
, backup
) {
1628 if (i
== nhlfe
->nexthop
->backup_idx
[j
])
1634 vty_out(vty
, " [backup %d]", i
);
1635 nhlfe_print(backup
, vty
, " ");
1642 * JSON objects for an LSP forwarding entry.
1644 static json_object
*lsp_json(zebra_lsp_t
*lsp
)
1646 zebra_nhlfe_t
*nhlfe
= NULL
;
1647 json_object
*json
= json_object_new_object();
1648 json_object
*json_nhlfe_list
= json_object_new_array();
1650 json_object_int_add(json
, "inLabel", lsp
->ile
.in_label
);
1652 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
))
1653 json_object_boolean_true_add(json
, "installed");
1655 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
)
1656 json_object_array_add(json_nhlfe_list
, nhlfe_json(nhlfe
));
1658 json_object_object_add(json
, "nexthops", json_nhlfe_list
);
1659 json_nhlfe_list
= NULL
;
1662 frr_each(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
1663 if (json_nhlfe_list
== NULL
)
1664 json_nhlfe_list
= json_object_new_array();
1666 json_object_array_add(json_nhlfe_list
, nhlfe_json(nhlfe
));
1669 if (json_nhlfe_list
)
1670 json_object_object_add(json
, "backupNexthops", json_nhlfe_list
);
1676 /* Return a sorted linked list of the hash contents */
1677 static struct list
*hash_get_sorted_list(struct hash
*hash
, void *cmp
)
1680 struct hash_bucket
*hb
;
1681 struct list
*sorted_list
= list_new();
1683 sorted_list
->cmp
= (int (*)(void *, void *))cmp
;
1685 for (i
= 0; i
< hash
->size
; i
++)
1686 for (hb
= hash
->index
[i
]; hb
; hb
= hb
->next
)
1687 listnode_add_sort(sorted_list
, hb
->data
);
1693 * Compare two LSPs based on their label values.
1695 static int lsp_cmp(const zebra_lsp_t
*lsp1
, const zebra_lsp_t
*lsp2
)
1697 if (lsp1
->ile
.in_label
< lsp2
->ile
.in_label
)
1700 if (lsp1
->ile
.in_label
> lsp2
->ile
.in_label
)
1707 * Initialize work queue for processing changed LSPs.
1709 static int mpls_processq_init(void)
1711 zrouter
.lsp_process_q
= work_queue_new(zrouter
.master
, "LSP processing");
1712 if (!zrouter
.lsp_process_q
) {
1713 flog_err(EC_ZEBRA_WQ_NONEXISTENT
,
1714 "%s: could not initialise work queue!", __func__
);
1718 zrouter
.lsp_process_q
->spec
.workfunc
= &lsp_process
;
1719 zrouter
.lsp_process_q
->spec
.del_item_data
= &lsp_processq_del
;
1720 zrouter
.lsp_process_q
->spec
.errorfunc
= NULL
;
1721 zrouter
.lsp_process_q
->spec
.completion_func
= &lsp_processq_complete
;
1722 zrouter
.lsp_process_q
->spec
.max_retries
= 0;
1723 zrouter
.lsp_process_q
->spec
.hold
= 10;
1730 * Process LSP update results from zebra dataplane.
1732 void zebra_mpls_lsp_dplane_result(struct zebra_dplane_ctx
*ctx
)
1734 struct zebra_vrf
*zvrf
;
1736 zebra_ile_t tmp_ile
;
1737 struct hash
*lsp_table
;
1739 zebra_nhlfe_t
*nhlfe
;
1740 struct nexthop
*nexthop
;
1741 enum dplane_op_e op
;
1742 enum zebra_dplane_result status
;
1743 enum zebra_sr_policy_update_label_mode update_mode
;
1745 op
= dplane_ctx_get_op(ctx
);
1746 status
= dplane_ctx_get_status(ctx
);
1748 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
1749 zlog_debug("LSP dplane ctx %p, op %s, in-label %u, result %s",
1750 ctx
, dplane_op2str(op
),
1751 dplane_ctx_get_in_label(ctx
),
1752 dplane_res2str(status
));
1754 label
= dplane_ctx_get_in_label(ctx
);
1757 case DPLANE_OP_LSP_INSTALL
:
1758 case DPLANE_OP_LSP_UPDATE
:
1759 /* Look for zebra LSP object */
1760 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
1764 lsp_table
= zvrf
->lsp_table
;
1766 tmp_ile
.in_label
= label
;
1767 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
1769 if (IS_ZEBRA_DEBUG_DPLANE
)
1770 zlog_debug("LSP ctx %p: in-label %u not found",
1771 ctx
, dplane_ctx_get_in_label(ctx
));
1775 /* TODO -- Confirm that this result is still 'current' */
1777 if (status
!= ZEBRA_DPLANE_REQUEST_SUCCESS
) {
1778 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
1779 clear_nhlfe_installed(lsp
);
1780 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE
,
1781 "LSP Install Failure: in-label %u",
1786 /* Update zebra object */
1787 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
1788 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
1789 nexthop
= nhlfe
->nexthop
;
1793 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
) &&
1794 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
)) {
1795 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
1796 SET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
1800 update_mode
= (op
== DPLANE_OP_LSP_INSTALL
)
1801 ? ZEBRA_SR_POLICY_LABEL_CREATED
1802 : ZEBRA_SR_POLICY_LABEL_UPDATED
;
1803 zebra_sr_policy_label_update(label
, update_mode
);
1806 case DPLANE_OP_LSP_DELETE
:
1807 if (status
!= ZEBRA_DPLANE_REQUEST_SUCCESS
) {
1808 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE
,
1809 "LSP Deletion Failure: in-label %u",
1810 dplane_ctx_get_in_label(ctx
));
1813 zebra_sr_policy_label_update(label
,
1814 ZEBRA_SR_POLICY_LABEL_REMOVED
);
1822 dplane_ctx_fini(&ctx
);
1826 * Process LSP installation info from two sets of nhlfes: a set from
1827 * a dplane notification, and a set from the zebra LSP object. Update
1828 * counters of installed nexthops, and return whether the LSP has changed.
1830 static bool compare_notif_nhlfes(const struct nhlfe_list_head
*ctx_head
,
1831 struct nhlfe_list_head
*nhlfe_head
,
1832 int *start_counter
, int *end_counter
)
1834 zebra_nhlfe_t
*nhlfe
;
1835 const zebra_nhlfe_t
*ctx_nhlfe
;
1836 struct nexthop
*nexthop
;
1837 const struct nexthop
*ctx_nexthop
;
1838 int start_count
= 0, end_count
= 0;
1839 bool changed_p
= false;
1840 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
1842 frr_each_safe(nhlfe_list
, nhlfe_head
, nhlfe
) {
1843 char buf
[NEXTHOP_STRLEN
];
1845 nexthop
= nhlfe
->nexthop
;
1849 if (CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
))
1854 frr_each(nhlfe_list_const
, ctx_head
, ctx_nhlfe
) {
1855 ctx_nexthop
= ctx_nhlfe
->nexthop
;
1859 if ((ctx_nexthop
->type
== nexthop
->type
) &&
1860 nexthop_same(ctx_nexthop
, nexthop
)) {
1867 nexthop2str(nexthop
, buf
, sizeof(buf
));
1869 if (ctx_nhlfe
&& ctx_nexthop
) {
1871 const char *tstr
= "";
1873 if (!CHECK_FLAG(ctx_nhlfe
->flags
,
1874 NHLFE_FLAG_INSTALLED
))
1877 zlog_debug("LSP dplane notif: matched nh %s (%sinstalled)",
1881 /* Test zebra nhlfe install state */
1882 if (CHECK_FLAG(ctx_nhlfe
->flags
,
1883 NHLFE_FLAG_INSTALLED
)) {
1885 if (!CHECK_FLAG(nhlfe
->flags
,
1886 NHLFE_FLAG_INSTALLED
))
1889 /* Update counter */
1893 if (CHECK_FLAG(nhlfe
->flags
,
1894 NHLFE_FLAG_INSTALLED
))
1899 /* Not mentioned in lfib set -> uninstalled */
1900 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
) ||
1901 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
) ||
1902 CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
)) {
1907 zlog_debug("LSP dplane notif: no match, nh %s",
1913 *start_counter
+= start_count
;
1915 *end_counter
+= end_count
;
1921 * Update an lsp nhlfe list from a dplane context, typically an async
1922 * notification context. Update the LSP list to match the installed
1923 * status from the context's list.
1925 static int update_nhlfes_from_ctx(struct nhlfe_list_head
*nhlfe_head
,
1926 const struct nhlfe_list_head
*ctx_head
)
1929 zebra_nhlfe_t
*nhlfe
;
1930 const zebra_nhlfe_t
*ctx_nhlfe
;
1931 struct nexthop
*nexthop
;
1932 const struct nexthop
*ctx_nexthop
;
1933 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
1935 frr_each_safe(nhlfe_list
, nhlfe_head
, nhlfe
) {
1936 char buf
[NEXTHOP_STRLEN
];
1938 nexthop
= nhlfe
->nexthop
;
1944 frr_each(nhlfe_list_const
, ctx_head
, ctx_nhlfe
) {
1945 ctx_nexthop
= ctx_nhlfe
->nexthop
;
1949 if ((ctx_nexthop
->type
== nexthop
->type
) &&
1950 nexthop_same(ctx_nexthop
, nexthop
)) {
1957 nexthop2str(nexthop
, buf
, sizeof(buf
));
1959 if (ctx_nhlfe
&& ctx_nexthop
) {
1961 /* Bring zebra nhlfe install state into sync */
1962 if (CHECK_FLAG(ctx_nhlfe
->flags
,
1963 NHLFE_FLAG_INSTALLED
)) {
1965 zlog_debug("%s: matched lsp nhlfe %s (installed)",
1968 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
1969 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
1973 zlog_debug("%s: matched lsp nhlfe %s (not installed)",
1976 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
1977 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
1980 if (CHECK_FLAG(ctx_nhlfe
->nexthop
->flags
,
1981 NEXTHOP_FLAG_FIB
)) {
1982 SET_FLAG(nhlfe
->nexthop
->flags
,
1983 NEXTHOP_FLAG_ACTIVE
);
1984 SET_FLAG(nhlfe
->nexthop
->flags
,
1987 UNSET_FLAG(nhlfe
->nexthop
->flags
,
1988 NEXTHOP_FLAG_ACTIVE
);
1989 UNSET_FLAG(nhlfe
->nexthop
->flags
,
1994 /* Not mentioned in lfib set -> uninstalled */
1996 zlog_debug("%s: no match for lsp nhlfe %s",
1998 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
);
1999 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_SELECTED
);
2000 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
2001 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_ACTIVE
);
2009 * Process async dplane notifications.
2011 void zebra_mpls_process_dplane_notify(struct zebra_dplane_ctx
*ctx
)
2013 struct zebra_vrf
*zvrf
;
2014 zebra_ile_t tmp_ile
;
2015 struct hash
*lsp_table
;
2017 const struct nhlfe_list_head
*ctx_list
;
2018 int start_count
= 0, end_count
= 0; /* Installed counts */
2019 bool changed_p
= false;
2020 bool is_debug
= (IS_ZEBRA_DEBUG_DPLANE
| IS_ZEBRA_DEBUG_MPLS
);
2021 enum zebra_sr_policy_update_label_mode update_mode
;
2024 zlog_debug("LSP dplane notif, in-label %u",
2025 dplane_ctx_get_in_label(ctx
));
2027 /* Look for zebra LSP object */
2028 zvrf
= vrf_info_lookup(VRF_DEFAULT
);
2032 lsp_table
= zvrf
->lsp_table
;
2034 tmp_ile
.in_label
= dplane_ctx_get_in_label(ctx
);
2035 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
2038 zlog_debug("dplane LSP notif: in-label %u not found",
2039 dplane_ctx_get_in_label(ctx
));
2044 * The dataplane/forwarding plane is notifying zebra about the state
2045 * of the nexthops associated with this LSP. First, we take a
2046 * pre-scan pass to determine whether the LSP has transitioned
2047 * from installed -> uninstalled. In that case, we need to have
2048 * the existing state of the LSP objects available before making
2051 ctx_list
= dplane_ctx_get_nhlfe_list(ctx
);
2053 changed_p
= compare_notif_nhlfes(ctx_list
, &lsp
->nhlfe_list
,
2054 &start_count
, &end_count
);
2057 zlog_debug("LSP dplane notif: lfib start_count %d, end_count %d%s",
2058 start_count
, end_count
,
2059 changed_p
? ", changed" : "");
2061 ctx_list
= dplane_ctx_get_backup_nhlfe_list(ctx
);
2063 if (compare_notif_nhlfes(ctx_list
, &lsp
->backup_nhlfe_list
,
2064 &start_count
, &end_count
))
2065 /* Avoid accidentally setting back to 'false' */
2069 zlog_debug("LSP dplane notif: lfib backups, start_count %d, end_count %d%s",
2070 start_count
, end_count
,
2071 changed_p
? ", changed" : "");
2074 * Has the LSP become uninstalled? We need the existing state of the
2075 * nexthops/nhlfes at this point so we know what to delete.
2077 if (start_count
> 0 && end_count
== 0) {
2078 /* Inform other lfibs */
2079 dplane_lsp_notif_update(lsp
, DPLANE_OP_LSP_DELETE
, ctx
);
2083 * Now we take a second pass and bring the zebra
2084 * nexthop state into sync with the forwarding-plane state.
2086 ctx_list
= dplane_ctx_get_nhlfe_list(ctx
);
2087 update_nhlfes_from_ctx(&lsp
->nhlfe_list
, ctx_list
);
2089 ctx_list
= dplane_ctx_get_backup_nhlfe_list(ctx
);
2090 update_nhlfes_from_ctx(&lsp
->backup_nhlfe_list
, ctx_list
);
2092 if (end_count
> 0) {
2093 SET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
2095 /* SR-TE update too */
2096 if (start_count
== 0)
2097 update_mode
= ZEBRA_SR_POLICY_LABEL_CREATED
;
2099 update_mode
= ZEBRA_SR_POLICY_LABEL_UPDATED
;
2100 zebra_sr_policy_label_update(lsp
->ile
.in_label
, update_mode
);
2103 dplane_lsp_notif_update(lsp
, DPLANE_OP_LSP_UPDATE
, ctx
);
2106 /* SR-TE update too */
2107 zebra_sr_policy_label_update(lsp
->ile
.in_label
,
2108 ZEBRA_SR_POLICY_LABEL_REMOVED
);
2110 UNSET_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
);
2111 clear_nhlfe_installed(lsp
);
2115 dplane_ctx_fini(&ctx
);
2119 * Install dynamic LSP entry.
2121 int zebra_mpls_lsp_install(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
2122 struct route_entry
*re
)
2124 struct route_table
*table
;
2127 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(&rn
->p
))];
2131 /* See if there is a configured label binding for this FEC. */
2132 fec
= fec_find(table
, &rn
->p
);
2133 if (!fec
|| fec
->label
== MPLS_INVALID_LABEL
)
2136 /* We cannot install a label forwarding entry if local label is the
2137 * implicit-null label.
2139 if (fec
->label
== MPLS_LABEL_IMPLICIT_NULL
)
2142 if (lsp_install(zvrf
, fec
->label
, rn
, re
))
2149 * Uninstall dynamic LSP entry, if any.
2151 int zebra_mpls_lsp_uninstall(struct zebra_vrf
*zvrf
, struct route_node
*rn
,
2152 struct route_entry
*re
)
2154 struct route_table
*table
;
2157 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(&rn
->p
))];
2161 /* See if there is a configured label binding for this FEC. */
2162 fec
= fec_find(table
, &rn
->p
);
2163 if (!fec
|| fec
->label
== MPLS_INVALID_LABEL
)
2166 /* Uninstall always removes all dynamic NHLFEs. */
2167 return lsp_uninstall(zvrf
, fec
->label
);
2171 * Add an NHLFE to an LSP, return the newly-added object. This path only changes
2172 * the LSP object - nothing is scheduled for processing, for example.
2174 zebra_nhlfe_t
*zebra_mpls_lsp_add_nhlfe(zebra_lsp_t
*lsp
,
2175 enum lsp_types_t lsp_type
,
2176 enum nexthop_types_t gtype
,
2177 const union g_addr
*gate
,
2180 const mpls_label_t
*out_labels
)
2182 /* Just a public pass-through to the internal implementation */
2183 return nhlfe_add(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
2184 out_labels
, false /*backup*/);
2188 * Add a backup NHLFE to an LSP, return the newly-added object.
2189 * This path only changes the LSP object - nothing is scheduled for
2190 * processing, for example.
2192 zebra_nhlfe_t
*zebra_mpls_lsp_add_backup_nhlfe(zebra_lsp_t
*lsp
,
2193 enum lsp_types_t lsp_type
,
2194 enum nexthop_types_t gtype
,
2195 const union g_addr
*gate
,
2198 const mpls_label_t
*out_labels
)
2200 /* Just a public pass-through to the internal implementation */
2201 return nhlfe_add(lsp
, lsp_type
, gtype
, gate
, ifindex
, num_labels
,
2206 * Add an NHLFE to an LSP based on a nexthop; return the newly-added object
2208 zebra_nhlfe_t
*zebra_mpls_lsp_add_nh(zebra_lsp_t
*lsp
,
2209 enum lsp_types_t lsp_type
,
2210 const struct nexthop
*nh
)
2212 zebra_nhlfe_t
*nhlfe
;
2214 if (nh
->nh_label
== NULL
|| nh
->nh_label
->num_labels
== 0)
2217 nhlfe
= nhlfe_add(lsp
, lsp_type
, nh
->type
, &nh
->gate
, nh
->ifindex
,
2218 nh
->nh_label
->num_labels
, nh
->nh_label
->label
,
2225 * Add a backup NHLFE to an LSP based on a nexthop;
2226 * return the newly-added object.
2228 zebra_nhlfe_t
*zebra_mpls_lsp_add_backup_nh(zebra_lsp_t
*lsp
,
2229 enum lsp_types_t lsp_type
,
2230 const struct nexthop
*nh
)
2232 zebra_nhlfe_t
*nhlfe
;
2234 if (nh
->nh_label
== NULL
|| nh
->nh_label
->num_labels
== 0)
2237 nhlfe
= nhlfe_add(lsp
, lsp_type
, nh
->type
, &nh
->gate
,
2238 nh
->ifindex
, nh
->nh_label
->num_labels
,
2239 nh
->nh_label
->label
, true);
2245 * Free an allocated NHLFE
2247 void zebra_mpls_nhlfe_free(zebra_nhlfe_t
*nhlfe
)
2249 /* Just a pass-through to the internal implementation */
2254 * Registration from a client for the label binding for a FEC. If a binding
2255 * already exists, it is informed to the client.
2256 * NOTE: If there is a manually configured label binding, that is used.
2257 * Otherwise, if a label index is specified, it means we have to allocate the
2258 * label from a locally configured label block (SRGB), if one exists and index
2259 * is acceptable. If no label index then just register the specified label.
2260 * NOTE2: Either label or label_index is expected to be set to MPLS_INVALID_*
2261 * by the calling function. Register requests with both will be rejected.
2263 int zebra_mpls_fec_register(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2264 uint32_t label
, uint32_t label_index
,
2265 struct zserv
*client
)
2267 struct route_table
*table
;
2270 bool label_change
= false;
2272 bool have_label_index
= (label_index
!= MPLS_INVALID_LABEL_INDEX
);
2273 bool is_configured_fec
= false; /* indicate statically configured FEC */
2275 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2279 if (label
!= MPLS_INVALID_LABEL
&& have_label_index
) {
2281 EC_ZEBRA_FEC_LABEL_INDEX_LABEL_CONFLICT
,
2282 "Rejecting FEC register for %pFX with both label %u and Label Index %u specified, client %s",
2283 p
, label
, label_index
,
2284 zebra_route_string(client
->proto
));
2289 fec
= fec_find(table
, p
);
2291 fec
= fec_add(table
, p
, label
, 0, label_index
);
2294 EC_ZEBRA_FEC_ADD_FAILED
,
2295 "Failed to add FEC %pFX upon register, client %s",
2296 p
, zebra_route_string(client
->proto
));
2300 old_label
= MPLS_INVALID_LABEL
;
2303 /* Check if the FEC has been statically defined in the config */
2304 is_configured_fec
= fec
->flags
& FEC_FLAG_CONFIGURED
;
2305 /* Client may register same FEC with different label index. */
2307 (listnode_lookup(fec
->client_list
, client
) == NULL
);
2308 if (!new_client
&& fec
->label_index
== label_index
2309 && fec
->label
== label
)
2310 /* Duplicate register */
2313 /* Save current label, update the FEC */
2314 old_label
= fec
->label
;
2315 fec
->label_index
= label_index
;
2319 listnode_add(fec
->client_list
, client
);
2321 if (IS_ZEBRA_DEBUG_MPLS
)
2322 zlog_debug("FEC %pFX label%s %u %s by client %s%s", p
,
2323 have_label_index
? " index" : "",
2324 have_label_index
? label_index
: label
,
2325 new_client
? "registered" : "updated",
2326 zebra_route_string(client
->proto
),
2328 ? ", but using statically configured label"
2331 /* If not a statically configured FEC, derive the local label
2332 * from label index or use the provided label
2334 if (!is_configured_fec
) {
2335 if (have_label_index
)
2336 fec_derive_label_from_index(zvrf
, fec
);
2340 /* If no label change, exit. */
2341 if (fec
->label
== old_label
)
2344 label_change
= true;
2347 /* If new client or label change, update client and install or uninstall
2348 * label forwarding entry as needed.
2350 /* Inform client of label, if needed. */
2351 if ((new_client
&& fec
->label
!= MPLS_INVALID_LABEL
) || label_change
) {
2352 if (IS_ZEBRA_DEBUG_MPLS
)
2353 zlog_debug("Update client label %u", fec
->label
);
2354 fec_send(fec
, client
);
2357 if (new_client
|| label_change
)
2358 return fec_change_update_lsp(zvrf
, fec
, old_label
);
2364 * Deregistration from a client for the label binding for a FEC. The FEC
2365 * itself is deleted if no other registered clients exist and there is no
2366 * label bound to the FEC.
2368 int zebra_mpls_fec_unregister(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2369 struct zserv
*client
)
2371 struct route_table
*table
;
2374 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2378 fec
= fec_find(table
, p
);
2380 flog_err(EC_ZEBRA_FEC_RM_FAILED
,
2381 "Failed to find FEC %pFX upon unregister, client %s",
2382 p
, zebra_route_string(client
->proto
));
2386 listnode_delete(fec
->client_list
, client
);
2388 if (IS_ZEBRA_DEBUG_MPLS
)
2389 zlog_debug("FEC %pFX unregistered by client %s", p
,
2390 zebra_route_string(client
->proto
));
2392 /* If not a configured entry, delete the FEC if no other clients. Before
2393 * deleting, see if any LSP needs to be uninstalled.
2395 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
)
2396 && list_isempty(fec
->client_list
)) {
2397 mpls_label_t old_label
= fec
->label
;
2398 fec
->label
= MPLS_INVALID_LABEL
; /* reset */
2399 fec_change_update_lsp(zvrf
, fec
, old_label
);
2407 * Cleanup any FECs registered by this client.
2409 static int zebra_mpls_cleanup_fecs_for_client(struct zserv
*client
)
2411 struct zebra_vrf
*zvrf
= vrf_info_lookup(VRF_DEFAULT
);
2412 struct route_node
*rn
;
2414 struct listnode
*node
;
2415 struct zserv
*fec_client
;
2418 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2419 if (zvrf
->fec_table
[af
] == NULL
)
2422 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2423 rn
= route_next(rn
)) {
2425 if (!fec
|| list_isempty(fec
->client_list
))
2428 for (ALL_LIST_ELEMENTS_RO(fec
->client_list
, node
,
2430 if (fec_client
== client
) {
2431 listnode_delete(fec
->client_list
,
2433 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
)
2434 && list_isempty(fec
->client_list
))
2445 struct lsp_uninstall_args
{
2446 struct hash
*lsp_table
;
2447 enum lsp_types_t type
;
2451 * Cleanup MPLS labels registered by this client.
2453 static int zebra_mpls_cleanup_zclient_labels(struct zserv
*client
)
2456 struct zebra_vrf
*zvrf
;
2458 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
2459 struct lsp_uninstall_args args
;
2466 args
.lsp_table
= zvrf
->lsp_table
;
2467 args
.type
= lsp_type_from_re_type(client
->proto
);
2468 hash_iterate(zvrf
->lsp_table
, mpls_lsp_uninstall_all_type
,
2472 mpls_ftn_uninstall_all(zvrf
, AFI_IP
,
2473 lsp_type_from_re_type(client
->proto
));
2474 mpls_ftn_uninstall_all(zvrf
, AFI_IP6
,
2475 lsp_type_from_re_type(client
->proto
));
2482 * Return FEC (if any) to which this label is bound.
2483 * Note: Only works for per-prefix binding and when the label is not
2485 * TODO: Currently walks entire table, can optimize later with another
2488 zebra_fec_t
*zebra_mpls_fec_for_label(struct zebra_vrf
*zvrf
,
2491 struct route_node
*rn
;
2495 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2496 if (zvrf
->fec_table
[af
] == NULL
)
2499 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2500 rn
= route_next(rn
)) {
2504 if (fec
->label
== label
)
2513 * Inform if specified label is currently bound to a FEC or not.
2515 int zebra_mpls_label_already_bound(struct zebra_vrf
*zvrf
, mpls_label_t label
)
2517 return (zebra_mpls_fec_for_label(zvrf
, label
) ? 1 : 0);
2521 * Add static FEC to label binding. If there are clients registered for this
2522 * FEC, notify them. If there are labeled routes for this FEC, install the
2523 * label forwarding entry.
2525 int zebra_mpls_static_fec_add(struct zebra_vrf
*zvrf
, struct prefix
*p
,
2526 mpls_label_t in_label
)
2528 struct route_table
*table
;
2530 mpls_label_t old_label
;
2533 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2537 /* Update existing FEC or create a new one. */
2538 fec
= fec_find(table
, p
);
2540 fec
= fec_add(table
, p
, in_label
, FEC_FLAG_CONFIGURED
,
2541 MPLS_INVALID_LABEL_INDEX
);
2543 flog_err(EC_ZEBRA_FEC_ADD_FAILED
,
2544 "Failed to add FEC %pFX upon config", p
);
2548 if (IS_ZEBRA_DEBUG_MPLS
)
2549 zlog_debug("Add fec %pFX label %u", p
, in_label
);
2551 fec
->flags
|= FEC_FLAG_CONFIGURED
;
2552 if (fec
->label
== in_label
)
2553 /* Duplicate config */
2556 /* Label change, update clients. */
2557 old_label
= fec
->label
;
2558 if (IS_ZEBRA_DEBUG_MPLS
)
2559 zlog_debug("Update fec %pFX new label %u", p
, in_label
);
2561 fec
->label
= in_label
;
2562 fec_update_clients(fec
);
2564 /* Update label forwarding entries appropriately */
2565 ret
= fec_change_update_lsp(zvrf
, fec
, old_label
);
2572 * Remove static FEC to label binding. If there are no clients registered
2573 * for this FEC, delete the FEC; else notify clients
2574 * Note: Upon delete of static binding, if label index exists for this FEC,
2575 * client may need to be updated with derived label.
2577 int zebra_mpls_static_fec_del(struct zebra_vrf
*zvrf
, struct prefix
*p
)
2579 struct route_table
*table
;
2581 mpls_label_t old_label
;
2583 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2587 fec
= fec_find(table
, p
);
2589 flog_err(EC_ZEBRA_FEC_RM_FAILED
,
2590 "Failed to find FEC %pFX upon delete", p
);
2594 if (IS_ZEBRA_DEBUG_MPLS
) {
2595 zlog_debug("Delete fec %pFX label %u label index %u", p
,
2596 fec
->label
, fec
->label_index
);
2599 old_label
= fec
->label
;
2600 fec
->flags
&= ~FEC_FLAG_CONFIGURED
;
2601 fec
->label
= MPLS_INVALID_LABEL
;
2603 /* If no client exists, just delete the FEC. */
2604 if (list_isempty(fec
->client_list
)) {
2609 /* Derive the local label (from label index) or reset it. */
2610 fec_derive_label_from_index(zvrf
, fec
);
2612 /* If there is a label change, update clients. */
2613 if (fec
->label
== old_label
)
2615 fec_update_clients(fec
);
2617 /* Update label forwarding entries appropriately */
2618 return fec_change_update_lsp(zvrf
, fec
, old_label
);
2622 * Display MPLS FEC to label binding configuration (VTY command handler).
2624 int zebra_mpls_write_fec_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
2626 struct route_node
*rn
;
2631 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2632 if (zvrf
->fec_table
[af
] == NULL
)
2635 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2636 rn
= route_next(rn
)) {
2643 if (!(fec
->flags
& FEC_FLAG_CONFIGURED
))
2647 vty_out(vty
, "mpls label bind %pFX %s\n", &rn
->p
,
2648 label2str(fec
->label
, lstr
, BUFSIZ
));
2656 * Display MPLS FEC to label binding (VTY command handler).
2658 void zebra_mpls_print_fec_table(struct vty
*vty
, struct zebra_vrf
*zvrf
)
2660 struct route_node
*rn
;
2663 for (af
= AFI_IP
; af
< AFI_MAX
; af
++) {
2664 if (zvrf
->fec_table
[af
] == NULL
)
2667 for (rn
= route_top(zvrf
->fec_table
[af
]); rn
;
2668 rn
= route_next(rn
)) {
2671 fec_print(rn
->info
, vty
);
2677 * Display MPLS FEC to label binding for a specific FEC (VTY command handler).
2679 void zebra_mpls_print_fec(struct vty
*vty
, struct zebra_vrf
*zvrf
,
2682 struct route_table
*table
;
2683 struct route_node
*rn
;
2685 table
= zvrf
->fec_table
[family2afi(PREFIX_FAMILY(p
))];
2690 rn
= route_node_lookup(table
, p
);
2694 route_unlock_node(rn
);
2698 fec_print(rn
->info
, vty
);
2701 static void mpls_zebra_nhe_update(struct route_entry
*re
, afi_t afi
,
2702 struct nhg_hash_entry
*new_nhe
)
2704 struct nhg_hash_entry
*nhe
;
2706 nhe
= zebra_nhg_rib_find_nhe(new_nhe
, afi
);
2708 route_entry_update_nhe(re
, nhe
);
2711 static bool ftn_update_nexthop(bool add_p
, struct nexthop
*nexthop
,
2712 enum lsp_types_t type
,
2713 const struct zapi_nexthop
*znh
)
2715 if (add_p
&& nexthop
->nh_label_type
== ZEBRA_LSP_NONE
)
2716 nexthop_add_labels(nexthop
, type
, znh
->label_num
, znh
->labels
);
2717 else if (!add_p
&& nexthop
->nh_label_type
== type
)
2718 nexthop_del_labels(nexthop
);
2725 int mpls_ftn_uninstall(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
2726 struct prefix
*prefix
, uint8_t route_type
,
2727 unsigned short route_instance
)
2729 struct route_table
*table
;
2730 struct route_node
*rn
;
2731 struct route_entry
*re
;
2732 struct nexthop
*nexthop
;
2733 struct nhg_hash_entry
*new_nhe
;
2734 afi_t afi
= family2afi(prefix
->family
);
2737 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
2741 /* Lookup existing route */
2742 rn
= route_node_get(table
, prefix
);
2743 RNODE_FOREACH_RE (rn
, re
) {
2744 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
2746 if (re
->type
== route_type
&& re
->instance
== route_instance
)
2753 * Nexthops are now shared by multiple routes, so we have to make
2754 * a local copy, modify the copy, then update the route.
2756 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
2758 for (nexthop
= new_nhe
->nhg
.nexthop
; nexthop
; nexthop
= nexthop
->next
)
2759 nexthop_del_labels(nexthop
);
2761 /* Update backup routes/nexthops also, if present. */
2762 if (zebra_nhg_get_backup_nhg(new_nhe
) != NULL
) {
2763 for (nexthop
= new_nhe
->backup_info
->nhe
->nhg
.nexthop
; nexthop
;
2764 nexthop
= nexthop
->next
)
2765 nexthop_del_labels(nexthop
);
2768 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
2769 SET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
2771 /* This will create (or ref) a new nhe, so we will discard the local
2774 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
2776 zebra_nhg_free(new_nhe
);
2784 * Iterate through a list of nexthops, for a match for 'znh'. If found,
2785 * update its labels according to 'add_p', and return 'true' if successful.
2787 static bool ftn_update_znh(bool add_p
, enum lsp_types_t type
,
2788 struct nexthop
*head
, const struct zapi_nexthop
*znh
)
2790 bool found
= false, success
= false;
2791 struct nexthop
*nexthop
;
2793 for (nexthop
= head
; nexthop
; nexthop
= nexthop
->next
) {
2794 switch (nexthop
->type
) {
2795 case NEXTHOP_TYPE_IPV4
:
2796 case NEXTHOP_TYPE_IPV4_IFINDEX
:
2797 if (znh
->type
!= NEXTHOP_TYPE_IPV4
2798 && znh
->type
!= NEXTHOP_TYPE_IPV4_IFINDEX
)
2800 if (!IPV4_ADDR_SAME(&nexthop
->gate
.ipv4
,
2803 if (nexthop
->type
== NEXTHOP_TYPE_IPV4_IFINDEX
2804 && nexthop
->ifindex
!= znh
->ifindex
)
2809 if (!ftn_update_nexthop(add_p
, nexthop
, type
, znh
))
2814 case NEXTHOP_TYPE_IPV6
:
2815 case NEXTHOP_TYPE_IPV6_IFINDEX
:
2816 if (znh
->type
!= NEXTHOP_TYPE_IPV6
2817 && znh
->type
!= NEXTHOP_TYPE_IPV6_IFINDEX
)
2819 if (!IPV6_ADDR_SAME(&nexthop
->gate
.ipv6
,
2822 if (nexthop
->type
== NEXTHOP_TYPE_IPV6_IFINDEX
2823 && nexthop
->ifindex
!= znh
->ifindex
)
2828 if (!ftn_update_nexthop(add_p
, nexthop
, type
, znh
))
2844 * Install/uninstall LSP and (optionally) FEC-To-NHLFE (FTN) bindings,
2845 * using zapi message info.
2846 * There are several changes that need to be made, in several zebra
2847 * data structures, so we want to do all the work required at once.
2849 int mpls_zapi_labels_process(bool add_p
, struct zebra_vrf
*zvrf
,
2850 const struct zapi_labels
*zl
)
2852 int i
, counter
, ret
= 0;
2853 char buf
[NEXTHOP_STRLEN
];
2854 const struct zapi_nexthop
*znh
;
2855 struct route_table
*table
;
2856 struct route_node
*rn
= NULL
;
2857 struct route_entry
*re
= NULL
;
2858 struct nhg_hash_entry
*new_nhe
= NULL
;
2861 const struct prefix
*prefix
= NULL
;
2862 struct hash
*lsp_table
;
2863 zebra_ile_t tmp_ile
;
2864 zebra_lsp_t
*lsp
= NULL
;
2866 /* Prep LSP for add case */
2869 lsp_table
= zvrf
->lsp_table
;
2873 /* Find or create LSP object */
2874 tmp_ile
.in_label
= zl
->local_label
;
2875 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
2880 /* Prep for route/FEC update if requested */
2881 if (CHECK_FLAG(zl
->message
, ZAPI_LABELS_FTN
)) {
2882 prefix
= &zl
->route
.prefix
;
2884 afi
= family2afi(prefix
->family
);
2887 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
2889 /* Lookup existing route */
2890 rn
= route_node_get(table
, prefix
);
2891 RNODE_FOREACH_RE(rn
, re
) {
2892 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_REMOVED
))
2894 if (re
->type
== zl
->route
.type
&&
2895 re
->instance
== zl
->route
.instance
)
2902 * Copy over current nexthops into a temporary group.
2903 * We can't just change the values here since the nhgs
2904 * are shared and if the labels change, we'll need
2905 * to find or create a new nhg. We need to create
2906 * a whole temporary group, make changes to it,
2907 * then attach that to the route.
2909 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
2913 * The old version of the zapi code
2914 * attempted to manage LSPs before trying to
2915 * find a route/FEC, so we'll continue that way.
2917 if (IS_ZEBRA_DEBUG_RECV
|| IS_ZEBRA_DEBUG_MPLS
)
2919 "%s: FTN update requested: no route for prefix %pFX",
2925 * Use info from the zapi nexthops to add/replace/remove LSP/FECs
2929 for (i
= 0; i
< zl
->nexthop_num
; i
++) {
2931 znh
= &zl
->nexthops
[i
];
2933 /* Attempt LSP update */
2935 ret
= lsp_znh_install(lsp
, zl
->type
, znh
);
2937 ret
= mpls_lsp_uninstall(zvrf
, zl
->type
,
2938 zl
->local_label
, znh
->type
,
2939 &znh
->gate
, znh
->ifindex
,
2942 if (IS_ZEBRA_DEBUG_RECV
|| IS_ZEBRA_DEBUG_MPLS
) {
2943 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
2944 zlog_debug("%s: Unable to %sinstall LSP: label %u, znh %s",
2945 __func__
, (add_p
? "" : "un"),
2946 zl
->local_label
, buf
);
2951 /* Attempt route/FEC update if requested */
2955 /* Search the route's nexthops for a match, and update it. */
2956 found
= ftn_update_znh(add_p
, zl
->type
, new_nhe
->nhg
.nexthop
,
2960 } else if (IS_ZEBRA_DEBUG_RECV
| IS_ZEBRA_DEBUG_MPLS
) {
2961 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
2963 "%s: Unable to update FEC: prefix %pFX, label %u, znh %s",
2964 __func__
, prefix
, zl
->local_label
, buf
);
2969 * Process backup LSPs/nexthop entries also. We associate backup
2970 * LSP info with backup nexthops.
2972 if (!CHECK_FLAG(zl
->message
, ZAPI_LABELS_HAS_BACKUPS
))
2975 for (i
= 0; i
< zl
->backup_nexthop_num
; i
++) {
2977 znh
= &zl
->backup_nexthops
[i
];
2980 ret
= lsp_backup_znh_install(lsp
, zl
->type
, znh
);
2982 ret
= mpls_lsp_uninstall(zvrf
, zl
->type
,
2984 znh
->type
, &znh
->gate
,
2985 znh
->ifindex
, true);
2988 if (IS_ZEBRA_DEBUG_RECV
||
2989 IS_ZEBRA_DEBUG_MPLS
) {
2990 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
2991 zlog_debug("%s: Unable to %sinstall backup LSP: label %u, znh %s",
2992 __func__
, (add_p
? "" : "un"),
2993 zl
->local_label
, buf
);
2998 /* Attempt backup nexthop/FEC update if requested */
2999 if (re
== NULL
|| zebra_nhg_get_backup_nhg(new_nhe
) == NULL
)
3002 /* Search the route's backup nexthops for a match
3005 found
= ftn_update_znh(add_p
, zl
->type
,
3006 new_nhe
->backup_info
->nhe
->nhg
.nexthop
,
3010 } else if (IS_ZEBRA_DEBUG_RECV
| IS_ZEBRA_DEBUG_MPLS
) {
3011 zapi_nexthop2str(znh
, buf
, sizeof(buf
));
3013 "%s: Unable to update backup FEC: prefix %pFX, label %u, znh %s",
3014 __func__
, prefix
, zl
->local_label
, buf
);
3021 * If we made changes, update the route, and schedule it
3022 * for rib processing
3024 if (re
!= NULL
&& counter
> 0) {
3027 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
3028 SET_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
);
3030 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
3036 zebra_nhg_free(new_nhe
);
3042 * Install/update a NHLFE for an LSP in the forwarding table. This may be
3043 * a new LSP entry or a new NHLFE for an existing in-label or an update of
3044 * the out-label for an existing NHLFE (update case).
3046 static zebra_nhlfe_t
*
3047 lsp_add_nhlfe(zebra_lsp_t
*lsp
, enum lsp_types_t type
,
3048 uint8_t num_out_labels
, const mpls_label_t
*out_labels
,
3049 enum nexthop_types_t gtype
, const union g_addr
*gate
,
3050 ifindex_t ifindex
, bool is_backup
)
3052 zebra_nhlfe_t
*nhlfe
;
3053 char buf
[MPLS_LABEL_STRLEN
];
3054 const char *backup_str
;
3057 nhlfe
= nhlfe_find(&lsp
->backup_nhlfe_list
, type
, gtype
,
3059 backup_str
= "backup ";
3061 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, type
, gtype
, gate
,
3067 struct nexthop
*nh
= nhlfe
->nexthop
;
3070 assert(nh
->nh_label
);
3072 /* Clear deleted flag (in case it was set) */
3073 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
3074 if (nh
->nh_label
->num_labels
== num_out_labels
3075 && !memcmp(nh
->nh_label
->label
, out_labels
,
3076 sizeof(mpls_label_t
) * num_out_labels
))
3080 if (IS_ZEBRA_DEBUG_MPLS
) {
3081 char buf2
[MPLS_LABEL_STRLEN
];
3082 char buf3
[MPLS_LABEL_STRLEN
];
3084 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3085 mpls_label2str(num_out_labels
, out_labels
, buf2
,
3087 mpls_label2str(nh
->nh_label
->num_labels
,
3088 nh
->nh_label
->label
, buf3
, sizeof(buf3
),
3091 zlog_debug("LSP in-label %u type %d %snexthop %s out-label(s) changed to %s (old %s)",
3092 lsp
->ile
.in_label
, type
, backup_str
, buf
,
3096 /* Update out label(s), trigger processing. */
3097 if (nh
->nh_label
->num_labels
== num_out_labels
)
3098 memcpy(nh
->nh_label
->label
, out_labels
,
3099 sizeof(mpls_label_t
) * num_out_labels
);
3101 nexthop_del_labels(nh
);
3102 nexthop_add_labels(nh
, type
, num_out_labels
,
3106 /* Add LSP entry to this nexthop */
3107 nhlfe
= nhlfe_add(lsp
, type
, gtype
, gate
, ifindex
,
3108 num_out_labels
, out_labels
, is_backup
);
3112 if (IS_ZEBRA_DEBUG_MPLS
) {
3113 char buf2
[MPLS_LABEL_STRLEN
];
3115 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3116 mpls_label2str(num_out_labels
, out_labels
, buf2
,
3119 zlog_debug("Add LSP in-label %u type %d %snexthop %s out-label(s) %s",
3120 lsp
->ile
.in_label
, type
, backup_str
, buf
,
3124 lsp
->addr_family
= NHLFE_FAMILY(nhlfe
);
3127 /* Mark NHLFE, queue LSP for processing. */
3128 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
3134 * Install an LSP and forwarding entry; used primarily
3135 * from vrf zapi message processing.
3137 int mpls_lsp_install(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3138 mpls_label_t in_label
, uint8_t num_out_labels
,
3139 const mpls_label_t
*out_labels
, enum nexthop_types_t gtype
,
3140 const union g_addr
*gate
, ifindex_t ifindex
)
3142 struct hash
*lsp_table
;
3143 zebra_ile_t tmp_ile
;
3145 zebra_nhlfe_t
*nhlfe
;
3148 lsp_table
= zvrf
->lsp_table
;
3152 /* Find or create LSP object */
3153 tmp_ile
.in_label
= in_label
;
3154 lsp
= hash_get(lsp_table
, &tmp_ile
, lsp_alloc
);
3158 nhlfe
= lsp_add_nhlfe(lsp
, type
, num_out_labels
, out_labels
, gtype
,
3159 gate
, ifindex
, false /*backup*/);
3163 /* Queue LSP for processing. */
3164 if (lsp_processq_add(lsp
))
3171 * Install or replace NHLFE, using info from zapi nexthop
3173 static int lsp_znh_install(zebra_lsp_t
*lsp
, enum lsp_types_t type
,
3174 const struct zapi_nexthop
*znh
)
3176 zebra_nhlfe_t
*nhlfe
;
3178 nhlfe
= lsp_add_nhlfe(lsp
, type
, znh
->label_num
, znh
->labels
,
3179 znh
->type
, &znh
->gate
, znh
->ifindex
,
3184 /* Update backup info if present */
3185 if (CHECK_FLAG(znh
->flags
, ZAPI_NEXTHOP_FLAG_HAS_BACKUP
)) {
3186 if (znh
->backup_num
> NEXTHOP_MAX_BACKUPS
) {
3191 nhlfe
->nexthop
->backup_num
= znh
->backup_num
;
3192 memcpy(nhlfe
->nexthop
->backup_idx
, znh
->backup_idx
,
3194 SET_FLAG(nhlfe
->nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
);
3196 /* Ensure there's no stale backup info */
3197 UNSET_FLAG(nhlfe
->nexthop
->flags
, NEXTHOP_FLAG_HAS_BACKUP
);
3198 nhlfe
->nexthop
->backup_num
= 0;
3201 /* Queue LSP for processing. */
3202 if (lsp_processq_add(lsp
))
3209 * Install/update backup NHLFE for an LSP, using info from a zapi message.
3211 static int lsp_backup_znh_install(zebra_lsp_t
*lsp
, enum lsp_types_t type
,
3212 const struct zapi_nexthop
*znh
)
3214 zebra_nhlfe_t
*nhlfe
;
3216 nhlfe
= lsp_add_nhlfe(lsp
, type
, znh
->label_num
,
3217 znh
->labels
, znh
->type
, &znh
->gate
,
3218 znh
->ifindex
, true /*backup*/);
3219 if (nhlfe
== NULL
) {
3220 if (IS_ZEBRA_DEBUG_MPLS
)
3221 zlog_debug("%s: unable to add backup nhlfe, label: %u",
3222 __func__
, lsp
->ile
.in_label
);
3226 /* Queue LSP for processing. */
3227 if (lsp_processq_add(lsp
))
3233 zebra_lsp_t
*mpls_lsp_find(struct zebra_vrf
*zvrf
, mpls_label_t in_label
)
3235 struct hash
*lsp_table
;
3236 zebra_ile_t tmp_ile
;
3239 lsp_table
= zvrf
->lsp_table
;
3243 /* If entry is not present, exit. */
3244 tmp_ile
.in_label
= in_label
;
3245 return hash_lookup(lsp_table
, &tmp_ile
);
3249 * Uninstall a particular NHLFE in the forwarding table. If this is
3250 * the only NHLFE, the entire LSP forwarding entry has to be deleted.
3252 int mpls_lsp_uninstall(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3253 mpls_label_t in_label
, enum nexthop_types_t gtype
,
3254 const union g_addr
*gate
, ifindex_t ifindex
,
3257 struct hash
*lsp_table
;
3258 zebra_ile_t tmp_ile
;
3260 zebra_nhlfe_t
*nhlfe
;
3261 char buf
[NEXTHOP_STRLEN
];
3262 bool schedule_lsp
= false;
3265 lsp_table
= zvrf
->lsp_table
;
3269 /* If entry is not present, exit. */
3270 tmp_ile
.in_label
= in_label
;
3271 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3276 nhlfe
= nhlfe_find(&lsp
->backup_nhlfe_list
, type
, gtype
,
3279 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, type
, gtype
, gate
,
3284 if (IS_ZEBRA_DEBUG_MPLS
) {
3285 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3286 zlog_debug("Del LSP in-label %u type %d nexthop %s flags 0x%x",
3287 in_label
, type
, buf
, nhlfe
->flags
);
3290 if (CHECK_FLAG(lsp
->flags
, LSP_FLAG_INSTALLED
) ||
3291 CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
))
3292 schedule_lsp
= true;
3294 /* Mark NHLFE for delete or directly delete, as appropriate. */
3296 SET_FLAG(nhlfe
->flags
, NHLFE_FLAG_DELETED
);
3297 UNSET_FLAG(nhlfe
->flags
, NHLFE_FLAG_CHANGED
);
3299 if (IS_ZEBRA_DEBUG_MPLS
)
3300 zlog_debug("Schedule LSP in-label %u flags 0x%x",
3301 lsp
->ile
.in_label
, lsp
->flags
);
3302 if (lsp_processq_add(lsp
))
3307 /* Free LSP entry if no other NHLFEs and not scheduled. */
3308 lsp_check_free(lsp_table
, &lsp
);
3313 int mpls_lsp_uninstall_all_vrf(struct zebra_vrf
*zvrf
, enum lsp_types_t type
,
3314 mpls_label_t in_label
)
3316 struct hash
*lsp_table
;
3317 zebra_ile_t tmp_ile
;
3321 lsp_table
= zvrf
->lsp_table
;
3325 /* If entry is not present, exit. */
3326 tmp_ile
.in_label
= in_label
;
3327 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3331 return mpls_lsp_uninstall_all(lsp_table
, lsp
, type
);
3335 * Uninstall all NHLFEs for a particular LSP forwarding entry.
3336 * If no other NHLFEs exist, the entry would be deleted.
3338 static void mpls_lsp_uninstall_all_type(struct hash_bucket
*bucket
, void *ctxt
)
3340 struct lsp_uninstall_args
*args
= ctxt
;
3342 struct hash
*lsp_table
;
3344 lsp
= (zebra_lsp_t
*)bucket
->data
;
3345 if (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
)
3348 lsp_table
= args
->lsp_table
;
3352 mpls_lsp_uninstall_all(lsp_table
, lsp
, args
->type
);
3356 * Uninstall all FEC-To-NHLFE (FTN) bindings of the given address-family and
3359 static void mpls_ftn_uninstall_all(struct zebra_vrf
*zvrf
,
3360 int afi
, enum lsp_types_t lsp_type
)
3362 struct route_table
*table
;
3363 struct route_node
*rn
;
3364 struct route_entry
*re
;
3365 struct nexthop
*nexthop
;
3366 struct nexthop_group
*nhg
;
3369 /* Process routes of interested address-families. */
3370 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, zvrf_id(zvrf
));
3374 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
3377 RNODE_FOREACH_RE (rn
, re
) {
3378 struct nhg_hash_entry
*new_nhe
;
3380 new_nhe
= zebra_nhe_copy(re
->nhe
, 0);
3382 nhg
= &new_nhe
->nhg
;
3383 for (nexthop
= nhg
->nexthop
; nexthop
;
3384 nexthop
= nexthop
->next
) {
3385 if (nexthop
->nh_label_type
!= lsp_type
)
3388 nexthop_del_labels(nexthop
);
3389 SET_FLAG(re
->status
, ROUTE_ENTRY_CHANGED
);
3390 SET_FLAG(re
->status
,
3391 ROUTE_ENTRY_LABELS_CHANGED
);
3395 /* Check for backup info and update that also */
3396 nhg
= zebra_nhg_get_backup_nhg(new_nhe
);
3398 for (nexthop
= nhg
->nexthop
; nexthop
;
3399 nexthop
= nexthop
->next
) {
3400 if (nexthop
->nh_label_type
!= lsp_type
)
3403 nexthop_del_labels(nexthop
);
3404 SET_FLAG(re
->status
,
3405 ROUTE_ENTRY_CHANGED
);
3406 SET_FLAG(re
->status
,
3407 ROUTE_ENTRY_LABELS_CHANGED
);
3412 if (CHECK_FLAG(re
->status
, ROUTE_ENTRY_LABELS_CHANGED
))
3413 mpls_zebra_nhe_update(re
, afi
, new_nhe
);
3415 zebra_nhg_free(new_nhe
);
3423 #if defined(HAVE_CUMULUS)
3425 * Check that the label values used in LSP creation are consistent. The
3426 * main criteria is that if there is ECMP, the label operation must still
3427 * be consistent - i.e., all paths either do a swap or do PHP. This is due
3428 * to current HW restrictions.
3430 int zebra_mpls_lsp_label_consistent(struct zebra_vrf
*zvrf
,
3431 mpls_label_t in_label
,
3432 mpls_label_t out_label
,
3433 enum nexthop_types_t gtype
,
3434 union g_addr
*gate
, ifindex_t ifindex
)
3436 struct hash
*slsp_table
;
3437 zebra_ile_t tmp_ile
;
3439 zebra_nhlfe_t
*nhlfe
;
3440 const struct nexthop
*nh
;
3443 slsp_table
= zvrf
->slsp_table
;
3447 /* If entry is not present, exit. */
3448 tmp_ile
.in_label
= in_label
;
3449 lsp
= hash_lookup(slsp_table
, &tmp_ile
);
3453 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
,
3454 gtype
, gate
, ifindex
);
3456 nh
= nhlfe
->nexthop
;
3458 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3461 if (nh
->nh_label
->label
[0] == out_label
)
3464 /* If not only NHLFE, cannot allow label change. */
3465 if (nhlfe
!= nhlfe_list_first(&lsp
->nhlfe_list
) ||
3466 nhlfe_list_next(&lsp
->nhlfe_list
, nhlfe
) != NULL
)
3469 /* If other NHLFEs exist, label operation must match. */
3470 nhlfe
= nhlfe_list_first(&lsp
->nhlfe_list
);
3471 if (nhlfe
!= NULL
) {
3474 nh
= nhlfe
->nexthop
;
3476 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3479 cur_op
= (nh
->nh_label
->label
[0] ==
3480 MPLS_LABEL_IMPLICIT_NULL
);
3481 new_op
= (out_label
== MPLS_LABEL_IMPLICIT_NULL
);
3482 if (cur_op
!= new_op
)
3487 /* Label values are good. */
3490 #endif /* HAVE_CUMULUS */
3493 * Add static LSP entry. This may be the first entry for this incoming label
3494 * or an additional nexthop; an existing entry may also have outgoing label
3496 * Note: The label operation (swap or PHP) is common for the LSP entry (all
3499 int zebra_mpls_static_lsp_add(struct zebra_vrf
*zvrf
, mpls_label_t in_label
,
3500 mpls_label_t out_label
,
3501 enum nexthop_types_t gtype
, union g_addr
*gate
,
3504 struct hash
*slsp_table
;
3505 zebra_ile_t tmp_ile
;
3507 zebra_nhlfe_t
*nhlfe
;
3511 slsp_table
= zvrf
->slsp_table
;
3515 /* Find or create LSP. */
3516 tmp_ile
.in_label
= in_label
;
3517 lsp
= hash_get(slsp_table
, &tmp_ile
, lsp_alloc
);
3521 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
, gtype
, gate
,
3524 struct nexthop
*nh
= nhlfe
->nexthop
;
3527 assert(nh
->nh_label
);
3529 /* Compare existing nexthop */
3530 if (nh
->nh_label
->num_labels
== 1 &&
3531 nh
->nh_label
->label
[0] == out_label
)
3535 if (IS_ZEBRA_DEBUG_MPLS
) {
3536 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3538 "Upd static LSP in-label %u nexthop %s out-label %u (old %u)",
3539 in_label
, buf
, out_label
,
3540 nh
->nh_label
->label
[0]);
3542 if (nh
->nh_label
->num_labels
== 1)
3543 nh
->nh_label
->label
[0] = out_label
;
3545 nexthop_del_labels(nh
);
3546 nexthop_add_labels(nh
, ZEBRA_LSP_STATIC
, 1, &out_label
);
3550 /* Add static LSP entry to this nexthop */
3551 nhlfe
= nhlfe_add(lsp
, ZEBRA_LSP_STATIC
, gtype
, gate
,
3552 ifindex
, 1, &out_label
, false /*backup*/);
3556 if (IS_ZEBRA_DEBUG_MPLS
) {
3557 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3559 "Add static LSP in-label %u nexthop %s out-label %u",
3560 in_label
, buf
, out_label
);
3564 /* (Re)Install LSP in the main table. */
3565 if (mpls_lsp_install(zvrf
, ZEBRA_LSP_STATIC
, in_label
, 1, &out_label
,
3566 gtype
, gate
, ifindex
))
3573 * Delete static LSP entry. This may be the delete of one particular
3574 * NHLFE for this incoming label or the delete of the entire entry (i.e.,
3576 * NOTE: Delete of the only NHLFE will also end up deleting the entire
3577 * LSP configuration.
3579 int zebra_mpls_static_lsp_del(struct zebra_vrf
*zvrf
, mpls_label_t in_label
,
3580 enum nexthop_types_t gtype
, union g_addr
*gate
,
3583 struct hash
*slsp_table
;
3584 zebra_ile_t tmp_ile
;
3586 zebra_nhlfe_t
*nhlfe
;
3589 slsp_table
= zvrf
->slsp_table
;
3593 /* If entry is not present, exit. */
3594 tmp_ile
.in_label
= in_label
;
3595 lsp
= hash_lookup(slsp_table
, &tmp_ile
);
3599 /* Is it delete of entire LSP or a specific NHLFE? */
3600 if (gtype
== NEXTHOP_TYPE_BLACKHOLE
) {
3601 if (IS_ZEBRA_DEBUG_MPLS
)
3602 zlog_debug("Del static LSP in-label %u", in_label
);
3604 /* Uninstall entire LSP from the main table. */
3605 mpls_static_lsp_uninstall_all(zvrf
, in_label
);
3607 /* Delete all static NHLFEs */
3608 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3612 /* Find specific NHLFE, exit if not found. */
3613 nhlfe
= nhlfe_find(&lsp
->nhlfe_list
, ZEBRA_LSP_STATIC
,
3614 gtype
, gate
, ifindex
);
3618 if (IS_ZEBRA_DEBUG_MPLS
) {
3620 nhlfe2str(nhlfe
, buf
, sizeof(buf
));
3621 zlog_debug("Del static LSP in-label %u nexthop %s",
3625 /* Uninstall LSP from the main table. */
3626 mpls_lsp_uninstall(zvrf
, ZEBRA_LSP_STATIC
, in_label
, gtype
,
3627 gate
, ifindex
, false);
3629 /* Delete static LSP NHLFE */
3633 /* Remove entire static LSP entry if no NHLFE - valid in either case
3636 if (nhlfe_list_first(&lsp
->nhlfe_list
) == NULL
) {
3637 lsp
= hash_release(slsp_table
, &tmp_ile
);
3638 XFREE(MTYPE_LSP
, lsp
);
3645 * Schedule all MPLS label forwarding entries for processing.
3646 * Called upon changes that may affect one or more of them such as
3647 * interface or nexthop state changes.
3649 void zebra_mpls_lsp_schedule(struct zebra_vrf
*zvrf
)
3653 hash_iterate(zvrf
->lsp_table
, lsp_schedule
, NULL
);
3657 * Display MPLS label forwarding table for a specific LSP
3658 * (VTY command handler).
3660 void zebra_mpls_print_lsp(struct vty
*vty
, struct zebra_vrf
*zvrf
,
3661 mpls_label_t label
, bool use_json
)
3663 struct hash
*lsp_table
;
3665 zebra_ile_t tmp_ile
;
3666 json_object
*json
= NULL
;
3669 lsp_table
= zvrf
->lsp_table
;
3673 /* If entry is not present, exit. */
3674 tmp_ile
.in_label
= label
;
3675 lsp
= hash_lookup(lsp_table
, &tmp_ile
);
3680 json
= lsp_json(lsp
);
3681 vty_out(vty
, "%s\n", json_object_to_json_string_ext(
3682 json
, JSON_C_TO_STRING_PRETTY
));
3683 json_object_free(json
);
3685 lsp_print(vty
, lsp
);
3689 * Display MPLS label forwarding table (VTY command handler).
3691 void zebra_mpls_print_lsp_table(struct vty
*vty
, struct zebra_vrf
*zvrf
,
3695 json_object
*json
= NULL
;
3696 zebra_lsp_t
*lsp
= NULL
;
3697 zebra_nhlfe_t
*nhlfe
= NULL
;
3698 struct listnode
*node
= NULL
;
3699 struct list
*lsp_list
= hash_get_sorted_list(zvrf
->lsp_table
, lsp_cmp
);
3702 json
= json_object_new_object();
3704 for (ALL_LIST_ELEMENTS_RO(lsp_list
, node
, lsp
))
3705 json_object_object_add(
3706 json
, label2str(lsp
->ile
.in_label
, buf
,
3710 vty_out(vty
, "%s\n", json_object_to_json_string_ext(
3711 json
, JSON_C_TO_STRING_PRETTY
));
3712 json_object_free(json
);
3716 /* Prepare table. */
3717 tt
= ttable_new(&ttable_styles
[TTSTYLE_BLANK
]);
3718 ttable_add_row(tt
, "Inbound Label|Type|Nexthop|Outbound Label");
3719 tt
->style
.cell
.rpad
= 2;
3720 tt
->style
.corner
= '+';
3722 ttable_rowseps(tt
, 0, BOTTOM
, true, '-');
3724 for (ALL_LIST_ELEMENTS_RO(lsp_list
, node
, lsp
)) {
3725 frr_each_safe(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3726 struct nexthop
*nexthop
;
3727 const char *out_label_str
;
3728 char nh_buf
[NEXTHOP_STRLEN
];
3730 nexthop
= nhlfe
->nexthop
;
3732 switch (nexthop
->type
) {
3733 case NEXTHOP_TYPE_IFINDEX
: {
3734 struct zebra_ns
*zns
;
3735 struct interface
*ifp
;
3737 zns
= zebra_ns_lookup(NS_DEFAULT
);
3738 ifp
= if_lookup_by_index_per_ns(
3739 zns
, nexthop
->ifindex
);
3740 snprintf(nh_buf
, sizeof(nh_buf
), "%s",
3741 ifp
? ifp
->name
: "Null");
3744 case NEXTHOP_TYPE_IPV4
:
3745 case NEXTHOP_TYPE_IPV4_IFINDEX
:
3746 inet_ntop(AF_INET
, &nexthop
->gate
.ipv4
,
3747 nh_buf
, sizeof(nh_buf
));
3749 case NEXTHOP_TYPE_IPV6
:
3750 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3751 inet_ntop(AF_INET6
, &nexthop
->gate
.ipv6
,
3752 nh_buf
, sizeof(nh_buf
));
3758 if (nexthop
->type
!= NEXTHOP_TYPE_IFINDEX
)
3759 out_label_str
= mpls_label2str(
3760 nexthop
->nh_label
->num_labels
,
3761 &nexthop
->nh_label
->label
[0],
3762 buf
, sizeof(buf
), 1);
3764 out_label_str
= "-";
3766 ttable_add_row(tt
, "%u|%s|%s|%s",
3768 nhlfe_type2str(nhlfe
->type
),
3769 nh_buf
, out_label_str
);
3773 /* Dump the generated table. */
3774 if (tt
->nrows
> 1) {
3775 char *table
= ttable_dump(tt
, "\n");
3776 vty_out(vty
, "%s\n", table
);
3777 XFREE(MTYPE_TMP
, table
);
3782 list_delete(&lsp_list
);
3786 * Create printable string for static LSP configuration.
3788 static char *nhlfe_config_str(const zebra_nhlfe_t
*nhlfe
, char *buf
, int size
)
3790 const struct nexthop
*nh
;
3792 nh
= nhlfe
->nexthop
;
3796 case NEXTHOP_TYPE_IPV4
:
3797 inet_ntop(AF_INET
, &nh
->gate
.ipv4
, buf
, size
);
3799 case NEXTHOP_TYPE_IPV6
:
3800 case NEXTHOP_TYPE_IPV6_IFINDEX
:
3801 inet_ntop(AF_INET6
, &nh
->gate
.ipv6
, buf
, size
);
3804 ifindex2ifname(nh
->ifindex
, VRF_DEFAULT
),
3815 * Display MPLS LSP configuration of all static LSPs (VTY command handler).
3817 int zebra_mpls_write_lsp_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
3820 zebra_nhlfe_t
*nhlfe
;
3822 struct listnode
*node
;
3823 struct list
*slsp_list
=
3824 hash_get_sorted_list(zvrf
->slsp_table
, lsp_cmp
);
3826 for (ALL_LIST_ELEMENTS_RO(slsp_list
, node
, lsp
)) {
3827 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3831 nh
= nhlfe
->nexthop
;
3832 if (nh
== NULL
|| nh
->nh_label
== NULL
)
3835 nhlfe_config_str(nhlfe
, buf
, sizeof(buf
));
3837 switch (nh
->nh_label
->label
[0]) {
3838 case MPLS_LABEL_IPV4_EXPLICIT_NULL
:
3839 case MPLS_LABEL_IPV6_EXPLICIT_NULL
:
3840 strlcpy(lstr
, "explicit-null", sizeof(lstr
));
3842 case MPLS_LABEL_IMPLICIT_NULL
:
3843 strlcpy(lstr
, "implicit-null", sizeof(lstr
));
3846 snprintf(lstr
, sizeof(lstr
), "%u",
3847 nh
->nh_label
->label
[0]);
3851 vty_out(vty
, "mpls lsp %u %s %s\n", lsp
->ile
.in_label
,
3856 list_delete(&slsp_list
);
3857 return (zvrf
->slsp_table
->count
? 1 : 0);
3861 * Add/update global label block.
3863 int zebra_mpls_label_block_add(struct zebra_vrf
*zvrf
, uint32_t start_label
,
3866 zvrf
->mpls_srgb
.start_label
= start_label
;
3867 zvrf
->mpls_srgb
.end_label
= end_label
;
3869 /* Evaluate registered FECs to see if any get a label or not. */
3875 * Delete global label block.
3877 int zebra_mpls_label_block_del(struct zebra_vrf
*zvrf
)
3879 zvrf
->mpls_srgb
.start_label
= MPLS_DEFAULT_MIN_SRGB_LABEL
;
3880 zvrf
->mpls_srgb
.end_label
= MPLS_DEFAULT_MAX_SRGB_LABEL
;
3882 /* Process registered FECs to clear their local label, if needed. */
3888 * Display MPLS global label block configuration (VTY command handler).
3890 int zebra_mpls_write_label_block_config(struct vty
*vty
, struct zebra_vrf
*zvrf
)
3892 if (zvrf
->mpls_srgb
.start_label
== 0)
3895 if ((zvrf
->mpls_srgb
.start_label
!= MPLS_DEFAULT_MIN_SRGB_LABEL
)
3896 || (zvrf
->mpls_srgb
.end_label
!= MPLS_DEFAULT_MAX_SRGB_LABEL
)) {
3897 vty_out(vty
, "mpls label global-block %u %u\n",
3898 zvrf
->mpls_srgb
.start_label
, zvrf
->mpls_srgb
.end_label
);
3905 * Called when VRF becomes inactive, cleans up information but keeps
3908 void zebra_mpls_cleanup_tables(struct zebra_vrf
*zvrf
)
3910 struct zebra_vrf
*def_zvrf
;
3913 if (zvrf_id(zvrf
) == VRF_DEFAULT
)
3914 hash_iterate(zvrf
->lsp_table
, lsp_uninstall_from_kernel
, NULL
);
3917 * For other vrfs, we try to remove associated LSPs; we locate
3918 * the LSPs in the default vrf.
3920 def_zvrf
= zebra_vrf_lookup_by_id(VRF_DEFAULT
);
3922 /* At shutdown, the default may be gone already */
3923 if (def_zvrf
== NULL
)
3926 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
3927 if (zvrf
->label
[afi
] != MPLS_LABEL_NONE
)
3928 lsp_uninstall(def_zvrf
, zvrf
->label
[afi
]);
3934 * Called upon process exiting, need to delete LSP forwarding
3935 * entries from the kernel.
3936 * NOTE: Currently supported only for default VRF.
3938 void zebra_mpls_close_tables(struct zebra_vrf
*zvrf
)
3940 hash_iterate(zvrf
->lsp_table
, lsp_uninstall_from_kernel
, NULL
);
3941 hash_clean(zvrf
->lsp_table
, NULL
);
3942 hash_free(zvrf
->lsp_table
);
3943 hash_clean(zvrf
->slsp_table
, NULL
);
3944 hash_free(zvrf
->slsp_table
);
3945 route_table_finish(zvrf
->fec_table
[AFI_IP
]);
3946 route_table_finish(zvrf
->fec_table
[AFI_IP6
]);
3950 * Allocate MPLS tables for this VRF and do other initialization.
3951 * NOTE: Currently supported only for default VRF.
3953 void zebra_mpls_init_tables(struct zebra_vrf
*zvrf
)
3960 snprintf(buffer
, sizeof(buffer
), "ZEBRA SLSP table: %s",
3962 zvrf
->slsp_table
= hash_create_size(8, label_hash
, label_cmp
, buffer
);
3964 snprintf(buffer
, sizeof(buffer
), "ZEBRA LSP table: %s",
3966 zvrf
->lsp_table
= hash_create_size(8, label_hash
, label_cmp
, buffer
);
3967 zvrf
->fec_table
[AFI_IP
] = route_table_init();
3968 zvrf
->fec_table
[AFI_IP6
] = route_table_init();
3969 zvrf
->mpls_flags
= 0;
3970 zvrf
->mpls_srgb
.start_label
= MPLS_DEFAULT_MIN_SRGB_LABEL
;
3971 zvrf
->mpls_srgb
.end_label
= MPLS_DEFAULT_MAX_SRGB_LABEL
;
3975 * Global MPLS initialization.
3977 void zebra_mpls_init(void)
3981 if (mpls_kernel_init() < 0) {
3982 flog_warn(EC_ZEBRA_MPLS_SUPPORT_DISABLED
,
3983 "Disabling MPLS support (no kernel support)");
3987 if (!mpls_processq_init())
3990 hook_register(zserv_client_close
, zebra_mpls_cleanup_fecs_for_client
);
3991 hook_register(zserv_client_close
, zebra_mpls_cleanup_zclient_labels
);