Fix: bug prevented IPsec ipv4 SPDs to show correctly - vpp

diff options

author	Guillaume Solignac <gsoligna@cisco.com>	2019-05-20 15:58:46 +0200
committer	Neale Ranns <nranns@cisco.com>	2019-06-04 15:20:56 +0000
commit	5f08ab6493e1420d84c03d0b62431ac3a6de4ce9 (patch)
tree	dc20925d665ec8710761c0ce2f122a4413f5b8db
parent	c602b384ac022f70690a3a7c711149f7cb63ad12 (diff)

Fix: bug prevented IPsec ipv4 SPDs to show correctly

Because of the initialisation of the end of the range, the command show ipsec spd on an ipv4 SPD didn't work correctly. Change-Id: I3582382197bb6edef4fb077aac1e927ef4581cbf Signed-off-by: Guillaume Solignac <gsoligna@cisco.com>

Diffstat

-rw-r--r--

src/vnet/ipsec/ipsec_format.c

1 files changed, 9 insertions, 4 deletions

/* * Copyright (c) 2019 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 * Value 0 is reserved for invalid index. */ static vlib_punt_reason_t punt_reason_last = 1; /** * 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; /** * clients interested/listening to this reason */ u32 pd_users; /** * function to invoke if a client becomes interested in the code. */ punt_interested_listener_t pd_fn; /** * Data to pass to the callback */ void *pd_data; /** * Flags associated to the reason */ u32 flags; /** * Formatting function for flags; */ format_function_t *flags_format; } 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); format_function_t *flags_format = punt_reason_data[pr].flags_format; u32 flags = punt_reason_data[pr].flags; if (flags_format) return (format (s, "[%d] %v flags: %U", pr, punt_reason_data[pr].pd_name, flags_format, flags)); else 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; if (0 == punt_reason_data[reason].pd_users++ && NULL != punt_reason_data[reason].pd_fn) punt_reason_data[reason].pd_fn (VLIB_ENABLE, punt_reason_data[reason].pd_data); 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) { if (0 == --punt_reason_data[reason].pd_users && NULL != punt_reason_data[reason].pd_fn) punt_reason_data[reason].pd_fn (VLIB_DISABLE, punt_reason_data[reason].pd_data); 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_validate (vlib_punt_reason_t reason) { if (reason < punt_reason_last) return (0); return (-1); } u32 vlib_punt_reason_get_flags (vlib_punt_reason_t pr) { return pr < punt_reason_last ? punt_reason_data[pr].flags : 0; } int vlib_punt_reason_alloc (vlib_punt_hdl_t client, const char *reason_name, punt_interested_listener_t fn, void *data, vlib_punt_reason_t *reason, u32 flags, format_function_t *flags_format) { 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; punt_reason_data[new].pd_fn = fn; punt_reason_data[new].pd_data = data; punt_reason_data[new].flags = flags; punt_reason_data[new].flags_format = flags_format; 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); } void punt_reason_walk (punt_reason_walk_cb_t cb, void *ctx) { punt_reason_data_t *pd; for (pd = punt_reason_data + 1; pd < vec_end (punt_reason_data); pd++) { cb (pd->pd_reason, pd->pd_name, ctx); } } /* 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); } /* Parse punt reason */ uword unformat_punt_reason (unformat_input_t *input, va_list *args) { u32 *result = va_arg (*args, u32 *); u8 *s = 0; u8 found = 0; for (int i = 0; i < punt_reason_last - 1; i++) { punt_reason_data_t *pd = vec_elt_at_index (punt_reason_data, 1 + i); vec_reset_length (s); s = format (0, "%v%c", pd->pd_name, 0); if (unformat (input, (const char *) s)) { *result = pd->pd_reason; found = 1; break; } } vec_free (s); return found; } 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; if (pd->flags_format) s = format (s, "[%d] %v flags: %U from:[", pd->pd_reason, pd->pd_name, pd->flags_format, pd->flags); else 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: */


context:
space:
mode: