X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Flisp-cp%2Fcontrol.c;h=907e9a0f677cd63e8cb03212c86a605617c7dc17;hb=9d286a47017c3cb641e62586929ec4dbac04a2d4;hp=de048a4144a6d087816c0366a22c2496163bc634;hpb=7cd468a3d7dee7d6c92f69a0bb7061ae208ec727;p=vpp.git diff --git a/src/vnet/lisp-cp/control.c b/src/vnet/lisp-cp/control.c index de048a4144a..907e9a0f677 100644 --- a/src/vnet/lisp-cp/control.c +++ b/src/vnet/lisp-cp/control.c @@ -17,15 +17,34 @@ #include #include #include -#include #include #include +#include #include #include +#include +#include #include #include +#define MAX_VALUE_U24 0xffffff + +/* mapping timer control constants (in seconds) */ +#define TIME_UNTIL_REFETCH_OR_DELETE 20 +#define MAPPING_TIMEOUT (((m->ttl) * 60) - TIME_UNTIL_REFETCH_OR_DELETE) + +lisp_cp_main_t lisp_control_main; + +u8 *format_lisp_cp_input_trace (u8 * s, va_list * args); +static void *send_map_request_thread_fn (void *arg); + +typedef enum +{ + LISP_CP_INPUT_NEXT_DROP, + LISP_CP_INPUT_N_NEXT, +} lisp_cp_input_next_t; + typedef struct { u8 is_resend; @@ -34,17 +53,6 @@ typedef struct u8 smr_invoked; } map_request_args_t; -typedef struct -{ - u64 nonce; - u8 is_rloc_probe; - mapping_t *mappings; -} map_records_arg_t; - -static int -lisp_add_del_adjacency (lisp_cp_main_t * lcm, gid_address_t * local_eid, - gid_address_t * remote_eid, u8 is_add); - u8 vnet_lisp_get_map_request_mode (void) { @@ -257,7 +265,7 @@ dp_add_del_iface (lisp_cp_main_t * lcm, u32 vni, u8 is_l2, u8 is_add) } static void -dp_del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index) +dp_del_fwd_entry (lisp_cp_main_t * lcm, u32 dst_map_index) { vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a; fwd_entry_t *fe = 0; @@ -279,6 +287,7 @@ dp_del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index) if (fe->is_src_dst) gid_address_copy (&a->lcl_eid, &fe->leid); + vnet_lisp_gpe_del_fwd_counters (a, feip[0]); vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index); /* delete entry in fwd table */ @@ -427,48 +436,62 @@ static void dp_add_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index) { vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a; - mapping_t *src_map, *dst_map; - u32 sw_if_index; - uword *feip = 0, *dpid; + gid_address_t *rmt_eid, *lcl_eid; + mapping_t *lcl_map, *rmt_map; + u32 sw_if_index, **rmts, rmts_idx; + uword *feip = 0, *dpid, *rmts_stored_idxp = 0; fwd_entry_t *fe; u8 type, is_src_dst = 0; + int rv; memset (a, 0, sizeof (*a)); /* remove entry if it already exists */ feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index); if (feip) - dp_del_fwd_entry (lcm, src_map_index, dst_map_index); + dp_del_fwd_entry (lcm, dst_map_index); + /* + * Determine local mapping and eid + */ if (lcm->lisp_pitr) - src_map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index); + lcl_map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index); else - src_map = pool_elt_at_index (lcm->mapping_pool, src_map_index); - dst_map = pool_elt_at_index (lcm->mapping_pool, dst_map_index); - - /* insert data plane forwarding entry */ + lcl_map = pool_elt_at_index (lcm->mapping_pool, src_map_index); + lcl_eid = &lcl_map->eid; + + /* + * Determine remote mapping and eid + */ + rmt_map = pool_elt_at_index (lcm->mapping_pool, dst_map_index); + rmt_eid = &rmt_map->eid; + + /* + * Build and insert data plane forwarding entry + */ a->is_add = 1; if (MR_MODE_SRC_DST == lcm->map_request_mode) { - if (GID_ADDR_SRC_DST == gid_address_type (&dst_map->eid)) + if (GID_ADDR_SRC_DST == gid_address_type (rmt_eid)) { - gid_address_sd_to_flat (&a->rmt_eid, &dst_map->eid, - &gid_address_sd_dst (&dst_map->eid)); - gid_address_sd_to_flat (&a->lcl_eid, &dst_map->eid, - &gid_address_sd_src (&dst_map->eid)); + gid_address_sd_to_flat (&a->rmt_eid, rmt_eid, + &gid_address_sd_dst (rmt_eid)); + gid_address_sd_to_flat (&a->lcl_eid, rmt_eid, + &gid_address_sd_src (rmt_eid)); } else { - gid_address_copy (&a->rmt_eid, &dst_map->eid); - gid_address_copy (&a->lcl_eid, &src_map->eid); + gid_address_copy (&a->rmt_eid, rmt_eid); + gid_address_copy (&a->lcl_eid, lcl_eid); } is_src_dst = 1; } else - gid_address_copy (&a->rmt_eid, &dst_map->eid); + gid_address_copy (&a->rmt_eid, rmt_eid); a->vni = gid_address_vni (&a->rmt_eid); + a->is_src_dst = is_src_dst; /* get vrf or bd_index associated to vni */ type = gid_address_type (&a->rmt_eid); @@ -494,28 +517,92 @@ dp_add_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index) } /* find best locator pair that 1) verifies LISP policy 2) are connected */ - if (0 == get_locator_pairs (lcm, src_map, dst_map, &a->locator_pairs)) + rv = get_locator_pairs (lcm, lcl_map, rmt_map, &a->locator_pairs); + + /* Either rmt mapping is negative or we can't find underlay path. + * Try again with petr if configured */ + if (rv == 0 && (lcm->flags & LISP_FLAG_USE_PETR)) { - /* negative entry */ - a->is_negative = 1; - a->action = dst_map->action; + rmt_map = lisp_get_petr_mapping (lcm); + rv = get_locator_pairs (lcm, lcl_map, rmt_map, &a->locator_pairs); } - /* TODO remove */ - u8 ipver = ip_prefix_version (&gid_address_ippref (&a->rmt_eid)); - a->decap_next_index = (ipver == IP4) ? - LISP_GPE_INPUT_NEXT_IP4_INPUT : LISP_GPE_INPUT_NEXT_IP6_INPUT; + /* negative entry */ + if (rv == 0) + { + a->is_negative = 1; + a->action = rmt_map->action; + } - vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index); + rv = vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index); + if (rv) + { + if (a->locator_pairs) + vec_free (a->locator_pairs); + return; + } - /* add tunnel to fwd entry table XXX check return value from DP insertion */ + /* add tunnel to fwd entry table */ pool_get (lcm->fwd_entry_pool, fe); + vnet_lisp_gpe_add_fwd_counters (a, fe - lcm->fwd_entry_pool); + fe->locator_pairs = a->locator_pairs; gid_address_copy (&fe->reid, &a->rmt_eid); - gid_address_copy (&fe->leid, &src_map->eid); + + if (is_src_dst) + gid_address_copy (&fe->leid, &a->lcl_eid); + else + gid_address_copy (&fe->leid, lcl_eid); + fe->is_src_dst = is_src_dst; hash_set (lcm->fwd_entry_by_mapping_index, dst_map_index, fe - lcm->fwd_entry_pool); + + /* Add rmt mapping to the vector of adjacent mappings to lcl mapping */ + rmts_stored_idxp = + hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, src_map_index); + if (!rmts_stored_idxp) + { + pool_get (lcm->lcl_to_rmt_adjacencies, rmts); + memset (rmts, 0, sizeof (*rmts)); + rmts_idx = rmts - lcm->lcl_to_rmt_adjacencies; + hash_set (lcm->lcl_to_rmt_adjs_by_lcl_idx, src_map_index, rmts_idx); + } + else + { + rmts_idx = (u32) (*rmts_stored_idxp); + rmts = pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idx); + } + vec_add1 (rmts[0], dst_map_index); +} + +typedef struct +{ + u32 si; + u32 di; +} fwd_entry_mt_arg_t; + +static void * +dp_add_fwd_entry_thread_fn (void *arg) +{ + fwd_entry_mt_arg_t *a = arg; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + dp_add_fwd_entry (lcm, a->si, a->di); + return 0; +} + +static int +dp_add_fwd_entry_from_mt (u32 si, u32 di) +{ + fwd_entry_mt_arg_t a; + + memset (&a, 0, sizeof (a)); + a.si = si; + a.di = di; + + vl_api_rpc_call_main_thread (dp_add_fwd_entry_thread_fn, + (u8 *) & a, sizeof (a)); + return 0; } /** @@ -548,58 +635,6 @@ vnet_lisp_adjacencies_get_by_vni (u32 vni) return adjs; } -static clib_error_t * -lisp_show_adjacencies_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - lisp_adjacency_t *adjs, *adj; - vlib_cli_output (vm, "%s %40s\n", "leid", "reid"); - unformat_input_t _line_input, *line_input = &_line_input; - u32 vni = ~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, "vni %d", &vni)) - ; - else - { - vlib_cli_output (vm, "parse error: '%U'", - format_unformat_error, line_input); - return 0; - } - } - - if (~0 == vni) - { - vlib_cli_output (vm, "error: no vni specified!"); - return 0; - } - - adjs = vnet_lisp_adjacencies_get_by_vni (vni); - - vec_foreach (adj, adjs) - { - vlib_cli_output (vm, "%U %40U\n", format_gid_address, &adj->leid, - format_gid_address, &adj->reid); - } - vec_free (adjs); - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_adjacencies_command) = { - .path = "show lisp adjacencies", - .short_help = "show lisp adjacencies", - .function = lisp_show_adjacencies_command_fn, -}; -/* *INDENT-ON* */ - static lisp_msmr_t * get_map_server (ip_address_t * a) { @@ -657,6 +692,9 @@ vnet_lisp_add_del_map_server (ip_address_t * addr, u8 is_add) memset (ms, 0, sizeof (*ms)); ip_address_copy (&ms->address, addr); vec_add1 (lcm->map_servers, ms[0]); + + if (vec_len (lcm->map_servers) == 1) + lcm->do_map_server_election = 1; } else { @@ -665,6 +703,9 @@ vnet_lisp_add_del_map_server (ip_address_t * addr, u8 is_add) ms = vec_elt_at_index (lcm->map_servers, i); if (!ip_address_cmp (&ms->address, addr)) { + if (!ip_address_cmp (&ms->address, &lcm->active_map_server)) + lcm->do_map_server_election = 1; + vec_del1 (lcm->map_servers, i); break; } @@ -674,58 +715,6 @@ vnet_lisp_add_del_map_server (ip_address_t * addr, u8 is_add) return 0; } -static clib_error_t * -lisp_add_del_map_server_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - int rv = 0; - u8 is_add = 1, ip_set = 0; - ip_address_t ip; - unformat_input_t _line_input, *line_input = &_line_input; - - /* 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, "add")) - is_add = 1; - else if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "%U", unformat_ip_address, &ip)) - ip_set = 1; - else - { - vlib_cli_output (vm, "parse error: '%U'", - format_unformat_error, line_input); - return 0; - } - } - - if (!ip_set) - { - vlib_cli_output (vm, "map-server ip address not set!"); - return 0; - } - - rv = vnet_lisp_add_del_map_server (&ip, is_add); - if (!rv) - vlib_cli_output (vm, "failed to %s map-server!", - is_add ? "add" : "delete"); - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_add_del_map_server_command) = { - .path = "lisp map-server", - .short_help = "lisp map-server add|del ", - .function = lisp_add_del_map_server_command_fn, -}; -/* *INDENT-ON* */ - /** * Add/remove mapping to/from map-cache. Overwriting not allowed. */ @@ -735,9 +724,25 @@ vnet_lisp_map_cache_add_del (vnet_lisp_add_del_mapping_args_t * a, { lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); u32 mi, *map_indexp, map_index, i; + u32 **rmts = 0, *remote_idxp, rmts_itr, remote_idx; + uword *rmts_idxp; mapping_t *m, *old_map; u32 **eid_indexes; + if (gid_address_type (&a->eid) == GID_ADDR_NSH) + { + if (gid_address_vni (&a->eid) != 0) + { + clib_warning ("Supported only default VNI for NSH!"); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + if (gid_address_nsh_spi (&a->eid) > MAX_VALUE_U24) + { + clib_warning ("SPI is greater than 24bit!"); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + } + mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->eid); old_map = mi != ~0 ? pool_elt_at_index (lcm->mapping_pool, mi) : 0; if (a->is_add) @@ -808,6 +813,21 @@ vnet_lisp_map_cache_add_del (vnet_lisp_add_del_mapping_args_t * a, m = pool_elt_at_index (lcm->mapping_pool, mi); if (m->local) { + /* Remove adjacencies associated with the local mapping */ + rmts_idxp = hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, mi); + if (rmts_idxp) + { + rmts = + pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idxp[0]); + vec_foreach (remote_idxp, rmts[0]) + { + dp_del_fwd_entry (lcm, remote_idxp[0]); + } + vec_free (rmts[0]); + pool_put (lcm->lcl_to_rmt_adjacencies, rmts); + hash_unset (lcm->lcl_to_rmt_adjs_by_lcl_idx, mi); + } + u32 k, *lm_indexp; for (k = 0; k < vec_len (lcm->local_mappings_indexes); k++) { @@ -817,6 +837,26 @@ vnet_lisp_map_cache_add_del (vnet_lisp_add_del_mapping_args_t * a, } vec_del1 (lcm->local_mappings_indexes, k); } + else + { + /* Remove remote (if present) from the vectors of lcl-to-rmts + * TODO: Address this in a more efficient way. + */ + /* *INDENT-OFF* */ + pool_foreach (rmts, lcm->lcl_to_rmt_adjacencies, + ({ + vec_foreach_index (rmts_itr, rmts[0]) + { + remote_idx = vec_elt (rmts[0], rmts_itr); + if (mi == remote_idx) + { + vec_del1 (rmts[0], rmts_itr); + break; + } + } + })); + /* *INDENT-ON* */ + } /* remove mapping from dictionary */ gid_dictionary_add_del (&lcm->mapping_index_by_gid, &a->eid, 0, 0); @@ -853,7 +893,7 @@ vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a, else if (GID_ADDR_MAC == type) dp_table = hash_get (lcm->bd_id_by_vni, vni); - if (!dp_table) + if (!dp_table && GID_ADDR_NSH != type) { clib_warning ("vni %d not associated to a %s!", vni, GID_ADDR_IP_PREFIX == type ? "vrf" : "bd"); @@ -864,109 +904,166 @@ vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a, return vnet_lisp_map_cache_add_del (a, map_index_result); } -static clib_error_t * -lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) +static void +add_l2_arp_bd (BVT (clib_bihash_kv) * kvp, void *arg) +{ + u32 **ht = arg; + u32 version = (u32) kvp->key[0]; + if (IP6 == version) + return; + + u32 bd = (u32) (kvp->key[0] >> 32); + hash_set (ht[0], bd, 0); +} + +u32 * +vnet_lisp_l2_arp_bds_get (void) { lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1; - gid_address_t eid; - gid_address_t *eids = 0; - clib_error_t *error = 0; - u8 *locator_set_name = 0; - u32 locator_set_index = 0, map_index = 0; - uword *p; - vnet_lisp_add_del_mapping_args_t _a, *a = &_a; - int rv = 0; - u32 vni = 0; - u8 *key = 0; - u32 key_id = 0; + u32 *bds = 0; - memset (&eid, 0, sizeof (eid)); - memset (a, 0, sizeof (*a)); + gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid, + add_l2_arp_bd, &bds); + return bds; +} - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; +static void +add_ndp_bd (BVT (clib_bihash_kv) * kvp, void *arg) +{ + u32 **ht = arg; + u32 version = (u32) kvp->key[0]; + if (IP4 == version) + return; - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "add")) - is_add = 1; - else if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "eid %U", unformat_gid_address, &eid)) - ; - else if (unformat (line_input, "vni %d", &vni)) - gid_address_vni (&eid) = vni; - else if (unformat (line_input, "secret-key %_%v%_", &key)) - ; - else if (unformat (line_input, "key-id %U", unformat_hmac_key_id, - &key_id)) - ; - else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name)) - { - p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name); - if (!p) - { - error = clib_error_return (0, "locator-set %s doesn't exist", - locator_set_name); - goto done; - } - locator_set_index = p[0]; - } - else - { - error = unformat_parse_error (line_input); - goto done; - } + u32 bd = (u32) (kvp->key[0] >> 32); + hash_set (ht[0], bd, 0); +} + +u32 * +vnet_lisp_ndp_bds_get (void) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + u32 *bds = 0; + + gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid, + add_ndp_bd, &bds); + return bds; +} + +typedef struct +{ + void *vector; + u32 bd; +} lisp_add_l2_arp_ndp_args_t; + +static void +add_l2_arp_entry (BVT (clib_bihash_kv) * kvp, void *arg) +{ + lisp_add_l2_arp_ndp_args_t *a = arg; + lisp_api_l2_arp_entry_t **vector = a->vector, e; + + u32 version = (u32) kvp->key[0]; + if (IP6 == version) + return; + + u32 bd = (u32) (kvp->key[0] >> 32); + + if (bd == a->bd) + { + mac_copy (e.mac, (void *) &kvp->value); + e.ip4 = (u32) kvp->key[1]; + vec_add1 (vector[0], e); } - /* XXX treat batch configuration */ +} + +lisp_api_l2_arp_entry_t * +vnet_lisp_l2_arp_entries_get_by_bd (u32 bd) +{ + lisp_api_l2_arp_entry_t *entries = 0; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lisp_add_l2_arp_ndp_args_t a; + + a.vector = &entries; + a.bd = bd; + + gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid, + add_l2_arp_entry, &a); + return entries; +} + +static void +add_ndp_entry (BVT (clib_bihash_kv) * kvp, void *arg) +{ + lisp_add_l2_arp_ndp_args_t *a = arg; + lisp_api_ndp_entry_t **vector = a->vector, e; - if (GID_ADDR_SRC_DST == gid_address_type (&eid)) + u32 version = (u32) kvp->key[0]; + if (IP4 == version) + return; + + u32 bd = (u32) (kvp->key[0] >> 32); + + if (bd == a->bd) { - error = - clib_error_return (0, "src/dst is not supported for local EIDs!"); - goto done; + mac_copy (e.mac, (void *) &kvp->value); + clib_memcpy (e.ip6, &kvp->key[1], 16); + vec_add1 (vector[0], e); } +} + +lisp_api_ndp_entry_t * +vnet_lisp_ndp_entries_get_by_bd (u32 bd) +{ + lisp_api_ndp_entry_t *entries = 0; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lisp_add_l2_arp_ndp_args_t a; - if (key && (0 == key_id)) + a.vector = &entries; + a.bd = bd; + + gid_dict_foreach_l2_arp_ndp_entry (&lcm->mapping_index_by_gid, + add_ndp_entry, &a); + return entries; +} + +int +vnet_lisp_add_del_l2_arp_ndp_entry (gid_address_t * key, u8 * mac, u8 is_add) +{ + if (vnet_lisp_enable_disable_status () == 0) { - vlib_cli_output (vm, "invalid key_id!"); - return 0; + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; } - gid_address_copy (&a->eid, &eid); - a->is_add = is_add; - a->locator_set_index = locator_set_index; - a->local = 1; - a->key = key; - a->key_id = key_id; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + int rc = 0; - rv = vnet_lisp_add_del_local_mapping (a, &map_index); - if (0 != rv) + u64 res = gid_dictionary_lookup (&lcm->mapping_index_by_gid, key); + if (is_add) { - error = clib_error_return (0, "failed to %s local mapping!", - is_add ? "add" : "delete"); + if (res != GID_LOOKUP_MISS_L2) + { + clib_warning ("Entry %U exists in DB!", format_gid_address, key); + return VNET_API_ERROR_ENTRY_ALREADY_EXISTS; + } + u64 val = mac_to_u64 (mac); + gid_dictionary_add_del (&lcm->mapping_index_by_gid, key, val, + 1 /* is_add */ ); + } + else + { + if (res == GID_LOOKUP_MISS_L2) + { + clib_warning ("ONE entry %U not found - cannot delete!", + format_gid_address, key); + return -1; + } + gid_dictionary_add_del (&lcm->mapping_index_by_gid, key, 0, + 0 /* is_add */ ); } -done: - vec_free (eids); - if (locator_set_name) - vec_free (locator_set_name); - gid_address_free (&a->eid); - vec_free (a->key); - return error; -} -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_add_del_local_eid_command) = { - .path = "lisp eid-table", - .short_help = "lisp eid-table add/del [vni ] eid " - "locator-set [key key-id sha1|sha256 ]", - .function = lisp_add_del_local_eid_command_fn, -}; -/* *INDENT-ON* */ + return rc; +} int vnet_lisp_eid_table_map (u32 vni, u32 dp_id, u8 is_l2, u8 is_add) @@ -977,7 +1074,7 @@ vnet_lisp_eid_table_map (u32 vni, u32 dp_id, u8 is_l2, u8 is_add) if (vnet_lisp_enable_disable_status () == 0) { clib_warning ("LISP is disabled!"); - return -1; + return VNET_API_ERROR_LISP_DISABLED; } dp_table_by_vni = is_l2 ? &lcm->bd_id_by_vni : &lcm->table_id_by_vni; @@ -1014,55 +1111,15 @@ vnet_lisp_eid_table_map (u32 vni, u32 dp_id, u8 is_l2, u8 is_add) "mapping!", vni, dp_id); return -1; } - hash_unset (dp_table_by_vni[0], vni); - hash_unset (vni_by_dp_table[0], dp_id); - /* remove dp iface */ dp_add_del_iface (lcm, vni, is_l2, 0); - } - return 0; - -} - -static clib_error_t * -lisp_eid_table_map_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u8 is_add = 1, is_l2 = 0; - u32 vni = 0, dp_id = 0; - unformat_input_t _line_input, *line_input = &_line_input; - - /* 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")) - is_add = 0; - else if (unformat (line_input, "vni %d", &vni)) - ; - else if (unformat (line_input, "vrf %d", &dp_id)) - ; - else if (unformat (line_input, "bd %d", &dp_id)) - is_l2 = 1; - else - { - return unformat_parse_error (line_input); - } + hash_unset (dp_table_by_vni[0], vni); + hash_unset (vni_by_dp_table[0], dp_id); } - vnet_lisp_eid_table_map (vni, dp_id, is_l2, is_add); return 0; -} -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_eid_table_map_command) = { - .path = "lisp eid-table map", - .short_help = "lisp eid-table map [del] vni vrf | bd ", - .function = lisp_eid_table_map_command_fn, -}; -/* *INDENT-ON* */ +} /* return 0 if the two locator sets are identical 1 otherwise */ static u8 @@ -1144,6 +1201,7 @@ remove_overlapping_sub_prefixes (lisp_cp_main_t * lcm, gid_address_t * eid, { gid_address_t *e; remove_mapping_args_t a; + memset (&a, 0, sizeof (a)); /* do this only in src/dst mode ... */ @@ -1163,8 +1221,15 @@ remove_overlapping_sub_prefixes (lisp_cp_main_t * lcm, gid_address_t * eid, vec_foreach (e, a.eids_to_be_deleted) { - lisp_add_del_adjacency (lcm, 0, e, 0 /* is_add */ ); - vnet_lisp_add_del_mapping (e, 0, 0, 0, 0, 0 /* is add */ , 0, 0); + vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args; + + memset (adj_args, 0, sizeof (adj_args[0])); + gid_address_copy (&adj_args->reid, e); + adj_args->is_add = 0; + if (vnet_lisp_add_del_adjacency (adj_args)) + clib_warning ("failed to del adjacency!"); + + vnet_lisp_del_mapping (e, NULL); } vec_free (a.eids_to_be_deleted); @@ -1176,29 +1241,39 @@ mapping_delete_timer (lisp_cp_main_t * lcm, u32 mi) timing_wheel_delete (&lcm->wheel, mi); } -/** - * Adds/removes/updates mapping. Does not program forwarding. - * - * @param eid end-host identifier - * @param rlocs vector of remote locators - * @param action action for negative map-reply - * @param is_add add mapping if non-zero, delete otherwise - * @param res_map_index the map-index that was created/updated/removed. It is - * set to ~0 if no action is taken. - * @param is_static used for distinguishing between statically learned - remote mappings and mappings obtained from MR - * @return return code - */ -int -vnet_lisp_add_del_mapping (gid_address_t * eid, locator_t * rlocs, u8 action, - u8 authoritative, u32 ttl, u8 is_add, u8 is_static, - u32 * res_map_index) +static int +is_local_ip (lisp_cp_main_t * lcm, ip_address_t * addr) +{ + fib_node_index_t fei; + fib_prefix_t prefix; + fib_entry_flag_t flags; + + ip_address_to_fib_prefix (addr, &prefix); + + fei = fib_table_lookup (0, &prefix); + flags = fib_entry_get_flags (fei); + return (FIB_ENTRY_FLAG_LOCAL & flags); +} + +/** + * Adds/updates mapping. Does not program forwarding. + * + * @param a parameters of the new mapping + * @param rlocs vector of remote locators + * @param res_map_index index of the newly created mapping + * @param locators_changed indicator if locators were updated in the mapping + * @return return code + */ +int +vnet_lisp_add_mapping (vnet_lisp_add_del_mapping_args_t * a, + locator_t * rlocs, + u32 * res_map_index, u8 * is_updated) { - vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args; vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args; lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); u32 mi, ls_index = 0, dst_map_index; mapping_t *old_map; + locator_t *loc; if (vnet_lisp_enable_disable_status () == 0) { @@ -1208,107 +1283,145 @@ vnet_lisp_add_del_mapping (gid_address_t * eid, locator_t * rlocs, u8 action, if (res_map_index) res_map_index[0] = ~0; + if (is_updated) + is_updated[0] = 0; - memset (m_args, 0, sizeof (m_args[0])); memset (ls_args, 0, sizeof (ls_args[0])); ls_args->locators = rlocs; - - mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid); + mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->eid); old_map = ((u32) ~ 0 != mi) ? pool_elt_at_index (lcm->mapping_pool, mi) : 0; - if (is_add) + /* check if none of the locators match localy configured address */ + vec_foreach (loc, rlocs) + { + ip_prefix_t *p = &gid_address_ippref (&loc->address); + if (is_local_ip (lcm, &ip_prefix_addr (p))) + { + clib_warning ("RLOC %U matches a local address!", + format_gid_address, &loc->address); + return VNET_API_ERROR_LISP_RLOC_LOCAL; + } + } + + /* overwrite: if mapping already exists, decide if locators should be + * updated and be done */ + if (old_map && gid_address_cmp (&old_map->eid, &a->eid) == 0) { - /* overwrite: if mapping already exists, decide if locators should be - * updated and be done */ - if (old_map && gid_address_cmp (&old_map->eid, eid) == 0) + if (!a->is_static && (old_map->is_static || old_map->local)) { - if (!is_static && (old_map->is_static || old_map->local)) - { - /* do not overwrite local or static remote mappings */ - clib_warning ("mapping %U rejected due to collision with local " - "or static remote mapping!", format_gid_address, - eid); - return 0; - } - - locator_set_t *old_ls; - - /* update mapping attributes */ - old_map->action = action; - old_map->authoritative = authoritative; - old_map->ttl = ttl; - - old_ls = pool_elt_at_index (lcm->locator_set_pool, - old_map->locator_set_index); - if (compare_locators (lcm, old_ls->locator_indices, - ls_args->locators)) - { - /* set locator-set index to overwrite */ - ls_args->is_add = 1; - ls_args->index = old_map->locator_set_index; - vnet_lisp_add_del_locator_set (ls_args, 0); - if (res_map_index) - res_map_index[0] = mi; - } + /* do not overwrite local or static remote mappings */ + clib_warning ("mapping %U rejected due to collision with local " + "or static remote mapping!", format_gid_address, + &a->eid); + return 0; } - /* new mapping */ - else - { - remove_overlapping_sub_prefixes (lcm, eid, 0 == ls_args->locators); - ls_args->is_add = 1; - ls_args->index = ~0; + locator_set_t *old_ls; - vnet_lisp_add_del_locator_set (ls_args, &ls_index); + /* update mapping attributes */ + old_map->action = a->action; + if (old_map->action != a->action && NULL != is_updated) + is_updated[0] = 1; - /* add mapping */ - gid_address_copy (&m_args->eid, eid); - m_args->is_add = 1; - m_args->action = action; - m_args->locator_set_index = ls_index; - m_args->is_static = is_static; - m_args->ttl = ttl; - vnet_lisp_map_cache_add_del (m_args, &dst_map_index); + old_map->authoritative = a->authoritative; + old_map->ttl = a->ttl; - if (res_map_index) - res_map_index[0] = dst_map_index; + old_ls = pool_elt_at_index (lcm->locator_set_pool, + old_map->locator_set_index); + if (compare_locators (lcm, old_ls->locator_indices, ls_args->locators)) + { + /* set locator-set index to overwrite */ + ls_args->is_add = 1; + ls_args->index = old_map->locator_set_index; + vnet_lisp_add_del_locator_set (ls_args, 0); + if (is_updated) + is_updated[0] = 1; } + if (res_map_index) + res_map_index[0] = mi; } + /* new mapping */ else { - if (old_map == 0 || gid_address_cmp (&old_map->eid, eid) != 0) - { - clib_warning ("cannot delete mapping for eid %U", - format_gid_address, eid); - return -1; - } - - m_args->is_add = 0; - gid_address_copy (&m_args->eid, eid); - m_args->locator_set_index = old_map->locator_set_index; + if (is_updated) + is_updated[0] = 1; + remove_overlapping_sub_prefixes (lcm, &a->eid, 0 == ls_args->locators); - /* delete mapping associated from map-cache */ - vnet_lisp_map_cache_add_del (m_args, 0); + ls_args->is_add = 1; + ls_args->index = ~0; - ls_args->is_add = 0; - ls_args->index = old_map->locator_set_index; - /* delete locator set */ - vnet_lisp_add_del_locator_set (ls_args, 0); + vnet_lisp_add_del_locator_set (ls_args, &ls_index); - /* delete timer associated to the mapping if any */ - if (old_map->timer_set) - mapping_delete_timer (lcm, mi); + /* add mapping */ + a->is_add = 1; + a->locator_set_index = ls_index; + vnet_lisp_map_cache_add_del (a, &dst_map_index); - /* return old mapping index */ if (res_map_index) - res_map_index[0] = mi; + res_map_index[0] = dst_map_index; } /* success */ return 0; } +/** + * Removes a mapping. Does not program forwarding. + * + * @param eid end-host indetifier + * @param res_map_index index of the removed mapping + * @return return code + */ +int +vnet_lisp_del_mapping (gid_address_t * eid, u32 * res_map_index) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args; + vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args; + mapping_t *old_map; + u32 mi; + + memset (ls_args, 0, sizeof (ls_args[0])); + memset (m_args, 0, sizeof (m_args[0])); + if (res_map_index) + res_map_index[0] = ~0; + + mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid); + old_map = ((u32) ~ 0 != mi) ? pool_elt_at_index (lcm->mapping_pool, mi) : 0; + + if (old_map == 0 || gid_address_cmp (&old_map->eid, eid) != 0) + { + clib_warning ("cannot delete mapping for eid %U", + format_gid_address, eid); + return -1; + } + + m_args->is_add = 0; + gid_address_copy (&m_args->eid, eid); + m_args->locator_set_index = old_map->locator_set_index; + + /* delete mapping associated from map-cache */ + vnet_lisp_map_cache_add_del (m_args, 0); + + ls_args->is_add = 0; + ls_args->index = old_map->locator_set_index; + + /* delete locator set */ + vnet_lisp_add_del_locator_set (ls_args, 0); + + /* delete timer associated to the mapping if any */ + if (old_map->timer_set) + mapping_delete_timer (lcm, mi); + + /* return old mapping index */ + if (res_map_index) + res_map_index[0] = mi; + + /* success */ + return 0; +} + int vnet_lisp_clear_all_remote_adjacencies (void) { @@ -1330,7 +1443,7 @@ vnet_lisp_clear_all_remote_adjacencies (void) mapping_t *map = pool_elt_at_index (lcm->mapping_pool, map_indexp[0]); if (!map->local) { - dp_del_fwd_entry (lcm, 0, map_indexp[0]); + dp_del_fwd_entry (lcm, map_indexp[0]); dm_args->is_add = 0; gid_address_copy (&dm_args->eid, &map->eid); @@ -1360,10 +1473,10 @@ cleanup: * Note that adjacencies are not stored, they only result in forwarding entries * being created. */ -static int -lisp_add_del_adjacency (lisp_cp_main_t * lcm, gid_address_t * local_eid, - gid_address_t * remote_eid, u8 is_add) +int +vnet_lisp_add_del_adjacency (vnet_lisp_add_del_adjacency_args_t * a) { + lisp_cp_main_t *lcm = &lisp_control_main; u32 local_mi, remote_mi = ~0; if (vnet_lisp_enable_disable_status () == 0) @@ -1373,30 +1486,41 @@ lisp_add_del_adjacency (lisp_cp_main_t * lcm, gid_address_t * local_eid, } remote_mi = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, - remote_eid, local_eid); + &a->reid, &a->leid); if (GID_LOOKUP_MISS == remote_mi) { clib_warning ("Remote eid %U not found. Cannot add adjacency!", - format_gid_address, remote_eid); + format_gid_address, &a->reid); return -1; } - if (is_add) + if (a->is_add) { - /* TODO 1) check if src/dst 2) once we have src/dst working, use it in - * delete*/ - /* check if source eid has an associated mapping. If pitr mode is on, * just use the pitr's mapping */ - local_mi = lcm->lisp_pitr ? lcm->pitr_map_index : - gid_dictionary_lookup (&lcm->mapping_index_by_gid, local_eid); - + if (lcm->lisp_pitr) + local_mi = lcm->pitr_map_index; + else + { + if (gid_address_type (&a->reid) == GID_ADDR_NSH) + { + if (lcm->nsh_map_index == ~0) + local_mi = GID_LOOKUP_MISS; + else + local_mi = lcm->nsh_map_index; + } + else + { + local_mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, + &a->leid); + } + } if (GID_LOOKUP_MISS == local_mi) { clib_warning ("Local eid %U not found. Cannot add adjacency!", - format_gid_address, local_eid); + format_gid_address, &a->leid); return -1; } @@ -1405,258 +1529,11 @@ lisp_add_del_adjacency (lisp_cp_main_t * lcm, gid_address_t * local_eid, dp_add_fwd_entry (lcm, local_mi, remote_mi); } else - dp_del_fwd_entry (lcm, 0, remote_mi); + dp_del_fwd_entry (lcm, remote_mi); return 0; } -int -vnet_lisp_add_del_adjacency (vnet_lisp_add_del_adjacency_args_t * a) -{ - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - return lisp_add_del_adjacency (lcm, &a->leid, &a->reid, a->is_add); -} - -/** - * Handler for add/del remote mapping CLI. - * - * @param vm vlib context - * @param input input from user - * @param cmd cmd - * @return pointer to clib error structure - */ -static clib_error_t * -lisp_add_del_remote_mapping_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - clib_error_t *error = 0; - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1, del_all = 0; - locator_t rloc, *rlocs = 0, *curr_rloc = 0; - gid_address_t eid; - u8 eid_set = 0; - u32 vni, action = ~0, p, w; - int rv; - - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; - - memset (&eid, 0, sizeof (eid)); - memset (&rloc, 0, sizeof (rloc)); - - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "del-all")) - del_all = 1; - else if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "add")) - ; - else if (unformat (line_input, "eid %U", unformat_gid_address, &eid)) - eid_set = 1; - else if (unformat (line_input, "vni %u", &vni)) - { - gid_address_vni (&eid) = vni; - } - else if (unformat (line_input, "p %d w %d", &p, &w)) - { - if (!curr_rloc) - { - clib_warning - ("No RLOC configured for setting priority/weight!"); - goto done; - } - curr_rloc->priority = p; - curr_rloc->weight = w; - } - else if (unformat (line_input, "rloc %U", unformat_ip_address, - &gid_address_ip (&rloc.address))) - { - /* since rloc is stored in ip prefix we need to set prefix length */ - ip_prefix_t *pref = &gid_address_ippref (&rloc.address); - - u8 version = gid_address_ip_version (&rloc.address); - ip_prefix_len (pref) = ip_address_max_len (version); - - vec_add1 (rlocs, rloc); - curr_rloc = &rlocs[vec_len (rlocs) - 1]; - } - else if (unformat (line_input, "action %U", - unformat_negative_mapping_action, &action)) - ; - else - { - clib_warning ("parse error"); - goto done; - } - } - - if (!eid_set) - { - clib_warning ("missing eid!"); - goto done; - } - - if (!del_all) - { - if (is_add && (~0 == action) && 0 == vec_len (rlocs)) - { - clib_warning ("no action set for negative map-reply!"); - goto done; - } - } - else - { - vnet_lisp_clear_all_remote_adjacencies (); - goto done; - } - - /* TODO build src/dst with seid */ - - /* if it's a delete, clean forwarding */ - if (!is_add) - { - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - rv = lisp_add_del_adjacency (lcm, 0, &eid, /* is_add */ 0); - if (rv) - { - goto done; - } - } - - /* add as static remote mapping, i.e., not authoritative and infinite - * ttl */ - rv = vnet_lisp_add_del_mapping (&eid, rlocs, action, 0, ~0, is_add, - 1 /* is_static */ , 0); - - if (rv) - clib_warning ("failed to %s remote mapping!", is_add ? "add" : "delete"); - -done: - vec_free (rlocs); - unformat_free (line_input); - return error; -} - -VLIB_CLI_COMMAND (lisp_add_del_remote_mapping_command) = -{ -.path = "lisp remote-mapping",.short_help = - "lisp remote-mapping add|del [del-all] vni " - "eid [action ] rloc p w " - "[rloc ... ]",.function = - lisp_add_del_remote_mapping_command_fn,}; - -/** - * Handler for add/del adjacency CLI. - */ -static clib_error_t * -lisp_add_del_adjacency_command_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - clib_error_t *error = 0; - unformat_input_t _line_input, *line_input = &_line_input; - vnet_lisp_add_del_adjacency_args_t _a, *a = &_a; - u8 is_add = 1; - ip_prefix_t *reid_ippref, *leid_ippref; - gid_address_t leid, reid; - u8 *dmac = gid_address_mac (&reid); - u8 *smac = gid_address_mac (&leid); - u8 reid_set = 0, leid_set = 0; - u32 vni; - int rv; - - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; - - memset (&reid, 0, sizeof (reid)); - memset (&leid, 0, sizeof (leid)); - - leid_ippref = &gid_address_ippref (&leid); - reid_ippref = &gid_address_ippref (&reid); - - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "add")) - ; - else if (unformat (line_input, "reid %U", - unformat_ip_prefix, reid_ippref)) - { - gid_address_type (&reid) = GID_ADDR_IP_PREFIX; - reid_set = 1; - } - else if (unformat (line_input, "reid %U", unformat_mac_address, dmac)) - { - gid_address_type (&reid) = GID_ADDR_MAC; - reid_set = 1; - } - else if (unformat (line_input, "vni %u", &vni)) - { - gid_address_vni (&leid) = vni; - gid_address_vni (&reid) = vni; - } - else if (unformat (line_input, "leid %U", - unformat_ip_prefix, leid_ippref)) - { - gid_address_type (&leid) = GID_ADDR_IP_PREFIX; - leid_set = 1; - } - else if (unformat (line_input, "leid %U", unformat_mac_address, smac)) - { - gid_address_type (&leid) = GID_ADDR_MAC; - leid_set = 1; - } - else - { - clib_warning ("parse error"); - goto done; - } - } - - if (!reid_set || !leid_set) - { - clib_warning ("missing remote or local eid!"); - goto done; - } - - if ((gid_address_type (&leid) != gid_address_type (&reid)) - || (gid_address_type (&reid) == GID_ADDR_IP_PREFIX - && ip_prefix_version (reid_ippref) - != ip_prefix_version (leid_ippref))) - { - clib_warning ("remote and local EIDs are of different types!"); - return error; - } - - memset (a, 0, sizeof (a[0])); - gid_address_copy (&a->leid, &leid); - gid_address_copy (&a->reid, &reid); - - a->is_add = is_add; - rv = vnet_lisp_add_del_adjacency (a); - - if (rv) - clib_warning ("failed to %s adjacency!", is_add ? "add" : "delete"); - -done: - unformat_free (line_input); - return error; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_add_del_adjacency_command) = { - .path = "lisp adjacency", - .short_help = "lisp adjacency add|del vni reid " - "leid ", - .function = lisp_add_del_adjacency_command_fn, -}; -/* *INDENT-ON* */ - int vnet_lisp_set_map_request_mode (u8 mode) { @@ -1678,106 +1555,57 @@ vnet_lisp_set_map_request_mode (u8 mode) return 0; } -static clib_error_t * -lisp_map_request_mode_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +int +vnet_lisp_nsh_set_locator_set (u8 * locator_set_name, u8 is_add) { - unformat_input_t _i, *i = &_i; - map_request_mode_t mr_mode = _MR_MODE_MAX; - - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, i)) - return 0; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main (); + u32 locator_set_index = ~0; + mapping_t *m; + uword *p; - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + if (vnet_lisp_enable_disable_status () == 0) { - if (unformat (i, "dst-only")) - mr_mode = MR_MODE_DST_ONLY; - else if (unformat (i, "src-dst")) - mr_mode = MR_MODE_SRC_DST; - else - { - clib_warning ("parse error '%U'", format_unformat_error, i); - goto done; - } + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; } - if (_MR_MODE_MAX == mr_mode) + if (is_add) { - clib_warning ("No LISP map request mode entered!"); - return 0; - } - - vnet_lisp_set_map_request_mode (mr_mode); -done: - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_map_request_mode_command) = { - .path = "lisp map-request mode", - .short_help = "lisp map-request mode dst-only|src-dst", - .function = lisp_map_request_mode_command_fn, -}; -/* *INDENT-ON* */ + if (lcm->nsh_map_index == (u32) ~ 0) + { + p = hash_get_mem (lcm->locator_set_index_by_name, locator_set_name); + if (!p) + { + clib_warning ("locator-set %v doesn't exist", locator_set_name); + return -1; + } + locator_set_index = p[0]; -static u8 * -format_lisp_map_request_mode (u8 * s, va_list * args) -{ - u32 mode = va_arg (*args, u32); + pool_get (lcm->mapping_pool, m); + memset (m, 0, sizeof *m); + m->locator_set_index = locator_set_index; + m->local = 1; + m->nsh_set = 1; + lcm->nsh_map_index = m - lcm->mapping_pool; - switch (mode) + if (~0 == vnet_lisp_gpe_add_nsh_iface (lgm)) + return -1; + } + } + else { - case 0: - return format (0, "dst-only"); - case 1: - return format (0, "src-dst"); + if (lcm->nsh_map_index != (u32) ~ 0) + { + /* remove NSH mapping */ + pool_put_index (lcm->mapping_pool, lcm->nsh_map_index); + lcm->nsh_map_index = ~0; + vnet_lisp_gpe_del_nsh_iface (lgm); + } } return 0; } -static clib_error_t * -lisp_show_map_request_mode_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - vlib_cli_output (vm, "map-request mode: %U", format_lisp_map_request_mode, - vnet_lisp_get_map_request_mode ()); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_map_request_mode_command) = { - .path = "show lisp map-request mode", - .short_help = "show lisp map-request mode", - .function = lisp_show_map_request_mode_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_show_map_resolvers_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - lisp_msmr_t *mr; - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - - vec_foreach (mr, lcm->map_resolvers) - { - vlib_cli_output (vm, "%U", format_ip_address, &mr->address); - } - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_map_resolvers_command) = { - .path = "show lisp map-resolvers", - .short_help = "show lisp map-resolvers", - .function = lisp_show_map_resolvers_command_fn, -}; -/* *INDENT-ON* */ - int vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add) { @@ -1805,6 +1633,7 @@ vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add) pool_get (lcm->mapping_pool, m); m->locator_set_index = locator_set_index; m->local = 1; + m->pitr_set = 1; lcm->pitr_map_index = m - lcm->mapping_pool; /* enable pitr mode */ @@ -1821,241 +1650,91 @@ vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add) return 0; } -static clib_error_t * -lisp_pitr_set_locator_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u8 locator_name_set = 0; - u8 *locator_set_name = 0; - u8 is_add = 1; - unformat_input_t _line_input, *line_input = &_line_input; - clib_error_t *error = 0; - int rv = 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, "ls %_%v%_", &locator_set_name)) - locator_name_set = 1; - else if (unformat (line_input, "disable")) - is_add = 0; - else - return clib_error_return (0, "parse error"); - } - - if (!locator_name_set) - { - clib_warning ("No locator set specified!"); - goto done; - } - rv = vnet_lisp_pitr_set_locator_set (locator_set_name, is_add); - if (0 != rv) - { - error = clib_error_return (0, "failed to %s pitr!", - is_add ? "add" : "delete"); - } - -done: - if (locator_set_name) - vec_free (locator_set_name); - return error; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_pitr_set_locator_set_command) = { - .path = "lisp pitr", - .short_help = "lisp pitr [disable] ls ", - .function = lisp_pitr_set_locator_set_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_show_pitr_command_fn (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd) +int +vnet_lisp_map_register_fallback_threshold_set (u32 value) { lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - mapping_t *m; - locator_set_t *ls; - u8 *tmp_str = 0; - - vlib_cli_output (vm, "%=20s%=16s", - "pitr", lcm->lisp_pitr ? "locator-set" : ""); - - if (!lcm->lisp_pitr) - { - vlib_cli_output (vm, "%=20s", "disable"); - return 0; - } - - if (~0 == lcm->pitr_map_index) - { - tmp_str = format (0, "N/A"); - } - else + if (0 == value) { - m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index); - if (~0 != m->locator_set_index) - { - ls = - pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index); - tmp_str = format (0, "%s", ls->name); - } - else - { - tmp_str = format (0, "N/A"); - } + return VNET_API_ERROR_INVALID_ARGUMENT; } - vec_add1 (tmp_str, 0); - - vlib_cli_output (vm, "%=20s%=16s", "enable", tmp_str); - - vec_free (tmp_str); + lcm->max_expired_map_registers = value; return 0; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_pitr_command) = { - .path = "show lisp pitr", - .short_help = "Show pitr", - .function = lisp_show_pitr_command_fn, -}; -/* *INDENT-ON* */ - -static u8 * -format_eid_entry (u8 * s, va_list * args) +u32 +vnet_lisp_map_register_fallback_threshold_get (void) { - vnet_main_t *vnm = va_arg (*args, vnet_main_t *); - lisp_cp_main_t *lcm = va_arg (*args, lisp_cp_main_t *); - mapping_t *mapit = va_arg (*args, mapping_t *); - locator_set_t *ls = va_arg (*args, locator_set_t *); - gid_address_t *gid = &mapit->eid; - u32 ttl = mapit->ttl; - u8 aut = mapit->authoritative; - u32 *loc_index; - u8 first_line = 1; - u8 *loc; - - u8 *type = ls->local ? format (0, "local(%s)", ls->name) - : format (0, "remote"); - - if (vec_len (ls->locator_indices) == 0) - { - s = format (s, "%-35U%-30s%-20u%-u", format_gid_address, gid, - type, ttl, aut); - } - else - { - vec_foreach (loc_index, ls->locator_indices) - { - locator_t *l = pool_elt_at_index (lcm->locator_pool, loc_index[0]); - if (l->local) - loc = format (0, "%U", format_vnet_sw_if_index_name, vnm, - l->sw_if_index); - else - loc = format (0, "%U", format_ip_address, - &gid_address_ip (&l->address)); - - if (first_line) - { - s = format (s, "%-35U%-20s%-30v%-20u%-u\n", format_gid_address, - gid, type, loc, ttl, aut); - first_line = 0; - } - else - s = format (s, "%55s%v\n", "", loc); - } - } - return s; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + return lcm->max_expired_map_registers; } -static clib_error_t * -lisp_show_eid_table_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +/** + * Configure Proxy-ETR + * + * @param ip PETR's IP address + * @param is_add Flag that indicates if this is an addition or removal + * + * return 0 on success + */ +int +vnet_lisp_use_petr (ip_address_t * ip, u8 is_add) { lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - mapping_t *mapit; - unformat_input_t _line_input, *line_input = &_line_input; - u32 mi; - gid_address_t eid; - u8 print_all = 1; - u8 filter = 0; + u32 ls_index = ~0; + mapping_t *m; + vnet_lisp_add_del_locator_set_args_t _ls_args, *ls_args = &_ls_args; + locator_t loc; - memset (&eid, 0, sizeof (eid)); + if (vnet_lisp_enable_disable_status () == 0) + { + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; + } - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + memset (ls_args, 0, sizeof (*ls_args)); - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + if (is_add) { - if (unformat (line_input, "eid %U", unformat_gid_address, &eid)) - print_all = 0; - else if (unformat (line_input, "local")) - filter = 1; - else if (unformat (line_input, "remote")) - filter = 2; - else - return clib_error_return (0, "parse error: '%U'", - format_unformat_error, line_input); - } + /* Create dummy petr locator-set */ + memset (&loc, 0, sizeof (loc)); + gid_address_from_ip (&loc.address, ip); + loc.priority = 1; + loc.state = loc.weight = 1; + loc.local = 0; - vlib_cli_output (vm, "%-35s%-20s%-30s%-20s%-s", - "EID", "type", "locators", "ttl", "autoritative"); + ls_args->is_add = 1; + ls_args->index = ~0; + vec_add1 (ls_args->locators, loc); + vnet_lisp_add_del_locator_set (ls_args, &ls_index); - if (print_all) - { - /* *INDENT-OFF* */ - pool_foreach (mapit, lcm->mapping_pool, - ({ - locator_set_t * ls = pool_elt_at_index (lcm->locator_set_pool, - mapit->locator_set_index); - if (filter && !((1 == filter && ls->local) || - (2 == filter && !ls->local))) - { - continue; - } - vlib_cli_output (vm, "%U", format_eid_entry, lcm->vnet_main, - lcm, mapit, ls); - })); - /* *INDENT-ON* */ + /* Add petr mapping */ + pool_get (lcm->mapping_pool, m); + m->locator_set_index = ls_index; + lcm->petr_map_index = m - lcm->mapping_pool; + + /* Enable use-petr */ + lcm->flags |= LISP_FLAG_USE_PETR; } else { - mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &eid); - if ((u32) ~ 0 == mi) - return 0; + m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index); - mapit = pool_elt_at_index (lcm->mapping_pool, mi); - locator_set_t *ls = pool_elt_at_index (lcm->locator_set_pool, - mapit->locator_set_index); + /* Remove petr locator */ + ls_args->is_add = 0; + ls_args->index = m->locator_set_index; + vnet_lisp_add_del_locator_set (ls_args, 0); - if (filter && !((1 == filter && ls->local) || - (2 == filter && !ls->local))) - { - return 0; - } + /* Remove petr mapping */ + pool_put_index (lcm->mapping_pool, lcm->petr_map_index); - vlib_cli_output (vm, "%U,", format_eid_entry, lcm->vnet_main, - lcm, mapit, ls); + /* Disable use-petr */ + lcm->flags &= ~LISP_FLAG_USE_PETR; } - return 0; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_cp_show_eid_table_command) = { - .path = "show lisp eid-table", - .short_help = "Shows EID table", - .function = lisp_show_eid_table_command_fn, -}; -/* *INDENT-ON* */ - /* cleans locator to locator-set data and removes locators not part of * any locator-set */ static void @@ -2108,6 +1787,7 @@ get_locator_set_index (vnet_lisp_add_del_locator_set_args_t * a, uword * p) /* find locator-set */ if (a->local) { + ASSERT (a->name); p = hash_get_mem (lcm->locator_set_index_by_name, a->name); } else @@ -2142,6 +1822,88 @@ is_locator_in_locator_set (lisp_cp_main_t * lcm, locator_set_t * ls, return 0; } +static void +update_adjacencies_by_map_index (lisp_cp_main_t * lcm, + u32 mapping_index, u8 remove_only) +{ + fwd_entry_t *fwd; + mapping_t *map; + uword *fei = 0, *rmts_idxp = 0; + u32 **rmts = 0, *remote_idxp = 0, *rmts_copy = 0; + vnet_lisp_add_del_adjacency_args_t _a, *a = &_a; + memset (a, 0, sizeof (*a)); + + map = pool_elt_at_index (lcm->mapping_pool, mapping_index); + + if (map->local) + { + rmts_idxp = hash_get (lcm->lcl_to_rmt_adjs_by_lcl_idx, mapping_index); + if (rmts_idxp) + { + rmts = + pool_elt_at_index (lcm->lcl_to_rmt_adjacencies, rmts_idxp[0]); + rmts_copy = vec_dup (rmts[0]); + + vec_foreach (remote_idxp, rmts_copy) + { + fei = hash_get (lcm->fwd_entry_by_mapping_index, remote_idxp[0]); + if (!fei) + continue; + + fwd = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]); + a->is_add = 0; + gid_address_copy (&a->leid, &fwd->leid); + gid_address_copy (&a->reid, &fwd->reid); + vnet_lisp_add_del_adjacency (a); + + if (!remove_only) + { + a->is_add = 1; + vnet_lisp_add_del_adjacency (a); + } + } + vec_free (rmts_copy); + } + } + else + { + fei = hash_get (lcm->fwd_entry_by_mapping_index, mapping_index); + if (!fei) + return; + + fwd = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]); + a->is_add = 0; + gid_address_copy (&a->leid, &fwd->leid); + gid_address_copy (&a->reid, &fwd->reid); + vnet_lisp_add_del_adjacency (a); + + if (!remove_only) + { + a->is_add = 1; + vnet_lisp_add_del_adjacency (a); + } + } +} + +static void +update_fwd_entries_by_locator_set (lisp_cp_main_t * lcm, + u32 ls_index, u8 remove_only) +{ + u32 i, *map_indexp; + u32 **eid_indexes; + + if (vec_len (lcm->locator_set_to_eids) <= ls_index) + return; + + eid_indexes = vec_elt_at_index (lcm->locator_set_to_eids, ls_index); + + for (i = 0; i < vec_len (eid_indexes[0]); i++) + { + map_indexp = vec_elt_at_index (eid_indexes[0], i); + update_adjacencies_by_map_index (lcm, map_indexp[0], remove_only); + } +} + static inline void remove_locator_from_locator_set (locator_set_t * ls, u32 * locit, u32 ls_index, u32 loc_id) @@ -2224,24 +1986,38 @@ vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a, else { ls_index = p[0]; + u8 removed; - itloc = a->locators; - loc_id = 0; - vec_foreach (locit, ls->locator_indices) + vec_foreach (itloc, a->locators) { - loc = pool_elt_at_index (lcm->locator_pool, locit[0]); + removed = 0; + loc_id = 0; + vec_foreach (locit, ls->locator_indices) + { + loc = pool_elt_at_index (lcm->locator_pool, locit[0]); - if (loc->local && loc->sw_if_index == itloc->sw_if_index) - { - remove_locator_from_locator_set (ls, locit, ls_index, loc_id); - } - if (0 == loc->local && - !gid_address_cmp (&loc->address, &itloc->address)) - { - remove_locator_from_locator_set (ls, locit, ls_index, loc_id); - } + if (loc->local && loc->sw_if_index == itloc->sw_if_index) + { + removed = 1; + remove_locator_from_locator_set (ls, locit, ls_index, loc_id); + } + if (0 == loc->local && + !gid_address_cmp (&loc->address, &itloc->address)) + { + removed = 1; + remove_locator_from_locator_set (ls, locit, ls_index, loc_id); + } + + if (removed) + { + /* update fwd entries using this locator in DP */ + update_fwd_entries_by_locator_set (lcm, ls_index, + vec_len (ls->locator_indices) + == 0); + } - loc_id++; + loc_id++; + } } } @@ -2403,485 +2179,67 @@ vnet_lisp_map_register_enable_disable (u8 is_enable) lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); lcm->map_registering = is_enable; - return 0; -} - -clib_error_t * -vnet_lisp_enable_disable (u8 is_enable) -{ - u32 vni, dp_table; - clib_error_t *error = 0; - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a; - - a->is_en = is_enable; - error = vnet_lisp_gpe_enable_disable (a); - if (error) - { - return clib_error_return (0, "failed to %s data-plane!", - a->is_en ? "enable" : "disable"); - } - - if (is_enable) - { - /* enable all l2 and l3 ifaces */ - - /* *INDENT-OFF* */ - hash_foreach(vni, dp_table, lcm->table_id_by_vni, ({ - dp_add_del_iface(lcm, vni, 0, 1); - })); - hash_foreach(vni, dp_table, lcm->bd_id_by_vni, ({ - dp_add_del_iface(lcm, vni, /* is_l2 */ 1, 1); - })); - /* *INDENT-ON* */ - } - else - { - /* clear interface table */ - hash_free (lcm->fwd_entry_by_mapping_index); - pool_free (lcm->fwd_entry_pool); - } - - /* update global flag */ - lcm->is_enabled = is_enable; - - return 0; -} - -static clib_error_t * -lisp_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_enabled = 0; - u8 is_set = 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, "enable")) - { - is_set = 1; - is_enabled = 1; - } - else if (unformat (line_input, "disable")) - is_set = 1; - else - { - return clib_error_return (0, "parse error: '%U'", - format_unformat_error, line_input); - } - } - - if (!is_set) - return clib_error_return (0, "state not set"); - - vnet_lisp_enable_disable (is_enabled); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_cp_enable_disable_command) = { - .path = "lisp", - .short_help = "lisp [enable|disable]", - .function = lisp_enable_disable_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_map_register_enable_disable_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_enabled = 0; - u8 is_set = 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, "enable")) - { - is_set = 1; - is_enabled = 1; - } - else if (unformat (line_input, "disable")) - is_set = 1; - else - { - vlib_cli_output (vm, "parse error: '%U'", format_unformat_error, - line_input); - return 0; - } - } - - if (!is_set) - { - vlib_cli_output (vm, "state not set!"); - return 0; - } - - vnet_lisp_map_register_enable_disable (is_enabled); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_map_register_enable_disable_command) = { - .path = "lisp map-register", - .short_help = "lisp map-register [enable|disable]", - .function = lisp_map_register_enable_disable_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_rloc_probe_enable_disable_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_enabled = 0; - u8 is_set = 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, "enable")) - { - is_set = 1; - is_enabled = 1; - } - else if (unformat (line_input, "disable")) - is_set = 1; - else - { - vlib_cli_output (vm, "parse error: '%U'", format_unformat_error, - line_input); - return 0; - } - } - - if (!is_set) - { - vlib_cli_output (vm, "state not set!"); - return 0; - } - - vnet_lisp_rloc_probe_enable_disable (is_enabled); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_rloc_probe_enable_disable_command) = { - .path = "lisp rloc-probe", - .short_help = "lisp rloc-probe [enable|disable]", - .function = lisp_rloc_probe_enable_disable_command_fn, -}; -/* *INDENT-ON* */ - -u8 -vnet_lisp_enable_disable_status (void) -{ - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - return lcm->is_enabled; -} - -static u8 * -format_lisp_status (u8 * s, va_list * args) -{ - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - return format (s, "%s", lcm->is_enabled ? "enabled" : "disabled"); -} - -static clib_error_t * -lisp_show_status_command_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - u8 *msg = 0; - msg = format (msg, "feature: %U\ngpe: %U\n", - format_lisp_status, format_vnet_lisp_gpe_status); - vlib_cli_output (vm, "%v", msg); - vec_free (msg); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_status_command) = { - .path = "show lisp status", - .short_help = "show lisp status", - .function = lisp_show_status_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_show_eid_table_map_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - hash_pair_t *p; - unformat_input_t _line_input, *line_input = &_line_input; - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - uword *vni_table = 0; - u8 is_l2 = 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, "l2")) - { - vni_table = lcm->bd_id_by_vni; - is_l2 = 1; - } - else if (unformat (line_input, "l3")) - { - vni_table = lcm->table_id_by_vni; - is_l2 = 0; - } - else - return clib_error_return (0, "parse error: '%U'", - format_unformat_error, line_input); - } - - if (!vni_table) - { - vlib_cli_output (vm, "Error: expected l2|l3 param!\n"); - return 0; - } - - vlib_cli_output (vm, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF"); - - /* *INDENT-OFF* */ - hash_foreach_pair (p, vni_table, - ({ - vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]); - })); - /* *INDENT-ON* */ - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_eid_table_map_command) = { - .path = "show lisp eid-table map", - .short_help = "show lisp eid-table l2|l3", - .function = lisp_show_eid_table_map_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_add_del_locator_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - lisp_gpe_main_t *lgm = &lisp_gpe_main; - vnet_main_t *vnm = lgm->vnet_main; - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1; - clib_error_t *error = 0; - u8 *locator_set_name = 0; - locator_t locator, *locators = 0; - vnet_lisp_add_del_locator_set_args_t _a, *a = &_a; - u32 ls_index = 0; - int rv = 0; - - memset (&locator, 0, sizeof (locator)); - memset (a, 0, sizeof (a[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, "add %_%v%_", &locator_set_name)) - is_add = 1; - else if (unformat (line_input, "del %_%v%_", &locator_set_name)) - is_add = 0; - else if (unformat (line_input, "iface %U p %d w %d", - unformat_vnet_sw_interface, vnm, - &locator.sw_if_index, &locator.priority, - &locator.weight)) - { - locator.local = 1; - vec_add1 (locators, locator); - } - else - { - error = unformat_parse_error (line_input); - goto done; - } - } - - a->name = locator_set_name; - a->locators = locators; - a->is_add = is_add; - a->local = 1; - - rv = vnet_lisp_add_del_locator_set (a, &ls_index); - if (0 != rv) - { - error = clib_error_return (0, "failed to %s locator-set!", - is_add ? "add" : "delete"); - } - -done: - vec_free (locators); - if (locator_set_name) - vec_free (locator_set_name); - return error; + return 0; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = { - .path = "lisp locator-set", - .short_help = "lisp locator-set add/del [iface " - "p w ]", - .function = lisp_add_del_locator_set_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_add_del_locator_in_set_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +clib_error_t * +vnet_lisp_enable_disable (u8 is_enable) { - lisp_gpe_main_t *lgm = &lisp_gpe_main; - vnet_main_t *vnm = lgm->vnet_main; - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1; + u32 vni, dp_table, **rmts; clib_error_t *error = 0; - u8 *locator_set_name = 0; - u8 locator_set_name_set = 0; - locator_t locator, *locators = 0; - vnet_lisp_add_del_locator_set_args_t _a, *a = &_a; - u32 ls_index = 0; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a; - memset (&locator, 0, sizeof (locator)); - memset (a, 0, sizeof (a[0])); + a->is_en = is_enable; + error = vnet_lisp_gpe_enable_disable (a); + if (error) + { + return clib_error_return (0, "failed to %s data-plane!", + a->is_en ? "enable" : "disable"); + } - /* Get a line of input. */ - if (!unformat_user (input, unformat_line_input, line_input)) - return 0; + if (is_enable) + { + /* enable all l2 and l3 ifaces */ - while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (line_input, "add")) - is_add = 1; - else if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "locator-set %_%v%_", &locator_set_name)) - locator_set_name_set = 1; - else if (unformat (line_input, "iface %U p %d w %d", - unformat_vnet_sw_interface, vnm, - &locator.sw_if_index, &locator.priority, - &locator.weight)) - { - locator.local = 1; - vec_add1 (locators, locator); - } - else - { - error = unformat_parse_error (line_input); - goto done; - } + /* *INDENT-OFF* */ + hash_foreach(vni, dp_table, lcm->table_id_by_vni, ({ + dp_add_del_iface(lcm, vni, 0, 1); + })); + hash_foreach(vni, dp_table, lcm->bd_id_by_vni, ({ + dp_add_del_iface(lcm, vni, /* is_l2 */ 1, 1); + })); + /* *INDENT-ON* */ } - - if (!locator_set_name_set) + else { - error = clib_error_return (0, "locator_set name not set!"); - goto done; + /* clear interface table */ + hash_free (lcm->fwd_entry_by_mapping_index); + pool_free (lcm->fwd_entry_pool); + /* Clear state tracking rmt-lcl fwd entries */ + /* *INDENT-OFF* */ + pool_foreach(rmts, lcm->lcl_to_rmt_adjacencies, + { + vec_free(rmts[0]); + }); + /* *INDENT-ON* */ + hash_free (lcm->lcl_to_rmt_adjs_by_lcl_idx); + pool_free (lcm->lcl_to_rmt_adjacencies); } - a->name = locator_set_name; - a->locators = locators; - a->is_add = is_add; - a->local = 1; - - vnet_lisp_add_del_locator (a, 0, &ls_index); + /* update global flag */ + lcm->is_enabled = is_enable; -done: - vec_free (locators); - vec_free (locator_set_name); - return error; + return 0; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_cp_add_del_locator_in_set_command) = { - .path = "lisp locator", - .short_help = "lisp locator add/del locator-set iface " - "p w ", - .function = lisp_add_del_locator_in_set_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_cp_show_locator_sets_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +u8 +vnet_lisp_enable_disable_status (void) { - locator_set_t *lsit; - locator_t *loc; - u32 *locit; lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - - vlib_cli_output (vm, "%s%=16s%=16s%=16s", "Locator-set", "Locator", - "Priority", "Weight"); - - /* *INDENT-OFF* */ - pool_foreach (lsit, lcm->locator_set_pool, - ({ - u8 * msg = 0; - int next_line = 0; - if (lsit->local) - { - msg = format (msg, "%v", lsit->name); - } - else - { - msg = format (msg, "<%s-%d>", "remote", lsit - lcm->locator_set_pool); - } - vec_foreach (locit, lsit->locator_indices) - { - if (next_line) - { - msg = format (msg, "%16s", " "); - } - loc = pool_elt_at_index (lcm->locator_pool, locit[0]); - if (loc->local) - msg = format (msg, "%16d%16d%16d\n", loc->sw_if_index, loc->priority, - loc->weight); - else - msg = format (msg, "%16U%16d%16d\n", format_ip_address, - &gid_address_ip(&loc->address), loc->priority, - loc->weight); - next_line = 1; - } - vlib_cli_output (vm, "%v", msg); - vec_free (msg); - })); - /* *INDENT-ON* */ - return 0; + return lcm->is_enabled; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_cp_show_locator_sets_command) = { - .path = "show lisp locator-set", - .short_help = "Shows locator-sets", - .function = lisp_cp_show_locator_sets_command_fn, -}; -/* *INDENT-ON* */ - int vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a) { @@ -2930,63 +2288,20 @@ vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a) return 0; } -static clib_error_t * -lisp_add_del_map_resolver_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +int +vnet_lisp_map_register_set_ttl (u32 ttl) { - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1, addr_set = 0; - ip_address_t ip_addr; - clib_error_t *error = 0; - int rv = 0; - vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a; - - /* 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, "add")) - is_add = 1; - else if (unformat (line_input, "del")) - is_add = 0; - else if (unformat (line_input, "%U", unformat_ip_address, &ip_addr)) - addr_set = 1; - else - { - error = unformat_parse_error (line_input); - goto done; - } - } - - if (!addr_set) - { - error = clib_error_return (0, "Map-resolver address must be set!"); - goto done; - } - - a->is_add = is_add; - a->address = ip_addr; - rv = vnet_lisp_add_del_map_resolver (a); - if (0 != rv) - { - error = clib_error_return (0, "failed to %s map-resolver!", - is_add ? "add" : "delete"); - } - -done: - return error; + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lcm->map_register_ttl = ttl; + return 0; } -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_add_del_map_resolver_command) = { - .path = "lisp map-resolver", - .short_help = "lisp map-resolver add/del ", - .function = lisp_add_del_map_resolver_command_fn, -}; -/* *INDENT-ON* */ +u32 +vnet_lisp_map_register_get_ttl (void) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + return lcm->map_register_ttl; +} int vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a) @@ -3019,93 +2334,13 @@ vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a) return 0; } -static clib_error_t * -lisp_add_del_mreq_itr_rlocs_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - unformat_input_t _line_input, *line_input = &_line_input; - u8 is_add = 1; - u8 *locator_set_name = 0; - clib_error_t *error = 0; - int rv = 0; - vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a; - - /* 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")) - is_add = 0; - else if (unformat (line_input, "add %_%v%_", &locator_set_name)) - is_add = 1; - else - { - error = unformat_parse_error (line_input); - goto done; - } - } - - a->is_add = is_add; - a->locator_set_name = locator_set_name; - rv = vnet_lisp_add_del_mreq_itr_rlocs (a); - if (0 != rv) - { - error = clib_error_return (0, "failed to %s map-request itr-rlocs!", - is_add ? "add" : "delete"); - } - - vec_free (locator_set_name); - -done: - return error; - -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_add_del_map_request_command) = { - .path = "lisp map-request itr-rlocs", - .short_help = "lisp map-request itr-rlocs add/del ", - .function = lisp_add_del_mreq_itr_rlocs_command_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -lisp_show_mreq_itr_rlocs_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - locator_set_t *loc_set; - - vlib_cli_output (vm, "%=20s", "itr-rlocs"); - - if (~0 == lcm->mreq_itr_rlocs) - { - return 0; - } - - loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs); - - vlib_cli_output (vm, "%=20s", loc_set->name); - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (lisp_show_map_request_command) = { - .path = "show lisp map-request itr-rlocs", - .short_help = "Shows map-request itr-rlocs", - .function = lisp_show_mreq_itr_rlocs_command_fn, -}; -/* *INDENT-ON* */ - /* Statistics (not really errors) */ #define foreach_lisp_cp_lookup_error \ _(DROP, "drop") \ -_(MAP_REQUESTS_SENT, "map-request sent") +_(MAP_REQUESTS_SENT, "map-request sent") \ +_(ARP_REPLY_TX, "ARP replies sent") \ +_(NDP_NEIGHBOR_ADVERTISEMENT_TX, \ + "neighbor advertisement sent") static char *lisp_cp_lookup_error_strings[] = { #define _(sym,string) string, @@ -3124,6 +2359,7 @@ typedef enum typedef enum { LISP_CP_LOOKUP_NEXT_DROP, + LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX, LISP_CP_LOOKUP_N_NEXT, } lisp_cp_lookup_next_t; @@ -3252,7 +2488,7 @@ build_map_request (lisp_cp_main_t * lcm, gid_address_t * deid, /* push outer ip header */ pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc, - rloc); + rloc, 1); bi_res[0] = bi; @@ -3278,6 +2514,7 @@ build_encapsulated_map_request (lisp_cp_main_t * lcm, } b = vlib_get_buffer (vm, bi); + b->flags = 0; /* leave some space for the encap headers */ vlib_buffer_make_headroom (b, MAX_LISP_MSG_ENCAP_LEN); @@ -3306,7 +2543,7 @@ build_encapsulated_map_request (lisp_cp_main_t * lcm, /* push outer ip header */ pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc, - mr_ip); + mr_ip, 1); bi_res[0] = bi; @@ -3321,24 +2558,29 @@ reset_pending_mr_counters (pending_map_request_t * r) r->retries_num = 0; } -static int -elect_map_resolver (lisp_cp_main_t * lcm) -{ - lisp_msmr_t *mr; - - vec_foreach (mr, lcm->map_resolvers) - { - if (!mr->is_down) - { - ip_address_copy (&lcm->active_map_resolver, &mr->address); - lcm->do_map_resolver_election = 0; - return 1; - } - } - return 0; +#define foreach_msmr \ + _(server) \ + _(resolver) + +#define _(name) \ +static int \ +elect_map_ ## name (lisp_cp_main_t * lcm) \ +{ \ + lisp_msmr_t *mr; \ + vec_foreach (mr, lcm->map_ ## name ## s) \ + { \ + if (!mr->is_down) \ + { \ + ip_address_copy (&lcm->active_map_ ##name, &mr->address); \ + lcm->do_map_ ## name ## _election = 0; \ + return 1; \ + } \ + } \ + return 0; \ } - -static void +foreach_msmr +#undef _ + static void free_map_register_records (mapping_t * maps) { mapping_t *map; @@ -3461,32 +2703,80 @@ build_map_register (lisp_cp_main_t * lcm, ip_address_t * sloc, /* push outer ip header */ pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, LISP_CONTROL_PORT, sloc, - ms_ip); + ms_ip, 1); bi_res[0] = bi; return b; } -static int -get_egress_map_resolver_ip (lisp_cp_main_t * lcm, ip_address_t * ip) +#define _(name) \ +static int \ +get_egress_map_ ##name## _ip (lisp_cp_main_t * lcm, ip_address_t * ip) \ +{ \ + lisp_msmr_t *mr; \ + while (lcm->do_map_ ## name ## _election \ + | (0 == ip_fib_get_first_egress_ip_for_dst \ + (lcm, &lcm->active_map_ ##name, ip))) \ + { \ + if (0 == elect_map_ ## name (lcm)) \ + /* all map resolvers/servers are down */ \ + { \ + /* restart MR/MS checking by marking all of them up */ \ + vec_foreach (mr, lcm->map_ ## name ## s) mr->is_down = 0; \ + return -1; \ + } \ + } \ + return 0; \ +} + +foreach_msmr +#undef _ +/* CP output statistics */ +#define foreach_lisp_cp_output_error \ +_(MAP_REGISTERS_SENT, "map-registers sent") \ +_(MAP_REQUESTS_SENT, "map-requests sent") \ +_(RLOC_PROBES_SENT, "rloc-probes sent") +static char *lisp_cp_output_error_strings[] = { +#define _(sym,string) string, + foreach_lisp_cp_output_error +#undef _ +}; + +typedef enum +{ +#define _(sym,str) LISP_CP_OUTPUT_ERROR_##sym, + foreach_lisp_cp_output_error +#undef _ + LISP_CP_OUTPUT_N_ERROR, +} lisp_cp_output_error_t; + +static uword +lisp_cp_output (vlib_main_t * vm, vlib_node_runtime_t * node, + vlib_frame_t * from_frame) { - lisp_msmr_t *mr; - while (lcm->do_map_resolver_election - | (0 == ip_fib_get_first_egress_ip_for_dst (lcm, - &lcm->active_map_resolver, - ip))) - { - if (0 == elect_map_resolver (lcm)) - /* all map resolvers are down */ - { - /* restart MR checking by marking all of them up */ - vec_foreach (mr, lcm->map_resolvers) mr->is_down = 0; - return -1; - } - } return 0; } +/* dummy node used only for statistics */ +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (lisp_cp_output_node) = { + .function = lisp_cp_output, + .name = "lisp-cp-output", + .vector_size = sizeof (u32), + .format_trace = format_lisp_cp_input_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = LISP_CP_OUTPUT_N_ERROR, + .error_strings = lisp_cp_output_error_strings, + + .n_next_nodes = LISP_CP_INPUT_N_NEXT, + + .next_nodes = { + [LISP_CP_INPUT_NEXT_DROP] = "error-drop", + }, +}; +/* *INDENT-ON* */ + static int send_rloc_probe (lisp_cp_main_t * lcm, gid_address_t * deid, u32 local_locator_set_index, ip_address_t * sloc, @@ -3510,7 +2800,7 @@ send_rloc_probe (lisp_cp_main_t * lcm, gid_address_t * deid, vnet_buffer (b)->sw_if_index[VLIB_TX] = 0; - next_index = (ip_addr_version (&lcm->active_map_resolver) == IP4) ? + next_index = (ip_addr_version (rloc) == IP4) ? ip4_lookup_node.index : ip6_lookup_node.index; f = vlib_get_frame_to_node (lcm->vlib_main, next_index); @@ -3521,7 +2811,6 @@ send_rloc_probe (lisp_cp_main_t * lcm, gid_address_t * deid, f->n_vectors = 1; vlib_put_frame_to_node (lcm->vlib_main, next_index, f); - hash_set (lcm->map_register_messages_by_nonce, nonce, 0); return 0; } @@ -3532,7 +2821,7 @@ send_rloc_probes (lisp_cp_main_t * lcm) mapping_t *lm; fwd_entry_t *e; locator_pair_t *lp; - u32 si; + u32 si, rloc_probes_sent = 0; /* *INDENT-OFF* */ pool_foreach (e, lcm->fwd_entry_pool, @@ -3561,38 +2850,32 @@ send_rloc_probes (lisp_cp_main_t * lcm) /* get first remote locator */ send_rloc_probe (lcm, &e->reid, lm->locator_set_index, &lp->lcl_loc, &lp->rmt_loc); + rloc_probes_sent++; } }); /* *INDENT-ON* */ + vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index, + LISP_CP_OUTPUT_ERROR_RLOC_PROBES_SENT, + rloc_probes_sent); return 0; } static int send_map_register (lisp_cp_main_t * lcm, u8 want_map_notif) { - u32 bi; + pending_map_register_t *pmr; + u32 bi, map_registers_sent = 0; vlib_buffer_t *b; ip_address_t sloc; vlib_frame_t *f; u64 nonce = 0; u32 next_index, *to_next; - ip_address_t *ms = 0; - mapping_t *records, *r, *g; + mapping_t *records, *r, *group, *k; - // TODO: support multiple map servers and do election - if (0 == vec_len (lcm->map_servers)) + if (get_egress_map_server_ip (lcm, &sloc) < 0) return -1; - ms = &lcm->map_servers[0].address; - - if (0 == ip_fib_get_first_egress_ip_for_dst (lcm, ms, &sloc)) - { - clib_warning ("no eligible interface address found for %U!", - format_ip_address, &lcm->map_servers[0]); - return -1; - } - records = build_map_register_record_list (lcm); if (!records) return -1; @@ -3605,18 +2888,31 @@ send_map_register (lisp_cp_main_t * lcm, u8 want_map_notif) if (!key) continue; /* no secret key -> map-register cannot be sent */ - g = 0; - // TODO: group mappings that share common key - vec_add1 (g, r[0]); - b = build_map_register (lcm, &sloc, ms, &nonce, want_map_notif, g, - key_id, key, &bi); - vec_free (g); + group = 0; + vec_add1 (group, r[0]); + + /* group mappings that share common key */ + for (k = r + 1; k < vec_end (records); k++) + { + if (k->key_id != r->key_id) + continue; + + if (vec_is_equal (k->key, r->key)) + { + vec_add1 (group, k[0]); + k->key = 0; /* don't process this mapping again */ + } + } + + b = build_map_register (lcm, &sloc, &lcm->active_map_server, &nonce, + want_map_notif, group, key_id, key, &bi); + vec_free (group); if (!b) continue; vnet_buffer (b)->sw_if_index[VLIB_TX] = 0; - next_index = (ip_addr_version (&lcm->active_map_resolver) == IP4) ? + next_index = (ip_addr_version (&lcm->active_map_server) == IP4) ? ip4_lookup_node.index : ip6_lookup_node.index; f = vlib_get_frame_to_node (lcm->vlib_main, next_index); @@ -3626,11 +2922,20 @@ send_map_register (lisp_cp_main_t * lcm, u8 want_map_notif) to_next[0] = bi; f->n_vectors = 1; vlib_put_frame_to_node (lcm->vlib_main, next_index, f); + map_registers_sent++; - hash_set (lcm->map_register_messages_by_nonce, nonce, 0); + pool_get (lcm->pending_map_registers_pool, pmr); + memset (pmr, 0, sizeof (*pmr)); + pmr->time_to_expire = PENDING_MREG_EXPIRATION_TIME; + hash_set (lcm->map_register_messages_by_nonce, nonce, + pmr - lcm->pending_map_registers_pool); } free_map_register_records (records); + vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index, + LISP_CP_OUTPUT_ERROR_MAP_REGISTERS_SENT, + map_registers_sent); + return 0; } @@ -3676,7 +2981,7 @@ _send_encapsulated_map_request (lisp_cp_main_t * lcm, } /* get locator-set for seid */ - if (!lcm->lisp_pitr) + if (!lcm->lisp_pitr && gid_address_type (deid) != GID_ADDR_NSH) { map_index = gid_dictionary_lookup (&lcm->mapping_index_by_gid, seid); if (map_index == ~0) @@ -3699,9 +3004,24 @@ _send_encapsulated_map_request (lisp_cp_main_t * lcm, } else { - map_index = lcm->pitr_map_index; - map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index); - ls_index = map->locator_set_index; + if (lcm->lisp_pitr) + { + map = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index); + ls_index = map->locator_set_index; + } + else + { + if (lcm->nsh_map_index == (u32) ~ 0) + { + clib_warning ("No locator-set defined for NSH!"); + return -1; + } + else + { + map = pool_elt_at_index (lcm->mapping_pool, lcm->nsh_map_index); + ls_index = map->locator_set_index; + } + } } /* overwrite locator set if map-request itr-rlocs configured */ @@ -3740,6 +3060,9 @@ _send_encapsulated_map_request (lisp_cp_main_t * lcm, f->n_vectors = 1; vlib_put_frame_to_node (lcm->vlib_main, next_index, f); + vlib_node_increment_counter (vlib_get_main (), lisp_cp_output_node.index, + LISP_CP_OUTPUT_ERROR_MAP_REQUESTS_SENT, 1); + if (duplicate_pmr) /* if there is a pending request already update it */ { @@ -3816,10 +3139,8 @@ lisp_get_vni_from_buffer_ip (lisp_cp_main_t * lcm, vlib_buffer_t * b, } always_inline u32 -lisp_get_vni_from_buffer_eth (lisp_cp_main_t * lcm, vlib_buffer_t * b) +lisp_get_bd_from_buffer_eth (vlib_buffer_t * b) { - uword *vnip; - u32 vni = ~0; u32 sw_if_index0; l2input_main_t *l2im = &l2input_main; @@ -3830,26 +3151,39 @@ lisp_get_vni_from_buffer_eth (lisp_cp_main_t * lcm, vlib_buffer_t * b) config = vec_elt_at_index (l2im->configs, sw_if_index0); bd_config = vec_elt_at_index (l2im->bd_configs, config->bd_index); - vnip = hash_get (lcm->vni_by_bd_id, bd_config->bd_id); + return bd_config->bd_id; +} + +always_inline u32 +lisp_get_vni_from_buffer_eth (lisp_cp_main_t * lcm, vlib_buffer_t * b) +{ + uword *vnip; + u32 vni = ~0; + u32 bd = lisp_get_bd_from_buffer_eth (b); + + vnip = hash_get (lcm->vni_by_bd_id, bd); if (vnip) vni = vnip[0]; else - clib_warning ("bridge domain %d is not mapped to any vni!", - config->bd_index); + clib_warning ("bridge domain %d is not mapped to any vni!", bd); return vni; } -always_inline void +void get_src_and_dst_eids_from_buffer (lisp_cp_main_t * lcm, vlib_buffer_t * b, - gid_address_t * src, gid_address_t * dst) + gid_address_t * src, gid_address_t * dst, + u16 type) { + ethernet_header_t *eh; u32 vni = 0; - u16 type; + icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *opt; memset (src, 0, sizeof (*src)); memset (dst, 0, sizeof (*dst)); - type = vnet_buffer (b)->lisp.overlay_afi; + + gid_address_type (dst) = GID_ADDR_NO_ADDRESS; + gid_address_type (src) = GID_ADDR_NO_ADDRESS; if (LISP_AFI_IP == type || LISP_AFI_IP6 == type) { @@ -3871,22 +3205,81 @@ get_src_and_dst_eids_from_buffer (lisp_cp_main_t * lcm, vlib_buffer_t * b, gid_address_vni (dst) = vni; gid_address_vni (src) = vni; } - else if (LISP_AFI_MAC == type) + else if (LISP_AFI_MAC == type) + { + ethernet_arp_header_t *ah; + + eh = vlib_buffer_get_current (b); + + if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_ARP) + { + ah = (ethernet_arp_header_t *) (((u8 *) eh) + sizeof (*eh)); + if (clib_net_to_host_u16 (ah->opcode) + != ETHERNET_ARP_OPCODE_request) + return; + + gid_address_type (dst) = GID_ADDR_ARP; + gid_address_arp_bd (dst) = lisp_get_bd_from_buffer_eth (b); + clib_memcpy (&gid_address_arp_ip4 (dst), + &ah->ip4_over_ethernet[1].ip4, 4); + } + else + { + if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_IP6) + { + ip6_header_t *ip; + ip = (ip6_header_t *) (eh + 1); + + if (IP_PROTOCOL_ICMP6 == ip->protocol) + { + icmp6_neighbor_solicitation_or_advertisement_header_t *ndh; + ndh = ip6_next_header (ip); + if (ndh->icmp.type == ICMP6_neighbor_solicitation) + { + opt = (void *) (ndh + 1); + if ((opt->header.type != + ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address) + || (opt->header.n_data_u64s != 1)) + return; /* source link layer address option not present */ + + gid_address_type (dst) = GID_ADDR_NDP; + gid_address_ndp_bd (dst) = + lisp_get_bd_from_buffer_eth (b); + ip_address_set (&gid_address_arp_ndp_ip (dst), + &ndh->target_address, IP6); + return; + } + } + } + + gid_address_type (src) = GID_ADDR_MAC; + gid_address_type (dst) = GID_ADDR_MAC; + mac_copy (&gid_address_mac (src), eh->src_address); + mac_copy (&gid_address_mac (dst), eh->dst_address); + + /* get vni */ + vni = lisp_get_vni_from_buffer_eth (lcm, b); + + gid_address_vni (dst) = vni; + gid_address_vni (src) = vni; + } + } + else if (LISP_AFI_LCAF == type) { - ethernet_header_t *eh; - + lisp_nsh_hdr_t *nh; eh = vlib_buffer_get_current (b); - gid_address_type (src) = GID_ADDR_MAC; - gid_address_type (dst) = GID_ADDR_MAC; - mac_copy (&gid_address_mac (src), eh->src_address); - mac_copy (&gid_address_mac (dst), eh->dst_address); - - /* get vni */ - vni = lisp_get_vni_from_buffer_eth (lcm, b); - - gid_address_vni (dst) = vni; - gid_address_vni (src) = vni; + if (clib_net_to_host_u16 (eh->type) == ETHERNET_TYPE_NSH) + { + nh = (lisp_nsh_hdr_t *) (((u8 *) eh) + sizeof (*eh)); + u32 spi = clib_net_to_host_u32 (nh->spi_si << 8); + u8 si = (u8) clib_net_to_host_u32 (nh->spi_si); + gid_address_nsh_spi (dst) = spi; + gid_address_nsh_si (dst) = si; + + gid_address_type (dst) = GID_ADDR_NSH; + gid_address_type (src) = GID_ADDR_NSH; + } } } @@ -3895,38 +3288,114 @@ lisp_cp_lookup_inline (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * from_frame, int overlay) { - u32 *from, *to_next_drop, di, si; + icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *opt; + u32 *from, *to_next, di, si; lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); - u32 pkts_mapped = 0; - uword n_left_from, n_left_to_next_drop; + u32 next_index; + uword n_left_from, n_left_to_next; + vnet_main_t *vnm = vnet_get_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) { - vlib_get_next_frame (vm, node, LISP_CP_LOOKUP_NEXT_DROP, - to_next_drop, n_left_to_next_drop); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); - while (n_left_from > 0 && n_left_to_next_drop > 0) + while (n_left_from > 0 && n_left_to_next > 0) { - u32 pi0; + u32 pi0, sw_if_index0, next0; + u64 mac0; vlib_buffer_t *b0; gid_address_t src, dst; + ethernet_arp_header_t *arp0; + ethernet_header_t *eth0; + vnet_hw_interface_t *hw_if0; + ethernet_header_t *eh0; + icmp6_neighbor_solicitation_or_advertisement_header_t *ndh; + ip6_header_t *ip0; pi0 = from[0]; from += 1; n_left_from -= 1; - to_next_drop[0] = pi0; - to_next_drop += 1; - n_left_to_next_drop -= 1; + to_next[0] = pi0; + to_next += 1; + n_left_to_next -= 1; b0 = vlib_get_buffer (vm, pi0); - b0->error = node->errors[LISP_CP_LOOKUP_ERROR_DROP]; - vnet_buffer (b0)->lisp.overlay_afi = overlay; /* src/dst eid pair */ - get_src_and_dst_eids_from_buffer (lcm, b0, &src, &dst); + get_src_and_dst_eids_from_buffer (lcm, b0, &src, &dst, overlay); + + if (gid_address_type (&dst) == GID_ADDR_ARP) + { + mac0 = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst); + if (GID_LOOKUP_MISS_L2 == mac0) + goto drop; + + /* send ARP reply */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0; + + hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0); + + eth0 = vlib_buffer_get_current (b0); + arp0 = (ethernet_arp_header_t *) (((u8 *) eth0) + + sizeof (*eth0)); + arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply); + arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0]; + clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, + (u8 *) & mac0, 6); + clib_memcpy (&arp0->ip4_over_ethernet[0].ip4, + &gid_address_arp_ip4 (&dst), 4); + + /* Hardware must be ethernet-like. */ + ASSERT (vec_len (hw_if0->hw_address) == 6); + + clib_memcpy (eth0->dst_address, eth0->src_address, 6); + clib_memcpy (eth0->src_address, hw_if0->hw_address, 6); + + b0->error = node->errors[LISP_CP_LOOKUP_ERROR_ARP_REPLY_TX]; + next0 = LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX; + goto enqueue; + } + else if (gid_address_type (&dst) == GID_ADDR_NDP) + { + mac0 = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst); + if (GID_LOOKUP_MISS_L2 == mac0) + goto drop; + + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0; + + eh0 = vlib_buffer_get_current (b0); + ip0 = (ip6_header_t *) (eh0 + 1); + ndh = ip6_next_header (ip0); + int bogus_length; + ip0->dst_address = ip0->src_address; + ip0->src_address = ndh->target_address; + ip0->hop_limit = 255; + opt = (void *) (ndh + 1); + opt->header.type = + ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address; + clib_memcpy (opt->ethernet_address, (u8 *) & mac0, 6); + ndh->icmp.type = ICMP6_neighbor_advertisement; + ndh->advertisement_flags = clib_host_to_net_u32 + (ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED | + ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE); + ndh->icmp.checksum = 0; + ndh->icmp.checksum = + ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip0, + &bogus_length); + clib_memcpy (eh0->dst_address, eh0->src_address, 6); + clib_memcpy (eh0->src_address, (u8 *) & mac0, 6); + b0->error = + node->errors + [LISP_CP_LOOKUP_ERROR_NDP_NEIGHBOR_ADVERTISEMENT_TX]; + next0 = LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX; + goto enqueue; + } /* if we have remote mapping for destination already in map-chache add forwarding tunnel directly. If not send a map-request */ @@ -3942,15 +3411,20 @@ lisp_cp_lookup_inline (vlib_main_t * vm, /* send map-request */ queue_map_request (&src, &dst, 0 /* smr_invoked */ , 0 /* is_resend */ ); - pkts_mapped++; } else { - si = gid_dictionary_lookup (&lcm->mapping_index_by_gid, - &src); + if (GID_ADDR_NSH != gid_address_type (&dst)) + { + si = gid_dictionary_lookup (&lcm->mapping_index_by_gid, + &src); + } + else + si = lcm->nsh_map_index; + if (~0 != si) { - dp_add_fwd_entry (lcm, si, di); + dp_add_fwd_entry_from_mt (si, di); } } } @@ -3959,9 +3433,12 @@ lisp_cp_lookup_inline (vlib_main_t * vm, /* send map-request */ queue_map_request (&src, &dst, 0 /* smr_invoked */ , 0 /* is_resend */ ); - pkts_mapped++; } + drop: + b0->error = node->errors[LISP_CP_LOOKUP_ERROR_DROP]; + next0 = LISP_CP_LOOKUP_NEXT_DROP; + enqueue: if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) { lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, b0, @@ -3974,14 +3451,13 @@ lisp_cp_lookup_inline (vlib_main_t * vm, } gid_address_free (&dst); gid_address_free (&src); + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, + n_left_to_next, pi0, next0); } - vlib_put_next_frame (vm, node, LISP_CP_LOOKUP_NEXT_DROP, - n_left_to_next_drop); + vlib_put_next_frame (vm, node, next_index, n_left_to_next); } - vlib_node_increment_counter (vm, node->node_index, - LISP_CP_LOOKUP_ERROR_MAP_REQUESTS_SENT, - pkts_mapped); return from_frame->n_vectors; } @@ -4006,6 +3482,14 @@ lisp_cp_lookup_l2 (vlib_main_t * vm, return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_MAC)); } +static uword +lisp_cp_lookup_nsh (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * from_frame) +{ + /* TODO decide if NSH should be propagated as LCAF or not */ + return (lisp_cp_lookup_inline (vm, node, from_frame, LISP_AFI_LCAF)); +} + /* *INDENT-OFF* */ VLIB_REGISTER_NODE (lisp_cp_lookup_ip4_node) = { .function = lisp_cp_lookup_ip4, @@ -4021,6 +3505,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_ip4_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -4040,6 +3525,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_ip6_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -4059,13 +3545,37 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_l2_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output", + }, +}; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (lisp_cp_lookup_nsh_node) = { + .function = lisp_cp_lookup_nsh, + .name = "lisp-cp-lookup-nsh", + .vector_size = sizeof (u32), + .format_trace = format_lisp_cp_lookup_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = LISP_CP_LOOKUP_N_ERROR, + .error_strings = lisp_cp_lookup_error_strings, + + .n_next_nodes = LISP_CP_LOOKUP_N_NEXT, + + .next_nodes = { + [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_NDP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ /* lisp_cp_input statistics */ -#define foreach_lisp_cp_input_error \ -_(DROP, "drop") \ +#define foreach_lisp_cp_input_error \ +_(DROP, "drop") \ +_(RLOC_PROBE_REQ_RECEIVED, "rloc-probe requests received") \ +_(RLOC_PROBE_REP_RECEIVED, "rloc-probe replies received") \ +_(MAP_NOTIFIES_RECEIVED, "map-notifies received") \ _(MAP_REPLIES_RECEIVED, "map-replies received") static char *lisp_cp_input_error_strings[] = { @@ -4082,12 +3592,6 @@ typedef enum LISP_CP_INPUT_N_ERROR, } lisp_cp_input_error_t; -typedef enum -{ - LISP_CP_INPUT_NEXT_DROP, - LISP_CP_INPUT_N_NEXT, -} lisp_cp_input_next_t; - typedef struct { gid_address_t dst_eid; @@ -4110,11 +3614,17 @@ static void remove_expired_mapping (lisp_cp_main_t * lcm, u32 mi) { mapping_t *m; + vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args; + memset (adj_args, 0, sizeof (adj_args[0])); m = pool_elt_at_index (lcm->mapping_pool, mi); - lisp_add_del_adjacency (lcm, 0, &m->eid, 0 /* is_add */ ); - vnet_lisp_add_del_mapping (&m->eid, 0, 0, 0, ~0, 0 /* is_add */ , - 0 /* is_static */ , 0); + + gid_address_copy (&adj_args->reid, &m->eid); + adj_args->is_add = 0; + if (vnet_lisp_add_del_adjacency (adj_args)) + clib_warning ("failed to del adjacency!"); + + vnet_lisp_del_mapping (&m->eid, NULL); mapping_delete_timer (lcm, mi); } @@ -4133,17 +3643,84 @@ mapping_start_expiration_timer (lisp_cp_main_t * lcm, u32 mi, timing_wheel_insert (&lcm->wheel, exp_clock_time, mi); } +static void +process_expired_mapping (lisp_cp_main_t * lcm, u32 mi) +{ + int rv; + vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a; + mapping_t *m = pool_elt_at_index (lcm->mapping_pool, mi); + uword *fei; + fwd_entry_t *fe; + vlib_counter_t c; + u8 have_stats = 0; + + if (m->delete_after_expiration) + { + remove_expired_mapping (lcm, mi); + return; + } + + fei = hash_get (lcm->fwd_entry_by_mapping_index, mi); + if (!fei) + return; + + fe = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]); + + memset (a, 0, sizeof (*a)); + a->rmt_eid = fe->reid; + if (fe->is_src_dst) + a->lcl_eid = fe->leid; + a->vni = gid_address_vni (&fe->reid); + + rv = vnet_lisp_gpe_get_fwd_stats (a, &c); + if (0 == rv) + have_stats = 1; + + if (m->almost_expired) + { + m->almost_expired = 0; /* reset flag */ + if (have_stats) + { + if (m->packets != c.packets) + { + /* mapping is in use, re-fetch */ + map_request_args_t mr_args; + memset (&mr_args, 0, sizeof (mr_args)); + mr_args.seid = fe->leid; + mr_args.deid = fe->reid; + + send_map_request_thread_fn (&mr_args); + } + else + remove_expired_mapping (lcm, mi); + } + else + remove_expired_mapping (lcm, mi); + } + else + { + m->almost_expired = 1; + mapping_start_expiration_timer (lcm, mi, TIME_UNTIL_REFETCH_OR_DELETE); + + if (have_stats) + /* save counter */ + m->packets = c.packets; + else + m->delete_after_expiration = 1; + } +} + static void map_records_arg_free (map_records_arg_t * a) { + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); mapping_t *m; vec_foreach (m, a->mappings) { vec_free (m->locators); gid_address_free (&m->eid); } - - clib_mem_free (a); + pool_put (lcm->map_records_args_pool[vlib_get_thread_index ()], a); } void * @@ -4155,6 +3732,7 @@ process_map_reply (map_records_arg_t * a) pending_map_request_t *pmr; u64 *noncep; uword *pmr_index; + u8 is_changed = 0; if (a->is_rloc_probe) goto done; @@ -4170,18 +3748,36 @@ process_map_reply (map_records_arg_t * a) vec_foreach (m, a->mappings) { + vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args; + memset (m_args, 0, sizeof (m_args[0])); + gid_address_copy (&m_args->eid, &m->eid); + m_args->action = m->action; + m_args->authoritative = m->authoritative; + m_args->ttl = m->ttl; + m_args->is_static = 0; + /* insert/update mappings cache */ - vnet_lisp_add_del_mapping (&m->eid, m->locators, m->action, - m->authoritative, m->ttl, - 1, 0 /* is_static */ , &dst_map_index); + vnet_lisp_add_mapping (m_args, m->locators, &dst_map_index, &is_changed); - /* try to program forwarding only if mapping saved or updated */ - if ((u32) ~ 0 != dst_map_index) + if (dst_map_index == (u32) ~ 0) + continue; + + if (is_changed) { - lisp_add_del_adjacency (lcm, &pmr->src, &m->eid, 1); - if ((u32) ~ 0 != m->ttl) - mapping_start_expiration_timer (lcm, dst_map_index, m->ttl * 60); + /* try to program forwarding only if mapping saved or updated */ + vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args; + memset (adj_args, 0, sizeof (adj_args[0])); + + gid_address_copy (&adj_args->leid, &pmr->src); + gid_address_copy (&adj_args->reid, &m->eid); + adj_args->is_add = 1; + + if (vnet_lisp_add_del_adjacency (adj_args)) + clib_warning ("failed to add adjacency!"); } + + if ((u32) ~ 0 != m->ttl) + mapping_start_expiration_timer (lcm, dst_map_index, MAPPING_TIMEOUT); } /* remove pending map request entry */ @@ -4196,7 +3792,7 @@ process_map_reply (map_records_arg_t * a) pool_put (lcm->pending_map_requests_pool, pmr); done: - map_records_arg_free (a); + a->is_free = 1; return 0; } @@ -4247,8 +3843,12 @@ process_map_notify (map_records_arg_t * a) return; } - map_records_arg_free (a); + a->is_free = 1; + pool_put_index (lcm->pending_map_registers_pool, pmr_index[0]); hash_unset (lcm->map_register_messages_by_nonce, a->nonce); + + /* reset map-notify counter */ + lcm->expired_map_registers = 0; } static mapping_t * @@ -4309,9 +3909,12 @@ parse_map_records (vlib_buffer_t * b, map_records_arg_t * a, u8 count) mapping_t m; locator_t *loc; + memset (&m, 0, sizeof (m)); + /* parse record eid */ for (i = 0; i < count; i++) { + locators = 0; len = lisp_msg_parse_mapping_record (b, &deid, &locators, NULL); if (len == ~0) { @@ -4329,6 +3932,24 @@ parse_map_records (vlib_buffer_t * b, map_records_arg_t * a, u8 count) return 0; } +static map_records_arg_t * +map_record_args_get () +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + map_records_arg_t *rec; + + /* Cleanup first */ + /* *INDENT-OFF* */ + pool_foreach (rec, lcm->map_records_args_pool[vlib_get_thread_index()], ({ + if (rec->is_free) + map_records_arg_free (rec); + })); + /* *INDENT-ON* */ + + pool_get (lcm->map_records_args_pool[vlib_get_thread_index ()], rec); + return rec; +} + static map_records_arg_t * parse_map_notify (vlib_buffer_t * b) { @@ -4340,8 +3961,9 @@ parse_map_notify (vlib_buffer_t * b) gid_address_t deid; u16 auth_data_len = 0; u8 record_count; - map_records_arg_t *a = clib_mem_alloc (sizeof (*a)); + map_records_arg_t *a; + a = map_record_args_get (); memset (a, 0, sizeof (*a)); mnotif_hdr = vlib_buffer_get_current (b); vlib_buffer_pull (b, sizeof (*mnotif_hdr)); @@ -4373,8 +3995,8 @@ parse_map_notify (vlib_buffer_t * b) if (!is_auth_data_valid (mnotif_hdr, vlib_buffer_get_tail (b) - (u8 *) mnotif_hdr, key_id, key)) { - clib_warning ("Map-notify auth data verification failed for nonce %lu!", - a->nonce); + clib_warning ("Map-notify auth data verification failed for nonce " + "0x%lx!", a->nonce); map_records_arg_free (a); return 0; } @@ -4404,7 +4026,7 @@ build_map_reply (lisp_cp_main_t * lcm, ip_address_t * sloc, lisp_msg_put_map_reply (b, records, nonce, probe_bit); /* push outer ip header */ - pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, dst_port, sloc, dst); + pkt_push_udp_and_ip (vm, b, LISP_CONTROL_PORT, dst_port, sloc, dst, 1); bi_res[0] = bi; return b; @@ -4457,49 +4079,35 @@ send_map_reply (lisp_cp_main_t * lcm, u32 mi, ip_address_t * dst, return 0; } +static void +find_ip_header (vlib_buffer_t * b, u8 ** ip_hdr) +{ + const i32 start = vnet_buffer (b)->l3_hdr_offset; + if (start < 0 && start < -sizeof (b->pre_data)) + { + *ip_hdr = 0; + return; + } + + *ip_hdr = b->data + start; + if ((u8 *) * ip_hdr > (u8 *) vlib_buffer_get_current (b)) + *ip_hdr = 0; +} + void -process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, - vlib_buffer_t * b) +process_map_request (vlib_main_t * vm, vlib_node_runtime_t * node, + lisp_cp_main_t * lcm, vlib_buffer_t * b) { - u8 *ip_hdr = 0, *udp_hdr; - ip4_header_t *ip4; - ip6_header_t *ip6; + u8 *ip_hdr = 0; ip_address_t *dst_loc = 0, probed_loc, src_loc; mapping_t m; map_request_hdr_t *mreq_hdr; gid_address_t src, dst; u64 nonce; - u32 i, len = 0; + u32 i, len = 0, rloc_probe_recv = 0; gid_address_t *itr_rlocs = 0; mreq_hdr = vlib_buffer_get_current (b); - - // TODO ugly workaround to find out whether LISP is carried by ip4 or 6 - // and needs to be fixed - udp_hdr = (u8 *) vlib_buffer_get_current (b) - sizeof (udp_header_t); - ip4 = (ip4_header_t *) (udp_hdr - sizeof (ip4_header_t)); - ip6 = (ip6_header_t *) (udp_hdr - sizeof (ip6_header_t)); - - if ((ip4->ip_version_and_header_length & 0xF0) == 0x40) - ip_hdr = (u8 *) ip4; - else - { - u32 flags = clib_net_to_host_u32 - (ip6->ip_version_traffic_class_and_flow_label); - if ((flags & 0xF0000000) == 0x60000000) - ip_hdr = (u8 *) ip6; - else - { - clib_warning ("internal error: cannot determine whether packet " - "is ip4 or 6!"); - return; - } - } - - vlib_buffer_pull (b, sizeof (*mreq_hdr)); - - nonce = MREQ_NONCE (mreq_hdr); - if (!MREQ_SMR (mreq_hdr) && !MREQ_RLOC_PROBE (mreq_hdr)) { clib_warning @@ -4507,6 +4115,9 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, return; } + vlib_buffer_pull (b, sizeof (*mreq_hdr)); + nonce = MREQ_NONCE (mreq_hdr); + /* parse src eid */ len = lisp_msg_parse_addr (b, &src); if (len == ~0) @@ -4515,7 +4126,7 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, len = lisp_msg_parse_itr_rlocs (b, &itr_rlocs, MREQ_ITR_RLOC_COUNT (mreq_hdr) + 1); if (len == ~0) - return; + goto done; /* parse eid records and send SMR-invoked map-requests */ for (i = 0; i < MREQ_REC_COUNT (mreq_hdr); i++) @@ -4535,6 +4146,13 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, } else if (MREQ_RLOC_PROBE (mreq_hdr)) { + find_ip_header (b, &ip_hdr); + if (!ip_hdr) + { + clib_warning ("Cannot find the IP header!"); + goto done; + } + rloc_probe_recv++; memset (&m, 0, sizeof (m)); u32 mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst); @@ -4553,10 +4171,13 @@ process_map_request (vlib_main_t * vm, lisp_cp_main_t * lcm, } done: + vlib_node_increment_counter (vm, node->node_index, + LISP_CP_INPUT_ERROR_RLOC_PROBE_REQ_RECEIVED, + rloc_probe_recv); vec_free (itr_rlocs); } -static map_records_arg_t * +map_records_arg_t * parse_map_reply (vlib_buffer_t * b) { locator_t probed; @@ -4565,13 +4186,21 @@ parse_map_reply (vlib_buffer_t * b) u32 i, len = 0; mapping_t m; map_reply_hdr_t *mrep_hdr; - map_records_arg_t *a = clib_mem_alloc (sizeof (*a)); + map_records_arg_t *a; + + a = map_record_args_get (); memset (a, 0, sizeof (*a)); + locator_t *locators; mrep_hdr = vlib_buffer_get_current (b); a->nonce = MREP_NONCE (mrep_hdr); a->is_rloc_probe = MREP_RLOC_PROBE (mrep_hdr); + if (!vlib_buffer_has_space (b, sizeof (*mrep_hdr))) + { + clib_mem_free (a); + return 0; + } vlib_buffer_pull (b, sizeof (*mrep_hdr)); for (i = 0; i < MREP_REC_COUNT (mrep_hdr); i++) @@ -4602,7 +4231,7 @@ parse_map_reply (vlib_buffer_t * b) static void queue_map_reply_for_processing (map_records_arg_t * a) { - vl_api_rpc_call_main_thread (process_map_reply, (u8 *) a, sizeof (a)); + vl_api_rpc_call_main_thread (process_map_reply, (u8 *) a, sizeof (*a)); } static void @@ -4615,7 +4244,8 @@ static uword lisp_cp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * from_frame) { - u32 n_left_from, *from, *to_next_drop; + u32 n_left_from, *from, *to_next_drop, rloc_probe_rep_recv = 0, + map_notifies_recv = 0; lisp_msg_type_e type; lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); map_records_arg_t *a; @@ -4650,15 +4280,22 @@ lisp_cp_input (vlib_main_t * vm, vlib_node_runtime_t * node, case LISP_MAP_REPLY: a = parse_map_reply (b0); if (a) - queue_map_reply_for_processing (a); + { + if (a->is_rloc_probe) + rloc_probe_rep_recv++; + queue_map_reply_for_processing (a); + } break; case LISP_MAP_REQUEST: - process_map_request (vm, lcm, b0); + process_map_request (vm, node, lcm, b0); break; case LISP_MAP_NOTIFY: a = parse_map_notify (b0); if (a) - queue_map_notify_for_processing (a); + { + map_notifies_recv++; + queue_map_notify_for_processing (a); + } break; default: clib_warning ("Unsupported LISP message type %d", type); @@ -4676,6 +4313,12 @@ lisp_cp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_put_next_frame (vm, node, LISP_CP_INPUT_NEXT_DROP, n_left_to_next_drop); } + vlib_node_increment_counter (vm, node->node_index, + LISP_CP_INPUT_ERROR_RLOC_PROBE_REP_RECEIVED, + rloc_probe_rep_recv); + vlib_node_increment_counter (vm, node->node_index, + LISP_CP_INPUT_ERROR_MAP_NOTIFIES_RECEIVED, + map_notifies_recv); return from_frame->n_vectors; } @@ -4703,6 +4346,8 @@ lisp_cp_init (vlib_main_t * vm) { lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); clib_error_t *error = 0; + vlib_thread_main_t *vtm = vlib_get_thread_main (); + u32 num_threads; if ((error = vlib_call_init_function (vm, lisp_gpe_init))) return error; @@ -4713,12 +4358,18 @@ lisp_cp_init (vlib_main_t * vm) lcm->vnet_main = vnet_get_main (); lcm->mreq_itr_rlocs = ~0; lcm->lisp_pitr = 0; + lcm->flags = 0; memset (&lcm->active_map_resolver, 0, sizeof (lcm->active_map_resolver)); + memset (&lcm->active_map_server, 0, sizeof (lcm->active_map_server)); gid_dictionary_init (&lcm->mapping_index_by_gid); lcm->do_map_resolver_election = 1; + lcm->do_map_server_election = 1; lcm->map_request_mode = MR_MODE_DST_ONLY; + num_threads = 1 /* main thread */ + vtm->n_threads; + vec_validate (lcm->map_records_args_pool, num_threads - 1); + /* default vrf mapped to vni 0 */ hash_set (lcm->table_id_by_vni, 0, 0); hash_set (lcm->vni_by_table_id, 0, 0); @@ -4730,9 +4381,64 @@ lisp_cp_init (vlib_main_t * vm) u64 now = clib_cpu_time_now (); timing_wheel_init (&lcm->wheel, now, vm->clib_time.clocks_per_second); + lcm->nsh_map_index = ~0; + lcm->map_register_ttl = MAP_REGISTER_DEFAULT_TTL; + lcm->max_expired_map_registers = MAX_EXPIRED_MAP_REGISTERS_DEFAULT; + lcm->expired_map_registers = 0; + lcm->transport_protocol = LISP_TRANSPORT_PROTOCOL_UDP; return 0; } +static int +lisp_stats_api_fill (lisp_cp_main_t * lcm, lisp_gpe_main_t * lgm, + lisp_api_stats_t * stat, lisp_stats_key_t * key, + u32 stats_index) +{ + vlib_counter_t v; + vlib_combined_counter_main_t *cm = &lgm->counters; + lisp_gpe_fwd_entry_key_t fwd_key; + const lisp_gpe_tunnel_t *lgt; + fwd_entry_t *fe; + + memset (stat, 0, sizeof (*stat)); + memset (&fwd_key, 0, sizeof (fwd_key)); + + fe = pool_elt_at_index (lcm->fwd_entry_pool, key->fwd_entry_index); + ASSERT (fe != 0); + + gid_to_dp_address (&fe->reid, &stat->deid); + gid_to_dp_address (&fe->leid, &stat->seid); + stat->vni = gid_address_vni (&fe->reid); + + lgt = lisp_gpe_tunnel_get (key->tunnel_index); + stat->loc_rloc = lgt->key->lcl; + stat->rmt_rloc = lgt->key->rmt; + + vlib_get_combined_counter (cm, stats_index, &v); + stat->counters = v; + return 1; +} + +lisp_api_stats_t * +vnet_lisp_get_stats (void) +{ + lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main (); + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lisp_api_stats_t *stats = 0, stat; + lisp_stats_key_t *key; + u32 index; + + /* *INDENT-OFF* */ + hash_foreach_mem (key, index, lgm->lisp_stats_index_by_key, + { + if (lisp_stats_api_fill (lcm, lgm, &stat, key, index)) + vec_add1 (stats, stat); + }); + /* *INDENT-ON* */ + + return stats; +} + static void * send_map_request_thread_fn (void *arg) { @@ -4839,7 +4545,7 @@ remove_dead_pending_map_requests (lisp_cp_main_t * lcm) /* *INDENT-ON* */ vec_foreach (pmr_index, to_be_removed) - pool_put_index (lcm->pending_map_requests_by_nonce, pmr_index[0]); + pool_put_index (lcm->pending_map_requests_pool, pmr_index[0]); vec_free (to_be_removed); } @@ -4860,15 +4566,98 @@ update_rloc_probing (lisp_cp_main_t * lcm, f64 dt) } } +static int +update_pending_map_register (pending_map_register_t * r, f64 dt, u8 * del_all) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lisp_msmr_t *ms; + del_all[0] = 0; + + r->time_to_expire -= dt; + + if (r->time_to_expire < 0) + { + lcm->expired_map_registers++; + + if (lcm->expired_map_registers >= lcm->max_expired_map_registers) + { + ms = get_map_server (&lcm->active_map_server); + if (!ms) + { + clib_warning ("Map server %U not found - probably deleted " + "by the user recently.", format_ip_address, + &lcm->active_map_server); + } + else + { + clib_warning ("map server %U is unreachable, ignoring", + format_ip_address, &lcm->active_map_server); + + /* mark current map server unavailable so it won't be + * elected next time */ + ms->is_down = 1; + ms->last_update = vlib_time_now (lcm->vlib_main); + } + + elect_map_server (lcm); + + /* indication for deleting all pending map registers */ + del_all[0] = 1; + lcm->expired_map_registers = 0; + return 0; + } + else + { + /* delete pending map register */ + return 0; + } + } + return 1; +} + static void update_map_register (lisp_cp_main_t * lcm, f64 dt) { + u32 *to_be_removed = 0, *pmr_index; static f64 time_left = QUICK_MAP_REGISTER_INTERVAL; static u64 mreg_sent_counter = 0; + pending_map_register_t *pmr; + u8 del_all = 0; + if (!lcm->is_enabled || !lcm->map_registering) return; + /* *INDENT-OFF* */ + pool_foreach (pmr, lcm->pending_map_registers_pool, + ({ + if (!update_pending_map_register (pmr, dt, &del_all)) + { + if (del_all) + break; + vec_add1 (to_be_removed, pmr - lcm->pending_map_registers_pool); + } + })); + /* *INDENT-ON* */ + + if (del_all) + { + /* delete all pending map register messages so they won't + * trigger another map server election.. */ + pool_free (lcm->pending_map_registers_pool); + hash_free (lcm->map_register_messages_by_nonce); + + /* ..and trigger registration against next map server (if any) */ + time_left = 0; + } + else + { + vec_foreach (pmr_index, to_be_removed) + pool_put_index (lcm->pending_map_registers_pool, pmr_index[0]); + } + + vec_free (to_be_removed); + time_left -= dt; if (time_left <= 0) { @@ -4920,7 +4709,7 @@ send_map_resolver_service (vlib_main_t * vm, u32 *mi = 0; vec_foreach (mi, expired) { - remove_expired_mapping (lcm, mi[0]); + process_expired_mapping (lcm, mi[0]); } _vec_len (expired) = 0; } @@ -4930,6 +4719,33 @@ send_map_resolver_service (vlib_main_t * vm, return 0; } +vnet_api_error_t +vnet_lisp_stats_enable_disable (u8 enable) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + + if (vnet_lisp_enable_disable_status () == 0) + return VNET_API_ERROR_LISP_DISABLED; + + if (enable) + lcm->flags |= LISP_FLAG_STATS_ENABLED; + else + lcm->flags &= ~LISP_FLAG_STATS_ENABLED; + + return 0; +} + +u8 +vnet_lisp_stats_enable_disable_state (void) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + + if (vnet_lisp_enable_disable_status () == 0) + return VNET_API_ERROR_LISP_DISABLED; + + return lcm->flags & LISP_FLAG_STATS_ENABLED; +} + /* *INDENT-OFF* */ VLIB_REGISTER_NODE (lisp_retry_service_node,static) = { .function = send_map_resolver_service, @@ -4939,6 +4755,26 @@ VLIB_REGISTER_NODE (lisp_retry_service_node,static) = { }; /* *INDENT-ON* */ +u32 +vnet_lisp_set_transport_protocol (u8 protocol) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + + if (protocol < LISP_TRANSPORT_PROTOCOL_UDP || + protocol > LISP_TRANSPORT_PROTOCOL_API) + return VNET_API_ERROR_INVALID_ARGUMENT; + + lcm->transport_protocol = protocol; + return 0; +} + +lisp_transport_protocol_t +vnet_lisp_get_transport_protocol (void) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + return lcm->transport_protocol; +} + VLIB_INIT_FUNCTION (lisp_cp_init); /*