diff options
| -rw-r--r-- | src/plugins/gbp/gbp_vxlan.c | 38 | ||||
| -rw-r--r-- | src/plugins/unittest/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | src/plugins/unittest/punt_test.c | 402 | ||||
| -rw-r--r-- | src/vlib/CMakeLists.txt | 4 | ||||
| -rw-r--r-- | src/vlib/buffer.h | 11 | ||||
| -rw-r--r-- | src/vlib/punt.c | 629 | ||||
| -rw-r--r-- | src/vlib/punt.h | 93 | ||||
| -rw-r--r-- | src/vlib/punt_node.c | 327 | ||||
| -rw-r--r-- | src/vlib/vlib.h | 1 | ||||
| -rw-r--r-- | src/vnet/ip/punt.c | 4 | ||||
| -rw-r--r-- | src/vnet/vxlan-gbp/decap.c | 26 | ||||
| -rw-r--r-- | src/vnet/vxlan-gbp/vxlan_gbp.c | 17 | ||||
| -rw-r--r-- | src/vnet/vxlan-gbp/vxlan_gbp.h | 7 | ||||
| -rw-r--r-- | test/test_punt.py | 176 |
14 files changed, 1706 insertions, 30 deletions
diff --git a/src/plugins/gbp/gbp_vxlan.c b/src/plugins/gbp/gbp_vxlan.c index 286345ed8fa..49dae7e9f4c 100644 --- a/src/plugins/gbp/gbp_vxlan.c +++ b/src/plugins/gbp/gbp_vxlan.c @@ -22,6 +22,7 @@ #include <vnet/vxlan-gbp/vxlan_gbp.h> #include <vlibmemory/api.h> #include <vnet/fib/fib_table.h> +#include <vlib/punt.h> /** * A reference to a VXLAN-GBP tunnel created as a child/dependent tunnel @@ -66,6 +67,10 @@ index_t *gbp_vxlan_tunnel_db; */ index_t *vxlan_tunnel_ref_db; +/** + * handle registered with the ;unt infra + */ +static vlib_punt_hdl_t punt_hdl; static char *gbp_vxlan_tunnel_layer_strings[] = { #define _(n,s) [GBP_VXLAN_TUN_##n] = s, @@ -672,28 +677,23 @@ VLIB_CLI_COMMAND (gbp_vxlan_show_node, static) = { static clib_error_t * gbp_vxlan_init (vlib_main_t * vm) { - u32 slot4; - vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "gbp-vxlan4"); - - /* - * insert ourselves into the VXLAN-GBP arc to collect the no-tunnel - * packets. - */ - slot4 = vlib_node_add_next_with_slot (vm, - vxlan4_gbp_input_node.index, - node->index, - VXLAN_GBP_INPUT_NEXT_NO_TUNNEL); - ASSERT (slot4 == VXLAN_GBP_INPUT_NEXT_NO_TUNNEL); - - /* slot6 = vlib_node_add_next_with_slot (vm, */ - /* vxlan6_gbp_input_node.index, */ - /* gbp_vxlan6_input_node.index, */ - /* VXLAN_GBP_INPUT_NEXT_NO_TUNNEL); */ - /* ASSERT (slot6 == VXLAN_GBP_INPUT_NEXT_NO_TUNNEL); */ + vxlan_gbp_main_t *vxm = &vxlan_gbp_main; + clib_error_t *error; gt_logger = vlib_log_register_class ("gbp", "tun"); - return (NULL); + if ((error = vlib_call_init_function (vm, punt_init))) + return error; + if ((error = vlib_call_init_function (vm, vxlan_gbp_init))) + return error; + + punt_hdl = vlib_punt_client_register ("gbp-vxlan"); + + vlib_punt_register (punt_hdl, + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP4], + "gbp-vxlan4"); + + return (error); } VLIB_INIT_FUNCTION (gbp_vxlan_init); diff --git a/src/plugins/unittest/CMakeLists.txt b/src/plugins/unittest/CMakeLists.txt index 74bcef3c208..0af0dea250c 100644 --- a/src/plugins/unittest/CMakeLists.txt +++ b/src/plugins/unittest/CMakeLists.txt @@ -24,6 +24,7 @@ add_vpp_plugin(unittest ipsec_test.c interface_test.c mfib_test.c + punt_test.c session_test.c string_test.c tcp_test.c diff --git a/src/plugins/unittest/punt_test.c b/src/plugins/unittest/punt_test.c new file mode 100644 index 00000000000..3806dae88a3 --- /dev/null +++ b/src/plugins/unittest/punt_test.c @@ -0,0 +1,402 @@ +/* + * Copyright (c) 2018 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/adj/rewrite.h> +#include <vnet/ethernet/ethernet.h> +#include <vnet/adj/adj.h> +#include <vnet/ip/ip.h> + +typedef enum punt_next_t_ +{ + PUNT_NEXT_DROP, + PUNT_N_NEXT, +} punt_next_t; + +typedef struct punt_trace_t_ +{ + vlib_punt_reason_t pt_reason; +} punt_trace_t; + +/** + * Per-thread clone vectors + */ +u32 **punt_clones; + +#define SW_IF_INDEX_PG0 1 +#define SW_IF_INDEX_PG1 2 + +index_t *adjs[FIB_PROTOCOL_IP_MAX]; + +static vlib_punt_reason_t punt_reason_v4, punt_reason_v6; +static vlib_punt_hdl_t punt_hdl; + +static u8 * +format_punt_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 *); + punt_trace_t *t = va_arg (*args, punt_trace_t *); + + s = format (s, "punt: %U", format_vlib_punt_reason, t->pt_reason); + + return s; +} + +always_inline uword +punt_test_fwd (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame, fib_protocol_t fproto, u32 sw_if_index) +{ + u32 n_left_from, *from, *to_next, next_index; + + from = vlib_frame_vector_args (frame); + n_left_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) + { + ip_adjacency_t *adj0; + vlib_buffer_t *b0; + void *ip0; + index_t ai0; + u32 bi0; + + bi0 = to_next[0] = from[0]; + from += 1; + to_next += 1; + n_left_to_next -= 1; + n_left_from -= 1; + + b0 = vlib_get_buffer (vm, bi0); + vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index; + ai0 = adjs[fproto][sw_if_index]; + + adj0 = adj_get (ai0); + ip0 = vlib_buffer_get_current (b0); + + vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes); + vnet_rewrite_one_header (adj0[0], ip0, sizeof (ethernet_header_t)); + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, bi0, 0); + } + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return frame->n_vectors; +} + +always_inline uword +punt_test_pg0_ip4 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_fwd (vm, node, frame, FIB_PROTOCOL_IP4, SW_IF_INDEX_PG0)); +} + +always_inline uword +punt_test_pg1_ip4 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_fwd (vm, node, frame, FIB_PROTOCOL_IP4, SW_IF_INDEX_PG1)); +} + +always_inline uword +punt_test_pg0_ip6 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_fwd (vm, node, frame, FIB_PROTOCOL_IP6, SW_IF_INDEX_PG0)); +} + +always_inline uword +punt_test_pg1_ip6 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_fwd (vm, node, frame, FIB_PROTOCOL_IP6, SW_IF_INDEX_PG1)); +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (punt_test_pg0_ip4_node) = { + .function = punt_test_pg0_ip4, + .name = "punt-test-pg0-ip4", + .vector_size = sizeof (u32), + .format_trace = format_punt_trace, +}; +VLIB_REGISTER_NODE (punt_test_pg1_ip4_node) = { + .function = punt_test_pg1_ip4, + .name = "punt-test-pg1-ip4", + .vector_size = sizeof (u32), + .format_trace = format_punt_trace, +}; +VLIB_REGISTER_NODE (punt_test_pg0_ip6_node) = { + .function = punt_test_pg0_ip6, + .name = "punt-test-pg0-ip6", + .vector_size = sizeof (u32), + .format_trace = format_punt_trace, +}; +VLIB_REGISTER_NODE (punt_test_pg1_ip6_node) = { + .function = punt_test_pg1_ip6, + .name = "punt-test-pg1-ip6", + .vector_size = sizeof (u32), + .format_trace = format_punt_trace, +}; +/* *INDENT-ON* */ + +typedef struct punt_feat_trace_t_ +{ + vlib_punt_reason_t pt_reason; +} punt_feat_trace_t; + +always_inline uword +punt_test_feat_inline (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame, u8 is_ip4) +{ + u32 n_left_from, *from, *to_next, next_index; + + from = vlib_frame_vector_args (frame); + n_left_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) + { + vlib_buffer_t *b0; + u32 bi0, next0; + + bi0 = to_next[0] = from[0]; + from += 1; + to_next += 1; + n_left_to_next -= 1; + n_left_from -= 1; + next0 = 0; + + b0 = vlib_get_buffer (vm, bi0); + + if (is_ip4) + b0->punt_reason = punt_reason_v4; + else + b0->punt_reason = punt_reason_v6; + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + punt_feat_trace_t *t; + + b0 = vlib_get_buffer (vm, bi0); + + t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->pt_reason = b0->punt_reason; + } + 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 u8 * +format_punt_feat_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 *); + punt_feat_trace_t *t = va_arg (*args, punt_feat_trace_t *); + + s = format (s, "reason: %U", format_vlib_punt_reason, t->pt_reason); + + return s; +} + +always_inline uword +punt_test_feat_ip4 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_feat_inline (vm, node, frame, 1)); +} + +always_inline uword +punt_test_feat_ip6 (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + return (punt_test_feat_inline (vm, node, frame, 0)); +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (punt_test_feat_ip6_node) = { + .function = punt_test_feat_ip6, + .name = "punt-test-feat-ip6", + .vector_size = sizeof (u32), + .format_trace = format_punt_feat_trace, + .n_next_nodes = 1, + .next_nodes = { + [0] = "punt-dispatch" + } +}; +VLIB_REGISTER_NODE (punt_test_feat_ip4_node) = { + .function = punt_test_feat_ip4, + .name = "punt-test-feat-ip4", + .vector_size = sizeof (u32), + .format_trace = format_punt_feat_trace, + .n_next_nodes = 1, + .next_nodes = { + [0] = "punt-dispatch" + } +}; +VNET_FEATURE_INIT (punt_test_feat_ip6_feature, static) = +{ + .arc_name = "ip6-unicast", + .node_name = "punt-test-feat-ip6", +}; +VNET_FEATURE_INIT (punt_test_feat_ip4_feature, static) = +{ + .arc_name = "ip4-unicast", + .node_name = "punt-test-feat-ip4", +}; +/* *INDENT-ON* */ + +static clib_error_t * +punt_test (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd_arg) +{ + ip46_address_t ip46 = ip46_address_initializer; + fib_protocol_t fproto; + vnet_main_t *vnm; + u32 sw_if_index; + int rc; + + vnm = vnet_get_main (); + fproto = FIB_PROTOCOL_IP4; + + if (unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) + { + vlib_node_t *from; + + if (unformat (input, "%U", unformat_ip4_address, &ip46.ip4)) + { + fproto = FIB_PROTOCOL_IP4; + } + else if (unformat (input, "%U", unformat_ip6_address, &ip46.ip6)) + { + fproto = FIB_PROTOCOL_IP6; + } + else if (unformat (input, "clear")) + { + vnet_feature_enable_disable ("ip4-unicast", + "punt-test-feat-ip4", + sw_if_index, 0, NULL, 0); + vnet_feature_enable_disable ("ip6-unicast", + "punt-test-feat-ip6", + sw_if_index, 0, NULL, 0); + return NULL; + } + else + { + /* + * allocate a client and a reason + */ + punt_hdl = vlib_punt_client_register ("test"); + + rc = + vlib_punt_reason_alloc (punt_hdl, "reason-v4", &punt_reason_v4); + rc |= + vlib_punt_reason_alloc (punt_hdl, "reason-v6", &punt_reason_v6); + ASSERT (!rc); + + vnet_feature_enable_disable ("ip4-unicast", + "punt-test-feat-ip4", + sw_if_index, 1, NULL, 0); + vnet_feature_enable_disable ("ip6-unicast", + "punt-test-feat-ip6", + sw_if_index, 1, NULL, 0); + return NULL; + } + + if (SW_IF_INDEX_PG0 == sw_if_index) + { + if (FIB_PROTOCOL_IP4 == fproto) + { + /* + * register the node that will forward the punted packet + */ + vlib_punt_register (punt_hdl, punt_reason_v4, + "punt-test-pg0-ip4"); + from = vlib_get_node_by_name (vm, (u8 *) "punt-test-pg0-ip4"); + } + else + { + vlib_punt_register (punt_hdl, punt_reason_v6, + "punt-test-pg0-ip6"); + from = vlib_get_node_by_name (vm, (u8 *) "punt-test-pg0-ip6"); + } + } + else + { + if (FIB_PROTOCOL_IP4 == fproto) + { + vlib_punt_register (punt_hdl, punt_reason_v4, + "punt-test-pg1-ip4"); + from = vlib_get_node_by_name (vm, (u8 *) "punt-test-pg1-ip4"); + } + else + { + vlib_punt_register (punt_hdl, punt_reason_v6, + "punt-test-pg1-ip6"); + from = vlib_get_node_by_name (vm, (u8 *) "punt-test-pg1-ip6"); + } + } + + vlib_node_add_next (vm, from->index, + vnet_tx_node_index_for_sw_interface + (vnm, sw_if_index)); + + vec_validate (adjs[fproto], sw_if_index); + + adjs[fproto][sw_if_index] = adj_nbr_find (fproto, + fib_proto_to_link (fproto), + &ip46, sw_if_index); + } + + return (NULL); +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (test_fib_command, static) = +{ + .path = "test punt", + .short_help = "punt unit tests - DO NOT RUN ON A LIVE SYSTEM", + .function = punt_test, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vlib/CMakeLists.txt b/src/vlib/CMakeLists.txt index ff64baea980..acd66359f9b 100644 --- a/src/vlib/CMakeLists.txt +++ b/src/vlib/CMakeLists.txt @@ -63,6 +63,8 @@ add_vpp_library(vlib node_format.c pci/pci.c physmem.c + punt.c + punt_node.c threads.c threads_cli.c trace.c @@ -77,6 +79,7 @@ add_vpp_library(vlib MULTIARCH_SOURCES drop.c + punt_node.c INSTALL_HEADERS buffer_funcs.h @@ -102,6 +105,7 @@ add_vpp_library(vlib pci/pci.h physmem_funcs.h physmem.h + punt.h threads.h trace_funcs.h trace.h diff --git a/src/vlib/buffer.h b/src/vlib/buffer.h index 514e73bd7ca..0fd57f5275b 100644 --- a/src/vlib/buffer.h +++ b/src/vlib/buffer.h @@ -139,8 +139,15 @@ typedef union * VLIB_BUFFER_NEXT_PRESENT flag is set. */ u32 next_buffer; - /** Used by feature subgraph arcs to visit enabled feature nodes */ - u32 current_config_index; + /** The following fields can be in a union because once a packet enters + * the punt path, it is no longer on a feature arc */ + union + { + /** Used by feature subgraph arcs to visit enabled feature nodes */ + u32 current_config_index; + /* the reason the packet once punted */ + u32 punt_reason; + }; /** Opaque data used by sub-graphs for their own purposes. */ u32 opaque[10]; diff --git a/src/vlib/punt.c b/src/vlib/punt.c new file mode 100644 index 00000000000..09f30f4f810 --- /dev/null +++ b/src/vlib/punt.c @@ -0,0 +1,629 @@ +/* + * Copyright (c) 2018 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/punt.h> + +/** + * The last allocated punt reason + */ +static vlib_punt_reason_t punt_reason_last; + +/** + * Counters per punt-reason + */ +vlib_combined_counter_main_t punt_counters = { + .name = "punt", + .stat_segment_name = "/net/punt", +}; + +/** + * A punt reason + */ +typedef struct punt_reason_data_t_ +{ + /** + * The reason name + */ + u8 *pd_name; + + /** + * The allocated reason value + */ + vlib_punt_reason_t pd_reason; + + /** + * Clients/owners that have registered this reason + */ + u32 *pd_owners; +} punt_reason_data_t; + +/** + * data for each punt reason + */ +static punt_reason_data_t *punt_reason_data; + +typedef enum punt_format_flags_t_ +{ + PUNT_FORMAT_FLAG_NONE = 0, + PUNT_FORMAT_FLAG_DETAIL = (1 << 0), +} punt_format_flags_t; + +/** + * A registration, by a client, to direct punted traffic to a given node + */ +typedef struct punt_reg_t_ +{ + /** + * Reason the packets were punted + */ + vlib_punt_reason_t pr_reason; + + /** + * number of clients that have made this registration + */ + u16 pr_locks; + + /** + * The edge from the punt dispatch node to the requested node + */ + u16 pr_edge; + + /** + * node-index to send punted packets to + */ + u32 pr_node_index; +} punt_reg_t; + +/** + * Pool of registrations + */ +static punt_reg_t *punt_reg_pool; + +/** + * A DB of all the register nodes against punt reason and node index + */ +static uword *punt_reg_db; + +/** + * A DB used in the DP per-reason to dispatch packets to the requested nodes. + * this is a vector of edges per-reason + */ +u16 **punt_dp_db; + +/** + * A client using the punt serivce and its registrations + */ +typedef struct punt_client_t_ +{ + /** + * The name of the client + */ + u8 *pc_name; + + /** + * The registrations is has made + */ + u32 *pc_regs; +} punt_client_t; + +/** + * Pool of clients + */ +static punt_client_t *punt_client_pool; + +/** + * DB of clients key'd by their name + */ +static uword *punt_client_db; + +u8 * +format_vlib_punt_reason (u8 * s, va_list * args) +{ + vlib_punt_reason_t pr = va_arg (*args, int); + + return (format (s, "[%d] %v", pr, punt_reason_data[pr].pd_name)); +} + +vlib_punt_hdl_t +vlib_punt_client_register (const char *who) +{ + u8 *pc_name; + uword *p; + u32 pci; + + pc_name = format (NULL, "%s", who); + p = hash_get_mem (punt_client_db, pc_name); + + if (NULL == p) + { + punt_client_t *pc; + + pool_get (punt_client_pool, pc); + pci = pc - punt_client_pool; + + pc->pc_name = pc_name; + + hash_set_mem (punt_client_db, pc->pc_name, pci); + } + else + { + pci = p[0]; + vec_free (pc_name); + } + + return (pci); +} + +static int +punt_validate_client (vlib_punt_hdl_t client) +{ + return (!pool_is_free_index (punt_client_pool, client)); +} + +static u64 +punt_reg_mk_key (vlib_punt_reason_t reason, u32 node_index) +{ + return (((u64) node_index) << 32 | reason); +} + +static u32 +punt_reg_find (vlib_punt_reason_t reason, u32 node_index) +{ + uword *p; + + p = hash_get (punt_reg_db, punt_reg_mk_key (reason, node_index)); + + if (p) + return p[0]; + + return ~0; +} + +static void +punt_reg_add (const punt_reg_t * pr) +{ + hash_set (punt_reg_db, punt_reg_mk_key (pr->pr_reason, + pr->pr_node_index), + pr - punt_reg_pool); +} + +static void +punt_reg_remove (const punt_reg_t * pr) +{ + hash_unset (punt_reg_db, punt_reg_mk_key (pr->pr_reason, + pr->pr_node_index)); +} + +/** + * reconstruct the DP per-reason DB + */ +static void +punt_reg_mk_dp (vlib_punt_reason_t reason) +{ + u32 pri, *prip, *pris; + const punt_reg_t *pr; + u16 *edges, *old; + u64 key; + + pris = NULL; + edges = NULL; + vec_validate (punt_dp_db, reason); + + old = punt_dp_db[reason]; + + /* *INDENT-OFF* */ + hash_foreach (key, pri, punt_reg_db, + ({ + vec_add1(pris, pri); + })); + /* *INDENT-ON* */ + + /* + * A check for an empty vector is done in the DP, so the a zero + * length vector here is ok + */ + vec_foreach (prip, pris) + { + pr = pool_elt_at_index (punt_reg_pool, *prip); + + if (pr->pr_reason == reason) + vec_add1 (edges, pr->pr_edge); + } + + /* atomic update of the DP */ + punt_dp_db[reason] = edges; + + vec_free (old); +} + +int +vlib_punt_register (vlib_punt_hdl_t client, vlib_punt_reason_t reason, + const char *node_name) +{ + vlib_node_t *punt_to, *punt_from; + punt_client_t *pc; + vlib_main_t *vm; + punt_reg_t *pr; + u32 pri; + + if (reason >= punt_reason_last) + return -1; + if (!punt_validate_client (client)) + return -2; + + vm = vlib_get_main (); + pc = pool_elt_at_index (punt_client_pool, client); + punt_to = vlib_get_node_by_name (vm, (u8 *) node_name); + punt_from = vlib_get_node_by_name (vm, (u8 *) "punt-dispatch"); + + /* + * find a global matching registration + */ + pri = punt_reg_find (reason, punt_to->index); + + if (~0 != pri) + { + u32 pos; + + pos = vec_search (pc->pc_regs, pri); + + if (~0 != pos) + { + /* duplicate registration for this client */ + return -1; + } + + pr = pool_elt_at_index (punt_reg_pool, pri); + } + else + { + pool_get (punt_reg_pool, pr); + + pr->pr_reason = reason; + pr->pr_node_index = punt_to->index; + pr->pr_edge = vlib_node_add_next (vm, + punt_from->index, pr->pr_node_index); + + pri = pr - punt_reg_pool; + + punt_reg_add (pr); + } + + /* + * add this reg to the list the client has made + */ + pr->pr_locks++; + vec_add1 (pc->pc_regs, pri); + + punt_reg_mk_dp (reason); + + return 0; +} + +int +vlib_punt_unregister (vlib_punt_hdl_t client, + vlib_punt_reason_t reason, const char *node_name) +{ + vlib_node_t *punt_to; + punt_client_t *pc; + vlib_main_t *vm; + punt_reg_t *pr; + u32 pri; + + if (reason >= punt_reason_last) + return -1; + + vm = vlib_get_main (); + pc = pool_elt_at_index (punt_client_pool, client); + punt_to = vlib_get_node_by_name (vm, (u8 *) node_name); + + /* + * construct a registration and check if it's one this client already has + */ + pri = punt_reg_find (reason, punt_to->index); + + if (~0 != pri) + { + u32 pos; + + pos = vec_search (pc->pc_regs, pri); + + if (~0 == pos) + { + /* not a registration for this client */ + return -1; + } + vec_del1 (pc->pc_regs, pos); + + pr = pool_elt_at_index (punt_reg_pool, pri); + + pr->pr_locks--; + + if (0 == pr->pr_locks) + { + punt_reg_remove (pr); + pool_put (punt_reg_pool, pr); + } + } + + /* + * rebuild the DP data-base + */ + punt_reg_mk_dp (reason); + + return (0); +} + +int +vlib_punt_reason_alloc (vlib_punt_hdl_t client, + const char *reason_name, vlib_punt_reason_t * reason) +{ + vlib_punt_reason_t new; + + if (!punt_validate_client (client)) + return -2; + + new = punt_reason_last++; + vec_validate (punt_reason_data, new); + punt_reason_data[new].pd_name = format (NULL, "%s", reason_name); + punt_reason_data[new].pd_reason = new; + vec_add1 (punt_reason_data[new].pd_owners, client); + + vlib_validate_combined_counter (&punt_counters, new); + vlib_zero_combined_counter (&punt_counters, new); + + *reason = new; + + /* build the DP data-base */ + punt_reg_mk_dp (*reason); + + return (0); +} + +/* Parse node name -> node index. */ +uword +unformat_punt_client (unformat_input_t * input, va_list * args) +{ + u32 *result = va_arg (*args, u32 *); + + return unformat_user (input, unformat_hash_vec_string, + punt_client_db, result); +} + +u8 * +format_punt_reg (u8 * s, va_list * args) +{ + u32 pri = va_arg (*args, u32); + punt_reg_t *pr; + + pr = pool_elt_at_index (punt_reg_pool, pri); + + s = format (s, "%U -> %U", + format_vlib_punt_reason, pr->pr_reason, + format_vlib_node_name, vlib_get_main (), pr->pr_node_index); + + return (s); +} + +u8 * +format_punt_reason_data (u8 * s, va_list * args) +{ + punt_reason_data_t *pd = va_arg (*args, punt_reason_data_t *); + punt_client_t *pc; + u32 *pci; + + s = format (s, "[%d] %v from:[", pd->pd_reason, pd->pd_name); + vec_foreach (pci, pd->pd_owners) + { + pc = pool_elt_at_index (punt_client_pool, *pci); + s = format (s, "%v ", pc->pc_name); + } + s = format (s, "]"); + + return (s); +} + +u8 * +format_punt_client (u8 * s, va_list * args) +{ + u32 pci = va_arg (*args, u32); + punt_format_flags_t flags = va_arg (*args, punt_format_flags_t); + punt_client_t *pc; + + pc = pool_elt_at_index (punt_client_pool, pci); + + s = format (s, "%v", pc->pc_name); + + if (flags & PUNT_FORMAT_FLAG_DETAIL) + { + punt_reason_data_t *pd; + u32 *pri; + + s = format (s, "\n registrations:"); + vec_foreach (pri, pc->pc_regs) + { + s = format (s, "\n [%U]", format_punt_reg, *pri); + } + + s = format (s, "\n reasons:"); + + vec_foreach (pd, punt_reason_data) + { + u32 *tmp; + + vec_foreach (tmp, pd->pd_owners) + { + if (*tmp == pci) + s = format (s, "\n %U", format_punt_reason_data, pd); + } + } + } + return (s); +} + +static clib_error_t * +punt_client_show (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + u32 pci = ~0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "%U", unformat_punt_client, &pci)) + ; + else + break; + } + + if (~0 != pci) + { + vlib_cli_output (vm, "%U", format_punt_client, pci, + PUNT_FORMAT_FLAG_DETAIL); + } + else + { + u8 *name; + + /* *INDENT-OFF* */ + hash_foreach(name, pci, punt_client_db, + ({ + vlib_cli_output (vm, "%U", format_punt_client, pci, + PUNT_FORMAT_FLAG_NONE); + })); + /* *INDENT-ON* */ + } + + return (NULL); +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (punt_client_show_command, static) = +{ + .path = "show punt client", + .short_help = "show client[s] registered with the punt infra", + .function = punt_client_show, +}; +/* *INDENT-ON* */ + +static clib_error_t * +punt_reason_show (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + const punt_reason_data_t *pd; + + vec_foreach (pd, punt_reason_data) + { + vlib_cli_output (vm, "%U", format_punt_reason_data, pd); + } + + return (NULL); +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (punt_reason_show_command, static) = +{ + .path = "show punt reasons", + .short_help = "show all punt reasons", + .function = punt_reason_show, +}; +/* *INDENT-ON* */ + +static clib_error_t * +punt_db_show (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + u32 pri, ii, jj; + u64 key; + + /* *INDENT-OFF* */ + hash_foreach (key, pri, punt_reg_db, + ({ + vlib_cli_output (vm, " %U", format_punt_reg, pri); + })); + /* *INDENT-ON* */ + + vlib_cli_output (vm, "\nDerived data-plane data-base:"); + vlib_cli_output (vm, + " (for each punt-reason the edge[s] from punt-dispatch)"); + + vec_foreach_index (ii, punt_dp_db) + { + u8 *s = NULL; + vlib_cli_output (vm, " %U", format_vlib_punt_reason, ii); + + vec_foreach_index (jj, punt_dp_db[ii]) + { + s = format (s, "%d ", punt_dp_db[ii][jj]); + } + vlib_cli_output (vm, " [%v]", s); + vec_free (s); + } + + return (NULL); +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (punt_db_show_command, static) = +{ + .path = "show punt db", + .short_help = "show the punt DB", + .function = punt_db_show, +}; +/* *INDENT-ON* */ + +static clib_error_t * +punt_stats_show (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + vlib_combined_counter_main_t *cm = &punt_counters; + vlib_counter_t c; + u32 ii; + + for (ii = 0; ii < vlib_combined_counter_n_counters (cm); ii++) + { + vlib_get_combined_counter (cm, ii, &c); + vlib_cli_output (vm, "%U packets:%lld bytes:%lld", + format_vlib_punt_reason, ii, c.packets, c.bytes); + } + + return (NULL); +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (punt_stats_show_command, static) = +{ + .path = "show punt stats", + .short_help = "show the punt stats", + .function = punt_stats_show, +}; +/* *INDENT-ON* */ + +static clib_error_t * +punt_init (vlib_main_t * vm) +{ + punt_client_db = hash_create_vec (0, sizeof (u8), sizeof (u32)); + + return (NULL); +} + +VLIB_INIT_FUNCTION (punt_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vlib/punt.h b/src/vlib/punt.h new file mode 100644 index 00000000000..adb25f91a5e --- /dev/null +++ b/src/vlib/punt.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2018 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 __PUNT_H__ +#define __PUNT_H__ + +#include <vlib/vlib.h> + +/** + * The 'syatem' defined punt reasons. + * Only add to this list reasons defined and used within the vlib subsystem. + * To define new reasons in e.g. plgins, use punt_reason_alloc() + */ +typedef enum vlib_punt_reason_t_ +{ + PUNT_N_REASONS, +} vlib_punt_reason_t; + + +/** + * @brief Format a punt reason + */ +extern u8 *format_vlib_punt_reason (u8 * s, va_list * args); + +/** + * Typedef for a client handle + */ +typedef int vlib_punt_hdl_t; + +/** + * @brief Register a new clinet + * + * @param who - The name of the client + * + * @retrun the handle the punt infra allocated for this client that must + * be used when the client wishes to use the infra + */ +vlib_punt_hdl_t vlib_punt_client_register (const char *who); + +/** + * Allocate a new punt reason + */ +extern int vlib_punt_reason_alloc (vlib_punt_hdl_t client, + const char *reason_name, + vlib_punt_reason_t * reason); + +/** + * @brief Register a node to receive particular punted buffers + * + * @paran client - The registered client registering for the packets + * @param reason - The reason the packet was punted + * @param node - The node to which the punted packets will be sent + */ +extern int vlib_punt_register (vlib_punt_hdl_t client, + vlib_punt_reason_t reason, const char *node); +extern int vlib_punt_unregister (vlib_punt_hdl_t client, + vlib_punt_reason_t pr, const char *node); + +/** + * FOR USE IN THE DP ONLY + * + * Arc[s] to follow for each reason + */ +extern u16 **punt_dp_db; + +/** + * FOR USE IN THE DP ONLY + * + * Per-reason counters + */ +extern vlib_combined_counter_main_t punt_counters; + +#endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vlib/punt_node.c b/src/vlib/punt_node.c new file mode 100644 index 00000000000..c87d2b6fe36 --- /dev/null +++ b/src/vlib/punt_node.c @@ -0,0 +1,327 @@ +/* + * Copyright (c) 2018 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/punt.h> + +#define foreach_punt_error \ + _(DISPATCHED, "dispatched") \ + _(NO_REASON, "No such punt reason") \ + _(NO_REG, "No registrations") \ + _(REP_FAIL, "Replication Faliure") + +typedef enum punt_error_t_ +{ +#define _(v,s) PUNT_ERROR_##v, + foreach_punt_error +#undef _ + PUNT_N_ERRORS, +} punt_error_t; + +static char *punt_error_strings[] = { +#define _(v,s) [PUNT_ERROR_##v] = s, + foreach_punt_error +#undef _ +}; + +typedef enum punt_next_t_ +{ + PUNT_NEXT_DROP, + PUNT_N_NEXT, +} punt_next_t; + +typedef struct punt_trace_t_ +{ + vlib_punt_reason_t pt_reason; +} punt_trace_t; + +/** + * Per-thread clone vectors + */ +#ifndef CLIB_MARCH_VARIANT +u32 **punt_clones; +#else +extern u32 **punt_clones; +#endif + +static u8 * +format_punt_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 *); + punt_trace_t *t = va_arg (*args, punt_trace_t *); + + s = format (s, "reason: %U", format_vlib_punt_reason, t->pt_reason); + + return s; +} + +always_inline u32 +punt_replicate (vlib_main_t * vm, + vlib_node_runtime_t * node, + u32 thread_index, + vlib_buffer_t * b0, + u32 bi0, + vlib_punt_reason_t pr0, + u32 * next_index, + u32 * n_left_to_next, u32 ** to_next, u32 * pkts_rep_fail) +{ + /* multiple clients => replicate a copy to each */ + u16 n_clones0, n_cloned0, clone0; + u32 ci0, next0; + + n_clones0 = vec_len (punt_dp_db[pr0]); + vec_validate (punt_clones[thread_index], n_clones0); + + n_cloned0 = vlib_buffer_clone (vm, bi0, + punt_clones[thread_index], + n_clones0, 2 * CLIB_CACHE_LINE_BYTES); + + if (PREDICT_FALSE (n_cloned0 != n_clones0)) + { + b0->error = node->errors[PUNT_ERROR_REP_FAIL]; + *pkts_rep_fail += 1; + } + + for (clone0 = 1; clone0 < n_cloned0; clone0++) + { + ci0 = punt_clones[thread_index][clone0]; + + *to_next[0] = ci0; + *to_next += 1; + *n_left_to_next -= 1; + + next0 = punt_dp_db[pr0][clone0]; + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + vlib_buffer_t *c0; + punt_trace_t *t; + + c0 = vlib_get_buffer (vm, ci0); + + if (c0 != b0) + vlib_buffer_copy_trace_flag (vm, b0, ci0); + + t = vlib_add_trace (vm, node, c0, sizeof (*t)); + t->pt_reason = pr0; + } + + vlib_validate_buffer_enqueue_x1 (vm, node, *next_index, + *to_next, *n_left_to_next, ci0, next0); + + /* replications here always go to different next-nodes + * so there's no need to check if the to_next frame + * is full */ + } + + /* The original buffer is the first clone */ + next0 = punt_dp_db[pr0][0]; + *to_next[0] = bi0; + return next0; +} + +always_inline u32 +punt_dispatch_one (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_combined_counter_main_t * cm, + u32 thread_index, + u32 bi0, + u32 * next_index, + u32 * n_left_to_next, u32 ** to_next, u32 * pkts_errors) +{ + vlib_punt_reason_t pr0; + vlib_buffer_t *b0; + u32 next0; + + b0 = vlib_get_buffer (vm, bi0); + pr0 = b0->punt_reason; + + if (PREDICT_FALSE (pr0 >= vec_len (punt_dp_db))) + { + b0->error = node->errors[PUNT_ERROR_NO_REASON]; + next0 = PUNT_NEXT_DROP; + pkts_errors[PUNT_ERROR_NO_REASON] += 1; + } + else + { + vlib_increment_combined_counter + (cm, thread_index, pr0, 1, vlib_buffer_length_in_chain (vm, b0)); + + if (PREDICT_TRUE (1 == vec_len (punt_dp_db[pr0]))) + { + /* + * one registered client => give it the packet + * This is the most likely outcome. + */ + next0 = punt_dp_db[pr0][0]; + pkts_errors[PUNT_ERROR_DISPATCHED] += 1; + } + else if (0 == vec_len (punt_dp_db[pr0])) + { + /* no registered clients => drop */ + next0 = PUNT_NEXT_DROP; + pkts_errors[PUNT_ERROR_NO_REG] += 1; + } + else + { + /* + * multiple registered clients => replicate + */ + pkts_errors[PUNT_ERROR_DISPATCHED] += 1; + + next0 = punt_replicate (vm, node, thread_index, b0, bi0, pr0, + next_index, n_left_to_next, to_next, + &pkts_errors[PUNT_ERROR_REP_FAIL]); + } + } + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + punt_trace_t *t; + + t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->pt_reason = pr0; + } + + return (next0); +} + +VLIB_NODE_FN (punt_dispatch_node) (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, *from, *to_next, next_index, thread_index; + vlib_combined_counter_main_t *cm; + u32 pkt_errors[PUNT_N_ERRORS] = { 0 }; + + cm = &punt_counters; + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + thread_index = vlib_get_thread_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 > 4 && n_left_to_next > 2) + { + punt_next_t next0, next1; + u32 bi0, bi1; + + { + vlib_buffer_t *b2, *b3; + + b2 = vlib_get_buffer (vm, from[2]); + b3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (b2, LOAD); + vlib_prefetch_buffer_header (b3, LOAD); + } + + bi0 = to_next[0] = from[0]; + bi1 = to_next[1] = from[1]; + from += 2; + n_left_from -= 2; + + next0 = punt_dispatch_one (vm, node, cm, thread_index, bi0, + &next_index, &n_left_to_next, + &to_next, pkt_errors); + next1 = punt_dispatch_one (vm, node, cm, thread_index, bi1, + &next_index, &n_left_to_next, + &to_next, pkt_errors); + + to_next += 2; + n_left_to_next -= 2; + + 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) + { + punt_next_t next0; + u32 bi0; + + bi0 = to_next[0] = from[0]; + from += 1; + n_left_from -= 1; + + next0 = punt_dispatch_one (vm, node, cm, thread_index, bi0, + &next_index, &n_left_to_next, + &to_next, pkt_errors); + + to_next += 1; + n_left_to_next -= 1; + + 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, node->node_index, + PUNT_ERROR_DISPATCHED, + pkt_errors[PUNT_ERROR_DISPATCHED]); + vlib_node_increment_counter (vm, node->node_index, + PUNT_ERROR_NO_REASON, + pkt_errors[PUNT_ERROR_NO_REASON]); + vlib_node_increment_counter (vm, node->node_index, + PUNT_ERROR_NO_REG, + pkt_errors[PUNT_ERROR_NO_REG]); + vlib_node_increment_counter (vm, node->node_index, + PUNT_ERROR_REP_FAIL, + pkt_errors[PUNT_ERROR_REP_FAIL]); + + return frame->n_vectors; +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (punt_dispatch_node) = { + .name = "punt-dispatch", + .vector_size = sizeof (u32), + .format_trace = format_punt_trace, + .n_errors = PUNT_N_ERRORS, + .error_strings = punt_error_strings, + .n_next_nodes = PUNT_N_NEXT, + .next_nodes = { + [PUNT_NEXT_DROP] = "drop", + }, +}; + +/* *INDENT-ON* */ + +#ifndef CLIB_MARCH_VARIANT +clib_error_t * +punt_node_init (vlib_main_t * vm) +{ + vec_validate (punt_clones, vlib_num_workers ()); + + return NULL; +} + +VLIB_INIT_FUNCTION (punt_node_init); +#endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vlib/vlib.h b/src/vlib/vlib.h index 2149c4763ab..b5fe47b3729 100644 --- a/src/vlib/vlib.h +++ b/src/vlib/vlib.h @@ -58,6 +58,7 @@ typedef u32 vlib_log_class_t; #include <vlib/error.h> #include <vlib/init.h> #include <vlib/node.h> +#include <vlib/punt.h> #include <vlib/trace.h> #include <vlib/log.h> diff --git a/src/vnet/ip/punt.c b/src/vnet/ip/punt.c index 831ece25415..743df1fef0b 100644 --- a/src/vnet/ip/punt.c +++ b/src/vnet/ip/punt.c @@ -1059,7 +1059,7 @@ VLIB_CLI_COMMAND (show_punt_socket_registration_command, static) = /* *INDENT-ON* */ clib_error_t * -punt_init (vlib_main_t * vm) +ip_punt_init (vlib_main_t * vm) { punt_main_t *pm = &punt_main; @@ -1077,7 +1077,7 @@ punt_init (vlib_main_t * vm) return 0; } -VLIB_INIT_FUNCTION (punt_init); +VLIB_INIT_FUNCTION (ip_punt_init); #endif /* CLIB_MARCH_VARIANT */ static clib_error_t * diff --git a/src/vnet/vxlan-gbp/decap.c b/src/vnet/vxlan-gbp/decap.c index 7dc8d250f10..c520e25dcf2 100644 --- a/src/vnet/vxlan-gbp/decap.c +++ b/src/vnet/vxlan-gbp/decap.c @@ -16,7 +16,7 @@ */ #include <vlib/vlib.h> -#include <vnet/pg/pg.h> + #include <vnet/vxlan-gbp/vxlan_gbp.h> typedef struct @@ -309,7 +309,13 @@ vxlan_gbp_input (vlib_main_t * vm, else { error0 = VXLAN_GBP_ERROR_NO_SUCH_TUNNEL; - next0 = VXLAN_GBP_INPUT_NEXT_NO_TUNNEL; + next0 = VXLAN_GBP_INPUT_NEXT_PUNT; + if (is_ip4) + b0->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP4]; + else + b0->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP6]; } b0->error = node->errors[error0]; } @@ -342,7 +348,13 @@ vxlan_gbp_input (vlib_main_t * vm, else { error1 = VXLAN_GBP_ERROR_NO_SUCH_TUNNEL; - next1 = VXLAN_GBP_INPUT_NEXT_NO_TUNNEL; + next1 = VXLAN_GBP_INPUT_NEXT_PUNT; + if (is_ip4) + b1->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP4]; + else + b1->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP6]; } b1->error = node->errors[error1]; } @@ -444,7 +456,13 @@ vxlan_gbp_input (vlib_main_t * vm, else { error0 = VXLAN_GBP_ERROR_NO_SUCH_TUNNEL; - next0 = VXLAN_GBP_INPUT_NEXT_NO_TUNNEL; + next0 = VXLAN_GBP_INPUT_NEXT_PUNT; + if (is_ip4) + b0->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP4]; + else + b0->punt_reason = + vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP6]; } b0->error = node->errors[error0]; } diff --git a/src/vnet/vxlan-gbp/vxlan_gbp.c b/src/vnet/vxlan-gbp/vxlan_gbp.c index db10f5448e4..e39c26fc5d1 100644 --- a/src/vnet/vxlan-gbp/vxlan_gbp.c +++ b/src/vnet/vxlan-gbp/vxlan_gbp.c @@ -28,7 +28,7 @@ * * VXLAN GBP provides the features of vxlan and carry group policy id. */ - +static vlib_punt_hdl_t punt_hdl; vxlan_gbp_main_t vxlan_gbp_main; @@ -1144,10 +1144,14 @@ clib_error_t * vxlan_gbp_init (vlib_main_t * vm) { vxlan_gbp_main_t *vxm = &vxlan_gbp_main; + clib_error_t *error; vxm->vnet_main = vnet_get_main (); vxm->vlib_main = vm; + if ((error = vlib_call_init_function (vm, punt_init))) + return (error); + /* initialize the ip6 hash */ clib_bihash_init_16_8 (&vxm->vxlan4_gbp_tunnel_by_key, "vxlan4-gbp", VXLAN_GBP_HASH_NUM_BUCKETS, @@ -1162,7 +1166,16 @@ vxlan_gbp_init (vlib_main_t * vm) fib_node_register_type (FIB_NODE_TYPE_VXLAN_GBP_TUNNEL, &vxlan_gbp_vft); - return 0; + punt_hdl = vlib_punt_client_register ("vxlan-gbp"); + + vlib_punt_reason_alloc (punt_hdl, + "VXLAN-GBP-no-such-v4-tunnel", + &vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP4]); + vlib_punt_reason_alloc (punt_hdl, + "VXLAN-GBP-no-such-v6-tunnel", + &vxm->punt_no_such_tunnel[FIB_PROTOCOL_IP6]); + + return (error); } VLIB_INIT_FUNCTION (vxlan_gbp_init); diff --git a/src/vnet/vxlan-gbp/vxlan_gbp.h b/src/vnet/vxlan-gbp/vxlan_gbp.h index 6dc62256a41..6580f38e119 100644 --- a/src/vnet/vxlan-gbp/vxlan_gbp.h +++ b/src/vnet/vxlan-gbp/vxlan_gbp.h @@ -132,7 +132,7 @@ typedef struct #define foreach_vxlan_gbp_input_next \ _(DROP, "error-drop") \ - _(NO_TUNNEL, "error-punt") \ + _(PUNT, "punt-dispatch") \ _(L2_INPUT, "l2-input") \ _(IP4_INPUT, "ip4-input") \ _(IP6_INPUT, "ip6-input") @@ -189,6 +189,11 @@ typedef struct /* Record used instances */ uword *instance_used; + + /** + * Punt reasons for no such tunnel + */ + vlib_punt_reason_t punt_no_such_tunnel[FIB_PROTOCOL_IP_MAX]; } vxlan_gbp_main_t; extern vxlan_gbp_main_t vxlan_gbp_main; diff --git a/test/test_punt.py b/test/test_punt.py index 74dc923365c..b190101fe82 100644 --- a/test/test_punt.py +++ b/test/test_punt.py @@ -23,6 +23,9 @@ from scapy.layers.inet6 import IPv6, ICMPv6DestUnreach import six from framework import VppTestCase, VppTestRunner +from vpp_ip import DpoProto +from vpp_ip_route import VppIpRoute, VppRoutePath + # Format MAC Address def get_mac_addr(bytes_addr): @@ -671,5 +674,178 @@ class TestIP6PuntSocket(TestPuntSocket): punts = self.vapi.punt_socket_dump(is_ip6=1) self.assertEqual(len(punts), 0) + +class TestPunt(VppTestCase): + """ Punt Test Case """ + + @classmethod + def setUpClass(cls): + super(TestPunt, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestPunt, cls).tearDownClass() + + def setUp(self): + super(TestPunt, self).setUp() + + self.create_pg_interfaces(range(4)) + + for i in self.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + i.config_ip6() + i.resolve_ndp() + + def tearDown(self): + for i in self.pg_interfaces: + i.unconfig_ip4() + i.unconfig_ip6() + i.ip6_disable() + i.admin_down() + super(TestPunt, self).tearDown() + + def test_punt(self): + """ Excpetion Path testing """ + + # + # Using the test CLI we will hook in a exception path to + # send ACL deny packets out of pg0 and pg1. + # the ACL is src,dst = 1.1.1.1,1.1.1.2 + # + ip_1_1_1_2 = VppIpRoute(self, "1.1.1.2", 32, + [VppRoutePath(self.pg3.remote_ip4, + self.pg3.sw_if_index)]) + ip_1_1_1_2.add_vpp_config() + ip_1_2 = VppIpRoute(self, "1::2", 128, + [VppRoutePath(self.pg3.remote_ip6, + self.pg3.sw_if_index, + proto=DpoProto.DPO_PROTO_IP6)], + is_ip6=1) + ip_1_2.add_vpp_config() + + p4 = (Ether(src=self.pg2.remote_mac, + dst=self.pg2.local_mac) / + IP(src="1.1.1.1", dst="1.1.1.2") / + UDP(sport=1234, dport=1234) / + Raw('\xa5' * 100)) + p6 = (Ether(src=self.pg2.remote_mac, + dst=self.pg2.local_mac) / + IPv6(src="1::1", dst="1::2") / + UDP(sport=1234, dport=1234) / + Raw('\xa5' * 100)) + self.send_and_expect(self.pg2, p4*1, self.pg3) + self.send_and_expect(self.pg2, p6*1, self.pg3) + + # + # apply the punting features + # + self.vapi.cli("test punt pg2") + + # + # pkts now dropped + # + self.send_and_assert_no_replies(self.pg2, p4*65) + self.send_and_assert_no_replies(self.pg2, p6*65) + + # + # Check state: + # 1 - node error counters + # 2 - per-reason counters + # 2, 3 are the index of the assigned punt reason + # + stats = self.statistics.get_counter( + "/err/punt-dispatch/No registrations") + self.assertEqual(stats, 130) + + stats = self.statistics.get_counter("/net/punt") + self.assertEqual(stats[0][2]['packets'], 65) + self.assertEqual(stats[0][3]['packets'], 65) + + # + # use the test CLI to test a client that punts exception + # packets out of pg0 + # + self.vapi.cli("test punt pg0 %s" % self.pg0.remote_ip4) + self.vapi.cli("test punt pg0 %s" % self.pg0.remote_ip6) + + rx4s = self.send_and_expect(self.pg2, p4*65, self.pg0) + rx6s = self.send_and_expect(self.pg2, p6*65, self.pg0) + + # + # check the packets come out IP unmodified but destined to pg0 host + # + for rx in rx4s: + self.assertEqual(rx[Ether].dst, self.pg0.remote_mac) + self.assertEqual(rx[Ether].src, self.pg0.local_mac) + self.assertEqual(p4[IP].dst, rx[IP].dst) + self.assertEqual(p4[IP].ttl, rx[IP].ttl) + for rx in rx6s: + self.assertEqual(rx[Ether].dst, self.pg0.remote_mac) + self.assertEqual(rx[Ether].src, self.pg0.local_mac) + self.assertEqual(p6[IPv6].dst, rx[IPv6].dst) + self.assertEqual(p6[IPv6].hlim, rx[IPv6].hlim) + + stats = self.statistics.get_counter("/net/punt") + self.assertEqual(stats[0][2]['packets'], 2*65) + self.assertEqual(stats[0][3]['packets'], 2*65) + + # + # add another registration for the same reason to send packets + # out of pg1 + # + self.vapi.cli("test punt pg1 %s" % self.pg1.remote_ip4) + self.vapi.cli("test punt pg1 %s" % self.pg1.remote_ip6) + + self.vapi.cli("clear trace") + self.pg2.add_stream(p4 * 65) + self.pg_enable_capture(self.pg_interfaces) + self.pg_start() + + rxd = self.pg0.get_capture(65) + for rx in rxd: + self.assertEqual(rx[Ether].dst, self.pg0.remote_mac) + self.assertEqual(rx[Ether].src, self.pg0.local_mac) + self.assertEqual(p4[IP].dst, rx[IP].dst) + self.assertEqual(p4[IP].ttl, rx[IP].ttl) + rxd = self.pg1.get_capture(65) + for rx in rxd: + self.assertEqual(rx[Ether].dst, self.pg1.remote_mac) + self.assertEqual(rx[Ether].src, self.pg1.local_mac) + self.assertEqual(p4[IP].dst, rx[IP].dst) + self.assertEqual(p4[IP].ttl, rx[IP].ttl) + + self.vapi.cli("clear trace") + self.pg2.add_stream(p6 * 65) + self.pg_enable_capture(self.pg_interfaces) + self.pg_start() + + rxd = self.pg0.get_capture(65) + for rx in rxd: + self.assertEqual(rx[Ether].dst, self.pg0.remote_mac) + self.assertEqual(rx[Ether].src, self.pg0.local_mac) + self.assertEqual(p6[IPv6].dst, rx[IPv6].dst) + self.assertEqual(p6[IPv6].hlim, rx[IPv6].hlim) + rxd = self.pg1.get_capture(65) + for rx in rxd: + self.assertEqual(rx[Ether].dst, self.pg1.remote_mac) + self.assertEqual(rx[Ether].src, self.pg1.local_mac) + self.assertEqual(p6[IPv6].dst, rx[IPv6].dst) + self.assertEqual(p6[IPv6].hlim, rx[IPv6].hlim) + + stats = self.statistics.get_counter("/net/punt") + self.assertEqual(stats[0][2]['packets'], 3*65) + self.assertEqual(stats[0][3]['packets'], 3*65) + + self.logger.info(self.vapi.cli("show vlib graph punt-dispatch")) + self.logger.info(self.vapi.cli("show punt client")) + self.logger.info(self.vapi.cli("show punt reason")) + self.logger.info(self.vapi.cli("show punt stats")) + self.logger.info(self.vapi.cli("show punt db")) + + self.vapi.cli("test punt clear") + + if __name__ == '__main__': unittest.main(testRunner=VppTestRunner) |