X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fvnet%2Flisp-cp%2Fcontrol.c;h=a85656b3fb23eee013bcf64eea8a80d31359a48a;hb=1e553a00389fb0eb2d54b950a3cfd91dd1a72644;hp=439802c947cf6a43eda8b155c82acbab181c79e4;hpb=68c74fc71bc19b44b39601e5ab3d79d35cd5007b;p=vpp.git diff --git a/src/vnet/lisp-cp/control.c b/src/vnet/lisp-cp/control.c index 439802c947c..a85656b3fb2 100644 --- a/src/vnet/lisp-cp/control.c +++ b/src/vnet/lisp-cp/control.c @@ -22,10 +22,14 @@ #include #include #include +#include +#include #include #include +#define MAX_VALUE_U24 0xffffff + lisp_cp_main_t lisp_control_main; u8 *format_lisp_cp_input_trace (u8 * s, va_list * args); @@ -695,6 +699,20 @@ vnet_lisp_map_cache_add_del (vnet_lisp_add_del_mapping_args_t * a, 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) @@ -810,7 +828,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"); @@ -821,6 +839,99 @@ 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 void +add_l2_arp_bd (BVT (clib_bihash_kv) * kvp, void *arg) +{ + u32 **ht = arg; + u32 bd = (u32) kvp->key[0]; + hash_set (ht[0], bd, 0); +} + +u32 * +vnet_lisp_l2_arp_bds_get (void) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + u32 *bds = 0; + + gid_dict_foreach_l2_arp_entry (&lcm->mapping_index_by_gid, + add_l2_arp_bd, &bds); + return bds; +} + +typedef struct +{ + void *vector; + u32 bd; +} lisp_add_l2_arp_args_t; + +static void +add_l2_arp_entry (BVT (clib_bihash_kv) * kvp, void *arg) +{ + lisp_add_l2_arp_args_t *a = arg; + lisp_api_l2_arp_entry_t **vector = a->vector, e; + + if ((u32) kvp->key[0] == a->bd) + { + mac_copy (e.mac, (void *) &kvp->value); + e.ip4 = (u32) kvp->key[1]; + vec_add1 (vector[0], e); + } +} + +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_args_t a; + + a.vector = &entries; + a.bd = bd; + + gid_dict_foreach_l2_arp_entry (&lcm->mapping_index_by_gid, + add_l2_arp_entry, &a); + return entries; +} + +int +vnet_lisp_add_del_l2_arp_entry (gid_address_t * key, u8 * mac, u8 is_add) +{ + if (vnet_lisp_enable_disable_status () == 0) + { + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; + } + + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + int rc = 0; + + u64 res = gid_dictionary_lookup (&lcm->mapping_index_by_gid, key); + if (is_add) + { + 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 ARP 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 */ ); + } + + return rc; +} + int vnet_lisp_eid_table_map (u32 vni, u32 dp_id, u8 is_l2, u8 is_add) { @@ -830,7 +941,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; @@ -1234,8 +1345,23 @@ vnet_lisp_add_del_adjacency (vnet_lisp_add_del_adjacency_args_t * a) { /* 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, &a->leid); + 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) { @@ -1275,6 +1401,57 @@ vnet_lisp_set_map_request_mode (u8 mode) return 0; } +int +vnet_lisp_nsh_set_locator_set (u8 * locator_set_name, u8 is_add) +{ + 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; + + if (vnet_lisp_enable_disable_status () == 0) + { + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; + } + + if (is_add) + { + 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]; + + 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; + + if (~0 == vnet_lisp_gpe_add_nsh_iface (lgm)) + return -1; + } + } + else + { + 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; +} + int vnet_lisp_pitr_set_locator_set (u8 * locator_set_name, u8 is_add) { @@ -1897,6 +2074,21 @@ vnet_lisp_add_del_map_resolver (vnet_lisp_add_del_map_resolver_args_t * a) return 0; } +int +vnet_lisp_map_register_set_ttl (u32 ttl) +{ + lisp_cp_main_t *lcm = vnet_lisp_cp_get_main (); + lcm->map_register_ttl = ttl; + return 0; +} + +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) { @@ -1931,7 +2123,8 @@ vnet_lisp_add_del_mreq_itr_rlocs (vnet_lisp_add_del_mreq_itr_rloc_args_t * a) /* 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") static char *lisp_cp_lookup_error_strings[] = { #define _(sym,string) string, @@ -1950,6 +2143,7 @@ typedef enum typedef enum { LISP_CP_LOOKUP_NEXT_DROP, + LISP_CP_LOOKUP_NEXT_ARP_REPLY_TX, LISP_CP_LOOKUP_N_NEXT, } lisp_cp_lookup_next_t; @@ -2078,7 +2272,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; @@ -2104,6 +2298,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); @@ -2132,7 +2327,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; @@ -2287,7 +2482,7 @@ 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; @@ -2570,7 +2765,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) @@ -2593,9 +2788,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 */ @@ -2710,10 +2920,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; @@ -2724,12 +2932,21 @@ 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; } @@ -2739,11 +2956,15 @@ get_src_and_dst_eids_from_buffer (lisp_cp_main_t * lcm, vlib_buffer_t * b, gid_address_t * src, gid_address_t * dst, u16 type) { + ethernet_header_t *eh; u32 vni = 0; memset (src, 0, sizeof (*src)); memset (dst, 0, sizeof (*dst)); + 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) { ip4_header_t *ip; @@ -2766,25 +2987,51 @@ get_src_and_dst_eids_from_buffer (lisp_cp_main_t * lcm, vlib_buffer_t * b, } else if (LISP_AFI_MAC == type) { - ethernet_header_t *eh; + ethernet_arp_header_t *ah; 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); + 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 + { + 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); + /* get vni */ + vni = lisp_get_vni_from_buffer_eth (lcm, b); - gid_address_vni (dst) = vni; - gid_address_vni (src) = vni; + gid_address_vni (dst) = vni; + gid_address_vni (src) = vni; + } } else if (LISP_AFI_LCAF == type) { - /* Eventually extend this to support NSH and other */ - ASSERT (0); + lisp_nsh_hdr_t *nh; + eh = vlib_buffer_get_current (b); + + 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; + } } } @@ -2793,38 +3040,81 @@ 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; + 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 pkts_mapped = 0, 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; 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]; /* src/dst eid pair */ 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) + { + /* 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_REPLY_TX; + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, + n_left_to_next, pi0, + next0); + } + continue; + } + /* if we have remote mapping for destination already in map-chache add forwarding tunnel directly. If not send a map-request */ di = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, &dst, @@ -2843,8 +3133,14 @@ lisp_cp_lookup_inline (vlib_main_t * vm, } 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_from_mt (si, di); @@ -2859,6 +3155,7 @@ lisp_cp_lookup_inline (vlib_main_t * vm, pkts_mapped++; } + b0->error = node->errors[LISP_CP_LOOKUP_ERROR_DROP]; if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) { lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, b0, @@ -2871,10 +3168,13 @@ lisp_cp_lookup_inline (vlib_main_t * vm, } gid_address_free (&dst); gid_address_free (&src); + next0 = LISP_CP_LOOKUP_NEXT_DROP; + 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, @@ -2926,6 +3226,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_ip4_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -2945,6 +3246,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_ip6_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -2964,6 +3266,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_l2_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -2983,6 +3286,7 @@ VLIB_REGISTER_NODE (lisp_cp_lookup_nsh_node) = { .next_nodes = { [LISP_CP_LOOKUP_NEXT_DROP] = "error-drop", + [LISP_CP_LOOKUP_NEXT_ARP_REPLY_TX] = "interface-output", }, }; /* *INDENT-ON* */ @@ -3064,14 +3368,14 @@ mapping_start_expiration_timer (lisp_cp_main_t * lcm, u32 mi, 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 * @@ -3132,7 +3436,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; } @@ -3183,7 +3487,7 @@ process_map_notify (map_records_arg_t * a) return; } - map_records_arg_free (a); + a->is_free = 1; hash_unset (lcm->map_register_messages_by_nonce, a->nonce); } @@ -3250,6 +3554,7 @@ parse_map_records (vlib_buffer_t * b, map_records_arg_t * a, u8 count) /* parse record eid */ for (i = 0; i < count; i++) { + locators = 0; len = lisp_msg_parse_mapping_record (b, &deid, &locators, NULL); if (len == ~0) { @@ -3267,6 +3572,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) { @@ -3278,8 +3601,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)); @@ -3342,7 +3666,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; @@ -3398,7 +3722,7 @@ send_map_reply (lisp_cp_main_t * lcm, u32 mi, ip_address_t * dst, static void find_ip_header (vlib_buffer_t * b, u8 ** ip_hdr) { - const i32 start = vnet_buffer (b)->ip.start_of_ip_header; + const i32 start = vnet_buffer (b)->l3_hdr_offset; if (start < 0 && start < -sizeof (b->pre_data)) { *ip_hdr = 0; @@ -3502,8 +3826,11 @@ 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); @@ -3659,6 +3986,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; @@ -3676,6 +4005,9 @@ lisp_cp_init (vlib_main_t * vm) lcm->do_map_resolver_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); @@ -3687,6 +4019,8 @@ 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; return 0; }