diff options
Diffstat (limited to 'vnet')
46 files changed, 2694 insertions, 2596 deletions
diff --git a/vnet/Makefile.am b/vnet/Makefile.am index 0ba07bac5bd..7d6abc60840 100644 --- a/vnet/Makefile.am +++ b/vnet/Makefile.am @@ -452,12 +452,13 @@ libvnet_la_SOURCES += \ vnet/mpls/mpls_features.c \ vnet/mpls/node.c \ vnet/mpls/interface.c \ - vnet/mpls/policy_encap.c \ + vnet/mpls/mpls_tunnel.c \ vnet/mpls/pg.c nobase_include_HEADERS += \ vnet/mpls/mpls.h \ vnet/mpls/mpls_types.h \ + vnet/mpls/mpls_tunnel.h \ vnet/mpls/packet.h \ vnet/mpls/error.def @@ -801,6 +802,7 @@ libvnet_la_SOURCES += \ vnet/fib/fib_entry_src_mpls.c \ vnet/fib/fib_entry_src_lisp.c \ vnet/fib/fib_entry_cover.c \ + vnet/fib/fib_entry_delegate.c \ vnet/fib/fib_path_list.c \ vnet/fib/fib_path.c \ vnet/fib/fib_path_ext.c \ @@ -815,7 +817,8 @@ nobase_include_HEADERS += \ vnet/fib/fib_table.h \ vnet/fib/fib_node.h \ vnet/fib/fib_node_list.h \ - vnet/fib/fib_entry.h + vnet/fib/fib_entry.h \ + vnet/fib/fib_entry_delegate.h ######################################## # ADJ diff --git a/vnet/etc/scripts/mpls-tunnel b/vnet/etc/scripts/mpls-tunnel new file mode 100644 index 00000000000..d04b29702e7 --- /dev/null +++ b/vnet/etc/scripts/mpls-tunnel @@ -0,0 +1,87 @@ +packet-generator new { + name x0 + limit 1 + node ip4-input + size 64-64 + no-recycle + data { + ICMP: 1.0.0.2 -> 2.0.0.2 + ICMP echo_request + incrementing 100 + } +} +packet-generator new { + name x1 + limit 1 + node ip4-input + size 64-64 + no-recycle + data { + ICMP: 1.0.0.2 -> 2.0.1.2 + ICMP echo_request + incrementing 100 + } +} +packet-generator new { + name x2 + limit 1 + node ip4-input + size 64-64 + no-recycle + data { + ICMP: 1.0.0.2 -> 2.0.2.2 + ICMP echo_request + incrementing 100 + } +} +packet-generator new { + name x3 + limit 1 + node ip4-input + size 64-64 + no-recycle + data { + ICMP: 1.0.0.2 -> 2.0.3.2 + ICMP echo_request + incrementing 100 + } +} + + + +trace add pg-input 100 + +loop create +set int state loop0 up + +set int ip address loop0 10.0.0.1/24 +set ip arp loop0 10.0.0.2 00:00:11:aa:bb:cc + +mpls tunnel add via 10.0.0.2 loop0 out-label 33 out-label 34 out-label 35 out-label 36 +set int state mpls-tunnel0 up +set int ip addr mpls-tunnel0 192.168.0.1/32 +ip route add 2.0.0.2/32 via 192.168.0.2 mpls-tunnel0 + + +mpls tunnel add via 10.0.0.2 out-label 33 +set int state mpls-tunnel1 up +set int ip addr mpls-tunnel1 192.168.1.1/32 +ip route add 2.0.1.2/32 via 192.168.1.2 mpls-tunnel1 out-label 99 + +mpls tunnel add via 10.0.0.2 loop0 out-label 3 +set int state mpls-tunnel2 up +set int ip addr mpls-tunnel2 192.168.2.1/32 +ip route add 2.0.2.2/32 via 192.168.2.2 mpls-tunnel2 + + +mpls tunnel add l2-only via 10.0.0.2 loop0 out-label 234 out-label 0 +set int state mpls-tunnel3 up +set int l2 bridge mpls-tunnel3 1 + +loop create +set int ip addr loop1 6.0.1.44/24 +set int l2 bridge loop1 1 bvi +set int l2 learn loop1 disable +set int state loop1 up + +ip route add 2.0.3.2/32 via 6.0.1.45 loop1 diff --git a/vnet/vnet/buffer.h b/vnet/vnet/buffer.h index 2ae4f1ccb70..b3c71c127cc 100644 --- a/vnet/vnet/buffer.h +++ b/vnet/vnet/buffer.h @@ -143,6 +143,18 @@ typedef struct }; } ip; + /* + * MPLS: + * data copied from the MPLS header that was popped from the packet + * during the look-up. + */ + struct + { + u8 ttl; + u8 exp; + u8 first; + } mpls; + /* Multicast replication */ struct { @@ -331,6 +343,14 @@ typedef struct }; } vnet_buffer_opaque_t; +/* + * The opaque field of the vlib_buffer_t is intepreted as a + * vnet_buffer_opaque_t. Hence it should be big enough to accommodate one. + */ +STATIC_ASSERT (sizeof (vnet_buffer_opaque_t) <= STRUCT_SIZE_OF (vlib_buffer_t, + opaque), + "VNET buffer meta-data too large for vlib_buffer"); + #define vnet_buffer(b) ((vnet_buffer_opaque_t *) (b)->opaque) /* Full cache line (64 bytes) of additional space */ diff --git a/vnet/vnet/dhcp/client.c b/vnet/vnet/dhcp/client.c index f555f19ef12..c352e3109ee 100644 --- a/vnet/vnet/dhcp/client.c +++ b/vnet/vnet/dhcp/client.c @@ -224,7 +224,7 @@ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, c->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, // no label stack FIB_ROUTE_PATH_FLAG_NONE); } diff --git a/vnet/vnet/dpo/mpls_label_dpo.c b/vnet/vnet/dpo/mpls_label_dpo.c index 48c03be57fc..606b7ba3911 100644 --- a/vnet/vnet/dpo/mpls_label_dpo.c +++ b/vnet/vnet/dpo/mpls_label_dpo.c @@ -42,29 +42,55 @@ mpls_label_dpo_get_index (mpls_label_dpo_t *mld) } index_t -mpls_label_dpo_create (mpls_label_t label, +mpls_label_dpo_create (mpls_label_t *label_stack, mpls_eos_bit_t eos, u8 ttl, u8 exp, + dpo_proto_t payload_proto, const dpo_id_t *dpo) { mpls_label_dpo_t *mld; + u32 ii; mld = mpls_label_dpo_alloc(); - - vnet_mpls_uc_set_label(&mld->mld_hdr.label_exp_s_ttl, label); - vnet_mpls_uc_set_ttl(&mld->mld_hdr.label_exp_s_ttl, ttl); - vnet_mpls_uc_set_exp(&mld->mld_hdr.label_exp_s_ttl, exp); - vnet_mpls_uc_set_s(&mld->mld_hdr.label_exp_s_ttl, eos); + mld->mld_n_labels = vec_len(label_stack); + mld->mld_payload_proto = payload_proto; /* + * construct label rewrite headers for each value value passed. * get the header in network byte order since we will paint it * on a packet in the data-plane */ - mld->mld_hdr.label_exp_s_ttl = - clib_host_to_net_u32(mld->mld_hdr.label_exp_s_ttl); - dpo_stack(DPO_MPLS_LABEL, DPO_PROTO_MPLS, &mld->mld_dpo, dpo); + for (ii = 0; ii < mld->mld_n_labels-1; ii++) + { + vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]); + vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl, 255); + vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl, 0); + vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, MPLS_NON_EOS); + mld->mld_hdr[ii].label_exp_s_ttl = + clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl); + } + + /* + * the inner most label + */ + ii = mld->mld_n_labels-1; + + vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]); + vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl, ttl); + vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl, exp); + vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, eos); + mld->mld_hdr[ii].label_exp_s_ttl = + clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl); + + /* + * stack this label objct on its parent. + */ + dpo_stack(DPO_MPLS_LABEL, + mld->mld_payload_proto, + &mld->mld_dpo, + dpo); return (mpls_label_dpo_get_index(mld)); } @@ -76,15 +102,20 @@ format_mpls_label_dpo (u8 *s, va_list *args) u32 indent = va_arg (*args, u32); mpls_unicast_header_t hdr; mpls_label_dpo_t *mld; + u32 ii; mld = mpls_label_dpo_get(index); - hdr.label_exp_s_ttl = - clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl); - s = format(s, "mpls-label:[%d]:", index); - s = format(s, "%U\n", format_mpls_header, hdr); - s = format(s, "%U", format_white_space, indent); + + for (ii = 0; ii < mld->mld_n_labels; ii++) + { + hdr.label_exp_s_ttl = + clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl); + s = format(s, "%U", format_mpls_header, hdr); + } + + s = format(s, "\n%U", format_white_space, indent); s = format(s, "%U", format_dpo_id, &mld->mld_dpo, indent+2); return (s); @@ -129,9 +160,11 @@ typedef struct mpls_label_imposition_trace_t_ } mpls_label_imposition_trace_t; always_inline uword -mpls_label_imposition (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) +mpls_label_imposition_inline (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * from_frame, + u8 payload_is_ip4, + u8 payload_is_ip6) { u32 n_left_from, next_index, * from, * to_next; @@ -153,6 +186,7 @@ mpls_label_imposition (vlib_main_t * vm, vlib_buffer_t * b0; u32 bi0, mldi0; u32 next0; + u8 ttl; bi0 = from[0]; to_next[0] = bi0; @@ -167,16 +201,69 @@ mpls_label_imposition (vlib_main_t * vm, mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX]; mld0 = mpls_label_dpo_get(mldi0); + if (payload_is_ip4) + { + /* + * decrement the TTL on ingress to the LSP + */ + ip4_header_t * ip0 = vlib_buffer_get_current(b0); + u32 checksum0; + + checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100); + checksum0 += checksum0 >= 0xffff; + + ip0->checksum = checksum0; + ip0->ttl -= 1; + ttl = ip0->ttl; + } + else if (payload_is_ip6) + { + /* + * decrement the TTL on ingress to the LSP + */ + ip6_header_t * ip0 = vlib_buffer_get_current(b0); + + ip0->hop_limit -= 1; + ttl = ip0->hop_limit; + } + else + { + /* + * else, the packet to be encapped is an MPLS packet + */ + if (vnet_buffer(b0)->mpls.first) + { + /* + * The first label to be imposed on the packet. this is a label swap. + * in which case we stashed the TTL and EXP bits in the + * packet in the lookup node + */ + ASSERT(0 != vnet_buffer (b0)->mpls.ttl); + + ttl = vnet_buffer(b0)->mpls.ttl - 1; + } + else + { + /* + * not the first label. implying we are recusring down a chain of + * output labels. + * Each layer is considered a new LSP - hence the TTL is reset. + */ + ttl = 255; + } + } + vnet_buffer(b0)->mpls.first = 0; + /* Paint the MPLS header */ - vlib_buffer_advance(b0, -sizeof(*hdr0)); + vlib_buffer_advance(b0, -(sizeof(*hdr0) * mld0->mld_n_labels)); hdr0 = vlib_buffer_get_current(b0); - // FIXME. - // need to copy the TTL from the correct place. - // for IPvX imposition from the IP header - // so we need a deidcated ipx-to-mpls-label-imp-node - // for mpls switch and stack another solution is required. - *hdr0 = mld0->mld_hdr; + clib_memcpy(hdr0, mld0->mld_hdr, + sizeof(*hdr0) * mld0->mld_n_labels); + + /* fixup the TTL for the inner most label */ + hdr0 = hdr0 + (mld0->mld_n_labels - 1); + ((char*)hdr0)[3] = ttl; next0 = mld0->mld_dpo.dpoi_next_node; vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index; @@ -215,6 +302,14 @@ format_mpls_label_imposition_trace (u8 * s, va_list * args) return (s); } +static uword +mpls_label_imposition (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + return (mpls_label_imposition_inline(vm, node, frame, 0, 0)); +} + VLIB_REGISTER_NODE (mpls_label_imposition_node) = { .function = mpls_label_imposition, .name = "mpls-label-imposition", @@ -226,7 +321,52 @@ VLIB_REGISTER_NODE (mpls_label_imposition_node) = { [0] = "error-drop", } }; -VLIB_NODE_FUNCTION_MULTIARCH (mpls_label_imposition_node, mpls_label_imposition) +VLIB_NODE_FUNCTION_MULTIARCH (mpls_label_imposition_node, + mpls_label_imposition) + +static uword +ip4_mpls_label_imposition (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + return (mpls_label_imposition_inline(vm, node, frame, 1, 0)); +} + +VLIB_REGISTER_NODE (ip4_mpls_label_imposition_node) = { + .function = ip4_mpls_label_imposition, + .name = "ip4-mpls-label-imposition", + .vector_size = sizeof (u32), + + .format_trace = format_mpls_label_imposition_trace, + .n_next_nodes = 1, + .next_nodes = { + [0] = "error-drop", + } +}; +VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_node, + ip4_mpls_label_imposition) + +static uword +ip6_mpls_label_imposition (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + return (mpls_label_imposition_inline(vm, node, frame, 0, 1)); +} + +VLIB_REGISTER_NODE (ip6_mpls_label_imposition_node) = { + .function = ip6_mpls_label_imposition, + .name = "ip6-mpls-label-imposition", + .vector_size = sizeof (u32), + + .format_trace = format_mpls_label_imposition_trace, + .n_next_nodes = 1, + .next_nodes = { + [0] = "error-drop", + } +}; +VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_node, + ip6_mpls_label_imposition) static void mpls_label_dpo_mem_show (void) @@ -246,12 +386,12 @@ const static dpo_vft_t mld_vft = { const static char* const mpls_label_imp_ip4_nodes[] = { - "mpls-label-imposition", + "ip4-mpls-label-imposition", NULL, }; const static char* const mpls_label_imp_ip6_nodes[] = { - "mpls-label-imposition", + "ip6-mpls-label-imposition", NULL, }; const static char* const mpls_label_imp_mpls_nodes[] = diff --git a/vnet/vnet/dpo/mpls_label_dpo.h b/vnet/vnet/dpo/mpls_label_dpo.h index 47ee344933f..6580c47d7cc 100644 --- a/vnet/vnet/dpo/mpls_label_dpo.h +++ b/vnet/vnet/dpo/mpls_label_dpo.h @@ -26,9 +26,9 @@ typedef struct mpls_label_dpo_t { /** - * The MPLS label header to impose + * The MPLS label header to impose. Outer most label first. */ - mpls_unicast_header_t mld_hdr; + mpls_unicast_header_t mld_hdr[8]; /** * Next DPO in the graph @@ -36,15 +36,45 @@ typedef struct mpls_label_dpo_t dpo_id_t mld_dpo; /** + * The protocol of the payload/packets that are being encapped + */ + dpo_proto_t mld_payload_proto; + + /** + * Size of the label stack + */ + u16 mld_n_labels; + + /** * Number of locks/users of the label */ u16 mld_locks; } mpls_label_dpo_t; -extern index_t mpls_label_dpo_create(mpls_label_t label, +/** + * @brief Assert that the MPLS label object is less than a cache line in size. + * Should this get any bigger then we will need to reconsider how many labels + * can be pushed in one object. + */ +_Static_assert((sizeof(mpls_label_dpo_t) <= CLIB_CACHE_LINE_BYTES), + "MPLS label DPO is larger than one cache line."); + +/** + * @brief Create an MPLS label object + * + * @param label_stack The stack if labels to impose, outer most label first + * @param eos The inner most label's EOS bit + * @param ttl The inner most label's TTL bit + * @param exp The inner most label's EXP bit + * @param payload_proto The ptocool of the payload packets that will + * be imposed with this label header. + * @param dpo The parent of the created MPLS label object + */ +extern index_t mpls_label_dpo_create(mpls_label_t *label_stack, mpls_eos_bit_t eos, u8 ttl, u8 exp, + dpo_proto_t payload_proto, const dpo_id_t *dpo); extern u8* format_mpls_label_dpo(u8 *s, va_list *args); diff --git a/vnet/vnet/ethernet/arp.c b/vnet/vnet/ethernet/arp.c index d0b7132ef74..4968d7b780d 100644 --- a/vnet/vnet/ethernet/arp.c +++ b/vnet/vnet/ethernet/arp.c @@ -557,9 +557,7 @@ vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm, &pfx.fp_addr, e->sw_if_index, ~0, - 1, - MPLS_LABEL_INVALID, - FIB_ROUTE_PATH_FLAG_NONE); + 1, NULL, FIB_ROUTE_PATH_FLAG_NONE); } else { diff --git a/vnet/vnet/fib/fib_attached_export.c b/vnet/vnet/fib/fib_attached_export.c index afc953a4ac5..07bce5548cc 100644 --- a/vnet/vnet/fib/fib_attached_export.c +++ b/vnet/vnet/fib/fib_attached_export.c @@ -16,9 +16,10 @@ #include <vnet/fib/fib_entry.h> #include <vnet/fib/fib_table.h> -#include "fib_attached_export.h" -#include "fib_entry_cover.h" -#include "fib_entry_src.h" +#include <vnet/fib/fib_attached_export.h> +#include <vnet/fib/fib_entry_cover.h> +#include <vnet/fib/fib_entry_src.h> +#include <vnet/fib/fib_entry_delegate.h> /** * A description of the need to import routes from the export table @@ -92,22 +93,27 @@ static fib_ae_export_t *fib_ae_export_pool; static fib_ae_export_t * fib_entry_ae_add_or_lock (fib_node_index_t connected) { + fib_entry_delegate_t *fed; fib_ae_export_t *export; fib_entry_t *entry; entry = fib_entry_get(connected); + fed = fib_entry_delegate_get(entry, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); - if (FIB_NODE_INDEX_INVALID == entry->fe_export) + if (NULL == fed) { + fed = fib_entry_delegate_find_or_add(entry, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); pool_get(fib_ae_export_pool, export); memset(export, 0, sizeof(*export)); - entry->fe_export = (export - fib_ae_export_pool); + fed->fd_index = (export - fib_ae_export_pool); export->faee_ei = connected; } else { - export = pool_elt_at_index(fib_ae_export_pool, entry->fe_export); + export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index); } export->faee_locks++; @@ -235,6 +241,7 @@ void fib_attached_export_import (fib_entry_t *fib_entry, fib_node_index_t export_fib) { + fib_entry_delegate_t *fed; fib_ae_import_t *import; pool_get(fib_ae_import_pool, import); @@ -290,7 +297,9 @@ fib_attached_export_import (fib_entry_t *fib_entry, fib_entry_cover_track(fib_entry_get(import->faei_export_entry), fib_entry_get_index(fib_entry)); - fib_entry->fe_import = (import - fib_ae_import_pool); + fed = fib_entry_delegate_find_or_add(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT); + fed->fd_index = (import - fib_ae_import_pool); } /** @@ -299,15 +308,19 @@ fib_attached_export_import (fib_entry_t *fib_entry, void fib_attached_export_purge (fib_entry_t *fib_entry) { - if (FIB_NODE_INDEX_INVALID != fib_entry->fe_import) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT); + + if (NULL != fed) { fib_node_index_t *import_index; fib_entry_t *export_entry; fib_ae_import_t *import; fib_ae_export_t *export; - import = pool_elt_at_index(fib_ae_import_pool, - fib_entry->fe_import); + import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index); /* * remove each imported entry @@ -342,9 +355,15 @@ fib_attached_export_purge (fib_entry_t *fib_entry) */ if (FIB_NODE_INDEX_INVALID != import->faei_exporter) { + fib_entry_delegate_t *fed; + export_entry = fib_entry_get(import->faei_export_entry); - ASSERT(FIB_NODE_INDEX_INVALID != export_entry->fe_export); - export = pool_elt_at_index(fib_ae_export_pool, export_entry->fe_export); + + fed = fib_entry_delegate_get(export_entry, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); + ASSERT(NULL != fed); + + export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index); u32 index = vec_search(export->faee_importers, (import - fib_ae_import_pool)); @@ -358,7 +377,8 @@ fib_attached_export_purge (fib_entry_t *fib_entry) if (0 == --export->faee_locks) { pool_put(fib_ae_export_pool, export); - export_entry->fe_export = FIB_NODE_INDEX_INVALID; + fib_entry_delegate_remove(export_entry, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); } } @@ -366,7 +386,8 @@ fib_attached_export_purge (fib_entry_t *fib_entry) * free the import tracker */ pool_put(fib_ae_import_pool, import); - fib_entry->fe_import = FIB_NODE_INDEX_INVALID; + fib_entry_delegate_remove(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT); } } @@ -374,7 +395,12 @@ void fib_attached_export_covered_added (fib_entry_t *cover, fib_node_index_t covered) { - if (FIB_NODE_INDEX_INVALID != cover->fe_export) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(cover, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); + + if (NULL != fed) { /* * the covering prefix is exporting to other tables @@ -383,7 +409,7 @@ fib_attached_export_covered_added (fib_entry_t *cover, fib_ae_import_t *import; fib_ae_export_t *export; - export = pool_elt_at_index(fib_ae_export_pool, cover->fe_export); + export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index); /* * export the covered entry to each of the importers @@ -401,7 +427,12 @@ void fib_attached_export_covered_removed (fib_entry_t *cover, fib_node_index_t covered) { - if (FIB_NODE_INDEX_INVALID != cover->fe_export) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(cover, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); + + if (NULL != fed) { /* * the covering prefix is exporting to other tables @@ -410,7 +441,7 @@ fib_attached_export_covered_removed (fib_entry_t *cover, fib_ae_import_t *import; fib_ae_export_t *export; - export = pool_elt_at_index(fib_ae_export_pool, cover->fe_export); + export = pool_elt_at_index(fib_ae_export_pool, fed->fd_index); /* * remove the covered entry from each of the importers @@ -427,7 +458,12 @@ fib_attached_export_covered_removed (fib_entry_t *cover, static void fib_attached_export_cover_modified_i (fib_entry_t *fib_entry) { - if (FIB_NODE_INDEX_INVALID != fib_entry->fe_import) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT); + + if (NULL != fed) { fib_ae_import_t *import; u32 export_fib; @@ -436,7 +472,7 @@ fib_attached_export_cover_modified_i (fib_entry_t *fib_entry) * safe the temporaries we need from the existing import * since it will be toast after the purge. */ - import = pool_elt_at_index(fib_ae_import_pool, fib_entry->fe_import); + import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index); export_fib = import->faei_export_fib; /* @@ -469,15 +505,20 @@ fib_attached_export_cover_update (fib_entry_t *fib_entry) } u8* -fib_ae_import_format (fib_node_index_t import_index, +fib_ae_import_format (fib_entry_t *fib_entry, u8* s) { - if (FIB_NODE_INDEX_INVALID != import_index) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT); + + if (NULL != fed) { fib_node_index_t *index; fib_ae_import_t *import; - import = pool_elt_at_index(fib_ae_import_pool, import_index); + import = pool_elt_at_index(fib_ae_import_pool, fed->fd_index); s = format(s, "\n Attached-Import:%d:[", (import - fib_ae_import_pool)); s = format(s, "export-prefix:%U ", format_fib_prefix, &import->faei_prefix); @@ -501,14 +542,20 @@ fib_ae_import_format (fib_node_index_t import_index, } u8* -fib_ae_export_format (fib_node_index_t export_index, u8*s) +fib_ae_export_format (fib_entry_t *fib_entry, + u8* s) { - if (FIB_NODE_INDEX_INVALID != export_index) + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(fib_entry, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT); + + if (NULL != fed) { - fib_node_index_t *index; + fib_node_index_t *index; fib_ae_export_t *export; - export = pool_elt_at_index(fib_ae_export_pool, export_index); + export = pool_elt_at_index(fib_ae_export_pool, fed->fd_list); s = format(s, "\n Attached-Export:%d:[", (export - fib_ae_export_pool)); s = format(s, "export-entry:%d ", export->faee_ei); diff --git a/vnet/vnet/fib/fib_attached_export.h b/vnet/vnet/fib/fib_attached_export.h index ee68481187c..fa28a6e13b8 100644 --- a/vnet/vnet/fib/fib_attached_export.h +++ b/vnet/vnet/fib/fib_attached_export.h @@ -51,7 +51,7 @@ extern void fib_attached_export_covered_removed(fib_entry_t *cover, extern void fib_attached_export_cover_change(fib_entry_t *fib_entry); extern void fib_attached_export_cover_update(fib_entry_t *fib_entry); -extern u8* fib_ae_import_format(fib_node_index_t import_index, u8*s); -extern u8* fib_ae_export_format(fib_node_index_t export_index, u8*s); +extern u8* fib_ae_import_format(fib_entry_t *fib_entry, u8*s); +extern u8* fib_ae_export_format(fib_entry_t *fib_entry, u8*s); #endif diff --git a/vnet/vnet/fib/fib_entry.c b/vnet/vnet/fib/fib_entry.c index da2656e35aa..24b506379ac 100644 --- a/vnet/vnet/fib/fib_entry.c +++ b/vnet/vnet/fib/fib_entry.c @@ -64,47 +64,6 @@ fib_entry_get_proto (const fib_entry_t * fib_entry) return (fib_entry->fe_prefix.fp_proto); } -/** - * @brief Turn the chain type requested by the client into the one they - * really wanted - */ -static fib_forward_chain_type_t -fib_entry_chain_type_fixup (const fib_entry_t *entry, - fib_forward_chain_type_t fct) -{ - if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct) - { - /* - * The EOS chain is a tricky since one cannot know the adjacency - * to link to without knowing what the packets payload protocol - * will be once the label is popped. - */ - fib_forward_chain_type_t dfct; - - dfct = fib_entry_get_default_chain_type(entry); - - if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct) - { - /* - * If the entry being asked is a eos-MPLS label entry, - * then use the payload-protocol field, that we stashed there - * for just this purpose - */ - return (fib_forw_chain_type_from_dpo_proto( - entry->fe_prefix.fp_payload_proto)); - } - /* - * else give them what this entry would be by default. i.e. if it's a v6 - * entry, then the label its local labelled should be carrying v6 traffic. - * If it's a non-EOS label entry, then there are more labels and we want - * a non-eos chain. - */ - return (dfct); - } - - return (fct); -} - fib_forward_chain_type_t fib_entry_get_default_chain_type (const fib_entry_t *fib_entry) { @@ -189,8 +148,8 @@ format_fib_entry (u8 * s, va_list * args) s = format(s, "\n tracking %d covered: ", n_covered); s = fib_entry_cover_list_format(fib_entry, s); } - s = fib_ae_import_format(fib_entry->fe_import, s); - s = fib_ae_export_format(fib_entry->fe_export, s); + s = fib_ae_import_format(fib_entry, s); + s = fib_ae_export_format(fib_entry, s); s = format (s, "\n forwarding: "); } @@ -201,34 +160,33 @@ format_fib_entry (u8 * s, va_list * args) fct = fib_entry_get_default_chain_type(fib_entry); - if (!dpo_id_is_valid(&fib_entry->fe_lb[fct])) + if (!dpo_id_is_valid(&fib_entry->fe_lb)) { s = format (s, " UNRESOLVED\n"); return (s); } else { + s = format(s, " %U-chain\n %U", + format_fib_forw_chain_type, fct, + format_dpo_id, + &fib_entry->fe_lb, + 2); + s = format(s, "\n"); + if (level >= FIB_ENTRY_FORMAT_DETAIL2) { + fib_entry_delegate_type_t fdt; + fib_entry_delegate_t *fed; - FOR_EACH_FIB_FORW_MPLS_CHAIN(fct) + FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed, { s = format(s, " %U-chain\n %U", - format_fib_forw_chain_type, fct, - format_dpo_id, - &fib_entry->fe_lb[fct], - 2); + format_fib_forw_chain_type, + fib_entry_delegate_type_to_chain_type(fdt), + format_dpo_id, &fed->fd_dpo, 2); s = format(s, "\n"); - } - } - else - { - s = format(s, " %U-chain\n %U", - format_fib_forw_chain_type, fct, - format_dpo_id, - &fib_entry->fe_lb[fct], - 2); - s = format(s, "\n"); + }); } } @@ -238,68 +196,6 @@ format_fib_entry (u8 * s, va_list * args) s = fib_node_children_format(fib_entry->fe_node.fn_children, s); } - /* adj = adj_get(fib_entry->fe_prefix.fp_proto, fib_entry->fe_adj_index); */ - - /* ip_multipath_next_hop_t * nhs, tmp_nhs[1]; */ - /* u32 i, j, n_left, n_nhs; */ - /* vlib_counter_t c, sum; */ - /* ip_lookup_main_t *lm = fib_get_lookup_main(fib_entry->fe_prefix.fp_proto); */ - - /* if (adj->n_adj == 1) */ - /* { */ - /* nhs = &tmp_nhs[0]; */ - /* nhs[0].next_hop_adj_index = ~0; /\* not used *\/ */ - /* nhs[0].weight = 1; */ - /* n_nhs = 1; */ - /* } */ - /* else */ - /* { */ - /* ip_multipath_adjacency_t * madj; */ - /* madj = vec_elt_at_index (lm->multipath_adjacencies, adj->heap_handle); */ - /* nhs = heap_elt_at_index (lm->next_hop_heap, madj->normalized_next_hops.heap_offset); */ - /* n_nhs = madj->normalized_next_hops.count; */ - /* } */ - - /* n_left = nhs[0].weight; */ - /* vlib_counter_zero (&sum); */ - /* for (i = j = 0; i < adj->n_adj; i++) */ - /* { */ - /* n_left -= 1; */ - /* vlib_get_combined_counter(&lm->adjacency_counters, */ - /* fib_entry->fe_adj_index + i, */ - /* &c); */ - /* /\* if (clear) *\/ */ - /* /\* vlib_zero_combined_counter (&lm->adjacency_counters, *\/ */ - /* /\* fib_entry->fe_adj_index + i); *\/ */ - - /* vlib_counter_add (&sum, &c); */ - /* if (n_left == 0) */ - /* { */ - /* s = format (s, "%16Ld%16Ld ", sum.packets, sum.bytes); */ - /* s = format (s, "weight %d, index %d", */ - /* nhs[j].weight, fib_entry->fe_adj_index + i); */ - - /* if (adj->n_adj > 1) */ - /* s = format (s, ", multipath"); */ - - /* s = format (s, "\n%U", */ - /* format_ip_adjacency, */ - /* vnet_get_main(), lm, fib_entry->fe_adj_index + i); */ - - /* // vlib_cli_output (vm, "%v", msg); */ - /* //vec_free (msg); */ - /* } */ - /* else */ - /* { */ - /* j++; */ - /* if (j < n_nhs) */ - /* { */ - /* n_left = nhs[j].weight; */ - /* vlib_counter_zero (&sum); */ - /* } */ - /* } */ - /* } */ - return (s); } @@ -315,20 +211,25 @@ fib_entry_from_fib_node (fib_node_t *node) static void fib_entry_last_lock_gone (fib_node_t *node) { - fib_forward_chain_type_t fct; + fib_entry_delegate_type_t fdt; + fib_entry_delegate_t *fed; fib_entry_t *fib_entry; fib_entry = fib_entry_from_fib_node(node); - FOR_EACH_FIB_FORW_MPLS_CHAIN(fct) + FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed, { - dpo_reset(&fib_entry->fe_lb[fct]); - } + dpo_reset(&fed->fd_dpo); + fib_entry_delegate_remove(fib_entry, fdt); + }); FIB_ENTRY_DBG(fib_entry, "last-lock"); fib_node_deinit(&fib_entry->fe_node); // FIXME -RR Backwalk + + ASSERT(0 == vec_len(fib_entry->fe_delegates)); + vec_free(fib_entry->fe_delegates); pool_put(fib_entry_pool, fib_entry); } @@ -487,44 +388,58 @@ fib_entry_contribute_urpf (fib_node_index_t entry_index, */ void fib_entry_contribute_forwarding (fib_node_index_t fib_entry_index, - fib_forward_chain_type_t type, + fib_forward_chain_type_t fct, dpo_id_t *dpo) { + fib_entry_delegate_t *fed; fib_entry_t *fib_entry; fib_entry = fib_entry_get(fib_entry_index); - /* - * these are not the droids you are looking for... - */ - type = fib_entry_chain_type_fixup(fib_entry, type); - - if (!dpo_id_is_valid(&fib_entry->fe_lb[type])) + if (fct == fib_entry_get_default_chain_type(fib_entry)) { - /* - * on-demand create eos/non-eos. - * There is no on-demand delete because: - * - memory versus complexity & reliability: - * leaving unrequired [n]eos LB arounds wastes memory, cleaning - * then up on the right trigger is more code. i favour the latter. - */ - fib_entry_src_mk_lb(fib_entry, - fib_entry_get_best_src_i(fib_entry), - type, - &fib_entry->fe_lb[type]); + dpo_copy(dpo, &fib_entry->fe_lb); } + else + { + fed = fib_entry_delegate_get(fib_entry, + fib_entry_chain_type_to_delegate_type(fct)); + + if (NULL == fed) + { + fed = fib_entry_delegate_find_or_add( + fib_entry, + fib_entry_chain_type_to_delegate_type(fct)); + /* + * on-demand create eos/non-eos. + * There is no on-demand delete because: + * - memory versus complexity & reliability: + * leaving unrequired [n]eos LB arounds wastes memory, cleaning + * then up on the right trigger is more code. i favour the latter. + */ + fib_entry_src_mk_lb(fib_entry, + fib_entry_get_best_src_i(fib_entry), + fct, + &fed->fd_dpo); + } - dpo_copy(dpo, &fib_entry->fe_lb[type]); + dpo_copy(dpo, &fed->fd_dpo); + } } const dpo_id_t * fib_entry_contribute_ip_forwarding (fib_node_index_t fib_entry_index) { + fib_forward_chain_type_t fct; fib_entry_t *fib_entry; fib_entry = fib_entry_get(fib_entry_index); + fct = fib_entry_get_default_chain_type(fib_entry); + + ASSERT((fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP4 || + fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP6)); - return (&fib_entry->fe_lb[fib_entry_get_default_chain_type(fib_entry)]); + return (&fib_entry->fe_lb); } adj_index_t @@ -570,6 +485,27 @@ fib_entry_child_remove (fib_node_index_t fib_entry_index, fib_node_child_remove(FIB_NODE_TYPE_ENTRY, fib_entry_index, sibling_index); + + if (0 == fib_node_get_n_children(FIB_NODE_TYPE_ENTRY, + fib_entry_index)) + { + /* + * if there are no children left then there is no reason to keep + * the non-default forwarding chains. those chains are built only + * because the children want them. + */ + fib_entry_delegate_type_t fdt; + fib_entry_delegate_t *fed; + fib_entry_t *fib_entry; + + fib_entry = fib_entry_get(fib_entry_index); + + FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed, + { + dpo_reset(&fed->fd_dpo); + fib_entry_delegate_remove(fib_entry, fdt); + }); + } } static fib_entry_t * @@ -577,8 +513,8 @@ fib_entry_alloc (u32 fib_index, const fib_prefix_t *prefix, fib_node_index_t *fib_entry_index) { - fib_forward_chain_type_t fct; fib_entry_t *fib_entry; + fib_prefix_t *fep; pool_get(fib_entry_pool, fib_entry); memset(fib_entry, 0, sizeof(*fib_entry)); @@ -587,20 +523,25 @@ fib_entry_alloc (u32 fib_index, FIB_NODE_TYPE_ENTRY); fib_entry->fe_fib_index = fib_index; - fib_entry->fe_prefix = *prefix; + + /* + * the one time we need to update the const prefix is when + * the entry is first created + */ + fep = (fib_prefix_t*)&(fib_entry->fe_prefix); + *fep = *prefix; + if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto) { - fib_entry->fe_prefix.fp_len = 21; + fep->fp_len = 21; + if (MPLS_NON_EOS == fep->fp_eos) + { + fep->fp_payload_proto = DPO_PROTO_MPLS; + } ASSERT(DPO_PROTO_NONE != fib_entry->fe_prefix.fp_payload_proto); } - fib_entry->fe_export = FIB_NODE_INDEX_INVALID; - fib_entry->fe_import = FIB_NODE_INDEX_INVALID; - fib_entry->fe_covered = FIB_NODE_INDEX_INVALID; - FOR_EACH_FIB_FORW_MPLS_CHAIN(fct) - { - dpo_reset(&fib_entry->fe_lb[fct]); - } + dpo_reset(&fib_entry->fe_lb); *fib_entry_index = fib_entry_get_index(fib_entry); @@ -1316,7 +1257,6 @@ fib_entry_recursive_loop_detect (fib_node_index_t entry_index, if (FIB_NODE_INDEX_INVALID != fib_entry->fe_parent) { fib_node_index_t *entries = *entry_indicies; - fib_forward_chain_type_t fct; vec_add1(entries, entry_index); was_looped = fib_path_list_is_looped(fib_entry->fe_parent); @@ -1331,16 +1271,16 @@ fib_entry_recursive_loop_detect (fib_node_index_t entry_index, * re-evaluate all the entry's forwarding * NOTE: this is an inplace modify */ - FOR_EACH_FIB_FORW_MPLS_CHAIN(fct) - { - if (dpo_id_is_valid(&fib_entry->fe_lb[fct])) - { - fib_entry_src_mk_lb(fib_entry, - fib_entry_get_best_src_i(fib_entry), - fct, - &fib_entry->fe_lb[fct]); - } - } + fib_entry_delegate_type_t fdt; + fib_entry_delegate_t *fed; + + FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed, + { + fib_entry_src_mk_lb(fib_entry, + fib_entry_get_best_src_i(fib_entry), + fib_entry_delegate_type_to_chain_type(fdt), + &fed->fd_dpo); + }); } } else @@ -1379,8 +1319,8 @@ fib_entry_get_best_source (fib_node_index_t entry_index) } static int -fib_ip4_address_compare (ip4_address_t * a1, - ip4_address_t * a2) +fib_ip4_address_compare (const ip4_address_t * a1, + const ip4_address_t * a2) { /* * IP addresses are unsiged ints. the return value here needs to be signed @@ -1393,8 +1333,8 @@ fib_ip4_address_compare (ip4_address_t * a1, } static int -fib_ip6_address_compare (ip6_address_t * a1, - ip6_address_t * a2) +fib_ip6_address_compare (const ip6_address_t * a1, + const ip6_address_t * a2) { int i; for (i = 0; i < ARRAY_LEN (a1->as_u16); i++) diff --git a/vnet/vnet/fib/fib_entry.h b/vnet/vnet/fib/fib_entry.h index d62a94043b3..44a5f2e6d7f 100644 --- a/vnet/vnet/fib/fib_entry.h +++ b/vnet/vnet/fib/fib_entry.h @@ -17,6 +17,7 @@ #define __FIB_ENTRY_H__ #include <vnet/fib/fib_node.h> +#include <vnet/fib/fib_entry_delegate.h> #include <vnet/adj/adj.h> #include <vnet/ip/ip.h> #include <vnet/dpo/dpo.h> @@ -363,9 +364,10 @@ typedef struct fib_entry_t_ { */ fib_node_t fe_node; /** - * The prefix of the route + * The prefix of the route. this is const just to be sure. + * It is the entry's key/identity and so should never change. */ - fib_prefix_t fe_prefix; + const fib_prefix_t fe_prefix; /** * The index of the FIB table this entry is in */ @@ -382,7 +384,7 @@ typedef struct fib_entry_t_ { * paint the header straight on without the need to check the packet * type to derive the EOS bit value. */ - dpo_id_t fe_lb[FIB_FORW_CHAIN_MPLS_NUM]; + dpo_id_t fe_lb; // [FIB_FORW_CHAIN_MPLS_NUM]; /** * Vector of source infos. * Most entries will only have 1 source. So we optimise for memory usage, @@ -400,17 +402,11 @@ typedef struct fib_entry_t_ { * be changed by the parent as it manages its list. */ u32 fe_sibling; + /** - * Dependency list of covered entries. - * these are more specific entries that are interested in changes - * to their respective cover - */ - fib_node_list_t fe_covered; - /** - * exporter + * A vector of delegates. */ - fib_node_index_t fe_export; - fib_node_index_t fe_import; + fib_entry_delegate_t *fe_delegates; } fib_entry_t; #define FOR_EACH_FIB_ENTRY_FLAG(_item) \ diff --git a/vnet/vnet/fib/fib_entry_cover.c b/vnet/vnet/fib/fib_entry_cover.c index 06b5b918abc..147c5daa4fd 100644 --- a/vnet/vnet/fib/fib_entry_cover.c +++ b/vnet/vnet/fib/fib_entry_cover.c @@ -21,16 +21,21 @@ u32 fib_entry_cover_track (fib_entry_t* cover, fib_node_index_t covered) { + fib_entry_delegate_t *fed; + FIB_ENTRY_DBG(cover, "cover-track %d", covered); ASSERT(fib_entry_get_index(cover) != covered); - if (FIB_NODE_INDEX_INVALID == cover->fe_covered) + fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED); + + if (NULL == fed) { - cover->fe_covered = fib_node_list_create(); + fed = fib_entry_delegate_find_or_add(cover, FIB_ENTRY_DELEGATE_COVERED); + fed->fd_list = fib_node_list_create(); } - return (fib_node_list_push_front(cover->fe_covered, + return (fib_node_list_push_front(fed->fd_list, 0, FIB_NODE_TYPE_ENTRY, covered)); } @@ -39,16 +44,21 @@ void fib_entry_cover_untrack (fib_entry_t* cover, u32 tracked_index) { + fib_entry_delegate_t *fed; + FIB_ENTRY_DBG(cover, "cover-untrack @ %d", tracked_index); - if (FIB_NODE_INDEX_INVALID == cover->fe_covered) + fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED); + + if (NULL == fed) return; - fib_node_list_remove(cover->fe_covered, tracked_index); + fib_node_list_remove(fed->fd_list, tracked_index); - if (0 == fib_node_list_get_size(cover->fe_covered)) + if (0 == fib_node_list_get_size(fed->fd_list)) { - fib_node_list_destroy(&cover->fe_covered); + fib_node_list_destroy(&fed->fd_list); + fib_entry_delegate_remove(cover, FIB_ENTRY_DELEGATE_COVERED); } } @@ -78,26 +88,35 @@ fib_entry_cover_walk (fib_entry_t *cover, fib_entry_covered_walk_t walk, void *args) { - if (FIB_NODE_INDEX_INVALID != cover->fe_covered) - { - fib_enty_cover_walk_ctx_t ctx = { - .cover = cover, - .walk = walk, - .ctx = args, - }; - - fib_node_list_walk(cover->fe_covered, - fib_entry_cover_walk_node_ptr, - &ctx); - } + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED); + + if (NULL == fed) + return; + + fib_enty_cover_walk_ctx_t ctx = { + .cover = cover, + .walk = walk, + .ctx = args, + }; + + fib_node_list_walk(fed->fd_list, + fib_entry_cover_walk_node_ptr, + &ctx); } u32 fib_entry_cover_get_size (fib_entry_t *cover) { - if (FIB_NODE_INDEX_INVALID != cover->fe_covered) - return (fib_node_list_get_size(cover->fe_covered)); - return (0); + fib_entry_delegate_t *fed; + + fed = fib_entry_delegate_get(cover, FIB_ENTRY_DELEGATE_COVERED); + + if (NULL == fed) + return (0); + + return (fib_node_list_get_size(fed->fd_list)); } typedef struct fib_entry_cover_list_format_ctx_t_ { diff --git a/vnet/vnet/fib/fib_entry_delegate.c b/vnet/vnet/fib/fib_entry_delegate.c new file mode 100644 index 00000000000..a0d45f970b3 --- /dev/null +++ b/vnet/vnet/fib/fib_entry_delegate.c @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/fib/fib_entry_delegate.h> +#include <vnet/fib/fib_entry.h> + +static fib_entry_delegate_t * +fib_entry_delegate_find_i (const fib_entry_t *fib_entry, + fib_entry_delegate_type_t type, + u32 *index) +{ + fib_entry_delegate_t *delegate; + int ii; + + ii = 0; + vec_foreach(delegate, fib_entry->fe_delegates) + { + if (delegate->fd_type == type) + { + if (NULL != index) + *index = ii; + + return (delegate); + } + else + { + ii++; + } + } + + return (NULL); +} + +fib_entry_delegate_t * +fib_entry_delegate_get (const fib_entry_t *fib_entry, + fib_entry_delegate_type_t type) +{ + return (fib_entry_delegate_find_i(fib_entry, type, NULL)); +} + +void +fib_entry_delegate_remove (fib_entry_t *fib_entry, + fib_entry_delegate_type_t type) +{ + fib_entry_delegate_t *fed; + u32 index = ~0; + + fed = fib_entry_delegate_find_i(fib_entry, type, &index); + + ASSERT(NULL != fed); + + vec_del1(fib_entry->fe_delegates, index); +} + +static int +fib_entry_delegate_cmp_for_sort (void * v1, + void * v2) +{ + fib_entry_delegate_t *delegate1 = v1, *delegate2 = v2; + + return (delegate1->fd_type - delegate2->fd_type); +} + +static void +fib_entry_delegate_init (fib_entry_t *fib_entry, + fib_entry_delegate_type_t type) + +{ + fib_entry_delegate_t delegate = { + .fd_entry_index = fib_entry_get_index(fib_entry), + .fd_type = type, + }; + + vec_add1(fib_entry->fe_delegates, delegate); + vec_sort_with_function(fib_entry->fe_delegates, + fib_entry_delegate_cmp_for_sort); +} + +fib_entry_delegate_t * +fib_entry_delegate_find_or_add (fib_entry_t *fib_entry, + fib_entry_delegate_type_t fdt) +{ + fib_entry_delegate_t *delegate; + + delegate = fib_entry_delegate_get(fib_entry, fdt); + + if (NULL == delegate) + { + fib_entry_delegate_init(fib_entry, fdt); + } + + return (fib_entry_delegate_get(fib_entry, fdt)); +} + +fib_entry_delegate_type_t +fib_entry_chain_type_to_delegate_type (fib_forward_chain_type_t fct) +{ + switch (fct) + { + case FIB_FORW_CHAIN_TYPE_UNICAST_IP4: + return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4); + case FIB_FORW_CHAIN_TYPE_UNICAST_IP6: + return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6); + case FIB_FORW_CHAIN_TYPE_MPLS_EOS: + return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS); + case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS: + return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS); + case FIB_FORW_CHAIN_TYPE_ETHERNET: + return (FIB_ENTRY_DELEGATE_CHAIN_ETHERNET); + } + ASSERT(0); + return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4); +} + +fib_forward_chain_type_t +fib_entry_delegate_type_to_chain_type (fib_entry_delegate_type_t fdt) +{ + switch (fdt) + { + case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4: + return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4); + case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6: + return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6); + case FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS: + return (FIB_FORW_CHAIN_TYPE_MPLS_EOS); + case FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS: + return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS); + case FIB_ENTRY_DELEGATE_CHAIN_ETHERNET: + return (FIB_FORW_CHAIN_TYPE_ETHERNET); + case FIB_ENTRY_DELEGATE_COVERED: + case FIB_ENTRY_DELEGATE_ATTACHED_IMPORT: + case FIB_ENTRY_DELEGATE_ATTACHED_EXPORT: + break; + } + ASSERT(0); + return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4); +} diff --git a/vnet/vnet/fib/fib_entry_delegate.h b/vnet/vnet/fib/fib_entry_delegate.h new file mode 100644 index 00000000000..6d3a6549f32 --- /dev/null +++ b/vnet/vnet/fib/fib_entry_delegate.h @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __FIB_ENTRY_DELEGATE_T__ +#define __FIB_ENTRY_DELEGATE_T__ + +#include <vnet/fib/fib_node.h> + +/** + * Delegate types + */ +typedef enum fib_entry_delegate_type_t_ { + /** + * Forwarding chain types: + * for the vast majority of FIB entries only one chain is required - the + * one that forwards traffic matching the fib_entry_t's fib_prefix_t. For those + * fib_entry_t that are a resolution target for other fib_entry_t's they will also + * need the chain to provide forwarding for those children. We store these additional + * chains in delegates to save memory in the common case. + */ + FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4 = FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6 = FIB_FORW_CHAIN_TYPE_UNICAST_IP6, + FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS = FIB_FORW_CHAIN_TYPE_MPLS_EOS, + FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, + FIB_ENTRY_DELEGATE_CHAIN_ETHERNET = FIB_FORW_CHAIN_TYPE_ETHERNET, + /** + * Dependency list of covered entries. + * these are more specific entries that are interested in changes + * to their respective cover + */ + FIB_ENTRY_DELEGATE_COVERED, + /** + * Attached import/export functionality + */ + FIB_ENTRY_DELEGATE_ATTACHED_IMPORT, + FIB_ENTRY_DELEGATE_ATTACHED_EXPORT, +} fib_entry_delegate_type_t; + +#define FOR_EACH_DELEGATE_CHAIN(_entry, _fdt, _fed, _body) \ +{ \ + for (_fdt = FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4; \ + _fdt <= FIB_ENTRY_DELEGATE_CHAIN_ETHERNET; \ + _fdt++) \ + { \ + _fed = fib_entry_delegate_get(_entry, _fdt); \ + if (NULL != _fed) { \ + _body; \ + } \ + } \ +} + +/** + * A Delagate is a means to implmenet the Delagation design pattern; the extension of an + * objects functionality through the composition of, and delgation to, other objects. + * These 'other' objects are delegates. Delagates are thus attached to other FIB objects + * to extend their functionality. + */ +typedef struct fib_entry_delegate_t_ +{ + /** + * The FIB entry object to which the delagate is attached + */ + fib_node_index_t fd_entry_index; + + /** + * The delagate type + */ + fib_entry_delegate_type_t fd_type; + + /** + * A union of data for the different delegate types + * These delegates are stored in a sparse vector on the entry, so they + * must all be of the same size. We could use indirection here for all types, + * i.e. store an index, that's ok for large delegates, like the attached export + * but for the chain delegates it's excessive + */ + union + { + /** + * Valid for the forwarding chain delegates. The LB that is built. + */ + dpo_id_t fd_dpo; + + /** + * Valid for the attached import cases. An index of the importer/exporter + */ + fib_node_index_t fd_index; + + /** + * For the cover tracking. The node list; + */ + fib_node_list_t fd_list; + }; +} fib_entry_delegate_t; + +struct fib_entry_t_; + +extern void fib_entry_delegate_remove(struct fib_entry_t_ *fib_entry, + fib_entry_delegate_type_t type); + +extern fib_entry_delegate_t *fib_entry_delegate_find_or_add(struct fib_entry_t_ *fib_entry, + fib_entry_delegate_type_t fdt); +extern fib_entry_delegate_t *fib_entry_delegate_get(const struct fib_entry_t_ *fib_entry, + fib_entry_delegate_type_t type); + +extern fib_forward_chain_type_t fib_entry_delegate_type_to_chain_type( + fib_entry_delegate_type_t type); + +extern fib_entry_delegate_type_t fib_entry_chain_type_to_delegate_type( + fib_forward_chain_type_t type); + +#endif diff --git a/vnet/vnet/fib/fib_entry_src.c b/vnet/vnet/fib/fib_entry_src.c index 6fb2e64c287..060fac941d2 100644 --- a/vnet/vnet/fib/fib_entry_src.c +++ b/vnet/vnet/fib/fib_entry_src.c @@ -221,6 +221,44 @@ fib_entry_src_valid_out_label (mpls_label_t label) MPLS_IETF_IMPLICIT_NULL_LABEL == label)); } +/** + * @brief Turn the chain type requested by the client into the one they + * really wanted + */ +fib_forward_chain_type_t +fib_entry_chain_type_fixup (const fib_entry_t *entry, + fib_forward_chain_type_t fct) +{ + ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct); + + /* + * The EOS chain is a tricky since one cannot know the adjacency + * to link to without knowing what the packets payload protocol + * will be once the label is popped. + */ + fib_forward_chain_type_t dfct; + + dfct = fib_entry_get_default_chain_type(entry); + + if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct) + { + /* + * If the entry being asked is a eos-MPLS label entry, + * then use the payload-protocol field, that we stashed there + * for just this purpose + */ + return (fib_forw_chain_type_from_dpo_proto( + entry->fe_prefix.fp_payload_proto)); + } + /* + * else give them what this entry would be by default. i.e. if it's a v6 + * entry, then the label its local labelled should be carrying v6 traffic. + * If it's a non-EOS label entry, then there are more labels and we want + * a non-eos chain. + */ + return (dfct); +} + static int fib_entry_src_collect_forwarding (fib_node_index_t pl_index, fib_node_index_t path_index, @@ -255,13 +293,13 @@ fib_entry_src_collect_forwarding (fib_node_index_t pl_index, if (NULL != path_ext && path_ext->fpe_path_index == path_index && - fib_entry_src_valid_out_label(path_ext->fpe_label)) + fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0])) { /* * found a matching extension. stack it to obtain the forwarding * info for this path. */ - ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fct, ctx->next_hops); + ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops); } else { @@ -299,6 +337,21 @@ fib_entry_src_collect_forwarding (fib_node_index_t pl_index, } break; case FIB_FORW_CHAIN_TYPE_MPLS_EOS: + { + /* + * no label. we need a chain based on the payload. fixup. + */ + vec_add2(ctx->next_hops, nh, 1); + + nh->path_index = path_index; + nh->path_weight = fib_path_get_weight(path_index); + fib_path_contribute_forwarding(path_index, + fib_entry_chain_type_fixup(ctx->fib_entry, + ctx->fct), + &nh->path_dpo); + + break; + } case FIB_FORW_CHAIN_TYPE_ETHERNET: ASSERT(0); break; @@ -420,12 +473,12 @@ fib_entry_src_action_install (fib_entry_t *fib_entry, * the load-balance object only needs to be added to the forwarding * DB once, when it is created. */ - insert = !dpo_id_is_valid(&fib_entry->fe_lb[fct]); + insert = !dpo_id_is_valid(&fib_entry->fe_lb); - fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb[fct]); + fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb); - ASSERT(dpo_id_is_valid(&fib_entry->fe_lb[fct])); - FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb[fct]); + ASSERT(dpo_id_is_valid(&fib_entry->fe_lb)); + FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb); /* * insert the adj into the data-plane forwarding trie @@ -434,51 +487,41 @@ fib_entry_src_action_install (fib_entry_t *fib_entry, { fib_table_fwding_dpo_update(fib_entry->fe_fib_index, &fib_entry->fe_prefix, - &fib_entry->fe_lb[fct]); + &fib_entry->fe_lb); } - if (FIB_FORW_CHAIN_TYPE_UNICAST_IP4 == fct || - FIB_FORW_CHAIN_TYPE_UNICAST_IP6 == fct) + /* + * if any of the other chain types are already created they will need + * updating too + */ + fib_entry_delegate_type_t fdt; + fib_entry_delegate_t *fed; + + FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed, { - for (fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS; - fct <= FIB_FORW_CHAIN_TYPE_MPLS_EOS; - fct++) - { - /* - * if any of the other chain types are already created they will need - * updating too - */ - if (dpo_id_is_valid(&fib_entry->fe_lb[fct])) - { - fib_entry_src_mk_lb(fib_entry, - esrc, - fct, - &fib_entry->fe_lb[fct]); - } - } - } + fib_entry_src_mk_lb(fib_entry, esrc, + fib_entry_delegate_type_to_chain_type(fdt), + &fed->fd_dpo); + }); } void fib_entry_src_action_uninstall (fib_entry_t *fib_entry) { - fib_forward_chain_type_t fct; - - fct = fib_entry_get_default_chain_type(fib_entry); /* * uninstall the forwarding chain from the forwarding tables */ FIB_ENTRY_DBG(fib_entry, "uninstall: %d", fib_entry->fe_adj_index); - if (dpo_id_is_valid(&fib_entry->fe_lb[fct])) + if (dpo_id_is_valid(&fib_entry->fe_lb)) { fib_table_fwding_dpo_remove( fib_entry->fe_fib_index, &fib_entry->fe_prefix, - &fib_entry->fe_lb[fct]); + &fib_entry->fe_lb); - dpo_reset(&fib_entry->fe_lb[fct]); + dpo_reset(&fib_entry->fe_lb); } } @@ -965,7 +1008,7 @@ static void fib_entry_src_path_ext_append (fib_entry_src_t *esrc, const fib_route_path_t *rpath) { - if (MPLS_LABEL_INVALID != rpath->frp_label) + if (NULL != rpath->frp_label_stack) { fib_path_ext_t *path_ext; @@ -991,7 +1034,7 @@ fib_entry_src_path_ext_insert (fib_entry_src_t *esrc, if (0 == vec_len(esrc->fes_path_exts)) return (fib_entry_src_path_ext_append(esrc, rpath)); - if (MPLS_LABEL_INVALID != rpath->frp_label) + if (NULL != rpath->frp_label_stack) { fib_path_ext_t path_ext; int i = 0; @@ -1097,6 +1140,7 @@ fib_entry_src_action_path_swap (fib_entry_t *fib_entry, fib_node_index_t old_path_list, fib_entry_index; fib_path_list_flags_t pl_flags; const fib_route_path_t *rpath; + fib_path_ext_t *path_ext; fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source, NULL); @@ -1138,7 +1182,12 @@ fib_entry_src_action_path_swap (fib_entry_t *fib_entry, pl_flags, rpaths); + vec_foreach(path_ext, esrc->fes_path_exts) + { + vec_free(path_ext->fpe_label_stack); + } vec_free(esrc->fes_path_exts); + vec_foreach(rpath, rpaths) { fib_entry_src_path_ext_append(esrc, rpath); @@ -1192,6 +1241,7 @@ fib_entry_src_action_path_remove (fib_entry_t *fib_entry, * delete the element moving the remaining elements down 1 position. * this preserves the sorted order. */ + vec_free(path_ext->fpe_label_stack); vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts)); break; } diff --git a/vnet/vnet/fib/fib_entry_src.h b/vnet/vnet/fib/fib_entry_src.h index 0b98c1c35c0..640c174db47 100644 --- a/vnet/vnet/fib/fib_entry_src.h +++ b/vnet/vnet/fib/fib_entry_src.h @@ -269,6 +269,9 @@ extern fib_entry_flag_t fib_entry_get_flags_i(const fib_entry_t *fib_entry); extern fib_path_list_flags_t fib_entry_src_flags_2_path_list_flags( fib_entry_flag_t eflags); +extern fib_forward_chain_type_t fib_entry_chain_type_fixup(const fib_entry_t *entry, + fib_forward_chain_type_t fct); + extern void fib_entry_src_mk_lb (fib_entry_t *fib_entry, const fib_entry_src_t *esrc, fib_forward_chain_type_t fct, diff --git a/vnet/vnet/fib/fib_entry_src_rr.c b/vnet/vnet/fib/fib_entry_src_rr.c index 6d56541dec2..ff15c54e281 100644 --- a/vnet/vnet/fib/fib_entry_src_rr.c +++ b/vnet/vnet/fib/fib_entry_src_rr.c @@ -58,6 +58,7 @@ fib_entry_src_rr_resolve_via_connected (fib_entry_src_t *src, vec_free(paths); } + /** * Source initialisation Function */ @@ -79,8 +80,18 @@ fib_entry_src_rr_activate (fib_entry_src_t *src, /* * find the covering prefix. become a dependent thereof. - * there should always be a cover, though it may be the default route. + * for IP there should always be a cover, though it may be the default route. + * For MPLS there is never a cover. */ + if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto) + { + src->fes_pl = fib_path_list_create_special(FIB_PROTOCOL_MPLS, + FIB_PATH_LIST_FLAG_DROP, + NULL); + fib_path_list_lock(src->fes_pl); + return (!0); + } + src->rr.fesr_cover = fib_table_get_less_specific(fib_entry->fe_fib_index, &fib_entry->fe_prefix); @@ -157,12 +168,12 @@ fib_entry_src_rr_deactivate (fib_entry_src_t *src, /* * remove the depednecy on the covering entry */ - ASSERT(FIB_NODE_INDEX_INVALID != src->rr.fesr_cover); - cover = fib_entry_get(src->rr.fesr_cover); - - fib_entry_cover_untrack(cover, src->rr.fesr_sibling); - - src->rr.fesr_cover = FIB_NODE_INDEX_INVALID; + if (FIB_NODE_INDEX_INVALID != src->rr.fesr_cover) + { + cover = fib_entry_get(src->rr.fesr_cover); + fib_entry_cover_untrack(cover, src->rr.fesr_sibling); + src->rr.fesr_cover = FIB_NODE_INDEX_INVALID; + } fib_path_list_unlock(src->fes_pl); src->fes_pl = FIB_NODE_INDEX_INVALID; diff --git a/vnet/vnet/fib/fib_internal.h b/vnet/vnet/fib/fib_internal.h index a0238ac3cdb..2d980bcce0a 100644 --- a/vnet/vnet/fib/fib_internal.h +++ b/vnet/vnet/fib/fib_internal.h @@ -24,6 +24,9 @@ */ #undef FIB_DEBUG +extern void fib_prefix_from_mpls_label(mpls_label_t label, + fib_prefix_t *prf); + extern int fib_route_path_cmp(const fib_route_path_t *rpath1, const fib_route_path_t *rpath2); diff --git a/vnet/vnet/fib/fib_node.c b/vnet/vnet/fib/fib_node.c index 35dc874effb..db3e22bb3b8 100644 --- a/vnet/vnet/fib/fib_node.c +++ b/vnet/vnet/fib/fib_node.c @@ -117,22 +117,6 @@ fib_node_child_add (fib_node_type_t parent_type, index)); } -u32 -fib_node_child_get_n_children (fib_node_type_t parent_type, - fib_node_index_t parent_index) -{ - fib_node_t *parent; - - parent = fn_vfts[parent_type].fnv_get(parent_index); - - if (FIB_NODE_INDEX_INVALID == parent->fn_children) - { - return (0); - } - - return (fib_node_list_get_size(parent->fn_children)); -} - void fib_node_child_remove (fib_node_type_t parent_type, fib_node_index_t parent_index, @@ -152,6 +136,17 @@ fib_node_child_remove (fib_node_type_t parent_type, fib_node_unlock(parent); } +u32 +fib_node_get_n_children (fib_node_type_t parent_type, + fib_node_index_t parent_index) +{ + fib_node_t *parent; + + parent = fn_vfts[parent_type].fnv_get(parent_index); + + return (fib_node_list_get_size(parent->fn_children)); +} + fib_node_back_walk_rc_t fib_node_back_walk_one (fib_node_ptr_t *ptr, diff --git a/vnet/vnet/fib/fib_node.h b/vnet/vnet/fib/fib_node.h index 4aabc64e288..3ad8ee95b64 100644 --- a/vnet/vnet/fib/fib_node.h +++ b/vnet/vnet/fib/fib_node.h @@ -35,6 +35,7 @@ typedef enum fib_node_type_t_ { FIB_NODE_TYPE_PATH, FIB_NODE_TYPE_ADJ, FIB_NODE_TYPE_MPLS_ENTRY, + FIB_NODE_TYPE_MPLS_TUNNEL, FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY, FIB_NODE_TYPE_LISP_ADJ, FIB_NODE_TYPE_GRE_TUNNEL, @@ -54,6 +55,7 @@ typedef enum fib_node_type_t_ { [FIB_NODE_TYPE_PATH_LIST] = "path-list", \ [FIB_NODE_TYPE_PATH] = "path", \ [FIB_NODE_TYPE_MPLS_ENTRY] = "mpls-entry", \ + [FIB_NODE_TYPE_MPLS_TUNNEL] = "mpls-tunnel", \ [FIB_NODE_TYPE_ADJ] = "adj", \ [FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY] = "lisp-gpe-fwd-entry", \ [FIB_NODE_TYPE_LISP_ADJ] = "lisp-adj", \ @@ -341,8 +343,8 @@ extern void fib_node_deinit(fib_node_t *node); extern void fib_node_lock(fib_node_t *node); extern void fib_node_unlock(fib_node_t *node); -extern u32 fib_node_child_get_n_children(fib_node_type_t parent_type, - fib_node_index_t parent_index); +extern u32 fib_node_get_n_children(fib_node_type_t parent_type, + fib_node_index_t parent_index); extern u32 fib_node_child_add(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_type_t child_type, diff --git a/vnet/vnet/fib/fib_path.c b/vnet/vnet/fib/fib_path.c index 988f689b102..809e3e166da 100644 --- a/vnet/vnet/fib/fib_path.c +++ b/vnet/vnet/fib/fib_path.c @@ -207,10 +207,17 @@ typedef struct fib_path_t_ { u32 fp_interface; } attached; struct { - /** - * The next-hop - */ - ip46_address_t fp_nh; + union + { + /** + * The next-hop + */ + ip46_address_t fp_ip; + /** + * The local label to resolve through. + */ + mpls_label_t fp_local_label; + } fp_nh; /** * The FIB table index in which to find the next-hop. * This needs to be fixed. We should lookup the adjacencies in @@ -237,7 +244,7 @@ typedef struct fib_path_t_ { } recursive; struct { /** - * The FIN index in which to perfom the next lookup + * The FIB index in which to perfom the next lookup */ fib_node_index_t fp_tbl_id; } deag; @@ -428,11 +435,22 @@ format_fib_path (u8 * s, va_list * args) } break; case FIB_PATH_TYPE_RECURSIVE: - s = format (s, "via %U", - format_ip46_address, - &path->recursive.fp_nh, - IP46_TYPE_ANY); - s = format (s, " in fib:%d", path->recursive.fp_tbl_id, path->fp_via_fib); + if (FIB_PROTOCOL_MPLS == path->fp_nh_proto) + { + s = format (s, "via %U", + format_mpls_unicast_label, + path->recursive.fp_nh.fp_local_label); + } + else + { + s = format (s, "via %U", + format_ip46_address, + &path->recursive.fp_nh.fp_ip, + IP46_TYPE_ANY); + } + s = format (s, " in fib:%d", + path->recursive.fp_tbl_id, + path->fp_via_fib); s = format (s, " via-fib:%d", path->fp_via_fib); s = format (s, " via-dpo:[%U:%d]", format_dpo_type, path->fp_dpo.dpoi_type, @@ -677,7 +695,7 @@ fib_path_unresolve (fib_path_t *path) { fib_prefix_t pfx; - fib_prefix_from_ip46_addr(&path->recursive.fp_nh, &pfx); + fib_entry_get_prefix(path->fp_via_fib, &pfx); fib_entry_child_remove(path->fp_via_fib, path->fp_sibling); fib_table_entry_special_remove(path->recursive.fp_tbl_id, @@ -1025,7 +1043,14 @@ fib_path_create (fib_node_index_t pl_index, else { path->fp_type = FIB_PATH_TYPE_RECURSIVE; - path->recursive.fp_nh = rpath->frp_addr; + if (FIB_PROTOCOL_MPLS == path->fp_nh_proto) + { + path->recursive.fp_nh.fp_local_label = rpath->frp_local_label; + } + else + { + path->recursive.fp_nh.fp_ip = rpath->frp_addr; + } path->recursive.fp_tbl_id = rpath->frp_fib_index; } } @@ -1301,13 +1326,20 @@ fib_path_cmp_w_route_path (fib_node_index_t path_index, rpath->frp_sw_if_index); break; case FIB_PATH_TYPE_RECURSIVE: - res = ip46_address_cmp(&path->recursive.fp_nh, - &rpath->frp_addr); - - if (0 == res) - { - res = (path->recursive.fp_tbl_id - rpath->frp_fib_index); - } + if (FIB_PROTOCOL_MPLS == path->fp_nh_proto) + { + res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label; + } + else + { + res = ip46_address_cmp(&path->recursive.fp_nh.fp_ip, + &rpath->frp_addr); + } + + if (0 == res) + { + res = (path->recursive.fp_tbl_id - rpath->frp_fib_index); + } break; case FIB_PATH_TYPE_DEAG: res = (path->deag.fp_tbl_id - rpath->frp_fib_index); @@ -1506,7 +1538,14 @@ fib_path_resolve (fib_node_index_t path_index) ASSERT(FIB_NODE_INDEX_INVALID == path->fp_via_fib); - fib_prefix_from_ip46_addr(&path->recursive.fp_nh, &pfx); + if (FIB_PROTOCOL_MPLS == path->fp_nh_proto) + { + fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label, &pfx); + } + else + { + fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx); + } fei = fib_table_entry_special_add(path->recursive.fp_tbl_id, &pfx, @@ -1720,7 +1759,7 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, adj_index_t ai; /* - * get a MPLS link type adj. + * get a appropriate link type adj. */ ai = fib_path_attached_next_hop_get_adj( path, @@ -1739,12 +1778,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, case FIB_FORW_CHAIN_TYPE_MPLS_EOS: case FIB_FORW_CHAIN_TYPE_UNICAST_IP4: case FIB_FORW_CHAIN_TYPE_UNICAST_IP6: - /* - * Assume that EOS and IP forwarding is the same. - * revisit for ieBGP - */ - dpo_copy(dpo, &path->fp_dpo); - break; case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS: fib_path_recursive_adj_update(path, fct, dpo); break; @@ -1898,7 +1931,7 @@ fib_path_encode (fib_node_index_t path_list_index, case FIB_PATH_TYPE_DEAG: break; case FIB_PATH_TYPE_RECURSIVE: - api_rpath->rpath.frp_addr = path->recursive.fp_nh; + api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip; break; default: break; @@ -1906,6 +1939,16 @@ fib_path_encode (fib_node_index_t path_list_index, return (1); } +fib_protocol_t +fib_path_get_proto (fib_node_index_t path_index) +{ + fib_path_t *path; + + path = fib_path_get(path_index); + + return (path->fp_nh_proto); +} + void fib_path_module_init (void) { diff --git a/vnet/vnet/fib/fib_path.h b/vnet/vnet/fib/fib_path.h index 4151c578aed..91f49d09234 100644 --- a/vnet/vnet/fib/fib_path.h +++ b/vnet/vnet/fib/fib_path.h @@ -132,6 +132,7 @@ extern int fib_path_is_recursive(fib_node_index_t path_index); extern int fib_path_is_exclusive(fib_node_index_t path_index); extern int fib_path_is_deag(fib_node_index_t path_index); extern int fib_path_is_looped(fib_node_index_t path_index); +extern fib_protocol_t fib_path_get_proto(fib_node_index_t path_index); extern void fib_path_destroy(fib_node_index_t path_index); extern uword fib_path_hash(fib_node_index_t path_index); extern load_balance_path_t * fib_path_append_nh_for_multipath_hash( diff --git a/vnet/vnet/fib/fib_path_ext.c b/vnet/vnet/fib/fib_path_ext.c index 6603b64f02f..f75b5626c04 100644 --- a/vnet/vnet/fib/fib_path_ext.c +++ b/vnet/vnet/fib/fib_path_ext.c @@ -18,23 +18,28 @@ #include <vnet/dpo/load_balance.h> #include <vnet/dpo/drop_dpo.h> -#include "fib_path_ext.h" -#include "fib_path.h" -#include "fib_path_list.h" -#include "fib_internal.h" +#include <vnet/fib/fib_path_ext.h> +#include <vnet/fib/fib_entry_src.h> +#include <vnet/fib/fib_path.h> +#include <vnet/fib/fib_path_list.h> +#include <vnet/fib/fib_internal.h> u8 * format_fib_path_ext (u8 * s, va_list * args) { fib_path_ext_t *path_ext; + u32 ii; path_ext = va_arg (*args, fib_path_ext_t *); - s = format(s, "path:%d label:%U", - path_ext->fpe_path_index, - format_mpls_unicast_label, - path_ext->fpe_path.frp_label); - + s = format(s, "path:%d labels:", + path_ext->fpe_path_index); + for (ii = 0; ii < vec_len(path_ext->fpe_path.frp_label_stack); ii++) + { + s = format(s, "%U ", + format_mpls_unicast_label, + path_ext->fpe_path.frp_label_stack[ii]); + } return (s); } @@ -86,12 +91,23 @@ fib_path_ext_init (fib_path_ext_t *path_ext, fib_path_ext_resolve(path_ext, path_list_index); } +/** + * @brief Return true if the label stack is implicit null + */ +static int +fib_path_ext_is_imp_null (fib_path_ext_t *path_ext) +{ + return ((1 == vec_len(path_ext->fpe_label_stack)) && + (MPLS_IETF_IMPLICIT_NULL_LABEL == path_ext->fpe_label_stack[0])); +} + load_balance_path_t * fib_path_ext_stack (fib_path_ext_t *path_ext, - fib_forward_chain_type_t parent_fct, + const fib_entry_t *entry, + fib_forward_chain_type_t child_fct, load_balance_path_t *nhs) { - fib_forward_chain_type_t child_fct; + fib_forward_chain_type_t parent_fct; load_balance_path_t *nh; if (!fib_path_is_resolved(path_ext->fpe_path_index)) @@ -102,33 +118,50 @@ fib_path_ext_stack (fib_path_ext_t *path_ext, * label. From the chain type request by the child, determine what * chain type we will request from the parent. */ - switch (parent_fct) + switch (child_fct) { case FIB_FORW_CHAIN_TYPE_MPLS_EOS: - ASSERT(0); - return (nhs); + { + /* + * The EOS chain is a tricky since, when the path has an imp NULL one cannot know + * the adjacency to link to without knowing what the packets payload protocol + * will be once the label is popped. + */ + if (fib_path_ext_is_imp_null(path_ext)) + { + parent_fct = fib_entry_chain_type_fixup(entry, child_fct); + } + else + { + /* + * we have a label to stack. packets will thus be labelled when + * they encounter the child, ergo, non-eos. + */ + parent_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS; + } break; + } case FIB_FORW_CHAIN_TYPE_UNICAST_IP4: case FIB_FORW_CHAIN_TYPE_UNICAST_IP6: - if (MPLS_IETF_IMPLICIT_NULL_LABEL == path_ext->fpe_label) + if (fib_path_ext_is_imp_null(path_ext)) { /* * implicit-null label for the eos or IP chain, need to pick up * the IP adj */ - child_fct = parent_fct; + parent_fct = child_fct; } else { /* * we have a label to stack. packets will thus be labelled when - * they encounter th child, ergo, non-eos. + * they encounter the child, ergo, non-eos. */ - child_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS; + parent_fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS; } break; case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS: - child_fct = parent_fct; + parent_fct = child_fct; break; default: return (nhs); @@ -143,7 +176,7 @@ fib_path_ext_stack (fib_path_ext_t *path_ext, * are to be sent. We stack the MPLS Label DPO on this path DPO */ fib_path_contribute_forwarding(path_ext->fpe_path_index, - child_fct, + parent_fct, &via_dpo); if (dpo_is_drop(&via_dpo) || @@ -165,17 +198,31 @@ fib_path_ext_stack (fib_path_ext_t *path_ext, * The label is stackable for this chain type * construct the mpls header that will be imposed in the data-path */ - if (MPLS_IETF_IMPLICIT_NULL_LABEL != path_ext->fpe_label) + if (!fib_path_ext_is_imp_null(path_ext)) { + /* + * we use the parent protocol for the label so that + * we pickup the correct MPLS imposition nodes to do + * ip[46] processing. + */ + dpo_proto_t chain_proto; + mpls_eos_bit_t eos; + index_t mldi; + + eos = (child_fct == FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS ? + MPLS_NON_EOS : + MPLS_EOS); + chain_proto = fib_forw_chain_type_to_dpo_proto(child_fct); + + mldi = mpls_label_dpo_create(path_ext->fpe_label_stack, + eos, 255, 0, + chain_proto, + &nh->path_dpo); + dpo_set(&nh->path_dpo, DPO_MPLS_LABEL, - DPO_PROTO_MPLS, - mpls_label_dpo_create(path_ext->fpe_label, - (parent_fct == FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS ? - MPLS_NON_EOS : - MPLS_EOS), - 255, 0, - &nh->path_dpo)); + chain_proto, + mldi); } } dpo_reset(&via_dpo); diff --git a/vnet/vnet/fib/fib_path_ext.h b/vnet/vnet/fib/fib_path_ext.h index 6cb7f507ff4..cf8f8df00c6 100644 --- a/vnet/vnet/fib/fib_path_ext.h +++ b/vnet/vnet/fib/fib_path_ext.h @@ -24,10 +24,10 @@ * when packets are sent for that entry over that path. * * For example: - * ip route add 1.1.1.1/32 via 10.10.10.10 mpls-label 100 + * ip route add 1.1.1.1/32 via 10.10.10.10 out-label 100 * * The out-going MPLS label value 100 is a path-extension. It is a value sepcific - * to the entry 1.1.1.1/32 and valid only went packets are sent via 10.10.10.10. + * to the entry 1.1.1.1/32 and valid only when packets are sent via 10.10.10.10. */ typedef struct fib_path_ext_t_ { @@ -37,7 +37,7 @@ typedef struct fib_path_ext_t_ * instance of a fib_path_t that is extended */ fib_route_path_t fpe_path; -#define fpe_label fpe_path.frp_label +#define fpe_label_stack fpe_path.frp_label_stack /** * The index of the path. This is the global index, not the path's @@ -46,6 +46,7 @@ typedef struct fib_path_ext_t_ fib_node_index_t fpe_path_index; } fib_path_ext_t; +struct fib_entry_t_; extern u8 * format_fib_path_ext(u8 * s, va_list * args); @@ -60,6 +61,7 @@ extern void fib_path_ext_resolve(fib_path_ext_t *path_ext, fib_node_index_t path_list_index); extern load_balance_path_t *fib_path_ext_stack(fib_path_ext_t *path_ext, + const struct fib_entry_t_ *entry, fib_forward_chain_type_t fct, load_balance_path_t *nhs); diff --git a/vnet/vnet/fib/fib_path_list.c b/vnet/vnet/fib/fib_path_list.c index 4d695d63d51..5b35e9b87e7 100644 --- a/vnet/vnet/fib/fib_path_list.c +++ b/vnet/vnet/fib/fib_path_list.c @@ -613,6 +613,20 @@ fib_path_list_get_resolving_interface (fib_node_index_t path_list_index) return (sw_if_index); } +fib_protocol_t +fib_path_list_get_proto (fib_node_index_t path_list_index) +{ + fib_path_list_t *path_list; + + path_list = fib_path_list_get(path_list_index); + + /* + * we don't support a mix of path protocols, so we can return the proto + * of the first + */ + return (fib_path_get_proto(path_list->fpl_paths[0])); +} + int fib_path_list_is_looped (fib_node_index_t path_list_index) { diff --git a/vnet/vnet/fib/fib_path_list.h b/vnet/vnet/fib/fib_path_list.h index 852f07d427d..8bc1b20b6bf 100644 --- a/vnet/vnet/fib/fib_path_list.h +++ b/vnet/vnet/fib/fib_path_list.h @@ -126,6 +126,7 @@ extern int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index, fib_node_index_t **entry_indicies); extern u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index); extern int fib_path_list_is_looped(fib_node_index_t path_list_index); +extern fib_protocol_t fib_path_list_get_proto(fib_node_index_t path_list_index); extern u8 * fib_path_list_format(fib_node_index_t pl_index, u8 * s); extern u8 * fib_path_list_adjs_format(fib_node_index_t pl_index, diff --git a/vnet/vnet/fib/fib_table.c b/vnet/vnet/fib/fib_table.c index 54bc8081993..76db42d0ec7 100644 --- a/vnet/vnet/fib/fib_table.c +++ b/vnet/vnet/fib/fib_table.c @@ -493,7 +493,7 @@ fib_table_entry_path_add (u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t next_hop_label, + mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags) { fib_route_path_t path = { @@ -503,12 +503,11 @@ fib_table_entry_path_add (u32 fib_index, .frp_fib_index = next_hop_fib_index, .frp_weight = next_hop_weight, .frp_flags = path_flags, - .frp_label = next_hop_label, + .frp_label_stack = next_hop_labels, }; fib_node_index_t fib_entry_index; fib_route_path_t *paths = NULL; - fib_table_route_path_fixup(prefix, &path); vec_add1(paths, path); fib_entry_index = fib_table_entry_path_add2(fib_index, prefix, @@ -523,14 +522,20 @@ fib_table_entry_path_add2 (u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, - const fib_route_path_t *rpath) + fib_route_path_t *rpath) { fib_node_index_t fib_entry_index; fib_table_t *fib_table; + u32 ii; fib_table = fib_table_get(fib_index, prefix->fp_proto); fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix); + for (ii = 0; ii < vec_len(rpath); ii++) + { + fib_table_route_path_fixup(prefix, &rpath[ii]); + } + if (FIB_NODE_INDEX_INVALID == fib_entry_index) { fib_entry_index = fib_entry_create(fib_index, prefix, @@ -558,9 +563,9 @@ fib_table_entry_path_add2 (u32 fib_index, void fib_table_entry_path_remove2 (u32 fib_index, - const fib_prefix_t *prefix, - fib_source_t source, - const fib_route_path_t *rpath) + const fib_prefix_t *prefix, + fib_source_t source, + fib_route_path_t *rpath) { /* * 1 is it present @@ -570,10 +575,16 @@ fib_table_entry_path_remove2 (u32 fib_index, */ fib_node_index_t fib_entry_index; fib_table_t *fib_table; + u32 ii; fib_table = fib_table_get(fib_index, prefix->fp_proto); fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix); + for (ii = 0; ii < vec_len(rpath); ii++) + { + fib_table_route_path_fixup(prefix, &rpath[ii]); + } + if (FIB_NODE_INDEX_INVALID == fib_entry_index) { /* @@ -667,20 +678,24 @@ fib_table_entry_update (u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, - const fib_route_path_t *paths) + fib_route_path_t *paths) { fib_node_index_t fib_entry_index; fib_table_t *fib_table; + u32 ii; fib_table = fib_table_get(fib_index, prefix->fp_proto); fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix); + for (ii = 0; ii < vec_len(paths); ii++) + { + fib_table_route_path_fixup(prefix, &paths[ii]); + } /* * sort the paths provided by the control plane. this means * the paths and the extension on the entry will be sorted. */ - vec_sort_with_function(((fib_route_path_t*)paths), // const cast - fib_route_path_cmp_for_sort); + vec_sort_with_function(paths, fib_route_path_cmp_for_sort); if (FIB_NODE_INDEX_INVALID == fib_entry_index) { @@ -717,7 +732,7 @@ fib_table_entry_update_one_path (u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t next_hop_label, + mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags) { fib_node_index_t fib_entry_index; @@ -728,7 +743,7 @@ fib_table_entry_update_one_path (u32 fib_index, .frp_fib_index = next_hop_fib_index, .frp_weight = next_hop_weight, .frp_flags = path_flags, - .frp_label = next_hop_label, + .frp_label_stack = next_hop_labels, }; fib_route_path_t *paths = NULL; diff --git a/vnet/vnet/fib/fib_table.h b/vnet/vnet/fib/fib_table.h index ef7599a7bf5..cfec516de1a 100644 --- a/vnet/vnet/fib/fib_table.h +++ b/vnet/vnet/fib/fib_table.h @@ -289,8 +289,8 @@ extern void fib_table_entry_special_remove(u32 fib_index, * @param next_hop_weight * [un]equal cost path weight * - * @param next_hop_label - * The path's out-going label. INVALID is there is none. + * @param next_hop_label_stack + * The path's out-going label stack. NULL is there is none. * * @param pf * Flags for the path @@ -307,7 +307,7 @@ extern fib_node_index_t fib_table_entry_path_add(u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t next_hop_label, + mpls_label_t *next_hop_label_stack, fib_route_path_flags_t pf); /** * @brief @@ -329,7 +329,7 @@ extern fib_node_index_t fib_table_entry_path_add(u32 fib_index, * Flags for the entry. * * @param rpaths - * A vector of paths. + * A vector of paths. Not const since they may be modified. * * @return * the index of the fib_entry_t that is created (or existed already). @@ -338,7 +338,7 @@ extern fib_node_index_t fib_table_entry_path_add2(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, - const fib_route_path_t *rpath); + fib_route_path_t *rpath); /** * @brief @@ -407,7 +407,7 @@ extern void fib_table_entry_path_remove(u32 fib_index, extern void fib_table_entry_path_remove2(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, - const fib_route_path_t *paths); + fib_route_path_t *paths); /** * @brief @@ -426,7 +426,7 @@ extern void fib_table_entry_path_remove2(u32 fib_index, * The ID of the client/source adding the entry. * * @param rpaths - * A vector of paths. + * A vector of paths. Not const since they may be modified. * * @return * the index of the fib_entry_t that is created (or existed already). @@ -435,7 +435,7 @@ extern fib_node_index_t fib_table_entry_update(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, - const fib_route_path_t *paths); + fib_route_path_t *paths); /** * @brief @@ -472,8 +472,8 @@ extern fib_node_index_t fib_table_entry_update(u32 fib_index, * @param next_hop_weight * [un]equal cost path weight * - * @param next_hop_label - * The path's out-going label. INVALID is there is none. + * @param next_hop_label_stack + * The path's out-going label stack. NULL is there is none. * * @param pf * Flags for the path @@ -490,7 +490,7 @@ extern fib_node_index_t fib_table_entry_update_one_path(u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t next_hop_label, + mpls_label_t *next_hop_label_stack, fib_route_path_flags_t pf); /** diff --git a/vnet/vnet/fib/fib_test.c b/vnet/vnet/fib/fib_test.c index eb5253d06da..a28026c13c1 100644 --- a/vnet/vnet/fib/fib_test.c +++ b/vnet/vnet/fib/fib_test.c @@ -28,6 +28,7 @@ #include <vnet/mpls/mpls.h> #include <vnet/fib/fib_path_list.h> +#include <vnet/fib/fib_entry_src.h> #include <vnet/fib/fib_walk.h> #include <vnet/fib/fib_node_list.h> #include <vnet/fib/fib_urpf_list.h> @@ -256,6 +257,7 @@ fib_test_build_rewrite (u8 *eth_addr) typedef enum fib_test_lb_bucket_type_t_ { FT_LB_LABEL_O_ADJ, + FT_LB_LABEL_STACK_O_ADJ, FT_LB_LABEL_O_LB, FT_LB_O_LB, FT_LB_SPECIAL, @@ -277,6 +279,14 @@ typedef struct fib_test_lb_bucket_t_ { struct { mpls_eos_bit_t eos; + mpls_label_t label_stack[8]; + u8 label_stack_size; + u8 ttl; + adj_index_t adj; + } label_stack_o_adj; + struct + { + mpls_eos_bit_t eos; mpls_label_t label; u8 ttl; index_t lb; @@ -322,6 +332,63 @@ fib_test_validate_lb_v (const load_balance_t *lb, switch (exp->type) { + case FT_LB_LABEL_STACK_O_ADJ: + { + const mpls_label_dpo_t *mld; + mpls_label_t hdr; + u32 ii; + + FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type), + "bucket %d stacks on %U", + bucket, + format_dpo_type, dpo->dpoi_type); + + mld = mpls_label_dpo_get(dpo->dpoi_index); + + FIB_TEST_LB(exp->label_stack_o_adj.label_stack_size == mld->mld_n_labels, + "label stack size", + mld->mld_n_labels); + + for (ii = 0; ii < mld->mld_n_labels; ii++) + { + hdr = clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl); + FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) == + exp->label_stack_o_adj.label_stack[ii]), + "bucket %d stacks on label %d", + bucket, + exp->label_stack_o_adj.label_stack[ii]); + + if (ii == mld->mld_n_labels-1) + { + FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) == + exp->label_o_adj.eos), + "bucket %d stacks on label %d %U!=%U", + bucket, + exp->label_stack_o_adj.label_stack[ii], + format_mpls_eos_bit, exp->label_o_adj.eos, + format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr)); + } + else + { + FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) == MPLS_NON_EOS), + "bucket %d stacks on label %d %U", + bucket, + exp->label_stack_o_adj.label_stack[ii], + format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr)); + } + } + + FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type), + "bucket %d label stacks on %U", + bucket, + format_dpo_type, mld->mld_dpo.dpoi_type); + + FIB_TEST_LB((exp->label_stack_o_adj.adj == mld->mld_dpo.dpoi_index), + "bucket %d label stacks on adj %d", + bucket, + exp->label_stack_o_adj.adj); + } + break; case FT_LB_LABEL_O_ADJ: { const mpls_label_dpo_t *mld; @@ -332,7 +399,7 @@ fib_test_validate_lb_v (const load_balance_t *lb, format_dpo_type, dpo->dpoi_type); mld = mpls_label_dpo_get(dpo->dpoi_index); - hdr = clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl); + hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl); FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) == exp->label_o_adj.label), @@ -367,10 +434,12 @@ fib_test_validate_lb_v (const load_balance_t *lb, "bucket %d stacks on %U", bucket, format_dpo_type, dpo->dpoi_type); - + mld = mpls_label_dpo_get(dpo->dpoi_index); - hdr = clib_net_to_host_u32(mld->mld_hdr.label_exp_s_ttl); + hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl); + FIB_TEST_LB(1 == mld->mld_n_labels, "label stack size", + mld->mld_n_labels); FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) == exp->label_o_lb.label), "bucket %d stacks on label %d", @@ -437,8 +506,8 @@ fib_test_validate_entry (fib_node_index_t fei, u16 n_buckets, ...) { - const load_balance_t *lb; dpo_id_t dpo = DPO_INVALID; + const load_balance_t *lb; fib_prefix_t pfx; index_t fw_lbi; u32 fib_index; @@ -462,34 +531,37 @@ fib_test_validate_entry (fib_node_index_t fei, * ensure that the LB contributed by the entry is the * same as the LB in the forwarding tables */ - switch (pfx.fp_proto) + if (fct == fib_entry_get_default_chain_type(fib_entry_get(fei))) { - case FIB_PROTOCOL_IP4: - fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx.fp_addr.ip4); - break; - case FIB_PROTOCOL_IP6: - fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx.fp_addr.ip6); - break; - case FIB_PROTOCOL_MPLS: - { - mpls_unicast_header_t hdr = { - .label_exp_s_ttl = 0, - }; - - vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx.fp_label); - vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx.fp_eos); - hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl); - - fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr); - break; - } - default: - fw_lbi = 0; + switch (pfx.fp_proto) + { + case FIB_PROTOCOL_IP4: + fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx.fp_addr.ip4); + break; + case FIB_PROTOCOL_IP6: + fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx.fp_addr.ip6); + break; + case FIB_PROTOCOL_MPLS: + { + mpls_unicast_header_t hdr = { + .label_exp_s_ttl = 0, + }; + + vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx.fp_label); + vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx.fp_eos); + hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl); + + fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr); + break; + } + default: + fw_lbi = 0; + } + FIB_TEST_LB((fw_lbi == dpo.dpoi_index), + "Contributed LB = FW LB: %U\n %U", + format_load_balance, fw_lbi, 0, + format_load_balance, dpo.dpoi_index, 0); } - FIB_TEST_LB((fw_lbi == dpo.dpoi_index), - "Contributed LB = FW LB: %U\n %U", - format_load_balance, fw_lbi, 0, - format_load_balance, dpo.dpoi_index, 0); dpo_reset(&dpo); @@ -623,7 +695,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, // weight - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &local_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present"); @@ -650,7 +722,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, // weight - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &local_pfx); FIB_TEST(((FIB_ENTRY_FLAG_LOCAL | FIB_ENTRY_FLAG_CONNECTED) == @@ -700,7 +772,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx); FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)), @@ -818,7 +890,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); dpo = fib_entry_contribute_ip_forwarding(fei); @@ -884,7 +956,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST((FIB_ENTRY_FLAG_ATTACHED == fib_entry_get_flags(fei)), "Flags set on adj-fib"); @@ -933,7 +1005,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_10_10_10_2_s_32); @@ -970,7 +1042,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32); ai = fib_entry_get_adj(fei); @@ -1003,7 +1075,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24); ai = fib_entry_get_adj(fei); @@ -1030,7 +1102,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24); dpo = fib_entry_contribute_ip_forwarding(fei); @@ -1116,7 +1188,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // nexthop in same fib as route 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&bgp_100_pfx, &pfx_1_1_1_1_s_32, 0); @@ -1152,7 +1224,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // nexthop in same fib as route 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&bgp_101_pfx, &pfx_1_1_1_1_s_32, 0); @@ -1274,7 +1346,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // nexthop in same fib as route 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0); @@ -1320,7 +1392,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_entry_path_add(fib_index, &pfx_1_2_3_4_s_32, @@ -1331,7 +1403,7 @@ fib_test_v4 (void) tm->hw[1]->sw_if_index, ~0, 3, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.4/32 presnet"); @@ -1372,7 +1444,7 @@ fib_test_v4 (void) tm->hw[1]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_entry_path_add(fib_index, &pfx_1_2_3_5_s_32, @@ -1383,7 +1455,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 4, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.5/32 presnet"); @@ -1455,7 +1527,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 0, // zero weigth - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32); @@ -1474,7 +1546,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 100, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32); @@ -1556,7 +1628,7 @@ fib_test_v4 (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 100, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32); @@ -1812,7 +1884,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_entry_path_add(fib_index, &bgp_44_s_32, @@ -1823,7 +1895,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_4_s_32, 0); @@ -1893,7 +1965,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // nexthop in same fib as route 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0); @@ -1936,7 +2008,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24); dpo1 = fib_entry_contribute_ip_forwarding(fei); @@ -1994,7 +2066,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28); dpo2 = fib_entry_contribute_ip_forwarding(fei); @@ -2097,7 +2169,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); dpo1 = fib_entry_contribute_ip_forwarding(fei); ai = fib_entry_get_adj(fei); @@ -2198,7 +2270,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // same as route 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, &bgp_102, @@ -2209,7 +2281,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // same as route's FIB 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &bgp_102); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "100.100.100.102/32 presnet"); @@ -2298,7 +2370,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, // Same as route's FIB 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); /* @@ -2345,7 +2417,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); /* @@ -2459,7 +2531,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, &pfx_5_5_5_6_s_32, @@ -2470,7 +2542,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, &pfx_5_5_5_7_s_32, @@ -2481,7 +2553,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); /* * +3 entries, +3 shared path-list @@ -2520,7 +2592,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); @@ -2579,7 +2651,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32); @@ -2621,7 +2693,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32); @@ -2696,7 +2768,7 @@ fib_test_v4 (void) ~0, // no index provided. fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32); FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)), @@ -2744,7 +2816,7 @@ fib_test_v4 (void) ~0, // recursive fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); dpo = fib_entry_contribute_ip_forwarding(fei); FIB_TEST(load_balance_is_drop(dpo), @@ -2774,7 +2846,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_RESOLVE_VIA_HOST); fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32); @@ -2804,7 +2876,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28); ai = fib_entry_get_adj(fei); @@ -2839,7 +2911,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)), "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1"); @@ -2863,7 +2935,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, @@ -2875,7 +2947,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_RESOLVE_VIA_HOST); fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx); @@ -2960,7 +3032,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket_i(lb, 0)), @@ -2987,7 +3059,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_RESOLVE_VIA_HOST); fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx); @@ -3055,7 +3127,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_remove(fib_index, @@ -3133,7 +3205,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, &pfx_4_4_4_4_s_32, @@ -3144,7 +3216,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_table_entry_path_add(fib_index, &pfx_4_4_4_4_s_32, @@ -3155,7 +3227,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(FIB_NODE_INDEX_INVALID != fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32), @@ -3240,7 +3312,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32); @@ -3300,7 +3372,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_entry_path_add(fib_index, &pfx_34_1_1_1_s_32, @@ -3311,7 +3383,7 @@ fib_test_v4 (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST_REC_FORW(&pfx_34_1_1_1_s_32, &pfx_34_34_1_1_s_32, 0); fib_table_entry_delete_index(fei, FIB_SOURCE_API); @@ -3389,7 +3461,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_4_1_1_1_s_32); @@ -3443,7 +3515,7 @@ fib_test_v4 (void) tm->hw[0]->sw_if_index, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(0, &pfx_2001_s_64); @@ -3684,7 +3756,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local_pfx); @@ -3715,7 +3787,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &local_pfx); @@ -3760,7 +3832,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_0_0); @@ -3881,7 +3953,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2001_1_2_s_128); @@ -3920,7 +3992,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2001_1_3_s_128); @@ -3974,7 +4046,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2001_a_s_64); ai = fib_entry_get_adj(fei); @@ -3988,7 +4060,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2001_b_s_64); ai = fib_entry_get_adj(fei); @@ -4023,7 +4095,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fei == fib_table_lookup_exact_match(0, &pfx_1_1_1_1_s_32), "1.1.1.1/32 o v6 route present"); @@ -4061,7 +4133,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached route present"); @@ -4163,7 +4235,7 @@ fib_test_v6 (void) tm->hw[1]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &connected_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present"); @@ -4182,7 +4254,7 @@ fib_test_v6 (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &connected_pfx); @@ -4462,429 +4534,6 @@ fib_test_v6 (void) } /* - * Test the recursive route route handling for GRE tunnels - */ -static void -fib_test_gre (void) -{ - /* fib_node_index_t fei; */ - /* u32 fib_index = 0; */ - /* test_main_t *tm; */ - /* u32 ii; */ - - /* tm = &test_main; */ - - /* for (ii = 0; ii < 4; ii++) */ - /* { */ - /* ip4_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = 0; */ - /* } */ - - /* /\* */ - /* * add interface routes. We'll assume this works. It's more rigorously */ - /* * tested elsewhere. */ - /* *\/ */ - /* fib_prefix_t local_pfx = { */ - /* .fp_len = 24, */ - /* .fp_proto = FIB_PROTOCOL_IP4, */ - /* .fp_addr = { */ - /* .ip4 = { */ - /* /\* 10.10.10.10 *\/ */ - /* .as_u32 = clib_host_to_net_u32(0x0a0a0a0a), */ - /* }, */ - /* }, */ - /* }; */ - - /* fib_table_entry_update_one_path(fib_index, &local_pfx, */ - /* FIB_SOURCE_INTERFACE, */ - /* (FIB_ENTRY_FLAG_CONNECTED | */ - /* FIB_ENTRY_FLAG_ATTACHED), */ - /* NULL, */ - /* tm->hw[0]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */ - /* "attached interface route present"); */ - - /* local_pfx.fp_len = 32; */ - /* fib_table_entry_update_one_path(fib_index, &local_pfx, */ - /* FIB_SOURCE_INTERFACE, */ - /* (FIB_ENTRY_FLAG_CONNECTED | */ - /* FIB_ENTRY_FLAG_LOCAL), */ - /* NULL, */ - /* tm->hw[0]->sw_if_index, */ - /* ~0, // invalid fib index */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */ - - /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */ - /* "local interface route present"); */ - - /* fib_prefix_t local2_pfx = { */ - /* .fp_len = 24, */ - /* .fp_proto = FIB_PROTOCOL_IP4, */ - /* .fp_addr = { */ - /* .ip4 = { */ - /* /\* 10.10.11.11 *\/ */ - /* .as_u32 = clib_host_to_net_u32(0x0a0a0b0b), */ - /* }, */ - /* }, */ - /* }; */ - - /* fib_table_entry_update_one_path(fib_index, &local2_pfx, */ - /* FIB_SOURCE_INTERFACE, */ - /* (FIB_ENTRY_FLAG_CONNECTED | */ - /* FIB_ENTRY_FLAG_ATTACHED), */ - /* NULL, */ - /* tm->hw[1]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */ - /* "attached interface route present"); */ - - /* local2_pfx.fp_len = 32; */ - /* fib_table_entry_update_one_path(fib_index, &local2_pfx, */ - /* FIB_SOURCE_INTERFACE, */ - /* (FIB_ENTRY_FLAG_CONNECTED | */ - /* FIB_ENTRY_FLAG_LOCAL), */ - /* NULL, */ - /* tm->hw[0]->sw_if_index, */ - /* ~0, // invalid fib index */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */ - - /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), */ - /* "local interface route present"); */ - - /* /\* */ - /* * Add the route that will be used to resolve the tunnel's destination */ - /* *\/ */ - /* fib_prefix_t route_pfx = { */ - /* .fp_len = 24, */ - /* .fp_proto = FIB_PROTOCOL_IP4, */ - /* .fp_addr = { */ - /* .ip4 = { */ - /* /\* 1.1.1.0/24 *\/ */ - /* .as_u32 = clib_host_to_net_u32(0x01010100), */ - /* }, */ - /* }, */ - /* }; */ - /* /\* 10.10.10.2 *\/ */ - /* ip46_address_t nh_10_10_10_2 = { */ - /* .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02), */ - /* }; */ - - /* fib_table_entry_path_add(fib_index, &route_pfx, */ - /* FIB_SOURCE_API, */ - /* FIB_ENTRY_FLAG_NONE, */ - /* &nh_10_10_10_2, */ - /* tm->hw[0]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID != */ - /* fib_table_lookup_exact_match(fib_index, &local_pfx)), */ - /* "route present"); */ - - /* /\* */ - /* * Add a tunnel */ - /* *\/ */ - /* /\* 1.1.1.1 *\/ */ - /* fib_prefix_t tun_dst_pfx = { */ - /* .fp_len = 32, */ - /* .fp_proto = FIB_PROTOCOL_IP4, */ - /* .fp_addr = { */ - /* .ip4.as_u32 = clib_host_to_net_u32(0x01010101), */ - /* }, */ - /* }; */ - /* /\* 10.10.10.10 *\/ */ - /* ip4_address_t tun_src = { */ - /* .as_u32 = clib_host_to_net_u32(0x0a0a0a0a), */ - /* }; */ - /* /\* 172.16.0.1 *\/ */ - /* ip4_address_t tun_itf = { */ - /* .as_u32 = clib_host_to_net_u32(0xac100001), */ - /* }; */ - /* fib_prefix_t tun_itf_pfx = { */ - /* .fp_len = 30, */ - /* .fp_proto = FIB_PROTOCOL_IP4, */ - /* .fp_addr = { */ - /* .ip4 = tun_itf, */ - /* }, */ - /* }; */ - /* u32 *encap_labels = NULL; */ - /* u32 label = 0xbaba; */ - /* u32 encap_index; */ - /* u32 tunnel_sw_if_index; */ - - /* int rv; */ - - /* /\* */ - /* * First we need the MPLS Encap present */ - /* * */ - /* * Pretty sure this is broken. the wiki say the 1st aparamter address */ - /* * should be the tunnel's interface address, which makes some sense. But */ - /* * the code for tunnel creation checks for the tunnel's destination */ - /* * address. curious... */ - /* *\/ */ - /* vec_add1(encap_labels, label); */ - /* rv = vnet_mpls_add_del_encap(&tun_dst_pfx.fp_addr.ip4, */ - /* 0, // inner VRF */ - /* encap_labels, */ - /* ~0, // policy_tunnel_index, */ - /* 0, // no_dst_hash, */ - /* &encap_index, */ - /* 1); // ADD */ - /* FIB_TEST((0 == rv), "MPLS encap created"); */ - - /* /\* */ - /* * now create the tunnel */ - /* *\/ */ - /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */ - /* &tun_dst_pfx.fp_addr.ip4, */ - /* &tun_itf_pfx.fp_addr.ip4, */ - /* tun_itf_pfx.fp_len, */ - /* 0, // inner VRF */ - /* 0, // outer VRF */ - /* &tunnel_sw_if_index, */ - /* 0, // l2 only */ - /* 1); // ADD */ - /* FIB_TEST((0 == rv), "Tunnel created"); */ - - /* /\* */ - /* * add it again. just for giggles. */ - /* *\/ */ - /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */ - /* &tun_dst_pfx.fp_addr.ip4, */ - /* &tun_itf_pfx.fp_addr.ip4, */ - /* tun_itf_pfx.fp_len, */ - /* 0, // inner VRF */ - /* 0, // outer VRF */ - /* &tunnel_sw_if_index, */ - /* 0, // l2 only */ - /* 1); // ADD */ - /* FIB_TEST((0 != rv), "Duplicate Tunnel not created"); */ - - /* /\* */ - /* * Find the route added for the tunnel subnet and check that */ - /* * it has a midchin adj that is stacked on the adj used to reach the */ - /* * tunnel destination */ - /* *\/ */ - /* ip_adjacency_t *midchain_adj, *route_adj, *adjfib_adj; */ - /* adj_index_t midchain_ai, route_ai, adjfib_ai1, adjfib_ai2; */ - /* ip_lookup_main_t *lm; */ - - /* lm = &ip4_main.lookup_main; */ - - /* fei = fib_table_lookup_exact_match(fib_index, &tun_itf_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "tun itf route present"); */ - /* midchain_ai = fib_entry_contribute_forwarding(fei); */ - /* midchain_adj = adj_get(midchain_ai); */ - - /* FIB_TEST((IP_LOOKUP_NEXT_MIDCHAIN == midchain_adj->lookup_next_index), */ - /* "Tunnel interface links to midchain"); */ - - /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */ - /* route_ai = fib_entry_contribute_forwarding(fei); */ - /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == route_ai), */ - /* "tunnel midchain it stacked on route adj"); */ - - /* /\* */ - /* * update the route to the tunnel's destination to load-balance via */ - /* * interface 1. */ - /* *\/ */ - /* /\* 10.10.11.2 *\/ */ - /* ip46_address_t nh_10_10_11_2 = { */ - /* .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b02), */ - /* }; */ - - /* fib_table_entry_path_add(fib_index, &route_pfx, */ - /* FIB_SOURCE_API, */ - /* FIB_ENTRY_FLAG_NONE, */ - /* &nh_10_10_11_2, */ - /* tm->hw[1]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - - /* /\* */ - /* * the tunnels midchain should have re-stacked. This tests that the */ - /* * route re-resolution backwalk works to a tunnel interface. */ - /* *\/ */ - /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */ - /* FIB_TEST((route_ai != fib_entry_contribute_forwarding(fei)), "route changed"); */ - /* route_ai = fib_entry_contribute_forwarding(fei); */ - - /* midchain_adj = adj_get(midchain_ai); */ - - /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == route_ai), */ - /* "tunnel midchain has re-stacked on route adj"); */ - - /* route_adj = adj_get(route_ai); */ - - /* FIB_TEST((2 == route_adj->n_adj), "Route adj is multipath"); */ - - /* /\* */ - /* * At this stage both nieghbour adjs are incomplete, so the same should */ - /* * be true of the multipath adj */ - /* *\/ */ - /* FIB_TEST((IP_LOOKUP_NEXT_ARP == route_adj->lookup_next_index), */ - /* "Adj0 is ARP: %d", route_adj->lookup_next_index); */ - /* FIB_TEST((IP_LOOKUP_NEXT_ARP == (route_adj+1)->lookup_next_index), */ - /* "Adj1 is ARP"); */ - - /* /\* */ - /* * do the equivalent of creating an ARP entry for 10.10.10.2. */ - /* * This will complete the adj, and this */ - /* * change should be refelct in the multipath too. */ - /* *\/ */ - /* u8* rewrite = NULL, byte = 0xd; */ - /* vec_add(rewrite, &byte, 6); */ - - /* adjfib_ai1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, */ - /* VNET_LINK_IP4, */ - /* &nh_10_10_10_2, */ - /* tm->hw[0]->sw_if_index); */ - /* adj_nbr_update_rewrite(FIB_PROTOCOL_IP4, */ - /* adjfib_ai1, */ - /* rewrite); */ - /* adjfib_adj = adj_get(adjfib_ai1); */ - /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adjfib_adj->lookup_next_index), */ - /* "Adj-fib10 adj is rewrite"); */ - - /* adjfib_ai2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, */ - /* VNET_LINK_IP4, */ - /* &nh_10_10_11_2, */ - /* tm->hw[1]->sw_if_index); */ - /* adj_nbr_update_rewrite(FIB_PROTOCOL_IP4, */ - /* adjfib_ai2, */ - /* rewrite); */ - - /* adjfib_adj = adj_get(adjfib_ai2); */ - - /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adjfib_adj->lookup_next_index), */ - /* "Adj-fib11 adj is rewrite"); */ - - /* fei = fib_table_lookup_exact_match(fib_index, &route_pfx); */ - /* FIB_TEST((route_ai != fib_entry_contribute_forwarding(fei)), "route changed"); */ - /* route_ai = fib_entry_contribute_forwarding(fei); */ - /* route_adj = adj_get(route_ai); */ - /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == route_adj->lookup_next_index), */ - /* "Adj0 is rewrite"); */ - /* FIB_TEST((IP_LOOKUP_NEXT_REWRITE == (route_adj+1)->lookup_next_index), */ - /* "Adj1 is rewrite"); */ - - /* /\* */ - /* * CLEANUP */ - /* *\/ */ - /* adj_index_t drop_ai = adj_get_special(FIB_PROTOCOL_IP4, */ - /* ADJ_SPECIAL_TYPE_DROP); */ - - /* /\* */ - /* * remove the route that the tunnel resovles via. expect */ - /* * it to now resolve via the default route, which is drop */ - /* *\/ */ - /* fib_table_entry_path_remove(fib_index, &route_pfx, */ - /* FIB_SOURCE_API, */ - /* &nh_10_10_10_2, */ - /* tm->hw[0]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* fib_table_entry_path_remove(fib_index, &route_pfx, */ - /* FIB_SOURCE_API, */ - /* &nh_10_10_11_2, */ - /* tm->hw[1]->sw_if_index, */ - /* ~0, */ - /* 1, */ - /* FIB_ROUTE_PATH_FLAG_NONE); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID != */ - /* fib_table_lookup_exact_match(fib_index, &local_pfx)), */ - /* "route present"); */ - /* midchain_adj = adj_get(midchain_ai); */ - /* FIB_TEST((midchain_adj->sub_type.midchain.adj_index == drop_ai), */ - /* "tunnel midchain has re-stacked on drop"); */ - - /* /\* */ - /* * remove the tunnel and its MPLS encaps */ - /* *\/ */ - /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */ - /* &tun_dst_pfx.fp_addr.ip4, */ - /* &tun_itf_pfx.fp_addr.ip4, */ - /* tun_itf_pfx.fp_len, */ - /* 0, // inner VRF */ - /* 0, // outer VRF */ - /* &tunnel_sw_if_index, */ - /* 0, // l2 only */ - /* 0); // DEL */ - /* FIB_TEST((0 == rv), "Tunnel removed"); */ - /* rv = vnet_mpls_gre_add_del_tunnel(&tun_src, */ - /* &tun_dst_pfx.fp_addr.ip4, */ - /* &tun_itf_pfx.fp_addr.ip4, */ - /* tun_itf_pfx.fp_len, */ - /* 0, // inner VRF */ - /* 0, // outer VRF */ - /* &tunnel_sw_if_index, */ - /* 0, // l2 only */ - /* 0); // DEL */ - /* FIB_TEST((0 != rv), "No existant Tunnel not removed"); */ - - /* rv = vnet_mpls_add_del_encap(&tun_dst_pfx.fp_addr.ip4, */ - /* 0, // inner VRF */ - /* encap_labels, */ - /* ~0, // policy_tunnel_index, */ - /* 0, // no_dst_hash, */ - /* NULL, */ - /* 0); // ADD */ - /* FIB_TEST((0 == rv), "MPLS encap deleted"); */ - - /* vec_free(encap_labels); */ - - /* /\* */ - /* * no more FIB entries expected */ - /* *\/ */ - /* fei = fib_table_lookup_exact_match(fib_index, &tun_itf_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "tun itf route removed"); */ - /* fei = fib_table_lookup_exact_match(fib_index, &tun_dst_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "tun dst route removed"); */ - - /* /\* */ - /* * CLEANUP the connecteds */ - /* *\/ */ - /* local2_pfx.fp_len = 24; */ - /* fib_table_entry_delete(fib_index, &local2_pfx, */ - /* FIB_SOURCE_INTERFACE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */ - /* "attached interface route remove"); */ - - /* local2_pfx.fp_len = 32; */ - /* fib_table_entry_special_remove(fib_index, &local2_pfx, */ - /* FIB_SOURCE_INTERFACE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local2_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */ - /* "local interface route removed"); */ - /* local_pfx.fp_len = 24; */ - /* fib_table_entry_delete(fib_index, &local_pfx, */ - /* FIB_SOURCE_INTERFACE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */ - /* "attached interface route remove"); */ - - /* local_pfx.fp_len = 32; */ - /* fib_table_entry_special_remove(fib_index, &local_pfx, */ - /* FIB_SOURCE_INTERFACE); */ - /* fei = fib_table_lookup_exact_match(fib_index, &local_pfx); */ - /* FIB_TEST((FIB_NODE_INDEX_INVALID == fei), */ - /* "local interface route removed"); */ -} - -/* * Test Attached Exports */ static void @@ -4931,7 +4580,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), @@ -4947,7 +4596,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local_pfx); @@ -4976,7 +4625,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_10_10_10_1_s_32); @@ -5003,7 +4652,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created"); @@ -5045,7 +4694,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 present"); @@ -5076,7 +4725,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created"); @@ -5113,7 +4762,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 present"); @@ -5185,7 +4834,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32); FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1"); @@ -5208,7 +4857,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported in FIB1"); @@ -5240,7 +4889,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); dpo = fib_entry_contribute_ip_forwarding(fei); @@ -5296,7 +4945,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); dpo = fib_entry_contribute_ip_forwarding(fei); @@ -5332,7 +4981,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32); @@ -5371,7 +5020,7 @@ fib_test_ae (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32); @@ -5430,6 +5079,7 @@ fib_test_ae (void) adj_nbr_db_size()); } + /* * Test the recursive route route handling for GRE tunnels */ @@ -5440,7 +5090,7 @@ fib_test_label (void) const u32 fib_index = 0; test_main_t *tm; ip4_main_t *im; - int lb_count; + int lb_count, ii; lb_count = pool_elts(load_balance_pool); tm = &test_main; @@ -5476,7 +5126,7 @@ fib_test_label (void) tm->hw[0]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local0_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), @@ -5492,7 +5142,7 @@ fib_test_label (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local0_pfx); @@ -5522,7 +5172,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local1_pfx); FIB_TEST((FIB_NODE_INDEX_INVALID != fei), @@ -5538,7 +5188,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup_exact_match(fib_index, &local1_pfx); @@ -5608,6 +5258,9 @@ fib_test_label (void) .eos = MPLS_NON_EOS, }, }; + mpls_label_t *l99 = NULL; + vec_add1(l99, 99); + fib_table_entry_update_one_path(fib_index, &pfx_1_1_1_1_s_32, FIB_SOURCE_API, @@ -5617,7 +5270,7 @@ fib_test_label (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - 99, + l99, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32); @@ -5644,6 +5297,8 @@ fib_test_label (void) .adj = ai_mpls_10_10_11_1, }, }; + mpls_label_t *l_imp_null = NULL; + vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL); fei = fib_table_entry_path_add(fib_index, &pfx_1_1_1_1_s_32, @@ -5654,7 +5309,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 1, - MPLS_IETF_IMPLICIT_NULL_LABEL, + l_imp_null, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -5732,7 +5387,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -5800,6 +5455,8 @@ fib_test_label (void) .eos = MPLS_EOS, }, }; + mpls_label_t *l1600 = NULL; + vec_add1(l1600, 1600); fib_table_entry_update_one_path(fib_index, &pfx_2_2_2_2_s_32, @@ -5810,7 +5467,7 @@ fib_test_label (void) ~0, fib_index, 1, - 1600, + l1600, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32); @@ -6063,6 +5720,9 @@ fib_test_label (void) /* * add back the path with the valid label */ + l99 = NULL; + vec_add1(l99, 99); + fib_table_entry_path_add(fib_index, &pfx_1_1_1_1_s_32, FIB_SOURCE_API, @@ -6072,7 +5732,7 @@ fib_test_label (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - 99, + l99, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32); @@ -6191,6 +5851,8 @@ fib_test_label (void) .eos = MPLS_EOS, }, }; + mpls_label_t *l101 = NULL; + vec_add1(l101, 101); fei = fib_table_entry_update_one_path(fib_index, &pfx_1_1_1_2_s_32, @@ -6201,7 +5863,7 @@ fib_test_label (void) tm->hw[0]->sw_if_index, ~0, // invalid fib index 1, - 101, + l101, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -6229,6 +5891,9 @@ fib_test_label (void) .eos = MPLS_EOS, }, }; + mpls_label_t *l1601 = NULL; + vec_add1(l1601, 1601); + l1600_eos_o_1_1_1_1.label_o_lb.lb = non_eos_1_1_1_1.dpoi_index; fei = fib_table_entry_path_add(fib_index, @@ -6240,7 +5905,7 @@ fib_test_label (void) ~0, fib_index, 1, - 1601, + l1601, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -6256,6 +5921,9 @@ fib_test_label (void) * update the via-entry so it no longer has an imp-null path. * the LB for the recursive can use an imp-null */ + l_imp_null = NULL; + vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL); + fei = fib_table_entry_update_one_path(fib_index, &pfx_1_1_1_2_s_32, FIB_SOURCE_API, @@ -6265,7 +5933,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 1, - MPLS_IETF_IMPLICIT_NULL_LABEL, + l_imp_null, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -6298,7 +5966,7 @@ fib_test_label (void) tm->hw[1]->sw_if_index, ~0, // invalid fib index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST(fib_test_validate_entry(fei, @@ -6340,7 +6008,7 @@ fib_test_label (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fib_entry_contribute_forwarding(fib_table_lookup(fib_index, @@ -6384,7 +6052,7 @@ fib_test_label (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); fei = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32); @@ -6398,6 +6066,54 @@ fib_test_label (void) dpo_reset(&ip_1_1_1_1); /* + * Create an entry with a deep label stack + */ + fib_prefix_t pfx_2_2_5_5_s_32 = { + .fp_len = 32, + .fp_proto = FIB_PROTOCOL_IP4, + .fp_addr = { + .ip4.as_u32 = clib_host_to_net_u32(0x02020505), + }, + }; + fib_test_lb_bucket_t ls_eos_o_10_10_10_1 = { + .type = FT_LB_LABEL_STACK_O_ADJ, + .label_stack_o_adj = { + .adj = ai_mpls_10_10_11_1, + .label_stack_size = 8, + .label_stack = { + 200, 201, 202, 203, 204, 205, 206, 207 + }, + .eos = MPLS_EOS, + }, + }; + mpls_label_t *label_stack = NULL; + vec_validate(label_stack, 7); + for (ii = 0; ii < 8; ii++) + { + label_stack[ii] = ii + 200; + } + + fei = fib_table_entry_update_one_path(fib_index, + &pfx_2_2_5_5_s_32, + FIB_SOURCE_API, + FIB_ENTRY_FLAG_NONE, + FIB_PROTOCOL_IP4, + &nh_10_10_11_1, + tm->hw[1]->sw_if_index, + ~0, // invalid fib index + 1, + label_stack, + FIB_ROUTE_PATH_FLAG_NONE); + + FIB_TEST(fib_test_validate_entry(fei, + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + 1, + &ls_eos_o_10_10_10_1), + "2.2.5.5/32 LB 1 buckets via: " + "adj 10.10.11.1"); + fib_table_entry_delete_index(fei, FIB_SOURCE_API); + + /* * cleanup */ fib_table_entry_delete(fib_index, @@ -6950,6 +6666,7 @@ lfib_test_deagg (void) lookup_dpo_t *lkd; test_main_t *tm; int lb_count; + adj_index_t ai_mpls_10_10_10_1; tm = &test_main; lb_count = pool_elts(load_balance_pool); @@ -6964,6 +6681,14 @@ lfib_test_deagg (void) tm->hw[0]->sw_if_index, 1); + ip46_address_t nh_10_10_10_1 = { + .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01), + }; + ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4, + VNET_LINK_MPLS, + &nh_10_10_10_1, + tm->hw[0]->sw_if_index); + /* * Test the specials stack properly. */ @@ -7023,7 +6748,7 @@ lfib_test_deagg (void) ~0, fib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)), @@ -7074,7 +6799,7 @@ lfib_test_deagg (void) ~0, lfib_index, 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)), @@ -7113,30 +6838,192 @@ lfib_test_deagg (void) format_mpls_unicast_label, deag_label, format_mpls_eos_bit, MPLS_EOS); + dpo_reset(&dpo); - mpls_sw_interface_enable_disable(&mpls_main, - tm->hw[0]->sw_if_index, - 0); + /* + * An MPLS x-connect + */ + fib_prefix_t pfx_1200 = { + .fp_len = 21, + .fp_proto = FIB_PROTOCOL_MPLS, + .fp_label = 1200, + .fp_eos = MPLS_NON_EOS, + }; + fib_test_lb_bucket_t neos_o_10_10_10_1 = { + .type = FT_LB_LABEL_STACK_O_ADJ, + .label_stack_o_adj = { + .adj = ai_mpls_10_10_10_1, + .label_stack_size = 4, + .label_stack = { + 200, 300, 400, 500, + }, + .eos = MPLS_NON_EOS, + }, + }; + dpo_id_t neos_1200 = DPO_INVALID; + dpo_id_t ip_1200 = DPO_INVALID; + mpls_label_t *l200 = NULL; + vec_add1(l200, 200); + vec_add1(l200, 300); + vec_add1(l200, 400); + vec_add1(l200, 500); + + lfe = fib_table_entry_update_one_path(fib_index, + &pfx_1200, + FIB_SOURCE_API, + FIB_ENTRY_FLAG_NONE, + FIB_PROTOCOL_IP4, + &nh_10_10_10_1, + tm->hw[0]->sw_if_index, + ~0, // invalid fib index + 1, + l200, + FIB_ROUTE_PATH_FLAG_NONE); + + FIB_TEST(fib_test_validate_entry(lfe, + FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, + 1, + &neos_o_10_10_10_1), + "1200/0 LB 1 buckets via: " + "adj 10.10.11.1"); - dpo_reset(&dpo); /* - * +1 for the drop LB in the MPLS tables. + * A recursive route via the MPLS x-connect */ - FIB_TEST(lb_count+1 == pool_elts(load_balance_pool), - "Load-balance resources freed %d of %d", - lb_count+1, pool_elts(load_balance_pool)); -} + fib_prefix_t pfx_2_2_2_3_s_32 = { + .fp_len = 32, + .fp_proto = FIB_PROTOCOL_IP4, + .fp_addr = { + .ip4.as_u32 = clib_host_to_net_u32(0x02020203), + }, + }; + fib_route_path_t *rpaths = NULL, rpath = { + .frp_proto = FIB_PROTOCOL_MPLS, + .frp_local_label = 1200, + .frp_sw_if_index = ~0, // recurive + .frp_fib_index = 0, // Default MPLS fib + .frp_weight = 1, + .frp_flags = FIB_ROUTE_PATH_FLAG_NONE, + .frp_label_stack = NULL, + }; + vec_add1(rpaths, rpath); -static clib_error_t * -lfib_test (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd_arg) -{ - fib_test_mk_intf(4); + fib_table_entry_path_add2(fib_index, + &pfx_2_2_2_3_s_32, + FIB_SOURCE_API, + FIB_ENTRY_FLAG_NONE, + rpaths); - lfib_test_deagg(); + /* + * A labelled recursive route via the MPLS x-connect + */ + fib_prefix_t pfx_2_2_2_4_s_32 = { + .fp_len = 32, + .fp_proto = FIB_PROTOCOL_IP4, + .fp_addr = { + .ip4.as_u32 = clib_host_to_net_u32(0x02020204), + }, + }; + mpls_label_t *l999 = NULL; + vec_add1(l999, 999); + rpaths[0].frp_label_stack = l999, + + fib_table_entry_path_add2(fib_index, + &pfx_2_2_2_4_s_32, + FIB_SOURCE_API, + FIB_ENTRY_FLAG_NONE, + rpaths); + + fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200), + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + &ip_1200); + fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200), + FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, + &neos_1200); + + fib_test_lb_bucket_t ip_o_1200 = { + .type = FT_LB_O_LB, + .lb = { + .lb = ip_1200.dpoi_index, + }, + }; + fib_test_lb_bucket_t mpls_o_1200 = { + .type = FT_LB_LABEL_O_LB, + .label_o_lb = { + .lb = neos_1200.dpoi_index, + .label = 999, + .eos = MPLS_EOS, + }, + }; - return (NULL); + lfe = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32); + FIB_TEST(fib_test_validate_entry(lfe, + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + 1, + &ip_o_1200), + "2.2.2.2.3/32 LB 1 buckets via: label 1200 EOS"); + lfe = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32); + FIB_TEST(fib_test_validate_entry(lfe, + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + 1, + &mpls_o_1200), + "2.2.2.2.4/32 LB 1 buckets via: label 1200 non-EOS"); + + fib_table_entry_delete(fib_index, &pfx_1200, FIB_SOURCE_API); + fib_table_entry_delete(fib_index, &pfx_2_2_2_3_s_32, FIB_SOURCE_API); + fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API); + + dpo_reset(&neos_1200); + dpo_reset(&ip_1200); + + /* + * A recursive via a label that does not exist + */ + fib_test_lb_bucket_t bucket_drop = { + .type = FT_LB_SPECIAL, + .special = { + .adj = DPO_PROTO_MPLS, + }, + }; + + rpaths[0].frp_label_stack = NULL; + lfe = fib_table_entry_path_add2(fib_index, + &pfx_2_2_2_4_s_32, + FIB_SOURCE_API, + FIB_ENTRY_FLAG_NONE, + rpaths); + + fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200), + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + &ip_1200); + ip_o_1200.lb.lb = ip_1200.dpoi_index; + + FIB_TEST(fib_test_validate_entry(lfe, + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + 1, + &ip_o_1200), + "2.2.2.2.4/32 LB 1 buckets via: label 1200 EOS"); + lfe = fib_table_lookup(fib_index, &pfx_1200); + FIB_TEST(fib_test_validate_entry(lfe, + FIB_FORW_CHAIN_TYPE_UNICAST_IP4, + 1, + &bucket_drop), + "2.2.2.4/32 LB 1 buckets via: ip4-DROP"); + + fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API); + + dpo_reset(&ip_1200); + + /* + * cleanup + */ + mpls_sw_interface_enable_disable(&mpls_main, + tm->hw[0]->sw_if_index, + 0); + + FIB_TEST(lb_count == pool_elts(load_balance_pool), + "Load-balance resources freed %d of %d", + lb_count, pool_elts(load_balance_pool)); } static clib_error_t * @@ -7151,10 +7038,6 @@ fib_test (vlib_main_t * vm, fib_test_v4(); fib_test_v6(); } - else if (unformat (input, "gre")) - { - fib_test_gre(); - } else if (unformat (input, "label")) { fib_test_label(); @@ -7163,6 +7046,10 @@ fib_test (vlib_main_t * vm, { fib_test_ae(); } + else if (unformat (input, "lfib")) + { + lfib_test_deagg(); + } else if (unformat (input, "walk")) { fib_test_walk(); @@ -7177,9 +7064,9 @@ fib_test (vlib_main_t * vm, */ fib_test_v4(); fib_test_v6(); - fib_test_gre(); fib_test_ae(); fib_test_label(); + lfib_test_deagg(); } return (NULL); @@ -7191,12 +7078,6 @@ VLIB_CLI_COMMAND (test_fib_command, static) = { .function = fib_test, }; -VLIB_CLI_COMMAND (test_lfib_command, static) = { - .path = "test lfib", - .short_help = "mpls label fib unit tests - DO NOT RUN ON A LIVE SYSTEM", - .function = lfib_test, -}; - clib_error_t * fib_test_init (vlib_main_t *vm) { diff --git a/vnet/vnet/fib/fib_types.c b/vnet/vnet/fib/fib_types.c index f52de7b8be0..d25a7731c64 100644 --- a/vnet/vnet/fib/fib_types.c +++ b/vnet/vnet/fib/fib_types.c @@ -64,6 +64,16 @@ fib_prefix_from_ip46_addr (const ip46_address_t *addr, pfx->fp_addr = *addr; } +void +fib_prefix_from_mpls_label (mpls_label_t label, + fib_prefix_t *pfx) +{ + pfx->fp_proto = FIB_PROTOCOL_MPLS; + pfx->fp_len = 21; + pfx->fp_label = label; + pfx->fp_eos = MPLS_NON_EOS; +} + int fib_prefix_cmp (const fib_prefix_t *p1, const fib_prefix_t *p2) @@ -301,11 +311,6 @@ fib_forw_chain_type_to_dpo_proto (fib_forward_chain_type_t fct) case FIB_FORW_CHAIN_TYPE_ETHERNET: return (DPO_PROTO_ETHERNET); case FIB_FORW_CHAIN_TYPE_MPLS_EOS: - /* - * insufficient information to to convert - */ - ASSERT(0); - break; case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS: return (DPO_PROTO_MPLS); } diff --git a/vnet/vnet/fib/fib_types.h b/vnet/vnet/fib/fib_types.h index 92371e6b8ba..73eb944994b 100644 --- a/vnet/vnet/fib/fib_types.h +++ b/vnet/vnet/fib/fib_types.h @@ -292,13 +292,22 @@ typedef struct fib_route_path_t_ { * zeros address is ambiguous. */ fib_protocol_t frp_proto; - /** - * The next-hop address. - * Will be NULL for attached paths. - * Will be all zeros for attached-next-hop paths on a p2p interface - * Will be all zeros for a deag path. - */ - ip46_address_t frp_addr; + + union { + /** + * The next-hop address. + * Will be NULL for attached paths. + * Will be all zeros for attached-next-hop paths on a p2p interface + * Will be all zeros for a deag path. + */ + ip46_address_t frp_addr; + + /** + * The MPLS local Label to reursively resolve through. + * This is valid when the path type is MPLS. + */ + mpls_label_t frp_local_label; + }; /** * The interface. * Will be invalid for recursive paths. @@ -318,9 +327,9 @@ typedef struct fib_route_path_t_ { */ fib_route_path_flags_t frp_flags; /** - * The outgoing MPLS label. INVALID implies no label. + * The outgoing MPLS label Stack. NULL implies no label. */ - mpls_label_t frp_label; + mpls_label_t *frp_label_stack; } fib_route_path_t; /** diff --git a/vnet/vnet/fib/fib_walk.c b/vnet/vnet/fib/fib_walk.c index e5f9b87f927..e7376bf47a2 100644 --- a/vnet/vnet/fib/fib_walk.c +++ b/vnet/vnet/fib/fib_walk.c @@ -619,8 +619,8 @@ fib_walk_async (fib_node_type_t parent_type, */ return; } - if (0 == fib_node_child_get_n_children(parent_type, - parent_index)) + if (0 == fib_node_get_n_children(parent_type, + parent_index)) { /* * no children to walk - quit now @@ -674,8 +674,8 @@ fib_walk_sync (fib_node_type_t parent_type, */ return; } - if (0 == fib_node_child_get_n_children(parent_type, - parent_index)) + if (0 == fib_node_get_n_children(parent_type, + parent_index)) { /* * no children to walk - quit now diff --git a/vnet/vnet/fib/mpls_fib.h b/vnet/vnet/fib/mpls_fib.h index 42c9a865276..93ae4623016 100644 --- a/vnet/vnet/fib/mpls_fib.h +++ b/vnet/vnet/fib/mpls_fib.h @@ -96,7 +96,7 @@ mpls_fib_table_get_index_for_sw_if_index (u32 sw_if_index) { mpls_main_t *mm = &mpls_main; - ASSERT(vec_len(mm->fib_index_by_sw_if_index) < sw_if_index); + ASSERT(vec_len(mm->fib_index_by_sw_if_index) > sw_if_index); return (mm->fib_index_by_sw_if_index[sw_if_index]); } diff --git a/vnet/vnet/gre/interface.c b/vnet/vnet/gre/interface.c index 7adc5268446..d624587d8e9 100644 --- a/vnet/vnet/gre/interface.c +++ b/vnet/vnet/gre/interface.c @@ -331,6 +331,7 @@ vnet_gre_tunnel_add (vnet_gre_add_del_tunnel_args_t *a, t->hw_if_index = hw_if_index; t->outer_fib_index = outer_fib_index; t->sw_if_index = sw_if_index; + t->l2_adj_index = ADJ_INDEX_INVALID; vec_validate_init_empty (gm->tunnel_index_by_sw_if_index, sw_if_index, ~0); gm->tunnel_index_by_sw_if_index[sw_if_index] = t - gm->tunnels; @@ -416,6 +417,9 @@ vnet_gre_tunnel_delete (vnet_gre_add_del_tunnel_args_t *a, if (GRE_TUNNEL_TYPE_TEB == t->type) adj_unlock(t->l2_adj_index); + if (t->l2_adj_index != ADJ_INDEX_INVALID) + adj_unlock(t->l2_adj_index); + fib_entry_child_remove(t->fib_entry_index, t->sibling_index); fib_table_entry_delete_index(t->fib_entry_index, diff --git a/vnet/vnet/ip/ip4_forward.c b/vnet/vnet/ip/ip4_forward.c index d6fd380815b..2a6791e5055 100644 --- a/vnet/vnet/ip/ip4_forward.c +++ b/vnet/vnet/ip/ip4_forward.c @@ -729,7 +729,7 @@ ip4_add_interface_routes (u32 sw_if_index, sw_if_index, ~0, // invalid FIB index 1, - MPLS_LABEL_INVALID, + NULL, // no out-label stack FIB_ROUTE_PATH_FLAG_NONE); a->neighbor_probe_adj_index = fib_entry_get_adj(fei); } @@ -769,7 +769,7 @@ ip4_add_interface_routes (u32 sw_if_index, sw_if_index, ~0, // invalid FIB index 1, - MPLS_LABEL_INVALID, + NULL, // no out-label stack FIB_ROUTE_PATH_FLAG_NONE); } diff --git a/vnet/vnet/ip/ip6_forward.c b/vnet/vnet/ip/ip6_forward.c index f3cd640a841..1f40c429310 100644 --- a/vnet/vnet/ip/ip6_forward.c +++ b/vnet/vnet/ip/ip6_forward.c @@ -340,7 +340,7 @@ ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index, sw_if_index, ~0, // invalid FIB index 1, - MPLS_LABEL_INVALID, + NULL, // no label stack FIB_ROUTE_PATH_FLAG_NONE); a->neighbor_probe_adj_index = fib_entry_get_adj(fei); } @@ -378,7 +378,7 @@ ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index, sw_if_index, ~0, // invalid FIB index 1, - MPLS_LABEL_INVALID, + NULL, FIB_ROUTE_PATH_FLAG_NONE); } diff --git a/vnet/vnet/ip/ip6_neighbor.c b/vnet/vnet/ip/ip6_neighbor.c index cc176306969..a407978b3fa 100644 --- a/vnet/vnet/ip/ip6_neighbor.c +++ b/vnet/vnet/ip/ip6_neighbor.c @@ -586,7 +586,7 @@ vnet_set_ip6_ethernet_neighbor (vlib_main_t * vm, n->key.sw_if_index, ~0, 1, - MPLS_LABEL_INVALID, + NULL, // no label stack FIB_ROUTE_PATH_FLAG_NONE); } else diff --git a/vnet/vnet/ip/lookup.c b/vnet/vnet/ip/lookup.c index 511a5cc83ec..1a32b4a6467 100644 --- a/vnet/vnet/ip/lookup.c +++ b/vnet/vnet/ip/lookup.c @@ -348,8 +348,8 @@ vnet_ip_route_cmd (vlib_main_t * vm, fib_route_path_t *rpaths = NULL, rpath; dpo_id_t dpo = DPO_INVALID, *dpos = NULL; fib_prefix_t *prefixs = NULL, pfx; + mpls_label_t out_label, via_label; clib_error_t * error = NULL; - mpls_label_t out_label; u32 table_id, is_del; vnet_main_t * vnm; u32 fib_index; @@ -361,6 +361,7 @@ vnet_ip_route_cmd (vlib_main_t * vm, table_id = 0; count = 1; memset(&pfx, 0, sizeof(pfx)); + out_label = via_label = MPLS_LABEL_INVALID; /* Get a line of input. */ if (! unformat_user (main_input, unformat_line_input, line_input)) @@ -403,7 +404,16 @@ vnet_ip_route_cmd (vlib_main_t * vm, error = clib_error_return(0 , "Paths then labels"); goto done; } - rpaths[vec_len(rpaths)-1].frp_label = out_label; + vec_add1(rpaths[vec_len(rpaths)-1].frp_label_stack, out_label); + } + else if (unformat (line_input, "via-label %U", + unformat_mpls_unicast_label, + &rpath.frp_local_label)) + { + rpath.frp_weight = 1; + rpath.frp_proto = FIB_PROTOCOL_MPLS; + rpath.frp_sw_if_index = ~0; + vec_add1(rpaths, rpath); } else if (unformat (line_input, "count %f", &count)) ; @@ -431,7 +441,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, &rpath.frp_sw_if_index, &rpath.frp_weight)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP4; vec_add1(rpaths, rpath); } @@ -443,7 +452,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, &rpath.frp_sw_if_index, &rpath.frp_weight)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP6; vec_add1(rpaths, rpath); } @@ -454,7 +462,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, unformat_vnet_sw_interface, vnm, &rpath.frp_sw_if_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_weight = 1; rpath.frp_proto = FIB_PROTOCOL_IP4; vec_add1(rpaths, rpath); @@ -466,7 +473,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, unformat_vnet_sw_interface, vnm, &rpath.frp_sw_if_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_weight = 1; rpath.frp_proto = FIB_PROTOCOL_IP6; vec_add1(rpaths, rpath); @@ -478,7 +484,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, { rpath.frp_weight = 1; rpath.frp_sw_if_index = ~0; - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP4; vec_add1(rpaths, rpath); } @@ -489,7 +494,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, { rpath.frp_weight = 1; rpath.frp_sw_if_index = ~0; - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP6; vec_add1(rpaths, rpath); } @@ -504,7 +508,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, rpath.frp_fib_index = table_id; rpath.frp_weight = 1; rpath.frp_sw_if_index = ~0; - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP4; vec_add1(rpaths, rpath); } @@ -515,7 +518,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, rpath.frp_fib_index = table_id; rpath.frp_weight = 1; rpath.frp_sw_if_index = ~0; - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP6; vec_add1(rpaths, rpath); } @@ -523,7 +525,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, "lookup in table %d", &rpath.frp_fib_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = pfx.fp_proto; rpath.frp_sw_if_index = ~0; vec_add1(rpaths, rpath); @@ -532,7 +533,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, unformat (line_input, "via %U", unformat_dpo, &dpo, prefixs[0].fp_proto)) { - rpath.frp_label = MPLS_LABEL_INVALID; vec_add1 (dpos, dpo); } else diff --git a/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c b/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c index 1f2b2863695..26a93a87b9d 100644 --- a/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c +++ b/vnet/vnet/lisp-gpe/lisp_gpe_fwd_entry.c @@ -243,7 +243,6 @@ lisp_gpe_mk_fib_paths (const lisp_fwd_path_t * paths) rpaths[ii].frp_sw_if_index = ladj->sw_if_index; rpaths[ii].frp_weight = (paths[ii].weight ? paths[ii].weight : 1); - rpaths[ii].frp_label = MPLS_LABEL_INVALID; } ASSERT (0 != vec_len (rpaths)); diff --git a/vnet/vnet/mpls/interface.c b/vnet/vnet/mpls/interface.c index a0f6f2f2474..692a2d1eb62 100644 --- a/vnet/vnet/mpls/interface.c +++ b/vnet/vnet/mpls/interface.c @@ -22,243 +22,6 @@ #include <vnet/adj/adj_midchain.h> #include <vnet/dpo/classify_dpo.h> -/* manually added to the interface output node */ -#define MPLS_ETH_OUTPUT_NEXT_OUTPUT 1 - -static uword -mpls_eth_interface_tx (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) -{ - mpls_main_t * gm = &mpls_main; - vnet_main_t * vnm = gm->vnet_main; - u32 next_index; - u32 * from, * to_next, n_left_from, n_left_to_next; - - /* Vector of buffer / pkt indices we're supposed to process */ - from = vlib_frame_vector_args (frame); - - /* Number of buffers / pkts */ - n_left_from = frame->n_vectors; - - /* Speculatively send the first buffer to the last disposition we used */ - next_index = node->cached_next_index; - - while (n_left_from > 0) - { - /* set up to enqueue to our disposition with index = next_index */ - vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); - - /* - * As long as we have enough pkts left to process two pkts - * and prefetch two pkts... - */ - while (n_left_from >= 4 && n_left_to_next >= 2) - { - vlib_buffer_t * b0, * b1; - u32 bi0, next0, bi1, next1; - mpls_eth_tunnel_t * t0, * t1; - u32 sw_if_index0, sw_if_index1; - vnet_hw_interface_t * hi0, * hi1; - u8 * dst0, * dst1; - - /* Prefetch the next iteration */ - { - vlib_buffer_t * p2, * p3; - - p2 = vlib_get_buffer (vm, from[2]); - p3 = vlib_get_buffer (vm, from[3]); - - vlib_prefetch_buffer_header (p2, LOAD); - vlib_prefetch_buffer_header (p3, LOAD); - - /* - * Prefetch packet data. We expect to overwrite - * the inbound L2 header with an ip header and a - * gre header. Might want to prefetch the last line - * of rewrite space as well; need profile data - */ - CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); - CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); - } - - /* Pick up the next two buffer indices */ - bi0 = from[0]; - bi1 = from[1]; - - /* Speculatively enqueue them where we sent the last buffer */ - to_next[0] = bi0; - to_next[1] = bi1; - from += 2; - to_next += 2; - n_left_to_next -= 2; - n_left_from -= 2; - - b0 = vlib_get_buffer (vm, bi0); - b1 = vlib_get_buffer (vm, bi1); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index [VLIB_TX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index [VLIB_TX]; - - /* get h/w intfcs */ - hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0); - hi1 = vnet_get_sup_hw_interface (vnm, sw_if_index1); - - /* hw_instance = tunnel pool index */ - t0 = pool_elt_at_index (gm->eth_tunnels, hi0->hw_instance); - t1 = pool_elt_at_index (gm->eth_tunnels, hi1->hw_instance); - - /* Apply rewrite - $$$$$ fixme don't use memcpy */ - vlib_buffer_advance (b0, -(word)vec_len(t0->rewrite_data)); - vlib_buffer_advance (b1, -(word)vec_len(t1->rewrite_data)); - - dst0 = vlib_buffer_get_current (b0); - dst1 = vlib_buffer_get_current (b1); - - clib_memcpy (dst0, t0->rewrite_data, vec_len(t0->rewrite_data)); - clib_memcpy (dst1, t1->rewrite_data, vec_len(t1->rewrite_data)); - - /* Fix TX fib indices */ - vnet_buffer(b0)->sw_if_index [VLIB_TX] = t0->tx_sw_if_index; - vnet_buffer(b1)->sw_if_index [VLIB_TX] = t1->tx_sw_if_index; - - /* mpls-post-rewrite takes it from here... */ - next0 = MPLS_ETH_OUTPUT_NEXT_OUTPUT; - next1 = MPLS_ETH_OUTPUT_NEXT_OUTPUT; - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->lookup_miss = 0; - tr->tunnel_id = t0 - gm->eth_tunnels; - tr->tx_sw_if_index = t0->tx_sw_if_index; - tr->mpls_encap_index = t0->encap_index; - tr->length = b0->current_length; - hi0 = vnet_get_sup_hw_interface (vnm, t0->tx_sw_if_index); - clib_memcpy (tr->dst, hi0->hw_address, sizeof (tr->dst)); - } - if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) - { - mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, - b1, sizeof (*tr)); - tr->lookup_miss = 0; - tr->tunnel_id = t1 - gm->eth_tunnels; - tr->tx_sw_if_index = t1->tx_sw_if_index; - tr->mpls_encap_index = t1->encap_index; - tr->length = b1->current_length; - hi1 = vnet_get_sup_hw_interface (vnm, t1->tx_sw_if_index); - clib_memcpy (tr->dst, hi1->hw_address, sizeof (tr->dst)); - } - - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - while (n_left_from > 0 && n_left_to_next > 0) - { - vlib_buffer_t * b0; - u32 bi0, next0; - mpls_eth_tunnel_t * t0; - u32 sw_if_index0; - vnet_hw_interface_t * hi0; - u8 * dst0; - - bi0 = from[0]; - to_next[0] = bi0; - from += 1; - to_next += 1; - n_left_from -= 1; - n_left_to_next -= 1; - - b0 = vlib_get_buffer (vm, bi0); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index [VLIB_TX]; - - hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0); - - t0 = pool_elt_at_index (gm->eth_tunnels, hi0->hw_instance); - - /* Apply rewrite - $$$$$ fixme don't use memcpy */ - vlib_buffer_advance (b0, -(word)vec_len(t0->rewrite_data)); - - dst0 = vlib_buffer_get_current (b0); - - clib_memcpy (dst0, t0->rewrite_data, vec_len(t0->rewrite_data)); - - /* Fix the TX interface */ - vnet_buffer(b0)->sw_if_index [VLIB_TX] = t0->tx_sw_if_index; - - /* Send the packet */ - next0 = MPLS_ETH_OUTPUT_NEXT_OUTPUT; - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - mpls_eth_tx_trace_t *tr = vlib_add_trace (vm, node, - b0, sizeof (*tr)); - tr->lookup_miss = 0; - tr->tunnel_id = t0 - gm->eth_tunnels; - tr->tx_sw_if_index = t0->tx_sw_if_index; - tr->mpls_encap_index = t0->encap_index; - tr->length = b0->current_length; - hi0 = vnet_get_sup_hw_interface (vnm, t0->tx_sw_if_index); - clib_memcpy (tr->dst, hi0->hw_address, sizeof (tr->dst)); - } - - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - bi0, next0); - } - - vlib_put_next_frame (vm, node, next_index, n_left_to_next); - } - - vlib_node_increment_counter (vm, mpls_input_node.index, - MPLS_ERROR_PKTS_ENCAP, frame->n_vectors); - - return frame->n_vectors; -} - -static u8 * format_mpls_eth_tunnel_name (u8 * s, va_list * args) -{ - u32 dev_instance = va_arg (*args, u32); - return format (s, "mpls-eth%d", dev_instance); -} - -static u8 * format_mpls_eth_device (u8 * s, va_list * args) -{ - u32 dev_instance = va_arg (*args, u32); - CLIB_UNUSED (int verbose) = va_arg (*args, int); - - s = format (s, "MPLS-ETH tunnel: id %d\n", dev_instance); - return s; -} - -VNET_DEVICE_CLASS (mpls_eth_device_class) = { - .name = "MPLS-ETH tunnel device", - .format_device_name = format_mpls_eth_tunnel_name, - .format_device = format_mpls_eth_device, - .format_tx_trace = format_mpls_eth_tx_trace, - .tx_function = mpls_eth_interface_tx, - .no_flatten_output_chains = 1, -#ifdef SOON - .clear counter = 0; - .admin_up_down_function = 0; -#endif -}; - -VLIB_DEVICE_TX_FUNCTION_MULTIARCH (mpls_eth_device_class, - mpls_eth_interface_tx) - -VNET_HW_INTERFACE_CLASS (mpls_eth_hw_interface_class) = { - .name = "MPLS-ETH", - .format_header = format_mpls_eth_header_with_length, -#if 0 - .unformat_header = unformat_mpls_eth_header, -#endif - .build_rewrite = default_build_rewrite, - .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P, -}; u8 mpls_sw_interface_is_enabled (u32 sw_if_index) @@ -308,753 +71,6 @@ mpls_sw_interface_enable_disable (mpls_main_t * mm, } -u8 * format_mpls_encap_index (u8 * s, va_list * args) -{ - mpls_main_t * mm = va_arg (*args, mpls_main_t *); - u32 entry_index = va_arg (*args, u32); - mpls_encap_t * e; - int i; - - e = pool_elt_at_index (mm->encaps, entry_index); - - for (i = 0; i < vec_len (e->labels); i++) - s = format - (s, "%d ", vnet_mpls_uc_get_label(clib_net_to_host_u32 - (e->labels[i].label_exp_s_ttl))); - - return s; -} - -u8 * format_mpls_ethernet_tunnel (u8 * s, va_list * args) -{ - mpls_eth_tunnel_t * t = va_arg (*args, mpls_eth_tunnel_t *); - mpls_main_t * mm = &mpls_main; - - s = format (s, "[%d]: dst %U, adj %U/%d, labels %U\n", - t - mm->eth_tunnels, - format_ethernet_address, &t->tunnel_dst, - format_ip4_address, &t->intfc_address, - t->mask_width, - format_mpls_encap_index, mm, t->encap_index); - - - s = format (s, " tx on %U, rx fib index %d", - format_vnet_sw_if_index_name, mm->vnet_main, t->tx_sw_if_index, - t->inner_fib_index); - - return s; -} - -static clib_error_t * -show_mpls_tunnel_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - mpls_main_t * mm = &mpls_main; - mpls_eth_tunnel_t * et; - - if (pool_elts (mm->eth_tunnels)) - { - vlib_cli_output (vm, "MPLS-Ethernet tunnels"); - pool_foreach (et, mm->eth_tunnels, - ({ - vlib_cli_output (vm, "%U", format_mpls_ethernet_tunnel, et); - })); - } - else - vlib_cli_output (vm, "No MPLS-Ethernet tunnels"); - - return 0; -} - -VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = { - .path = "show mpls tunnel", - .short_help = "show mpls tunnel", - .function = show_mpls_tunnel_command_fn, -}; - - -/* force inclusion from application's main.c */ -clib_error_t *mpls_interface_init (vlib_main_t *vm) -{ - clib_error_t * error; - - if ((error = vlib_call_init_function (vm, mpls_policy_encap_init))) - return error; - - return 0; -} -VLIB_INIT_FUNCTION(mpls_interface_init); - - -static u8 * mpls_ethernet_rewrite (mpls_main_t *mm, mpls_eth_tunnel_t * t) -{ - u8 * rewrite_data = 0; - mpls_encap_t * e; - mpls_unicast_header_t *lp0; - int i; - - /* look up the encap label stack using the RX FIB and adjacency address*/ - e = mpls_encap_by_fib_and_dest (mm, t->inner_fib_index, - t->intfc_address.as_u32); - - if (e == 0) - { - clib_warning ("no label for inner fib index %d, dst %U", - t->inner_fib_index, format_ip4_address, - &t->intfc_address); - return 0; - } - - vec_validate (rewrite_data, - sizeof (mpls_unicast_header_t) * vec_len(e->labels) -1); - - /* Copy the encap label stack */ - lp0 = (mpls_unicast_header_t *) rewrite_data; - - for (i = 0; i < vec_len(e->labels); i++) - lp0[i] = e->labels[i]; - - return (rewrite_data); -} - -int vnet_mpls_ethernet_add_del_tunnel (u8 *dst, - ip4_address_t *intfc, - u32 mask_width, - u32 inner_fib_id, - u32 tx_sw_if_index, - u32 * tunnel_sw_if_index, - u8 l2_only, - u8 is_add) -{ - ip4_main_t * im = &ip4_main; - ip_lookup_main_t * lm = &im->lookup_main; - mpls_main_t * mm = &mpls_main; - vnet_main_t * vnm = vnet_get_main(); - mpls_eth_tunnel_t *tp; - u32 inner_fib_index = 0; - ip_adjacency_t adj; - u32 adj_index; - u8 * rewrite_data; - int found_tunnel = 0; - mpls_encap_t * e = 0; - u32 hw_if_index = ~0; - vnet_hw_interface_t * hi; - u32 slot; - u32 dummy; - - if (tunnel_sw_if_index == 0) - tunnel_sw_if_index = &dummy; - - *tunnel_sw_if_index = ~0; - - if (inner_fib_id != (u32)~0) - { - uword * p; - - p = hash_get (im->fib_index_by_table_id, inner_fib_id); - if (! p) - return VNET_API_ERROR_NO_SUCH_FIB; - inner_fib_index = p[0]; - } - - /* suppress duplicate mpls interface generation. */ - pool_foreach (tp, mm->eth_tunnels, - ({ - /* - * If we have a tunnel which matches (src, dst, intfc/mask) - * AND the expected route is in the FIB, it's a dup - */ - if (!memcmp (&tp->tunnel_dst, dst, sizeof (*dst)) - && !memcmp (&tp->intfc_address, intfc, sizeof (*intfc)) - && tp->inner_fib_index == inner_fib_index - && FIB_NODE_INDEX_INVALID != tp->fei) - { - found_tunnel = 1; - - if (is_add) - { - if (l2_only) - return 1; - else - { - e = mpls_encap_by_fib_and_dest (mm, inner_fib_index, - intfc->as_u32); - if (e == 0) - return VNET_API_ERROR_NO_SUCH_LABEL; - - goto reinstall_it; - } - } - else - { - /* Delete */ - goto add_del_route; - } - - } - })); - - /* Delete, and we can't find the tunnel */ - if (is_add == 0 && found_tunnel == 0) - return VNET_API_ERROR_NO_SUCH_ENTRY; - - e = mpls_encap_by_fib_and_dest (mm, inner_fib_index, intfc->as_u32); - if (e == 0) - return VNET_API_ERROR_NO_SUCH_LABEL; - - pool_get(mm->eth_tunnels, tp); - memset (tp, 0, sizeof (*tp)); - - if (vec_len (mm->free_eth_sw_if_indices) > 0) - { - hw_if_index = - mm->free_eth_sw_if_indices[vec_len(mm->free_eth_sw_if_indices)-1]; - _vec_len (mm->free_eth_sw_if_indices) -= 1; - hi = vnet_get_hw_interface (vnm, hw_if_index); - hi->dev_instance = tp - mm->eth_tunnels; - hi->hw_instance = tp - mm->eth_tunnels; - } - else - { - hw_if_index = vnet_register_interface - (vnm, mpls_eth_device_class.index, tp - mm->eth_tunnels, - mpls_eth_hw_interface_class.index, - tp - mm->eth_tunnels); - hi = vnet_get_hw_interface (vnm, hw_if_index); - - /* ... to make the IP and L2 x-connect cases identical */ - slot = vlib_node_add_named_next_with_slot - (vnm->vlib_main, hi->tx_node_index, - "interface-output", MPLS_ETH_OUTPUT_NEXT_OUTPUT); - - ASSERT (slot == MPLS_ETH_OUTPUT_NEXT_OUTPUT); - } - - *tunnel_sw_if_index = hi->sw_if_index; - vnet_sw_interface_set_flags (vnm, hi->sw_if_index, - VNET_SW_INTERFACE_FLAG_ADMIN_UP); - - tp->hw_if_index = hw_if_index; - - reinstall_it: - clib_memcpy(tp->tunnel_dst, dst, sizeof (tp->tunnel_dst)); - tp->intfc_address.as_u32 = intfc->as_u32; - tp->mask_width = mask_width; - tp->inner_fib_index = inner_fib_index; - tp->encap_index = e - mm->encaps; - tp->tx_sw_if_index = tx_sw_if_index; - tp->l2_only = l2_only; - - /* Create the adjacency and add to v4 fib */ - memset(&adj, 0, sizeof (adj)); - adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE; - - rewrite_data = mpls_ethernet_rewrite (mm, tp); - if (rewrite_data == 0) - { - if (*tunnel_sw_if_index != ~0) - { - hi = vnet_get_hw_interface (vnm, tp->hw_if_index); - vnet_sw_interface_set_flags (vnm, hi->sw_if_index, - 0 /* admin down */); - vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index); - } - - pool_put (mm->eth_tunnels, tp); - return VNET_API_ERROR_NO_SUCH_LABEL; - } - - vnet_rewrite_for_sw_interface - (vnm, - VNET_LINK_MPLS, - tx_sw_if_index, - ip4_rewrite_node.index, - tp->tunnel_dst, - &adj.rewrite_header, - sizeof (adj.rewrite_data)); - - /* - * Prepend the (0,1,2) VLAN tag ethernet header - * we just built to the mpls header stack - */ - vec_insert (rewrite_data, adj.rewrite_header.data_bytes, 0); - clib_memcpy(rewrite_data, - vnet_rewrite_get_data_internal(&adj.rewrite_header, - sizeof (adj.rewrite_data)), - adj.rewrite_header.data_bytes); - - vnet_rewrite_set_data_internal (&adj.rewrite_header, - sizeof(adj.rewrite_data), - rewrite_data, - vec_len(rewrite_data)); - - vec_free (tp->rewrite_data); - - tp->rewrite_data = rewrite_data; - - if (!l2_only) - ip_add_adjacency (lm, &adj, 1 /* one adj */, - &adj_index); - - add_del_route: - - if (!l2_only) - { - const fib_prefix_t pfx = { - .fp_addr = { - .ip4 = tp->intfc_address, - }, - .fp_len = tp->mask_width, - .fp_proto = FIB_PROTOCOL_IP4, - }; - if (is_add) - tp->fei = fib_table_entry_special_add(tp->inner_fib_index, - &pfx, - FIB_SOURCE_API, - FIB_ENTRY_FLAG_NONE, - adj_index); - else - { - fib_table_entry_delete(tp->inner_fib_index, &pfx, FIB_SOURCE_API); - tp->fei = FIB_NODE_INDEX_INVALID; - } - } - if (is_add == 0 && found_tunnel) - { - hi = vnet_get_hw_interface (vnm, tp->hw_if_index); - vnet_sw_interface_set_flags (vnm, hi->sw_if_index, - 0 /* admin down */); - vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index); - vec_free (tp->rewrite_data); - pool_put (mm->eth_tunnels, tp); - } - - return 0; -} - -static clib_error_t * -create_mpls_ethernet_tunnel_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, * line_input = &_line_input; - vnet_main_t * vnm = vnet_get_main(); - ip4_address_t intfc; - int adj_set = 0; - u8 dst[6]; - int dst_set = 0, intfc_set = 0; - u32 mask_width; - u32 inner_fib_id = (u32)~0; - int rv; - u8 is_del = 0; - u8 l2_only = 0; - u32 tx_sw_if_index; - u32 sw_if_index = ~0; - - /* Get a line of input. */ - if (! unformat_user (input, unformat_line_input, line_input)) - return 0; - - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "dst %U", - unformat_ethernet_address, &dst)) - dst_set = 1; - else if (unformat (line_input, "adj %U/%d", - unformat_ip4_address, &intfc, &mask_width)) - adj_set = 1; - else if (unformat (line_input, "tx-intfc %U", - unformat_vnet_sw_interface, vnm, &tx_sw_if_index)) - intfc_set = 1; - else if (unformat (line_input, "fib-id %d", &inner_fib_id)) - ; - else if (unformat (line_input, "l2-only")) - l2_only = 1; - else if (unformat (line_input, "del")) - is_del = 1; - else - return clib_error_return (0, "unknown input '%U'", - format_unformat_error, line_input); - } - - if (!intfc_set) - return clib_error_return (0, "missing tx-intfc"); - - if (!dst_set) - return clib_error_return (0, "missing: dst <ethernet-address>"); - - if (!adj_set) - return clib_error_return (0, "missing: intfc <ip-address>/<mask-width>"); - - - rv = vnet_mpls_ethernet_add_del_tunnel (dst, &intfc, mask_width, - inner_fib_id, tx_sw_if_index, - &sw_if_index, - l2_only, !is_del); - - switch (rv) - { - case 0: - if (!is_del) - vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index); - break; - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "rx fib ID %d doesn't exist\n", - inner_fib_id); - - case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return (0, "tunnel not found\n"); - - case VNET_API_ERROR_NO_SUCH_LABEL: - /* - * This happens when there's no MPLS label for the dst address - * no need for two error messages. - */ - return clib_error_return (0, "no label for %U in fib %d", - format_ip4_address, &intfc, inner_fib_id); - break; - - default: - return clib_error_return (0, "vnet_mpls_ethernet_add_del_tunnel returned %d", rv); - break; - } - return 0; -} - - -VLIB_CLI_COMMAND (create_mpls_ethernet_tunnel_command, static) = { - .path = "create mpls ethernet tunnel", - .short_help = - "create mpls ethernet tunnel [del] dst <mac-addr> intfc <addr>/<mw>", - .function = create_mpls_ethernet_tunnel_command_fn, -}; - - -int vnet_mpls_policy_tunnel_add_rewrite (mpls_main_t * mm, - mpls_encap_t * e, - u32 policy_tunnel_index) -{ - mpls_eth_tunnel_t * t; - ip_adjacency_t adj; - u8 * rewrite_data = 0; - u8 * label_start; - mpls_unicast_header_t *lp; - int i; - - if (pool_is_free_index (mm->eth_tunnels, policy_tunnel_index)) - return VNET_API_ERROR_NO_SUCH_ENTRY; - - t = pool_elt_at_index (mm->eth_tunnels, policy_tunnel_index); - - memset (&adj, 0, sizeof (adj)); - - /* Build L2 encap */ - vnet_rewrite_for_sw_interface - (mm->vnet_main, - VNET_LINK_MPLS, - t->tx_sw_if_index, - mpls_policy_encap_node.index, - t->tunnel_dst, - &adj.rewrite_header, - sizeof (adj.rewrite_data)); - - vec_validate (rewrite_data, adj.rewrite_header.data_bytes -1); - - clib_memcpy(rewrite_data, - vnet_rewrite_get_data_internal(&adj.rewrite_header, - sizeof (adj.rewrite_data)), - adj.rewrite_header.data_bytes); - - /* Append the label stack */ - - vec_add2 (rewrite_data, label_start, vec_len(e->labels) * sizeof (u32)); - - lp = (mpls_unicast_header_t *) label_start; - - for (i = 0; i < vec_len(e->labels); i++) - lp[i] = e->labels[i]; - - /* Remember the rewrite data */ - e->rewrite = rewrite_data; - e->output_next_index = adj.rewrite_header.next_index; - - return 0; -} - -int vnet_mpls_ethernet_add_del_policy_tunnel (u8 *dst, - ip4_address_t *intfc, - u32 mask_width, - u32 inner_fib_id, - u32 tx_sw_if_index, - u32 * tunnel_sw_if_index, - u32 classify_table_index, - u32 * new_tunnel_index, - u8 l2_only, - u8 is_add) -{ - ip4_main_t * im = &ip4_main; - mpls_main_t * mm = &mpls_main; - vnet_main_t * vnm = vnet_get_main(); - mpls_eth_tunnel_t *tp; - u32 inner_fib_index = 0; - int found_tunnel = 0; - mpls_encap_t * e = 0; - u32 hw_if_index = ~0; - vnet_hw_interface_t * hi; - u32 slot; - u32 dummy; - - if (tunnel_sw_if_index == 0) - tunnel_sw_if_index = &dummy; - - *tunnel_sw_if_index = ~0; - - if (inner_fib_id != (u32)~0) - { - uword * p; - - p = hash_get (im->fib_index_by_table_id, inner_fib_id); - if (! p) - return VNET_API_ERROR_NO_SUCH_FIB; - inner_fib_index = p[0]; - } - - /* suppress duplicate mpls interface generation. */ - pool_foreach (tp, mm->eth_tunnels, - ({ - /* - * If we have a tunnel which matches (src, dst, intfc/mask) - * AND the expected route is in the FIB, it's a dup - */ - if (!memcmp (&tp->tunnel_dst, dst, sizeof (*dst)) - && !memcmp (&tp->intfc_address, intfc, sizeof (*intfc)) - && tp->inner_fib_index == inner_fib_index - && FIB_NODE_INDEX_INVALID != tp->fei) - { - found_tunnel = 1; - - if (is_add) - { - if (l2_only) - return 1; - else - { - goto reinstall_it; - } - } - else - { - /* Delete */ - goto add_del_route; - } - - } - })); - - /* Delete, and we can't find the tunnel */ - if (is_add == 0 && found_tunnel == 0) - return VNET_API_ERROR_NO_SUCH_ENTRY; - - pool_get(mm->eth_tunnels, tp); - memset (tp, 0, sizeof (*tp)); - - if (vec_len (mm->free_eth_sw_if_indices) > 0) - { - hw_if_index = - mm->free_eth_sw_if_indices[vec_len(mm->free_eth_sw_if_indices)-1]; - _vec_len (mm->free_eth_sw_if_indices) -= 1; - hi = vnet_get_hw_interface (vnm, hw_if_index); - hi->dev_instance = tp - mm->eth_tunnels; - hi->hw_instance = tp - mm->eth_tunnels; - } - else - { - hw_if_index = vnet_register_interface - (vnm, mpls_eth_device_class.index, tp - mm->eth_tunnels, - mpls_eth_hw_interface_class.index, - tp - mm->eth_tunnels); - hi = vnet_get_hw_interface (vnm, hw_if_index); - - /* ... to make the IP and L2 x-connect cases identical */ - slot = vlib_node_add_named_next_with_slot - (vnm->vlib_main, hi->tx_node_index, - "interface-output", MPLS_ETH_OUTPUT_NEXT_OUTPUT); - - ASSERT (slot == MPLS_ETH_OUTPUT_NEXT_OUTPUT); - } - - *tunnel_sw_if_index = hi->sw_if_index; - vnet_sw_interface_set_flags (vnm, hi->sw_if_index, - VNET_SW_INTERFACE_FLAG_ADMIN_UP); - - tp->hw_if_index = hw_if_index; - - reinstall_it: - clib_memcpy(tp->tunnel_dst, dst, sizeof (tp->tunnel_dst)); - tp->intfc_address.as_u32 = intfc->as_u32; - tp->mask_width = mask_width; - tp->inner_fib_index = inner_fib_index; - tp->encap_index = e - mm->encaps; - tp->tx_sw_if_index = tx_sw_if_index; - tp->l2_only = l2_only; - tp->fei = FIB_NODE_INDEX_INVALID; - - if (new_tunnel_index) - *new_tunnel_index = tp - mm->eth_tunnels; - - add_del_route: - - if (!l2_only) - { - const fib_prefix_t pfx = { - .fp_addr = { - .ip4 = tp->intfc_address, - }, - .fp_len = tp->mask_width, - .fp_proto = FIB_PROTOCOL_IP4, - }; - dpo_id_t dpo = DPO_INVALID; - - if (is_add) - { - dpo_set(&dpo, - DPO_CLASSIFY, - DPO_PROTO_IP4, - classify_dpo_create(DPO_PROTO_IP4, - classify_table_index)); - - tp->fei = fib_table_entry_special_dpo_add(tp->inner_fib_index, - &pfx, - FIB_SOURCE_API, - FIB_ENTRY_FLAG_EXCLUSIVE, - &dpo); - dpo_reset(&dpo); - } - else - { - fib_table_entry_delete(tp->inner_fib_index, &pfx, FIB_SOURCE_API); - tp->fei = FIB_NODE_INDEX_INVALID; - } - } - if (is_add == 0 && found_tunnel) - { - hi = vnet_get_hw_interface (vnm, tp->hw_if_index); - vnet_sw_interface_set_flags (vnm, hi->sw_if_index, - 0 /* admin down */); - vec_add1 (mm->free_eth_sw_if_indices, tp->hw_if_index); - pool_put (mm->eth_tunnels, tp); - } - - return 0; -} - -static clib_error_t * -create_mpls_ethernet_policy_tunnel_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, * line_input = &_line_input; - vnet_main_t * vnm = vnet_get_main(); - ip4_address_t intfc; - int adj_set = 0; - u8 dst[6]; - int dst_set = 0, intfc_set = 0; - u32 mask_width; - u32 inner_fib_id = (u32)~0; - u32 classify_table_index = (u32)~0; - u32 new_tunnel_index; - int rv; - u8 is_del = 0; - u8 l2_only = 0; - u32 tx_sw_if_index; - - /* Get a line of input. */ - if (! unformat_user (input, unformat_line_input, line_input)) - return 0; - - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "dst %U", - unformat_ethernet_address, &dst)) - dst_set = 1; - else if (unformat (line_input, "adj %U/%d", - unformat_ip4_address, &intfc, &mask_width)) - adj_set = 1; - else if (unformat (line_input, "tx-intfc %U", - unformat_vnet_sw_interface, vnm, &tx_sw_if_index)) - intfc_set = 1; - else if (unformat (line_input, "classify-table-index %d", - &classify_table_index)) - ; - else if (unformat (line_input, "fib-id %d", &inner_fib_id)) - ; - else if (unformat (line_input, "l2-only")) - l2_only = 1; - else if (unformat (line_input, "del")) - is_del = 1; - else - return clib_error_return (0, "unknown input '%U'", - format_unformat_error, line_input); - } - - if (classify_table_index == ~0) - return clib_error_return (0, "missing classify_table_index"); - - if (!intfc_set) - return clib_error_return (0, "missing tx-intfc"); - - if (!dst_set) - return clib_error_return (0, "missing: dst <ethernet-address>"); - - if (!adj_set) - return clib_error_return (0, "missing: intfc <ip-address>/<mask-width>"); - - - rv = vnet_mpls_ethernet_add_del_policy_tunnel (dst, &intfc, mask_width, - inner_fib_id, tx_sw_if_index, - 0 /* tunnel sw_if_index */, - classify_table_index, - &new_tunnel_index, - l2_only, !is_del); - switch (rv) - { - case 0: - if (!is_del) - vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), new_tunnel_index); - break; - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "rx fib ID %d doesn't exist\n", - inner_fib_id); - - case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return (0, "tunnel not found\n"); - - case VNET_API_ERROR_NO_SUCH_LABEL: - /* - * This happens when there's no MPLS label for the dst address - * no need for two error messages. - */ - return clib_error_return (0, "no label for %U in fib %d", - format_ip4_address, &intfc, inner_fib_id); - break; - - default: - return clib_error_return (0, "vnet_mpls_ethernet_add_del_policy_tunnel returned %d", rv); - break; - } - - return 0; -} - -VLIB_CLI_COMMAND (create_mpls_ethernet_policy_tunnel_command, static) = { - .path = "create mpls ethernet policy tunnel", - .short_help = - "create mpls ethernet policy tunnel [del] dst <mac-addr> intfc <addr>/<mw>\n" - " classify-table-index <nn>", - .function = create_mpls_ethernet_policy_tunnel_command_fn, -}; - static clib_error_t * mpls_interface_enable_disable (vlib_main_t * vm, unformat_input_t * input, @@ -1090,6 +106,14 @@ mpls_interface_enable_disable (vlib_main_t * vm, return error; } +/*? + * This command enables an interface to accpet MPLS packets + * + * @cliexpar + * @cliexstart{set interface mpls} + * set interface mpls GigEthernet0/8/0 enable + * @cliexend + ?*/ VLIB_CLI_COMMAND (set_interface_ip_table_command, static) = { .path = "set interface mpls", .function = mpls_interface_enable_disable, diff --git a/vnet/vnet/mpls/mpls.c b/vnet/vnet/mpls/mpls.c index aa1d963dca1..e6ae4980067 100644 --- a/vnet/vnet/mpls/mpls.c +++ b/vnet/vnet/mpls/mpls.c @@ -121,45 +121,6 @@ unformat_mpls_header (unformat_input_t * input, va_list * args) return 1; } -u8 * format_mpls_eth_tx_trace (u8 * s, va_list * args) -{ - CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); - CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); - mpls_eth_tx_trace_t * t = va_arg (*args, mpls_eth_tx_trace_t *); - mpls_main_t * mm = &mpls_main; - - if (t->lookup_miss) - s = format (s, "MPLS: lookup miss"); - else - { - s = format (s, "MPLS: tunnel %d labels %U len %d tx_sw_index %d dst %U", - t->tunnel_id, - format_mpls_encap_index, mm, t->mpls_encap_index, - clib_net_to_host_u16 (t->length), - t->tx_sw_if_index, - format_ethernet_address, t->dst); - } - return s; -} - -u8 * format_mpls_eth_header_with_length (u8 * s, va_list * args) -{ - ethernet_header_t * h = va_arg (*args, ethernet_header_t *); - mpls_unicast_header_t * m = (mpls_unicast_header_t *)(h+1); - u32 max_header_bytes = va_arg (*args, u32); - uword header_bytes; - - header_bytes = sizeof (h[0]); - if (max_header_bytes != 0 && header_bytes > max_header_bytes) - return format (s, "ethernet header truncated"); - - s = format - (s, "ETHERNET-MPLS label %d", - vnet_mpls_uc_get_label (clib_net_to_host_u32 (m->label_exp_s_ttl))); - - return s; -} - uword unformat_mpls_label_net_byte_order (unformat_input_t * input, va_list * args) @@ -176,157 +137,6 @@ unformat_mpls_label_net_byte_order (unformat_input_t * input, return 1; } -mpls_encap_t * -mpls_encap_by_fib_and_dest (mpls_main_t * mm, u32 rx_fib, u32 dst_address) -{ - uword * p; - mpls_encap_t * e; - u64 key; - - key = ((u64)rx_fib<<32) | ((u64) dst_address); - p = hash_get (mm->mpls_encap_by_fib_and_dest, key); - - if (!p) - return 0; - - e = pool_elt_at_index (mm->encaps, p[0]); - return e; -} - -int vnet_mpls_add_del_encap (ip4_address_t *dest, u32 fib_id, - u32 *labels_host_byte_order, - u32 policy_tunnel_index, - int no_dst_hash, u32 * indexp, int is_add) -{ - mpls_main_t * mm = &mpls_main; - ip4_main_t * im = &ip4_main; - mpls_encap_t * e; - u32 label_net_byte_order, label_host_byte_order; - u32 fib_index; - u64 key; - uword *p; - int i; - - p = hash_get (im->fib_index_by_table_id, fib_id); - if (! p) - return VNET_API_ERROR_NO_SUCH_FIB; - - fib_index = p[0]; - - key = ((u64)fib_index<<32) | ((u64) dest->as_u32); - - if (is_add) - { - pool_get (mm->encaps, e); - memset (e, 0, sizeof (*e)); - - for (i = 0; i < vec_len (labels_host_byte_order); i++) - { - mpls_unicast_header_t h; - label_host_byte_order = labels_host_byte_order[i]; - - /* Reformat label into mpls_unicast_header_t */ - label_host_byte_order <<= 12; - // FIXME NEOS AND EOS - //if (i == vec_len(labels_host_byte_order) - 1) - // label_host_byte_order |= 1<<8; /* S=1 */ - label_host_byte_order |= 0xff; /* TTL=FF */ - label_net_byte_order = clib_host_to_net_u32 (label_host_byte_order); - h.label_exp_s_ttl = label_net_byte_order; - vec_add1 (e->labels, h); - } - if (no_dst_hash == 0) - hash_set (mm->mpls_encap_by_fib_and_dest, key, e - mm->encaps); - if (indexp) - *indexp = e - mm->encaps; - if (policy_tunnel_index != ~0) - return vnet_mpls_policy_tunnel_add_rewrite (mm, e, policy_tunnel_index); - } - else - { - p = hash_get (mm->mpls_encap_by_fib_and_dest, key); - if (!p) - return VNET_API_ERROR_NO_SUCH_LABEL; - - e = pool_elt_at_index (mm->encaps, p[0]); - - vec_free (e->labels); - vec_free (e->rewrite); - pool_put(mm->encaps, e); - - if (no_dst_hash == 0) - hash_unset (mm->mpls_encap_by_fib_and_dest, key); - } - return 0; -} - -static clib_error_t * -mpls_add_encap_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u32 fib_id; - u32 *labels = 0; - u32 this_label; - ip4_address_t dest; - u32 policy_tunnel_index = ~0; - int no_dst_hash = 0; - int rv; - int fib_set = 0; - int dest_set = 0; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "fib %d", &fib_id)) - fib_set = 1; - else if (unformat (input, "dest %U", unformat_ip4_address, &dest)) - dest_set = 1; - else if (unformat (input, "no-dst-hash")) - no_dst_hash = 1; - else if (unformat (input, "label %d", &this_label)) - vec_add1 (labels, this_label); - else if (unformat (input, "policy-tunnel %d", &policy_tunnel_index)) - ; - else - break; - } - - if (fib_set == 0) - return clib_error_return (0, "fib-id missing"); - if (dest_set == 0) - return clib_error_return (0, "destination IP address missing"); - if (vec_len (labels) == 0) - return clib_error_return (0, "label stack missing"); - - rv = vnet_mpls_add_del_encap (&dest, fib_id, labels, - policy_tunnel_index, - no_dst_hash, 0 /* indexp */, - 1 /* is_add */); - vec_free (labels); - - switch (rv) - { - case 0: - break; - - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "fib id %d unknown", fib_id); - - default: - return clib_error_return (0, "vnet_mpls_add_del_encap returned %d", - rv); - } - - return 0; -} - -VLIB_CLI_COMMAND (mpls_add_encap_command, static) = { - .path = "mpls encap add", - .short_help = - "mpls encap add label <label> ... fib <id> dest <ip4-address>", - .function = mpls_add_encap_command_fn, -}; - u8 * format_mpls_unicast_header_host_byte_order (u8 * s, va_list * args) { mpls_unicast_header_t *h = va_arg(*args, mpls_unicast_header_t *); @@ -351,46 +161,6 @@ u8 * format_mpls_unicast_header_net_byte_order (u8 * s, va_list * args) &h_host); } -static clib_error_t * -mpls_del_encap_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u32 fib_id; - ip4_address_t dest; - int rv; - - if (unformat (input, "fib %d dest %U", &fib_id, - unformat_ip4_address, &dest)) - { - rv = vnet_mpls_add_del_encap (&dest, fib_id, 0 /* labels */, - ~0 /* policy_tunnel_index */, - 0 /* no_dst_hash */, - 0 /* indexp */, - 0 /* is_add */); - switch (rv) - { - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "fib id %d unknown", fib_id); - case VNET_API_ERROR_NO_SUCH_ENTRY: - return clib_error_return (0, "dest %U not in fib %d", - format_ip4_address, &dest, fib_id); - default: - break; - } - return 0; - } - else - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); -} - -VLIB_CLI_COMMAND (mpls_del_encap_command, static) = { - .path = "mpls encap delete", - .short_help = "mpls encap delete fib <id> dest <ip4-address>", - .function = mpls_del_encap_command_fn, -}; - int mpls_dest_cmp(void * a1, void * a2) { @@ -419,65 +189,22 @@ mpls_label_cmp(void * a1, void * a2) } static clib_error_t * -show_mpls_fib_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u64 key; - u32 value; - show_mpls_fib_t *records = 0; - show_mpls_fib_t *s; - mpls_main_t * mm = &mpls_main; - ip4_fib_t * rx_fib; - - hash_foreach (key, value, mm->mpls_encap_by_fib_and_dest, - ({ - vec_add2 (records, s, 1); - s->fib_index = (u32)(key>>32); - s->dest = (u32)(key & 0xFFFFFFFF); - s->entry_index = (u32) value; - })); - - if (!vec_len(records)) - { - vlib_cli_output (vm, "MPLS encap table empty"); - } - /* sort output by dst address within fib */ - vec_sort_with_function (records, mpls_dest_cmp); - vec_sort_with_function (records, mpls_fib_index_cmp); - vlib_cli_output (vm, "MPLS encap table"); - vlib_cli_output (vm, "%=6s%=16s%=16s", "Table", "Dest address", "Labels"); - vec_foreach (s, records) - { - rx_fib = ip4_fib_get (s->fib_index); - vlib_cli_output (vm, "%=6d%=16U%=16U", rx_fib->table_id, - format_ip4_address, &s->dest, - format_mpls_encap_index, mm, s->entry_index); - } - - vec_free(records); - return 0; -} - -VLIB_CLI_COMMAND (show_mpls_fib_command, static) = { - .path = "show mpls encap", - .short_help = "show mpls encap", - .function = show_mpls_fib_command_fn, -}; - -static clib_error_t * vnet_mpls_local_label (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { unformat_input_t _line_input, * line_input = &_line_input; fib_route_path_t *rpaths = NULL, rpath; - clib_error_t * error = 0; u32 table_id, is_del, is_ip; - fib_prefix_t pfx; mpls_label_t local_label; + mpls_label_t out_label; + clib_error_t * error; mpls_eos_bit_t eos; + vnet_main_t * vnm; + fib_prefix_t pfx; + vnm = vnet_get_main(); + error = NULL; is_ip = 0; table_id = 0; eos = MPLS_EOS; @@ -519,13 +246,99 @@ vnet_mpls_local_label (vlib_main_t * vm, pfx.fp_proto = FIB_PROTOCOL_IP6; is_ip = 1; } + else if (unformat (line_input, "via %U %U weight %u", + unformat_ip4_address, + &rpath.frp_addr.ip4, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index, + &rpath.frp_weight)) + { + rpath.frp_proto = FIB_PROTOCOL_IP4; + vec_add1(rpaths, rpath); + } + + else if (unformat (line_input, "via %U %U weight %u", + unformat_ip6_address, + &rpath.frp_addr.ip6, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index, + &rpath.frp_weight)) + { + rpath.frp_proto = FIB_PROTOCOL_IP6; + vec_add1(rpaths, rpath); + } + + else if (unformat (line_input, "via %U %U", + unformat_ip4_address, + &rpath.frp_addr.ip4, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index)) + { + rpath.frp_weight = 1; + rpath.frp_proto = FIB_PROTOCOL_IP4; + vec_add1(rpaths, rpath); + } + + else if (unformat (line_input, "via %U %U", + unformat_ip6_address, + &rpath.frp_addr.ip6, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index)) + { + rpath.frp_weight = 1; + rpath.frp_proto = FIB_PROTOCOL_IP6; + vec_add1(rpaths, rpath); + } + else if (unformat (line_input, "via %U next-hop-table %d", + unformat_ip4_address, + &rpath.frp_addr.ip4, + &rpath.frp_fib_index)) + { + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP4; + vec_add1(rpaths, rpath); + } + else if (unformat (line_input, "via %U next-hop-table %d", + unformat_ip6_address, + &rpath.frp_addr.ip6, + &rpath.frp_fib_index)) + { + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP6; + vec_add1(rpaths, rpath); + } + else if (unformat (line_input, "via %U", + unformat_ip4_address, + &rpath.frp_addr.ip4)) + { + /* + * the recursive next-hops are by default in the same table + * as the prefix + */ + rpath.frp_fib_index = table_id; + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP4; + vec_add1(rpaths, rpath); + } + else if (unformat (line_input, "via %U", + unformat_ip6_address, + &rpath.frp_addr.ip6)) + { + rpath.frp_fib_index = table_id; + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP6; + vec_add1(rpaths, rpath); + } else if (unformat (line_input, "%d", &local_label)) ; else if (unformat (line_input, "ip4-lookup-in-table %d", &rpath.frp_fib_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP4; rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID; pfx.fp_payload_proto = DPO_PROTO_IP4; @@ -535,7 +348,6 @@ vnet_mpls_local_label (vlib_main_t * vm, "ip6-lookup-in-table %d", &rpath.frp_fib_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_IP6; rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID; vec_add1(rpaths, rpath); @@ -545,16 +357,26 @@ vnet_mpls_local_label (vlib_main_t * vm, "mpls-lookup-in-table %d", &rpath.frp_fib_index)) { - rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = FIB_PROTOCOL_MPLS; rpath.frp_sw_if_index = FIB_NODE_INDEX_INVALID; pfx.fp_payload_proto = DPO_PROTO_MPLS; vec_add1(rpaths, rpath); } + else if (unformat (line_input, "out-label %U", + unformat_mpls_unicast_label, + &out_label)) + { + if (vec_len(rpaths) == 0) + { + error = clib_error_return(0 , "Paths then labels"); + goto done; + } + vec_add1(rpaths[vec_len(rpaths)-1].frp_label_stack, out_label); + } else { error = clib_error_return (0, "unkown input: %U", - format_unformat_error, input); + format_unformat_error, line_input); goto done; } @@ -596,6 +418,7 @@ vnet_mpls_local_label (vlib_main_t * vm, pfx.fp_proto = FIB_PROTOCOL_MPLS; pfx.fp_len = 21; pfx.fp_label = local_label; + pfx.fp_payload_proto = DPO_PROTO_MPLS; if (NULL == rpaths) { @@ -606,17 +429,20 @@ vnet_mpls_local_label (vlib_main_t * vm, /* * the CLI parsing stored table Ids, swap to FIB indicies */ - fi = fib_table_id_find_fib_index(dpo_proto_to_fib(pfx.fp_payload_proto), - rpaths[0].frp_fib_index); - - if (~0 == fi) + if (FIB_NODE_INDEX_INVALID == rpath.frp_sw_if_index) { - error = clib_error_return(0 , "%U Via table %d does not exist", - format_fib_protocol, pfx.fp_payload_proto, - rpaths[0].frp_fib_index); - goto done; + fi = fib_table_id_find_fib_index(dpo_proto_to_fib(pfx.fp_payload_proto), + rpaths[0].frp_fib_index); + + if (~0 == fi) + { + error = clib_error_return(0 , "%U Via table %d does not exist", + format_fib_protocol, pfx.fp_payload_proto, + rpaths[0].frp_fib_index); + goto done; + } + rpaths[0].frp_fib_index = fi; } - rpaths[0].frp_fib_index = fi; fib_index = mpls_fib_index_from_table_id(table_id); @@ -653,44 +479,15 @@ VLIB_CLI_COMMAND (mpls_local_label_command, static) = { .short_help = "Create/Delete MPL local labels", }; -int mpls_fib_reset_labels (u32 fib_id) +int +mpls_fib_reset_labels (u32 fib_id) { - u64 key; - u32 value; - show_mpls_fib_t *records = 0; - show_mpls_fib_t *s; - mpls_main_t * mm = &mpls_main; - ip4_main_t * im = &ip4_main; - u32 fib_index; - uword *p; - - p = hash_get (im->fib_index_by_table_id, fib_id); - if (! p) - return VNET_API_ERROR_NO_SUCH_FIB; - - fib_index = p[0]; - - hash_foreach (key, value, mm->mpls_encap_by_fib_and_dest, - ({ - if (fib_index == (u32)(key>>32)) { - vec_add2 (records, s, 1); - s->dest = (u32)(key & 0xFFFFFFFF); - s->entry_index = (u32) value; - } - })); - - vec_foreach (s, records) - { - key = ((u64)fib_index<<32) | ((u64) s->dest); - hash_unset (mm->mpls_encap_by_fib_and_dest, key); - pool_put_index (mm->encaps, s->entry_index); - } - - vec_free(records); + // FIXME return 0; } -static clib_error_t * mpls_init (vlib_main_t * vm) +static clib_error_t * +mpls_init (vlib_main_t * vm) { mpls_main_t * mm = &mpls_main; clib_error_t * error; @@ -701,8 +498,6 @@ static clib_error_t * mpls_init (vlib_main_t * vm) if ((error = vlib_call_init_function (vm, ip_main_init))) return error; - mm->mpls_encap_by_fib_and_dest = hash_create (0, sizeof (uword)); - return vlib_call_init_function (vm, mpls_input_init); } diff --git a/vnet/vnet/mpls/mpls.h b/vnet/vnet/mpls/mpls.h index 59fc761ea2c..b6fdbce7d70 100644 --- a/vnet/vnet/mpls/mpls.h +++ b/vnet/vnet/mpls/mpls.h @@ -30,30 +30,6 @@ typedef enum { MPLS_N_ERROR, } mpls_error_t; -/* - * No protocol info, MPLS labels don't have a next-header field - * presumably the label field tells all... - */ -typedef struct { - u8 tunnel_dst[6]; - ip4_address_t intfc_address; - u32 tx_sw_if_index; - u32 inner_fib_index; - u32 mask_width; - u32 encap_index; - u32 hw_if_index; - u8 * rewrite_data; - u8 l2_only; - fib_node_index_t fei; -} mpls_eth_tunnel_t; - -typedef struct { - mpls_unicast_header_t *labels; - /* only for policy tunnels */ - u8 * rewrite; - u32 output_next_index; -} mpls_encap_t; - #define MPLS_FIB_DEFAULT_TABLE_ID 0 /** @@ -94,18 +70,6 @@ typedef struct { /** A hash table to lookup the mpls_fib by table ID */ uword *fib_index_by_table_id; - /* pool of ethernet tunnel instances */ - mpls_eth_tunnel_t *eth_tunnels; - u32 * free_eth_sw_if_indices; - - /* Encap side: map (fib, dst_address) to mpls label stack */ - mpls_encap_t * encaps; - uword * mpls_encap_by_fib_and_dest; - - /* mpls-o-e policy tunnel next index for ip4/ip6-classify */ - u32 ip4_classify_mpls_policy_encap_next_index; - u32 ip6_classify_mpls_policy_encap_next_index; - /* Feature arc indices */ u8 input_feature_arc_index; u8 output_feature_arc_index; @@ -123,7 +87,6 @@ extern mpls_main_t mpls_main; extern clib_error_t * mpls_feature_init(vlib_main_t * vm); format_function_t format_mpls_protocol; -format_function_t format_mpls_eth_header_with_length; format_function_t format_mpls_encap_index; format_function_t format_mpls_eos_bit; @@ -153,29 +116,8 @@ void mpls_sw_interface_enable_disable (mpls_main_t * mm, u8 mpls_sw_interface_is_enabled (u32 sw_if_index); -mpls_encap_t * -mpls_encap_by_fib_and_dest (mpls_main_t * mm, u32 rx_fib, u32 dst_address); - -int vnet_mpls_ethernet_add_del_tunnel (u8 *dst, - ip4_address_t *intfc, - u32 mask_width, - u32 inner_fib_id, - u32 tx_sw_if_index, - u32 * tunnel_sw_if_index, - u8 l2_only, - u8 is_add); - int mpls_fib_reset_labels (u32 fib_id); -int vnet_mpls_add_del_encap (ip4_address_t *dest, u32 fib_id, - u32 *labels_host_byte_order, - u32 policy_tunnel_index, - int no_dst_hash, u32 * indexp, int is_add); - -int vnet_mpls_policy_tunnel_add_rewrite (mpls_main_t * mm, - mpls_encap_t * e, - u32 policy_tunnel_index); - #define foreach_mpls_input_next \ _(DROP, "error-drop") \ _(LOOKUP, "mpls-lookup") @@ -211,26 +153,6 @@ typedef enum { } mpls_output_next_t; typedef struct { - u32 lookup_miss; - - /* Tunnel-id / index in tunnel vector */ - u32 tunnel_id; - - /* output interface */ - u32 tx_sw_if_index; - - /* mpls encap index */ - u32 mpls_encap_index; - - /* pkt length */ - u32 length; - - u8 dst[6]; -} mpls_eth_tx_trace_t; - -u8 * format_mpls_eth_tx_trace (u8 * s, va_list * args); - -typedef struct { u32 fib_index; u32 entry_index; u32 dest; diff --git a/vnet/vnet/mpls/mpls_lookup.c b/vnet/vnet/mpls/mpls_lookup.c index 34ba79e40fd..2d34cbde341 100644 --- a/vnet/vnet/mpls/mpls_lookup.c +++ b/vnet/vnet/mpls/mpls_lookup.c @@ -170,6 +170,19 @@ mpls_lookup (vlib_main_t * vm, vlib_buffer_length_in_chain (vm, b1)); /* + * before we pop the label copy th values we need to maintain. + * The label header is in network byte order. + * last byte is the TTL. + * bits 2 to 4 inclusive are the EXP bits + */ + vnet_buffer (b0)->mpls.ttl = ((char*)h0)[3]; + vnet_buffer (b0)->mpls.exp = (((char*)h0)[2] & 0xe) >> 1; + vnet_buffer (b0)->mpls.first = 1; + vnet_buffer (b1)->mpls.ttl = ((char*)h1)[3]; + vnet_buffer (b1)->mpls.exp = (((char*)h1)[2] & 0xe) >> 1; + vnet_buffer (b1)->mpls.first = 1; + + /* * pop the label that was just used in the lookup */ vlib_buffer_advance(b0, sizeof(*h0)); @@ -223,8 +236,8 @@ mpls_lookup (vlib_main_t * vm, lfib_index0 = vec_elt(mm->fib_index_by_sw_if_index, vnet_buffer(b0)->sw_if_index[VLIB_RX]); - lbi0 = mpls_fib_table_forwarding_lookup (lfib_index0, h0); - lb0 = load_balance_get(lbi0); + lbi0 = mpls_fib_table_forwarding_lookup(lfib_index0, h0); + lb0 = load_balance_get(lbi0); hash_c0 = vnet_buffer(b0)->ip.flow_hash = 0; if (PREDICT_FALSE(lb0->lb_n_buckets > 1)) @@ -248,6 +261,16 @@ mpls_lookup (vlib_main_t * vm, vlib_buffer_length_in_chain (vm, b0)); /* + * before we pop the label copy th values we need to maintain. + * The label header is in network byte order. + * last byte is the TTL. + * bits 2 to 4 inclusive are the EXP bits + */ + vnet_buffer (b0)->mpls.ttl = ((char*)h0)[3]; + vnet_buffer (b0)->mpls.exp = (((char*)h0)[2] & 0xe) >> 1; + vnet_buffer (b0)->mpls.first = 1; + + /* * pop the label that was just used in the lookup */ vlib_buffer_advance(b0, sizeof(*h0)); diff --git a/vnet/vnet/mpls/mpls_tunnel.c b/vnet/vnet/mpls/mpls_tunnel.c new file mode 100644 index 00000000000..656bf330b1a --- /dev/null +++ b/vnet/vnet/mpls/mpls_tunnel.c @@ -0,0 +1,779 @@ +/* + * mpls_tunnel.c: MPLS tunnel interfaces (i.e. for RSVP-TE) + * + * Copyright (c) 2012 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> +#include <vnet/mpls/mpls_tunnel.h> +#include <vnet/ip/ip.h> +#include <vnet/fib/fib_path_list.h> +#include <vnet/adj/adj_midchain.h> + +/** + * @brief pool of tunnel instances + */ +static mpls_tunnel_t *mpls_tunnel_pool; + +/** + * @brief Pool of free tunnel SW indices - i.e. recycled indices + */ +static u32 * mpls_tunnel_free_hw_if_indices; + +/** + * @brief DB of SW index to tunnel index + */ +static u32 *mpls_tunnel_db; + +/** + * @brief Get a tunnel object from a SW interface index + */ +static mpls_tunnel_t* +mpls_tunnel_get_from_sw_if_index (u32 sw_if_index) +{ + if ((vec_len(mpls_tunnel_db) < sw_if_index) || + (~0 == mpls_tunnel_db[sw_if_index])) + return (NULL); + + return (pool_elt_at_index(mpls_tunnel_pool, + mpls_tunnel_db[sw_if_index])); +} + +/** + * @brief Return true if the label stack is imp-null only + */ +static fib_forward_chain_type_t +mpls_tunnel_get_fwd_chain_type (const mpls_tunnel_t *mt) +{ + if ((1 == vec_len(mt->mt_label_stack)) && + (mt->mt_label_stack[0] == MPLS_IETF_IMPLICIT_NULL_LABEL)) + { + /* + * the only label in the label stack is implicit null + * we need to build an IP chain. + */ + if (FIB_PROTOCOL_IP4 == fib_path_list_get_proto(mt->mt_path_list)) + { + return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4); + } + else + { + return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6); + } + } + else + { + return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS); + } +} + +/** + * @brief Build a rewrite string for the MPLS tunnel. + * + * We have choices here; + * 1 - have an Adjacency with a zero length string and stack it on + * MPLS label objects + * 2 - put the label header rewrites in the adjacency string. + * + * We choose 2 since it results in fewer graph nodes in the egress path + */ +static u8* +mpls_tunnel_build_rewrite (vnet_main_t * vnm, + u32 sw_if_index, + vnet_link_t link_type, + const void *dst_address) +{ + mpls_unicast_header_t *muh; + mpls_tunnel_t *mt; + u8 *rewrite; + u32 mti, ii; + + rewrite = NULL; + mti = mpls_tunnel_db[sw_if_index]; + mt = pool_elt_at_index(mpls_tunnel_pool, mti); + + vec_validate(rewrite, (sizeof(*muh) * vec_len(mt->mt_label_stack)) - 1); + muh = (mpls_unicast_header_t *)rewrite; + + /* + * The last (inner most) label in the stack may be EOS, all the rest Non-EOS + */ + for (ii = 0; ii < vec_len(mt->mt_label_stack)-1; ii++) + { + vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]); + vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255); + vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0); + vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS); + muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl); + } + + vnet_mpls_uc_set_label(&muh[ii].label_exp_s_ttl, mt->mt_label_stack[ii]); + vnet_mpls_uc_set_ttl(&muh[ii].label_exp_s_ttl, 255); + vnet_mpls_uc_set_exp(&muh[ii].label_exp_s_ttl, 0); + + if (VNET_LINK_MPLS == link_type && + mt->mt_label_stack[ii] != MPLS_IETF_IMPLICIT_NULL_LABEL) + vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_NON_EOS); + else + vnet_mpls_uc_set_s(&muh[ii].label_exp_s_ttl, MPLS_EOS); + + muh[ii].label_exp_s_ttl = clib_host_to_net_u32(muh[ii].label_exp_s_ttl); + + return ((u8*)muh); +} + +/** + * mpls_tunnel_stack + * + * 'stack' (resolve the recursion for) the tunnel's midchain adjacency + */ +static void +mpls_tunnel_stack (adj_index_t ai) +{ + ip_adjacency_t *adj; + mpls_tunnel_t *mt; + u32 sw_if_index; + + adj = adj_get(ai); + sw_if_index = adj->rewrite_header.sw_if_index; + + mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); + + if (NULL == mt) + return; + + /* + * find the adjacency that is contributed by the FIB path-list + * that this tunnel resovles via, and use it as the next adj + * in the midchain + */ + if (vnet_hw_interface_get_flags(vnet_get_main(), + mt->mt_hw_if_index) & + VNET_HW_INTERFACE_FLAG_LINK_UP) + { + dpo_id_t dpo = DPO_INVALID; + + fib_path_list_contribute_forwarding(mt->mt_path_list, + mpls_tunnel_get_fwd_chain_type(mt), + &dpo); + + if (DPO_LOAD_BALANCE == dpo.dpoi_type) + { + /* + * we don't support multiple paths, so no need to load-balance. + * pull the first and only choice and stack directly on that. + */ + load_balance_t *lb; + + lb = load_balance_get (dpo.dpoi_index); + + ASSERT(1 == lb->lb_n_buckets); + + dpo_copy(&dpo, load_balance_get_bucket_i (lb, 0)); + } + + adj_nbr_midchain_stack(ai, &dpo); + dpo_reset(&dpo); + } + else + { + adj_nbr_midchain_unstack(ai); + } +} + +/** + * @brief Call back when restacking all adjacencies on a MPLS interface + */ +static adj_walk_rc_t +mpls_adj_walk_cb (adj_index_t ai, + void *ctx) +{ + mpls_tunnel_stack(ai); + + return (ADJ_WALK_RC_CONTINUE); +} + +static void +mpls_tunnel_restack (mpls_tunnel_t *mt) +{ + fib_protocol_t proto; + + /* + * walk all the adjacencies on the MPLS interface and restack them + */ + FOR_EACH_FIB_PROTOCOL(proto) + { + adj_nbr_walk(mt->mt_sw_if_index, + proto, + mpls_adj_walk_cb, + NULL); + } +} + +static clib_error_t * +mpls_tunnel_admin_up_down (vnet_main_t * vnm, + u32 hw_if_index, + u32 flags) +{ + vnet_hw_interface_t * hi; + mpls_tunnel_t *mt; + + hi = vnet_get_hw_interface (vnm, hw_if_index); + + mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index); + + if (NULL == mt) + return (NULL); + + if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) + vnet_hw_interface_set_flags (vnm, hw_if_index, + VNET_HW_INTERFACE_FLAG_LINK_UP); + else + vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */); + + mpls_tunnel_restack(mt); + + return (NULL); +} + +/** + * @brief Fixup the adj rewrite post encap. This is a no-op since the + * rewrite is a stack of labels. + */ +static void +mpls_tunnel_fixup (vlib_main_t *vm, + ip_adjacency_t *adj, + vlib_buffer_t *b0) +{ +} + +static void +mpls_tunnel_update_adj (vnet_main_t * vnm, + u32 sw_if_index, + adj_index_t ai) +{ + adj_nbr_midchain_update_rewrite( + ai, mpls_tunnel_fixup, + ADJ_MIDCHAIN_FLAG_NONE, + mpls_tunnel_build_rewrite(vnm, sw_if_index, + adj_get_link_type(ai), + NULL)); + + mpls_tunnel_stack(ai); +} + +static u8 * +format_mpls_tunnel_name (u8 * s, va_list * args) +{ + u32 dev_instance = va_arg (*args, u32); + return format (s, "mpls-tunnel%d", dev_instance); +} + +static u8 * +format_mpls_tunnel_device (u8 * s, va_list * args) +{ + u32 dev_instance = va_arg (*args, u32); + CLIB_UNUSED (int verbose) = va_arg (*args, int); + + return (format (s, "MPLS-tunnel: id %d\n", dev_instance)); +} + +/** + * @brief Packet trace structure + */ +typedef struct mpls_tunnel_trace_t_ +{ + /** + * Tunnel-id / index in tunnel vector + */ + u32 tunnel_id; +} mpls_tunnel_trace_t; + +static u8 * +format_mpls_tunnel_tx_trace (u8 * s, + va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *); + + s = format (s, "MPLS: tunnel %d", t->tunnel_id); + return s; +} + +/** + * @brief TX function. Only called L2. L3 traffic uses the adj-midchains + */ +static uword +mpls_tunnel_tx (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 next_index; + u32 * from, * to_next, n_left_from, n_left_to_next; + vnet_interface_output_runtime_t * rd = (void *) node->runtime_data; + const mpls_tunnel_t *mt; + + mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance); + + /* Vector of buffer / pkt indices we're supposed to process */ + from = vlib_frame_vector_args (frame); + + /* Number of buffers / pkts */ + n_left_from = frame->n_vectors; + + /* Speculatively send the first buffer to the last disposition we used */ + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + /* set up to enqueue to our disposition with index = next_index */ + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + /* + * FIXME DUAL LOOP + */ + while (n_left_from > 0 && n_left_to_next > 0) + { + vlib_buffer_t * b0; + u32 bi0; + + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_from -= 1; + n_left_to_next -= 1; + + b0 = vlib_get_buffer(vm, bi0); + + vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_adj; + + if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) + { + mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->tunnel_id = rd->dev_instance; + } + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, mt->mt_l2_tx_arc); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return frame->n_vectors; +} + +VNET_DEVICE_CLASS (mpls_tunnel_class) = { + .name = "MPLS tunnel device", + .format_device_name = format_mpls_tunnel_name, + .format_device = format_mpls_tunnel_device, + .format_tx_trace = format_mpls_tunnel_tx_trace, + .tx_function = mpls_tunnel_tx, + .no_flatten_output_chains = 1, + .admin_up_down_function = mpls_tunnel_admin_up_down, +}; + +VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = { + .name = "MPLS-Tunnel", +// .format_header = format_mpls_eth_header_with_length, +// .unformat_header = unformat_mpls_eth_header, + .update_adjacency = mpls_tunnel_update_adj, + .build_rewrite = mpls_tunnel_build_rewrite, + .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P, +}; + +const mpls_tunnel_t * +mpls_tunnel_get (u32 mti) +{ + return (pool_elt_at_index(mpls_tunnel_pool, mti)); +} + +/** + * @brief Walk all the MPLS tunnels + */ +void +mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb, + void *ctx) +{ + u32 mti; + + pool_foreach_index(mti, mpls_tunnel_pool, + ({ + cb(mti, ctx); + })); +} + +void +vnet_mpls_tunnel_del (u32 sw_if_index) +{ + mpls_tunnel_t *mt; + + mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); + + if (NULL == mt) + return; + + fib_path_list_child_remove(mt->mt_path_list, + mt->mt_sibling_index); + if (ADJ_INDEX_INVALID != mt->mt_l2_adj) + adj_unlock(mt->mt_l2_adj); + + vec_free(mt->mt_label_stack); + + vec_add1 (mpls_tunnel_free_hw_if_indices, mt->mt_hw_if_index); + pool_put(mpls_tunnel_pool, mt); + mpls_tunnel_db[sw_if_index] = ~0; +} + +void +vnet_mpls_tunnel_add (fib_route_path_t *rpaths, + mpls_label_t *label_stack, + u8 l2_only, + u32 *sw_if_index) +{ + vnet_hw_interface_t * hi; + mpls_tunnel_t *mt; + vnet_main_t * vnm; + u32 mti; + + vnm = vnet_get_main(); + pool_get(mpls_tunnel_pool, mt); + memset (mt, 0, sizeof (*mt)); + mti = mt - mpls_tunnel_pool; + fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL); + mt->mt_l2_adj = ADJ_INDEX_INVALID; + + /* + * Create a new, or re=use and old, tunnel HW interface + */ + if (vec_len (mpls_tunnel_free_hw_if_indices) > 0) + { + mt->mt_hw_if_index = + mpls_tunnel_free_hw_if_indices[vec_len(mpls_tunnel_free_hw_if_indices)-1]; + _vec_len (mpls_tunnel_free_hw_if_indices) -= 1; + hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index); + hi->hw_instance = mti; + hi->dev_instance = mti; + } + else + { + mt->mt_hw_if_index = vnet_register_interface( + vnm, + mpls_tunnel_class.index, + mti, + mpls_tunnel_hw_interface_class.index, + mti); + hi = vnet_get_hw_interface(vnm, mt->mt_hw_if_index); + } + + /* + * Add the new tunnel to the tunnel DB - key:SW if index + */ + mt->mt_sw_if_index = hi->sw_if_index; + vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0); + mpls_tunnel_db[mt->mt_sw_if_index] = mti; + + /* + * construct a path-list from the path provided + */ + mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths); + mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list, + FIB_NODE_TYPE_MPLS_TUNNEL, + mti); + + mt->mt_label_stack = vec_dup(label_stack); + + if (l2_only) + { + mt->mt_l2_adj = + adj_nbr_add_or_lock(fib_path_list_get_proto(mt->mt_path_list), + VNET_LINK_ETHERNET, + &zero_addr, + mt->mt_sw_if_index); + + mt->mt_l2_tx_arc = vlib_node_add_named_next(vlib_get_main(), + hi->tx_node_index, + "adj-l2-midchain"); + } + + *sw_if_index = mt->mt_sw_if_index; +} + +static clib_error_t * +vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, * line_input = &_line_input; + vnet_main_t * vnm = vnet_get_main(); + u8 is_del = 0; + u8 l2_only = 0; + fib_route_path_t rpath, *rpaths = NULL; + mpls_label_t out_label = MPLS_LABEL_INVALID, *labels = NULL; + u32 sw_if_index; + + memset(&rpath, 0, sizeof(rpath)); + + /* Get a line of input. */ + if (! unformat_user (input, unformat_line_input, line_input)) + return 0; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "del %U", + unformat_vnet_sw_interface, vnm, + &sw_if_index)) + is_del = 1; + else if (unformat (line_input, "add")) + is_del = 0; + else if (unformat (line_input, "out-label %U", + unformat_mpls_unicast_label, &out_label)) + { + vec_add1(labels, out_label); + } + else if (unformat (line_input, "via %U %U", + unformat_ip4_address, + &rpath.frp_addr.ip4, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index)) + { + rpath.frp_weight = 1; + rpath.frp_proto = FIB_PROTOCOL_IP4; + } + + else if (unformat (line_input, "via %U %U", + unformat_ip6_address, + &rpath.frp_addr.ip6, + unformat_vnet_sw_interface, vnm, + &rpath.frp_sw_if_index)) + { + rpath.frp_weight = 1; + rpath.frp_proto = FIB_PROTOCOL_IP6; + } + else if (unformat (line_input, "via %U", + unformat_ip6_address, + &rpath.frp_addr.ip6)) + { + rpath.frp_fib_index = 0; + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP6; + } + else if (unformat (line_input, "via %U", + unformat_ip4_address, + &rpath.frp_addr.ip4)) + { + rpath.frp_fib_index = 0; + rpath.frp_weight = 1; + rpath.frp_sw_if_index = ~0; + rpath.frp_proto = FIB_PROTOCOL_IP4; + } + else if (unformat (line_input, "l2-only")) + l2_only = 1; + else + return clib_error_return (0, "unknown input '%U'", + format_unformat_error, line_input); + } + + if (is_del) + { + vnet_mpls_tunnel_del(sw_if_index); + } + else + { + if (0 == vec_len(labels)) + return clib_error_return (0, "No Output Labels '%U'", + format_unformat_error, line_input); + + vec_add1(rpaths, rpath); + vnet_mpls_tunnel_add(rpaths, labels, l2_only, &sw_if_index); + } + + vec_free(labels); + vec_free(rpaths); + + return (NULL); +} + +/*? + * This command create a uni-directional MPLS tunnel + * + * @cliexpar + * @cliexstart{create mpls tunnel} + * create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34 + * @cliexend + ?*/ +VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = { + .path = "mpls tunnel", + .short_help = + "mpls tunnel via [addr] [interface] [out-labels]", + .function = vnet_create_mpls_tunnel_command_fn, +}; + +static u8 * +format_mpls_tunnel (u8 * s, va_list * args) +{ + mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *); + int ii; + + s = format(s, "mpls_tunnel%d: sw_if_index:%d hw_if_index:%d", + mt - mpls_tunnel_pool, + mt->mt_sw_if_index, + mt->mt_hw_if_index); + s = format(s, "\n label-stack:\n "); + for (ii = 0; ii < vec_len(mt->mt_label_stack); ii++) + { + s = format(s, "%d, ", mt->mt_label_stack[ii]); + } + s = format(s, "\n via:\n"); + s = fib_path_list_format(mt->mt_path_list, s); + s = format(s, "\n"); + + return (s); +} + +static clib_error_t * +show_mpls_tunnel_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + mpls_tunnel_t * mt; + u32 mti = ~0; + + if (pool_elts (mpls_tunnel_pool) == 0) + vlib_cli_output (vm, "No MPLS tunnels configured..."); + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "%d", &mti)) + ; + else + break; + } + + if (~0 == mti) + { + pool_foreach (mt, mpls_tunnel_pool, + ({ + vlib_cli_output (vm, "[@%d] %U", + mt - mpls_tunnel_pool, + format_mpls_tunnel, mt); + })); + } + else + { + if (pool_is_free_index(mpls_tunnel_pool, mti)) + return clib_error_return (0, "Not atunnel index %d", mti); + + mt = pool_elt_at_index(mpls_tunnel_pool, mti); + + vlib_cli_output (vm, "[@%d] %U", + mt - mpls_tunnel_pool, + format_mpls_tunnel, mt); + } + + return 0; +} + +/*? + * This command to show MPLS tunnels + * + * @cliexpar + * @cliexstart{sh mpls tunnel 2} + * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5 + * label-stack: + * 3, + * via: + * index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ] + * index:26 pl-index:26 ipv4 weight=1 attached-nexthop: oper-flags:resolved, + * 10.0.0.2 loop0 + * [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc + * @cliexend + ?*/ +VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = { + .path = "show mpls tunnel", + .function = show_mpls_tunnel_command_fn, +}; + +static mpls_tunnel_t * +mpls_tunnel_from_fib_node (fib_node_t *node) +{ +#if (CLIB_DEBUG > 0) + ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type); +#endif + return ((mpls_tunnel_t*) (((char*)node) - + STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node))); +} + +/** + * Function definition to backwalk a FIB node + */ +static fib_node_back_walk_rc_t +mpls_tunnel_back_walk (fib_node_t *node, + fib_node_back_walk_ctx_t *ctx) +{ + mpls_tunnel_restack(mpls_tunnel_from_fib_node(node)); + + return (FIB_NODE_BACK_WALK_CONTINUE); +} + +/** + * Function definition to get a FIB node from its index + */ +static fib_node_t* +mpls_tunnel_fib_node_get (fib_node_index_t index) +{ + mpls_tunnel_t * mt; + + mt = pool_elt_at_index(mpls_tunnel_pool, index); + + return (&mt->mt_node); +} + +/** + * Function definition to inform the FIB node that its last lock has gone. + */ +static void +mpls_tunnel_last_lock_gone (fib_node_t *node) +{ + /* + * The MPLS MPLS tunnel is a root of the graph. As such + * it never has children and thus is never locked. + */ + ASSERT(0); +} + +/* + * Virtual function table registered by MPLS MPLS tunnels + * for participation in the FIB object graph. + */ +const static fib_node_vft_t mpls_vft = { + .fnv_get = mpls_tunnel_fib_node_get, + .fnv_last_lock = mpls_tunnel_last_lock_gone, + .fnv_back_walk = mpls_tunnel_back_walk, +}; + +static clib_error_t * +mpls_tunnel_init (vlib_main_t *vm) +{ + fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft); + + return 0; +} +VLIB_INIT_FUNCTION(mpls_tunnel_init); diff --git a/vnet/vnet/mpls/mpls_tunnel.h b/vnet/vnet/mpls/mpls_tunnel.h new file mode 100644 index 00000000000..ee56c0fc8e3 --- /dev/null +++ b/vnet/vnet/mpls/mpls_tunnel.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __MPLS_TUNNEL_H__ +#define __MPLS_TUNNEL_H__ + +#include <vnet/mpls/mpls.h> + +/** + * @brief A uni-directional MPLS tunnel + */ +typedef struct mpls_tunnel_t_ +{ + /** + * @brief The tunnel hooks into the FIB control plane graph. + */ + fib_node_t mt_node; + + /** + * @brief If the tunnel is an L2 tunnel, this is the link type ETHERNET + * adjacency + */ + adj_index_t mt_l2_adj; + + /** + * @brief on a L2 tunnel this is the VLIB arc from the L2-tx to the l2-midchain + */ + u32 mt_l2_tx_arc; + + /** + * @brief The path-list over which the tunnel's destination is reachable + */ + fib_node_index_t mt_path_list; + + /** + * @brief sibling index on the path-list so notifications are received. + */ + u32 mt_sibling_index; + + /** + * @brief The Label stack to apply to egress packets + */ + mpls_label_t *mt_label_stack; + + /** + * @brief Flag to indicate the tunnel is only for L2 traffic, that is + * this tunnel belongs in a bridge domain. + */ + u8 mt_l2_only; + + /** + * @brief The HW interface index of the tunnel interfaces + */ + u32 mt_hw_if_index; + + /** + * @brief The SW interface index of the tunnel interfaces + */ + u32 mt_sw_if_index; + +} mpls_tunnel_t; + +/** + * @brief Create a new MPLS tunnel + */ +extern void vnet_mpls_tunnel_add (fib_route_path_t *rpath, + mpls_label_t *label_stack, + u8 l2_only, + u32 *sw_if_index); + +extern void vnet_mpls_tunnel_del (u32 sw_if_index); + +extern const mpls_tunnel_t *mpls_tunnel_get(u32 index); + +/** + * @brief Callback function invoked while walking MPLS tunnels + */ +typedef void (*mpls_tunnel_walk_cb_t)(u32 index, void *ctx); + +/** + * @brief Walk all the MPLS tunnels + */ +extern void mpls_tunnel_walk(mpls_tunnel_walk_cb_t cb, + void *ctx); + +#endif diff --git a/vnet/vnet/mpls/policy_encap.c b/vnet/vnet/mpls/policy_encap.c deleted file mode 100644 index d48a153b37d..00000000000 --- a/vnet/vnet/mpls/policy_encap.c +++ /dev/null @@ -1,181 +0,0 @@ -/* - * policy_encap.c: mpls-o-e policy encap - * - * Copyright (c) 2012-2014 Cisco and/or its affiliates. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include <vlib/vlib.h> -#include <vnet/pg/pg.h> -#include <vnet/mpls/mpls.h> -#include <vnet/classify/vnet_classify.h> - -typedef struct { - u32 next_index; - u32 encap_index; -} mpls_policy_encap_trace_t; - -u8 * format_mpls_policy_encap_trace (u8 * s, va_list * args) -{ - CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); - CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); - mpls_policy_encap_trace_t * t = va_arg (*args, mpls_policy_encap_trace_t *); - - s = format (s, "MPLS-POLICY-ENCAP: next-index %d encap-index %d", - t->next_index, t->encap_index); - - return s; -} - -vlib_node_registration_t mpls_policy_encap_node; - -#define foreach_mpls_policy_encap_next \ -_(DROP, "error-drop") - -typedef enum { -#define _(s,n) MPLS_POLICY_ENCAP_NEXT_##s, - foreach_mpls_policy_encap_next -#undef _ - MPLS_POLICY_ENCAP_N_NEXT, -} mpls_policy_encap_next_t; - -#define foreach_mpls_policy_error \ -_(PKTS_ENCAP, "mpls policy tunnel packets encapsulated") - -typedef enum { -#define _(n,s) MPLS_POLICY_ENCAP_ERROR_##n, - foreach_mpls_policy_error - MPLS_POLICY_ENCAP_N_ERROR, -#undef _ -} mpls_policy_encap_error_t; - -static char * mpls_policy_encap_error_strings[] = - { -#define _(n,s) s, - foreach_mpls_policy_error -#undef _ -}; - -static uword -mpls_policy_encap (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * from_frame) -{ - u32 n_left_from, next_index, * from, * to_next; - mpls_main_t * mm = &mpls_main; - - from = vlib_frame_vector_args (from_frame); - n_left_from = from_frame->n_vectors; - - next_index = node->cached_next_index; - - while (n_left_from > 0) - { - u32 n_left_to_next; - - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); - - while (n_left_from > 0 && n_left_to_next > 0) - { - u32 bi0; - vlib_buffer_t * b0; - u8 * h0; - u32 encap_index0; - u32 next0; - mpls_encap_t * e0; - - bi0 = from[0]; - to_next[0] = bi0; - from += 1; - to_next += 1; - n_left_from -= 1; - n_left_to_next -= 1; - - b0 = vlib_get_buffer (vm, bi0); - - encap_index0 = vnet_buffer(b0)->l2_classify.opaque_index; - - e0 = pool_elt_at_index (mm->encaps, encap_index0); - - vlib_buffer_advance (b0, -(word)vec_len(e0->rewrite)); - h0 = vlib_buffer_get_current (b0); - clib_memcpy (h0, e0->rewrite, vec_len(e0->rewrite)); - - next0 = e0->output_next_index; - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - mpls_policy_encap_trace_t *tr = - vlib_add_trace (vm, node, b0, sizeof (*tr)); - tr->next_index = next0; - tr->encap_index = encap_index0; - } - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - bi0, next0); - } - vlib_put_next_frame (vm, node, next_index, n_left_to_next); - } - vlib_node_increment_counter (vm, mpls_policy_encap_node.index, - MPLS_POLICY_ENCAP_ERROR_PKTS_ENCAP, - from_frame->n_vectors); - return from_frame->n_vectors; -} - -VLIB_REGISTER_NODE (mpls_policy_encap_node) = { - .function = mpls_policy_encap, - .name = "mpls-policy-encap", - /* Takes a vector of packets. */ - .vector_size = sizeof (u32), - - .runtime_data_bytes = 0, - - .n_errors = MPLS_POLICY_ENCAP_N_ERROR, - .error_strings = mpls_policy_encap_error_strings, - - .format_trace = format_mpls_policy_encap_trace, - - .n_next_nodes = MPLS_POLICY_ENCAP_N_NEXT, - .next_nodes = { -#define _(s,n) [MPLS_POLICY_ENCAP_NEXT_##s] = n, - foreach_mpls_policy_encap_next -#undef _ - }, -}; - -VLIB_NODE_FUNCTION_MULTIARCH (mpls_policy_encap_node, mpls_policy_encap) - -static clib_error_t * -mpls_policy_encap_init (vlib_main_t * vm) -{ - mpls_main_t * mm = &mpls_main; - clib_error_t * error; - - if ((error = vlib_call_init_function (vm, mpls_init))) - return error; - - mm->ip4_classify_mpls_policy_encap_next_index = - vlib_node_add_next (mm->vlib_main, - ip4_classify_node.index, - mpls_policy_encap_node.index); - - mm->ip6_classify_mpls_policy_encap_next_index = - vlib_node_add_next (mm->vlib_main, - ip6_classify_node.index, - mpls_policy_encap_node.index); - - return 0; -} - -VLIB_INIT_FUNCTION (mpls_policy_encap_init); |