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