mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-12-22 09:41:54 +00:00
Code Releases Activity

Nest: proto/channel state table naming convention cleanup

Browse Source
This commit is contained in:
Maria Matejka 2024-12-09 15:34:11 +01:00
parent d503204aa0
commit dc692ae06a
5 changed files with 44 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
nest/proto.c
View File

@ -260,21 +260,21 @@ proto_add_channel(struct proto *p, struct channel_config *cf)
hmap_set(&ts->channel_id_map, c->id);
/* The current channel state table may be too small */
if (c->id >= ts->length_channels)
if (c->id >= ts->channels_len)
{
ea_list **l = mb_allocz(ts->pool, sizeof(ea_list*) * ts->length_channels * 2);
memcpy(l, ts->channels, sizeof(ea_list*) * ts->length_channels);
mb_free(ts->channels);
ea_list **l = mb_allocz(ts->pool, sizeof(ea_list*) * ts->channels_len * 2);
memcpy(l, ts->channel_states, sizeof(ea_list*) * ts->channels_len);
mb_free(ts->channel_states);
ts->channels = l;
ts->length_channels = ts->length_channels * 2;
ts->channel_states = l;
ts->channels_len = ts->channels_len * 2;
}
ASSERT_DIE(c->id < ts->length_channels);
ASSERT_DIE(ts->channels[c->id] == NULL);
ASSERT_DIE(c->id < ts->channels_len);
ASSERT_DIE(ts->channel_states[c->id] == NULL);
/* Set the channel info */
ts->channels[c->id] = ea_lookup_slow(ca, 0, EALS_IN_TABLE);
ts->channel_states[c->id] = ea_lookup_slow(ca, 0, EALS_IN_TABLE);
}
/* Update channel list in protocol state */
@ -317,9 +317,9 @@ proto_remove_channel(struct proto *p UNUSED, struct channel *c)
*/
PST_LOCKED(ts)
{
ASSERT_DIE(c->id < ts->length_channels);
ea_free_later(ts->channels[c->id]);
ts->channels[c->id] = NULL;
ASSERT_DIE(c->id < ts->channels_len);
ea_free_later(ts->channel_states[c->id]);
ts->channel_states[c->id] = NULL;
hmap_clear(&ts->channel_id_map, c->id);
}
@ -1348,15 +1348,15 @@ proto_new(struct proto_config *cf)
p->id = hmap_first_zero(&tp->proto_id_map);
hmap_set(&tp->proto_id_map, p->id);
if (p->id >= tp->length_states)
if (p->id >= tp->proto_len)
{
/* Grow the states array */
ea_list **new_states = mb_allocz(tp->pool, sizeof *new_states * tp->length_states * 2);
memcpy(new_states, tp->states, tp->length_states * sizeof *new_states);
ea_list **new_states = mb_allocz(tp->pool, sizeof *new_states * tp->proto_len * 2);
memcpy(new_states, tp->proto_states, tp->proto_len * sizeof *new_states);
mb_free(tp->states);
tp->states = new_states;
tp->length_states *= 2;
mb_free(tp->proto_states);
tp->proto_states = new_states;
tp->proto_len *= 2;
}
}
@ -2140,15 +2140,15 @@ protos_build(void)
PST_LOCKED(ts)
{
ts->length_channels = 64;
ts->length_states = 32;
ts->channels_len = 64;
ts->proto_len = 32;
hmap_init(&ts->proto_id_map, p, ts->length_states); /* for proto ids. Value of proto id is the same as index of that proto in ptoto_state_table->attrs */
hmap_init(&ts->channel_id_map, p, ts->length_channels);
hmap_init(&ts->proto_id_map, p, ts->proto_len); /* for proto ids. Value of proto id is the same as index of that proto in ptoto_state_table->attrs */
hmap_init(&ts->channel_id_map, p, ts->channels_len);
ts->pool = p;
ts->states = mb_allocz(p, sizeof(ea_list *) * ts->length_states);
ts->channels = mb_allocz(p, sizeof(ea_list *) * ts->length_channels * 2);
ts->proto_states = mb_allocz(p, sizeof(ea_list *) * ts->proto_len);
ts->channel_states = mb_allocz(p, sizeof(ea_list *) * ts->channels_len * 2);
}
/* Init proto state journal */
@ -2939,7 +2939,7 @@ proto_journal_item_cleanup_(bool withdrawal, ea_list *old_attr)
{
u32 id = ea_get_int(old_attr, &ea_proto_id, 0);
ASSERT_DIE(id);
ASSERT_DIE(tp->states[id] == NULL);
ASSERT_DIE(tp->proto_states[id] == NULL);
hmap_clear(&tp->proto_id_map, id);
}
}
@ -2955,7 +2955,7 @@ proto_journal_item_cleanup(struct lfjour * journal UNUSED, struct lfjour_item *i
/*
* Protocol state announcement.
*
* The authoritative protocol state is always stored in ts->states[p->id]
* The authoritative protocol state is always stored in ts->proto_states[p->id]
* and it holds a reference. But sometimes it's too clumsy to announce all
* protocol changes happening in a fast succession, so there is a
* state-to-be-announced stored in the protocol itself, in p->ea_state.
@ -3014,15 +3014,15 @@ proto_announce_state_locked(struct proto_state_table_private* ts, struct proto *
}
/* Then we check the public state */
ASSERT_DIE(p->id < ts->length_states);
ea_list *old_state = ts->states[p->id];
ASSERT_DIE(p->id < ts->proto_len);
ea_list *old_state = ts->proto_states[p->id];
/* Nothing has changed? */
if (p->ea_state == old_state)
return;
/* Set the new state */
ts->states[p->id] = p->ea_state ? ea_ref(p->ea_state) : NULL;
ts->proto_states[p->id] = p->ea_state ? ea_ref(p->ea_state) : NULL;
/* Announce the new state */
struct lfjour_item *li = lfjour_push_prepare(&proto_state_table_pub.journal);
@ -3094,9 +3094,9 @@ channel_get_state(int id)
{
PST_LOCKED(ts)
{
ASSERT_DIE((u32) id < ts->length_channels);
if (ts->channels[id])
return ea_ref_tmp(ts->channels[id]);
ASSERT_DIE((u32) id < ts->channels_len);
if (ts->channel_states[id])
return ea_ref_tmp(ts->channel_states[id]);
}
return NULL;
}
@ -3107,8 +3107,8 @@ proto_get_state(int id)
ea_list *eal;
PST_LOCKED(ts)
{
ASSERT_DIE((u32)id < ts->length_states);
eal = ts->states[id];
ASSERT_DIE((u32)id < ts->proto_len);
eal = ts->proto_states[id];
}
if (eal)
return ea_ref_tmp(eal);

8
nest/protocol.h
View File

@ -412,10 +412,10 @@ struct proto_state_table_private {
PROTO_STATE_TABLE_PUBLIC;
};
struct proto_state_table_private **locked_at;
ea_list ** states;
ea_list ** channels;
u32 length_states;
u32 length_channels;
ea_list ** proto_states;
ea_list ** channel_states;
u32 proto_len;
u32 channels_len;
struct hmap proto_id_map;
struct hmap channel_id_map;
pool *pool;

4
proto/bgp/bgp.c
View File

@ -2025,9 +2025,9 @@ bgp_channel_init(struct channel *C, struct channel_config *CF)
PST_LOCKED(ts)
{
ea_list *eal = ea_free_later(ts->channels[c->c.id]);
ea_list *eal = ea_free_later(ts->channel_states[c->c.id]);
ea_set_attr(&eal, EA_LITERAL_EMBEDDED(&ea_bgp_afi, 0, c->afi));
ts->channels[c->c.id] = ea_lookup_slow(eal, 0, EALS_IN_TABLE);
ts->channel_states[c->c.id] = ea_lookup_slow(eal, 0, EALS_IN_TABLE);
}
}

