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)) ->n_vectors;
next_index = node->cached_next_index;
if (node->flags & VLIB_NODE_FLAG_TRACE)
ip4_forward_next_trace (vm, node, frame, VLIB_TX);
if (is_ip4) addr4.data_u32 = ~0;
else ip6_address_set_zero (&addr6);
while (n_left_from > 0)
{
vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
while (n_left_from >= 4 && n_left_to_next >= 2)
{
vlib_buffer_t * b0, * b1;
ip4_header_t * ip40, * ip41;
ip6_header_t * ip60, * ip61;
udp_header_t * udp0, * udp1;
u32 bi0, ip_len0, udp_len0, flags0, next0;
u32 bi1, ip_len1, udp_len1, flags1, next1;
i32 len_diff0, len_diff1;
u8 error0, good_udp0, proto0;
u8 error1, good_udp1, proto1;
/* Prefetch 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);
CLIB_PREFETCH (p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
CLIB_PREFETCH (p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
}
bi0 = to_next[0] = from[0];
bi1 = to_next[1] = from[1];
from += 2;
n_left_from -= 2;
to_next += 2;
n_left_to_next -= 2;
b0 = vlib_get_buffer (vm, bi0);
b1 = vlib_get_buffer (vm, bi1);
if (is_ip4)
{
ip40 = vlib_buffer_get_current (b0);
ip41 = vlib_buffer_get_current (b1);
}
else
{
ip60 = vlib_buffer_get_current (b0);
ip61 = vlib_buffer_get_current (b1);
}
/* Setup packet for next IP feature */
vnet_feature_next(vnet_buffer(b0)->sw_if_index[VLIB_RX], &next0, b0);
vnet_feature_next(vnet_buffer(b1)->sw_if_index[VLIB_RX], &next1, b1);
if (is_ip4)
{
/* Treat IP frag packets as "experimental" protocol for now
until support of IP frag reassembly is implemented */
proto0 = ip4_is_fragment(ip40) ? 0xfe : ip40->protocol;
proto1 = ip4_is_fragment(ip41) ? 0xfe : ip41->protocol;
}
else
{
proto0 = ip60->protocol;
proto1 = ip61->protocol;
}
/* Process packet 0 */
if (proto0 != IP_PROTOCOL_UDP)
goto exit0; /* not UDP packet */
if (is_ip4)
udp0 = ip4_next_header (ip40);
else
udp0 = ip6_next_header (ip60);
if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
goto exit0; /* not VXLAN packet */
/* Validate DIP against VTEPs*/
if (is_ip4)
{
if (addr4.as_u32 != ip40->dst_address.as_u32)
{
if (!hash_get (vxm->vtep4, ip40->dst_address.as_u32))
goto exit0; /* no local VTEP for VXLAN packet */
addr4 = ip40->dst_address;
}
}
else
{
if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
{
if (!hash_get_mem (vxm->vtep6, &ip60->dst_address))
goto exit0; /* no local VTEP for VXLAN packet */
addr6 = ip60->dst_address;
}
}
flags0 = b0->flags;
good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
/* Don't verify UDP checksum for packets with explicit zero checksum. */
good_udp0 |= udp0->checksum == 0;
/* Verify UDP length */
if (is_ip4)
ip_len0 = clib_net_to_host_u16 (ip40->length);
else
ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
udp_len0 = clib_net_to_host_u16 (udp0->length);
len_diff0 = ip_len0 - udp_len0;
/* Verify UDP checksum */
if (PREDICT_FALSE (!good_udp0))
{
if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
{
if (is_ip4)
flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
else
flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
good_udp0 =
(flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
}
}
if (is_ip4)
{
error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
}
else
{
error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
}
next0 = error0 ?
IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
b0->error = error0 ? error_node->errors[error0] : 0;
/* vxlan-input node expect current at VXLAN header */
if (is_ip4)
vlib_buffer_advance (b0, sizeof(ip4_header_t)+sizeof(udp_header_t));
else
vlib_buffer_advance (b0, sizeof(ip6_header_t)+sizeof(udp_header_t));
exit0:
/* Process packet 1 */
if (proto1 != IP_PROTOCOL_UDP)
goto exit1; /* not UDP packet */
if (is_ip4)
udp1 = ip4_next_header (ip41);
else
udp1 = ip6_next_header (ip61);
if (udp1->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
goto exit1; /* not VXLAN packet */
/* Validate DIP against VTEPs*/
if (is_ip4)
{
if (addr4.as_u32 != ip41->dst_address.as_u32)
{
if (!hash_get (vxm->vtep4, ip41->dst_address.as_u32))
goto exit1; /* no local VTEP for VXLAN packet */
addr4 = ip41->dst_address;
}
}
else
{
if (!ip6_address_is_equal (&addr6, &ip61->dst_address))
{
if (!hash_get_mem (vxm->vtep6, &ip61->dst_address))
goto exit1; /* no local VTEP for VXLAN packet */
addr6 = ip61->dst_address;
}
}
flags1 = b1->flags;
good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
/* Don't verify UDP checksum for packets with explicit zero checksum. */
good_udp1 |= udp1->checksum == 0;
/* Verify UDP length */
if (is_ip4)
ip_len1 = clib_net_to_host_u16 (ip41->length);
else
ip_len1 = clib_net_to_host_u16 (ip61->payload_length);
udp_len1 = clib_net_to_host_u16 (udp1->length);
len_diff1 = ip_len1 - udp_len1;
/* Verify UDP checksum */
if (PREDICT_FALSE (!good_udp1))
{
if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
{
if (is_ip4)
flags1 = ip4_tcp_udp_validate_checksum (vm, b1);
else
flags1 = ip6_tcp_udp_icmp_validate_checksum (vm, b1);
good_udp1 =
(flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
}
}
if (is_ip4)
{
error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
}
else
{
error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
}
next1 = error1 ?
IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
b1->error = error1 ? error_node->errors[error1] : 0;
/* vxlan-input node expect current at VXLAN header */
if (is_ip4)
vlib_buffer_advance (b1, sizeof(ip4_header_t)+sizeof(udp_header_t));
else
vlib_buffer_advance (b1, sizeof(ip6_header_t)+sizeof(udp_header_t));
exit1:
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;
ip4_header_t * ip40;
ip6_header_t * ip60;
udp_header_t * udp0;
u32 bi0, ip_len0, udp_len0, flags0, next0;
i32 len_diff0;
u8 error0, good_udp0, proto0;
bi0 = to_next[0] = from[0];
from += 1;
n_left_from -= 1;
to_next += 1;
n_left_to_next -= 1;
b0 = vlib_get_buffer (vm, bi0);
if (is_ip4)
ip40 = vlib_buffer_get_current (b0);
else
ip60 = vlib_buffer_get_current (b0);
/* Setup packet for next IP feature */
vnet_feature_next(vnet_buffer(b0)->sw_if_index[VLIB_RX], &next0, b0);
if (is_ip4)
/* Treat IP4 frag packets as "experimental" protocol for now
until support of IP frag reassembly is implemented */
proto0 = ip4_is_fragment(ip40) ? 0xfe : ip40->protocol;
else
proto0 = ip60->protocol;
if (proto0 != IP_PROTOCOL_UDP)
goto exit; /* not UDP packet */
if (is_ip4)
udp0 = ip4_next_header (ip40);
else
udp0 = ip6_next_header (ip60);
if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
goto exit; /* not VXLAN packet */
/* Validate DIP against VTEPs*/
if (is_ip4)
{
if (addr4.as_u32 != ip40->dst_address.as_u32)
{
if (!hash_get (vxm->vtep4, ip40->dst_address.as_u32))
goto exit; /* no local VTEP for VXLAN packet */
addr4 = ip40->dst_address;
}
}
else
{
if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
{
if (!hash_get_mem (vxm->vtep6, &ip60->dst_address))
goto exit; /* no local VTEP for VXLAN packet */
addr6 = ip60->dst_address;
}
}
flags0 = b0->flags;
good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
/* Don't verify UDP checksum for packets with explicit zero checksum. */
good_udp0 |= udp0->checksum == 0;
/* Verify UDP length */
if (is_ip4)
ip_len0 = clib_net_to_host_u16 (ip40->length);
else
ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
udp_len0 = clib_net_to_host_u16 (udp0->length);
len_diff0 = ip_len0 - udp_len0;
/* Verify UDP checksum */
if (PREDICT_FALSE (!good_udp0))
{
if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
{
if (is_ip4)
flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
else
flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
good_udp0 =
(flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
}
}
if (is_ip4)
{
error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
}
else
{
error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
}
next0 = error0 ?
IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
b0->error = error0 ? error_node->errors[error0] : 0;
/* vxlan-input node expect current at VXLAN header */
if (is_ip4)
vlib_buffer_advance (b0, sizeof(ip4_header_t)+sizeof(udp_header_t));
else
vlib_buffer_advance (b0, sizeof(ip6_header_t)+sizeof(udp_header_t));
exit:
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);
}
return frame->n_vectors;
}
static uword
ip4_vxlan_bypass (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
return ip_vxlan_bypass_inline (vm, node, frame, /* is_ip4 */ 1);
}
VLIB_REGISTER_NODE (ip4_vxlan_bypass_node) = {
.function = ip4_vxlan_bypass,
.name = "ip4-vxlan-bypass",
.vector_size = sizeof (u32),
.n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
.next_nodes = {
[IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
[IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan4-input",
},
.format_buffer = format_ip4_header,
.format_trace = format_ip4_forward_next_trace,
};
VLIB_NODE_FUNCTION_MULTIARCH (ip4_vxlan_bypass_node,ip4_vxlan_bypass)
/* Dummy init function to get us linked in. */
clib_error_t * ip4_vxlan_bypass_init (vlib_main_t * vm)
{ return 0; }
VLIB_INIT_FUNCTION (ip4_vxlan_bypass_init);
static uword
ip6_vxlan_bypass (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
return ip_vxlan_bypass_inline (vm, node, frame, /* is_ip4 */ 0);
}
VLIB_REGISTER_NODE (ip6_vxlan_bypass_node) = {
.function = ip6_vxlan_bypass,
.name = "ip6-vxlan-bypass",
.vector_size = sizeof (u32),
.n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
.next_nodes = {
[IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
[IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan6-input",
},
.format_buffer = format_ip6_header,
.format_trace = format_ip6_forward_next_trace,
};
VLIB_NODE_FUNCTION_MULTIARCH (ip6_vxlan_bypass_node,ip6_vxlan_bypass)
/* Dummy init function to get us linked in. */
clib_error_t * ip6_vxlan_bypass_init (vlib_main_t * vm)
{ return 0; }
VLIB_INIT_FUNCTION (ip6_vxlan_bypass_init);
#define foreach_vxlan_flow_input_next \
_(DROP, "error-drop") \
_(L2_INPUT, "l2-input")
typedef enum
{
#define _(s,n) VXLAN_FLOW_NEXT_##s,
foreach_vxlan_flow_input_next
#undef _
VXLAN_FLOW_N_NEXT,
} vxlan_flow_input_next_t;
#define foreach_vxlan_flow_error \
_(NONE, "no error") \
_(IP_CHECKSUM_ERROR, "Rx ip checksum errors") \
_(IP_HEADER_ERROR, "Rx ip header errors") \
_(UDP_CHECKSUM_ERROR, "Rx udp checksum errors") \
_(UDP_LENGTH_ERROR, "Rx udp length errors")
typedef enum
{
#define _(f,s) VXLAN_FLOW_ERROR_##f,
foreach_vxlan_flow_error
#undef _
VXLAN_FLOW_N_ERROR,
} vxlan_flow_error_t;
static char *vxlan_flow_error_strings[] = {
#define _(n,s) s,
foreach_vxlan_flow_error
#undef _
};
static_always_inline u8
vxlan_validate_udp_csum (vlib_main_t * vm, vlib_buffer_t *b)
{
u32 flags = b->flags;
enum { offset = sizeof(ip4_header_t) + sizeof(udp_header_t) + sizeof(vxlan_header_t), };
/* Verify UDP checksum */
if ((flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
{
vlib_buffer_advance (b, -offset);
flags = ip4_tcp_udp_validate_checksum (vm, b);
vlib_buffer_advance (b, offset);
}
return (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
}
static_always_inline u8
vxlan_check_udp_csum (vlib_main_t * vm, vlib_buffer_t *b)
{
ip4_vxlan_header_t * hdr = vlib_buffer_get_current(b) - sizeof *hdr;
udp_header_t * udp = &hdr->udp;
/* Don't verify UDP checksum for packets with explicit zero checksum. */
u8 good_csum = (b->flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0 ||
udp->checksum == 0;
return !good_csum;
}
static_always_inline u8
vxlan_check_ip (vlib_buffer_t *b, u16 payload_len)
{
ip4_vxlan_header_t * hdr = vlib_buffer_get_current(b) - sizeof *hdr;
u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
u16 expected = payload_len + sizeof *hdr;
return ip_len > expected || hdr->ip4.ttl == 0 || hdr->ip4.ip_version_and_header_length != 0x45;
}
static_always_inline u8
vxlan_check_ip_udp_len (vlib_buffer_t *b)
{
ip4_vxlan_header_t * hdr = vlib_buffer_get_current(b) - sizeof *hdr;
u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
u16 udp_len = clib_net_to_host_u16 (hdr->udp.length);
return udp_len > ip_len;
}
static_always_inline u8
vxlan_err_code (u8 ip_err0, u8 udp_err0, u8 csum_err0)
{
u8 error0 = VXLAN_FLOW_ERROR_NONE;
if (ip_err0)
error0 = VXLAN_FLOW_ERROR_IP_HEADER_ERROR;
if (udp_err0)
error0 = VXLAN_FLOW_ERROR_UDP_LENGTH_ERROR;
if (csum_err0)
error0 = VXLAN_FLOW_ERROR_UDP_CHECKSUM_ERROR;
return error0;
}
VLIB_NODE_FN (vxlan4_flow_input_node) (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * f)
{
enum { payload_offset = sizeof(ip4_vxlan_header_t) };
vxlan_main_t * vxm = &vxlan_main;
vnet_interface_main_t * im = &vnet_main.interface_main;
vlib_combined_counter_main_t * rx_counter[VXLAN_FLOW_N_NEXT] = {
[VXLAN_FLOW_NEXT_DROP] = im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_DROP,
[VXLAN_FLOW_NEXT_L2_INPUT] = im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX,
};
u32 thread_index = vlib_get_thread_index();
u32 * from = vlib_frame_vector_args (f);
u32 n_left_from = f->n_vectors;
u32 next_index = VXLAN_FLOW_NEXT_L2_INPUT;
while (n_left_from > 0)
{
u32 n_left_to_next, *to_next;
vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
while (n_left_from > 3 && n_left_to_next > 3)
{
u32 bi0 = to_next[0] = from[0];
u32 bi1 = to_next[1] = from[1];
u32 bi2 = to_next[2] = from[2];
u32 bi3 = to_next[3] = from[3];
from+=4;
n_left_from-=4;
to_next+=4;
n_left_to_next-=4;
vlib_buffer_t * b0 = vlib_get_buffer (vm, bi0);
vlib_buffer_t * b1 = vlib_get_buffer (vm, bi1);
vlib_buffer_t * b2 = vlib_get_buffer (vm, bi2);
vlib_buffer_t * b3 = vlib_get_buffer (vm, bi3);
vlib_buffer_advance (b0, payload_offset);
vlib_buffer_advance (b1, payload_offset);
vlib_buffer_advance (b2, payload_offset);
vlib_buffer_advance (b3, payload_offset);
u16 len0 = vlib_buffer_length_in_chain (vm, b0);
u16 len1 = vlib_buffer_length_in_chain (vm, b1);
u16 len2 = vlib_buffer_length_in_chain (vm, b2);
u16 len3 = vlib_buffer_length_in_chain (vm, b3);
u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT, next1 = VXLAN_FLOW_NEXT_L2_INPUT,
next2 = VXLAN_FLOW_NEXT_L2_INPUT, next3 = VXLAN_FLOW_NEXT_L2_INPUT;
u8 ip_err0 = vxlan_check_ip (b0, len0);
u8 ip_err1 = vxlan_check_ip (b1, len1);
u8 ip_err2 = vxlan_check_ip (b2, len2);
u8 ip_err3 = vxlan_check_ip (b3, len3);
u8 ip_err = ip_err0 | ip_err1 | ip_err2 | ip_err3;
u8 udp_err0 = vxlan_check_ip_udp_len (b0);
u8 udp_err1 = vxlan_check_ip_udp_len (b1);
u8 udp_err2 = vxlan_check_ip_udp_len (b2);
u8 udp_err3 = vxlan_check_ip_udp_len (b3);
u8 udp_err = udp_err0 | udp_err1 | udp_err2 | udp_err3;
u8 csum_err0 = vxlan_check_udp_csum (vm, b0);
u8 csum_err1 = vxlan_check_udp_csum (vm, b1);
u8 csum_err2 = vxlan_check_udp_csum (vm, b2);
u8 csum_err3 = vxlan_check_udp_csum (vm, b3);
u8 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
if (PREDICT_FALSE(csum_err))
{
if (csum_err0)
csum_err0 = !vxlan_validate_udp_csum (vm, b0);
if (csum_err1)
csum_err1 = !vxlan_validate_udp_csum (vm, b1);
if (csum_err2)
csum_err2 = !vxlan_validate_udp_csum (vm, b2);
if (csum_err3)
csum_err3 = !vxlan_validate_udp_csum (vm, b3);
csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
}
if (PREDICT_FALSE(ip_err || udp_err || csum_err))
{
if (ip_err0 || udp_err0 || csum_err0)
{
next0 = VXLAN_FLOW_NEXT_DROP;
u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
b0->error = node->errors[error0];
}
if (ip_err1 || udp_err1 || csum_err1)
{
next1 = VXLAN_FLOW_NEXT_DROP;
u8 error1 = vxlan_err_code (ip_err1, udp_err1, csum_err1);
b1->error = node->errors[error1];
}
if (ip_err2 || udp_err2 || csum_err2)
{
next2 = VXLAN_FLOW_NEXT_DROP;
u8 error2 = vxlan_err_code (ip_err2, udp_err2, csum_err2);
b2->error = node->errors[error2];
}
if (ip_err3 || udp_err3 || csum_err3)
{
next3 = VXLAN_FLOW_NEXT_DROP;
u8 error3 = vxlan_err_code (ip_err3, udp_err3, csum_err3);
b3->error = node->errors[error3];
}
}
vnet_update_l2_len (b0);
vnet_update_l2_len (b1);
vnet_update_l2_len (b2);
vnet_update_l2_len (b3);
ASSERT (b0->flow_id != 0);
ASSERT (b1->flow_id != 0);
ASSERT (b2->flow_id != 0);
ASSERT (b3->flow_id != 0);
u32 t_index0 = b0->flow_id - vxm->flow_id_start;
u32 t_index1 = b1->flow_id - vxm->flow_id_start;
u32 t_index2 = b2->flow_id - vxm->flow_id_start;
u32 t_index3 = b3->flow_id - vxm->flow_id_start;
vxlan_tunnel_t * t0 = &vxm->tunnels[t_index0];
vxlan_tunnel_t * t1 = &vxm->tunnels[t_index1];
vxlan_tunnel_t * t2 = &vxm->tunnels[t_index2];
vxlan_tunnel_t * t3 = &vxm->tunnels[t_index3];
/* flow id consumed */
b0->flow_id = 0;
b1->flow_id = 0;
b2->flow_id = 0;
b3->flow_id = 0;
u32 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
u32 sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX] = t1->sw_if_index;
u32 sw_if_index2 = vnet_buffer (b2)->sw_if_index[VLIB_RX] = t2->sw_if_index;
u32 sw_if_index3 = vnet_buffer (b3)->sw_if_index[VLIB_RX] = t3->sw_if_index;
vlib_increment_combined_counter (rx_counter[next0], thread_index, sw_if_index0, 1, len0);
vlib_increment_combined_counter (rx_counter[next1], thread_index, sw_if_index1, 1, len1);
vlib_increment_combined_counter (rx_counter[next2], thread_index, sw_if_index2, 1, len2);
vlib_increment_combined_counter (rx_counter[next3], thread_index, sw_if_index3, 1, len3);
u32 flags = b0->flags | b1->flags | b2->flags | b3->flags;
if (PREDICT_FALSE(flags & VLIB_BUFFER_IS_TRACED))
{
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
vxlan_rx_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof *tr);
u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
*tr = (vxlan_rx_trace_t) {
.next_index = next0, .error = error0, .tunnel_index = t_index0, .vni = t0->vni };
}
if (b1->flags & VLIB_BUFFER_IS_TRACED)
{
vxlan_rx_trace_t *tr = vlib_add_trace (vm, node, b1, sizeof *tr);
u8 error1 = vxlan_err_code (ip_err1, udp_err1, csum_err1);
*tr = (vxlan_rx_trace_t) {
.next_index = next1, .error = error1, .tunnel_index = t_index1, .vni = t1->vni };
}
if (b2->flags & VLIB_BUFFER_IS_TRACED)
{
vxlan_rx_trace_t *tr = vlib_add_trace (vm, node, b2, sizeof *tr);
u8 error2 = vxlan_err_code (ip_err2, udp_err2, csum_err2);
*tr = (vxlan_rx_trace_t) {
.next_index = next2, .error = error2, .tunnel_index = t_index2, .vni = t2->vni };
}
if (b3->flags & VLIB_BUFFER_IS_TRACED)
{
vxlan_rx_trace_t *tr = vlib_add_trace (vm, node, b3, sizeof *tr);
u8 error3 = vxlan_err_code (ip_err3, udp_err3, csum_err3);
*tr = (vxlan_rx_trace_t) {
.next_index = next3, .error = error3, .tunnel_index = t_index3, .vni = t3->vni };
}
}
vlib_validate_buffer_enqueue_x4
(vm, node, next_index, to_next, n_left_to_next,
bi0, bi1, bi2, bi3, next0, next1, next2, next3);
}
while (n_left_from > 0 && n_left_to_next > 0)
{
u32 bi0 = to_next[0] = from[0];
from++;
n_left_from--;
to_next++;
n_left_to_next--;
vlib_buffer_t * b0 = vlib_get_buffer (vm, bi0);
vlib_buffer_advance (b0, payload_offset);
u16 len0 = vlib_buffer_length_in_chain (vm, b0);
u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT;
u8 ip_err0 = vxlan_check_ip (b0, len0);
u8 udp_err0 = vxlan_check_ip_udp_len (b0);
u8 csum_err0 = vxlan_check_udp_csum (vm, b0);
if (csum_err0)
csum_err0 = !vxlan_validate_udp_csum (vm, b0);
if (ip_err0 || udp_err0 || csum_err0)
{
next0 = VXLAN_FLOW_NEXT_DROP;
u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
b0->error = node->errors[error0];
}
vnet_update_l2_len (b0);
ASSERT (b0->flow_id != 0);
u32 t_index0 = b0->flow_id - vxm->flow_id_start;
vxlan_tunnel_t * t0 = &vxm->tunnels[t_index0];
b0->flow_id = 0;
u32 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
vlib_increment_combined_counter (rx_counter[next0], thread_index, sw_if_index0, 1, len0);
if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
{
vxlan_rx_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof *tr);
u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
*tr = (vxlan_rx_trace_t) {
.next_index = next0, .error = error0, .tunnel_index = t_index0, .vni = t0->vni };
}
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);
}
return f->n_vectors;
}
/* *INDENT-OFF* */
#ifndef CLIB_MULTIARCH_VARIANT
VLIB_REGISTER_NODE (vxlan4_flow_input_node) = {
.name = "vxlan-flow-input",
.type = VLIB_NODE_TYPE_INTERNAL,
.vector_size = sizeof (u32),
.format_trace = format_vxlan_rx_trace,
.n_errors = VXLAN_FLOW_N_ERROR,
.error_strings = vxlan_flow_error_strings,
.n_next_nodes = VXLAN_FLOW_N_NEXT,
.next_nodes = {
#define _(s,n) [VXLAN_FLOW_NEXT_##s] = n,
foreach_vxlan_flow_input_next
#undef _
},
};
#endif
/* *INDENT-ON* */
t_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); |