diff options
Diffstat (limited to 'hicn-plugin/src/route.c')
| -rw-r--r-- | hicn-plugin/src/route.c | 587 |
1 files changed, 289 insertions, 298 deletions
diff --git a/hicn-plugin/src/route.c b/hicn-plugin/src/route.c index 6db52f2fd..34a94936e 100644 --- a/hicn-plugin/src/route.c +++ b/hicn-plugin/src/route.c @@ -34,20 +34,20 @@ #include "infra.h" #include "udp_tunnels/udp_tunnel.h" -#define FIB_SOURCE_HICN 0x04 //Right after the FIB_SOURCE_INTERFACE priority +#define FIB_SOURCE_HICN 0x04 // Right after the FIB_SOURCE_INTERFACE priority fib_source_t hicn_fib_src; fib_node_type_t hicn_fib_node_type; -ip4_address_t localhost4 = {0}; -ip6_address_t localhost6 = {0}; +ip4_address_t localhost4 = { 0 }; +ip6_address_t localhost6 = { 0 }; int -hicn_route_get_dpo (const fib_prefix_t * prefix, - const dpo_id_t ** hicn_dpo, u32 * fib_index) +hicn_route_get_dpo (const fib_prefix_t *prefix, const dpo_id_t **hicn_dpo, + u32 *fib_index) { - //fib_prefix_t fib_pfx; + // fib_prefix_t fib_pfx; const dpo_id_t *load_balance_dpo_id; const dpo_id_t *former_dpo_id; int found = 0, ret = HICN_ERROR_ROUTE_NOT_FOUND; @@ -58,9 +58,8 @@ hicn_route_get_dpo (const fib_prefix_t * prefix, * ASSUMPTION: we use table 0 which is the default table and it is * already existing and locked */ - *fib_index = fib_table_find_or_create_and_lock (prefix->fp_proto, - HICN_FIB_TABLE, - hicn_fib_src); + *fib_index = fib_table_find_or_create_and_lock ( + prefix->fp_proto, HICN_FIB_TABLE, hicn_fib_src); fib_entry_index = fib_table_lookup_exact_match (*fib_index, prefix); if (fib_entry_index != FIB_NODE_INDEX_INVALID) @@ -103,7 +102,7 @@ hicn_route_get_dpo (const fib_prefix_t * prefix, } int -hicn_route_set_strategy (fib_prefix_t * prefix, u8 strategy_id) +hicn_route_set_strategy (fib_prefix_t *prefix, u8 strategy_id) { const dpo_id_t *hicn_dpo_id; dpo_id_t new_dpo_id = DPO_INVALID; @@ -125,16 +124,15 @@ hicn_route_set_strategy (fib_prefix_t * prefix, u8 strategy_id) return HICN_ERROR_STRATEGY_NOT_FOUND; /* Create a new dpo for the new strategy */ - new_dpo_vft->hicn_dpo_create (hicn_dpo_id->dpoi_proto, - old_hicn_dpo_ctx->next_hops, - old_hicn_dpo_ctx->entry_count, - &new_hicn_dpo_idx); + new_dpo_vft->hicn_dpo_create ( + hicn_dpo_id->dpoi_proto, old_hicn_dpo_ctx->next_hops, + old_hicn_dpo_ctx->entry_count, &new_hicn_dpo_idx); /* the value we got when we registered */ - dpo_set (&new_dpo_id, - new_dpo_vft->hicn_dpo_get_type (), + dpo_set (&new_dpo_id, new_dpo_vft->hicn_dpo_get_type (), (ip46_address_is_ip4 (&prefix->fp_addr) ? DPO_PROTO_IP4 : - DPO_PROTO_IP6), new_hicn_dpo_idx); + DPO_PROTO_IP6), + new_hicn_dpo_idx); /* Here is where we create the "via" like route */ /* @@ -143,253 +141,247 @@ hicn_route_set_strategy (fib_prefix_t * prefix, u8 strategy_id) * that is adding them -- no easy explanation at this time… */ fib_node_index_t new_fib_node_index = - fib_table_entry_special_dpo_update (fib_index, - prefix, - hicn_fib_src, + fib_table_entry_special_dpo_update (fib_index, prefix, hicn_fib_src, FIB_ENTRY_FLAG_EXCLUSIVE, &new_dpo_id); dpo_unlock (&new_dpo_id); - ret = - (new_fib_node_index != - FIB_NODE_INDEX_INVALID) ? HICN_ERROR_NONE : - HICN_ERROR_ROUTE_NOT_UPDATED; + ret = (new_fib_node_index != FIB_NODE_INDEX_INVALID) ? + HICN_ERROR_NONE : + HICN_ERROR_ROUTE_NOT_UPDATED; } - //Remember to remove the lock from the table when removing the entry + // Remember to remove the lock from the table when removing the entry return ret; - } int -ip_nh_add_helper (fib_protocol_t fib_proto, const fib_prefix_t * rpfx, ip46_address_t * nh, u32 sw_if) +ip_nh_add_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx, + ip46_address_t *nh, u32 sw_if) { fib_route_path_t *rpaths = NULL, rpath; - u32 fib_index = fib_table_find(fib_proto, 0); + u32 fib_index = fib_table_find (fib_proto, 0); - clib_memset(&rpath, 0, sizeof(rpath)); + clib_memset (&rpath, 0, sizeof (rpath)); rpath.frp_weight = 1; rpath.frp_sw_if_index = sw_if; rpath.frp_addr = *nh; - rpath.frp_proto = ip46_address_is_ip4(nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6; + rpath.frp_proto = ip46_address_is_ip4 (nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6; - vec_add1(rpaths, rpath); + vec_add1 (rpaths, rpath); - fib_table_entry_path_add2 (fib_index, - rpfx, - FIB_SOURCE_CLI, - FIB_ENTRY_FLAG_NONE, rpaths); + fib_table_entry_path_add2 (fib_index, rpfx, FIB_SOURCE_CLI, + FIB_ENTRY_FLAG_NONE, rpaths); return 0; } int -ip_nh_del_helper (fib_protocol_t fib_proto, const fib_prefix_t * rpfx, ip46_address_t * nh, u32 sw_if) +ip_nh_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx, + ip46_address_t *nh, u32 sw_if) { fib_route_path_t *rpaths = NULL, rpath; - u32 fib_index = fib_table_find(fib_proto, 0); + u32 fib_index = fib_table_find (fib_proto, 0); - clib_memset(&rpath, 0, sizeof(rpath)); + clib_memset (&rpath, 0, sizeof (rpath)); rpath.frp_weight = 1; rpath.frp_sw_if_index = sw_if; rpath.frp_addr = *nh; - rpath.frp_proto = ip46_address_is_ip4(nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6; + rpath.frp_proto = ip46_address_is_ip4 (nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6; - vec_add1(rpaths, rpath); + vec_add1 (rpaths, rpath); - fib_table_entry_path_remove2 (fib_index, - rpfx, - FIB_SOURCE_CLI, - rpaths); + fib_table_entry_path_remove2 (fib_index, rpfx, FIB_SOURCE_CLI, rpaths); return 0; } - -static ip46_address_t * get_address(ip46_address_t * nh, u32 sw_if, fib_protocol_t proto) +static ip46_address_t * +get_address (ip46_address_t *nh, u32 sw_if, fib_protocol_t proto) { - ip46_address_t * local_address = calloc(1, sizeof(ip46_address_t)); + ip46_address_t *local_address = calloc (1, sizeof (ip46_address_t)); if (proto == FIB_PROTOCOL_IP4) { ip_interface_address_t *interface_address; - ip4_address_t *addr = - ip4_interface_address_matching_destination (&ip4_main, - &nh->ip4, - sw_if, - &interface_address); + ip4_address_t *addr = ip4_interface_address_matching_destination ( + &ip4_main, &nh->ip4, sw_if, &interface_address); if (addr == NULL) - addr = ip4_interface_first_address (&ip4_main, - sw_if, - &interface_address); + addr = + ip4_interface_first_address (&ip4_main, sw_if, &interface_address); if (addr != NULL) - ip46_address_set_ip4 (local_address, addr); + ip46_address_set_ip4 (local_address, addr); } else if (proto == FIB_PROTOCOL_IP6) { ip_interface_address_t *interface_address; - ip6_interface_address_matching_destination (&ip6_main, - &nh->ip6, - sw_if, - &interface_address); + ip6_interface_address_matching_destination (&ip6_main, &nh->ip6, sw_if, + &interface_address); ip6_address_t *addr = NULL; if (interface_address != NULL) - addr = - (ip6_address_t *) - ip_interface_address_get_address (&ip6_main.lookup_main, - interface_address); + addr = (ip6_address_t *) ip_interface_address_get_address ( + &ip6_main.lookup_main, interface_address); if (addr == NULL) - addr = ip6_interface_first_address (&ip6_main, sw_if); + addr = ip6_interface_first_address (&ip6_main, sw_if); if (addr != NULL) - ip46_address_set_ip6 (local_address, addr); + ip46_address_set_ip6 (local_address, addr); } return local_address; } static void -sync_hicn_fib_entry(hicn_dpo_ctx_t *fib_entry) +sync_hicn_fib_entry (hicn_dpo_ctx_t *fib_entry) { - const dpo_id_t * dpo_loadbalance = fib_entry_contribute_ip_forwarding (fib_entry->fib_entry_index); - const load_balance_t *lb0 = load_balance_get(dpo_loadbalance->dpoi_index); - index_t hicn_fib_entry_index = hicn_strategy_dpo_ctx_get_index(fib_entry); - hicn_face_id_t * vec_faces = 0; + const dpo_id_t *dpo_loadbalance = + fib_entry_contribute_ip_forwarding (fib_entry->fib_entry_index); + const load_balance_t *lb0 = load_balance_get (dpo_loadbalance->dpoi_index); + index_t hicn_fib_entry_index = hicn_strategy_dpo_ctx_get_index (fib_entry); + hicn_face_id_t *vec_faces = 0; dpo_id_t temp = DPO_INVALID; const dpo_id_t *former_dpo = &temp; int index = 0; -#define ADD_FACE(nh) \ - do { \ - /* Careful, this adds a lock on the face if it exists */ \ - hicn_face_add(dpo, nh, sw_if, &face_id, 0); \ - vec_validate(vec_faces, index); \ - vec_faces[index] = face_id; \ - (index)++; \ - \ - /* Face creation can realloc load_balance_t? Seem the fib_tracking does so. */ \ - dpo_loadbalance = fib_entry_contribute_ip_forwarding (fib_entry->fib_entry_index); \ - lb0 = load_balance_get(dpo_loadbalance->dpoi_index); \ - } while (0) \ - - for (int j = 0; j < lb0->lb_n_buckets; j++) { - const dpo_id_t * dpo = load_balance_get_bucket_i(lb0,j); - - int dpo_comparison = dpo_cmp(former_dpo, dpo); - former_dpo = dpo; - /* - * Loadbalancing in ip replicate the dpo in multiple buckets - * in order to honor the assigned weights. - */ - if (dpo_comparison == 0) - continue; - - u32 sw_if = ~0; - ip46_address_t * nh = NULL; - hicn_face_id_t face_id = HICN_FACE_NULL; - - if (dpo_is_adj(dpo)) - { - ip_adjacency_t * adj = adj_get (dpo->dpoi_index); - sw_if = adj->rewrite_header.sw_if_index; - nh = get_address (&(adj->sub_type.nbr.next_hop), sw_if, fib_entry->proto); - ADD_FACE(nh); - } - else if (dpo->dpoi_type == dpo_type_udp_ip4 || dpo->dpoi_type == dpo_type_udp_ip6) - { - u8 proto = dpo->dpoi_type == dpo_type_udp_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; - ip46_address_t _nh = {0}; - nh = &_nh; - switch (dpo->dpoi_proto) - { - case FIB_PROTOCOL_IP6: - case FIB_PROTOCOL_IP4: - /** - * Independently of the type of tunnel, encapsulated packet - * can be either v6 or v4, so we need to create 2 faces for each - * version. Tunneled hicn packet MUST have locator set to the loopback - * address, so ::1 for IPv6 and 127.0.0.1 for IPv4. - */ - ip46_address_set_ip6(nh, &localhost6); - ADD_FACE(nh); - ip46_address_set_ip4(nh, &localhost4); - ADD_FACE(nh); - break; - default: - continue; - } - udp_tunnel_add_existing (dpo->dpoi_index, proto); - } - } - - const hicn_dpo_vft_t * strategy_vft = hicn_dpo_get_vft(fib_entry->dpo_type); +#define ADD_FACE(nh) \ + do \ + { \ + /* Careful, this adds a lock on the face if it exists */ \ + hicn_face_add (dpo, nh, sw_if, &face_id, 0); \ + vec_validate (vec_faces, index); \ + vec_faces[index] = face_id; \ + (index)++; \ + \ + /* Face creation can realloc load_balance_t? Seem the fib_tracking does \ + * so. */ \ + dpo_loadbalance = \ + fib_entry_contribute_ip_forwarding (fib_entry->fib_entry_index); \ + lb0 = load_balance_get (dpo_loadbalance->dpoi_index); \ + } \ + while (0) + + for (int j = 0; j < lb0->lb_n_buckets; j++) + { + const dpo_id_t *dpo = load_balance_get_bucket_i (lb0, j); + + int dpo_comparison = dpo_cmp (former_dpo, dpo); + former_dpo = dpo; + /* + * Loadbalancing in ip replicate the dpo in multiple buckets + * in order to honor the assigned weights. + */ + if (dpo_comparison == 0) + continue; + + u32 sw_if = ~0; + ip46_address_t *nh = NULL; + hicn_face_id_t face_id = HICN_FACE_NULL; + + if (dpo_is_adj (dpo)) + { + ip_adjacency_t *adj = adj_get (dpo->dpoi_index); + sw_if = adj->rewrite_header.sw_if_index; + nh = get_address (&(adj->sub_type.nbr.next_hop), sw_if, + fib_entry->proto); + ADD_FACE (nh); + } + else if (dpo->dpoi_type == dpo_type_udp_ip4 || + dpo->dpoi_type == dpo_type_udp_ip6) + { + u8 proto = dpo->dpoi_type == dpo_type_udp_ip4 ? FIB_PROTOCOL_IP4 : + FIB_PROTOCOL_IP6; + ip46_address_t _nh = { 0 }; + nh = &_nh; + switch (dpo->dpoi_proto) + { + case FIB_PROTOCOL_IP6: + case FIB_PROTOCOL_IP4: + /** + * Independently of the type of tunnel, encapsulated packet + * can be either v6 or v4, so we need to create 2 faces for each + * version. Tunneled hicn packet MUST have locator set to the + * loopback address, so ::1 for IPv6 and 127.0.0.1 for IPv4. + */ + ip46_address_set_ip6 (nh, &localhost6); + ADD_FACE (nh); + ip46_address_set_ip4 (nh, &localhost4); + ADD_FACE (nh); + break; + default: + continue; + } + udp_tunnel_add_existing (dpo->dpoi_index, proto); + } + } + + const hicn_dpo_vft_t *strategy_vft = hicn_dpo_get_vft (fib_entry->dpo_type); int i = 0; while (i < fib_entry->entry_count) { - u32 idx_nh = vec_search(vec_faces, fib_entry->next_hops[i]); + u32 idx_nh = vec_search (vec_faces, fib_entry->next_hops[i]); if (idx_nh == ~0) - { - strategy_vft->hicn_dpo_del_nh(fib_entry->next_hops[i], hicn_fib_entry_index); - } + { + strategy_vft->hicn_dpo_del_nh (fib_entry->next_hops[i], + hicn_fib_entry_index); + } else - { - vec_del1(vec_faces, idx_nh); + { + vec_del1 (vec_faces, idx_nh); - /* Remove the lock added by hicn_face_add */ - hicn_face_unlock_with_id (fib_entry->next_hops[i]); - i++; - } + /* Remove the lock added by hicn_face_add */ + hicn_face_unlock_with_id (fib_entry->next_hops[i]); + i++; + } } hicn_face_id_t *face_id; - vec_foreach(face_id, vec_faces) + vec_foreach (face_id, vec_faces) { - strategy_vft->hicn_dpo_add_update_nh(*face_id, hicn_fib_entry_index); + strategy_vft->hicn_dpo_add_update_nh (*face_id, hicn_fib_entry_index); /* Remove the lock added by hicn_face_add */ hicn_face_unlock_with_id (*face_id); - } - vec_free(vec_faces); + vec_free (vec_faces); } static void enable_disable_data_receiving (fib_protocol_t proto, u32 sw_if, u8 is_enable) { if (proto == FIB_PROTOCOL_IP4 && sw_if != ~0) - vnet_feature_enable_disable ("ip4-local", "hicn-data-input-ip4", - sw_if, is_enable, 0, 0); + vnet_feature_enable_disable ("ip4-local", "hicn-data-input-ip4", sw_if, + is_enable, 0, 0); else if (proto == FIB_PROTOCOL_IP6 && sw_if != ~0) - vnet_feature_enable_disable ("ip6-local", "hicn-data-input-ip6", - sw_if, is_enable, 0, 0); - + vnet_feature_enable_disable ("ip6-local", "hicn-data-input-ip6", sw_if, + is_enable, 0, 0); } -walk_rc_t enable_data_receiving_new_fib_entry (vnet_main_t * vnm, - vnet_sw_interface_t * si, - void *ctx) +walk_rc_t +enable_data_receiving_new_fib_entry (vnet_main_t *vnm, vnet_sw_interface_t *si, + void *ctx) { fib_protocol_t *proto = (fib_protocol_t *) ctx; - enable_disable_data_receiving(*proto, si->sw_if_index, 1); + enable_disable_data_receiving (*proto, si->sw_if_index, 1); return (WALK_CONTINUE); } -walk_rc_t disable_data_receiving_rm_fib_entry (vnet_main_t * vnm, - vnet_sw_interface_t * si, - void *ctx) +walk_rc_t +disable_data_receiving_rm_fib_entry (vnet_main_t *vnm, vnet_sw_interface_t *si, + void *ctx) { fib_protocol_t *proto = (fib_protocol_t *) ctx; - enable_disable_data_receiving(*proto, si->sw_if_index, 0); + enable_disable_data_receiving (*proto, si->sw_if_index, 0); return (WALK_CONTINUE); - } +} int -hicn_route_enable (fib_prefix_t *prefix) { +hicn_route_enable (fib_prefix_t *prefix) +{ int ret = HICN_ERROR_NONE; fib_node_index_t fib_entry_index; @@ -399,7 +391,7 @@ hicn_route_enable (fib_prefix_t *prefix) { * ASSUMPTION: we use table 0 which is the default table and it is * already existing and locked */ - u32 fib_index = fib_table_find(prefix->fp_proto, 0); + u32 fib_index = fib_table_find (prefix->fp_proto, 0); fib_entry_index = fib_table_lookup_exact_match (fib_index, prefix); @@ -407,43 +399,43 @@ hicn_route_enable (fib_prefix_t *prefix) { { fib_entry_index = fib_table_lookup (fib_index, prefix); - fib_route_path_t * paths = fib_entry_encode(fib_entry_index); + fib_route_path_t *paths = fib_entry_encode (fib_entry_index); - fib_table_entry_path_add2(fib_index, prefix, FIB_SOURCE_CLI, FIB_ENTRY_FLAG_NONE, paths); + fib_table_entry_path_add2 (fib_index, prefix, FIB_SOURCE_CLI, + FIB_ENTRY_FLAG_NONE, paths); } /* Check if the prefix is already enabled */ - u32 fib_hicn_index = fib_table_find(prefix->fp_proto, HICN_FIB_TABLE); + u32 fib_hicn_index = fib_table_find (prefix->fp_proto, HICN_FIB_TABLE); - fib_node_index_t fib_hicn_entry_index = fib_table_lookup_exact_match (fib_hicn_index, prefix); + fib_node_index_t fib_hicn_entry_index = + fib_table_lookup_exact_match (fib_hicn_index, prefix); if (fib_hicn_entry_index == FIB_NODE_INDEX_INVALID) { dpo_id_t dpo = DPO_INVALID; index_t dpo_idx; default_dpo.hicn_dpo_create (prefix->fp_proto, 0, NEXT_HOP_INVALID, - &dpo_idx); + &dpo_idx); /* the value we got when we registered */ /* * This should be taken from the name?!? the index of the * object */ - dpo_set (&dpo, - default_dpo.hicn_dpo_get_type (), - (ip46_address_is_ip4 (&prefix->fp_addr) ? DPO_PROTO_IP4 : - DPO_PROTO_IP6), dpo_idx); + dpo_set (&dpo, default_dpo.hicn_dpo_get_type (), + (ip46_address_is_ip4 (&prefix->fp_addr) ? DPO_PROTO_IP4 : + DPO_PROTO_IP6), + dpo_idx); - hicn_dpo_ctx_t * fib_entry = hicn_strategy_dpo_ctx_get(dpo_idx); + hicn_dpo_ctx_t *fib_entry = hicn_strategy_dpo_ctx_get (dpo_idx); fib_node_init (&fib_entry->fib_node, hicn_fib_node_type); fib_node_lock (&fib_entry->fib_node); - fib_entry->fib_entry_index = fib_entry_track (fib_index, - prefix, - hicn_fib_node_type, - dpo_idx, &fib_entry->fib_sibling); - + fib_entry->fib_entry_index = + fib_entry_track (fib_index, prefix, hicn_fib_node_type, dpo_idx, + &fib_entry->fib_sibling); /* Here is where we create the "via" like route */ /* @@ -452,27 +444,27 @@ hicn_route_enable (fib_prefix_t *prefix) { * that is adding them -- no easy explanation at this time… */ CLIB_UNUSED (fib_node_index_t new_fib_node_index) = - fib_table_entry_special_dpo_add (fib_hicn_index, - prefix, - hicn_fib_src, - (FIB_ENTRY_FLAG_EXCLUSIVE | - FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT), - &dpo); + fib_table_entry_special_dpo_add ( + fib_hicn_index, prefix, hicn_fib_src, + (FIB_ENTRY_FLAG_EXCLUSIVE | FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT), &dpo); - sync_hicn_fib_entry(fib_entry); + sync_hicn_fib_entry (fib_entry); /* We added a route, therefore add one lock to the table */ fib_table_lock (fib_index, prefix->fp_proto, hicn_fib_src); - /* Enable the feature to punt data packet every time we enable a new hicn route - * For each enable there must be a disable to defenitely disable the feature + /* Enable the feature to punt data packet every time we enable a new hicn + * route For each enable there must be a disable to defenitely disable + * the feature * - * We cannot enable only the interfaces on which we send out interest because - * Data packet might be coming on in different interfaces, as in che case of mpls - * tunnels (packets are received from the physical nic, not the mpls tunnel interface). + * We cannot enable only the interfaces on which we send out interest + * because Data packet might be coming on in different interfaces, as in + * che case of mpls tunnels (packets are received from the physical nic, + * not the mpls tunnel interface). */ - vnet_main_t * vnm = vnet_get_main (); - vnet_sw_interface_walk(vnm, enable_data_receiving_new_fib_entry, &(prefix->fp_proto)); + vnet_main_t *vnm = vnet_get_main (); + vnet_sw_interface_walk (vnm, enable_data_receiving_new_fib_entry, + &(prefix->fp_proto)); dpo_unlock (&dpo); } @@ -487,48 +479,51 @@ hicn_route_enable (fib_prefix_t *prefix) { /* The dpo is not a load balance dpo as expected */ if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE) - { - ret = HICN_ERROR_ROUTE_NO_LD; - goto done; - } + { + ret = HICN_ERROR_ROUTE_NO_LD; + goto done; + } else { load_balance_t *lb = load_balance_get (load_balance_dpo_id->dpoi_index); - strategy_dpo_id = load_balance_get_bucket_i (lb, 0); + strategy_dpo_id = load_balance_get_bucket_i (lb, 0); - if (!dpo_is_hicn (strategy_dpo_id)) - { - ret = HICN_ERROR_ROUTE_DPO_NO_HICN; - goto done; - } + if (!dpo_is_hicn (strategy_dpo_id)) + { + ret = HICN_ERROR_ROUTE_DPO_NO_HICN; + goto done; + } - if (lb->lb_n_buckets > 1) - { - ret = HICN_ERROR_ROUTE_MLT_LD; - goto done; - } + if (lb->lb_n_buckets > 1) + { + ret = HICN_ERROR_ROUTE_MLT_LD; + goto done; + } - hicn_dpo_ctx_t * hicn_fib_entry = hicn_strategy_dpo_ctx_get(strategy_dpo_id->dpoi_index); + hicn_dpo_ctx_t *hicn_fib_entry = + hicn_strategy_dpo_ctx_get (strategy_dpo_id->dpoi_index); - sync_hicn_fib_entry(hicn_fib_entry); - } + sync_hicn_fib_entry (hicn_fib_entry); + } } - done: +done: return ret; } int -hicn_route_disable (fib_prefix_t *prefix) { +hicn_route_disable (fib_prefix_t *prefix) +{ int ret = HICN_ERROR_NONE; /* Check if the prefix is already enabled */ - u32 fib_hicn_index = fib_table_find(prefix->fp_proto, HICN_FIB_TABLE); + u32 fib_hicn_index = fib_table_find (prefix->fp_proto, HICN_FIB_TABLE); - fib_node_index_t fib_hicn_entry_index = fib_table_lookup_exact_match (fib_hicn_index, prefix); + fib_node_index_t fib_hicn_entry_index = + fib_table_lookup_exact_match (fib_hicn_index, prefix); if (fib_hicn_entry_index == FIB_NODE_INDEX_INVALID) { @@ -538,7 +533,7 @@ hicn_route_disable (fib_prefix_t *prefix) { { const dpo_id_t *load_balance_dpo_id; const dpo_id_t *strategy_dpo_id; - hicn_dpo_ctx_t * hicn_fib_entry; + hicn_dpo_ctx_t *hicn_fib_entry; /* Route already existing. We need to update the dpo. */ load_balance_dpo_id = @@ -546,57 +541,61 @@ hicn_route_disable (fib_prefix_t *prefix) { /* The dpo is not a load balance dpo as expected */ if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE) - { - ret = HICN_ERROR_ROUTE_NO_LD; - goto done; - } + { + ret = HICN_ERROR_ROUTE_NO_LD; + goto done; + } else { load_balance_t *lb = load_balance_get (load_balance_dpo_id->dpoi_index); - strategy_dpo_id = load_balance_get_bucket_i (lb, 0); + strategy_dpo_id = load_balance_get_bucket_i (lb, 0); - if (!dpo_is_hicn (strategy_dpo_id)) - { - ret = HICN_ERROR_ROUTE_DPO_NO_HICN; - goto done; - } + if (!dpo_is_hicn (strategy_dpo_id)) + { + ret = HICN_ERROR_ROUTE_DPO_NO_HICN; + goto done; + } - if (lb->lb_n_buckets > 1) - { - ret = HICN_ERROR_ROUTE_MLT_LD; - goto done; - } + if (lb->lb_n_buckets > 1) + { + ret = HICN_ERROR_ROUTE_MLT_LD; + goto done; + } - hicn_fib_entry = hicn_strategy_dpo_ctx_get(strategy_dpo_id->dpoi_index); + hicn_fib_entry = + hicn_strategy_dpo_ctx_get (strategy_dpo_id->dpoi_index); - for (int i = 0; i < hicn_fib_entry->entry_count; i++) - { - hicn_strategy_dpo_ctx_del_nh(hicn_fib_entry->next_hops[i], hicn_fib_entry); - } - } + for (int i = 0; i < hicn_fib_entry->entry_count; i++) + { + hicn_strategy_dpo_ctx_del_nh (hicn_fib_entry->next_hops[i], + hicn_fib_entry); + } + } - fib_entry_untrack(hicn_fib_entry->fib_entry_index, hicn_fib_entry->fib_sibling); + fib_entry_untrack (hicn_fib_entry->fib_entry_index, + hicn_fib_entry->fib_sibling); fib_table_entry_special_remove (fib_hicn_index, prefix, hicn_fib_src); - /* Disable the feature to punt data packet every time we enable a new hicn route */ - vnet_main_t * vnm = vnet_get_main (); - vnet_sw_interface_walk(vnm, disable_data_receiving_rm_fib_entry, &(prefix->fp_proto)); + /* Disable the feature to punt data packet every time we enable a new + * hicn route */ + vnet_main_t *vnm = vnet_get_main (); + vnet_sw_interface_walk (vnm, disable_data_receiving_rm_fib_entry, + &(prefix->fp_proto)); } - done: +done: return ret; } - static fib_node_t * hicn_ctx_node_get (fib_node_index_t index) { - hicn_dpo_ctx_t * hicn_ctx; + hicn_dpo_ctx_t *hicn_ctx; - hicn_ctx = hicn_strategy_dpo_ctx_get(index); + hicn_ctx = hicn_strategy_dpo_ctx_get (index); return (&hicn_ctx->fib_node); } @@ -607,20 +606,19 @@ hicn_fib_last_lock_gone (fib_node_t *node) } static hicn_dpo_ctx_t * -hicn_ctx_from_fib_node (fib_node_t * node) +hicn_ctx_from_fib_node (fib_node_t *node) { return ((hicn_dpo_ctx_t *) (((char *) node) - - STRUCT_OFFSET_OF (hicn_dpo_ctx_t, fib_node))); + STRUCT_OFFSET_OF (hicn_dpo_ctx_t, fib_node))); } static fib_node_back_walk_rc_t -hicn_fib_back_walk_notify (fib_node_t *node, - fib_node_back_walk_ctx_t *ctx) +hicn_fib_back_walk_notify (fib_node_t *node, fib_node_back_walk_ctx_t *ctx) { hicn_dpo_ctx_t *fib_entry = hicn_ctx_from_fib_node (node); - sync_hicn_fib_entry(fib_entry); + sync_hicn_fib_entry (fib_entry); return (FIB_NODE_BACK_WALK_CONTINUE); } @@ -630,25 +628,22 @@ hicn_fib_show_memory (void) { } - -static const fib_node_vft_t hicn_fib_vft = -{ - .fnv_get = hicn_ctx_node_get, - .fnv_last_lock = hicn_fib_last_lock_gone, - .fnv_back_walk = hicn_fib_back_walk_notify, - .fnv_mem_show = hicn_fib_show_memory, +static const fib_node_vft_t hicn_fib_vft = { + .fnv_get = hicn_ctx_node_get, + .fnv_last_lock = hicn_fib_last_lock_gone, + .fnv_back_walk = hicn_fib_back_walk_notify, + .fnv_mem_show = hicn_fib_show_memory, }; -fib_table_walk_rc_t enable_data_on_existing_hicn(fib_node_index_t fei, - void *ctx) +fib_table_walk_rc_t +enable_data_on_existing_hicn (fib_node_index_t fei, void *ctx) { - u32 sw_if = *(u32 *)ctx; + u32 sw_if = *(u32 *) ctx; const dpo_id_t *load_balance_dpo_id; const dpo_id_t *strategy_dpo_id; /* Route already existing. We need to update the dpo. */ - load_balance_dpo_id = - fib_entry_contribute_ip_forwarding (fei); + load_balance_dpo_id = fib_entry_contribute_ip_forwarding (fei); /* The dpo is not a load balance dpo as expected */ if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE) @@ -657,25 +652,24 @@ fib_table_walk_rc_t enable_data_on_existing_hicn(fib_node_index_t fei, } else { - load_balance_t *lb = - load_balance_get (load_balance_dpo_id->dpoi_index); + load_balance_t *lb = load_balance_get (load_balance_dpo_id->dpoi_index); strategy_dpo_id = load_balance_get_bucket_i (lb, 0); if (!dpo_is_hicn (strategy_dpo_id)) - { - goto done; - } + { + goto done; + } enable_disable_data_receiving (strategy_dpo_id->dpoi_proto, sw_if, 1); } - done: +done: return (FIB_TABLE_WALK_CONTINUE); } static clib_error_t * -set_table_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add) +set_table_interface_add_del (vnet_main_t *vnm, u32 sw_if_index, u32 is_add) { if (!is_add) @@ -688,37 +682,32 @@ set_table_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add) rv = ip_table_bind (FIB_PROTOCOL_IP6, sw_if_index, HICN_FIB_TABLE, 1); if (rv) - { - /* An error occurred. Bind the interface back to the default fib */ - ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, 0, 1); - } + { + /* An error occurred. Bind the interface back to the default fib */ + ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, 0, 1); + } } - u32 fib_index = fib_table_find(FIB_PROTOCOL_IP4, - HICN_FIB_TABLE); + u32 fib_index = fib_table_find (FIB_PROTOCOL_IP4, HICN_FIB_TABLE); if (fib_index != ~0) { /* * Walk the ip4 and ip6 fib tables to discover existing hicn fib entries. * For each of them we need to enable the feature to punt data packets. */ - fib_table_walk(fib_index, - FIB_PROTOCOL_IP4, - enable_data_on_existing_hicn, - &sw_if_index); + fib_table_walk (fib_index, FIB_PROTOCOL_IP4, + enable_data_on_existing_hicn, &sw_if_index); } - fib_index = fib_table_find(FIB_PROTOCOL_IP6, - HICN_FIB_TABLE); + fib_index = fib_table_find (FIB_PROTOCOL_IP6, HICN_FIB_TABLE); if (fib_index != ~0) { - fib_table_walk(fib_index, - FIB_PROTOCOL_IP6, - enable_data_on_existing_hicn, - &sw_if_index); + fib_table_walk (fib_index, FIB_PROTOCOL_IP6, + enable_data_on_existing_hicn, &sw_if_index); } - return rv ? clib_error_return (0, "unable to add hicn table to interface") : 0; + return rv ? clib_error_return (0, "unable to add hicn table to interface") : + 0; } VNET_SW_INTERFACE_ADD_DEL_FUNCTION (set_table_interface_add_del); @@ -726,23 +715,23 @@ VNET_SW_INTERFACE_ADD_DEL_FUNCTION (set_table_interface_add_del); void hicn_route_init () { - vnet_main_t * vnm = vnet_get_main (); - vlib_main_t * vm = vlib_get_main (); - hicn_fib_src = fib_source_allocate ("hicn", - FIB_SOURCE_HICN, FIB_SOURCE_BH_API); + vnet_main_t *vnm = vnet_get_main (); + vlib_main_t *vm = vlib_get_main (); + hicn_fib_src = + fib_source_allocate ("hicn", FIB_SOURCE_HICN, FIB_SOURCE_BH_API); - hicn_fib_node_type = fib_node_register_new_type(&hicn_fib_vft); + hicn_fib_node_type = fib_node_register_new_type (&hicn_fib_vft); - ip_table_create(FIB_PROTOCOL_IP4, HICN_FIB_TABLE, 1, (const u8 *)"hicn4"); - ip_table_create(FIB_PROTOCOL_IP6, HICN_FIB_TABLE, 1, (const u8 *)"hicn6"); + ip_table_create (FIB_PROTOCOL_IP4, HICN_FIB_TABLE, 1, (const u8 *) "hicn4"); + ip_table_create (FIB_PROTOCOL_IP6, HICN_FIB_TABLE, 1, (const u8 *) "hicn6"); u32 sw_if_index; u8 mac_address[6]; u8 is_specified = 0; u32 user_instance = 0; - vnet_create_loopback_interface (&sw_if_index, mac_address, - is_specified, user_instance); + vnet_create_loopback_interface (&sw_if_index, mac_address, is_specified, + user_instance); localhost4.as_u8[0] = 127; localhost4.as_u8[3] = 1; @@ -750,8 +739,10 @@ hicn_route_init () localhost6.as_u8[15] = 1; - ip4_add_del_interface_address (vm, sw_if_index, &localhost4, length4, is_del); - ip6_add_del_interface_address (vm, sw_if_index, &localhost6, length6, is_del); + ip4_add_del_interface_address (vm, sw_if_index, &localhost4, length4, + is_del); + ip6_add_del_interface_address (vm, sw_if_index, &localhost6, length6, + is_del); flags |= VNET_SW_INTERFACE_FLAG_ADMIN_UP; vnet_sw_interface_set_flags (vnm, sw_if_index, flags); |