2 * mpls_tunnel.c: MPLS tunnel interfaces (i.e. for RSVP-TE)
4 * Copyright (c) 2012 Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <vnet/vnet.h>
19 #include <vnet/mpls/mpls_tunnel.h>
20 #include <vnet/mpls/mpls_types.h>
21 #include <vnet/ip/ip.h>
22 #include <vnet/fib/fib_path_list.h>
23 #include <vnet/adj/adj_midchain.h>
24 #include <vnet/adj/adj_mcast.h>
25 #include <vnet/dpo/replicate_dpo.h>
26 #include <vnet/fib/mpls_fib.h>
29 * @brief pool of tunnel instances
31 static mpls_tunnel_t *mpls_tunnel_pool;
34 * @brief DB of SW index to tunnel index
36 static u32 *mpls_tunnel_db;
39 * @brief MPLS tunnel flags strings
41 static const char *mpls_tunnel_attribute_names[] = MPLS_TUNNEL_ATTRIBUTES;
44 * @brief Get a tunnel object from a SW interface index
47 mpls_tunnel_get_from_sw_if_index (u32 sw_if_index)
49 if ((vec_len(mpls_tunnel_db) <= sw_if_index) ||
50 (~0 == mpls_tunnel_db[sw_if_index]))
53 return (pool_elt_at_index(mpls_tunnel_pool,
54 mpls_tunnel_db[sw_if_index]));
58 * @brief Build a rewrite string for the MPLS tunnel.
61 mpls_tunnel_build_rewrite_i (void)
64 * passing the adj code a NULL rewrite means 'i don't have one cos
65 * t'other end is unresolved'. That's not the case here. For the mpls
66 * tunnel there are just no bytes of encap to apply in the adj. We'll impose
67 * the label stack once we choose a path. So return a zero length rewrite.
71 vec_validate(rewrite, 0);
72 vec_reset_length(rewrite);
78 * @brief Build a rewrite string for the MPLS tunnel.
81 mpls_tunnel_build_rewrite (vnet_main_t * vnm,
83 vnet_link_t link_type,
84 const void *dst_address)
86 return (mpls_tunnel_build_rewrite_i());
89 typedef struct mpls_tunnel_collect_forwarding_ctx_t_
91 load_balance_path_t * next_hops;
92 const mpls_tunnel_t *mt;
93 fib_forward_chain_type_t fct;
94 } mpls_tunnel_collect_forwarding_ctx_t;
96 static fib_path_list_walk_rc_t
97 mpls_tunnel_collect_forwarding (fib_node_index_t pl_index,
98 fib_node_index_t path_index,
101 mpls_tunnel_collect_forwarding_ctx_t *ctx;
102 fib_path_ext_t *path_ext;
107 * if the path is not resolved, don't include it.
109 if (!fib_path_is_resolved(path_index))
111 return (FIB_PATH_LIST_WALK_CONTINUE);
115 * get the matching path-extension for the path being visited.
117 path_ext = fib_path_ext_list_find_by_path_index(&ctx->mt->mt_path_exts,
121 * we don't want IP TTL decrements for packets hitting the MPLS labels
122 * we stack on, since the IP TTL decrement is done by the adj
124 path_ext->fpe_mpls_flags |= FIB_PATH_EXT_MPLS_FLAG_NO_IP_TTL_DECR;
127 * found a matching extension. stack it to obtain the forwarding
128 * info for this path.
130 ctx->next_hops = fib_path_ext_stack(path_ext,
135 return (FIB_PATH_LIST_WALK_CONTINUE);
139 mpls_tunnel_mk_lb (mpls_tunnel_t *mt,
141 fib_forward_chain_type_t fct,
144 dpo_proto_t lb_proto;
147 * If the entry has path extensions then we construct a load-balance
148 * by stacking the extensions on the forwarding chains of the paths.
149 * Otherwise we use the load-balance of the path-list
151 mpls_tunnel_collect_forwarding_ctx_t ctx = {
158 * As an optimisation we allocate the vector of next-hops to be sized
159 * equal to the maximum nuber of paths we will need, which is also the
160 * most likely number we will need, since in most cases the paths are 'up'.
162 vec_validate(ctx.next_hops, fib_path_list_get_n_paths(mt->mt_path_list));
163 vec_reset_length(ctx.next_hops);
165 lb_proto = fib_forw_chain_type_to_dpo_proto(fct);
167 if (FIB_NODE_INDEX_INVALID != mt->mt_path_list)
169 fib_path_list_walk(mt->mt_path_list,
170 mpls_tunnel_collect_forwarding,
174 if (!dpo_id_is_valid(dpo_lb))
179 if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST)
184 replicate_create(0, lb_proto));
188 flow_hash_config_t fhc;
193 fhc = MPLS_FLOW_HASH_DEFAULT;
197 fhc = IP_FLOW_HASH_DEFAULT;
207 load_balance_create(0, lb_proto, fhc));
211 if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST)
216 replicate_multipath_update(dpo_lb, ctx.next_hops);
220 load_balance_multipath_update(dpo_lb,
222 LOAD_BALANCE_FLAG_NONE);
223 vec_free(ctx.next_hops);
230 * 'stack' (resolve the recursion for) the tunnel's midchain adjacency
233 mpls_tunnel_stack (adj_index_t ai)
240 sw_if_index = adj->rewrite_header.sw_if_index;
242 mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
244 if (NULL == mt || FIB_NODE_INDEX_INVALID == mt->mt_path_list)
247 if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
249 adj_nbr_midchain_unstack(ai);
254 * while we're stacking the adj, remove the tunnel from the child list
255 * of the path list. this breaks a circular dependency of walk updates
256 * where the create of adjacencies in the children can lead to walks
257 * that get back here.
259 fib_path_list_lock(mt->mt_path_list);
261 fib_path_list_child_remove(mt->mt_path_list,
262 mt->mt_sibling_index);
265 * Construct the DPO (load-balance or replicate) that we can stack
266 * the tunnel's midchain on
268 if (vnet_hw_interface_get_flags(vnet_get_main(),
269 mt->mt_hw_if_index) &
270 VNET_HW_INTERFACE_FLAG_LINK_UP)
272 dpo_id_t dpo = DPO_INVALID;
274 mpls_tunnel_mk_lb(mt,
276 fib_forw_chain_type_from_link_type(
277 adj_get_link_type(ai)),
280 adj_nbr_midchain_stack(ai, &dpo);
285 adj_nbr_midchain_unstack(ai);
288 mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
289 FIB_NODE_TYPE_MPLS_TUNNEL,
290 mt - mpls_tunnel_pool);
292 fib_path_list_unlock(mt->mt_path_list);
296 * @brief Call back when restacking all adjacencies on a MPLS interface
299 mpls_adj_walk_cb (adj_index_t ai,
302 mpls_tunnel_stack(ai);
304 return (ADJ_WALK_RC_CONTINUE);
308 mpls_tunnel_restack (mpls_tunnel_t *mt)
310 fib_protocol_t proto;
313 * walk all the adjacencies on the MPLS interface and restack them
315 if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
318 * Stack a load-balance that drops, whilst we have no paths
320 vnet_hw_interface_t * hi;
321 dpo_id_t dpo = DPO_INVALID;
323 mpls_tunnel_mk_lb(mt,
325 FIB_FORW_CHAIN_TYPE_ETHERNET,
328 hi = vnet_get_hw_interface(vnet_get_main(), mt->mt_hw_if_index);
329 dpo_stack_from_node(hi->tx_node_index,
336 FOR_EACH_FIB_IP_PROTOCOL(proto)
338 adj_nbr_walk(mt->mt_sw_if_index,
346 static clib_error_t *
347 mpls_tunnel_admin_up_down (vnet_main_t * vnm,
351 vnet_hw_interface_t * hi;
354 hi = vnet_get_hw_interface (vnm, hw_if_index);
356 mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index);
361 if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
362 vnet_hw_interface_set_flags (vnm, hw_if_index,
363 VNET_HW_INTERFACE_FLAG_LINK_UP);
365 vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */);
367 mpls_tunnel_restack(mt);
373 * @brief Fixup the adj rewrite post encap. This is a no-op since the
374 * rewrite is a stack of labels.
377 mpls_tunnel_fixup (vlib_main_t *vm,
378 const ip_adjacency_t *adj,
383 * A no-op w.r.t. the header. but reset the 'have we pushed any
384 * MPLS labels onto the packet' flag. That way when we enter the
385 * tunnel we'll get a TTL set to 255
387 vnet_buffer(b0)->mpls.first = 0;
391 mpls_tunnel_update_adj (vnet_main_t * vnm,
397 ASSERT(ADJ_INDEX_INVALID != ai);
401 switch (adj->lookup_next_index)
403 case IP_LOOKUP_NEXT_ARP:
404 case IP_LOOKUP_NEXT_GLEAN:
405 case IP_LOOKUP_NEXT_BCAST:
406 adj_nbr_midchain_update_rewrite(ai, mpls_tunnel_fixup,
409 mpls_tunnel_build_rewrite_i());
411 case IP_LOOKUP_NEXT_MCAST:
413 * Construct a partial rewrite from the known ethernet mcast dest MAC
414 * There's no MAC fixup, so the last 2 parameters are 0
416 adj_mcast_midchain_update_rewrite(ai, mpls_tunnel_fixup,
419 mpls_tunnel_build_rewrite_i(),
423 case IP_LOOKUP_NEXT_DROP:
424 case IP_LOOKUP_NEXT_PUNT:
425 case IP_LOOKUP_NEXT_LOCAL:
426 case IP_LOOKUP_NEXT_REWRITE:
427 case IP_LOOKUP_NEXT_MIDCHAIN:
428 case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
429 case IP_LOOKUP_NEXT_ICMP_ERROR:
430 case IP_LOOKUP_N_NEXT:
435 mpls_tunnel_stack(ai);
439 format_mpls_tunnel_name (u8 * s, va_list * args)
441 u32 dev_instance = va_arg (*args, u32);
442 return format (s, "mpls-tunnel%d", dev_instance);
446 format_mpls_tunnel_device (u8 * s, va_list * args)
448 u32 dev_instance = va_arg (*args, u32);
449 CLIB_UNUSED (int verbose) = va_arg (*args, int);
451 return (format (s, "MPLS-tunnel: id %d\n", dev_instance));
455 * @brief Packet trace structure
457 typedef struct mpls_tunnel_trace_t_
460 * Tunnel-id / index in tunnel vector
463 } mpls_tunnel_trace_t;
466 format_mpls_tunnel_tx_trace (u8 * s,
469 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
470 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
471 mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *);
473 s = format (s, "MPLS: tunnel %d", t->tunnel_id);
478 * @brief TX function. Only called L2. L3 traffic uses the adj-midchains
481 mpls_tunnel_tx (vlib_main_t * vm,
482 vlib_node_runtime_t * node,
483 vlib_frame_t * frame)
486 u32 * from, * to_next, n_left_from, n_left_to_next;
487 vnet_interface_output_runtime_t * rd = (void *) node->runtime_data;
488 const mpls_tunnel_t *mt;
490 mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance);
492 /* Vector of buffer / pkt indices we're supposed to process */
493 from = vlib_frame_vector_args (frame);
495 /* Number of buffers / pkts */
496 n_left_from = frame->n_vectors;
498 /* Speculatively send the first buffer to the last disposition we used */
499 next_index = node->cached_next_index;
501 while (n_left_from > 0)
503 /* set up to enqueue to our disposition with index = next_index */
504 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
509 while (n_left_from > 0 && n_left_to_next > 0)
521 b0 = vlib_get_buffer(vm, bi0);
523 vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_lb.dpoi_index;
524 /* since we are coming out of the L2 world, where the vlib_buffer
525 * union is used for other things, make sure it is clean for
528 vnet_buffer(b0)->mpls.first = 0;
530 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
532 mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node,
534 tr->tunnel_id = rd->dev_instance;
537 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
538 to_next, n_left_to_next,
539 bi0, mt->mt_l2_lb.dpoi_next_node);
542 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
545 return frame->n_vectors;
548 VNET_DEVICE_CLASS (mpls_tunnel_class) = {
549 .name = "MPLS tunnel device",
550 .format_device_name = format_mpls_tunnel_name,
551 .format_device = format_mpls_tunnel_device,
552 .format_tx_trace = format_mpls_tunnel_tx_trace,
553 .tx_function = mpls_tunnel_tx,
554 .admin_up_down_function = mpls_tunnel_admin_up_down,
557 VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = {
558 .name = "MPLS-Tunnel",
559 .update_adjacency = mpls_tunnel_update_adj,
560 .build_rewrite = mpls_tunnel_build_rewrite,
561 .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
564 const mpls_tunnel_t *
565 mpls_tunnel_get (u32 mti)
567 return (pool_elt_at_index(mpls_tunnel_pool, mti));
571 * @brief Walk all the MPLS tunnels
574 mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb,
579 pool_foreach_index(mti, mpls_tunnel_pool,
586 vnet_mpls_tunnel_del (u32 sw_if_index)
590 mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
595 if (FIB_NODE_INDEX_INVALID != mt->mt_path_list)
596 fib_path_list_child_remove(mt->mt_path_list,
597 mt->mt_sibling_index);
598 dpo_reset(&mt->mt_l2_lb);
600 vnet_delete_hw_interface (vnet_get_main(), mt->mt_hw_if_index);
602 pool_put(mpls_tunnel_pool, mt);
603 mpls_tunnel_db[sw_if_index] = ~0;
607 vnet_mpls_tunnel_create (u8 l2_only,
611 vnet_hw_interface_t * hi;
616 vnm = vnet_get_main();
617 pool_get(mpls_tunnel_pool, mt);
618 clib_memset (mt, 0, sizeof (*mt));
619 mti = mt - mpls_tunnel_pool;
620 fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
621 mt->mt_path_list = FIB_NODE_INDEX_INVALID;
622 mt->mt_sibling_index = FIB_NODE_INDEX_INVALID;
625 mt->mt_flags |= MPLS_TUNNEL_FLAG_MCAST;
627 mt->mt_flags |= MPLS_TUNNEL_FLAG_L2;
629 memcpy(mt->mt_tag, tag, sizeof(mt->mt_tag));
631 mt->mt_tag[0] = '\0';
634 * Create a new tunnel HW interface
636 mt->mt_hw_if_index = vnet_register_interface(
638 mpls_tunnel_class.index,
640 mpls_tunnel_hw_interface_class.index,
642 hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index);
644 /* Standard default MPLS tunnel MTU. */
645 vnet_sw_interface_set_mtu (vnm, hi->sw_if_index, 9000);
648 * Add the new tunnel to the tunnel DB - key:SW if index
650 mt->mt_sw_if_index = hi->sw_if_index;
651 vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0);
652 mpls_tunnel_db[mt->mt_sw_if_index] = mti;
654 return (mt->mt_sw_if_index);
658 vnet_mpls_tunnel_path_add (u32 sw_if_index,
659 fib_route_path_t *rpaths)
661 fib_route_path_t *rpath;
665 mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
670 mti = mt - mpls_tunnel_pool;
673 * construct a path-list from the path provided
675 if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
677 mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths);
678 mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
679 FIB_NODE_TYPE_MPLS_TUNNEL,
684 fib_node_index_t old_pl_index;
686 old_pl_index = mt->mt_path_list;
689 fib_path_list_copy_and_path_add(old_pl_index,
690 FIB_PATH_LIST_FLAG_SHARED,
693 fib_path_list_child_remove(old_pl_index,
694 mt->mt_sibling_index);
695 mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list,
696 FIB_NODE_TYPE_MPLS_TUNNEL,
699 * re-resolve all the path-extensions with the new path-list
701 fib_path_ext_list_resolve(&mt->mt_path_exts, mt->mt_path_list);
703 vec_foreach(rpath, rpaths)
705 fib_path_ext_list_insert(&mt->mt_path_exts,
710 mpls_tunnel_restack(mt);
714 vnet_mpls_tunnel_path_remove (u32 sw_if_index,
715 fib_route_path_t *rpaths)
720 mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
725 mti = mt - mpls_tunnel_pool;
728 * construct a path-list from the path provided
730 if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
732 /* can't remove a path if we have onoe */
737 fib_node_index_t old_pl_index;
739 old_pl_index = mt->mt_path_list;
741 fib_path_list_lock(old_pl_index);
743 fib_path_list_copy_and_path_remove(old_pl_index,
744 FIB_PATH_LIST_FLAG_SHARED,
747 fib_path_list_child_remove(old_pl_index,
748 mt->mt_sibling_index);
750 if (FIB_NODE_INDEX_INVALID == mt->mt_path_list)
753 fib_path_list_unlock(old_pl_index);
758 mt->mt_sibling_index =
759 fib_path_list_child_add(mt->mt_path_list,
760 FIB_NODE_TYPE_MPLS_TUNNEL,
764 * find the matching path extension and remove it
766 fib_path_ext_list_remove(&mt->mt_path_exts,
771 * re-resolve all the path-extensions with the new path-list
773 fib_path_ext_list_resolve(&mt->mt_path_exts,
776 mpls_tunnel_restack(mt);
777 fib_path_list_unlock(old_pl_index);
780 return (fib_path_list_get_n_paths(mt->mt_path_list));
784 vnet_mpls_tunnel_get_index (u32 sw_if_index)
788 mt = mpls_tunnel_get_from_sw_if_index(sw_if_index);
793 return (mt - mpls_tunnel_pool);
796 static clib_error_t *
797 vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm,
798 unformat_input_t * input,
799 vlib_cli_command_t * cmd)
801 unformat_input_t _line_input, * line_input = &_line_input;
802 vnet_main_t * vnm = vnet_get_main();
803 u8 is_del = 0, l2_only = 0, is_multicast =0;
804 fib_route_path_t rpath, *rpaths = NULL;
805 u32 sw_if_index = ~0, payload_proto;
806 clib_error_t *error = NULL;
808 clib_memset(&rpath, 0, sizeof(rpath));
809 payload_proto = DPO_PROTO_MPLS;
811 /* Get a line of input. */
812 if (! unformat_user (input, unformat_line_input, line_input))
815 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
817 if (unformat (line_input, "del %U",
818 unformat_vnet_sw_interface, vnm,
821 else if (unformat (line_input, "add %U",
822 unformat_vnet_sw_interface, vnm,
825 else if (unformat (line_input, "add"))
827 else if (unformat (line_input, "l2-only"))
829 else if (unformat (line_input, "multicast"))
831 else if (unformat (line_input, "via %U",
832 unformat_fib_route_path,
833 &rpath, &payload_proto))
834 vec_add1(rpaths, rpath);
837 error = clib_error_return (0, "unknown input '%U'",
838 format_unformat_error, line_input);
847 vnet_mpls_tunnel_del(sw_if_index);
849 else if (!vnet_mpls_tunnel_path_remove(sw_if_index, rpaths))
851 vnet_mpls_tunnel_del(sw_if_index);
856 if (0 == vec_len(rpath.frp_label_stack))
858 error = clib_error_return (0, "No Output Labels '%U'",
859 format_unformat_error, line_input);
863 if (~0 == sw_if_index)
865 sw_if_index = vnet_mpls_tunnel_create(l2_only, is_multicast, NULL);
867 vnet_mpls_tunnel_path_add(sw_if_index, rpaths);
872 unformat_free (line_input);
878 * This command create a uni-directional MPLS tunnel
881 * @cliexstart{create mpls tunnel}
882 * create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34
885 VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = {
886 .path = "mpls tunnel",
888 "mpls tunnel [multicast] [l2-only] via [next-hop-address] [next-hop-interface] [next-hop-table <value>] [weight <value>] [preference <value>] [udp-encap-id <value>] [ip4-lookup-in-table <value>] [ip6-lookup-in-table <value>] [mpls-lookup-in-table <value>] [resolve-via-host] [resolve-via-connected] [rx-ip4 <interface>] [out-labels <value value value>]",
889 .function = vnet_create_mpls_tunnel_command_fn,
893 format_mpls_tunnel (u8 * s, va_list * args)
895 mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *);
896 mpls_tunnel_attribute_t attr;
898 s = format(s, "mpls-tunnel%d: sw_if_index:%d hw_if_index:%d",
899 mt - mpls_tunnel_pool,
902 if (MPLS_TUNNEL_FLAG_NONE != mt->mt_flags) {
903 s = format(s, " \n flags:");
904 FOR_EACH_MPLS_TUNNEL_ATTRIBUTE(attr) {
905 if ((1<<attr) & mt->mt_flags) {
906 s = format (s, "%s,", mpls_tunnel_attribute_names[attr]);
910 s = format(s, "\n via:\n");
911 s = fib_path_list_format(mt->mt_path_list, s);
912 s = format(s, "%U", format_fib_path_ext_list, &mt->mt_path_exts);
915 if (mt->mt_flags & MPLS_TUNNEL_FLAG_L2)
917 s = format(s, " forwarding: %U\n",
918 format_fib_forw_chain_type,
919 FIB_FORW_CHAIN_TYPE_ETHERNET);
920 s = format(s, " %U\n", format_dpo_id, &mt->mt_l2_lb, 2);
926 static clib_error_t *
927 show_mpls_tunnel_command_fn (vlib_main_t * vm,
928 unformat_input_t * input,
929 vlib_cli_command_t * cmd)
934 if (pool_elts (mpls_tunnel_pool) == 0)
935 vlib_cli_output (vm, "No MPLS tunnels configured...");
937 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
939 if (unformat (input, "%d", &mti))
947 pool_foreach (mt, mpls_tunnel_pool,
949 vlib_cli_output (vm, "[@%d] %U",
950 mt - mpls_tunnel_pool,
951 format_mpls_tunnel, mt);
956 if (pool_is_free_index(mpls_tunnel_pool, mti))
957 return clib_error_return (0, "Not a tunnel index %d", mti);
959 mt = pool_elt_at_index(mpls_tunnel_pool, mti);
961 vlib_cli_output (vm, "[@%d] %U",
962 mt - mpls_tunnel_pool,
963 format_mpls_tunnel, mt);
970 * This command to show MPLS tunnels
973 * @cliexstart{sh mpls tunnel 2}
974 * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5
978 * index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ]
979 * index:26 pl-index:26 ipv4 weight=1 attached-nexthop: oper-flags:resolved,
981 * [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc
984 VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = {
985 .path = "show mpls tunnel",
986 .function = show_mpls_tunnel_command_fn,
989 static mpls_tunnel_t *
990 mpls_tunnel_from_fib_node (fib_node_t *node)
992 ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type);
993 return ((mpls_tunnel_t*) (((char*)node) -
994 STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node)));
998 * Function definition to backwalk a FIB node
1000 static fib_node_back_walk_rc_t
1001 mpls_tunnel_back_walk (fib_node_t *node,
1002 fib_node_back_walk_ctx_t *ctx)
1004 mpls_tunnel_restack(mpls_tunnel_from_fib_node(node));
1006 return (FIB_NODE_BACK_WALK_CONTINUE);
1010 * Function definition to get a FIB node from its index
1013 mpls_tunnel_fib_node_get (fib_node_index_t index)
1017 mt = pool_elt_at_index(mpls_tunnel_pool, index);
1019 return (&mt->mt_node);
1023 * Function definition to inform the FIB node that its last lock has gone.
1026 mpls_tunnel_last_lock_gone (fib_node_t *node)
1029 * The MPLS MPLS tunnel is a root of the graph. As such
1030 * it never has children and thus is never locked.
1036 * Virtual function table registered by MPLS MPLS tunnels
1037 * for participation in the FIB object graph.
1039 const static fib_node_vft_t mpls_vft = {
1040 .fnv_get = mpls_tunnel_fib_node_get,
1041 .fnv_last_lock = mpls_tunnel_last_lock_gone,
1042 .fnv_back_walk = mpls_tunnel_back_walk,
1045 static clib_error_t *
1046 mpls_tunnel_init (vlib_main_t *vm)
1048 fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft);
1052 VLIB_INIT_FUNCTION(mpls_tunnel_init);