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