]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_mpls.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12780 from opensourcerouting/spdx-license-id
[mirror_frr.git] / zebra / zebra_mpls.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Zebra MPLS code
3 * Copyright (C) 2013 Cumulus Networks, Inc.
4 */
5
6 #include <zebra.h>
7
8 #include "prefix.h"
9 #include "table.h"
10 #include "memory.h"
11 #include "command.h"
12 #include "if.h"
13 #include "log.h"
14 #include "sockunion.h"
15 #include "linklist.h"
16 #include "thread.h"
17 #include "workqueue.h"
18 #include "prefix.h"
19 #include "routemap.h"
20 #include "stream.h"
21 #include "nexthop.h"
22 #include "termtable.h"
23 #include "lib/json.h"
24
25 #include "zebra/rib.h"
26 #include "zebra/rt.h"
27 #include "zebra/interface.h"
28 #include "zebra/zserv.h"
29 #include "zebra/zebra_router.h"
30 #include "zebra/redistribute.h"
31 #include "zebra/debug.h"
32 #include "zebra/zebra_vrf.h"
33 #include "zebra/zebra_mpls.h"
34 #include "zebra/zebra_srte.h"
35 #include "zebra/zebra_errors.h"
36
37 DEFINE_MTYPE_STATIC(ZEBRA, LSP, "MPLS LSP object");
38 DEFINE_MTYPE_STATIC(ZEBRA, FEC, "MPLS FEC object");
39 DEFINE_MTYPE_STATIC(ZEBRA, NHLFE, "MPLS nexthop object");
40
41 bool mpls_enabled;
42 bool mpls_pw_reach_strict; /* Strict reachability checking */
43
44 /* static function declarations */
45
46 static void fec_evaluate(struct zebra_vrf *zvrf);
47 static uint32_t fec_derive_label_from_index(struct zebra_vrf *vrf,
48 struct zebra_fec *fec);
49 static int lsp_install(struct zebra_vrf *zvrf, mpls_label_t label,
50 struct route_node *rn, struct route_entry *re);
51 static int lsp_uninstall(struct zebra_vrf *zvrf, mpls_label_t label);
52 static int fec_change_update_lsp(struct zebra_vrf *zvrf, struct zebra_fec *fec,
53 mpls_label_t old_label);
54 static int fec_send(struct zebra_fec *fec, struct zserv *client);
55 static void fec_update_clients(struct zebra_fec *fec);
56 static void fec_print(struct zebra_fec *fec, struct vty *vty);
57 static struct zebra_fec *fec_find(struct route_table *table, struct prefix *p);
58 static struct zebra_fec *fec_add(struct route_table *table, struct prefix *p,
59 mpls_label_t label, uint32_t flags,
60 uint32_t label_index);
61 static int fec_del(struct zebra_fec *fec);
62
63 static unsigned int label_hash(const void *p);
64 static bool label_cmp(const void *p1, const void *p2);
65 static int nhlfe_nexthop_active_ipv4(struct zebra_nhlfe *nhlfe,
66 struct nexthop *nexthop);
67 static int nhlfe_nexthop_active_ipv6(struct zebra_nhlfe *nhlfe,
68 struct nexthop *nexthop);
69 static int nhlfe_nexthop_active(struct zebra_nhlfe *nhlfe);
70
71 static void lsp_select_best_nhlfe(struct zebra_lsp *lsp);
72 static void lsp_uninstall_from_kernel(struct hash_bucket *bucket, void *ctxt);
73 static void lsp_schedule(struct hash_bucket *bucket, void *ctxt);
74 static wq_item_status lsp_process(struct work_queue *wq, void *data);
75 static void lsp_processq_del(struct work_queue *wq, void *data);
76 static void lsp_processq_complete(struct work_queue *wq);
77 static int lsp_processq_add(struct zebra_lsp *lsp);
78 static void *lsp_alloc(void *p);
79
80 /* Check whether lsp can be freed - no nhlfes, e.g., and call free api */
81 static void lsp_check_free(struct hash *lsp_table, struct zebra_lsp **plsp);
82
83 /* Free lsp; sets caller's pointer to NULL */
84 static void lsp_free(struct hash *lsp_table, struct zebra_lsp **plsp);
85
86 static char *nhlfe2str(const struct zebra_nhlfe *nhlfe, char *buf, int size);
87 static char *nhlfe_config_str(const struct zebra_nhlfe *nhlfe, char *buf,
88 int size);
89 static int nhlfe_nhop_match(struct zebra_nhlfe *nhlfe,
90 enum nexthop_types_t gtype,
91 const union g_addr *gate, ifindex_t ifindex);
92 static struct zebra_nhlfe *nhlfe_find(struct nhlfe_list_head *list,
93 enum lsp_types_t lsp_type,
94 enum nexthop_types_t gtype,
95 const union g_addr *gate,
96 ifindex_t ifindex);
97 static struct zebra_nhlfe *
98 nhlfe_add(struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
99 enum nexthop_types_t gtype, const union g_addr *gate,
100 ifindex_t ifindex, uint8_t num_labels, const mpls_label_t *labels,
101 bool is_backup);
102 static int nhlfe_del(struct zebra_nhlfe *nhlfe);
103 static void nhlfe_free(struct zebra_nhlfe *nhlfe);
104 static void nhlfe_out_label_update(struct zebra_nhlfe *nhlfe,
105 struct mpls_label_stack *nh_label);
106 static int mpls_lsp_uninstall_all(struct hash *lsp_table, struct zebra_lsp *lsp,
107 enum lsp_types_t type);
108 static int mpls_static_lsp_uninstall_all(struct zebra_vrf *zvrf,
109 mpls_label_t in_label);
110 static void nhlfe_print(struct zebra_nhlfe *nhlfe, struct vty *vty,
111 const char *indent);
112 static void lsp_print(struct vty *vty, struct zebra_lsp *lsp);
113 static void mpls_lsp_uninstall_all_type(struct hash_bucket *bucket, void *ctxt);
114 static void mpls_ftn_uninstall_all(struct zebra_vrf *zvrf,
115 int afi, enum lsp_types_t lsp_type);
116 static int lsp_znh_install(struct zebra_lsp *lsp, enum lsp_types_t type,
117 const struct zapi_nexthop *znh);
118 static int lsp_backup_znh_install(struct zebra_lsp *lsp, enum lsp_types_t type,
119 const struct zapi_nexthop *znh);
120
121 /* Static functions */
122
123 /*
124 * Handle failure in LSP install, clear flags for NHLFE.
125 */
126 static void clear_nhlfe_installed(struct zebra_lsp *lsp)
127 {
128 struct zebra_nhlfe *nhlfe;
129 struct nexthop *nexthop;
130
131 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
132 nexthop = nhlfe->nexthop;
133 if (!nexthop)
134 continue;
135
136 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
137 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
138 }
139
140 frr_each_safe(nhlfe_list, &lsp->backup_nhlfe_list, nhlfe) {
141 nexthop = nhlfe->nexthop;
142 if (!nexthop)
143 continue;
144
145 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
146 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
147 }
148 }
149
150 /*
151 * Install label forwarding entry based on labeled-route entry.
152 */
153 static int lsp_install(struct zebra_vrf *zvrf, mpls_label_t label,
154 struct route_node *rn, struct route_entry *re)
155 {
156 struct hash *lsp_table;
157 struct zebra_ile tmp_ile;
158 struct zebra_lsp *lsp;
159 struct zebra_nhlfe *nhlfe;
160 struct nexthop *nexthop;
161 enum lsp_types_t lsp_type;
162 char buf[BUFSIZ];
163 int added, changed;
164
165 /* Lookup table. */
166 lsp_table = zvrf->lsp_table;
167 if (!lsp_table)
168 return -1;
169
170 lsp_type = lsp_type_from_re_type(re->type);
171 added = changed = 0;
172
173 /* Locate or allocate LSP entry. */
174 tmp_ile.in_label = label;
175 lsp = hash_get(lsp_table, &tmp_ile, lsp_alloc);
176
177 /* For each active nexthop, create NHLFE. Note that we deliberately skip
178 * recursive nexthops right now, because intermediate hops won't
179 * understand
180 * the label advertised by the recursive nexthop (plus we don't have the
181 * logic yet to push multiple labels).
182 */
183 for (nexthop = re->nhe->nhg.nexthop;
184 nexthop; nexthop = nexthop->next) {
185 /* Skip inactive and recursive entries. */
186 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
187 continue;
188 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
189 continue;
190
191 nhlfe = nhlfe_find(&lsp->nhlfe_list, lsp_type,
192 nexthop->type, &nexthop->gate,
193 nexthop->ifindex);
194 if (nhlfe) {
195 /* Clear deleted flag (in case it was set) */
196 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
197 if (nexthop_labels_match(nhlfe->nexthop, nexthop))
198 /* No change */
199 continue;
200
201
202 if (IS_ZEBRA_DEBUG_MPLS) {
203 nhlfe2str(nhlfe, buf, BUFSIZ);
204 zlog_debug(
205 "LSP in-label %u type %d nexthop %s out-label changed",
206 lsp->ile.in_label, lsp_type, buf);
207 }
208
209 /* Update out label, trigger processing. */
210 nhlfe_out_label_update(nhlfe, nexthop->nh_label);
211 SET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
212 changed++;
213 } else {
214 /* Add LSP entry to this nexthop */
215 nhlfe = nhlfe_add(lsp, lsp_type, nexthop->type,
216 &nexthop->gate, nexthop->ifindex,
217 nexthop->nh_label->num_labels,
218 nexthop->nh_label->label,
219 false /*backup*/);
220 if (!nhlfe)
221 return -1;
222
223 if (IS_ZEBRA_DEBUG_MPLS) {
224 nhlfe2str(nhlfe, buf, BUFSIZ);
225 zlog_debug(
226 "Add LSP in-label %u type %d nexthop %s out-label %u",
227 lsp->ile.in_label, lsp_type, buf,
228 nexthop->nh_label->label[0]);
229 }
230
231 lsp->addr_family = NHLFE_FAMILY(nhlfe);
232
233 /* Mark NHLFE as changed. */
234 SET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
235 added++;
236 }
237 }
238
239 /* Queue LSP for processing if necessary. If no NHLFE got added (special
240 * case), delete the LSP entry; this case results in somewhat ugly
241 * logging.
242 */
243 if (added || changed) {
244 if (lsp_processq_add(lsp))
245 return -1;
246 } else {
247 lsp_check_free(lsp_table, &lsp);
248 }
249
250 return 0;
251 }
252
253 /*
254 * Uninstall all non-static NHLFEs of a label forwarding entry. If all
255 * NHLFEs are removed, the entire entry is deleted.
256 */
257 static int lsp_uninstall(struct zebra_vrf *zvrf, mpls_label_t label)
258 {
259 struct hash *lsp_table;
260 struct zebra_ile tmp_ile;
261 struct zebra_lsp *lsp;
262 struct zebra_nhlfe *nhlfe;
263 char buf[BUFSIZ];
264
265 /* Lookup table. */
266 lsp_table = zvrf->lsp_table;
267 if (!lsp_table)
268 return -1;
269
270 /* If entry is not present, exit. */
271 tmp_ile.in_label = label;
272 lsp = hash_lookup(lsp_table, &tmp_ile);
273 if (!lsp || (nhlfe_list_first(&lsp->nhlfe_list) == NULL))
274 return 0;
275
276 /* Mark NHLFEs for delete or directly delete, as appropriate. */
277 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
278
279 /* Skip static NHLFEs */
280 if (nhlfe->type == ZEBRA_LSP_STATIC)
281 continue;
282
283 if (IS_ZEBRA_DEBUG_MPLS) {
284 nhlfe2str(nhlfe, buf, BUFSIZ);
285 zlog_debug(
286 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
287 label, nhlfe->type, buf, nhlfe->flags);
288 }
289
290 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)) {
291 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
292 SET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
293 } else {
294 nhlfe_del(nhlfe);
295 }
296 }
297
298 /* Queue LSP for processing, if needed, else delete. */
299 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
300 if (lsp_processq_add(lsp))
301 return -1;
302 } else {
303 lsp_check_free(lsp_table, &lsp);
304 }
305
306 return 0;
307 }
308
309 /*
310 * This function is invoked upon change to label block configuration; it
311 * will walk all registered FECs with label-index and appropriately update
312 * their local labels and trigger client updates.
313 */
314 static void fec_evaluate(struct zebra_vrf *zvrf)
315 {
316 struct route_node *rn;
317 struct zebra_fec *fec;
318 uint32_t old_label, new_label;
319 int af;
320
321 for (af = AFI_IP; af < AFI_MAX; af++) {
322 if (zvrf->fec_table[af] == NULL)
323 continue;
324
325 for (rn = route_top(zvrf->fec_table[af]); rn;
326 rn = route_next(rn)) {
327 if ((fec = rn->info) == NULL)
328 continue;
329
330 /* Skip configured FECs and those without a label index.
331 */
332 if (fec->flags & FEC_FLAG_CONFIGURED
333 || fec->label_index == MPLS_INVALID_LABEL_INDEX)
334 continue;
335
336 /* Save old label, determine new label. */
337 old_label = fec->label;
338 new_label =
339 zvrf->mpls_srgb.start_label + fec->label_index;
340 if (new_label >= zvrf->mpls_srgb.end_label)
341 new_label = MPLS_INVALID_LABEL;
342
343 /* If label has changed, update FEC and clients. */
344 if (new_label == old_label)
345 continue;
346
347 if (IS_ZEBRA_DEBUG_MPLS)
348 zlog_debug(
349 "Update fec %pRN new label %u upon label block",
350 rn, new_label);
351
352 fec->label = new_label;
353 fec_update_clients(fec);
354
355 /* Update label forwarding entries appropriately */
356 fec_change_update_lsp(zvrf, fec, old_label);
357 }
358 }
359 }
360
361 /*
362 * Derive (if possible) and update the local label for the FEC based on
363 * its label index. The index is "acceptable" if it falls within the
364 * globally configured label block (SRGB).
365 */
366 static uint32_t fec_derive_label_from_index(struct zebra_vrf *zvrf,
367 struct zebra_fec *fec)
368 {
369 uint32_t label;
370
371 if (fec->label_index != MPLS_INVALID_LABEL_INDEX
372 && zvrf->mpls_srgb.start_label
373 && ((label = zvrf->mpls_srgb.start_label + fec->label_index)
374 < zvrf->mpls_srgb.end_label))
375 fec->label = label;
376 else
377 fec->label = MPLS_INVALID_LABEL;
378
379 return fec->label;
380 }
381
382 /*
383 * There is a change for this FEC. Install or uninstall label forwarding
384 * entries, as appropriate.
385 */
386 static int fec_change_update_lsp(struct zebra_vrf *zvrf, struct zebra_fec *fec,
387 mpls_label_t old_label)
388 {
389 struct route_table *table;
390 struct route_node *rn;
391 struct route_entry *re;
392 afi_t afi;
393
394 /* Uninstall label forwarding entry, if previously installed. */
395 if (old_label != MPLS_INVALID_LABEL
396 && old_label != MPLS_LABEL_IMPLICIT_NULL)
397 lsp_uninstall(zvrf, old_label);
398
399 /* Install label forwarding entry corr. to new label, if needed. */
400 if (fec->label == MPLS_INVALID_LABEL
401 || fec->label == MPLS_LABEL_IMPLICIT_NULL)
402 return 0;
403
404 afi = family2afi(PREFIX_FAMILY(&fec->rn->p));
405 table = zebra_vrf_table(afi, SAFI_UNICAST, zvrf_id(zvrf));
406 if (!table)
407 return 0;
408
409 /* See if labeled route exists. */
410 rn = route_node_lookup(table, &fec->rn->p);
411 if (!rn)
412 return 0;
413
414 RNODE_FOREACH_RE (rn, re) {
415 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
416 break;
417 }
418
419 if (!re || !zebra_rib_labeled_unicast(re))
420 return 0;
421
422 if (lsp_install(zvrf, fec->label, rn, re))
423 return -1;
424
425 return 0;
426 }
427
428 /*
429 * Inform about FEC to a registered client.
430 */
431 static int fec_send(struct zebra_fec *fec, struct zserv *client)
432 {
433 struct stream *s;
434 struct route_node *rn;
435
436 rn = fec->rn;
437
438 /* Get output stream. */
439 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
440
441 zclient_create_header(s, ZEBRA_FEC_UPDATE, VRF_DEFAULT);
442
443 stream_putw(s, rn->p.family);
444 stream_put_prefix(s, &rn->p);
445 stream_putl(s, fec->label);
446 stream_putw_at(s, 0, stream_get_endp(s));
447 return zserv_send_message(client, s);
448 }
449
450 /*
451 * Update all registered clients about this FEC. Caller should've updated
452 * FEC and ensure no duplicate updates.
453 */
454 static void fec_update_clients(struct zebra_fec *fec)
455 {
456 struct listnode *node;
457 struct zserv *client;
458
459 for (ALL_LIST_ELEMENTS_RO(fec->client_list, node, client)) {
460 if (IS_ZEBRA_DEBUG_MPLS)
461 zlog_debug("Update client %s",
462 zebra_route_string(client->proto));
463 fec_send(fec, client);
464 }
465 }
466
467
468 /*
469 * Print a FEC-label binding entry.
470 */
471 static void fec_print(struct zebra_fec *fec, struct vty *vty)
472 {
473 struct route_node *rn;
474 struct listnode *node;
475 struct zserv *client;
476 char buf[BUFSIZ];
477
478 rn = fec->rn;
479 vty_out(vty, "%pRN\n", rn);
480 vty_out(vty, " Label: %s", label2str(fec->label, 0, buf, BUFSIZ));
481 if (fec->label_index != MPLS_INVALID_LABEL_INDEX)
482 vty_out(vty, ", Label Index: %u", fec->label_index);
483 vty_out(vty, "\n");
484 if (!list_isempty(fec->client_list)) {
485 vty_out(vty, " Client list:");
486 for (ALL_LIST_ELEMENTS_RO(fec->client_list, node, client))
487 vty_out(vty, " %s(fd %d)",
488 zebra_route_string(client->proto),
489 client->sock);
490 vty_out(vty, "\n");
491 }
492 }
493
494 /*
495 * Locate FEC-label binding that matches with passed info.
496 */
497 static struct zebra_fec *fec_find(struct route_table *table, struct prefix *p)
498 {
499 struct route_node *rn;
500
501 apply_mask(p);
502 rn = route_node_lookup(table, p);
503 if (!rn)
504 return NULL;
505
506 route_unlock_node(rn);
507 return (rn->info);
508 }
509
510 /*
511 * Add a FEC. This may be upon a client registering for a binding
512 * or when a binding is configured.
513 */
514 static struct zebra_fec *fec_add(struct route_table *table, struct prefix *p,
515 mpls_label_t label, uint32_t flags,
516 uint32_t label_index)
517 {
518 struct route_node *rn;
519 struct zebra_fec *fec;
520
521 apply_mask(p);
522
523 /* Lookup (or add) route node.*/
524 rn = route_node_get(table, p);
525 if (!rn)
526 return NULL;
527
528 fec = rn->info;
529
530 if (!fec) {
531 fec = XCALLOC(MTYPE_FEC, sizeof(struct zebra_fec));
532
533 rn->info = fec;
534 fec->rn = rn;
535 fec->label = label;
536 fec->client_list = list_new();
537 } else
538 route_unlock_node(rn); /* for the route_node_get */
539
540 fec->label_index = label_index;
541 fec->flags = flags;
542
543 return fec;
544 }
545
546 /*
547 * Delete a FEC. This may be upon the last client deregistering for
548 * a FEC and no binding exists or when the binding is deleted and there
549 * are no registered clients.
550 */
551 static int fec_del(struct zebra_fec *fec)
552 {
553 list_delete(&fec->client_list);
554 fec->rn->info = NULL;
555 route_unlock_node(fec->rn);
556 XFREE(MTYPE_FEC, fec);
557 return 0;
558 }
559
560 /*
561 * Hash function for label.
562 */
563 static unsigned int label_hash(const void *p)
564 {
565 const struct zebra_ile *ile = p;
566
567 return (jhash_1word(ile->in_label, 0));
568 }
569
570 /*
571 * Compare 2 LSP hash entries based on in-label.
572 */
573 static bool label_cmp(const void *p1, const void *p2)
574 {
575 const struct zebra_ile *ile1 = p1;
576 const struct zebra_ile *ile2 = p2;
577
578 return (ile1->in_label == ile2->in_label);
579 }
580
581 /*
582 * Check if an IPv4 nexthop for a NHLFE is active. Update nexthop based on
583 * the passed flag.
584 * NOTE: Looking only for connected routes right now.
585 */
586 static int nhlfe_nexthop_active_ipv4(struct zebra_nhlfe *nhlfe,
587 struct nexthop *nexthop)
588 {
589 struct route_table *table;
590 struct prefix_ipv4 p;
591 struct route_node *rn;
592 struct route_entry *match;
593 struct nexthop *match_nh;
594
595 table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, nexthop->vrf_id);
596 if (!table)
597 return 0;
598
599 /* Lookup nexthop in IPv4 routing table. */
600 memset(&p, 0, sizeof(p));
601 p.family = AF_INET;
602 p.prefixlen = IPV4_MAX_BITLEN;
603 p.prefix = nexthop->gate.ipv4;
604
605 rn = route_node_match(table, (struct prefix *)&p);
606 if (!rn)
607 return 0;
608
609 route_unlock_node(rn);
610
611 /* Locate a valid connected route. */
612 RNODE_FOREACH_RE (rn, match) {
613 if (CHECK_FLAG(match->status, ROUTE_ENTRY_REMOVED)
614 || !CHECK_FLAG(match->flags, ZEBRA_FLAG_SELECTED))
615 continue;
616
617 for (match_nh = match->nhe->nhg.nexthop; match_nh;
618 match_nh = match_nh->next) {
619 if (match->type == ZEBRA_ROUTE_CONNECT
620 || nexthop->ifindex == match_nh->ifindex) {
621 nexthop->ifindex = match_nh->ifindex;
622 return 1;
623 }
624 }
625 }
626
627 return 0;
628 }
629
630
631 /*
632 * Check if an IPv6 nexthop for a NHLFE is active. Update nexthop based on
633 * the passed flag.
634 * NOTE: Looking only for connected routes right now.
635 */
636 static int nhlfe_nexthop_active_ipv6(struct zebra_nhlfe *nhlfe,
637 struct nexthop *nexthop)
638 {
639 struct route_table *table;
640 struct prefix_ipv6 p;
641 struct route_node *rn;
642 struct route_entry *match;
643
644 table = zebra_vrf_table(AFI_IP6, SAFI_UNICAST, nexthop->vrf_id);
645 if (!table)
646 return 0;
647
648 /* Lookup nexthop in IPv6 routing table. */
649 memset(&p, 0, sizeof(p));
650 p.family = AF_INET6;
651 p.prefixlen = IPV6_MAX_BITLEN;
652 p.prefix = nexthop->gate.ipv6;
653
654 rn = route_node_match(table, (struct prefix *)&p);
655 if (!rn)
656 return 0;
657
658 route_unlock_node(rn);
659
660 /* Locate a valid connected route. */
661 RNODE_FOREACH_RE (rn, match) {
662 if ((match->type == ZEBRA_ROUTE_CONNECT)
663 && !CHECK_FLAG(match->status, ROUTE_ENTRY_REMOVED)
664 && CHECK_FLAG(match->flags, ZEBRA_FLAG_SELECTED))
665 break;
666 }
667
668 if (!match || !match->nhe->nhg.nexthop)
669 return 0;
670
671 nexthop->ifindex = match->nhe->nhg.nexthop->ifindex;
672 return 1;
673 }
674
675
676 /*
677 * Check the nexthop reachability for a NHLFE and return if valid (reachable)
678 * or not.
679 * NOTE: Each NHLFE points to only 1 nexthop.
680 */
681 static int nhlfe_nexthop_active(struct zebra_nhlfe *nhlfe)
682 {
683 struct nexthop *nexthop;
684 struct interface *ifp;
685 struct zebra_ns *zns;
686
687 nexthop = nhlfe->nexthop;
688 if (!nexthop) // unexpected
689 return 0;
690
691 /* Check on nexthop based on type. */
692 switch (nexthop->type) {
693 case NEXTHOP_TYPE_IFINDEX:
694 /*
695 * Lookup if this type is special. The
696 * NEXTHOP_TYPE_IFINDEX is a pop and
697 * forward into a different table for
698 * processing. As such this ifindex
699 * passed to us may be a VRF device
700 * which will not be in the default
701 * VRF. So let's look in all of them
702 */
703 zns = zebra_ns_lookup(NS_DEFAULT);
704 ifp = if_lookup_by_index_per_ns(zns, nexthop->ifindex);
705 if (ifp && if_is_operative(ifp))
706 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
707 else
708 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
709 break;
710 case NEXTHOP_TYPE_IPV4:
711 case NEXTHOP_TYPE_IPV4_IFINDEX:
712 if (nhlfe_nexthop_active_ipv4(nhlfe, nexthop))
713 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
714 else
715 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
716 break;
717
718 case NEXTHOP_TYPE_IPV6:
719 if (nhlfe_nexthop_active_ipv6(nhlfe, nexthop))
720 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
721 else
722 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
723 break;
724
725 case NEXTHOP_TYPE_IPV6_IFINDEX:
726 if (IN6_IS_ADDR_LINKLOCAL(&nexthop->gate.ipv6)) {
727 ifp = if_lookup_by_index(nexthop->ifindex,
728 nexthop->vrf_id);
729 if (ifp && if_is_operative(ifp))
730 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
731 else
732 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
733 } else {
734 if (nhlfe_nexthop_active_ipv6(nhlfe, nexthop))
735 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
736 else
737 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
738 }
739 break;
740
741 case NEXTHOP_TYPE_BLACKHOLE:
742 break;
743 }
744
745 return CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
746 }
747
748 /*
749 * Walk through NHLFEs for a LSP forwarding entry, verify nexthop
750 * reachability and select the best. Multipath entries are also
751 * marked. This is invoked when an LSP scheduled for processing (due
752 * to some change) is examined.
753 */
754 static void lsp_select_best_nhlfe(struct zebra_lsp *lsp)
755 {
756 struct zebra_nhlfe *nhlfe;
757 struct zebra_nhlfe *best;
758 struct nexthop *nexthop;
759 int changed = 0;
760
761 if (!lsp)
762 return;
763
764 best = NULL;
765 lsp->num_ecmp = 0;
766 UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
767
768 /*
769 * First compute the best path, after checking nexthop status. We are
770 * only concerned with non-deleted NHLFEs.
771 */
772 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
773 /* Clear selection flags. */
774 UNSET_FLAG(nhlfe->flags,
775 (NHLFE_FLAG_SELECTED | NHLFE_FLAG_MULTIPATH));
776
777 if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED)
778 && nhlfe_nexthop_active(nhlfe)) {
779 if (!best || (nhlfe->distance < best->distance))
780 best = nhlfe;
781 }
782 }
783
784 lsp->best_nhlfe = best;
785 if (!lsp->best_nhlfe)
786 return;
787
788 /*
789 * Check the active status of backup nhlfes also
790 */
791 frr_each_safe(nhlfe_list, &lsp->backup_nhlfe_list, nhlfe) {
792 if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
793 (void)nhlfe_nexthop_active(nhlfe);
794 }
795
796 /* Mark best NHLFE as selected. */
797 SET_FLAG(lsp->best_nhlfe->flags, NHLFE_FLAG_SELECTED);
798
799 /*
800 * If best path exists, see if there is ECMP. While doing this, note if
801 * a
802 * new (uninstalled) NHLFE has been selected, an installed entry that is
803 * still selected has a change or an installed entry is to be removed.
804 */
805 frr_each(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
806 int nh_chg, nh_sel, nh_inst;
807
808 nexthop = nhlfe->nexthop;
809 if (!nexthop) // unexpected
810 continue;
811
812 if (!CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED)
813 && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)
814 && (nhlfe->distance == lsp->best_nhlfe->distance)) {
815 SET_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED);
816 SET_FLAG(nhlfe->flags, NHLFE_FLAG_MULTIPATH);
817 lsp->num_ecmp++;
818 }
819
820 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED) && !changed) {
821 nh_chg = CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
822 nh_sel = CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED);
823 nh_inst =
824 CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
825
826 if ((nh_sel && !nh_inst)
827 || (nh_sel && nh_inst && nh_chg)
828 || (nh_inst && !nh_sel))
829 changed = 1;
830 }
831
832 /* We have finished examining, clear changed flag. */
833 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
834 }
835
836 if (changed)
837 SET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
838 }
839
840 /*
841 * Delete LSP forwarding entry from kernel, if installed. Called upon
842 * process exit.
843 */
844 static void lsp_uninstall_from_kernel(struct hash_bucket *bucket, void *ctxt)
845 {
846 struct zebra_lsp *lsp;
847
848 lsp = (struct zebra_lsp *)bucket->data;
849 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
850 (void)dplane_lsp_delete(lsp);
851 }
852
853 /*
854 * Schedule LSP forwarding entry for processing. Called upon changes
855 * that may impact LSPs such as nexthop / connected route changes.
856 */
857 static void lsp_schedule(struct hash_bucket *bucket, void *ctxt)
858 {
859 struct zebra_lsp *lsp;
860
861 lsp = (struct zebra_lsp *)bucket->data;
862
863 /* In the common flow, this is used when external events occur. For
864 * LSPs with backup nhlfes, we'll assume that the forwarding
865 * plane will use the backups to handle these events, until the
866 * owning protocol can react.
867 */
868 if (ctxt == NULL) {
869 /* Skip LSPs with backups */
870 if (nhlfe_list_first(&lsp->backup_nhlfe_list) != NULL) {
871 if (IS_ZEBRA_DEBUG_MPLS_DETAIL)
872 zlog_debug("%s: skip LSP in-label %u",
873 __func__, lsp->ile.in_label);
874 return;
875 }
876 }
877
878 (void)lsp_processq_add(lsp);
879 }
880
881 /*
882 * Process a LSP entry that is in the queue. Recalculate best NHLFE and
883 * any multipaths and update or delete from the kernel, as needed.
884 */
885 static wq_item_status lsp_process(struct work_queue *wq, void *data)
886 {
887 struct zebra_lsp *lsp;
888 struct zebra_nhlfe *oldbest, *newbest;
889 char buf[BUFSIZ], buf2[BUFSIZ];
890 struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
891 enum zebra_dplane_result res;
892
893 lsp = (struct zebra_lsp *)data;
894 if (!lsp) // unexpected
895 return WQ_SUCCESS;
896
897 oldbest = lsp->best_nhlfe;
898
899 /* Select best NHLFE(s) */
900 lsp_select_best_nhlfe(lsp);
901
902 newbest = lsp->best_nhlfe;
903
904 if (IS_ZEBRA_DEBUG_MPLS) {
905 if (oldbest)
906 nhlfe2str(oldbest, buf, sizeof(buf));
907 if (newbest)
908 nhlfe2str(newbest, buf2, sizeof(buf2));
909 zlog_debug(
910 "Process LSP in-label %u oldbest %s newbest %s flags 0x%x ecmp# %d",
911 lsp->ile.in_label, oldbest ? buf : "NULL",
912 newbest ? buf2 : "NULL", lsp->flags, lsp->num_ecmp);
913 }
914
915 if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
916 /* Not already installed */
917 if (newbest) {
918
919 UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
920
921 switch (dplane_lsp_add(lsp)) {
922 case ZEBRA_DPLANE_REQUEST_QUEUED:
923 /* Set 'installed' flag so we will know
924 * that an install is in-flight.
925 */
926 SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
927
928 zvrf->lsp_installs_queued++;
929 break;
930 case ZEBRA_DPLANE_REQUEST_FAILURE:
931 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
932 "LSP Install Failure: %u",
933 lsp->ile.in_label);
934 break;
935 case ZEBRA_DPLANE_REQUEST_SUCCESS:
936 zvrf->lsp_installs++;
937 break;
938 }
939 }
940 } else {
941 /* Installed, may need an update and/or delete. */
942 if (!newbest) {
943 res = dplane_lsp_delete(lsp);
944
945 /* We do some of the lsp cleanup immediately for
946 * deletes.
947 */
948 UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
949 clear_nhlfe_installed(lsp);
950
951 switch (res) {
952 case ZEBRA_DPLANE_REQUEST_QUEUED:
953 zvrf->lsp_removals_queued++;
954 break;
955 case ZEBRA_DPLANE_REQUEST_FAILURE:
956 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE,
957 "LSP Deletion Failure: %u",
958 lsp->ile.in_label);
959 break;
960 case ZEBRA_DPLANE_REQUEST_SUCCESS:
961 zvrf->lsp_removals++;
962 break;
963 }
964 } else if (CHECK_FLAG(lsp->flags, LSP_FLAG_CHANGED)) {
965 struct zebra_nhlfe *nhlfe;
966 struct nexthop *nexthop;
967
968 UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
969
970 /* We leave the INSTALLED flag set here
971 * so we know an update is in-flight.
972 */
973
974 /*
975 * Any NHLFE that was installed but is not
976 * selected now needs to have its flags updated.
977 */
978 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
979 nexthop = nhlfe->nexthop;
980 if (!nexthop)
981 continue;
982
983 if (CHECK_FLAG(nhlfe->flags,
984 NHLFE_FLAG_INSTALLED)
985 && !CHECK_FLAG(nhlfe->flags,
986 NHLFE_FLAG_SELECTED)) {
987 UNSET_FLAG(nhlfe->flags,
988 NHLFE_FLAG_INSTALLED);
989 UNSET_FLAG(nexthop->flags,
990 NEXTHOP_FLAG_FIB);
991 }
992 }
993
994 switch (dplane_lsp_update(lsp)) {
995 case ZEBRA_DPLANE_REQUEST_QUEUED:
996 zvrf->lsp_installs_queued++;
997 break;
998 case ZEBRA_DPLANE_REQUEST_FAILURE:
999 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
1000 "LSP Update Failure: %u",
1001 lsp->ile.in_label);
1002 break;
1003 case ZEBRA_DPLANE_REQUEST_SUCCESS:
1004 zvrf->lsp_installs++;
1005 break;
1006 }
1007 }
1008 }
1009
1010 return WQ_SUCCESS;
1011 }
1012
1013
1014 /*
1015 * Callback upon processing completion of a LSP forwarding entry.
1016 */
1017 static void lsp_processq_del(struct work_queue *wq, void *data)
1018 {
1019 struct zebra_vrf *zvrf;
1020 struct zebra_lsp *lsp;
1021 struct hash *lsp_table;
1022 struct zebra_nhlfe *nhlfe;
1023
1024 /* If zebra is shutting down, don't delete any structs,
1025 * just ignore this callback. The LSPs will be cleaned up
1026 * during the shutdown processing.
1027 */
1028 if (zebra_router_in_shutdown())
1029 return;
1030
1031 zvrf = vrf_info_lookup(VRF_DEFAULT);
1032 assert(zvrf);
1033
1034 lsp_table = zvrf->lsp_table;
1035 if (!lsp_table) // unexpected
1036 return;
1037
1038 lsp = (struct zebra_lsp *)data;
1039 if (!lsp) // unexpected
1040 return;
1041
1042 /* Clear flag, remove any NHLFEs marked for deletion. If no NHLFEs
1043 * exist,
1044 * delete LSP entry also.
1045 */
1046 UNSET_FLAG(lsp->flags, LSP_FLAG_SCHEDULED);
1047
1048 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
1049 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
1050 nhlfe_del(nhlfe);
1051 }
1052
1053 frr_each_safe(nhlfe_list, &lsp->backup_nhlfe_list, nhlfe) {
1054 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED))
1055 nhlfe_del(nhlfe);
1056 }
1057
1058 lsp_check_free(lsp_table, &lsp);
1059 }
1060
1061 /*
1062 * Callback upon finishing the processing of all scheduled
1063 * LSP forwarding entries.
1064 */
1065 static void lsp_processq_complete(struct work_queue *wq)
1066 {
1067 /* Nothing to do for now. */
1068 }
1069
1070 /*
1071 * Add LSP forwarding entry to queue for subsequent processing.
1072 */
1073 static int lsp_processq_add(struct zebra_lsp *lsp)
1074 {
1075 /* If already scheduled, exit. */
1076 if (CHECK_FLAG(lsp->flags, LSP_FLAG_SCHEDULED))
1077 return 0;
1078
1079 if (zrouter.lsp_process_q == NULL) {
1080 flog_err(EC_ZEBRA_WQ_NONEXISTENT,
1081 "%s: work_queue does not exist!", __func__);
1082 return -1;
1083 }
1084
1085 work_queue_add(zrouter.lsp_process_q, lsp);
1086 SET_FLAG(lsp->flags, LSP_FLAG_SCHEDULED);
1087 return 0;
1088 }
1089
1090 /*
1091 * Callback to allocate LSP forwarding table entry.
1092 */
1093 static void *lsp_alloc(void *p)
1094 {
1095 const struct zebra_ile *ile = p;
1096 struct zebra_lsp *lsp;
1097
1098 lsp = XCALLOC(MTYPE_LSP, sizeof(struct zebra_lsp));
1099 lsp->ile = *ile;
1100 nhlfe_list_init(&lsp->nhlfe_list);
1101 nhlfe_list_init(&lsp->backup_nhlfe_list);
1102
1103 if (IS_ZEBRA_DEBUG_MPLS)
1104 zlog_debug("Alloc LSP in-label %u", lsp->ile.in_label);
1105
1106 return ((void *)lsp);
1107 }
1108
1109 /*
1110 * Check whether lsp can be freed - no nhlfes, e.g., and call free api
1111 */
1112 static void lsp_check_free(struct hash *lsp_table, struct zebra_lsp **plsp)
1113 {
1114 struct zebra_lsp *lsp;
1115
1116 if (plsp == NULL || *plsp == NULL)
1117 return;
1118
1119 lsp = *plsp;
1120
1121 if ((nhlfe_list_first(&lsp->nhlfe_list) == NULL) &&
1122 (nhlfe_list_first(&lsp->backup_nhlfe_list) == NULL) &&
1123 !CHECK_FLAG(lsp->flags, LSP_FLAG_SCHEDULED))
1124 lsp_free(lsp_table, plsp);
1125 }
1126
1127 static void lsp_free_nhlfe(struct zebra_lsp *lsp)
1128 {
1129 struct zebra_nhlfe *nhlfe;
1130
1131 while ((nhlfe = nhlfe_list_first(&lsp->nhlfe_list))) {
1132 nhlfe_list_del(&lsp->nhlfe_list, nhlfe);
1133 nhlfe_free(nhlfe);
1134 }
1135
1136 while ((nhlfe = nhlfe_list_first(&lsp->backup_nhlfe_list))) {
1137 nhlfe_list_del(&lsp->backup_nhlfe_list, nhlfe);
1138 nhlfe_free(nhlfe);
1139 }
1140 }
1141
1142 /*
1143 * Dtor for an LSP: remove from ile hash, release any internal allocations,
1144 * free LSP object.
1145 */
1146 static void lsp_free(struct hash *lsp_table, struct zebra_lsp **plsp)
1147 {
1148 struct zebra_lsp *lsp;
1149
1150 if (plsp == NULL || *plsp == NULL)
1151 return;
1152
1153 lsp = *plsp;
1154
1155 if (IS_ZEBRA_DEBUG_MPLS)
1156 zlog_debug("Free LSP in-label %u flags 0x%x",
1157 lsp->ile.in_label, lsp->flags);
1158
1159 lsp_free_nhlfe(lsp);
1160
1161 hash_release(lsp_table, &lsp->ile);
1162 XFREE(MTYPE_LSP, lsp);
1163
1164 *plsp = NULL;
1165 }
1166
1167 /*
1168 * Create printable string for NHLFE entry.
1169 */
1170 static char *nhlfe2str(const struct zebra_nhlfe *nhlfe, char *buf, int size)
1171 {
1172 const struct nexthop *nexthop;
1173
1174 buf[0] = '\0';
1175 nexthop = nhlfe->nexthop;
1176 switch (nexthop->type) {
1177 case NEXTHOP_TYPE_IPV4:
1178 case NEXTHOP_TYPE_IPV4_IFINDEX:
1179 inet_ntop(AF_INET, &nexthop->gate.ipv4, buf, size);
1180 break;
1181 case NEXTHOP_TYPE_IPV6:
1182 case NEXTHOP_TYPE_IPV6_IFINDEX:
1183 inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf, size);
1184 break;
1185 case NEXTHOP_TYPE_IFINDEX:
1186 snprintf(buf, size, "Ifindex: %u", nexthop->ifindex);
1187 case NEXTHOP_TYPE_BLACKHOLE:
1188 break;
1189 }
1190
1191 return buf;
1192 }
1193
1194 /*
1195 * Check if NHLFE matches with search info passed.
1196 */
1197 static int nhlfe_nhop_match(struct zebra_nhlfe *nhlfe,
1198 enum nexthop_types_t gtype,
1199 const union g_addr *gate, ifindex_t ifindex)
1200 {
1201 struct nexthop *nhop;
1202 int cmp = 1;
1203
1204 nhop = nhlfe->nexthop;
1205 if (!nhop)
1206 return 1;
1207
1208 if (nhop->type != gtype)
1209 return 1;
1210
1211 switch (nhop->type) {
1212 case NEXTHOP_TYPE_IPV4:
1213 case NEXTHOP_TYPE_IPV4_IFINDEX:
1214 cmp = memcmp(&(nhop->gate.ipv4), &(gate->ipv4),
1215 sizeof(struct in_addr));
1216 if (!cmp && nhop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1217 cmp = !(nhop->ifindex == ifindex);
1218 break;
1219 case NEXTHOP_TYPE_IPV6:
1220 case NEXTHOP_TYPE_IPV6_IFINDEX:
1221 cmp = memcmp(&(nhop->gate.ipv6), &(gate->ipv6),
1222 sizeof(struct in6_addr));
1223 if (!cmp && nhop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1224 cmp = !(nhop->ifindex == ifindex);
1225 break;
1226 case NEXTHOP_TYPE_IFINDEX:
1227 cmp = !(nhop->ifindex == ifindex);
1228 break;
1229 case NEXTHOP_TYPE_BLACKHOLE:
1230 break;
1231 }
1232
1233 return cmp;
1234 }
1235
1236
1237 /*
1238 * Locate NHLFE that matches with passed info.
1239 */
1240 static struct zebra_nhlfe *nhlfe_find(struct nhlfe_list_head *list,
1241 enum lsp_types_t lsp_type,
1242 enum nexthop_types_t gtype,
1243 const union g_addr *gate,
1244 ifindex_t ifindex)
1245 {
1246 struct zebra_nhlfe *nhlfe;
1247
1248 frr_each_safe(nhlfe_list, list, nhlfe) {
1249 if (nhlfe->type != lsp_type)
1250 continue;
1251 if (!nhlfe_nhop_match(nhlfe, gtype, gate, ifindex))
1252 break;
1253 }
1254
1255 return nhlfe;
1256 }
1257
1258 /*
1259 * Allocate and init new NHLFE.
1260 */
1261 static struct zebra_nhlfe *
1262 nhlfe_alloc(struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
1263 enum nexthop_types_t gtype, const union g_addr *gate,
1264 ifindex_t ifindex, uint8_t num_labels, const mpls_label_t *labels)
1265 {
1266 struct zebra_nhlfe *nhlfe;
1267 struct nexthop *nexthop;
1268
1269 assert(lsp);
1270
1271 nhlfe = XCALLOC(MTYPE_NHLFE, sizeof(struct zebra_nhlfe));
1272
1273 nhlfe->lsp = lsp;
1274 nhlfe->type = lsp_type;
1275 nhlfe->distance = lsp_distance(lsp_type);
1276
1277 nexthop = nexthop_new();
1278
1279 nexthop_add_labels(nexthop, lsp_type, num_labels, labels);
1280
1281 nexthop->vrf_id = VRF_DEFAULT;
1282 nexthop->type = gtype;
1283 switch (nexthop->type) {
1284 case NEXTHOP_TYPE_IPV4:
1285 case NEXTHOP_TYPE_IPV4_IFINDEX:
1286 nexthop->gate.ipv4 = gate->ipv4;
1287 if (ifindex)
1288 nexthop->ifindex = ifindex;
1289 break;
1290 case NEXTHOP_TYPE_IPV6:
1291 case NEXTHOP_TYPE_IPV6_IFINDEX:
1292 nexthop->gate.ipv6 = gate->ipv6;
1293 if (ifindex)
1294 nexthop->ifindex = ifindex;
1295 break;
1296 case NEXTHOP_TYPE_IFINDEX:
1297 nexthop->ifindex = ifindex;
1298 break;
1299 case NEXTHOP_TYPE_BLACKHOLE:
1300 if (IS_ZEBRA_DEBUG_MPLS)
1301 zlog_debug("%s: invalid: blackhole nexthop", __func__);
1302
1303 nexthop_free(nexthop);
1304 XFREE(MTYPE_NHLFE, nhlfe);
1305 return NULL;
1306 }
1307 nhlfe->nexthop = nexthop;
1308
1309 return nhlfe;
1310 }
1311
1312 /*
1313 * Add primary or backup NHLFE. Base entry must have been created and
1314 * duplicate check done.
1315 */
1316 static struct zebra_nhlfe *nhlfe_add(struct zebra_lsp *lsp,
1317 enum lsp_types_t lsp_type,
1318 enum nexthop_types_t gtype,
1319 const union g_addr *gate,
1320 ifindex_t ifindex, uint8_t num_labels,
1321 const mpls_label_t *labels, bool is_backup)
1322 {
1323 struct zebra_nhlfe *nhlfe;
1324
1325 if (!lsp)
1326 return NULL;
1327
1328 /* Must have labels */
1329 if (num_labels == 0 || labels == NULL) {
1330 if (IS_ZEBRA_DEBUG_MPLS)
1331 zlog_debug("%s: invalid nexthop: no labels", __func__);
1332
1333 return NULL;
1334 }
1335
1336 /* Allocate new object */
1337 nhlfe = nhlfe_alloc(lsp, lsp_type, gtype, gate, ifindex, num_labels,
1338 labels);
1339
1340 if (!nhlfe)
1341 return NULL;
1342
1343 /* Enqueue to LSP: primaries at head of list, backups at tail */
1344 if (is_backup) {
1345 SET_FLAG(nhlfe->flags, NHLFE_FLAG_IS_BACKUP);
1346 nhlfe_list_add_tail(&lsp->backup_nhlfe_list, nhlfe);
1347 } else
1348 nhlfe_list_add_head(&lsp->nhlfe_list, nhlfe);
1349
1350 return nhlfe;
1351 }
1352
1353 /*
1354 * Common delete for NHLFEs.
1355 */
1356 static void nhlfe_free(struct zebra_nhlfe *nhlfe)
1357 {
1358 if (!nhlfe)
1359 return;
1360
1361 /* Free nexthop. */
1362 if (nhlfe->nexthop)
1363 nexthop_free(nhlfe->nexthop);
1364
1365 nhlfe->nexthop = NULL;
1366
1367 XFREE(MTYPE_NHLFE, nhlfe);
1368 }
1369
1370
1371 /*
1372 * Disconnect NHLFE from LSP, and free. Entry must be present on LSP's list.
1373 */
1374 static int nhlfe_del(struct zebra_nhlfe *nhlfe)
1375 {
1376 struct zebra_lsp *lsp;
1377
1378 if (!nhlfe)
1379 return -1;
1380
1381 lsp = nhlfe->lsp;
1382 if (!lsp)
1383 return -1;
1384
1385 if (nhlfe == lsp->best_nhlfe)
1386 lsp->best_nhlfe = NULL;
1387
1388 /* Unlink from LSP */
1389 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_IS_BACKUP))
1390 nhlfe_list_del(&lsp->backup_nhlfe_list, nhlfe);
1391 else
1392 nhlfe_list_del(&lsp->nhlfe_list, nhlfe);
1393
1394 nhlfe->lsp = NULL;
1395
1396 nhlfe_free(nhlfe);
1397
1398 return 0;
1399 }
1400
1401 /*
1402 * Update label for NHLFE entry.
1403 */
1404 static void nhlfe_out_label_update(struct zebra_nhlfe *nhlfe,
1405 struct mpls_label_stack *nh_label)
1406 {
1407 nhlfe->nexthop->nh_label->label[0] = nh_label->label[0];
1408 }
1409
1410 static int mpls_lsp_uninstall_all(struct hash *lsp_table, struct zebra_lsp *lsp,
1411 enum lsp_types_t type)
1412 {
1413 struct zebra_nhlfe *nhlfe;
1414 int schedule_lsp = 0;
1415 char buf[BUFSIZ];
1416
1417 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
1418 schedule_lsp = 1;
1419
1420 /* Mark NHLFEs for delete or directly delete, as appropriate. */
1421 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
1422 /* Skip non-static NHLFEs */
1423 if (nhlfe->type != type)
1424 continue;
1425
1426 if (IS_ZEBRA_DEBUG_MPLS) {
1427 nhlfe2str(nhlfe, buf, sizeof(buf));
1428 zlog_debug(
1429 "Del LSP in-label %u type %d nexthop %s flags 0x%x",
1430 lsp->ile.in_label, type, buf, nhlfe->flags);
1431 }
1432
1433 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED)) {
1434 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
1435 SET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
1436 schedule_lsp = 1;
1437 } else {
1438 nhlfe_del(nhlfe);
1439 }
1440 }
1441
1442 frr_each_safe(nhlfe_list, &lsp->backup_nhlfe_list, nhlfe) {
1443 /* Skip non-static NHLFEs */
1444 if (nhlfe->type != type)
1445 continue;
1446
1447 if (IS_ZEBRA_DEBUG_MPLS) {
1448 nhlfe2str(nhlfe, buf, sizeof(buf));
1449 zlog_debug(
1450 "Del backup LSP in-label %u type %d nexthop %s flags 0x%x",
1451 lsp->ile.in_label, type, buf, nhlfe->flags);
1452 }
1453
1454 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED)) {
1455 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
1456 SET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
1457 schedule_lsp = 1;
1458 } else {
1459 nhlfe_del(nhlfe);
1460 }
1461 }
1462
1463 /* Queue LSP for processing, if needed, else delete. */
1464 if (schedule_lsp) {
1465 if (IS_ZEBRA_DEBUG_MPLS) {
1466 zlog_debug("Schedule LSP in-label %u flags 0x%x",
1467 lsp->ile.in_label, lsp->flags);
1468 }
1469 if (lsp_processq_add(lsp))
1470 return -1;
1471 } else {
1472 lsp_check_free(lsp_table, &lsp);
1473 }
1474
1475 return 0;
1476 }
1477
1478 /*
1479 * Uninstall all static NHLFEs for a particular LSP forwarding entry.
1480 * If no other NHLFEs exist, the entry would be deleted.
1481 */
1482 static int mpls_static_lsp_uninstall_all(struct zebra_vrf *zvrf,
1483 mpls_label_t in_label)
1484 {
1485 struct hash *lsp_table;
1486 struct zebra_ile tmp_ile;
1487 struct zebra_lsp *lsp;
1488
1489 /* Lookup table. */
1490 lsp_table = zvrf->lsp_table;
1491 if (!lsp_table)
1492 return -1;
1493
1494 /* If entry is not present, exit. */
1495 tmp_ile.in_label = in_label;
1496 lsp = hash_lookup(lsp_table, &tmp_ile);
1497 if (!lsp || (nhlfe_list_first(&lsp->nhlfe_list) == NULL))
1498 return 0;
1499
1500 return mpls_lsp_uninstall_all(lsp_table, lsp, ZEBRA_LSP_STATIC);
1501 }
1502
1503 static json_object *nhlfe_json(struct zebra_nhlfe *nhlfe)
1504 {
1505 json_object *json_nhlfe = NULL;
1506 json_object *json_backups = NULL;
1507 json_object *json_label_stack;
1508 struct nexthop *nexthop = nhlfe->nexthop;
1509 int i;
1510
1511 json_nhlfe = json_object_new_object();
1512 json_object_string_add(json_nhlfe, "type", nhlfe_type2str(nhlfe->type));
1513 json_object_int_add(json_nhlfe, "outLabel",
1514 nexthop->nh_label->label[0]);
1515
1516 json_label_stack = json_object_new_array();
1517 json_object_object_add(json_nhlfe, "outLabelStack", json_label_stack);
1518 for (i = 0; i < nexthop->nh_label->num_labels; i++)
1519 json_object_array_add(
1520 json_label_stack,
1521 json_object_new_int(nexthop->nh_label->label[i]));
1522
1523 json_object_int_add(json_nhlfe, "distance", nhlfe->distance);
1524
1525 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED))
1526 json_object_boolean_true_add(json_nhlfe, "installed");
1527
1528 switch (nexthop->type) {
1529 case NEXTHOP_TYPE_IPV4:
1530 case NEXTHOP_TYPE_IPV4_IFINDEX:
1531 json_object_string_addf(json_nhlfe, "nexthop", "%pI4",
1532 &nexthop->gate.ipv4);
1533 break;
1534 case NEXTHOP_TYPE_IPV6:
1535 case NEXTHOP_TYPE_IPV6_IFINDEX:
1536 json_object_string_addf(json_nhlfe, "nexthop", "%pI6",
1537 &nexthop->gate.ipv6);
1538
1539 if (nexthop->ifindex)
1540 json_object_string_add(json_nhlfe, "interface",
1541 ifindex2ifname(nexthop->ifindex,
1542 nexthop->vrf_id));
1543 break;
1544 case NEXTHOP_TYPE_IFINDEX:
1545 if (nexthop->ifindex)
1546 json_object_string_add(json_nhlfe, "interface",
1547 ifindex2ifname(nexthop->ifindex,
1548 nexthop->vrf_id));
1549 break;
1550 case NEXTHOP_TYPE_BLACKHOLE:
1551 break;
1552 }
1553
1554 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP)) {
1555 json_backups = json_object_new_array();
1556 for (i = 0; i < nexthop->backup_num; i++) {
1557 json_object_array_add(
1558 json_backups,
1559 json_object_new_int(nexthop->backup_idx[i]));
1560 }
1561
1562 json_object_object_add(json_nhlfe, "backupIndex",
1563 json_backups);
1564 }
1565
1566 return json_nhlfe;
1567 }
1568
1569 /*
1570 * Print the NHLFE for a LSP forwarding entry.
1571 */
1572 static void nhlfe_print(struct zebra_nhlfe *nhlfe, struct vty *vty,
1573 const char *indent)
1574 {
1575 struct nexthop *nexthop;
1576 char buf[MPLS_LABEL_STRLEN];
1577
1578 nexthop = nhlfe->nexthop;
1579 if (!nexthop || !nexthop->nh_label) // unexpected
1580 return;
1581
1582 vty_out(vty, " type: %s remote label: %s distance: %d\n",
1583 nhlfe_type2str(nhlfe->type),
1584 mpls_label2str(nexthop->nh_label->num_labels,
1585 nexthop->nh_label->label, buf, sizeof(buf),
1586 nexthop->nh_label_type, 0),
1587 nhlfe->distance);
1588
1589 if (indent)
1590 vty_out(vty, "%s", indent);
1591
1592 switch (nexthop->type) {
1593 case NEXTHOP_TYPE_IPV4:
1594 case NEXTHOP_TYPE_IPV4_IFINDEX:
1595 vty_out(vty, " via %pI4", &nexthop->gate.ipv4);
1596 if (nexthop->ifindex)
1597 vty_out(vty, " dev %s",
1598 ifindex2ifname(nexthop->ifindex,
1599 nexthop->vrf_id));
1600 break;
1601 case NEXTHOP_TYPE_IPV6:
1602 case NEXTHOP_TYPE_IPV6_IFINDEX:
1603 vty_out(vty, " via %s",
1604 inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
1605 sizeof(buf)));
1606 if (nexthop->ifindex)
1607 vty_out(vty, " dev %s",
1608 ifindex2ifname(nexthop->ifindex,
1609 nexthop->vrf_id));
1610 break;
1611 case NEXTHOP_TYPE_IFINDEX:
1612 if (nexthop->ifindex)
1613 vty_out(vty, " dev %s",
1614 ifindex2ifname(nexthop->ifindex,
1615 nexthop->vrf_id));
1616 break;
1617 case NEXTHOP_TYPE_BLACKHOLE:
1618 break;
1619 }
1620 vty_out(vty, "%s",
1621 CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_IS_BACKUP) ? " (backup)"
1622 : "");
1623 vty_out(vty, "%s",
1624 CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED) ? " (installed)"
1625 : "");
1626 vty_out(vty, "\n");
1627 }
1628
1629 /*
1630 * Print an LSP forwarding entry.
1631 */
1632 static void lsp_print(struct vty *vty, struct zebra_lsp *lsp)
1633 {
1634 struct zebra_nhlfe *nhlfe, *backup;
1635 int i, j;
1636
1637 vty_out(vty, "Local label: %u%s\n", lsp->ile.in_label,
1638 CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED) ? " (installed)"
1639 : "");
1640
1641 frr_each(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
1642 nhlfe_print(nhlfe, vty, NULL);
1643
1644 if (nhlfe->nexthop == NULL ||
1645 !CHECK_FLAG(nhlfe->nexthop->flags,
1646 NEXTHOP_FLAG_HAS_BACKUP))
1647 continue;
1648
1649 /* Backup nhlfes: find backups in backup list */
1650
1651 for (j = 0; j < nhlfe->nexthop->backup_num; j++) {
1652 i = 0;
1653 backup = NULL;
1654 frr_each(nhlfe_list, &lsp->backup_nhlfe_list, backup) {
1655 if (i == nhlfe->nexthop->backup_idx[j])
1656 break;
1657 i++;
1658 }
1659
1660 if (backup) {
1661 vty_out(vty, " [backup %d]", i);
1662 nhlfe_print(backup, vty, " ");
1663 }
1664 }
1665 }
1666 }
1667
1668 /*
1669 * JSON objects for an LSP forwarding entry.
1670 */
1671 static json_object *lsp_json(struct zebra_lsp *lsp)
1672 {
1673 struct zebra_nhlfe *nhlfe = NULL;
1674 json_object *json = json_object_new_object();
1675 json_object *json_nhlfe_list = json_object_new_array();
1676
1677 json_object_int_add(json, "inLabel", lsp->ile.in_label);
1678
1679 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
1680 json_object_boolean_true_add(json, "installed");
1681
1682 frr_each(nhlfe_list, &lsp->nhlfe_list, nhlfe)
1683 json_object_array_add(json_nhlfe_list, nhlfe_json(nhlfe));
1684
1685 json_object_object_add(json, "nexthops", json_nhlfe_list);
1686 json_nhlfe_list = NULL;
1687
1688
1689 frr_each(nhlfe_list, &lsp->backup_nhlfe_list, nhlfe) {
1690 if (json_nhlfe_list == NULL)
1691 json_nhlfe_list = json_object_new_array();
1692
1693 json_object_array_add(json_nhlfe_list, nhlfe_json(nhlfe));
1694 }
1695
1696 if (json_nhlfe_list)
1697 json_object_object_add(json, "backupNexthops", json_nhlfe_list);
1698
1699 return json;
1700 }
1701
1702
1703 /* Return a sorted linked list of the hash contents */
1704 static struct list *hash_get_sorted_list(struct hash *hash, void *cmp)
1705 {
1706 unsigned int i;
1707 struct hash_bucket *hb;
1708 struct list *sorted_list = list_new();
1709
1710 sorted_list->cmp = (int (*)(void *, void *))cmp;
1711
1712 for (i = 0; i < hash->size; i++)
1713 for (hb = hash->index[i]; hb; hb = hb->next)
1714 listnode_add_sort(sorted_list, hb->data);
1715
1716 return sorted_list;
1717 }
1718
1719 /*
1720 * Compare two LSPs based on their label values.
1721 */
1722 static int lsp_cmp(const struct zebra_lsp *lsp1, const struct zebra_lsp *lsp2)
1723 {
1724 if (lsp1->ile.in_label < lsp2->ile.in_label)
1725 return -1;
1726
1727 if (lsp1->ile.in_label > lsp2->ile.in_label)
1728 return 1;
1729
1730 return 0;
1731 }
1732
1733 /*
1734 * Initialize work queue for processing changed LSPs.
1735 */
1736 static void mpls_processq_init(void)
1737 {
1738 zrouter.lsp_process_q = work_queue_new(zrouter.master, "LSP processing");
1739
1740 zrouter.lsp_process_q->spec.workfunc = &lsp_process;
1741 zrouter.lsp_process_q->spec.del_item_data = &lsp_processq_del;
1742 zrouter.lsp_process_q->spec.completion_func = &lsp_processq_complete;
1743 zrouter.lsp_process_q->spec.max_retries = 0;
1744 zrouter.lsp_process_q->spec.hold = 10;
1745 }
1746
1747
1748 /*
1749 * Process LSP update results from zebra dataplane.
1750 */
1751 void zebra_mpls_lsp_dplane_result(struct zebra_dplane_ctx *ctx)
1752 {
1753 struct zebra_vrf *zvrf;
1754 mpls_label_t label;
1755 struct zebra_ile tmp_ile;
1756 struct hash *lsp_table;
1757 struct zebra_lsp *lsp;
1758 struct zebra_nhlfe *nhlfe;
1759 struct nexthop *nexthop;
1760 enum dplane_op_e op;
1761 enum zebra_dplane_result status;
1762 enum zebra_sr_policy_update_label_mode update_mode;
1763
1764 op = dplane_ctx_get_op(ctx);
1765 status = dplane_ctx_get_status(ctx);
1766
1767 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
1768 zlog_debug("LSP dplane ctx %p, op %s, in-label %u, result %s",
1769 ctx, dplane_op2str(op),
1770 dplane_ctx_get_in_label(ctx),
1771 dplane_res2str(status));
1772
1773 label = dplane_ctx_get_in_label(ctx);
1774
1775 switch (op) {
1776 case DPLANE_OP_LSP_INSTALL:
1777 case DPLANE_OP_LSP_UPDATE:
1778 /* Look for zebra LSP object */
1779 zvrf = vrf_info_lookup(VRF_DEFAULT);
1780 if (zvrf == NULL)
1781 break;
1782
1783 lsp_table = zvrf->lsp_table;
1784
1785 tmp_ile.in_label = label;
1786 lsp = hash_lookup(lsp_table, &tmp_ile);
1787 if (lsp == NULL) {
1788 if (IS_ZEBRA_DEBUG_DPLANE)
1789 zlog_debug("LSP ctx %p: in-label %u not found",
1790 ctx, dplane_ctx_get_in_label(ctx));
1791 break;
1792 }
1793
1794 /* TODO -- Confirm that this result is still 'current' */
1795
1796 if (status != ZEBRA_DPLANE_REQUEST_SUCCESS) {
1797 UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
1798 clear_nhlfe_installed(lsp);
1799 flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
1800 "LSP Install Failure: in-label %u",
1801 lsp->ile.in_label);
1802 break;
1803 }
1804
1805 /* Update zebra object */
1806 SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
1807 frr_each(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
1808 nexthop = nhlfe->nexthop;
1809 if (!nexthop)
1810 continue;
1811
1812 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED) &&
1813 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)) {
1814 SET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
1815 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
1816 }
1817 }
1818
1819 update_mode = (op == DPLANE_OP_LSP_INSTALL)
1820 ? ZEBRA_SR_POLICY_LABEL_CREATED
1821 : ZEBRA_SR_POLICY_LABEL_UPDATED;
1822 zebra_sr_policy_label_update(label, update_mode);
1823 break;
1824
1825 case DPLANE_OP_LSP_DELETE:
1826 if (status != ZEBRA_DPLANE_REQUEST_SUCCESS) {
1827 flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE,
1828 "LSP Deletion Failure: in-label %u",
1829 dplane_ctx_get_in_label(ctx));
1830 break;
1831 }
1832 zebra_sr_policy_label_update(label,
1833 ZEBRA_SR_POLICY_LABEL_REMOVED);
1834 break;
1835
1836 case DPLANE_OP_LSP_NOTIFY:
1837 case DPLANE_OP_NONE:
1838 case DPLANE_OP_ROUTE_INSTALL:
1839 case DPLANE_OP_ROUTE_UPDATE:
1840 case DPLANE_OP_ROUTE_DELETE:
1841 case DPLANE_OP_ROUTE_NOTIFY:
1842 case DPLANE_OP_NH_INSTALL:
1843 case DPLANE_OP_NH_UPDATE:
1844 case DPLANE_OP_NH_DELETE:
1845 case DPLANE_OP_PW_INSTALL:
1846 case DPLANE_OP_PW_UNINSTALL:
1847 case DPLANE_OP_SYS_ROUTE_ADD:
1848 case DPLANE_OP_SYS_ROUTE_DELETE:
1849 case DPLANE_OP_ADDR_INSTALL:
1850 case DPLANE_OP_ADDR_UNINSTALL:
1851 case DPLANE_OP_MAC_INSTALL:
1852 case DPLANE_OP_MAC_DELETE:
1853 case DPLANE_OP_NEIGH_INSTALL:
1854 case DPLANE_OP_NEIGH_UPDATE:
1855 case DPLANE_OP_NEIGH_DELETE:
1856 case DPLANE_OP_VTEP_ADD:
1857 case DPLANE_OP_VTEP_DELETE:
1858 case DPLANE_OP_RULE_ADD:
1859 case DPLANE_OP_RULE_DELETE:
1860 case DPLANE_OP_RULE_UPDATE:
1861 case DPLANE_OP_NEIGH_DISCOVER:
1862 case DPLANE_OP_BR_PORT_UPDATE:
1863 case DPLANE_OP_IPTABLE_ADD:
1864 case DPLANE_OP_IPTABLE_DELETE:
1865 case DPLANE_OP_IPSET_ADD:
1866 case DPLANE_OP_IPSET_DELETE:
1867 case DPLANE_OP_IPSET_ENTRY_ADD:
1868 case DPLANE_OP_IPSET_ENTRY_DELETE:
1869 case DPLANE_OP_NEIGH_IP_INSTALL:
1870 case DPLANE_OP_NEIGH_IP_DELETE:
1871 case DPLANE_OP_NEIGH_TABLE_UPDATE:
1872 case DPLANE_OP_GRE_SET:
1873 case DPLANE_OP_INTF_ADDR_ADD:
1874 case DPLANE_OP_INTF_ADDR_DEL:
1875 case DPLANE_OP_INTF_NETCONFIG:
1876 case DPLANE_OP_INTF_INSTALL:
1877 case DPLANE_OP_INTF_UPDATE:
1878 case DPLANE_OP_INTF_DELETE:
1879 case DPLANE_OP_TC_QDISC_INSTALL:
1880 case DPLANE_OP_TC_QDISC_UNINSTALL:
1881 case DPLANE_OP_TC_CLASS_ADD:
1882 case DPLANE_OP_TC_CLASS_DELETE:
1883 case DPLANE_OP_TC_CLASS_UPDATE:
1884 case DPLANE_OP_TC_FILTER_ADD:
1885 case DPLANE_OP_TC_FILTER_DELETE:
1886 case DPLANE_OP_TC_FILTER_UPDATE:
1887 break;
1888
1889 } /* Switch */
1890 }
1891
1892 /*
1893 * Process LSP installation info from two sets of nhlfes: a set from
1894 * a dplane notification, and a set from the zebra LSP object. Update
1895 * counters of installed nexthops, and return whether the LSP has changed.
1896 */
1897 static bool compare_notif_nhlfes(const struct nhlfe_list_head *ctx_head,
1898 struct nhlfe_list_head *nhlfe_head,
1899 int *start_counter, int *end_counter)
1900 {
1901 struct zebra_nhlfe *nhlfe;
1902 const struct zebra_nhlfe *ctx_nhlfe;
1903 struct nexthop *nexthop;
1904 const struct nexthop *ctx_nexthop;
1905 int start_count = 0, end_count = 0;
1906 bool changed_p = false;
1907 bool is_debug = (IS_ZEBRA_DEBUG_DPLANE | IS_ZEBRA_DEBUG_MPLS);
1908
1909 frr_each_safe(nhlfe_list, nhlfe_head, nhlfe) {
1910 char buf[NEXTHOP_STRLEN];
1911
1912 nexthop = nhlfe->nexthop;
1913 if (!nexthop)
1914 continue;
1915
1916 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))
1917 start_count++;
1918
1919 ctx_nhlfe = NULL;
1920 ctx_nexthop = NULL;
1921 frr_each(nhlfe_list_const, ctx_head, ctx_nhlfe) {
1922 ctx_nexthop = ctx_nhlfe->nexthop;
1923 if (!ctx_nexthop)
1924 continue;
1925
1926 if ((ctx_nexthop->type == nexthop->type) &&
1927 nexthop_same(ctx_nexthop, nexthop)) {
1928 /* Matched */
1929 break;
1930 }
1931 }
1932
1933 if (is_debug)
1934 nexthop2str(nexthop, buf, sizeof(buf));
1935
1936 if (ctx_nhlfe && ctx_nexthop) {
1937 if (is_debug) {
1938 const char *tstr = "";
1939
1940 if (!CHECK_FLAG(ctx_nhlfe->flags,
1941 NHLFE_FLAG_INSTALLED))
1942 tstr = "not ";
1943
1944 zlog_debug("LSP dplane notif: matched nh %s (%sinstalled)",
1945 buf, tstr);
1946 }
1947
1948 /* Test zebra nhlfe install state */
1949 if (CHECK_FLAG(ctx_nhlfe->flags,
1950 NHLFE_FLAG_INSTALLED)) {
1951
1952 if (!CHECK_FLAG(nhlfe->flags,
1953 NHLFE_FLAG_INSTALLED))
1954 changed_p = true;
1955
1956 /* Update counter */
1957 end_count++;
1958 } else {
1959
1960 if (CHECK_FLAG(nhlfe->flags,
1961 NHLFE_FLAG_INSTALLED))
1962 changed_p = true;
1963 }
1964
1965 } else {
1966 /* Not mentioned in lfib set -> uninstalled */
1967 if (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED) ||
1968 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE) ||
1969 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)) {
1970 changed_p = true;
1971 }
1972
1973 if (is_debug)
1974 zlog_debug("LSP dplane notif: no match, nh %s",
1975 buf);
1976 }
1977 }
1978
1979 if (start_counter)
1980 *start_counter += start_count;
1981 if (end_counter)
1982 *end_counter += end_count;
1983
1984 return changed_p;
1985 }
1986
1987 /*
1988 * Update an lsp nhlfe list from a dplane context, typically an async
1989 * notification context. Update the LSP list to match the installed
1990 * status from the context's list.
1991 */
1992 static int update_nhlfes_from_ctx(struct nhlfe_list_head *nhlfe_head,
1993 const struct nhlfe_list_head *ctx_head)
1994 {
1995 int ret = 0;
1996 struct zebra_nhlfe *nhlfe;
1997 const struct zebra_nhlfe *ctx_nhlfe;
1998 struct nexthop *nexthop;
1999 const struct nexthop *ctx_nexthop;
2000 bool is_debug = (IS_ZEBRA_DEBUG_DPLANE | IS_ZEBRA_DEBUG_MPLS);
2001
2002 frr_each_safe(nhlfe_list, nhlfe_head, nhlfe) {
2003 char buf[NEXTHOP_STRLEN];
2004
2005 nexthop = nhlfe->nexthop;
2006 if (!nexthop)
2007 continue;
2008
2009 ctx_nhlfe = NULL;
2010 ctx_nexthop = NULL;
2011 frr_each(nhlfe_list_const, ctx_head, ctx_nhlfe) {
2012 ctx_nexthop = ctx_nhlfe->nexthop;
2013 if (!ctx_nexthop)
2014 continue;
2015
2016 if ((ctx_nexthop->type == nexthop->type) &&
2017 nexthop_same(ctx_nexthop, nexthop)) {
2018 /* Matched */
2019 break;
2020 }
2021 }
2022
2023 if (is_debug)
2024 nexthop2str(nexthop, buf, sizeof(buf));
2025
2026 if (ctx_nhlfe && ctx_nexthop) {
2027
2028 /* Bring zebra nhlfe install state into sync */
2029 if (CHECK_FLAG(ctx_nhlfe->flags,
2030 NHLFE_FLAG_INSTALLED)) {
2031 if (is_debug)
2032 zlog_debug("%s: matched lsp nhlfe %s (installed)",
2033 __func__, buf);
2034
2035 SET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
2036 SET_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED);
2037
2038 } else {
2039 if (is_debug)
2040 zlog_debug("%s: matched lsp nhlfe %s (not installed)",
2041 __func__, buf);
2042
2043 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
2044 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED);
2045 }
2046
2047 if (CHECK_FLAG(ctx_nhlfe->nexthop->flags,
2048 NEXTHOP_FLAG_FIB)) {
2049 SET_FLAG(nhlfe->nexthop->flags,
2050 NEXTHOP_FLAG_ACTIVE);
2051 SET_FLAG(nhlfe->nexthop->flags,
2052 NEXTHOP_FLAG_FIB);
2053 } else {
2054 UNSET_FLAG(nhlfe->nexthop->flags,
2055 NEXTHOP_FLAG_ACTIVE);
2056 UNSET_FLAG(nhlfe->nexthop->flags,
2057 NEXTHOP_FLAG_FIB);
2058 }
2059
2060 } else {
2061 /* Not mentioned in lfib set -> uninstalled */
2062 if (is_debug)
2063 zlog_debug("%s: no match for lsp nhlfe %s",
2064 __func__, buf);
2065 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
2066 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED);
2067 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
2068 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
2069 }
2070 }
2071
2072 return ret;
2073 }
2074
2075 /*
2076 * Process async dplane notifications.
2077 */
2078 void zebra_mpls_process_dplane_notify(struct zebra_dplane_ctx *ctx)
2079 {
2080 struct zebra_vrf *zvrf;
2081 struct zebra_ile tmp_ile;
2082 struct hash *lsp_table;
2083 struct zebra_lsp *lsp;
2084 const struct nhlfe_list_head *ctx_list;
2085 int start_count = 0, end_count = 0; /* Installed counts */
2086 bool changed_p = false;
2087 bool is_debug = (IS_ZEBRA_DEBUG_DPLANE | IS_ZEBRA_DEBUG_MPLS);
2088 enum zebra_sr_policy_update_label_mode update_mode;
2089
2090 if (is_debug)
2091 zlog_debug("LSP dplane notif, in-label %u",
2092 dplane_ctx_get_in_label(ctx));
2093
2094 /* Look for zebra LSP object */
2095 zvrf = vrf_info_lookup(VRF_DEFAULT);
2096 if (zvrf == NULL)
2097 return;
2098
2099 lsp_table = zvrf->lsp_table;
2100
2101 tmp_ile.in_label = dplane_ctx_get_in_label(ctx);
2102 lsp = hash_lookup(lsp_table, &tmp_ile);
2103 if (lsp == NULL) {
2104 if (is_debug)
2105 zlog_debug("dplane LSP notif: in-label %u not found",
2106 dplane_ctx_get_in_label(ctx));
2107 return;
2108 }
2109
2110 /*
2111 * The dataplane/forwarding plane is notifying zebra about the state
2112 * of the nexthops associated with this LSP. First, we take a
2113 * pre-scan pass to determine whether the LSP has transitioned
2114 * from installed -> uninstalled. In that case, we need to have
2115 * the existing state of the LSP objects available before making
2116 * any changes.
2117 */
2118 ctx_list = dplane_ctx_get_nhlfe_list(ctx);
2119
2120 changed_p = compare_notif_nhlfes(ctx_list, &lsp->nhlfe_list,
2121 &start_count, &end_count);
2122
2123 if (is_debug)
2124 zlog_debug("LSP dplane notif: lfib start_count %d, end_count %d%s",
2125 start_count, end_count,
2126 changed_p ? ", changed" : "");
2127
2128 ctx_list = dplane_ctx_get_backup_nhlfe_list(ctx);
2129
2130 if (compare_notif_nhlfes(ctx_list, &lsp->backup_nhlfe_list,
2131 &start_count, &end_count))
2132 /* Avoid accidentally setting back to 'false' */
2133 changed_p = true;
2134
2135 if (is_debug)
2136 zlog_debug("LSP dplane notif: lfib backups, start_count %d, end_count %d%s",
2137 start_count, end_count,
2138 changed_p ? ", changed" : "");
2139
2140 /*
2141 * Has the LSP become uninstalled? We need the existing state of the
2142 * nexthops/nhlfes at this point so we know what to delete.
2143 */
2144 if (start_count > 0 && end_count == 0) {
2145 /* Inform other lfibs */
2146 dplane_lsp_notif_update(lsp, DPLANE_OP_LSP_DELETE, ctx);
2147 }
2148
2149 /*
2150 * Now we take a second pass and bring the zebra
2151 * nexthop state into sync with the forwarding-plane state.
2152 */
2153 ctx_list = dplane_ctx_get_nhlfe_list(ctx);
2154 update_nhlfes_from_ctx(&lsp->nhlfe_list, ctx_list);
2155
2156 ctx_list = dplane_ctx_get_backup_nhlfe_list(ctx);
2157 update_nhlfes_from_ctx(&lsp->backup_nhlfe_list, ctx_list);
2158
2159 if (end_count > 0) {
2160 SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
2161
2162 /* SR-TE update too */
2163 if (start_count == 0)
2164 update_mode = ZEBRA_SR_POLICY_LABEL_CREATED;
2165 else
2166 update_mode = ZEBRA_SR_POLICY_LABEL_UPDATED;
2167 zebra_sr_policy_label_update(lsp->ile.in_label, update_mode);
2168
2169 if (changed_p)
2170 dplane_lsp_notif_update(lsp, DPLANE_OP_LSP_UPDATE, ctx);
2171
2172 } else {
2173 /* SR-TE update too */
2174 zebra_sr_policy_label_update(lsp->ile.in_label,
2175 ZEBRA_SR_POLICY_LABEL_REMOVED);
2176
2177 UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
2178 clear_nhlfe_installed(lsp);
2179 }
2180 }
2181
2182 /*
2183 * Install dynamic LSP entry.
2184 */
2185 int zebra_mpls_lsp_install(struct zebra_vrf *zvrf, struct route_node *rn,
2186 struct route_entry *re)
2187 {
2188 struct route_table *table;
2189 struct zebra_fec *fec;
2190
2191 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(&rn->p))];
2192 if (!table)
2193 return -1;
2194
2195 /* See if there is a configured label binding for this FEC. */
2196 fec = fec_find(table, &rn->p);
2197 if (!fec || fec->label == MPLS_INVALID_LABEL)
2198 return 0;
2199
2200 /* We cannot install a label forwarding entry if local label is the
2201 * implicit-null label.
2202 */
2203 if (fec->label == MPLS_LABEL_IMPLICIT_NULL)
2204 return 0;
2205
2206 if (lsp_install(zvrf, fec->label, rn, re))
2207 return -1;
2208
2209 return 0;
2210 }
2211
2212 /*
2213 * Uninstall dynamic LSP entry, if any.
2214 */
2215 int zebra_mpls_lsp_uninstall(struct zebra_vrf *zvrf, struct route_node *rn,
2216 struct route_entry *re)
2217 {
2218 struct route_table *table;
2219 struct zebra_fec *fec;
2220
2221 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(&rn->p))];
2222 if (!table)
2223 return -1;
2224
2225 /* See if there is a configured label binding for this FEC. */
2226 fec = fec_find(table, &rn->p);
2227 if (!fec || fec->label == MPLS_INVALID_LABEL)
2228 return 0;
2229
2230 /* Uninstall always removes all dynamic NHLFEs. */
2231 return lsp_uninstall(zvrf, fec->label);
2232 }
2233
2234 /*
2235 * Add an NHLFE to an LSP, return the newly-added object. This path only changes
2236 * the LSP object - nothing is scheduled for processing, for example.
2237 */
2238 struct zebra_nhlfe *
2239 zebra_mpls_lsp_add_nhlfe(struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
2240 enum nexthop_types_t gtype, const union g_addr *gate,
2241 ifindex_t ifindex, uint8_t num_labels,
2242 const mpls_label_t *out_labels)
2243 {
2244 /* Just a public pass-through to the internal implementation */
2245 return nhlfe_add(lsp, lsp_type, gtype, gate, ifindex, num_labels,
2246 out_labels, false /*backup*/);
2247 }
2248
2249 /*
2250 * Add a backup NHLFE to an LSP, return the newly-added object.
2251 * This path only changes the LSP object - nothing is scheduled for
2252 * processing, for example.
2253 */
2254 struct zebra_nhlfe *zebra_mpls_lsp_add_backup_nhlfe(
2255 struct zebra_lsp *lsp, enum lsp_types_t lsp_type,
2256 enum nexthop_types_t gtype, const union g_addr *gate, ifindex_t ifindex,
2257 uint8_t num_labels, const mpls_label_t *out_labels)
2258 {
2259 /* Just a public pass-through to the internal implementation */
2260 return nhlfe_add(lsp, lsp_type, gtype, gate, ifindex, num_labels,
2261 out_labels, true);
2262 }
2263
2264 /*
2265 * Add an NHLFE to an LSP based on a nexthop; return the newly-added object
2266 */
2267 struct zebra_nhlfe *zebra_mpls_lsp_add_nh(struct zebra_lsp *lsp,
2268 enum lsp_types_t lsp_type,
2269 const struct nexthop *nh)
2270 {
2271 struct zebra_nhlfe *nhlfe;
2272
2273 if (nh->nh_label == NULL || nh->nh_label->num_labels == 0)
2274 return NULL;
2275
2276 nhlfe = nhlfe_add(lsp, lsp_type, nh->type, &nh->gate, nh->ifindex,
2277 nh->nh_label->num_labels, nh->nh_label->label,
2278 false /*backup*/);
2279
2280 return nhlfe;
2281 }
2282
2283 /*
2284 * Add a backup NHLFE to an LSP based on a nexthop;
2285 * return the newly-added object.
2286 */
2287 struct zebra_nhlfe *zebra_mpls_lsp_add_backup_nh(struct zebra_lsp *lsp,
2288 enum lsp_types_t lsp_type,
2289 const struct nexthop *nh)
2290 {
2291 struct zebra_nhlfe *nhlfe;
2292
2293 if (nh->nh_label == NULL || nh->nh_label->num_labels == 0)
2294 return NULL;
2295
2296 nhlfe = nhlfe_add(lsp, lsp_type, nh->type, &nh->gate,
2297 nh->ifindex, nh->nh_label->num_labels,
2298 nh->nh_label->label, true);
2299
2300 return nhlfe;
2301 }
2302
2303 /*
2304 * Free an allocated NHLFE
2305 */
2306 void zebra_mpls_nhlfe_free(struct zebra_nhlfe *nhlfe)
2307 {
2308 /* Just a pass-through to the internal implementation */
2309 nhlfe_free(nhlfe);
2310 }
2311
2312 /*
2313 * Registration from a client for the label binding for a FEC. If a binding
2314 * already exists, it is informed to the client.
2315 * NOTE: If there is a manually configured label binding, that is used.
2316 * Otherwise, if a label index is specified, it means we have to allocate the
2317 * label from a locally configured label block (SRGB), if one exists and index
2318 * is acceptable. If no label index then just register the specified label.
2319 * NOTE2: Either label or label_index is expected to be set to MPLS_INVALID_*
2320 * by the calling function. Register requests with both will be rejected.
2321 */
2322 int zebra_mpls_fec_register(struct zebra_vrf *zvrf, struct prefix *p,
2323 uint32_t label, uint32_t label_index,
2324 struct zserv *client)
2325 {
2326 struct route_table *table;
2327 struct zebra_fec *fec;
2328 bool new_client;
2329 bool label_change = false;
2330 uint32_t old_label;
2331 bool have_label_index = (label_index != MPLS_INVALID_LABEL_INDEX);
2332 bool is_configured_fec = false; /* indicate statically configured FEC */
2333
2334 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
2335 if (!table)
2336 return -1;
2337
2338 if (label != MPLS_INVALID_LABEL && have_label_index) {
2339 flog_err(
2340 EC_ZEBRA_FEC_LABEL_INDEX_LABEL_CONFLICT,
2341 "Rejecting FEC register for %pFX with both label %u and Label Index %u specified, client %s",
2342 p, label, label_index,
2343 zebra_route_string(client->proto));
2344 return -1;
2345 }
2346
2347 /* Locate FEC */
2348 fec = fec_find(table, p);
2349 if (!fec) {
2350 fec = fec_add(table, p, label, 0, label_index);
2351 if (!fec) {
2352 flog_err(
2353 EC_ZEBRA_FEC_ADD_FAILED,
2354 "Failed to add FEC %pFX upon register, client %s",
2355 p, zebra_route_string(client->proto));
2356 return -1;
2357 }
2358
2359 old_label = MPLS_INVALID_LABEL;
2360 new_client = true;
2361 } else {
2362 /* Check if the FEC has been statically defined in the config */
2363 is_configured_fec = fec->flags & FEC_FLAG_CONFIGURED;
2364 /* Client may register same FEC with different label index. */
2365 new_client =
2366 (listnode_lookup(fec->client_list, client) == NULL);
2367 if (!new_client && fec->label_index == label_index
2368 && fec->label == label)
2369 /* Duplicate register */
2370 return 0;
2371
2372 /* Save current label, update the FEC */
2373 old_label = fec->label;
2374 fec->label_index = label_index;
2375 }
2376
2377 if (new_client)
2378 listnode_add(fec->client_list, client);
2379
2380 if (IS_ZEBRA_DEBUG_MPLS)
2381 zlog_debug("FEC %pFX label%s %u %s by client %s%s", p,
2382 have_label_index ? " index" : "",
2383 have_label_index ? label_index : label,
2384 new_client ? "registered" : "updated",
2385 zebra_route_string(client->proto),
2386 is_configured_fec
2387 ? ", but using statically configured label"
2388 : "");
2389
2390 /* If not a statically configured FEC, derive the local label
2391 * from label index or use the provided label
2392 */
2393 if (!is_configured_fec) {
2394 if (have_label_index)
2395 fec_derive_label_from_index(zvrf, fec);
2396 else
2397 fec->label = label;
2398
2399 /* If no label change, exit. */
2400 if (fec->label == old_label)
2401 return 0;
2402
2403 label_change = true;
2404 }
2405
2406 /* If new client or label change, update client and install or uninstall
2407 * label forwarding entry as needed.
2408 */
2409 /* Inform client of label, if needed. */
2410 if ((new_client && fec->label != MPLS_INVALID_LABEL) || label_change) {
2411 if (IS_ZEBRA_DEBUG_MPLS)
2412 zlog_debug("Update client label %u", fec->label);
2413 fec_send(fec, client);
2414 }
2415
2416 if (new_client || label_change)
2417 return fec_change_update_lsp(zvrf, fec, old_label);
2418
2419 return 0;
2420 }
2421
2422 /*
2423 * Deregistration from a client for the label binding for a FEC. The FEC
2424 * itself is deleted if no other registered clients exist and there is no
2425 * label bound to the FEC.
2426 */
2427 int zebra_mpls_fec_unregister(struct zebra_vrf *zvrf, struct prefix *p,
2428 struct zserv *client)
2429 {
2430 struct route_table *table;
2431 struct zebra_fec *fec;
2432
2433 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
2434 if (!table)
2435 return -1;
2436
2437 fec = fec_find(table, p);
2438 if (!fec) {
2439 flog_err(EC_ZEBRA_FEC_RM_FAILED,
2440 "Failed to find FEC %pFX upon unregister, client %s",
2441 p, zebra_route_string(client->proto));
2442 return -1;
2443 }
2444
2445 listnode_delete(fec->client_list, client);
2446
2447 if (IS_ZEBRA_DEBUG_MPLS)
2448 zlog_debug("FEC %pFX unregistered by client %s", p,
2449 zebra_route_string(client->proto));
2450
2451 /* If not a configured entry, delete the FEC if no other clients. Before
2452 * deleting, see if any LSP needs to be uninstalled.
2453 */
2454 if (!(fec->flags & FEC_FLAG_CONFIGURED)
2455 && list_isempty(fec->client_list)) {
2456 mpls_label_t old_label = fec->label;
2457 fec->label = MPLS_INVALID_LABEL; /* reset */
2458 fec_change_update_lsp(zvrf, fec, old_label);
2459 fec_del(fec);
2460 }
2461
2462 return 0;
2463 }
2464
2465 /*
2466 * Cleanup any FECs registered by this client.
2467 */
2468 static int zebra_mpls_cleanup_fecs_for_client(struct zserv *client)
2469 {
2470 struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
2471 struct route_node *rn;
2472 struct zebra_fec *fec;
2473 struct listnode *node;
2474 struct zserv *fec_client;
2475 int af;
2476
2477 for (af = AFI_IP; af < AFI_MAX; af++) {
2478 if (zvrf->fec_table[af] == NULL)
2479 continue;
2480
2481 for (rn = route_top(zvrf->fec_table[af]); rn;
2482 rn = route_next(rn)) {
2483 fec = rn->info;
2484 if (!fec || list_isempty(fec->client_list))
2485 continue;
2486
2487 for (ALL_LIST_ELEMENTS_RO(fec->client_list, node,
2488 fec_client)) {
2489 if (fec_client == client) {
2490 listnode_delete(fec->client_list,
2491 fec_client);
2492 if (!(fec->flags & FEC_FLAG_CONFIGURED)
2493 && list_isempty(fec->client_list))
2494 fec_del(fec);
2495 break;
2496 }
2497 }
2498 }
2499 }
2500
2501 return 0;
2502 }
2503
2504 struct lsp_uninstall_args {
2505 struct hash *lsp_table;
2506 enum lsp_types_t type;
2507 };
2508
2509 /*
2510 * Cleanup MPLS labels registered by this client.
2511 */
2512 static int zebra_mpls_cleanup_zclient_labels(struct zserv *client)
2513 {
2514 struct vrf *vrf;
2515 struct zebra_vrf *zvrf;
2516
2517 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
2518 struct lsp_uninstall_args args;
2519
2520 zvrf = vrf->info;
2521 if (!zvrf)
2522 continue;
2523
2524 /* Cleanup LSPs. */
2525 args.lsp_table = zvrf->lsp_table;
2526 args.type = lsp_type_from_re_type(client->proto);
2527 hash_iterate(zvrf->lsp_table, mpls_lsp_uninstall_all_type,
2528 &args);
2529
2530 /* Cleanup FTNs. */
2531 mpls_ftn_uninstall_all(zvrf, AFI_IP,
2532 lsp_type_from_re_type(client->proto));
2533 mpls_ftn_uninstall_all(zvrf, AFI_IP6,
2534 lsp_type_from_re_type(client->proto));
2535 }
2536
2537 return 0;
2538 }
2539
2540 /*
2541 * Return FEC (if any) to which this label is bound.
2542 * Note: Only works for per-prefix binding and when the label is not
2543 * implicit-null.
2544 * TODO: Currently walks entire table, can optimize later with another
2545 * hash..
2546 */
2547 struct zebra_fec *zebra_mpls_fec_for_label(struct zebra_vrf *zvrf,
2548 mpls_label_t label)
2549 {
2550 struct route_node *rn;
2551 struct zebra_fec *fec;
2552 int af;
2553
2554 for (af = AFI_IP; af < AFI_MAX; af++) {
2555 if (zvrf->fec_table[af] == NULL)
2556 continue;
2557
2558 for (rn = route_top(zvrf->fec_table[af]); rn;
2559 rn = route_next(rn)) {
2560 if (!rn->info)
2561 continue;
2562 fec = rn->info;
2563 if (fec->label == label)
2564 return fec;
2565 }
2566 }
2567
2568 return NULL;
2569 }
2570
2571 /*
2572 * Inform if specified label is currently bound to a FEC or not.
2573 */
2574 int zebra_mpls_label_already_bound(struct zebra_vrf *zvrf, mpls_label_t label)
2575 {
2576 return (zebra_mpls_fec_for_label(zvrf, label) ? 1 : 0);
2577 }
2578
2579 /*
2580 * Add static FEC to label binding. If there are clients registered for this
2581 * FEC, notify them. If there are labeled routes for this FEC, install the
2582 * label forwarding entry.
2583 */
2584 int zebra_mpls_static_fec_add(struct zebra_vrf *zvrf, struct prefix *p,
2585 mpls_label_t in_label)
2586 {
2587 struct route_table *table;
2588 struct zebra_fec *fec;
2589 mpls_label_t old_label;
2590 int ret = 0;
2591
2592 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
2593 if (!table)
2594 return -1;
2595
2596 /* Update existing FEC or create a new one. */
2597 fec = fec_find(table, p);
2598 if (!fec) {
2599 fec = fec_add(table, p, in_label, FEC_FLAG_CONFIGURED,
2600 MPLS_INVALID_LABEL_INDEX);
2601 if (!fec) {
2602 flog_err(EC_ZEBRA_FEC_ADD_FAILED,
2603 "Failed to add FEC %pFX upon config", p);
2604 return -1;
2605 }
2606
2607 if (IS_ZEBRA_DEBUG_MPLS)
2608 zlog_debug("Add fec %pFX label %u", p, in_label);
2609 } else {
2610 fec->flags |= FEC_FLAG_CONFIGURED;
2611 if (fec->label == in_label)
2612 /* Duplicate config */
2613 return 0;
2614
2615 /* Label change, update clients. */
2616 old_label = fec->label;
2617 if (IS_ZEBRA_DEBUG_MPLS)
2618 zlog_debug("Update fec %pFX new label %u", p, in_label);
2619
2620 fec->label = in_label;
2621 fec_update_clients(fec);
2622
2623 /* Update label forwarding entries appropriately */
2624 ret = fec_change_update_lsp(zvrf, fec, old_label);
2625 }
2626
2627 return ret;
2628 }
2629
2630 /*
2631 * Remove static FEC to label binding. If there are no clients registered
2632 * for this FEC, delete the FEC; else notify clients
2633 * Note: Upon delete of static binding, if label index exists for this FEC,
2634 * client may need to be updated with derived label.
2635 */
2636 int zebra_mpls_static_fec_del(struct zebra_vrf *zvrf, struct prefix *p)
2637 {
2638 struct route_table *table;
2639 struct zebra_fec *fec;
2640 mpls_label_t old_label;
2641
2642 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
2643 if (!table)
2644 return -1;
2645
2646 fec = fec_find(table, p);
2647 if (!fec) {
2648 flog_err(EC_ZEBRA_FEC_RM_FAILED,
2649 "Failed to find FEC %pFX upon delete", p);
2650 return -1;
2651 }
2652
2653 if (IS_ZEBRA_DEBUG_MPLS) {
2654 zlog_debug("Delete fec %pFX label %u label index %u", p,
2655 fec->label, fec->label_index);
2656 }
2657
2658 old_label = fec->label;
2659 fec->flags &= ~FEC_FLAG_CONFIGURED;
2660 fec->label = MPLS_INVALID_LABEL;
2661
2662 /* If no client exists, just delete the FEC. */
2663 if (list_isempty(fec->client_list)) {
2664 fec_del(fec);
2665 return 0;
2666 }
2667
2668 /* Derive the local label (from label index) or reset it. */
2669 fec_derive_label_from_index(zvrf, fec);
2670
2671 /* If there is a label change, update clients. */
2672 if (fec->label == old_label)
2673 return 0;
2674 fec_update_clients(fec);
2675
2676 /* Update label forwarding entries appropriately */
2677 return fec_change_update_lsp(zvrf, fec, old_label);
2678 }
2679
2680 /*
2681 * Display MPLS FEC to label binding configuration (VTY command handler).
2682 */
2683 int zebra_mpls_write_fec_config(struct vty *vty, struct zebra_vrf *zvrf)
2684 {
2685 struct route_node *rn;
2686 int af;
2687 struct zebra_fec *fec;
2688 int write = 0;
2689
2690 for (af = AFI_IP; af < AFI_MAX; af++) {
2691 if (zvrf->fec_table[af] == NULL)
2692 continue;
2693
2694 for (rn = route_top(zvrf->fec_table[af]); rn;
2695 rn = route_next(rn)) {
2696 if (!rn->info)
2697 continue;
2698
2699 char lstr[BUFSIZ];
2700 fec = rn->info;
2701
2702 if (!(fec->flags & FEC_FLAG_CONFIGURED))
2703 continue;
2704
2705 write = 1;
2706 vty_out(vty, "mpls label bind %pFX %s\n", &rn->p,
2707 label2str(fec->label, 0, lstr, BUFSIZ));
2708 }
2709 }
2710
2711 return write;
2712 }
2713
2714 /*
2715 * Display MPLS FEC to label binding (VTY command handler).
2716 */
2717 void zebra_mpls_print_fec_table(struct vty *vty, struct zebra_vrf *zvrf)
2718 {
2719 struct route_node *rn;
2720 int af;
2721
2722 for (af = AFI_IP; af < AFI_MAX; af++) {
2723 if (zvrf->fec_table[af] == NULL)
2724 continue;
2725
2726 for (rn = route_top(zvrf->fec_table[af]); rn;
2727 rn = route_next(rn)) {
2728 if (!rn->info)
2729 continue;
2730 fec_print(rn->info, vty);
2731 }
2732 }
2733 }
2734
2735 /*
2736 * Display MPLS FEC to label binding for a specific FEC (VTY command handler).
2737 */
2738 void zebra_mpls_print_fec(struct vty *vty, struct zebra_vrf *zvrf,
2739 struct prefix *p)
2740 {
2741 struct route_table *table;
2742 struct route_node *rn;
2743
2744 table = zvrf->fec_table[family2afi(PREFIX_FAMILY(p))];
2745 if (!table)
2746 return;
2747
2748 apply_mask(p);
2749 rn = route_node_lookup(table, p);
2750 if (!rn)
2751 return;
2752
2753 route_unlock_node(rn);
2754 if (!rn->info)
2755 return;
2756
2757 fec_print(rn->info, vty);
2758 }
2759
2760 static void mpls_zebra_nhe_update(struct route_entry *re, afi_t afi,
2761 struct nhg_hash_entry *new_nhe)
2762 {
2763 struct nhg_hash_entry *nhe;
2764
2765 nhe = zebra_nhg_rib_find_nhe(new_nhe, afi);
2766
2767 route_entry_update_nhe(re, nhe);
2768 }
2769
2770 static bool ftn_update_nexthop(bool add_p, struct nexthop *nexthop,
2771 enum lsp_types_t type,
2772 const struct zapi_nexthop *znh)
2773 {
2774 if (add_p && nexthop->nh_label_type == ZEBRA_LSP_NONE)
2775 nexthop_add_labels(nexthop, type, znh->label_num, znh->labels);
2776 else if (!add_p && nexthop->nh_label_type == type)
2777 nexthop_del_labels(nexthop);
2778 else
2779 return false;
2780
2781 return true;
2782 }
2783
2784 void zebra_mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type,
2785 struct prefix *prefix, uint8_t route_type,
2786 uint8_t route_instance)
2787 {
2788 struct route_table *table;
2789 struct route_node *rn;
2790 struct route_entry *re;
2791 struct nexthop *nexthop;
2792 struct nhg_hash_entry *new_nhe;
2793 afi_t afi = family2afi(prefix->family);
2794
2795 /* Lookup table. */
2796 table = zebra_vrf_table(afi, SAFI_UNICAST, zvrf_id(zvrf));
2797 if (!table)
2798 return;
2799
2800 /* Lookup existing route */
2801 rn = route_node_get(table, prefix);
2802 RNODE_FOREACH_RE (rn, re) {
2803 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2804 continue;
2805 if (re->type == route_type && re->instance == route_instance)
2806 break;
2807 }
2808 if (re == NULL)
2809 return;
2810
2811 /*
2812 * Nexthops are now shared by multiple routes, so we have to make
2813 * a local copy, modify the copy, then update the route.
2814 */
2815 new_nhe = zebra_nhe_copy(re->nhe, 0);
2816
2817 for (nexthop = new_nhe->nhg.nexthop; nexthop; nexthop = nexthop->next)
2818 nexthop_del_labels(nexthop);
2819
2820 /* Update backup routes/nexthops also, if present. */
2821 if (zebra_nhg_get_backup_nhg(new_nhe) != NULL) {
2822 for (nexthop = new_nhe->backup_info->nhe->nhg.nexthop; nexthop;
2823 nexthop = nexthop->next)
2824 nexthop_del_labels(nexthop);
2825 }
2826
2827 SET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
2828 SET_FLAG(re->status, ROUTE_ENTRY_LABELS_CHANGED);
2829
2830 /* This will create (or ref) a new nhe, so we will discard the local
2831 * temporary nhe
2832 */
2833 mpls_zebra_nhe_update(re, afi, new_nhe);
2834
2835 zebra_nhg_free(new_nhe);
2836
2837 rib_queue_add(rn);
2838 }
2839
2840 /*
2841 * Iterate through a list of nexthops, for a match for 'znh'. If found,
2842 * update its labels according to 'add_p', and return 'true' if successful.
2843 */
2844 static bool ftn_update_znh(bool add_p, enum lsp_types_t type,
2845 struct nexthop *head, const struct zapi_nexthop *znh)
2846 {
2847 bool found = false, success = false;
2848 struct nexthop *nexthop;
2849
2850 for (nexthop = head; nexthop; nexthop = nexthop->next) {
2851 switch (nexthop->type) {
2852 case NEXTHOP_TYPE_IPV4:
2853 case NEXTHOP_TYPE_IPV4_IFINDEX:
2854 if (znh->type != NEXTHOP_TYPE_IPV4
2855 && znh->type != NEXTHOP_TYPE_IPV4_IFINDEX)
2856 continue;
2857 if (!IPV4_ADDR_SAME(&nexthop->gate.ipv4,
2858 &znh->gate.ipv4))
2859 continue;
2860 if (nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX
2861 && nexthop->ifindex != znh->ifindex)
2862 continue;
2863
2864 found = true;
2865
2866 if (!ftn_update_nexthop(add_p, nexthop, type, znh))
2867 break;
2868
2869 success = true;
2870 break;
2871 case NEXTHOP_TYPE_IPV6:
2872 case NEXTHOP_TYPE_IPV6_IFINDEX:
2873 if (znh->type != NEXTHOP_TYPE_IPV6
2874 && znh->type != NEXTHOP_TYPE_IPV6_IFINDEX)
2875 continue;
2876 if (!IPV6_ADDR_SAME(&nexthop->gate.ipv6,
2877 &znh->gate.ipv6))
2878 continue;
2879 if (nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX
2880 && nexthop->ifindex != znh->ifindex)
2881 continue;
2882
2883 found = true;
2884
2885 if (!ftn_update_nexthop(add_p, nexthop, type, znh))
2886 break;
2887 success = true;
2888 break;
2889 case NEXTHOP_TYPE_IFINDEX:
2890 if (znh->type != NEXTHOP_TYPE_IFINDEX)
2891 continue;
2892 if (nexthop->ifindex != znh->ifindex)
2893 continue;
2894
2895 found = true;
2896
2897 if (!ftn_update_nexthop(add_p, nexthop, type, znh))
2898 break;
2899 success = true;
2900 break;
2901 case NEXTHOP_TYPE_BLACKHOLE:
2902 /* Not valid */
2903 continue;
2904 }
2905
2906 if (found)
2907 break;
2908 }
2909
2910 return success;
2911 }
2912
2913 /*
2914 * Install/uninstall LSP and (optionally) FEC-To-NHLFE (FTN) bindings,
2915 * using zapi message info.
2916 * There are several changes that need to be made, in several zebra
2917 * data structures, so we want to do all the work required at once.
2918 */
2919 void zebra_mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf,
2920 const struct zapi_labels *zl)
2921 {
2922 int i, counter, ret = 0;
2923 char buf[NEXTHOP_STRLEN];
2924 const struct zapi_nexthop *znh;
2925 struct route_table *table;
2926 struct route_node *rn = NULL;
2927 struct route_entry *re = NULL;
2928 struct nhg_hash_entry *new_nhe = NULL;
2929 bool found;
2930 afi_t afi = AFI_IP;
2931 const struct prefix *prefix = NULL;
2932 struct hash *lsp_table;
2933 struct zebra_ile tmp_ile;
2934 struct zebra_lsp *lsp = NULL;
2935
2936 /* Prep LSP for add case */
2937 if (add_p) {
2938 /* Lookup table. */
2939 lsp_table = zvrf->lsp_table;
2940 if (!lsp_table)
2941 return;
2942
2943 /* Find or create LSP object */
2944 tmp_ile.in_label = zl->local_label;
2945 lsp = hash_get(lsp_table, &tmp_ile, lsp_alloc);
2946 }
2947
2948 /* Prep for route/FEC update if requested */
2949 if (CHECK_FLAG(zl->message, ZAPI_LABELS_FTN)) {
2950 prefix = &zl->route.prefix;
2951
2952 afi = family2afi(prefix->family);
2953
2954 /* Lookup table. */
2955 table = zebra_vrf_table(afi, SAFI_UNICAST, zvrf_id(zvrf));
2956 if (table) {
2957 /* Lookup existing route */
2958 rn = route_node_get(table, prefix);
2959 RNODE_FOREACH_RE(rn, re) {
2960 if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
2961 continue;
2962 if (re->type == zl->route.type &&
2963 re->instance == zl->route.instance)
2964 break;
2965 }
2966 }
2967
2968 if (re) {
2969 /*
2970 * Copy over current nexthops into a temporary group.
2971 * We can't just change the values here since the nhgs
2972 * are shared and if the labels change, we'll need
2973 * to find or create a new nhg. We need to create
2974 * a whole temporary group, make changes to it,
2975 * then attach that to the route.
2976 */
2977 new_nhe = zebra_nhe_copy(re->nhe, 0);
2978
2979 } else {
2980 /*
2981 * The old version of the zapi code
2982 * attempted to manage LSPs before trying to
2983 * find a route/FEC, so we'll continue that way.
2984 */
2985 if (IS_ZEBRA_DEBUG_RECV || IS_ZEBRA_DEBUG_MPLS)
2986 zlog_debug(
2987 "%s: FTN update requested: no route for prefix %pFX",
2988 __func__, prefix);
2989 }
2990 }
2991
2992 /*
2993 * Use info from the zapi nexthops to add/replace/remove LSP/FECs
2994 */
2995
2996 counter = 0;
2997 for (i = 0; i < zl->nexthop_num; i++) {
2998
2999 znh = &zl->nexthops[i];
3000
3001 /* Attempt LSP update */
3002 if (add_p)
3003 ret = lsp_znh_install(lsp, zl->type, znh);
3004 else
3005 ret = mpls_lsp_uninstall(zvrf, zl->type,
3006 zl->local_label, znh->type,
3007 &znh->gate, znh->ifindex,
3008 false);
3009 if (ret < 0) {
3010 if (IS_ZEBRA_DEBUG_RECV || IS_ZEBRA_DEBUG_MPLS) {
3011 zapi_nexthop2str(znh, buf, sizeof(buf));
3012 zlog_debug("%s: Unable to %sinstall LSP: label %u, znh %s",
3013 __func__, (add_p ? "" : "un"),
3014 zl->local_label, buf);
3015 }
3016 continue;
3017 }
3018
3019 /* Attempt route/FEC update if requested */
3020 if (re == NULL)
3021 continue;
3022
3023 /* Search the route's nexthops for a match, and update it. */
3024 found = ftn_update_znh(add_p, zl->type, new_nhe->nhg.nexthop,
3025 znh);
3026 if (found) {
3027 counter++;
3028 } else if (IS_ZEBRA_DEBUG_RECV | IS_ZEBRA_DEBUG_MPLS) {
3029 zapi_nexthop2str(znh, buf, sizeof(buf));
3030 zlog_debug(
3031 "%s: Unable to update FEC: prefix %pFX, label %u, znh %s",
3032 __func__, prefix, zl->local_label, buf);
3033 }
3034 }
3035
3036 /*
3037 * Process backup LSPs/nexthop entries also. We associate backup
3038 * LSP info with backup nexthops.
3039 */
3040 if (!CHECK_FLAG(zl->message, ZAPI_LABELS_HAS_BACKUPS))
3041 goto znh_done;
3042
3043 for (i = 0; i < zl->backup_nexthop_num; i++) {
3044
3045 znh = &zl->backup_nexthops[i];
3046
3047 if (add_p)
3048 ret = lsp_backup_znh_install(lsp, zl->type, znh);
3049 else
3050 ret = mpls_lsp_uninstall(zvrf, zl->type,
3051 zl->local_label,
3052 znh->type, &znh->gate,
3053 znh->ifindex, true);
3054
3055 if (ret < 0) {
3056 if (IS_ZEBRA_DEBUG_RECV ||
3057 IS_ZEBRA_DEBUG_MPLS) {
3058 zapi_nexthop2str(znh, buf, sizeof(buf));
3059 zlog_debug("%s: Unable to %sinstall backup LSP: label %u, znh %s",
3060 __func__, (add_p ? "" : "un"),
3061 zl->local_label, buf);
3062 }
3063 continue;
3064 }
3065
3066 /* Attempt backup nexthop/FEC update if requested */
3067 if (re == NULL || zebra_nhg_get_backup_nhg(new_nhe) == NULL)
3068 continue;
3069
3070 /* Search the route's backup nexthops for a match
3071 * and update it.
3072 */
3073 found = ftn_update_znh(add_p, zl->type,
3074 new_nhe->backup_info->nhe->nhg.nexthop,
3075 znh);
3076 if (found) {
3077 counter++;
3078 } else if (IS_ZEBRA_DEBUG_RECV | IS_ZEBRA_DEBUG_MPLS) {
3079 zapi_nexthop2str(znh, buf, sizeof(buf));
3080 zlog_debug(
3081 "%s: Unable to update backup FEC: prefix %pFX, label %u, znh %s",
3082 __func__, prefix, zl->local_label, buf);
3083 }
3084 }
3085
3086 znh_done:
3087
3088 /*
3089 * If we made changes, update the route, and schedule it
3090 * for rib processing
3091 */
3092 if (re != NULL && counter > 0) {
3093 assert(rn != NULL);
3094
3095 SET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
3096 SET_FLAG(re->status, ROUTE_ENTRY_LABELS_CHANGED);
3097
3098 mpls_zebra_nhe_update(re, afi, new_nhe);
3099
3100 rib_queue_add(rn);
3101 }
3102
3103 if (new_nhe)
3104 zebra_nhg_free(new_nhe);
3105 }
3106
3107 /*
3108 * Install/update a NHLFE for an LSP in the forwarding table. This may be
3109 * a new LSP entry or a new NHLFE for an existing in-label or an update of
3110 * the out-label for an existing NHLFE (update case).
3111 */
3112 static struct zebra_nhlfe *
3113 lsp_add_nhlfe(struct zebra_lsp *lsp, enum lsp_types_t type,
3114 uint8_t num_out_labels, const mpls_label_t *out_labels,
3115 enum nexthop_types_t gtype, const union g_addr *gate,
3116 ifindex_t ifindex, bool is_backup)
3117 {
3118 struct zebra_nhlfe *nhlfe;
3119 char buf[MPLS_LABEL_STRLEN];
3120 const char *backup_str;
3121
3122 if (is_backup) {
3123 nhlfe = nhlfe_find(&lsp->backup_nhlfe_list, type, gtype,
3124 gate, ifindex);
3125 backup_str = "backup ";
3126 } else {
3127 nhlfe = nhlfe_find(&lsp->nhlfe_list, type, gtype, gate,
3128 ifindex);
3129 backup_str = "";
3130 }
3131
3132 if (nhlfe) {
3133 struct nexthop *nh = nhlfe->nexthop;
3134
3135 assert(nh);
3136 assert(nh->nh_label);
3137
3138 /* Clear deleted flag (in case it was set) */
3139 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
3140 if (nh->nh_label->num_labels == num_out_labels
3141 && !memcmp(nh->nh_label->label, out_labels,
3142 sizeof(mpls_label_t) * num_out_labels))
3143 /* No change */
3144 return nhlfe;
3145
3146 if (IS_ZEBRA_DEBUG_MPLS) {
3147 char buf2[MPLS_LABEL_STRLEN];
3148 char buf3[MPLS_LABEL_STRLEN];
3149
3150 nhlfe2str(nhlfe, buf, sizeof(buf));
3151 mpls_label2str(num_out_labels, out_labels, buf2,
3152 sizeof(buf2), 0, 0);
3153 mpls_label2str(nh->nh_label->num_labels,
3154 nh->nh_label->label, buf3, sizeof(buf3),
3155 nh->nh_label_type, 0);
3156
3157 zlog_debug("LSP in-label %u type %d %snexthop %s out-label(s) changed to %s (old %s)",
3158 lsp->ile.in_label, type, backup_str, buf,
3159 buf2, buf3);
3160 }
3161
3162 /* Update out label(s), trigger processing. */
3163 if (nh->nh_label->num_labels == num_out_labels)
3164 memcpy(nh->nh_label->label, out_labels,
3165 sizeof(mpls_label_t) * num_out_labels);
3166 else {
3167 nexthop_del_labels(nh);
3168 nexthop_add_labels(nh, type, num_out_labels,
3169 out_labels);
3170 }
3171 } else {
3172 /* Add LSP entry to this nexthop */
3173 nhlfe = nhlfe_add(lsp, type, gtype, gate, ifindex,
3174 num_out_labels, out_labels, is_backup);
3175 if (!nhlfe)
3176 return NULL;
3177
3178 if (IS_ZEBRA_DEBUG_MPLS) {
3179 char buf2[MPLS_LABEL_STRLEN];
3180
3181 nhlfe2str(nhlfe, buf, sizeof(buf));
3182 mpls_label2str(num_out_labels, out_labels, buf2,
3183 sizeof(buf2), 0, 0);
3184
3185 zlog_debug("Add LSP in-label %u type %d %snexthop %s out-label(s) %s",
3186 lsp->ile.in_label, type, backup_str, buf,
3187 buf2);
3188 }
3189
3190 lsp->addr_family = NHLFE_FAMILY(nhlfe);
3191 }
3192
3193 /* Mark NHLFE, queue LSP for processing. */
3194 SET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
3195
3196 return nhlfe;
3197 }
3198
3199 /*
3200 * Install an LSP and forwarding entry; used primarily
3201 * from vrf zapi message processing.
3202 */
3203 int mpls_lsp_install(struct zebra_vrf *zvrf, enum lsp_types_t type,
3204 mpls_label_t in_label, uint8_t num_out_labels,
3205 const mpls_label_t *out_labels, enum nexthop_types_t gtype,
3206 const union g_addr *gate, ifindex_t ifindex)
3207 {
3208 struct hash *lsp_table;
3209 struct zebra_ile tmp_ile;
3210 struct zebra_lsp *lsp;
3211 struct zebra_nhlfe *nhlfe;
3212
3213 /* Lookup table. */
3214 lsp_table = zvrf->lsp_table;
3215 if (!lsp_table)
3216 return -1;
3217
3218 /* Find or create LSP object */
3219 tmp_ile.in_label = in_label;
3220 lsp = hash_get(lsp_table, &tmp_ile, lsp_alloc);
3221
3222 nhlfe = lsp_add_nhlfe(lsp, type, num_out_labels, out_labels, gtype,
3223 gate, ifindex, false /*backup*/);
3224 if (nhlfe == NULL)
3225 return -1;
3226
3227 /* Queue LSP for processing. */
3228 if (lsp_processq_add(lsp))
3229 return -1;
3230
3231 return 0;
3232 }
3233
3234 /*
3235 * Install or replace NHLFE, using info from zapi nexthop
3236 */
3237 static int lsp_znh_install(struct zebra_lsp *lsp, enum lsp_types_t type,
3238 const struct zapi_nexthop *znh)
3239 {
3240 struct zebra_nhlfe *nhlfe;
3241
3242 nhlfe = lsp_add_nhlfe(lsp, type, znh->label_num, znh->labels,
3243 znh->type, &znh->gate, znh->ifindex,
3244 false /*backup*/);
3245 if (nhlfe == NULL)
3246 return -1;
3247
3248 /* Update backup info if present */
3249 if (CHECK_FLAG(znh->flags, ZAPI_NEXTHOP_FLAG_HAS_BACKUP)) {
3250 if (znh->backup_num > NEXTHOP_MAX_BACKUPS) {
3251 nhlfe_del(nhlfe);
3252 return -1;
3253 }
3254
3255 nhlfe->nexthop->backup_num = znh->backup_num;
3256 memcpy(nhlfe->nexthop->backup_idx, znh->backup_idx,
3257 znh->backup_num);
3258 SET_FLAG(nhlfe->nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP);
3259 } else {
3260 /* Ensure there's no stale backup info */
3261 UNSET_FLAG(nhlfe->nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP);
3262 nhlfe->nexthop->backup_num = 0;
3263 }
3264
3265 /* Queue LSP for processing. */
3266 if (lsp_processq_add(lsp))
3267 return -1;
3268
3269 return 0;
3270 }
3271
3272 /*
3273 * Install/update backup NHLFE for an LSP, using info from a zapi message.
3274 */
3275 static int lsp_backup_znh_install(struct zebra_lsp *lsp, enum lsp_types_t type,
3276 const struct zapi_nexthop *znh)
3277 {
3278 struct zebra_nhlfe *nhlfe;
3279
3280 nhlfe = lsp_add_nhlfe(lsp, type, znh->label_num,
3281 znh->labels, znh->type, &znh->gate,
3282 znh->ifindex, true /*backup*/);
3283 if (nhlfe == NULL) {
3284 if (IS_ZEBRA_DEBUG_MPLS)
3285 zlog_debug("%s: unable to add backup nhlfe, label: %u",
3286 __func__, lsp->ile.in_label);
3287 return -1;
3288 }
3289
3290 /* Queue LSP for processing. */
3291 if (lsp_processq_add(lsp))
3292 return -1;
3293
3294 return 0;
3295 }
3296
3297 struct zebra_lsp *mpls_lsp_find(struct zebra_vrf *zvrf, mpls_label_t in_label)
3298 {
3299 struct hash *lsp_table;
3300 struct zebra_ile tmp_ile;
3301
3302 /* Lookup table. */
3303 lsp_table = zvrf->lsp_table;
3304 if (!lsp_table)
3305 return NULL;
3306
3307 /* If entry is not present, exit. */
3308 tmp_ile.in_label = in_label;
3309 return hash_lookup(lsp_table, &tmp_ile);
3310 }
3311
3312 /*
3313 * Uninstall a particular NHLFE in the forwarding table. If this is
3314 * the only NHLFE, the entire LSP forwarding entry has to be deleted.
3315 */
3316 int mpls_lsp_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type,
3317 mpls_label_t in_label, enum nexthop_types_t gtype,
3318 const union g_addr *gate, ifindex_t ifindex,
3319 bool backup_p)
3320 {
3321 struct hash *lsp_table;
3322 struct zebra_ile tmp_ile;
3323 struct zebra_lsp *lsp;
3324 struct zebra_nhlfe *nhlfe;
3325 char buf[NEXTHOP_STRLEN];
3326 bool schedule_lsp = false;
3327
3328 /* Lookup table. */
3329 lsp_table = zvrf->lsp_table;
3330 if (!lsp_table)
3331 return -1;
3332
3333 /* If entry is not present, exit. */
3334 tmp_ile.in_label = in_label;
3335 lsp = hash_lookup(lsp_table, &tmp_ile);
3336 if (!lsp)
3337 return 0;
3338
3339 if (backup_p)
3340 nhlfe = nhlfe_find(&lsp->backup_nhlfe_list, type, gtype,
3341 gate, ifindex);
3342 else
3343 nhlfe = nhlfe_find(&lsp->nhlfe_list, type, gtype, gate,
3344 ifindex);
3345 if (!nhlfe)
3346 return 0;
3347
3348 if (IS_ZEBRA_DEBUG_MPLS) {
3349 nhlfe2str(nhlfe, buf, sizeof(buf));
3350 zlog_debug("Del LSP in-label %u type %d nexthop %s flags 0x%x",
3351 in_label, type, buf, nhlfe->flags);
3352 }
3353
3354 if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED) ||
3355 CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED))
3356 schedule_lsp = true;
3357
3358 /* Mark NHLFE for delete or directly delete, as appropriate. */
3359 if (schedule_lsp) {
3360 SET_FLAG(nhlfe->flags, NHLFE_FLAG_DELETED);
3361 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_CHANGED);
3362
3363 if (IS_ZEBRA_DEBUG_MPLS)
3364 zlog_debug("Schedule LSP in-label %u flags 0x%x",
3365 lsp->ile.in_label, lsp->flags);
3366 if (lsp_processq_add(lsp))
3367 return -1;
3368 } else {
3369 nhlfe_del(nhlfe);
3370
3371 /* Free LSP entry if no other NHLFEs and not scheduled. */
3372 lsp_check_free(lsp_table, &lsp);
3373 }
3374 return 0;
3375 }
3376
3377 int mpls_lsp_uninstall_all_vrf(struct zebra_vrf *zvrf, enum lsp_types_t type,
3378 mpls_label_t in_label)
3379 {
3380 struct hash *lsp_table;
3381 struct zebra_ile tmp_ile;
3382 struct zebra_lsp *lsp;
3383
3384 /* Lookup table. */
3385 lsp_table = zvrf->lsp_table;
3386 if (!lsp_table)
3387 return -1;
3388
3389 /* If entry is not present, exit. */
3390 tmp_ile.in_label = in_label;
3391 lsp = hash_lookup(lsp_table, &tmp_ile);
3392 if (!lsp)
3393 return 0;
3394
3395 return mpls_lsp_uninstall_all(lsp_table, lsp, type);
3396 }
3397
3398 /*
3399 * Uninstall all NHLFEs for a particular LSP forwarding entry.
3400 * If no other NHLFEs exist, the entry would be deleted.
3401 */
3402 static void mpls_lsp_uninstall_all_type(struct hash_bucket *bucket, void *ctxt)
3403 {
3404 struct lsp_uninstall_args *args = ctxt;
3405 struct zebra_lsp *lsp;
3406 struct hash *lsp_table;
3407
3408 lsp = (struct zebra_lsp *)bucket->data;
3409 if (nhlfe_list_first(&lsp->nhlfe_list) == NULL)
3410 return;
3411
3412 lsp_table = args->lsp_table;
3413 if (!lsp_table)
3414 return;
3415
3416 mpls_lsp_uninstall_all(lsp_table, lsp, args->type);
3417 }
3418
3419 /*
3420 * Uninstall all FEC-To-NHLFE (FTN) bindings of the given address-family and
3421 * LSP type.
3422 */
3423 static void mpls_ftn_uninstall_all(struct zebra_vrf *zvrf,
3424 int afi, enum lsp_types_t lsp_type)
3425 {
3426 struct route_table *table;
3427 struct route_node *rn;
3428 struct route_entry *re;
3429 struct nexthop *nexthop;
3430 struct nexthop_group *nhg;
3431 bool update;
3432
3433 /* Process routes of interested address-families. */
3434 table = zebra_vrf_table(afi, SAFI_UNICAST, zvrf_id(zvrf));
3435 if (!table)
3436 return;
3437
3438 for (rn = route_top(table); rn; rn = route_next(rn)) {
3439 update = false;
3440
3441 RNODE_FOREACH_RE (rn, re) {
3442 struct nhg_hash_entry *new_nhe;
3443
3444 new_nhe = zebra_nhe_copy(re->nhe, 0);
3445
3446 nhg = &new_nhe->nhg;
3447 for (nexthop = nhg->nexthop; nexthop;
3448 nexthop = nexthop->next) {
3449 if (nexthop->nh_label_type != lsp_type)
3450 continue;
3451
3452 nexthop_del_labels(nexthop);
3453 SET_FLAG(re->status, ROUTE_ENTRY_CHANGED);
3454 SET_FLAG(re->status,
3455 ROUTE_ENTRY_LABELS_CHANGED);
3456 update = true;
3457 }
3458
3459 /* Check for backup info and update that also */
3460 nhg = zebra_nhg_get_backup_nhg(new_nhe);
3461 if (nhg != NULL) {
3462 for (nexthop = nhg->nexthop; nexthop;
3463 nexthop = nexthop->next) {
3464 if (nexthop->nh_label_type != lsp_type)
3465 continue;
3466
3467 nexthop_del_labels(nexthop);
3468 SET_FLAG(re->status,
3469 ROUTE_ENTRY_CHANGED);
3470 SET_FLAG(re->status,
3471 ROUTE_ENTRY_LABELS_CHANGED);
3472 update = true;
3473 }
3474 }
3475
3476 if (CHECK_FLAG(re->status, ROUTE_ENTRY_LABELS_CHANGED))
3477 mpls_zebra_nhe_update(re, afi, new_nhe);
3478
3479 zebra_nhg_free(new_nhe);
3480 }
3481
3482 if (update)
3483 rib_queue_add(rn);
3484 }
3485 }
3486
3487 #if defined(HAVE_CUMULUS)
3488 /*
3489 * Check that the label values used in LSP creation are consistent. The
3490 * main criteria is that if there is ECMP, the label operation must still
3491 * be consistent - i.e., all paths either do a swap or do PHP. This is due
3492 * to current HW restrictions.
3493 */
3494 int zebra_mpls_lsp_label_consistent(struct zebra_vrf *zvrf,
3495 mpls_label_t in_label,
3496 mpls_label_t out_label,
3497 enum nexthop_types_t gtype,
3498 union g_addr *gate, ifindex_t ifindex)
3499 {
3500 struct hash *slsp_table;
3501 struct zebra_ile tmp_ile;
3502 struct zebra_lsp *lsp;
3503 struct zebra_nhlfe *nhlfe;
3504 const struct nexthop *nh;
3505
3506 /* Lookup table. */
3507 slsp_table = zvrf->slsp_table;
3508 if (!slsp_table)
3509 return 0;
3510
3511 /* If entry is not present, exit. */
3512 tmp_ile.in_label = in_label;
3513 lsp = hash_lookup(slsp_table, &tmp_ile);
3514 if (!lsp)
3515 return 1;
3516
3517 nhlfe = nhlfe_find(&lsp->nhlfe_list, ZEBRA_LSP_STATIC,
3518 gtype, gate, ifindex);
3519 if (nhlfe) {
3520 nh = nhlfe->nexthop;
3521
3522 if (nh == NULL || nh->nh_label == NULL)
3523 return 0;
3524
3525 if (nh->nh_label->label[0] == out_label)
3526 return 1;
3527
3528 /* If not only NHLFE, cannot allow label change. */
3529 if (nhlfe != nhlfe_list_first(&lsp->nhlfe_list) ||
3530 nhlfe_list_next(&lsp->nhlfe_list, nhlfe) != NULL)
3531 return 0;
3532 } else {
3533 /* If other NHLFEs exist, label operation must match. */
3534 nhlfe = nhlfe_list_first(&lsp->nhlfe_list);
3535 if (nhlfe != NULL) {
3536 int cur_op, new_op;
3537
3538 nh = nhlfe->nexthop;
3539
3540 if (nh == NULL || nh->nh_label == NULL)
3541 return 0;
3542
3543 cur_op = (nh->nh_label->label[0] ==
3544 MPLS_LABEL_IMPLICIT_NULL);
3545 new_op = (out_label == MPLS_LABEL_IMPLICIT_NULL);
3546 if (cur_op != new_op)
3547 return 0;
3548 }
3549 }
3550
3551 /* Label values are good. */
3552 return 1;
3553 }
3554 #endif /* HAVE_CUMULUS */
3555
3556 /*
3557 * Add static LSP entry. This may be the first entry for this incoming label
3558 * or an additional nexthop; an existing entry may also have outgoing label
3559 * changed.
3560 * Note: The label operation (swap or PHP) is common for the LSP entry (all
3561 * NHLFEs).
3562 */
3563 int zebra_mpls_static_lsp_add(struct zebra_vrf *zvrf, mpls_label_t in_label,
3564 mpls_label_t out_label,
3565 enum nexthop_types_t gtype, union g_addr *gate,
3566 ifindex_t ifindex)
3567 {
3568 struct hash *slsp_table;
3569 struct zebra_ile tmp_ile;
3570 struct zebra_lsp *lsp;
3571 struct zebra_nhlfe *nhlfe;
3572 char buf[BUFSIZ];
3573
3574 /* Lookup table. */
3575 slsp_table = zvrf->slsp_table;
3576 if (!slsp_table)
3577 return -1;
3578
3579 /* Find or create LSP. */
3580 tmp_ile.in_label = in_label;
3581 lsp = hash_get(slsp_table, &tmp_ile, lsp_alloc);
3582
3583 nhlfe = nhlfe_find(&lsp->nhlfe_list, ZEBRA_LSP_STATIC, gtype, gate,
3584 ifindex);
3585 if (nhlfe) {
3586 struct nexthop *nh = nhlfe->nexthop;
3587
3588 assert(nh);
3589 assert(nh->nh_label);
3590
3591 /* Compare existing nexthop */
3592 if (nh->nh_label->num_labels == 1 &&
3593 nh->nh_label->label[0] == out_label)
3594 /* No change */
3595 return 0;
3596
3597 if (IS_ZEBRA_DEBUG_MPLS) {
3598 nhlfe2str(nhlfe, buf, sizeof(buf));
3599 zlog_debug(
3600 "Upd static LSP in-label %u nexthop %s out-label %u (old %u)",
3601 in_label, buf, out_label,
3602 nh->nh_label->label[0]);
3603 }
3604 if (nh->nh_label->num_labels == 1)
3605 nh->nh_label->label[0] = out_label;
3606 else {
3607 nexthop_del_labels(nh);
3608 nexthop_add_labels(nh, ZEBRA_LSP_STATIC, 1, &out_label);
3609 }
3610
3611 } else {
3612 /* Add static LSP entry to this nexthop */
3613 nhlfe = nhlfe_add(lsp, ZEBRA_LSP_STATIC, gtype, gate,
3614 ifindex, 1, &out_label, false /*backup*/);
3615 if (!nhlfe)
3616 return -1;
3617
3618 if (IS_ZEBRA_DEBUG_MPLS) {
3619 nhlfe2str(nhlfe, buf, sizeof(buf));
3620 zlog_debug(
3621 "Add static LSP in-label %u nexthop %s out-label %u",
3622 in_label, buf, out_label);
3623 }
3624 }
3625
3626 /* (Re)Install LSP in the main table. */
3627 if (mpls_lsp_install(zvrf, ZEBRA_LSP_STATIC, in_label, 1, &out_label,
3628 gtype, gate, ifindex))
3629 return -1;
3630
3631 return 0;
3632 }
3633
3634 /*
3635 * Delete static LSP entry. This may be the delete of one particular
3636 * NHLFE for this incoming label or the delete of the entire entry (i.e.,
3637 * all NHLFEs).
3638 * NOTE: Delete of the only NHLFE will also end up deleting the entire
3639 * LSP configuration.
3640 */
3641 int zebra_mpls_static_lsp_del(struct zebra_vrf *zvrf, mpls_label_t in_label,
3642 enum nexthop_types_t gtype, union g_addr *gate,
3643 ifindex_t ifindex)
3644 {
3645 struct hash *slsp_table;
3646 struct zebra_ile tmp_ile;
3647 struct zebra_lsp *lsp;
3648 struct zebra_nhlfe *nhlfe;
3649
3650 /* Lookup table. */
3651 slsp_table = zvrf->slsp_table;
3652 if (!slsp_table)
3653 return -1;
3654
3655 /* If entry is not present, exit. */
3656 tmp_ile.in_label = in_label;
3657 lsp = hash_lookup(slsp_table, &tmp_ile);
3658 if (!lsp)
3659 return 0;
3660
3661 /* Is it delete of entire LSP or a specific NHLFE? */
3662 if (gtype == NEXTHOP_TYPE_BLACKHOLE) {
3663 if (IS_ZEBRA_DEBUG_MPLS)
3664 zlog_debug("Del static LSP in-label %u", in_label);
3665
3666 /* Uninstall entire LSP from the main table. */
3667 mpls_static_lsp_uninstall_all(zvrf, in_label);
3668
3669 /* Delete all static NHLFEs */
3670 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
3671 nhlfe_del(nhlfe);
3672 }
3673 } else {
3674 /* Find specific NHLFE, exit if not found. */
3675 nhlfe = nhlfe_find(&lsp->nhlfe_list, ZEBRA_LSP_STATIC,
3676 gtype, gate, ifindex);
3677 if (!nhlfe)
3678 return 0;
3679
3680 if (IS_ZEBRA_DEBUG_MPLS) {
3681 char buf[BUFSIZ];
3682 nhlfe2str(nhlfe, buf, sizeof(buf));
3683 zlog_debug("Del static LSP in-label %u nexthop %s",
3684 in_label, buf);
3685 }
3686
3687 /* Uninstall LSP from the main table. */
3688 mpls_lsp_uninstall(zvrf, ZEBRA_LSP_STATIC, in_label, gtype,
3689 gate, ifindex, false);
3690
3691 /* Delete static LSP NHLFE */
3692 nhlfe_del(nhlfe);
3693 }
3694
3695 /* Remove entire static LSP entry if no NHLFE - valid in either case
3696 * above.
3697 */
3698 if (nhlfe_list_first(&lsp->nhlfe_list) == NULL) {
3699 lsp = hash_release(slsp_table, &tmp_ile);
3700 lsp_free_nhlfe(lsp);
3701 XFREE(MTYPE_LSP, lsp);
3702 }
3703
3704 return 0;
3705 }
3706
3707 /*
3708 * Schedule all MPLS label forwarding entries for processing.
3709 * Called upon changes that may affect one or more of them such as
3710 * interface or nexthop state changes.
3711 */
3712 void zebra_mpls_lsp_schedule(struct zebra_vrf *zvrf)
3713 {
3714 if (!zvrf)
3715 return;
3716 hash_iterate(zvrf->lsp_table, lsp_schedule, NULL);
3717 }
3718
3719 /*
3720 * Display MPLS label forwarding table for a specific LSP
3721 * (VTY command handler).
3722 */
3723 void zebra_mpls_print_lsp(struct vty *vty, struct zebra_vrf *zvrf,
3724 mpls_label_t label, bool use_json)
3725 {
3726 struct hash *lsp_table;
3727 struct zebra_lsp *lsp;
3728 struct zebra_ile tmp_ile;
3729 json_object *json = NULL;
3730
3731 /* Lookup table. */
3732 lsp_table = zvrf->lsp_table;
3733 if (!lsp_table)
3734 return;
3735
3736 /* If entry is not present, exit. */
3737 tmp_ile.in_label = label;
3738 lsp = hash_lookup(lsp_table, &tmp_ile);
3739 if (!lsp)
3740 return;
3741
3742 if (use_json) {
3743 json = lsp_json(lsp);
3744 vty_json(vty, json);
3745 } else
3746 lsp_print(vty, lsp);
3747 }
3748
3749 /*
3750 * Display MPLS label forwarding table (VTY command handler).
3751 */
3752 void zebra_mpls_print_lsp_table(struct vty *vty, struct zebra_vrf *zvrf,
3753 bool use_json)
3754 {
3755 char buf[BUFSIZ];
3756 json_object *json = NULL;
3757 struct zebra_lsp *lsp = NULL;
3758 struct zebra_nhlfe *nhlfe = NULL;
3759 struct listnode *node = NULL;
3760 struct list *lsp_list = hash_get_sorted_list(zvrf->lsp_table, lsp_cmp);
3761
3762 if (use_json) {
3763 json = json_object_new_object();
3764
3765 for (ALL_LIST_ELEMENTS_RO(lsp_list, node, lsp))
3766 json_object_object_add(json,
3767 label2str(lsp->ile.in_label, 0,
3768 buf, sizeof(buf)),
3769 lsp_json(lsp));
3770
3771 vty_json(vty, json);
3772 } else {
3773 struct ttable *tt;
3774
3775 /* Prepare table. */
3776 tt = ttable_new(&ttable_styles[TTSTYLE_BLANK]);
3777 ttable_add_row(tt, "Inbound Label|Type|Nexthop|Outbound Label");
3778 tt->style.cell.rpad = 2;
3779 tt->style.corner = '+';
3780 ttable_restyle(tt);
3781 ttable_rowseps(tt, 0, BOTTOM, true, '-');
3782
3783 for (ALL_LIST_ELEMENTS_RO(lsp_list, node, lsp)) {
3784 frr_each_safe(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
3785 struct nexthop *nexthop;
3786 const char *out_label_str;
3787 char nh_buf[NEXTHOP_STRLEN];
3788
3789 nexthop = nhlfe->nexthop;
3790
3791 switch (nexthop->type) {
3792 case NEXTHOP_TYPE_IFINDEX: {
3793 struct zebra_ns *zns;
3794 struct interface *ifp;
3795
3796 zns = zebra_ns_lookup(NS_DEFAULT);
3797 ifp = if_lookup_by_index_per_ns(
3798 zns, nexthop->ifindex);
3799 snprintf(nh_buf, sizeof(nh_buf), "%s",
3800 ifp ? ifp->name : "Null");
3801 break;
3802 }
3803 case NEXTHOP_TYPE_IPV4:
3804 case NEXTHOP_TYPE_IPV4_IFINDEX:
3805 inet_ntop(AF_INET, &nexthop->gate.ipv4,
3806 nh_buf, sizeof(nh_buf));
3807 break;
3808 case NEXTHOP_TYPE_IPV6:
3809 case NEXTHOP_TYPE_IPV6_IFINDEX:
3810 inet_ntop(AF_INET6, &nexthop->gate.ipv6,
3811 nh_buf, sizeof(nh_buf));
3812 break;
3813 case NEXTHOP_TYPE_BLACKHOLE:
3814 break;
3815 }
3816
3817 if (nexthop->type != NEXTHOP_TYPE_IFINDEX)
3818 out_label_str = mpls_label2str(
3819 nexthop->nh_label->num_labels,
3820 &nexthop->nh_label->label[0],
3821 buf, sizeof(buf),
3822 nexthop->nh_label_type, 1);
3823 else
3824 out_label_str = "-";
3825
3826 ttable_add_row(tt, "%u|%s|%s|%s",
3827 lsp->ile.in_label,
3828 nhlfe_type2str(nhlfe->type),
3829 nh_buf, out_label_str);
3830 }
3831 }
3832
3833 /* Dump the generated table. */
3834 if (tt->nrows > 1) {
3835 char *table = ttable_dump(tt, "\n");
3836 vty_out(vty, "%s\n", table);
3837 XFREE(MTYPE_TMP, table);
3838 }
3839 ttable_del(tt);
3840 }
3841
3842 list_delete(&lsp_list);
3843 }
3844
3845 /*
3846 * Create printable string for static LSP configuration.
3847 */
3848 static char *nhlfe_config_str(const struct zebra_nhlfe *nhlfe, char *buf,
3849 int size)
3850 {
3851 const struct nexthop *nh;
3852
3853 nh = nhlfe->nexthop;
3854
3855 buf[0] = '\0';
3856 switch (nh->type) {
3857 case NEXTHOP_TYPE_IPV4:
3858 case NEXTHOP_TYPE_IPV4_IFINDEX:
3859 inet_ntop(AF_INET, &nh->gate.ipv4, buf, size);
3860 if (nh->ifindex)
3861 strlcat(buf, ifindex2ifname(nh->ifindex, VRF_DEFAULT),
3862 size);
3863 break;
3864 case NEXTHOP_TYPE_IPV6:
3865 case NEXTHOP_TYPE_IPV6_IFINDEX:
3866 inet_ntop(AF_INET6, &nh->gate.ipv6, buf, size);
3867 if (nh->ifindex)
3868 strlcat(buf,
3869 ifindex2ifname(nh->ifindex, VRF_DEFAULT),
3870 size);
3871 break;
3872 case NEXTHOP_TYPE_IFINDEX:
3873 if (nh->ifindex)
3874 strlcat(buf,
3875 ifindex2ifname(nh->ifindex, VRF_DEFAULT),
3876 size);
3877 break;
3878 case NEXTHOP_TYPE_BLACKHOLE:
3879 break;
3880 }
3881
3882 return buf;
3883 }
3884
3885 /*
3886 * Display MPLS LSP configuration of all static LSPs (VTY command handler).
3887 */
3888 int zebra_mpls_write_lsp_config(struct vty *vty, struct zebra_vrf *zvrf)
3889 {
3890 struct zebra_lsp *lsp;
3891 struct zebra_nhlfe *nhlfe;
3892 struct nexthop *nh;
3893 struct listnode *node;
3894 struct list *slsp_list =
3895 hash_get_sorted_list(zvrf->slsp_table, lsp_cmp);
3896
3897 for (ALL_LIST_ELEMENTS_RO(slsp_list, node, lsp)) {
3898 frr_each(nhlfe_list, &lsp->nhlfe_list, nhlfe) {
3899 char buf[BUFSIZ];
3900 char lstr[30];
3901
3902 nh = nhlfe->nexthop;
3903 if (nh == NULL || nh->nh_label == NULL)
3904 continue;
3905
3906 nhlfe_config_str(nhlfe, buf, sizeof(buf));
3907
3908 switch (nh->nh_label->label[0]) {
3909 case MPLS_LABEL_IPV4_EXPLICIT_NULL:
3910 case MPLS_LABEL_IPV6_EXPLICIT_NULL:
3911 strlcpy(lstr, "explicit-null", sizeof(lstr));
3912 break;
3913 case MPLS_LABEL_IMPLICIT_NULL:
3914 strlcpy(lstr, "implicit-null", sizeof(lstr));
3915 break;
3916 default:
3917 snprintf(lstr, sizeof(lstr), "%u",
3918 nh->nh_label->label[0]);
3919 break;
3920 }
3921
3922 vty_out(vty, "mpls lsp %u %s %s\n", lsp->ile.in_label,
3923 buf, lstr);
3924 }
3925 }
3926
3927 list_delete(&slsp_list);
3928 return (zvrf->slsp_table->count ? 1 : 0);
3929 }
3930
3931 /*
3932 * Add/update global label block.
3933 */
3934 int zebra_mpls_label_block_add(struct zebra_vrf *zvrf, uint32_t start_label,
3935 uint32_t end_label)
3936 {
3937 zvrf->mpls_srgb.start_label = start_label;
3938 zvrf->mpls_srgb.end_label = end_label;
3939
3940 /* Evaluate registered FECs to see if any get a label or not. */
3941 fec_evaluate(zvrf);
3942 return 0;
3943 }
3944
3945 /*
3946 * Delete global label block.
3947 */
3948 int zebra_mpls_label_block_del(struct zebra_vrf *zvrf)
3949 {
3950 zvrf->mpls_srgb.start_label = MPLS_DEFAULT_MIN_SRGB_LABEL;
3951 zvrf->mpls_srgb.end_label = MPLS_DEFAULT_MAX_SRGB_LABEL;
3952
3953 /* Process registered FECs to clear their local label, if needed. */
3954 fec_evaluate(zvrf);
3955 return 0;
3956 }
3957
3958 /*
3959 * Display MPLS global label block configuration (VTY command handler).
3960 */
3961 int zebra_mpls_write_label_block_config(struct vty *vty, struct zebra_vrf *zvrf)
3962 {
3963 if (zvrf->mpls_srgb.start_label == 0)
3964 return 0;
3965
3966 if ((zvrf->mpls_srgb.start_label != MPLS_DEFAULT_MIN_SRGB_LABEL)
3967 || (zvrf->mpls_srgb.end_label != MPLS_DEFAULT_MAX_SRGB_LABEL)) {
3968 vty_out(vty, "mpls label global-block %u %u\n",
3969 zvrf->mpls_srgb.start_label, zvrf->mpls_srgb.end_label);
3970 }
3971
3972 return 1;
3973 }
3974
3975 /*
3976 * Called when VRF becomes inactive, cleans up information but keeps
3977 * the table itself.
3978 */
3979 void zebra_mpls_cleanup_tables(struct zebra_vrf *zvrf)
3980 {
3981 struct zebra_vrf *def_zvrf;
3982 afi_t afi;
3983
3984 if (zvrf_id(zvrf) == VRF_DEFAULT)
3985 hash_iterate(zvrf->lsp_table, lsp_uninstall_from_kernel, NULL);
3986 else {
3987 /*
3988 * For other vrfs, we try to remove associated LSPs; we locate
3989 * the LSPs in the default vrf.
3990 */
3991 def_zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
3992
3993 /* At shutdown, the default may be gone already */
3994 if (def_zvrf == NULL)
3995 return;
3996
3997 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
3998 if (zvrf->label[afi] != MPLS_LABEL_NONE)
3999 lsp_uninstall(def_zvrf, zvrf->label[afi]);
4000 }
4001 }
4002 }
4003
4004 /*
4005 * When a vrf label is assigned and the client goes away
4006 * we should cleanup the vrf labels associated with
4007 * that zclient.
4008 */
4009 void zebra_mpls_client_cleanup_vrf_label(uint8_t proto)
4010 {
4011 struct vrf *vrf;
4012 struct zebra_vrf *def_zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
4013
4014 if (def_zvrf == NULL)
4015 return;
4016
4017 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
4018 struct zebra_vrf *zvrf = vrf->info;
4019 afi_t afi;
4020
4021 if (!zvrf)
4022 continue;
4023
4024 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
4025 if (zvrf->label_proto[afi] == proto
4026 && zvrf->label[afi] != MPLS_LABEL_NONE)
4027 lsp_uninstall(def_zvrf, zvrf->label[afi]);
4028
4029 /*
4030 * Cleanup data structures by fiat
4031 */
4032 zvrf->label_proto[afi] = 0;
4033 zvrf->label[afi] = MPLS_LABEL_NONE;
4034 }
4035 }
4036 }
4037
4038 static void lsp_table_free(void *p)
4039 {
4040 struct zebra_lsp *lsp = p;
4041
4042 lsp_free_nhlfe(lsp);
4043
4044 XFREE(MTYPE_LSP, lsp);
4045 }
4046
4047 /*
4048 * Called upon process exiting, need to delete LSP forwarding
4049 * entries from the kernel.
4050 * NOTE: Currently supported only for default VRF.
4051 */
4052 void zebra_mpls_close_tables(struct zebra_vrf *zvrf)
4053 {
4054 hash_iterate(zvrf->lsp_table, lsp_uninstall_from_kernel, NULL);
4055 hash_clean(zvrf->lsp_table, lsp_table_free);
4056 hash_free(zvrf->lsp_table);
4057 hash_clean(zvrf->slsp_table, lsp_table_free);
4058 hash_free(zvrf->slsp_table);
4059 route_table_finish(zvrf->fec_table[AFI_IP]);
4060 route_table_finish(zvrf->fec_table[AFI_IP6]);
4061 }
4062
4063 /*
4064 * Allocate MPLS tables for this VRF and do other initialization.
4065 * NOTE: Currently supported only for default VRF.
4066 */
4067 void zebra_mpls_init_tables(struct zebra_vrf *zvrf)
4068 {
4069 char buffer[80];
4070
4071 if (!zvrf)
4072 return;
4073
4074 snprintf(buffer, sizeof(buffer), "ZEBRA SLSP table: %s",
4075 zvrf->vrf->name);
4076 zvrf->slsp_table = hash_create_size(8, label_hash, label_cmp, buffer);
4077
4078 snprintf(buffer, sizeof(buffer), "ZEBRA LSP table: %s",
4079 zvrf->vrf->name);
4080 zvrf->lsp_table = hash_create_size(8, label_hash, label_cmp, buffer);
4081 zvrf->fec_table[AFI_IP] = route_table_init();
4082 zvrf->fec_table[AFI_IP6] = route_table_init();
4083 zvrf->mpls_flags = 0;
4084 zvrf->mpls_srgb.start_label = MPLS_DEFAULT_MIN_SRGB_LABEL;
4085 zvrf->mpls_srgb.end_label = MPLS_DEFAULT_MAX_SRGB_LABEL;
4086 }
4087
4088 void zebra_mpls_turned_on(void)
4089 {
4090 if (!mpls_enabled) {
4091 mpls_processq_init();
4092 mpls_enabled = true;
4093 }
4094
4095 hook_register(zserv_client_close, zebra_mpls_cleanup_fecs_for_client);
4096 hook_register(zserv_client_close, zebra_mpls_cleanup_zclient_labels);
4097 }
4098
4099 /*
4100 * Global MPLS initialization.
4101 */
4102 void zebra_mpls_init(void)
4103 {
4104 mpls_enabled = false;
4105 mpls_pw_reach_strict = false;
4106
4107 if (mpls_kernel_init() < 0) {
4108 flog_warn(EC_ZEBRA_MPLS_SUPPORT_DISABLED,
4109 "Disabling MPLS support (no kernel support)");
4110 return;
4111 }
4112
4113 zebra_mpls_turned_on();
4114 }
FRRouting mirror