4
proto/bmp/bmp.c
View File

@ -702,7 +702,7 @@ bmp_add_peer(struct bmp_proto *p, ea_list *bgp_attr)
{
ea_list *chan_attr;
PST_LOCKED(ts)
chan_attr = ts->channels[chann_ids[i]];
chan_attr = ts->channel_states[chann_ids[i]];
if (chan_attr == NULL)
continue;
@ -1117,7 +1117,7 @@ bmp_startup(struct bmp_proto *p)
/* Send Peer Up messages */
u32 length;
PST_LOCKED(ts) /* The size of protos field will never decrease, the inconsistency caused by growing is not important */
length = ts->length_states;
length = ts->proto_len;
/* Subscribe to protocol state changes */
p->proto_state_reader = (struct lfjour_recipient) {

4
proto/mrt/mrt.c
View File

@ -335,9 +335,9 @@ mrt_peer_table_dump(struct mrt_table_dump_state *s)
#ifdef CONFIG_BGP
PST_LOCKED(ts)
{
for(u32 i = 0; i < ts->length_states; i++)
for(u32 i = 0; i < ts->proto_len; i++)
{
ea_list *eal = ts->states[i];
ea_list *eal = ts->proto_states[i];
if (eal)
ea_free_later(ea_ref(eal));
else