static void _shop_key2(struct bfd_session *bs, const struct bfd_shop_key *shop);
static void _mhop_key(struct bfd_session *bs, const struct bfd_mhop_key *mhop);
-static void _bfd_free(struct hash_backet *hb,
+static void _bfd_free(struct hash_bucket *hb,
void *arg __attribute__((__unused__)));
/* BFD hash for our discriminator. */
"BFD multihop hop hash");
}
-static void _bfd_free(struct hash_backet *hb,
+static void _bfd_free(struct hash_bucket *hb,
void *arg __attribute__((__unused__)))
{
struct bfd_session *bs = hb->data;
bool bfd_vrf_insert(struct bfd_vrf *vrf);
bool bfd_iface_insert(struct bfd_iface *iface);
-typedef void (*hash_iter_func)(struct hash_backet *hb, void *arg);
+typedef void (*hash_iter_func)(struct hash_bucket *hb, void *arg);
void bfd_id_iterate(hash_iter_func hif, void *arg);
void bfd_shop_iterate(hash_iter_func hif, void *arg);
void bfd_mhop_iterate(hash_iter_func hif, void *arg);
static int bfdd_write_config(struct vty *vty);
static int bfdd_peer_write_config(struct vty *vty);
static void _bfdd_peer_write_config(struct vty *vty, struct bfd_session *bs);
-static void _bfdd_peer_write_config_iter(struct hash_backet *hb, void *arg);
+static void _bfdd_peer_write_config_iter(struct hash_bucket *hb, void *arg);
static int bfd_configure_peer(struct bfd_peer_cfg *bpc, bool mhop,
const struct sockaddr_any *peer,
const struct sockaddr_any *local,
static void _display_peer_json(struct vty *vty, struct bfd_session *bs);
static void _display_peer(struct vty *vty, struct bfd_session *bs);
static void _display_all_peers(struct vty *vty, bool use_json);
-static void _display_peer_iter(struct hash_backet *hb, void *arg);
-static void _display_peer_json_iter(struct hash_backet *hb, void *arg);
+static void _display_peer_iter(struct hash_bucket *hb, void *arg);
+static void _display_peer_json_iter(struct hash_bucket *hb, void *arg);
static void _display_peer_counter(struct vty *vty, struct bfd_session *bs);
static struct json_object *__display_peer_counters_json(struct bfd_session *bs);
static void _display_peer_counters_json(struct vty *vty, struct bfd_session *bs);
-static void _display_peer_counter_iter(struct hash_backet *hb, void *arg);
-static void _display_peer_counter_json_iter(struct hash_backet *hb, void *arg);
+static void _display_peer_counter_iter(struct hash_bucket *hb, void *arg);
+static void _display_peer_counter_json_iter(struct hash_bucket *hb, void *arg);
static void _display_peers_counter(struct vty *vty, bool use_json);
static struct bfd_session *
_find_peer_or_error(struct vty *vty, int argc, struct cmd_token **argv,
json_object_free(jo);
}
-static void _display_peer_iter(struct hash_backet *hb, void *arg)
+static void _display_peer_iter(struct hash_bucket *hb, void *arg)
{
struct vty *vty = arg;
struct bfd_session *bs = hb->data;
_display_peer(vty, bs);
}
-static void _display_peer_json_iter(struct hash_backet *hb, void *arg)
+static void _display_peer_json_iter(struct hash_bucket *hb, void *arg)
{
struct json_object *jo = arg, *jon = NULL;
struct bfd_session *bs = hb->data;
json_object_free(jo);
}
-static void _display_peer_counter_iter(struct hash_backet *hb, void *arg)
+static void _display_peer_counter_iter(struct hash_bucket *hb, void *arg)
{
struct vty *vty = arg;
struct bfd_session *bs = hb->data;
_display_peer_counter(vty, bs);
}
-static void _display_peer_counter_json_iter(struct hash_backet *hb, void *arg)
+static void _display_peer_counter_json_iter(struct hash_bucket *hb, void *arg)
{
struct json_object *jo = arg, *jon = NULL;
struct bfd_session *bs = hb->data;
return CMD_SUCCESS;
}
-static void _bfdd_peer_write_config_iter(struct hash_backet *hb, void *arg)
+static void _bfdd_peer_write_config_iter(struct hash_bucket *hb, void *arg)
{
struct vty *vty = arg;
struct bfd_session *bs = hb->data;
struct bfd_control_msg *bcm);
static void control_handle_notify_del(struct bfd_control_socket *bcs,
struct bfd_control_msg *bcm);
-static void _control_handle_notify(struct hash_backet *hb, void *arg);
+static void _control_handle_notify(struct hash_bucket *hb, void *arg);
static void control_handle_notify(struct bfd_control_socket *bcs,
struct bfd_control_msg *bcm);
static void control_response(struct bfd_control_socket *bcs, uint16_t id,
return bs_peer_find(bpc);
}
-static void _control_handle_notify(struct hash_backet *hb, void *arg)
+static void _control_handle_notify(struct hash_bucket *hb, void *arg)
{
struct bfd_control_socket *bcs = arg;
struct bfd_session *bs = hb->data;
vty_out(vty, "%s", suffix);
}
-static void aspath_show_all_iterator(struct hash_backet *backet,
+static void aspath_show_all_iterator(struct hash_bucket *bucket,
struct vty *vty)
{
struct aspath *as;
- as = (struct aspath *)backet->data;
+ as = (struct aspath *)bucket->data;
- vty_out(vty, "[%p:%u] (%ld) ", (void *)backet, backet->key, as->refcnt);
+ vty_out(vty, "[%p:%u] (%ld) ", (void *)bucket, bucket->key, as->refcnt);
vty_out(vty, "%s\n", as->str);
}
`show [ip] bgp paths' command. */
void aspath_print_all_vty(struct vty *vty)
{
- hash_iterate(ashash, (void (*)(struct hash_backet *,
+ hash_iterate(ashash, (void (*)(struct hash_bucket *,
void *))aspath_show_all_iterator,
vty);
}
attrhash = NULL;
}
-static void attr_show_all_iterator(struct hash_backet *backet, struct vty *vty)
+static void attr_show_all_iterator(struct hash_bucket *bucket, struct vty *vty)
{
- struct attr *attr = backet->data;
+ struct attr *attr = bucket->data;
vty_out(vty, "attr[%ld] nexthop %s\n", attr->refcnt,
inet_ntoa(attr->nexthop));
void attr_show_all(struct vty *vty)
{
- hash_iterate(attrhash, (void (*)(struct hash_backet *,
+ hash_iterate(attrhash, (void (*)(struct hash_bucket *,
void *))attr_show_all_iterator,
vty);
}
* router-id. The routes in the per-VNI table are used to create routes in
* the global table and schedule them.
*/
-static void update_router_id_vni(struct hash_backet *backet, struct bgp *bgp)
+static void update_router_id_vni(struct hash_bucket *bucket, struct bgp *bgp)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
/* Skip VNIs with configured RD. */
if (is_rd_configured(vpn))
* the router-id and is done only on the global route table, the routes
* are needed in the per-VNI table to re-advertise with new router id.
*/
-static void withdraw_router_id_vni(struct hash_backet *backet, struct bgp *bgp)
+static void withdraw_router_id_vni(struct hash_bucket *bucket, struct bgp *bgp)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
/* Skip VNIs with configured RD. */
if (is_rd_configured(vpn))
* Create RT-3 for a VNI and schedule for processing and advertisement.
* This is invoked upon flooding mode changing to head-end replication.
*/
-static void create_advertise_type3(struct hash_backet *backet, void *data)
+static void create_advertise_type3(struct hash_bucket *bucket, void *data)
{
- struct bgpevpn *vpn = backet->data;
+ struct bgpevpn *vpn = bucket->data;
struct bgp *bgp = data;
struct prefix_evpn p;
* Delete RT-3 for a VNI and schedule for processing and withdrawal.
* This is invoked upon flooding mode changing to drop BUM packets.
*/
-static void delete_withdraw_type3(struct hash_backet *backet, void *data)
+static void delete_withdraw_type3(struct hash_bucket *bucket, void *data)
{
- struct bgpevpn *vpn = backet->data;
+ struct bgpevpn *vpn = bucket->data;
struct bgp *bgp = data;
struct prefix_evpn p;
/*
* Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
*/
-static void cleanup_vni_on_disable(struct hash_backet *backet, struct bgp *bgp)
+static void cleanup_vni_on_disable(struct hash_bucket *bucket, struct bgp *bgp)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
/* Remove EVPN routes and schedule for processing. */
delete_routes_for_vni(bgp, vpn);
/*
* Free a VNI entry; iterator function called during cleanup.
*/
-static void free_vni_entry(struct hash_backet *backet, struct bgp *bgp)
+static void free_vni_entry(struct hash_bucket *bucket, struct bgp *bgp)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
delete_all_vni_routes(bgp, vpn);
bgp_evpn_free(bgp, vpn);
/*
* Handle autort change for a given VNI.
*/
-static void update_autort_vni(struct hash_backet *backet, struct bgp *bgp)
+static void update_autort_vni(struct hash_bucket *bucket, struct bgp *bgp)
{
- struct bgpevpn *vpn = backet->data;
+ struct bgpevpn *vpn = bucket->data;
if (!is_import_rt_configured(vpn)) {
if (is_vni_live(vpn))
* L2-VNIs
*/
hash_iterate(bgp->vnihash,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))withdraw_router_id_vni,
bgp);
} else {
* new RD
*/
hash_iterate(bgp->vnihash,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))update_router_id_vni,
bgp);
}
void bgp_evpn_handle_autort_change(struct bgp *bgp)
{
hash_iterate(bgp->vnihash,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void*))update_autort_vni,
bgp);
}
return 0;
}
-static void link_l2vni_hash_to_l3vni(struct hash_backet *backet,
+static void link_l2vni_hash_to_l3vni(struct hash_bucket *bucket,
struct bgp *bgp_vrf)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
struct bgp *bgp_def = NULL;
bgp_def = bgp_get_default();
/* link all corresponding l2vnis */
hash_iterate(bgp_def->vnihash,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))link_l2vni_hash_to_l3vni,
bgp_vrf);
*/
void bgp_evpn_cleanup_on_disable(struct bgp *bgp)
{
- hash_iterate(bgp->vnihash, (void (*)(struct hash_backet *,
+ hash_iterate(bgp->vnihash, (void (*)(struct hash_bucket *,
void *))cleanup_vni_on_disable,
bgp);
}
void bgp_evpn_cleanup(struct bgp *bgp)
{
hash_iterate(bgp->vnihash,
- (void (*)(struct hash_backet *, void *))free_vni_entry,
+ (void (*)(struct hash_bucket *, void *))free_vni_entry,
bgp);
hash_free(bgp->import_rt_hash);
}
}
-static void show_vrf_import_rt_entry(struct hash_backet *backet, void *args[])
+static void show_vrf_import_rt_entry(struct hash_bucket *bucket, void *args[])
{
json_object *json = NULL;
struct vty *vty = NULL;
- struct vrf_irt_node *irt = (struct vrf_irt_node *)backet->data;
+ struct vrf_irt_node *irt = (struct vrf_irt_node *)bucket->data;
vty = (struct vty *)args[0];
json = (struct json_object *)args[1];
}
}
-static void show_import_rt_entry(struct hash_backet *backet, void *args[])
+static void show_import_rt_entry(struct hash_bucket *bucket, void *args[])
{
json_object *json = NULL;
struct vty *vty = NULL;
- struct irt_node *irt = (struct irt_node *)backet->data;
+ struct irt_node *irt = (struct irt_node *)bucket->data;
vty = args[0];
json = args[1];
}
}
-static void show_vni_routes_hash(struct hash_backet *backet, void *arg)
+static void show_vni_routes_hash(struct hash_bucket *bucket, void *arg)
{
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
struct vni_walk_ctx *wctx = arg;
struct vty *vty = wctx->vty;
json_object *json = wctx->json;
}
}
-static void show_es_entry(struct hash_backet *backet, void *args[])
+static void show_es_entry(struct hash_bucket *bucket, void *args[])
{
char buf[ESI_STR_LEN];
char buf1[RD_ADDRSTRLEN];
json_object *json = args[1];
json_object *json_vteps = NULL;
struct listnode *node = NULL;
- struct evpnes *es = (struct evpnes *)backet->data;
+ struct evpnes *es = (struct evpnes *)bucket->data;
if (json) {
json_vteps = json_object_new_array();
}
}
-static void show_vni_entry(struct hash_backet *backet, void *args[])
+static void show_vni_entry(struct hash_bucket *bucket, void *args[])
{
struct vty *vty;
json_object *json;
json_object *json_vni = NULL;
json_object *json_import_rtl = NULL;
json_object *json_export_rtl = NULL;
- struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
+ struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
char buf1[10];
char buf2[RD_ADDRSTRLEN];
char rt_buf[25];
args[1] = json;
hash_iterate(bgp_def->vrf_import_rt_hash,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))show_vrf_import_rt_entry,
args);
}
hash_iterate(
bgp->import_rt_hash,
- (void (*)(struct hash_backet *, void *))show_import_rt_entry,
+ (void (*)(struct hash_bucket *, void *))show_import_rt_entry,
args);
}
wctx.vty = vty;
wctx.vtep_ip = vtep_ip;
wctx.json = json;
- hash_iterate(bgp->vnihash, (void (*)(struct hash_backet *,
+ hash_iterate(bgp->vnihash, (void (*)(struct hash_bucket *,
void *))show_vni_routes_hash,
&wctx);
}
args[0] = vty;
args[1] = json;
hash_iterate(bgp->esihash,
- (void (*)(struct hash_backet *, void *))show_es_entry,
+ (void (*)(struct hash_bucket *, void *))show_es_entry,
args);
}
args[0] = vty;
args[1] = json;
hash_iterate(bgp->vnihash,
- (void (*)(struct hash_backet *, void *))show_vni_entry,
+ (void (*)(struct hash_bucket *, void *))show_vni_entry,
args);
/* print all L3 VNIs */
*
* @return maximum time to wait until next update (0 if infinity)
*/
-static void peer_process(struct hash_backet *hb, void *arg)
+static void peer_process(struct hash_bucket *hb, void *arg)
{
struct pkat *pkat = hb->data;
const char *ifname;
};
-static void bgp_mac_find_ifp_internal(struct hash_backet *backet, void *arg)
+static void bgp_mac_find_ifp_internal(struct hash_bucket *bucket, void *arg)
{
struct bgp_mac_find_internal *bmfi = arg;
- struct bgp_self_mac *bsm = backet->data;
+ struct bgp_self_mac *bsm = bucket->data;
struct listnode *node;
char *name;
return true;
}
-static void bgp_mac_show_mac_entry(struct hash_backet *backet, void *arg)
+static void bgp_mac_show_mac_entry(struct hash_bucket *bucket, void *arg)
{
struct vty *vty = arg;
- struct bgp_self_mac *bsm = backet->data;
+ struct bgp_self_mac *bsm = bucket->data;
struct listnode *node;
char *name;
char buf_mac[ETHER_ADDR_STRLEN];
struct list *ifp_name_list;
};
-static void show_address_entry(struct hash_backet *backet, void *args)
+static void show_address_entry(struct hash_bucket *bucket, void *args)
{
struct vty *vty = (struct vty *)args;
- struct bgp_addr *addr = (struct bgp_addr *)backet->data;
+ struct bgp_addr *addr = (struct bgp_addr *)bucket->data;
char *name;
struct listnode *node;
void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp)
{
hash_iterate(bgp->address_hash,
- (void (*)(struct hash_backet *, void *))show_address_entry,
+ (void (*)(struct hash_bucket *, void *))show_address_entry,
vty);
}
struct bgp_pbr_rule *bpr_found;
};
-static int bgp_pbr_rule_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_rule_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_rule *bpr = (struct bgp_pbr_rule *)backet->data;
+ struct bgp_pbr_rule *bpr = (struct bgp_pbr_rule *)bucket->data;
struct bgp_pbr_rule_unique *bpru = (struct bgp_pbr_rule_unique *)
arg;
uint32_t unique = bpru->unique;
return HASHWALK_CONTINUE;
}
-static int bgp_pbr_action_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_action_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_action *bpa = (struct bgp_pbr_action *)backet->data;
+ struct bgp_pbr_action *bpa = (struct bgp_pbr_action *)bucket->data;
struct bgp_pbr_action_unique *bpau = (struct bgp_pbr_action_unique *)
arg;
uint32_t unique = bpau->unique;
return HASHWALK_CONTINUE;
}
-static int bgp_pbr_match_entry_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_match_entry_walkcb(struct hash_bucket *bucket, void *arg)
{
struct bgp_pbr_match_entry *bpme =
- (struct bgp_pbr_match_entry *)backet->data;
+ (struct bgp_pbr_match_entry *)bucket->data;
struct bgp_pbr_match_entry_unique *bpmeu =
(struct bgp_pbr_match_entry_unique *)arg;
uint32_t unique = bpmeu->unique;
struct bgp_pbr_match *bpm_found;
};
-static int bgp_pbr_match_pername_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_match_pername_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)backet->data;
+ struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)bucket->data;
struct bgp_pbr_match_ipsetname *bpmi =
(struct bgp_pbr_match_ipsetname *)arg;
char *ipset_name = bpmi->ipsetname;
return HASHWALK_CONTINUE;
}
-static int bgp_pbr_match_iptable_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_match_iptable_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)backet->data;
+ struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)bucket->data;
struct bgp_pbr_match_iptable_unique *bpmiu =
(struct bgp_pbr_match_iptable_unique *)arg;
uint32_t unique = bpmiu->unique;
struct bgp_pbr_match *bpm_found;
};
-static int bgp_pbr_match_walkcb(struct hash_backet *backet, void *arg)
+static int bgp_pbr_match_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)backet->data;
+ struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)bucket->data;
struct bgp_pbr_match_unique *bpmu = (struct bgp_pbr_match_unique *)
arg;
uint32_t unique = bpmu->unique;
struct bgp_pbr_rule *bpr_found;
};
-static int bgp_pbr_get_same_rule(struct hash_backet *backet, void *arg)
+static int bgp_pbr_get_same_rule(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_rule *r1 = (struct bgp_pbr_rule *)backet->data;
+ struct bgp_pbr_rule *r1 = (struct bgp_pbr_rule *)bucket->data;
struct bgp_pbr_rule_remain *ctxt =
(struct bgp_pbr_rule_remain *)arg;
struct bgp_pbr_rule *r2;
return HASHWALK_CONTINUE;
}
-static int bgp_pbr_get_remaining_entry(struct hash_backet *backet, void *arg)
+static int bgp_pbr_get_remaining_entry(struct hash_bucket *bucket, void *arg)
{
- struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)backet->data;
+ struct bgp_pbr_match *bpm = (struct bgp_pbr_match *)bucket->data;
struct bgp_pbr_match_entry_remain *bpmer =
(struct bgp_pbr_match_entry_remain *)arg;
struct bgp_pbr_match *bpm_temp;
NULL, 0);
}
-static void show_bgp_peerhash_entry(struct hash_backet *backet, void *arg)
+static void show_bgp_peerhash_entry(struct hash_bucket *bucket, void *arg)
{
struct vty *vty = arg;
- struct peer *peer = backet->data;
+ struct peer *peer = bucket->data;
char buf[SU_ADDRSTRLEN];
vty_out(vty, "\tPeer: %s %s\n", peer->host,
return UPDWALK_CONTINUE;
}
-static int update_group_walkcb(struct hash_backet *backet, void *arg)
+static int update_group_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct update_group *updgrp = backet->data;
+ struct update_group *updgrp = bucket->data;
struct updwalk_context *wctx = arg;
int ret = (*wctx->cb)(updgrp, wctx->context);
return ret;
return CMD_SUCCESS;
}
-static void show_tip_entry(struct hash_backet *backet, void *args)
+static void show_tip_entry(struct hash_bucket *bucket, void *args)
{
struct vty *vty = (struct vty *)args;
- struct tip_addr *tip = (struct tip_addr *)backet->data;
+ struct tip_addr *tip = (struct tip_addr *)bucket->data;
vty_out(vty, "addr: %s, count: %d\n", inet_ntoa(tip->addr),
tip->refcnt);
vty_out(vty, "Tunnel-ip database:\n");
hash_iterate(bgp->tip_hash,
- (void (*)(struct hash_backet *, void *))show_tip_entry,
+ (void (*)(struct hash_bucket *, void *))show_tip_entry,
vty);
}
if ((count = mtype_stats_alloc(MTYPE_HASH_BACKET)))
vty_out(vty, "%ld hash buckets, using %s of memory\n", count,
mtype_memstr(memstrbuf, sizeof(memstrbuf),
- count * sizeof(struct hash_backet)));
+ count * sizeof(struct hash_bucket)));
if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
vty_out(vty, "%ld compiled regexes, using %s of memory\n",
count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
#include "hash.h"
-static void community_show_all_iterator(struct hash_backet *backet,
+static void community_show_all_iterator(struct hash_bucket *bucket,
struct vty *vty)
{
struct community *com;
- com = (struct community *)backet->data;
+ com = (struct community *)bucket->data;
vty_out(vty, "[%p] (%ld) %s\n", (void *)com, com->refcnt,
community_str(com, false));
}
vty_out(vty, "Address Refcnt Community\n");
hash_iterate(community_hash(),
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))community_show_all_iterator,
vty);
return CMD_SUCCESS;
}
-static void lcommunity_show_all_iterator(struct hash_backet *backet,
+static void lcommunity_show_all_iterator(struct hash_bucket *bucket,
struct vty *vty)
{
struct lcommunity *lcom;
- lcom = (struct lcommunity *)backet->data;
+ lcom = (struct lcommunity *)bucket->data;
vty_out(vty, "[%p] (%ld) %s\n", (void *)lcom, lcom->refcnt,
lcommunity_str(lcom, false));
}
vty_out(vty, "Address Refcnt Large-community\n");
hash_iterate(lcommunity_hash(),
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))lcommunity_show_all_iterator,
vty);
listnode_add(lsp->flooding_neighbors[type], neighbor_id);
}
-static void mark_neighbor_as_present(struct hash_backet *backet, void *arg)
+static void mark_neighbor_as_present(struct hash_bucket *bucket, void *arg)
{
- struct neighbor_entry *n = backet->data;
+ struct neighbor_entry *n = bucket->data;
n->present = true;
}
-static void handle_firsthops(struct hash_backet *backet, void *arg)
+static void handle_firsthops(struct hash_bucket *bucket, void *arg)
{
struct isis_lsp *lsp = arg;
struct fabricd *f = lsp->area->fabricd;
- struct isis_vertex *vertex = backet->data;
+ struct isis_vertex *vertex = bucket->data;
struct neighbor_entry *n;
return vertex;
}
-static void vertex_add_parent_firsthop(struct hash_backet *backet, void *arg)
+static void vertex_add_parent_firsthop(struct hash_bucket *bucket, void *arg)
{
struct isis_vertex *vertex = arg;
- struct isis_vertex *hop = backet->data;
+ struct isis_vertex *hop = bucket->data;
hash_get(vertex->firsthops, hop, hash_alloc_intern);
}
{
unsigned int i;
int has_print = 0;
- struct hash_backet *mp;
+ struct hash_bucket *mp;
struct distribute *dist;
/* Output filter configuration. */
unsigned int i;
int j;
int output, v6;
- struct hash_backet *mp;
+ struct hash_bucket *mp;
int write = 0;
for (i = 0; i < dist_ctxt->disthash->size; i++)
assert((size & (size - 1)) == 0);
hash = XCALLOC(MTYPE_HASH, sizeof(struct hash));
hash->index =
- XCALLOC(MTYPE_HASH_INDEX, sizeof(struct hash_backet *) * size);
+ XCALLOC(MTYPE_HASH_INDEX, sizeof(struct hash_bucket *) * size);
hash->size = size;
hash->hash_key = hash_key;
hash->hash_cmp = hash_cmp;
static void hash_expand(struct hash *hash)
{
unsigned int i, new_size;
- struct hash_backet *hb, *hbnext, **new_index;
+ struct hash_bucket *hb, *hbnext, **new_index;
new_size = hash->size * 2;
return;
new_index = XCALLOC(MTYPE_HASH_INDEX,
- sizeof(struct hash_backet *) * new_size);
+ sizeof(struct hash_bucket *) * new_size);
if (new_index == NULL)
return;
unsigned int key;
unsigned int index;
void *newdata;
- struct hash_backet *backet;
+ struct hash_bucket *bucket;
if (!alloc_func && !hash->count)
return NULL;
key = (*hash->hash_key)(data);
index = key & (hash->size - 1);
- for (backet = hash->index[index]; backet != NULL;
- backet = backet->next) {
- if (backet->key == key && (*hash->hash_cmp)(backet->data, data))
- return backet->data;
+ for (bucket = hash->index[index]; bucket != NULL;
+ bucket = bucket->next) {
+ if (bucket->key == key && (*hash->hash_cmp)(bucket->data, data))
+ return bucket->data;
}
if (alloc_func) {
index = key & (hash->size - 1);
}
- backet = XCALLOC(MTYPE_HASH_BACKET, sizeof(struct hash_backet));
- backet->data = newdata;
- backet->key = key;
- backet->next = hash->index[index];
- hash->index[index] = backet;
+ bucket = XCALLOC(MTYPE_HASH_BACKET, sizeof(struct hash_bucket));
+ bucket->data = newdata;
+ bucket->key = key;
+ bucket->next = hash->index[index];
+ hash->index[index] = bucket;
hash->count++;
- int oldlen = backet->next ? backet->next->len : 0;
+ int oldlen = bucket->next ? bucket->next->len : 0;
int newlen = oldlen + 1;
if (newlen == 1)
hash->stats.empty--;
else
- backet->next->len = 0;
+ bucket->next->len = 0;
- backet->len = newlen;
+ bucket->len = newlen;
hash_update_ssq(hash, oldlen, newlen);
- return backet->data;
+ return bucket->data;
}
return NULL;
}
void *ret;
unsigned int key;
unsigned int index;
- struct hash_backet *backet;
- struct hash_backet *pp;
+ struct hash_bucket *bucket;
+ struct hash_bucket *pp;
key = (*hash->hash_key)(data);
index = key & (hash->size - 1);
- for (backet = pp = hash->index[index]; backet; backet = backet->next) {
- if (backet->key == key
- && (*hash->hash_cmp)(backet->data, data)) {
+ for (bucket = pp = hash->index[index]; bucket; bucket = bucket->next) {
+ if (bucket->key == key
+ && (*hash->hash_cmp)(bucket->data, data)) {
int oldlen = hash->index[index]->len;
int newlen = oldlen - 1;
- if (backet == pp)
- hash->index[index] = backet->next;
+ if (bucket == pp)
+ hash->index[index] = bucket->next;
else
- pp->next = backet->next;
+ pp->next = bucket->next;
if (hash->index[index])
hash->index[index]->len = newlen;
hash_update_ssq(hash, oldlen, newlen);
- ret = backet->data;
- XFREE(MTYPE_HASH_BACKET, backet);
+ ret = bucket->data;
+ XFREE(MTYPE_HASH_BACKET, bucket);
hash->count--;
return ret;
}
- pp = backet;
+ pp = bucket;
}
return NULL;
}
-void hash_iterate(struct hash *hash, void (*func)(struct hash_backet *, void *),
+void hash_iterate(struct hash *hash, void (*func)(struct hash_bucket *, void *),
void *arg)
{
unsigned int i;
- struct hash_backet *hb;
- struct hash_backet *hbnext;
+ struct hash_bucket *hb;
+ struct hash_bucket *hbnext;
for (i = 0; i < hash->size; i++)
for (hb = hash->index[i]; hb; hb = hbnext) {
- /* get pointer to next hash backet here, in case (*func)
+ /* get pointer to next hash bucket here, in case (*func)
* decides to delete hb by calling hash_release
*/
hbnext = hb->next;
}
}
-void hash_walk(struct hash *hash, int (*func)(struct hash_backet *, void *),
+void hash_walk(struct hash *hash, int (*func)(struct hash_bucket *, void *),
void *arg)
{
unsigned int i;
- struct hash_backet *hb;
- struct hash_backet *hbnext;
+ struct hash_bucket *hb;
+ struct hash_bucket *hbnext;
int ret = HASHWALK_CONTINUE;
for (i = 0; i < hash->size; i++) {
for (hb = hash->index[i]; hb; hb = hbnext) {
- /* get pointer to next hash backet here, in case (*func)
+ /* get pointer to next hash bucket here, in case (*func)
* decides to delete hb by calling hash_release
*/
hbnext = hb->next;
void hash_clean(struct hash *hash, void (*free_func)(void *))
{
unsigned int i;
- struct hash_backet *hb;
- struct hash_backet *next;
+ struct hash_bucket *hb;
+ struct hash_bucket *next;
for (i = 0; i < hash->size; i++) {
for (hb = hash->index[i]; hb; hb = next) {
hash->stats.empty = hash->size;
}
-static void hash_to_list_iter(struct hash_backet *hb, void *arg)
+static void hash_to_list_iter(struct hash_bucket *hb, void *arg)
{
struct list *list = arg;
#define HASHWALK_CONTINUE 0
#define HASHWALK_ABORT -1
-struct hash_backet {
+struct hash_bucket {
/*
- * if this backet is the head of the linked listed, len denotes the
+ * if this bucket is the head of the linked listed, len denotes the
* number of elements in the list
*/
int len;
/* Linked list. */
- struct hash_backet *next;
+ struct hash_bucket *next;
/* Hash key. */
unsigned int key;
};
struct hash {
- /* Hash backet. */
- struct hash_backet **index;
+ /* Hash bucket. */
+ struct hash_bucket **index;
/* Hash table size. Must be power of 2 */
unsigned int size;
* hash table to operate on
*
* data
- * data to insert or retrieve - A hash backet will not be created if
+ * data to insert or retrieve - A hash bucket will not be created if
* the alloc_func returns a NULL pointer and nothing will be added to
- * the hash. As such backet->data will always be non-NULL.
+ * the hash. As such bucket->data will always be non-NULL.
*
* alloc_func
* function to call if the item is not found in the hash table. This
* during the walk will cause undefined behavior in that some new entries
* will be walked and some will not. So do not do this.
*
- * The backet passed to func will have a non-NULL data pointer.
+ * The bucket passed to func will have a non-NULL data pointer.
*
* hash
* hash table to operate on
* arbitrary argument passed as the second parameter in each call to 'func'
*/
extern void hash_iterate(struct hash *hash,
- void (*func)(struct hash_backet *, void *), void *arg);
+ void (*func)(struct hash_bucket *, void *), void *arg);
/*
* Iterate over the elements in a hash table, stopping on condition.
* during the walk will cause undefined behavior in that some new entries
* will be walked and some will not. So do not do this.
*
- * The backet passed to func will have a non-NULL data pointer.
+ * The bucket passed to func will have a non-NULL data pointer.
*
* hash
* hash table to operate on
* arbitrary argument passed as the second parameter in each call to 'func'
*/
extern void hash_walk(struct hash *hash,
- int (*func)(struct hash_backet *, void *), void *arg);
+ int (*func)(struct hash_bucket *, void *), void *arg);
/*
* Remove all elements from a hash table.
int config_write_if_rmap(struct vty *vty)
{
unsigned int i;
- struct hash_backet *mp;
+ struct hash_bucket *mp;
int write = 0;
for (i = 0; i < ifrmaphash->size; i++)
== 0);
}
-static void route_map_clear_reference(struct hash_backet *backet, void *arg)
+static void route_map_clear_reference(struct hash_bucket *bucket, void *arg)
{
- struct route_map_dep *dep = (struct route_map_dep *)backet->data;
+ struct route_map_dep *dep = (struct route_map_dep *)bucket->data;
char *rmap_name;
if (arg) {
return (string_hash_make((char *)p));
}
-static void route_map_print_dependency(struct hash_backet *backet, void *data)
+static void route_map_print_dependency(struct hash_bucket *bucket, void *data)
{
- char *rmap_name = (char *)backet->data;
+ char *rmap_name = (char *)bucket->data;
char *dep_name = (char *)data;
zlog_debug("%s: Dependency for %s: %s", __FUNCTION__, dep_name,
return (upd8_hash);
}
-static void route_map_process_dependency(struct hash_backet *backet, void *data)
+static void route_map_process_dependency(struct hash_bucket *bucket, void *data)
{
- char *rmap_name = (char *)backet->data;
+ char *rmap_name = (char *)bucket->data;
route_map_event_t type = (route_map_event_t)(ptrdiff_t)data;
if (rmap_debug)
a->types & (1 << THREAD_EXECUTE) ? 'X' : ' ', a->funcname);
}
-static void cpu_record_hash_print(struct hash_backet *bucket, void *args[])
+static void cpu_record_hash_print(struct hash_bucket *bucket, void *args[])
{
struct cpu_thread_history *totals = args[0];
struct cpu_thread_history copy;
if (m->cpu_record->count)
hash_iterate(
m->cpu_record,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))cpu_record_hash_print,
args);
else
vty_out_cpu_thread_history(vty, &tmp);
}
-static void cpu_record_hash_clear(struct hash_backet *bucket, void *args[])
+static void cpu_record_hash_clear(struct hash_bucket *bucket, void *args[])
{
uint8_t *filter = args[0];
struct hash *cpu_record = args[1];
void *args[2] = {tmp, m->cpu_record};
hash_iterate(
m->cpu_record,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))cpu_record_hash_clear,
args);
}
void *ctx;
};
-static void nhrp_cache_iterator(struct hash_backet *b, void *ctx)
+static void nhrp_cache_iterator(struct hash_bucket *b, void *ctx)
{
struct nhrp_cache_iterator_ctx *ic = ctx;
ic->cb(b->data, ic->ctx);
void *ctx;
};
-static void nhrp_vc_iterator(struct hash_backet *b, void *ctx)
+static void nhrp_vc_iterator(struct hash_bucket *b, void *ctx)
{
struct nhrp_vc_iterator_ctx *ic = ctx;
ic->cb(b->data, ic->ctx);
* When change the FRR Self SRGB, update the NHLFE Input Label
* for all Extended Prefix with SID index through hash_iterate()
*/
-static void update_in_nhlfe(struct hash_backet *backet, void *args)
+static void update_in_nhlfe(struct hash_bucket *bucket, void *args)
{
struct listnode *node;
- struct sr_node *srn = (struct sr_node *)backet->data;
+ struct sr_node *srn = (struct sr_node *)bucket->data;
struct sr_prefix *srp;
struct sr_nhlfe new;
* When SRGB has changed, update NHLFE Output Label for all Extended Prefix
* with SID index which use the given SR-Node as nexthop though hash_iterate()
*/
-static void update_out_nhlfe(struct hash_backet *backet, void *args)
+static void update_out_nhlfe(struct hash_bucket *bucket, void *args)
{
struct listnode *node;
- struct sr_node *srn = (struct sr_node *)backet->data;
+ struct sr_node *srn = (struct sr_node *)bucket->data;
struct sr_node *srnext = (struct sr_node *)args;
struct sr_prefix *srp;
struct sr_nhlfe new;
/* Update NHLFE if it is a neighbor SR node */
if (srn->neighbor == OspfSR.self)
hash_iterate(OspfSR.neighbors,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))update_out_nhlfe,
(void *)srn);
}
* Following functions are used to update MPLS LFIB after a SPF run
*/
-static void ospf_sr_nhlfe_update(struct hash_backet *backet, void *args)
+static void ospf_sr_nhlfe_update(struct hash_bucket *bucket, void *args)
{
- struct sr_node *srn = (struct sr_node *)backet->data;
+ struct sr_node *srn = (struct sr_node *)bucket->data;
struct listnode *node;
struct sr_prefix *srp;
struct sr_nhlfe old;
if (IS_DEBUG_OSPF_SR)
zlog_debug("SR (%s): Start SPF update", __func__);
- hash_iterate(OspfSR.neighbors, (void (*)(struct hash_backet *,
+ hash_iterate(OspfSR.neighbors, (void (*)(struct hash_bucket *,
void *))ospf_sr_nhlfe_update,
NULL);
/* Update NHLFE entries */
hash_iterate(OspfSR.neighbors,
- (void (*)(struct hash_backet *, void *))update_in_nhlfe,
+ (void (*)(struct hash_bucket *, void *))update_in_nhlfe,
NULL);
return CMD_SUCCESS;
/* Update NHLFE entries */
hash_iterate(OspfSR.neighbors,
- (void (*)(struct hash_backet *, void *))update_in_nhlfe,
+ (void (*)(struct hash_bucket *, void *))update_in_nhlfe,
NULL);
return CMD_SUCCESS;
vty_out(vty, "\n");
}
-static void show_vty_srdb(struct hash_backet *backet, void *args)
+static void show_vty_srdb(struct hash_bucket *bucket, void *args)
{
struct vty *vty = (struct vty *)args;
- struct sr_node *srn = (struct sr_node *)backet->data;
+ struct sr_node *srn = (struct sr_node *)bucket->data;
show_sr_node(vty, NULL, srn);
}
-static void show_json_srdb(struct hash_backet *backet, void *args)
+static void show_json_srdb(struct hash_bucket *bucket, void *args)
{
struct json_object *json = (struct json_object *)args;
- struct sr_node *srn = (struct sr_node *)backet->data;
+ struct sr_node *srn = (struct sr_node *)bucket->data;
show_sr_node(NULL, json, srn);
}
/* No parameters have been provided, Iterate through all the SRDB */
if (uj) {
- hash_iterate(OspfSR.neighbors, (void (*)(struct hash_backet *,
+ hash_iterate(OspfSR.neighbors, (void (*)(struct hash_bucket *,
void *))show_json_srdb,
(void *)json_node_array);
vty_out(vty, "%s\n", json_object_to_json_string_ext(
json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
- hash_iterate(OspfSR.neighbors, (void (*)(struct hash_backet *,
+ hash_iterate(OspfSR.neighbors, (void (*)(struct hash_bucket *,
void *))show_vty_srdb,
(void *)vty);
}
XFREE(MTYPE_PBR_NHG, *pnhc);
}
-static void pbr_nh_delete_iterate(struct hash_backet *b, void *p)
+static void pbr_nh_delete_iterate(struct hash_bucket *b, void *p)
{
pbr_nh_delete((struct pbr_nexthop_cache **)&b->data);
}
}
#endif
-static void pbr_nht_find_nhg_from_table_install(struct hash_backet *b,
+static void pbr_nht_find_nhg_from_table_install(struct hash_bucket *b,
void *data)
{
struct pbr_nexthop_group_cache *pnhgc =
&table_id);
}
-static void pbr_nht_find_nhg_from_table_remove(struct hash_backet *b,
+static void pbr_nht_find_nhg_from_table_remove(struct hash_bucket *b,
void *data)
{
;
uint32_t valid;
};
-static void pbr_nht_individual_nexthop_update_lookup(struct hash_backet *b,
+static void pbr_nht_individual_nexthop_update_lookup(struct hash_bucket *b,
void *data)
{
struct pbr_nexthop_cache *pnhc = b->data;
pnhi->valid += 1;
}
-static void pbr_nht_nexthop_update_lookup(struct hash_backet *b, void *data)
+static void pbr_nht_nexthop_update_lookup(struct hash_bucket *b, void *data)
{
struct pbr_nexthop_group_cache *pnhgc = b->data;
struct pbr_nht_individual pnhi;
return pnhgc->installed;
}
-static void pbr_nht_show_nhg_nexthops(struct hash_backet *b, void *data)
+static void pbr_nht_show_nhg_nexthops(struct hash_bucket *b, void *data)
{
struct pbr_nexthop_cache *pnhc = b->data;
struct vty *vty = data;
const char *name;
};
-static void pbr_nht_show_nhg(struct hash_backet *b, void *data)
+static void pbr_nht_show_nhg(struct hash_bucket *b, void *data)
{
struct pbr_nexthop_group_cache *pnhgc = b->data;
struct pbr_nht_show *pns = data;
struct pim_instance *pim;
};
-static int pim_print_pnc_cache_walkcb(struct hash_backet *backet, void *arg)
+static int pim_print_pnc_cache_walkcb(struct hash_bucket *bucket, void *arg)
{
- struct pim_nexthop_cache *pnc = backet->data;
+ struct pim_nexthop_cache *pnc = bucket->data;
struct pnc_cache_walk_data *cwd = arg;
struct vty *vty = cwd->vty;
struct pim_instance *pim = cwd->pim;
}
/* Update Upstream nexthop info based on Nexthop update received from Zebra.*/
-static int pim_update_upstream_nh_helper(struct hash_backet *backet, void *arg)
+static int pim_update_upstream_nh_helper(struct hash_bucket *bucket, void *arg)
{
struct pim_instance *pim = (struct pim_instance *)arg;
- struct pim_upstream *up = (struct pim_upstream *)backet->data;
+ struct pim_upstream *up = (struct pim_upstream *)bucket->data;
int vif_index = 0;
enum pim_rpf_result rpf_result;
XFREE(MTYPE_TMP, hash_entry_intern);
}
-static void verify_log(struct hash_backet *backet, void *arg)
+static void verify_log(struct hash_bucket *bucket, void *arg)
{
struct test_state *test = arg;
- struct prefix *hash_entry = backet->data;
+ struct prefix *hash_entry = bucket->data;
struct prefix *dst_p = &hash_entry[0];
struct prefix_ipv6 *src_p = (struct prefix_ipv6 *)&hash_entry[1];
struct route_node *rn = srcdest_rnode_lookup(test->table, dst_p, src_p);
route_unlock_node(rn);
}
-static void dump_log(struct hash_backet *backet, void *arg)
+static void dump_log(struct hash_bucket *bucket, void *arg)
{
- struct prefix *hash_entry = backet->data;
+ struct prefix *hash_entry = bucket->data;
struct prefix_ipv6 *dst_p = (struct prefix_ipv6 *)&hash_entry[0];
struct prefix_ipv6 *src_p = (struct prefix_ipv6 *)&hash_entry[1];
char *route_id = format_srcdest(dst_p, src_p);
static int nhlfe_nexthop_active(zebra_nhlfe_t *nhlfe);
static void lsp_select_best_nhlfe(zebra_lsp_t *lsp);
-static void lsp_uninstall_from_kernel(struct hash_backet *backet, void *ctxt);
-static void lsp_schedule(struct hash_backet *backet, void *ctxt);
+static void lsp_uninstall_from_kernel(struct hash_bucket *bucket, void *ctxt);
+static void lsp_schedule(struct hash_bucket *bucket, void *ctxt);
static wq_item_status lsp_process(struct work_queue *wq, void *data);
static void lsp_processq_del(struct work_queue *wq, void *data);
static void lsp_processq_complete(struct work_queue *wq);
* Delete LSP forwarding entry from kernel, if installed. Called upon
* process exit.
*/
-static void lsp_uninstall_from_kernel(struct hash_backet *backet, void *ctxt)
+static void lsp_uninstall_from_kernel(struct hash_bucket *bucket, void *ctxt)
{
zebra_lsp_t *lsp;
- lsp = (zebra_lsp_t *)backet->data;
+ lsp = (zebra_lsp_t *)bucket->data;
if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
(void)dplane_lsp_delete(lsp);
}
* Schedule LSP forwarding entry for processing. Called upon changes
* that may impact LSPs such as nexthop / connected route changes.
*/
-static void lsp_schedule(struct hash_backet *backet, void *ctxt)
+static void lsp_schedule(struct hash_bucket *bucket, void *ctxt)
{
zebra_lsp_t *lsp;
- lsp = (zebra_lsp_t *)backet->data;
+ lsp = (zebra_lsp_t *)bucket->data;
(void)lsp_processq_add(lsp);
}
static struct list *hash_get_sorted_list(struct hash *hash, void *cmp)
{
unsigned int i;
- struct hash_backet *hb;
+ struct hash_bucket *hb;
struct list *sorted_list = list_new();
sorted_list->cmp = (int (*)(void *, void *))cmp;
* Uninstall all LDP NHLFEs for a particular LSP forwarding entry.
* If no other NHLFEs exist, the entry would be deleted.
*/
-void mpls_ldp_lsp_uninstall_all(struct hash_backet *backet, void *ctxt)
+void mpls_ldp_lsp_uninstall_all(struct hash_bucket *bucket, void *ctxt)
{
zebra_lsp_t *lsp;
struct hash *lsp_table;
- lsp = (zebra_lsp_t *)backet->data;
+ lsp = (zebra_lsp_t *)bucket->data;
if (!lsp->nhlfe_list)
return;
* Uninstall all LDP NHLFEs for a particular LSP forwarding entry.
* If no other NHLFEs exist, the entry would be deleted.
*/
-void mpls_ldp_lsp_uninstall_all(struct hash_backet *backet, void *ctxt);
+void mpls_ldp_lsp_uninstall_all(struct hash_bucket *bucket, void *ctxt);
/*
* Uninstall all LDP FEC-To-NHLFE (FTN) bindings of the given address-family.
* Uninstall all Segment Routing NHLFEs for a particular LSP forwarding entry.
* If no other NHLFEs exist, the entry would be deleted.
*/
-void mpls_sr_lsp_uninstall_all(struct hash_backet *backet, void *ctxt);
+void mpls_sr_lsp_uninstall_all(struct hash_bucket *bucket, void *ctxt);
#if defined(HAVE_CUMULUS)
/*
vrf_id_t vrf_id;
};
-static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data)
+static int pbr_rule_lookup_unique_walker(struct hash_bucket *b, void *data)
{
struct pbr_rule_unique_lookup *pul = data;
struct zebra_pbr_rule *rule = b->data;
__PRETTY_FUNCTION__);
}
-static void zebra_pbr_cleanup_rules(struct hash_backet *b, void *data)
+static void zebra_pbr_cleanup_rules(struct hash_bucket *b, void *data)
{
struct zebra_pbr_rule *rule = b->data;
int *sock = data;
}
}
-static void zebra_pbr_cleanup_ipset(struct hash_backet *b, void *data)
+static void zebra_pbr_cleanup_ipset(struct hash_bucket *b, void *data)
{
struct zebra_pbr_ipset *ipset = b->data;
int *sock = data;
}
}
-static void zebra_pbr_cleanup_ipset_entry(struct hash_backet *b, void *data)
+static void zebra_pbr_cleanup_ipset_entry(struct hash_bucket *b, void *data)
{
struct zebra_pbr_ipset_entry *ipset = b->data;
int *sock = data;
}
}
-static void zebra_pbr_cleanup_iptable(struct hash_backet *b, void *data)
+static void zebra_pbr_cleanup_iptable(struct hash_bucket *b, void *data)
{
struct zebra_pbr_iptable *iptable = b->data;
int *sock = data;
"Unrecognized IPset Type");
}
-static int zebra_pbr_ipset_pername_walkcb(struct hash_backet *backet, void *arg)
+static int zebra_pbr_ipset_pername_walkcb(struct hash_bucket *bucket, void *arg)
{
struct pbr_ipset_name_lookup *pinl =
(struct pbr_ipset_name_lookup *)arg;
- struct zebra_pbr_ipset *zpi = (struct zebra_pbr_ipset *)backet->data;
+ struct zebra_pbr_ipset *zpi = (struct zebra_pbr_ipset *)bucket->data;
if (!strncmp(pinl->ipset_name, zpi->ipset_name,
ZEBRA_IPSET_NAME_SIZE)) {
}
}
-static int zebra_pbr_show_ipset_entry_walkcb(struct hash_backet *backet,
+static int zebra_pbr_show_ipset_entry_walkcb(struct hash_bucket *bucket,
void *arg)
{
struct zebra_pbr_ipset_entry_unique_display *unique =
struct zebra_pbr_ipset *zpi = unique->zpi;
struct vty *vty = unique->vty;
struct zebra_pbr_ipset_entry *zpie =
- (struct zebra_pbr_ipset_entry *)backet->data;
+ (struct zebra_pbr_ipset_entry *)bucket->data;
uint64_t pkts = 0, bytes = 0;
int ret = 0;
return HASHWALK_CONTINUE;
}
-static int zebra_pbr_show_ipset_walkcb(struct hash_backet *backet, void *arg)
+static int zebra_pbr_show_ipset_walkcb(struct hash_bucket *bucket, void *arg)
{
struct zebra_pbr_env_display *uniqueipset =
(struct zebra_pbr_env_display *)arg;
- struct zebra_pbr_ipset *zpi = (struct zebra_pbr_ipset *)backet->data;
+ struct zebra_pbr_ipset *zpi = (struct zebra_pbr_ipset *)bucket->data;
struct zebra_pbr_ipset_entry_unique_display unique;
struct vty *vty = uniqueipset->vty;
struct zebra_ns *zns = uniqueipset->zns;
uint32_t fwmark;
};
-static int zebra_pbr_rule_lookup_fwmark_walkcb(struct hash_backet *backet,
+static int zebra_pbr_rule_lookup_fwmark_walkcb(struct hash_bucket *bucket,
void *arg)
{
struct pbr_rule_fwmark_lookup *iprule =
(struct pbr_rule_fwmark_lookup *)arg;
- struct zebra_pbr_rule *zpr = (struct zebra_pbr_rule *)backet->data;
+ struct zebra_pbr_rule *zpr = (struct zebra_pbr_rule *)bucket->data;
if (iprule->fwmark == zpr->rule.filter.fwmark) {
iprule->ptr = zpr;
}
}
-static int zebra_pbr_show_iptable_walkcb(struct hash_backet *backet, void *arg)
+static int zebra_pbr_show_iptable_walkcb(struct hash_bucket *bucket, void *arg)
{
struct zebra_pbr_iptable *iptable =
- (struct zebra_pbr_iptable *)backet->data;
+ (struct zebra_pbr_iptable *)bucket->data;
struct zebra_pbr_env_display *env = (struct zebra_pbr_env_display *)arg;
struct vty *vty = env->vty;
struct zebra_ns *zns = env->zns;
static int ip_prefix_send_to_client(vrf_id_t vrf_id, struct prefix *p,
uint16_t cmd);
static void zvni_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json);
-static void zvni_print_neigh_hash(struct hash_backet *backet, void *ctxt);
-static void zvni_print_dad_neigh_hash(struct hash_backet *backet, void *ctxt);
-static void zvni_print_neigh_hash_all_vni(struct hash_backet *backet,
+static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt);
+static void zvni_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt);
+static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
void **args);
static void zl3vni_print_nh(zebra_neigh_t *n, struct vty *vty,
json_object *json);
static void zl3vni_print_rmac(zebra_mac_t *zrmac, struct vty *vty,
json_object *json);
static void zvni_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json);
-static void zvni_print_mac_hash(struct hash_backet *backet, void *ctxt);
-static void zvni_print_mac_hash_all_vni(struct hash_backet *backet, void *ctxt);
+static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt);
+static void zvni_print_mac_hash_all_vni(struct hash_bucket *bucket, void *ctxt);
static void zvni_print(zebra_vni_t *zvni, void **ctxt);
-static void zvni_print_hash(struct hash_backet *backet, void *ctxt[]);
+static void zvni_print_hash(struct hash_bucket *bucket, void *ctxt[]);
static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
struct ipaddr *ip, uint8_t flags,
static int zl3vni_nh_uninstall(zebra_l3vni_t *zl3vni, zebra_neigh_t *n);
/* l3-vni rmac related APIs */
-static void zl3vni_print_rmac_hash(struct hash_backet *, void *);
+static void zl3vni_print_rmac_hash(struct hash_bucket *, void *);
static zebra_mac_t *zl3vni_rmac_lookup(zebra_l3vni_t *zl3vni,
struct ethaddr *rmac);
static void *zl3vni_rmac_alloc(void *p);
struct interface *br_if, vlanid_t vid);
static int zvni_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac);
static int zvni_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac);
-static void zvni_install_mac_hash(struct hash_backet *backet, void *ctxt);
+static void zvni_install_mac_hash(struct hash_bucket *bucket, void *ctxt);
static unsigned int vni_hash_keymake(void *p);
static void *zvni_alloc(void *p);
unsigned int i;
uint32_t num_macs = 0;
struct hash *hash;
- struct hash_backet *hb;
+ struct hash_bucket *hb;
zebra_mac_t *mac;
hash = zvni->mac_table;
unsigned int i;
uint32_t num_macs = 0;
struct hash *hash;
- struct hash_backet *hb;
+ struct hash_bucket *hb;
zebra_mac_t *mac;
hash = zvni->mac_table;
unsigned int i;
uint32_t num_neighs = 0;
struct hash *hash;
- struct hash_backet *hb;
+ struct hash_bucket *hb;
zebra_neigh_t *nbr;
hash = zvni->neigh_table;
* display - just because we're dealing with IPv6 addresses that can
* widely vary.
*/
-static void zvni_find_neigh_addr_width(struct hash_backet *backet, void *ctxt)
+static void zvni_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt)
{
zebra_neigh_t *n;
char buf[INET6_ADDRSTRLEN];
struct neigh_walk_ctx *wctx = ctxt;
int width;
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
ipaddr2str(&n->ip, buf, sizeof(buf));
width = strlen(buf);
/*
* Print neighbor hash entry - called for display of all neighbors.
*/
-static void zvni_print_neigh_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
{
struct vty *vty;
json_object *json_vni = NULL, *json_row = NULL;
vty = wctx->vty;
json_vni = wctx->json;
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
if (json_vni)
json_row = json_object_new_object();
/*
* Print neighbor hash entry in detail - called for display of all neighbors.
*/
-static void zvni_print_neigh_hash_detail(struct hash_backet *backet, void *ctxt)
+static void zvni_print_neigh_hash_detail(struct hash_bucket *bucket, void *ctxt)
{
struct vty *vty;
json_object *json_vni = NULL, *json_row = NULL;
vty = wctx->vty;
json_vni = wctx->json;
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
if (!n)
return;
/*
* Print neighbors for all VNI.
*/
-static void zvni_print_neigh_hash_all_vni(struct hash_backet *backet,
+static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
void **args)
{
struct vty *vty;
json = (json_object *)args[1];
print_dup = (uint32_t)(uintptr_t)args[2];
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
num_neigh = hashcount(zvni->neigh_table);
json_object_object_add(json, vni_str, json_vni);
}
-static void zvni_print_dad_neigh_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt)
{
zebra_neigh_t *nbr;
- nbr = (zebra_neigh_t *)backet->data;
+ nbr = (zebra_neigh_t *)bucket->data;
if (!nbr)
return;
if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
- zvni_print_neigh_hash(backet, ctxt);
+ zvni_print_neigh_hash(bucket, ctxt);
}
-static void zvni_print_dad_neigh_hash_detail(struct hash_backet *backet,
+static void zvni_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
void *ctxt)
{
zebra_neigh_t *nbr;
- nbr = (zebra_neigh_t *)backet->data;
+ nbr = (zebra_neigh_t *)bucket->data;
if (!nbr)
return;
if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
- zvni_print_neigh_hash_detail(backet, ctxt);
+ zvni_print_neigh_hash_detail(bucket, ctxt);
}
/*
* Print neighbors for all VNIs in detail.
*/
-static void zvni_print_neigh_hash_all_vni_detail(struct hash_backet *backet,
+static void zvni_print_neigh_hash_all_vni_detail(struct hash_bucket *bucket,
void **args)
{
struct vty *vty;
json = (json_object *)args[1];
print_dup = (uint32_t)(uintptr_t)args[2];
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
if (!zvni) {
if (json)
vty_out(vty, "{}\n");
/*
* Print MAC hash entry - called for display of all MACs.
*/
-static void zvni_print_mac_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
{
struct vty *vty;
json_object *json_mac_hdr = NULL, *json_mac = NULL;
vty = wctx->vty;
json_mac_hdr = wctx->json;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
prefix_mac2str(&mac->macaddr, buf1, sizeof(buf1));
}
/* Print Duplicate MAC */
-static void zvni_print_dad_mac_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_print_dad_mac_hash(struct hash_bucket *bucket, void *ctxt)
{
zebra_mac_t *mac;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
if (!mac)
return;
if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
- zvni_print_mac_hash(backet, ctxt);
+ zvni_print_mac_hash(bucket, ctxt);
}
/*
* Print MAC hash entry in detail - called for display of all MACs.
*/
-static void zvni_print_mac_hash_detail(struct hash_backet *backet, void *ctxt)
+static void zvni_print_mac_hash_detail(struct hash_bucket *bucket, void *ctxt)
{
struct vty *vty;
json_object *json_mac_hdr = NULL;
vty = wctx->vty;
json_mac_hdr = wctx->json;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
if (!mac)
return;
}
/* Print Duplicate MAC in detail */
-static void zvni_print_dad_mac_hash_detail(struct hash_backet *backet,
+static void zvni_print_dad_mac_hash_detail(struct hash_bucket *bucket,
void *ctxt)
{
zebra_mac_t *mac;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
if (!mac)
return;
if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
- zvni_print_mac_hash_detail(backet, ctxt);
+ zvni_print_mac_hash_detail(bucket, ctxt);
}
/*
* Print MACs for all VNI.
*/
-static void zvni_print_mac_hash_all_vni(struct hash_backet *backet, void *ctxt)
+static void zvni_print_mac_hash_all_vni(struct hash_bucket *bucket, void *ctxt)
{
struct vty *vty;
json_object *json = NULL, *json_vni = NULL;
vty = (struct vty *)wctx->vty;
json = (struct json_object *)wctx->json;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
wctx->zvni = zvni;
/*We are iterating over a new VNI, set the count to 0*/
/*
* Print MACs in detail for all VNI.
*/
-static void zvni_print_mac_hash_all_vni_detail(struct hash_backet *backet,
+static void zvni_print_mac_hash_all_vni_detail(struct hash_bucket *bucket,
void *ctxt)
{
struct vty *vty;
vty = (struct vty *)wctx->vty;
json = (struct json_object *)wctx->json;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
if (!zvni) {
if (json)
vty_out(vty, "{}\n");
}
}
-static void zl3vni_print_nh_hash(struct hash_backet *backet, void *ctx)
+static void zl3vni_print_nh_hash(struct hash_bucket *bucket, void *ctx)
{
struct nh_walk_ctx *wctx = NULL;
struct vty *vty = NULL;
json_vni = wctx->json;
if (json_vni)
json_nh = json_object_new_object();
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
if (!json_vni) {
vty_out(vty, "%-15s %-17s\n",
}
}
-static void zl3vni_print_nh_hash_all_vni(struct hash_backet *backet,
+static void zl3vni_print_nh_hash_all_vni(struct hash_bucket *bucket,
void **args)
{
struct vty *vty = NULL;
vty = (struct vty *)args[0];
json = (struct json_object *)args[1];
- zl3vni = (zebra_l3vni_t *)backet->data;
+ zl3vni = (zebra_l3vni_t *)bucket->data;
num_nh = hashcount(zl3vni->nh_table);
if (!num_nh)
json_object_object_add(json, vni_str, json_vni);
}
-static void zl3vni_print_rmac_hash_all_vni(struct hash_backet *backet,
+static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
void **args)
{
struct vty *vty = NULL;
vty = (struct vty *)args[0];
json = (struct json_object *)args[1];
- zl3vni = (zebra_l3vni_t *)backet->data;
+ zl3vni = (zebra_l3vni_t *)bucket->data;
num_rmacs = hashcount(zl3vni->rmac_table);
if (!num_rmacs)
json_object_object_add(json, vni_str, json_vni);
}
-static void zl3vni_print_rmac_hash(struct hash_backet *backet, void *ctx)
+static void zl3vni_print_rmac_hash(struct hash_bucket *bucket, void *ctx)
{
zebra_mac_t *zrmac = NULL;
struct rmac_walk_ctx *wctx = NULL;
json = wctx->json;
if (json)
json_rmac = json_object_new_object();
- zrmac = (zebra_mac_t *)backet->data;
+ zrmac = (zebra_mac_t *)bucket->data;
if (!json) {
vty_out(vty, "%-17s %-21s\n",
}
/* print a L3 VNI hash entry */
-static void zl3vni_print_hash(struct hash_backet *backet, void *ctx[])
+static void zl3vni_print_hash(struct hash_bucket *bucket, void *ctx[])
{
struct vty *vty = NULL;
json_object *json = NULL;
vty = (struct vty *)ctx[0];
json = (json_object *)ctx[1];
- zl3vni = (zebra_l3vni_t *)backet->data;
+ zl3vni = (zebra_l3vni_t *)bucket->data;
if (!json) {
vty_out(vty, "%-10u %-4s %-21s %-8lu %-8lu %-15s %-37s\n",
};
/* print a L3 VNI hash entry in detail*/
-static void zl3vni_print_hash_detail(struct hash_backet *backet, void *data)
+static void zl3vni_print_hash_detail(struct hash_bucket *bucket, void *data)
{
struct vty *vty = NULL;
zebra_l3vni_t *zl3vni = NULL;
if (json)
use_json = true;
- zl3vni = (zebra_l3vni_t *)backet->data;
+ zl3vni = (zebra_l3vni_t *)bucket->data;
zebra_vxlan_print_vni(vty, zes->zvrf, zl3vni->vni, use_json);
vty_out(vty, "\n");
/*
* Print a VNI hash entry - called for display of all VNIs.
*/
-static void zvni_print_hash(struct hash_backet *backet, void *ctxt[])
+static void zvni_print_hash(struct hash_bucket *bucket, void *ctxt[])
{
struct vty *vty;
zebra_vni_t *zvni;
vty = ctxt[0];
json = ctxt[1];
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
zvtep = zvni->vteps;
while (zvtep) {
/*
* Print a VNI hash entry in detail - called for display of all VNIs.
*/
-static void zvni_print_hash_detail(struct hash_backet *backet, void *data)
+static void zvni_print_hash_detail(struct hash_bucket *bucket, void *data)
{
struct vty *vty;
zebra_vni_t *zvni;
if (json)
use_json = true;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
zebra_vxlan_print_vni(vty, zes->zvrf, zvni->vni, use_json);
vty_out(vty, "\n");
/*
* Free neighbor hash entry (callback)
*/
-static void zvni_neigh_del_hash_entry(struct hash_backet *backet, void *arg)
+static void zvni_neigh_del_hash_entry(struct hash_bucket *bucket, void *arg)
{
struct neigh_walk_ctx *wctx = arg;
- zebra_neigh_t *n = backet->data;
+ zebra_neigh_t *n = bucket->data;
if (((wctx->flags & DEL_LOCAL_NEIGH) && (n->flags & ZEBRA_NEIGH_LOCAL))
|| ((wctx->flags & DEL_REMOTE_NEIGH)
/*
* Install neighbor hash entry - called upon access VLAN change.
*/
-static void zvni_install_neigh_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_install_neigh_hash(struct hash_bucket *bucket, void *ctxt)
{
zebra_neigh_t *n;
struct neigh_walk_ctx *wctx = ctxt;
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE))
zvni_neigh_install(wctx->zvni, n);
return 0;
}
-static void zvni_gw_macip_del_for_vni_hash(struct hash_backet *backet,
+static void zvni_gw_macip_del_for_vni_hash(struct hash_bucket *bucket,
void *ctxt)
{
zebra_vni_t *zvni = NULL;
struct interface *ifp;
/* Add primary SVI MAC*/
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
ifp = zvni->vxlan_if;
if (!ifp)
return;
}
-static void zvni_gw_macip_add_for_vni_hash(struct hash_backet *backet,
+static void zvni_gw_macip_add_for_vni_hash(struct hash_bucket *bucket,
void *ctxt)
{
zebra_vni_t *zvni = NULL;
struct interface *vrr_if = NULL;
struct interface *ifp = NULL;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
ifp = zvni->vxlan_if;
if (!ifp)
return;
}
-static void zvni_svi_macip_del_for_vni_hash(struct hash_backet *backet,
+static void zvni_svi_macip_del_for_vni_hash(struct hash_bucket *bucket,
void *ctxt)
{
zebra_vni_t *zvni = NULL;
struct interface *ifp;
/* Add primary SVI MAC*/
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
if (!zvni)
return;
/*
* Free MAC hash entry (callback)
*/
-static void zvni_mac_del_hash_entry(struct hash_backet *backet, void *arg)
+static void zvni_mac_del_hash_entry(struct hash_bucket *bucket, void *arg)
{
struct mac_walk_ctx *wctx = arg;
- zebra_mac_t *mac = backet->data;
+ zebra_mac_t *mac = bucket->data;
if (((wctx->flags & DEL_LOCAL_MAC) && (mac->flags & ZEBRA_MAC_LOCAL))
|| ((wctx->flags & DEL_REMOTE_MAC)
/*
* Install MAC hash entry - called upon access VLAN change.
*/
-static void zvni_install_mac_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_install_mac_hash(struct hash_bucket *bucket, void *ctxt)
{
zebra_mac_t *mac;
struct mac_walk_ctx *wctx = ctxt;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE))
zvni_mac_install(wctx->zvni, mac);
* Install or uninstall flood entries in the kernel corresponding to
* remote VTEPs. This is invoked upon change to BUM handling.
*/
-static void zvni_handle_flooding_remote_vteps(struct hash_backet *backet,
+static void zvni_handle_flooding_remote_vteps(struct hash_bucket *bucket,
void *zvrf)
{
zebra_vni_t *zvni;
zebra_vtep_t *zvtep;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
if (!zvni)
return;
/*
* Cleanup VNI/VTEP and update kernel
*/
-static void zvni_cleanup_all(struct hash_backet *backet, void *arg)
+static void zvni_cleanup_all(struct hash_bucket *bucket, void *arg)
{
zebra_vni_t *zvni = NULL;
zebra_l3vni_t *zl3vni = NULL;
struct zebra_vrf *zvrf = (struct zebra_vrf *)arg;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
/* remove from l3-vni list */
if (zvrf->l3vni)
}
/* cleanup L3VNI */
-static void zl3vni_cleanup_all(struct hash_backet *backet, void *args)
+static void zl3vni_cleanup_all(struct hash_bucket *bucket, void *args)
{
zebra_l3vni_t *zl3vni = NULL;
- zl3vni = (zebra_l3vni_t *)backet->data;
+ zl3vni = (zebra_l3vni_t *)bucket->data;
zebra_vxlan_process_l3vni_oper_down(zl3vni);
}
zl3vni_send_del_to_client(zl3vni);
}
-static void zvni_add_to_l3vni_list(struct hash_backet *backet, void *ctxt)
+static void zvni_add_to_l3vni_list(struct hash_bucket *bucket, void *ctxt)
{
- zebra_vni_t *zvni = (zebra_vni_t *)backet->data;
+ zebra_vni_t *zvni = (zebra_vni_t *)bucket->data;
zebra_l3vni_t *zl3vni = (zebra_l3vni_t *)ctxt;
if (zvni->vrf_id == zl3vni_vrf_id(zl3vni))
}
/* delete and uninstall rmac hash entry */
-static void zl3vni_del_rmac_hash_entry(struct hash_backet *backet, void *ctx)
+static void zl3vni_del_rmac_hash_entry(struct hash_bucket *bucket, void *ctx)
{
zebra_mac_t *zrmac = NULL;
zebra_l3vni_t *zl3vni = NULL;
- zrmac = (zebra_mac_t *)backet->data;
+ zrmac = (zebra_mac_t *)bucket->data;
zl3vni = (zebra_l3vni_t *)ctx;
zl3vni_rmac_uninstall(zl3vni, zrmac);
zl3vni_rmac_del(zl3vni, zrmac);
}
/* delete and uninstall nh hash entry */
-static void zl3vni_del_nh_hash_entry(struct hash_backet *backet, void *ctx)
+static void zl3vni_del_nh_hash_entry(struct hash_bucket *bucket, void *ctx)
{
zebra_neigh_t *n = NULL;
zebra_l3vni_t *zl3vni = NULL;
- n = (zebra_neigh_t *)backet->data;
+ n = (zebra_neigh_t *)bucket->data;
zl3vni = (zebra_l3vni_t *)ctx;
zl3vni_nh_uninstall(zl3vni, n);
zl3vni_nh_del(zl3vni, n);
args[0] = vty;
args[1] = json;
hash_iterate(zrouter.l3vni_table,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))zl3vni_print_rmac_hash_all_vni,
args);
args[0] = vty;
args[1] = json;
hash_iterate(zrouter.l3vni_table,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))zl3vni_print_nh_hash_all_vni,
args);
args[2] = (void *)(ptrdiff_t)print_dup;
hash_iterate(zvrf->vni_table,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))zvni_print_neigh_hash_all_vni,
args);
if (use_json) {
args[2] = (void *)(ptrdiff_t)print_dup;
hash_iterate(zvrf->vni_table,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))zvni_print_neigh_hash_all_vni_detail,
args);
if (use_json) {
return CMD_SUCCESS;
}
-static void zvni_clear_dup_mac_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
{
struct mac_walk_ctx *wctx = ctxt;
zebra_mac_t *mac;
struct listnode *node = NULL;
zebra_neigh_t *nbr = NULL;
- mac = (zebra_mac_t *)backet->data;
+ mac = (zebra_mac_t *)bucket->data;
if (!mac)
return;
}
}
-static void zvni_clear_dup_neigh_hash(struct hash_backet *backet, void *ctxt)
+static void zvni_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt)
{
struct neigh_walk_ctx *wctx = ctxt;
zebra_neigh_t *nbr;
zebra_vni_t *zvni;
char buf[INET6_ADDRSTRLEN];
- nbr = (zebra_neigh_t *)backet->data;
+ nbr = (zebra_neigh_t *)bucket->data;
if (!nbr)
return;
}
}
-static void zvni_clear_dup_detect_hash_vni_all(struct hash_backet *backet,
+static void zvni_clear_dup_detect_hash_vni_all(struct hash_bucket *bucket,
void **args)
{
struct vty *vty;
struct mac_walk_ctx m_wctx;
struct neigh_walk_ctx n_wctx;
- zvni = (zebra_vni_t *)backet->data;
+ zvni = (zebra_vni_t *)bucket->data;
if (!zvni)
return;
args[1] = zvrf;
hash_iterate(zvrf->vni_table,
- (void (*)(struct hash_backet *, void *))
+ (void (*)(struct hash_bucket *, void *))
zvni_clear_dup_detect_hash_vni_all, args);
return CMD_SUCCESS;
/* Display all L2-VNIs */
hash_iterate(zvrf->vni_table,
- (void (*)(struct hash_backet *, void *))zvni_print_hash,
+ (void (*)(struct hash_bucket *, void *))zvni_print_hash,
args);
/* Display all L3-VNIs */
hash_iterate(zrouter.l3vni_table,
- (void (*)(struct hash_backet *, void *))zl3vni_print_hash,
+ (void (*)(struct hash_bucket *, void *))zl3vni_print_hash,
args);
if (use_json) {
zes.zvrf = zvrf;
/* Display all L2-VNIs */
- hash_iterate(zvrf->vni_table, (void (*)(struct hash_backet *,
+ hash_iterate(zvrf->vni_table, (void (*)(struct hash_bucket *,
void *))zvni_print_hash_detail,
&zes);
/* Display all L3-VNIs */
hash_iterate(zrouter.l3vni_table,
- (void (*)(struct hash_backet *,
+ (void (*)(struct hash_bucket *,
void *))zl3vni_print_hash_detail,
&zes);
projects / mirror_frr.git / commitdiff