X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vnet%2Fvnet%2Flisp-gpe%2Flisp_gpe.c;h=f05c6a2028f4f65d48009935043b7d480ee14df1;hb=0bfe5d8c792abcdbcf27bfcc7b7b353fba04aee2;hp=35e16bbcf7c7bd1593207dd1d724aee841af2ba5;hpb=53f09e36f97a28a42a2e3eb58032c75691de4f4c;p=vpp.git diff --git a/vnet/vnet/lisp-gpe/lisp_gpe.c b/vnet/vnet/lisp-gpe/lisp_gpe.c index 35e16bbcf7c..f05c6a2028f 100644 --- a/vnet/vnet/lisp-gpe/lisp_gpe.c +++ b/vnet/vnet/lisp-gpe/lisp_gpe.c @@ -12,572 +12,855 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +/** + * @file + * @brief Common utility functions for IPv4, IPv6 and L2 LISP-GPE tunnels. + * + */ #include - +#include +#include +#include +#include +#include +#include +#include + +/** LISP-GPE global state */ lisp_gpe_main_t lisp_gpe_main; -static int -lisp_gpe_rewrite (lisp_gpe_tunnel_t * t) -{ - u8 *rw = 0; - lisp_gpe_header_t * lisp0; - int len; - - if (ip_addr_version(&t->src) == IP4) - { - ip4_header_t * ip0; - ip4_udp_lisp_gpe_header_t * h0; - len = sizeof(*h0); - - vec_validate_aligned(rw, len - 1, CLIB_CACHE_LINE_BYTES); +/** + * @brief A Pool of all LISP forwarding entries + */ +static lisp_fwd_entry_t *lisp_fwd_entry_pool; - h0 = (ip4_udp_lisp_gpe_header_t *) rw; +/** + * DB of all forwarding entries. The Key is:{l-EID,r-EID,vni} + * where the EID encodes L2 or L3 + */ +static uword *lisp_gpe_fwd_entries; - /* Fixed portion of the (outer) ip4 header */ - ip0 = &h0->ip4; - ip0->ip_version_and_header_length = 0x45; - ip0->ttl = 254; - ip0->protocol = IP_PROTOCOL_UDP; +static void +create_fib_entries (lisp_fwd_entry_t * lfe) +{ + dpo_proto_t dproto; - /* we fix up the ip4 header length and checksum after-the-fact */ - ip_address_copy_addr(&ip0->src_address, &t->src); - ip_address_copy_addr(&ip0->dst_address, &t->dst); - ip0->checksum = ip4_header_checksum (ip0); + dproto = (ip_prefix_version (&lfe->key->rmt.ippref) == IP4 ? + FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6); - /* UDP header, randomize src port on something, maybe? */ - h0->udp.src_port = clib_host_to_net_u16 (4341); - h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe); + lfe->src_fib_index = ip_dst_fib_add_route (lfe->eid_fib_index, + &lfe->key->rmt.ippref); - /* LISP-gpe header */ - lisp0 = &h0->lisp; + if (LISP_FWD_ENTRY_TYPE_NEGATIVE == lfe->type) + { + dpo_id_t dpo = DPO_NULL; + + switch (lfe->action) + { + case LISP_NO_ACTION: + /* TODO update timers? */ + case LISP_FORWARD_NATIVE: + /* TODO check if route/next-hop for eid exists in fib and add + * more specific for the eid with the next-hop found */ + case LISP_SEND_MAP_REQUEST: + /* insert tunnel that always sends map-request */ + dpo_set (&dpo, DPO_LISP_CP, 0, dproto); + break; + case LISP_DROP: + /* for drop fwd entries, just add route, no need to add encap tunnel */ + dpo_copy (&dpo, drop_dpo_get (dproto)); + break; + } + ip_src_fib_add_route_w_dpo (lfe->src_fib_index, + &lfe->key->lcl.ippref, &dpo); + dpo_reset (&dpo); } else { - ip6_header_t * ip0; - ip6_udp_lisp_gpe_header_t * h0; - len = sizeof(*h0); - - vec_validate_aligned(rw, len - 1, CLIB_CACHE_LINE_BYTES); + ip_src_fib_add_route (lfe->src_fib_index, + &lfe->key->lcl.ippref, lfe->paths); + } +} - h0 = (ip6_udp_lisp_gpe_header_t *) rw; +static void +delete_fib_entries (lisp_fwd_entry_t * lfe) +{ + ip_src_dst_fib_del_route (lfe->src_fib_index, + &lfe->key->lcl.ippref, + lfe->eid_fib_index, &lfe->key->rmt.ippref); +} - /* Fixed portion of the (outer) ip6 header */ - ip0 = &h0->ip6; - ip0->ip_version_traffic_class_and_flow_label = - clib_host_to_net_u32 (0x6 << 28); - ip0->hop_limit = 254; - ip0->protocol = IP_PROTOCOL_UDP; +static void +gid_to_dp_address (gid_address_t * g, dp_address_t * d) +{ + switch (gid_address_type (g)) + { + case GID_ADDR_IP_PREFIX: + case GID_ADDR_SRC_DST: + ip_prefix_copy (&d->ippref, &gid_address_ippref (g)); + d->type = FID_ADDR_IP_PREF; + break; + case GID_ADDR_MAC: + default: + mac_copy (&d->mac, &gid_address_mac (g)); + d->type = FID_ADDR_MAC; + break; + } +} - /* we fix up the ip6 header length after-the-fact */ - ip_address_copy_addr(&ip0->src_address, &t->src); - ip_address_copy_addr(&ip0->dst_address, &t->dst); +static lisp_fwd_entry_t * +find_fwd_entry (lisp_gpe_main_t * lgm, + vnet_lisp_gpe_add_del_fwd_entry_args_t * a, + lisp_gpe_fwd_entry_key_t * key) +{ + uword *p; - /* UDP header, randomize src port on something, maybe? */ - h0->udp.src_port = clib_host_to_net_u16 (4341); - h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe); + memset (key, 0, sizeof (*key)); - /* LISP-gpe header */ - lisp0 = &h0->lisp; + if (GID_ADDR_IP_PREFIX == gid_address_type (&a->rmt_eid)) + { + /* + * the ip version of the source is not set to ip6 when the + * source is all zeros. force it. + */ + ip_prefix_version (&gid_address_ippref (&a->lcl_eid)) = + ip_prefix_version (&gid_address_ippref (&a->rmt_eid)); } - lisp0->flags = t->flags; - lisp0->ver_res = t->ver_res; - lisp0->res = t->res; - lisp0->next_protocol = t->next_protocol; - lisp0->iid = clib_host_to_net_u32 (t->vni); + gid_to_dp_address (&a->rmt_eid, &key->rmt); + gid_to_dp_address (&a->lcl_eid, &key->lcl); + key->vni = a->vni; - t->rewrite = rw; - return 0; -} + p = hash_get_mem (lisp_gpe_fwd_entries, key); -#define foreach_copy_field \ -_(encap_fib_index) \ -_(decap_fib_index) \ -_(decap_next_index) \ -_(vni) + if (NULL != p) + { + return (pool_elt_at_index (lisp_fwd_entry_pool, p[0])); + } + return (NULL); +} -static u32 -add_del_ip_tunnel (vnet_lisp_gpe_add_del_fwd_entry_args_t *a, - u32 * tun_index_res) +static int +lisp_gpe_fwd_entry_path_sort (void *a1, void *a2) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - lisp_gpe_tunnel_t *t = 0; - uword * p; - int rv; - lisp_gpe_tunnel_key_t key; + lisp_fwd_path_t *p1 = a1, *p2 = a2; - /* prepare tunnel key */ - memset(&key, 0, sizeof(key)); - ip_prefix_copy(&key.eid, &gid_address_ippref(&a->deid)); - ip_address_copy(&key.dst_loc, &a->dlocator); - key.iid = clib_host_to_net_u32 (a->vni); + return (p1->priority - p2->priority); +} - p = mhash_get (&lgm->lisp_gpe_tunnel_by_key, &key); +/** + * @brief Add/Delete LISP IP forwarding entry. + * + * creation of forwarding entries for IP LISP overlay: + * + * @param[in] lgm Reference to @ref lisp_gpe_main_t. + * @param[in] a Parameters for building the forwarding entry. + * + * @return 0 on success. + */ +static int +add_ip_fwd_entry (lisp_gpe_main_t * lgm, + vnet_lisp_gpe_add_del_fwd_entry_args_t * a) +{ + lisp_gpe_fwd_entry_key_t key; + lisp_fwd_entry_t *lfe; + fib_protocol_t fproto; - if (a->is_add) - { - /* adding a tunnel: tunnel must not already exist */ - if (p) - return VNET_API_ERROR_INVALID_VALUE; + lfe = find_fwd_entry (lgm, a, &key); - if (a->decap_next_index >= LISP_GPE_INPUT_N_NEXT) - return VNET_API_ERROR_INVALID_DECAP_NEXT; + if (NULL != lfe) + /* don't support updates */ + return VNET_API_ERROR_INVALID_VALUE; - pool_get_aligned (lgm->tunnels, t, CLIB_CACHE_LINE_BYTES); - memset (t, 0, sizeof (*t)); + pool_get (lisp_fwd_entry_pool, lfe); + memset (lfe, 0, sizeof (*lfe)); + lfe->key = clib_mem_alloc (sizeof (key)); + memcpy (lfe->key, &key, sizeof (key)); - /* copy from arg structure */ -#define _(x) t->x = a->x; - foreach_copy_field; -#undef _ + hash_set_mem (lisp_gpe_fwd_entries, lfe->key, lfe - lisp_fwd_entry_pool); - ip_address_copy(&t->src, &a->slocator); - ip_address_copy(&t->dst, &a->dlocator); + fproto = (IP4 == ip_prefix_version (&fid_addr_ippref (&lfe->key->rmt)) ? + FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6); - t->flags |= LISP_GPE_FLAGS_P; - t->next_protocol = ip_prefix_version(&key.eid) == IP4 ? - LISP_GPE_NEXT_PROTO_IP4 : LISP_GPE_NEXT_PROTO_IP6; + lfe->type = (a->is_negative ? + LISP_FWD_ENTRY_TYPE_NEGATIVE : LISP_FWD_ENTRY_TYPE_NORMAL); + lfe->eid_table_id = a->table_id; + lfe->eid_fib_index = fib_table_find_or_create_and_lock (fproto, + lfe->eid_table_id); - rv = lisp_gpe_rewrite (t); + if (LISP_FWD_ENTRY_TYPE_NEGATIVE != lfe->type) + { + lisp_fwd_path_t *path; + u32 index; - if (rv) - { - pool_put(lgm->tunnels, t); - return rv; - } + vec_validate (lfe->paths, vec_len (a->locator_pairs) - 1); - mhash_set(&lgm->lisp_gpe_tunnel_by_key, &key, t - lgm->tunnels, 0); + vec_foreach_index (index, a->locator_pairs) + { + path = &lfe->paths[index]; - /* return tunnel index */ - if (tun_index_res) - tun_index_res[0] = t - lgm->tunnels; + path->priority = a->locator_pairs[index].priority; + path->weight = a->locator_pairs[index].weight; + + path->lisp_adj = + lisp_gpe_adjacency_find_or_create_and_lock (&a->locator_pairs + [index], + lfe->eid_table_id, + lfe->key->vni); + } + vec_sort_with_function (lfe->paths, lisp_gpe_fwd_entry_path_sort); } - else - { - /* deleting a tunnel: tunnel must exist */ - if (!p) - { - clib_warning("Tunnel for eid %U doesn't exist!", format_gid_address, - &a->deid); - return VNET_API_ERROR_NO_SUCH_ENTRY; - } - t = pool_elt_at_index(lgm->tunnels, p[0]); + create_fib_entries (lfe); - mhash_unset(&lgm->lisp_gpe_tunnel_by_key, &key, 0); + return (0); +} - vec_free(t->rewrite); - pool_put(lgm->tunnels, t); - } +static void +del_ip_fwd_entry_i (lisp_fwd_entry_t * lfe) +{ + lisp_fwd_path_t *path; + fib_protocol_t fproto; - return 0; + vec_foreach (path, lfe->paths) + { + lisp_gpe_adjacency_unlock (path->lisp_adj); + } + + delete_fib_entries (lfe); + + fproto = (IP4 == ip_prefix_version (&fid_addr_ippref (&lfe->key->rmt)) ? + FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6); + fib_table_unlock (lfe->eid_fib_index, fproto); + + hash_unset_mem (lisp_gpe_fwd_entries, lfe->key); + clib_mem_free (lfe->key); + pool_put (lisp_fwd_entry_pool, lfe); } +/** + * @brief Add/Delete LISP IP forwarding entry. + * + * removal of forwarding entries for IP LISP overlay: + * + * @param[in] lgm Reference to @ref lisp_gpe_main_t. + * @param[in] a Parameters for building the forwarding entry. + * + * @return 0 on success. + */ static int -add_del_negative_fwd_entry (lisp_gpe_main_t * lgm, - vnet_lisp_gpe_add_del_fwd_entry_args_t * a) +del_ip_fwd_entry (lisp_gpe_main_t * lgm, + vnet_lisp_gpe_add_del_fwd_entry_args_t * a) { - ip_adjacency_t adj; - /* setup adjacency for eid */ - memset (&adj, 0, sizeof(adj)); - adj.n_adj = 1; - adj.explicit_fib_index = ~0; + lisp_gpe_fwd_entry_key_t key; + lisp_fwd_entry_t *lfe; + + lfe = find_fwd_entry (lgm, a, &key); + + if (NULL == lfe) + /* no such entry */ + return VNET_API_ERROR_INVALID_VALUE; + + del_ip_fwd_entry_i (lfe); - ip_prefix_t * dpref = &gid_address_ippref(&a->deid); - ip_prefix_t * spref = &gid_address_ippref(&a->seid); + return (0); +} - switch (a->action) +static void +make_mac_fib_key (BVT (clib_bihash_kv) * kv, u16 bd_index, u8 src_mac[6], + u8 dst_mac[6]) +{ + kv->key[0] = (((u64) bd_index) << 48) | mac_to_u64 (dst_mac); + kv->key[1] = mac_to_u64 (src_mac); + kv->key[2] = 0; +} + +/** + * @brief Lookup L2 SD FIB entry + * + * Does a vni + dest + source lookup in the L2 LISP FIB. If the lookup fails + * it tries a second time with source set to 0 (i.e., a simple dest lookup). + * + * @param[in] lgm Reference to @ref lisp_gpe_main_t. + * @param[in] bd_index Bridge domain index. + * @param[in] src_mac Source mac address. + * @param[in] dst_mac Destination mac address. + * + * @return index of mapping matching the lookup key. + */ +index_t +lisp_l2_fib_lookup (lisp_gpe_main_t * lgm, u16 bd_index, u8 src_mac[6], + u8 dst_mac[6]) +{ + int rv; + BVT (clib_bihash_kv) kv, value; + + make_mac_fib_key (&kv, bd_index, src_mac, dst_mac); + rv = BV (clib_bihash_search_inline_2) (&lgm->l2_fib, &kv, &value); + + /* no match, try with src 0, catch all for dst */ + if (rv != 0) { - case NO_ACTION: - /* TODO update timers? */ - case FORWARD_NATIVE: - /* TODO check if route/next-hop for eid exists in fib and add - * more specific for the eid with the next-hop found */ - case SEND_MAP_REQUEST: - /* insert tunnel that always sends map-request */ - adj.rewrite_header.sw_if_index = ~0; - adj.lookup_next_index = (u32) (ip_prefix_version(dpref) == IP4) ? - LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP: - LGPE_IP6_LOOKUP_NEXT_LISP_CP_LOOKUP; - /* add/delete route for prefix */ - return ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj, - a->is_add); - case DROP: - /* for drop fwd entries, just add route, no need to add encap tunnel */ - adj.lookup_next_index = (u32) (ip_prefix_version(dpref) == IP4 ? - LGPE_IP4_LOOKUP_NEXT_DROP : LGPE_IP6_LOOKUP_NEXT_DROP); - - /* add/delete route for prefix */ - return ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj, - a->is_add); - default: - return -1; + kv.key[1] = 0; + rv = BV (clib_bihash_search_inline_2) (&lgm->l2_fib, &kv, &value); + if (rv == 0) + return value.value; } + + return lisp_gpe_main.l2_lb_miss; } -int -vnet_lisp_gpe_add_del_fwd_entry (vnet_lisp_gpe_add_del_fwd_entry_args_t * a, - u32 * hw_if_indexp) +/** + * @brief Add/del L2 SD FIB entry + * + * Inserts value in L2 FIB keyed by vni + dest + source. If entry is + * overwritten the associated value is returned. + * + * @param[in] lgm Reference to @ref lisp_gpe_main_t. + * @param[in] bd_index Bridge domain index. + * @param[in] src_mac Source mac address. + * @param[in] dst_mac Destination mac address. + * @param[in] val Value to add. + * @param[in] is_add Add/del flag. + * + * @return ~0 or value of overwritten entry. + */ +u32 +lisp_l2_fib_add_del_entry (lisp_gpe_main_t * lgm, u16 bd_index, u8 src_mac[6], + u8 dst_mac[6], u32 val, u8 is_add) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - ip_adjacency_t adj, * adjp; - u32 adj_index, rv, tun_index = ~0; - ip_prefix_t * dpref, * spref; - uword * lookup_next_index, * lgpe_sw_if_index, * lnip; - u8 ip_ver; - - /* treat negative fwd entries separately */ - if (a->is_negative) - return add_del_negative_fwd_entry (lgm, a); - - dpref = &gid_address_ippref(&a->deid); - spref = &gid_address_ippref(&a->seid); - ip_ver = ip_prefix_version(dpref); - - /* add/del tunnel to tunnels pool and prepares rewrite */ - rv = add_del_ip_tunnel (a, &tun_index); - if (rv) - return rv; - - /* setup adjacency for eid */ - memset (&adj, 0, sizeof(adj)); - adj.n_adj = 1; - adj.explicit_fib_index = ~0; - - if (a->is_add) + BVT (clib_bihash_kv) kv, value; + u32 old_val = ~0; + + make_mac_fib_key (&kv, bd_index, src_mac, dst_mac); + + if (BV (clib_bihash_search) (&lgm->l2_fib, &kv, &value) == 0) + old_val = value.value; + + if (!is_add) + BV (clib_bihash_add_del) (&lgm->l2_fib, &kv, 0 /* is_add */ ); + else { - /* send packets that hit this adj to lisp-gpe interface output node in - * requested vrf. */ - lnip = ip_ver == IP4 ? - lgm->lgpe_ip4_lookup_next_index_by_table_id : - lgm->lgpe_ip6_lookup_next_index_by_table_id; - lookup_next_index = hash_get(lnip, a->table_id); - lgpe_sw_if_index = hash_get(lgm->lisp_gpe_hw_if_index_by_table_id, - a->table_id); - - /* the assumption is that the interface must've been created before - * programming the dp */ - ASSERT(lookup_next_index != 0); - ASSERT(lgpe_sw_if_index != 0); - - adj.lookup_next_index = lookup_next_index[0]; - adj.rewrite_header.node_index = tun_index; - adj.rewrite_header.sw_if_index = lgpe_sw_if_index[0]; + kv.value = val; + BV (clib_bihash_add_del) (&lgm->l2_fib, &kv, 1 /* is_add */ ); } + return old_val; +} - /* add/delete route for prefix */ - rv = ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj, - a->is_add); +static void +l2_fib_init (lisp_gpe_main_t * lgm) +{ + BV (clib_bihash_init) (&lgm->l2_fib, "l2 fib", + 1 << max_log2 (L2_FIB_DEFAULT_HASH_NUM_BUCKETS), + L2_FIB_DEFAULT_HASH_MEMORY_SIZE); + + /* + * the result from a 'miss' in a L2 Table + */ + lgm->l2_lb_miss = load_balance_create (1, DPO_PROTO_IP4, 0); + load_balance_set_bucket (lgm->l2_lb_miss, 0, drop_dpo_get (DPO_PROTO_IP4)); +} - /* check that everything worked */ - if (CLIB_DEBUG && a->is_add) - { - adj_index = ip_sd_fib_get_route (lgm, dpref, spref, a->table_id); - ASSERT(adj_index != 0); +/** + * @brief Add/Delete LISP L2 forwarding entry. + * + * Coordinates the creation/removal of forwarding entries for L2 LISP overlay: + * creates lisp-gpe tunnel and injects new entry in Source/Dest L2 FIB. + * + * @param[in] lgm Reference to @ref lisp_gpe_main_t. + * @param[in] a Parameters for building the forwarding entry. + * + * @return 0 on success. + */ +static int +add_del_l2_fwd_entry (lisp_gpe_main_t * lgm, + vnet_lisp_gpe_add_del_fwd_entry_args_t * a) +{ + /* lisp_gpe_fwd_entry_key_t key; */ + /* lisp_fwd_entry_t *lfe; */ + /* fib_protocol_t fproto; */ + /* uword *bd_indexp; */ + + /* bd_indexp = hash_get (bdm->bd_index_by_bd_id, a->bd_id); */ + /* if (!bd_indexp) */ + /* { */ + /* clib_warning ("bridge domain %d doesn't exist", a->bd_id); */ + /* return -1; */ + /* } */ + + /* lfe = find_fwd_entry(lgm, a, &key); */ + + /* if (NULL != lfe) */ + /* /\* don't support updates *\/ */ + /* return VNET_API_ERROR_INVALID_VALUE; */ + + /* int rv; */ + /* u32 tun_index; */ + /* fib_node_index_t old_path_list; */ + /* bd_main_t *bdm = &bd_main; */ + /* fib_route_path_t *rpaths; */ + /* lisp_gpe_tunnel_t *t; */ + /* const dpo_id_t *dpo; */ + /* index_t lbi; */ + + /* /\* create tunnel *\/ */ + /* rv = add_del_ip_tunnel (a, 1 /\* is_l2 *\/ , &tun_index, NULL); */ + /* if (rv) */ + /* return rv; */ + + /* bd_indexp = hash_get (bdm->bd_index_by_bd_id, a->bd_id); */ + /* if (!bd_indexp) */ + /* { */ + /* clib_warning ("bridge domain %d doesn't exist", a->bd_id); */ + /* return -1; */ + /* } */ + + /* t = pool_elt_at_index (lgm->tunnels, tun_index); */ + /* old_path_list = t->l2_path_list; */ + + /* if (LISP_NO_ACTION == t->action) */ + /* { */ + /* rpaths = lisp_gpe_mk_paths_for_sub_tunnels (t); */ + + /* t->l2_path_list = fib_path_list_create (FIB_PATH_LIST_FLAG_NONE, */ + /* rpaths); */ + + /* vec_free (rpaths); */ + /* fib_path_list_lock (t->l2_path_list); */ + + /* dpo = fib_path_list_contribute_forwarding (t->l2_path_list, */ + /* FIB_FORW_CHAIN_TYPE_UNICAST_IP); */ + /* lbi = dpo->dpoi_index; */ + /* } */ + /* else if (LISP_SEND_MAP_REQUEST == t->action) */ + /* { */ + /* lbi = lgm->l2_lb_cp_lkup; */ + /* } */ + /* else */ + /* { */ + /* lbi = lgm->l2_lb_miss; */ + /* } */ + /* fib_path_list_unlock (old_path_list); */ + + /* /\* add entry to l2 lisp fib *\/ */ + /* lisp_l2_fib_add_del_entry (lgm, bd_indexp[0], gid_address_mac (&a->lcl_eid), */ + /* gid_address_mac (&a->rmt_eid), lbi, a->is_add); */ + return 0; +} - adjp = ip_get_adjacency ((ip_ver == IP4) ? lgm->lm4 : lgm->lm6, - adj_index); +/** + * @brief Forwarding entry create/remove dispatcher. + * + * Calls l2 or l3 forwarding entry add/del function based on input data. + * + * @param[in] a Forwarding entry parameters. + * @param[out] hw_if_indexp NOT USED + * + * @return 0 on success. + */ +int +vnet_lisp_gpe_add_del_fwd_entry (vnet_lisp_gpe_add_del_fwd_entry_args_t * a, + u32 * hw_if_indexp) +{ + lisp_gpe_main_t *lgm = &lisp_gpe_main; + u8 type; - ASSERT(adjp != 0); - ASSERT(adjp->rewrite_header.node_index == tun_index); + if (vnet_lisp_gpe_enable_disable_status () == 0) + { + clib_warning ("LISP is disabled!"); + return VNET_API_ERROR_LISP_DISABLED; } - return rv; + type = gid_address_type (&a->rmt_eid); + switch (type) + { + case GID_ADDR_IP_PREFIX: + if (a->is_add) + return add_ip_fwd_entry (lgm, a); + else + return del_ip_fwd_entry (lgm, a); + break; + case GID_ADDR_MAC: + return add_del_l2_fwd_entry (lgm, a); + default: + clib_warning ("Forwarding entries for type %d not supported!", type); + return -1; + } } +/** CLI command to add/del forwarding entry. */ static clib_error_t * lisp_gpe_add_del_fwd_entry_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - unformat_input_t _line_input, * line_input = &_line_input; + unformat_input_t _line_input, *line_input = &_line_input; u8 is_add = 1; - ip_address_t slocator, dlocator, *slocators = 0, *dlocators = 0; - ip_prefix_t * prefp; - gid_address_t * eids = 0, eid; - clib_error_t * error = 0; - u32 i; - - prefp = &gid_address_ippref(&eid); + ip_address_t lloc, rloc; + clib_error_t *error = 0; + gid_address_t _reid, *reid = &_reid, _leid, *leid = &_leid; + u8 reid_set = 0, leid_set = 0, is_negative = 0, vrf_set = 0, vni_set = 0; + u32 vni, vrf, action = ~0, p, w; + locator_pair_t pair, *pairs = 0; + int rv; /* Get a line of input. */ - if (! unformat_user (input, unformat_line_input, line_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; + is_add = 0; else if (unformat (line_input, "add")) - is_add = 1; - else if (unformat (line_input, "eid %U slocator %U dlocator %U", - unformat_ip_prefix, prefp, - unformat_ip_address, &slocator, - unformat_ip_address, &dlocator)) - { - vec_add1 (eids, eid); - vec_add1 (slocators, slocator); - vec_add1 (dlocators, dlocator); - } + is_add = 1; + else if (unformat (line_input, "leid %U", unformat_gid_address, leid)) + { + leid_set = 1; + } + else if (unformat (line_input, "reid %U", unformat_gid_address, reid)) + { + reid_set = 1; + } + else if (unformat (line_input, "vni %u", &vni)) + { + gid_address_vni (leid) = vni; + gid_address_vni (reid) = vni; + vni_set = 1; + } + else if (unformat (line_input, "vrf %u", &vrf)) + { + vrf_set = 1; + } + else if (unformat (line_input, "negative action %U", + unformat_negative_mapping_action, &action)) + { + is_negative = 1; + } + else if (unformat (line_input, "loc-pair %U %U p %d w %d", + unformat_ip_address, &lloc, + unformat_ip_address, &rloc, &p, &w)) + { + pair.lcl_loc = lloc; + pair.rmt_loc = rloc; + pair.priority = p; + pair.weight = w; + vec_add1 (pairs, pair); + } else - { - error = unformat_parse_error (line_input); - goto done; - } + { + error = unformat_parse_error (line_input); + goto done; + } } unformat_free (line_input); - if (vec_len (eids) + vec_len (slocators) == 0) + if (!vni_set || !vrf_set) { - error = clib_error_return (0, "expected ip4/ip6 eids/locators."); + error = clib_error_return (0, "vni and vrf must be set!"); goto done; } - if (vec_len (eids) != vec_len (slocators)) + if (!reid_set) { - error = clib_error_return (0, "number of eids not equal to that of " - "locators."); + error = clib_error_return (0, "remote eid must be set!"); goto done; } - for (i = 0; i < vec_len(eids); i++) + if (is_negative) { - vnet_lisp_gpe_add_del_fwd_entry_args_t a; - memset (&a, 0, sizeof(a)); - - a.is_add = is_add; - a.deid = eids[i]; - a.slocator = slocators[i]; - a.dlocator = dlocators[i]; - vnet_lisp_gpe_add_del_fwd_entry (&a, 0); + if (~0 == action) + { + error = clib_error_return (0, "no action set for negative tunnel!"); + goto done; + } + } + else + { + if (vec_len (pairs) == 0) + { + error = clib_error_return (0, "expected ip4/ip6 locators."); + goto done; + } } - done: - vec_free(eids); - vec_free(slocators); - vec_free(dlocators); + if (!leid_set) + { + /* if leid not set, make sure it's the same AFI like reid */ + gid_address_type (leid) = gid_address_type (reid); + if (GID_ADDR_IP_PREFIX == gid_address_type (reid)) + gid_address_ip_version (leid) = gid_address_ip_version (reid); + } + + /* add fwd entry */ + vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a; + memset (a, 0, sizeof (a[0])); + + a->is_add = is_add; + a->vni = vni; + a->table_id = vrf; + gid_address_copy (&a->lcl_eid, leid); + gid_address_copy (&a->rmt_eid, reid); + a->locator_pairs = pairs; + + rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0); + if (0 != rv) + { + error = clib_error_return (0, "failed to %s gpe tunnel!", + is_add ? "add" : "delete"); + } + +done: + vec_free (pairs); return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (lisp_gpe_add_del_fwd_entry_command, static) = { - .path = "lisp gpe maptunnel", - .short_help = "lisp gpe maptunnel eid sloc " - "dloc [del]", + .path = "lisp gpe entry", + .short_help = "lisp gpe entry add/del vni vrf [leid ]" + "reid [loc-pair p w ] " + "[negative action ]", .function = lisp_gpe_add_del_fwd_entry_command_fn, }; +/* *INDENT-ON* */ static u8 * -format_decap_next (u8 * s, va_list * args) +format_lisp_fwd_path (u8 * s, va_list ap) { - u32 next_index = va_arg (*args, u32); + lisp_fwd_path_t *lfp = va_arg (ap, lisp_fwd_path_t *); - switch (next_index) - { - case LISP_GPE_INPUT_NEXT_DROP: - return format (s, "drop"); - case LISP_GPE_INPUT_NEXT_IP4_INPUT: - return format (s, "ip4"); - case LISP_GPE_INPUT_NEXT_IP6_INPUT: - return format (s, "ip6"); - default: - return format (s, "unknown %d", next_index); - } - return s; + s = format (s, "pirority:%d weight:%d ", lfp->priority, lfp->weight); + s = format (s, "adj:[%U]\n", + format_lisp_gpe_adjacency, + lisp_gpe_adjacency_get (lfp->lisp_adj), + LISP_GPE_ADJ_FORMAT_FLAG_NONE); + + return (s); } -u8 * -format_lisp_gpe_tunnel (u8 * s, va_list * args) +static u8 * +format_lisp_gpe_fwd_entry (u8 * s, va_list ap) { - lisp_gpe_tunnel_t * t = va_arg (*args, lisp_gpe_tunnel_t *); - lisp_gpe_main_t * lgm = &lisp_gpe_main; - - s = format (s, - "[%d] %U (src) %U (dst) fibs: encap %d, decap %d", - t - lgm->tunnels, - format_ip_address, &t->src, - format_ip_address, &t->dst, - t->encap_fib_index, - t->decap_fib_index); + lisp_fwd_entry_t *lfe = va_arg (ap, lisp_fwd_entry_t *); - s = format (s, " decap next %U\n", format_decap_next, t->decap_next_index); - s = format (s, "lisp ver %d ", (t->ver_res>>6)); - -#define _(n,v) if (t->flags & v) s = format (s, "%s-bit ", #n); - foreach_lisp_gpe_flag_bit; -#undef _ + s = format (s, "VNI:%d VRF:%d EID: %U -> %U", + lfe->key->vni, lfe->eid_table_id, + format_fid_address, &lfe->key->lcl, + format_fid_address, &lfe->key->rmt); + if (LISP_FWD_ENTRY_TYPE_NEGATIVE == lfe->type) + { + s = format (s, "\n Negative - action:%U", + format_negative_mapping_action, lfe->action); + } + else + { + lisp_fwd_path_t *path; - s = format (s, "next_protocol %d ver_res %x res %x\n", - t->next_protocol, t->ver_res, t->res); + s = format (s, "\n via:"); + vec_foreach (path, lfe->paths) + { + s = format (s, "\n %U", format_lisp_fwd_path, path); + } + } - s = format (s, "iid %d (0x%x)\n", t->vni, t->vni); - return s; + return (s); } static clib_error_t * -show_lisp_gpe_tunnel_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +lisp_gpe_fwd_entry_show (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - lisp_gpe_tunnel_t * t; - - if (pool_elts (lgm->tunnels) == 0) - vlib_cli_output (vm, "No lisp-gpe tunnels configured..."); + lisp_fwd_entry_t *lfe; - pool_foreach (t, lgm->tunnels, +/* *INDENT-OFF* */ + pool_foreach (lfe, lisp_fwd_entry_pool, ({ - vlib_cli_output (vm, "%U", format_lisp_gpe_tunnel, t); + vlib_cli_output (vm, "%U", format_lisp_gpe_fwd_entry, lfe); })); - - return 0; +/* *INDENT-ON* */ + + return (NULL); } -VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) = { - .path = "show lisp gpe tunnel", - .function = show_lisp_gpe_tunnel_command_fn, +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (lisp_gpe_fwd_entry_show_command, static) = { + .path = "show lisp gpe entry", + .short_help = "show lisp gpe entry vni vrf [leid ] reid ", + .function = lisp_gpe_fwd_entry_show, }; +/* *INDENT-ON* */ +/** Check if LISP-GPE is enabled. */ u8 -vnet_lisp_gpe_enable_disable_status(void) +vnet_lisp_gpe_enable_disable_status (void) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; + lisp_gpe_main_t *lgm = &lisp_gpe_main; return lgm->is_en; } +/** Enable/disable LISP-GPE. */ clib_error_t * vnet_lisp_gpe_enable_disable (vnet_lisp_gpe_enable_disable_args_t * a) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - vnet_main_t * vnm = lgm->vnet_main; + lisp_gpe_main_t *lgm = &lisp_gpe_main; if (a->is_en) { - /* add lgpe_ip4_lookup as possible next_node for ip4 lookup */ - if (lgm->ip4_lookup_next_lgpe_ip4_lookup == ~0) - { - lgm->ip4_lookup_next_lgpe_ip4_lookup = vlib_node_add_next ( - vnm->vlib_main, ip4_lookup_node.index, - lgpe_ip4_lookup_node.index); - } - /* add lgpe_ip6_lookup as possible next_node for ip6 lookup */ - if (lgm->ip6_lookup_next_lgpe_ip6_lookup == ~0) - { - lgm->ip6_lookup_next_lgpe_ip6_lookup = vlib_node_add_next ( - vnm->vlib_main, ip6_lookup_node.index, - lgpe_ip6_lookup_node.index); - } - else - { - /* ask cp to re-add ifaces and defaults */ - } - lgm->is_en = 1; } else { - CLIB_UNUSED(uword * val); - hash_pair_t * p; - u32 * table_ids = 0, * table_id; - lisp_gpe_tunnel_key_t * tunnels = 0, * tunnel; - vnet_lisp_gpe_add_del_fwd_entry_args_t _at, * at = &_at; - vnet_lisp_gpe_add_del_iface_args_t _ai, * ai= &_ai; - - /* remove all tunnels */ - mhash_foreach(tunnel, val, &lgm->lisp_gpe_tunnel_by_key, ({ - vec_add1(tunnels, tunnel[0]); + CLIB_UNUSED (uword * val); + hash_pair_t *p; + u32 *dp_tables = 0, *dp_table; + vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai; + lisp_fwd_entry_t *lfe; + + /* remove all entries */ + /* *INDENT-OFF* */ + pool_foreach (lfe, lisp_fwd_entry_pool, + ({ + del_ip_fwd_entry_i (lfe); + })); + /* *INDENT-ON* */ + + /* disable all l3 ifaces */ + + /* *INDENT-OFF* */ + hash_foreach_pair(p, lgm->l3_ifaces.hw_if_index_by_dp_table, ({ + vec_add1(dp_tables, p->key); })); + /* *INDENT-ON* */ + + vec_foreach (dp_table, dp_tables) + { + ai->is_add = 0; + ai->table_id = dp_table[0]; + ai->is_l2 = 0; - vec_foreach(tunnel, tunnels) { - memset(at, 0, sizeof(at[0])); - at->is_add = 0; - gid_address_type(&at->deid) = GID_ADDR_IP_PREFIX; - ip_prefix_copy(&gid_address_ippref(&at->deid), &tunnel->eid); - ip_address_copy(&at->dlocator, &tunnel->dst_loc); - vnet_lisp_gpe_add_del_fwd_entry (at, 0); + /* disables interface and removes defaults */ + vnet_lisp_gpe_add_del_iface (ai, 0); } - vec_free(tunnels); - /* disable all ifaces */ - hash_foreach_pair(p, lgm->lisp_gpe_hw_if_index_by_table_id, ({ - vec_add1(table_ids, p->key); + /* disable all l2 ifaces */ + _vec_len (dp_tables) = 0; + + /* *INDENT-OFF* */ + hash_foreach_pair(p, lgm->l2_ifaces.hw_if_index_by_dp_table, ({ + vec_add1(dp_tables, p->key); })); + /* *INDENT-ON* */ - vec_foreach(table_id, table_ids) { - ai->is_add = 0; - ai->table_id = table_id[0]; + vec_foreach (dp_table, dp_tables) + { + ai->is_add = 0; + ai->bd_id = dp_table[0]; + ai->is_l2 = 1; - /* disables interface and removes defaults */ - vnet_lisp_gpe_add_del_iface(ai, 0); + /* disables interface and removes defaults */ + vnet_lisp_gpe_add_del_iface (ai, 0); } - vec_free(table_ids); + + vec_free (dp_tables); lgm->is_en = 0; } return 0; } +/** CLI command to enable/disable LISP-GPE. */ static clib_error_t * -lisp_gpe_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) +lisp_gpe_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; + unformat_input_t _line_input, *line_input = &_line_input; u8 is_en = 1; - vnet_lisp_gpe_enable_disable_args_t _a, * a = &_a; + vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a; /* Get a line of input. */ - if (! unformat_user (input, unformat_line_input, line_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_en = 1; + is_en = 1; else if (unformat (line_input, "disable")) - is_en = 0; + is_en = 0; else - { - return clib_error_return (0, "parse error: '%U'", - format_unformat_error, line_input); - } + { + return clib_error_return (0, "parse error: '%U'", + format_unformat_error, line_input); + } } a->is_en = is_en; return vnet_lisp_gpe_enable_disable (a); } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (enable_disable_lisp_gpe_command, static) = { .path = "lisp gpe", .short_help = "lisp gpe [enable|disable]", .function = lisp_gpe_enable_disable_command_fn, }; +/* *INDENT-ON* */ +/** CLI command to show LISP-GPE interfaces. */ static clib_error_t * lisp_show_iface_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - hash_pair_t * p; + lisp_gpe_main_t *lgm = &lisp_gpe_main; + hash_pair_t *p; vlib_cli_output (vm, "%=10s%=12s", "vrf", "hw_if_index"); - hash_foreach_pair (p, lgm->lisp_gpe_hw_if_index_by_table_id, ({ + + /* *INDENT-OFF* */ + hash_foreach_pair (p, lgm->l3_ifaces.hw_if_index_by_dp_table, ({ vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]); })); + /* *INDENT-ON* */ + + if (0 != lgm->l2_ifaces.hw_if_index_by_dp_table) + { + vlib_cli_output (vm, "%=10s%=12s", "bd_id", "hw_if_index"); + /* *INDENT-OFF* */ + hash_foreach_pair (p, lgm->l2_ifaces.hw_if_index_by_dp_table, ({ + vlib_cli_output (vm, "%=10d%=10d", p->key, p->value[0]); + })); + /* *INDENT-ON* */ + } return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (lisp_show_iface_command) = { .path = "show lisp gpe interface", .short_help = "show lisp gpe interface", .function = lisp_show_iface_command_fn, }; +/* *INDENT-ON* */ + +/** Format LISP-GPE status. */ +u8 * +format_vnet_lisp_gpe_status (u8 * s, va_list * args) +{ + lisp_gpe_main_t *lgm = &lisp_gpe_main; + return format (s, "%s", lgm->is_en ? "enabled" : "disabled"); +} + +/** LISP-GPE init function. */ clib_error_t * -lisp_gpe_init (vlib_main_t *vm) +lisp_gpe_init (vlib_main_t * vm) { - lisp_gpe_main_t * lgm = &lisp_gpe_main; - clib_error_t * error = 0; + lisp_gpe_main_t *lgm = &lisp_gpe_main; + clib_error_t *error = 0; if ((error = vlib_call_init_function (vm, ip_main_init))) return error; @@ -585,30 +868,32 @@ lisp_gpe_init (vlib_main_t *vm) if ((error = vlib_call_init_function (vm, ip4_lookup_init))) return error; - lgm->vnet_main = vnet_get_main(); + lgm->vnet_main = vnet_get_main (); lgm->vlib_main = vm; lgm->im4 = &ip4_main; lgm->im6 = &ip6_main; lgm->lm4 = &ip4_main.lookup_main; lgm->lm6 = &ip6_main.lookup_main; - lgm->ip4_lookup_next_lgpe_ip4_lookup = ~0; - lgm->ip6_lookup_next_lgpe_ip6_lookup = ~0; - mhash_init (&lgm->lisp_gpe_tunnel_by_key, sizeof(uword), - sizeof(lisp_gpe_tunnel_key_t)); + lisp_gpe_fwd_entries = hash_create_mem (0, + sizeof (lisp_gpe_fwd_entry_key_t), + sizeof (uword)); + + l2_fib_init (lgm); - udp_register_dst_port (vm, UDP_DST_PORT_lisp_gpe, - lisp_gpe_ip4_input_node.index, 1 /* is_ip4 */); + udp_register_dst_port (vm, UDP_DST_PORT_lisp_gpe, + lisp_gpe_ip4_input_node.index, 1 /* is_ip4 */ ); udp_register_dst_port (vm, UDP_DST_PORT_lisp_gpe6, - lisp_gpe_ip6_input_node.index, 0 /* is_ip4 */); + lisp_gpe_ip6_input_node.index, 0 /* is_ip4 */ ); return 0; } -u8 * -format_vnet_lisp_gpe_status (u8 * s, va_list * args) -{ - lisp_gpe_main_t * lgm = &lisp_gpe_main; - return format (s, "%s", lgm->is_en ? "enabled" : "disabled"); -} +VLIB_INIT_FUNCTION (lisp_gpe_init); -VLIB_INIT_FUNCTION(lisp_gpe_init); +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */