proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-04-29 20:04:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

*: Convert THREAD_XXX macros to EVENT_XXX macros

Browse Source 
Signed-off-by: Donald Sharp <sharpd@nvidia.com>
This commit is contained in:
Donald Sharp 2022-12-25 10:26:52 -05:00
parent 70d4d90c82
commit e16d030c65
191 changed files with 1243 additions and 1248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
bfdd/bfd.c
View File

@ -620,14 +620,14 @@ struct bfd_session *ptm_bfd_sess_find(struct bfd_pkt *cp,
void bfd_xmt_cb(struct event *t) void bfd_xmt_cb(struct event *t)
{ {
struct bfd_session *bs = THREAD_ARG(t); struct bfd_session *bs = EVENT_ARG(t);
ptm_bfd_xmt_TO(bs, 0); ptm_bfd_xmt_TO(bs, 0);
} }
void bfd_echo_xmt_cb(struct event *t) void bfd_echo_xmt_cb(struct event *t)
{ {
struct bfd_session *bs = THREAD_ARG(t); struct bfd_session *bs = EVENT_ARG(t);
if (bs->echo_xmt_TO > 0) if (bs->echo_xmt_TO > 0)
ptm_bfd_echo_xmt_TO(bs); ptm_bfd_echo_xmt_TO(bs);
@ -636,7 +636,7 @@ void bfd_echo_xmt_cb(struct event *t)
/* Was ptm_bfd_detect_TO() */ /* Was ptm_bfd_detect_TO() */
void bfd_recvtimer_cb(struct event *t) void bfd_recvtimer_cb(struct event *t)
{ {
struct bfd_session *bs = THREAD_ARG(t); struct bfd_session *bs = EVENT_ARG(t);
switch (bs->ses_state) { switch (bs->ses_state) {
case PTM_BFD_INIT: case PTM_BFD_INIT:
@ -649,7 +649,7 @@ void bfd_recvtimer_cb(struct event *t)
/* Was ptm_bfd_echo_detect_TO() */ /* Was ptm_bfd_echo_detect_TO() */
void bfd_echo_recvtimer_cb(struct event *t) void bfd_echo_recvtimer_cb(struct event *t)
{ {
struct bfd_session *bs = THREAD_ARG(t); struct bfd_session *bs = EVENT_ARG(t);
switch (bs->ses_state) { switch (bs->ses_state) {
case PTM_BFD_INIT: case PTM_BFD_INIT:
@ -1999,12 +1999,12 @@ static int bfd_vrf_disable(struct vrf *vrf)
zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id); zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
/* Disable read/write poll triggering. */ /* Disable read/write poll triggering. */
THREAD_OFF(bvrf->bg_ev[0]); EVENT_OFF(bvrf->bg_ev[0]);
THREAD_OFF(bvrf->bg_ev[1]); EVENT_OFF(bvrf->bg_ev[1]);
THREAD_OFF(bvrf->bg_ev[2]); EVENT_OFF(bvrf->bg_ev[2]);
THREAD_OFF(bvrf->bg_ev[3]); EVENT_OFF(bvrf->bg_ev[3]);
THREAD_OFF(bvrf->bg_ev[4]); EVENT_OFF(bvrf->bg_ev[4]);
THREAD_OFF(bvrf->bg_ev[5]); EVENT_OFF(bvrf->bg_ev[5]);
/* Close all descriptors. */ /* Close all descriptors. */
socket_close(&bvrf->bg_echo); socket_close(&bvrf->bg_echo);

16
bfdd/bfd_packet.c
View File

@ -701,27 +701,27 @@ ssize_t bfd_recv_ipv6(int sd, uint8_t *msgbuf, size_t msgbuflen, uint8_t *ttl,
static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd) static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd)
{ {
if (sd == bvrf->bg_shop) { if (sd == bvrf->bg_shop) {
THREAD_OFF(bvrf->bg_ev[0]); EVENT_OFF(bvrf->bg_ev[0]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop,
&bvrf->bg_ev[0]); &bvrf->bg_ev[0]);
} else if (sd == bvrf->bg_mhop) { } else if (sd == bvrf->bg_mhop) {
THREAD_OFF(bvrf->bg_ev[1]); EVENT_OFF(bvrf->bg_ev[1]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop,
&bvrf->bg_ev[1]); &bvrf->bg_ev[1]);
} else if (sd == bvrf->bg_shop6) { } else if (sd == bvrf->bg_shop6) {
THREAD_OFF(bvrf->bg_ev[2]); EVENT_OFF(bvrf->bg_ev[2]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop6, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_shop6,
&bvrf->bg_ev[2]); &bvrf->bg_ev[2]);
} else if (sd == bvrf->bg_mhop6) { } else if (sd == bvrf->bg_mhop6) {
THREAD_OFF(bvrf->bg_ev[3]); EVENT_OFF(bvrf->bg_ev[3]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop6, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_mhop6,
&bvrf->bg_ev[3]); &bvrf->bg_ev[3]);
} else if (sd == bvrf->bg_echo) { } else if (sd == bvrf->bg_echo) {
THREAD_OFF(bvrf->bg_ev[4]); EVENT_OFF(bvrf->bg_ev[4]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echo, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echo,
&bvrf->bg_ev[4]); &bvrf->bg_ev[4]);
} else if (sd == bvrf->bg_echov6) { } else if (sd == bvrf->bg_echov6) {
THREAD_OFF(bvrf->bg_ev[5]); EVENT_OFF(bvrf->bg_ev[5]);
event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echov6, event_add_read(master, bfd_recv_cb, bvrf, bvrf->bg_echov6,
&bvrf->bg_ev[5]); &bvrf->bg_ev[5]);
} }
@ -770,7 +770,7 @@ static void cp_debug(bool mhop, struct sockaddr_any *peer,
void bfd_recv_cb(struct event *t) void bfd_recv_cb(struct event *t)
{ {
int sd = THREAD_FD(t); int sd = EVENT_FD(t);
struct bfd_session *bfd; struct bfd_session *bfd;
struct bfd_pkt *cp; struct bfd_pkt *cp;
bool is_mhop; bool is_mhop;
@ -781,7 +781,7 @@ void bfd_recv_cb(struct event *t)
struct sockaddr_any local, peer; struct sockaddr_any local, peer;
uint8_t msgbuf[1516]; uint8_t msgbuf[1516];
struct interface *ifp = NULL; struct interface *ifp = NULL;
struct bfd_vrf_global *bvrf = THREAD_ARG(t); struct bfd_vrf_global *bvrf = EVENT_ARG(t);
/* Schedule next read. */ /* Schedule next read. */
bfd_sd_reschedule(bvrf, sd); bfd_sd_reschedule(bvrf, sd);

6
bfdd/control.c
View File

@ -144,7 +144,7 @@ void control_shutdown(void)
void control_accept(struct event *t) void control_accept(struct event *t)
{ {
int csock, sd = THREAD_FD(t); int csock, sd = EVENT_FD(t);
csock = accept(sd, NULL, 0); csock = accept(sd, NULL, 0);
if (csock == -1) { if (csock == -1) {
@ -381,7 +381,7 @@ static void control_reset_buf(struct bfd_control_buffer *bcb)
static void control_read(struct event *t) static void control_read(struct event *t)
{ {
struct bfd_control_socket *bcs = THREAD_ARG(t); struct bfd_control_socket *bcs = EVENT_ARG(t);
struct bfd_control_buffer *bcb = &bcs->bcs_bin; struct bfd_control_buffer *bcb = &bcs->bcs_bin;
int sd = bcs->bcs_sd; int sd = bcs->bcs_sd;
struct bfd_control_msg bcm; struct bfd_control_msg bcm;
@ -516,7 +516,7 @@ schedule_next_read:
static void control_write(struct event *t) static void control_write(struct event *t)
{ {
struct bfd_control_socket *bcs = THREAD_ARG(t); struct bfd_control_socket *bcs = EVENT_ARG(t);
struct bfd_control_buffer *bcb = bcs->bcs_bout; struct bfd_control_buffer *bcb = bcs->bcs_bout;
int sd = bcs->bcs_sd; int sd = bcs->bcs_sd;
ssize_t bwrite; ssize_t bwrite;

26
bfdd/dplane.c
View File

@ -307,14 +307,14 @@ static ssize_t bfd_dplane_flush(struct bfd_dplane_ctx *bdc)
stream_pulldown(bdc->outbuf); stream_pulldown(bdc->outbuf);
/* Disable write ready events. */ /* Disable write ready events. */
THREAD_OFF(bdc->outbufev); EVENT_OFF(bdc->outbufev);
return total; return total;
} }
static void bfd_dplane_write(struct event *t) static void bfd_dplane_write(struct event *t)
{ {
struct bfd_dplane_ctx *bdc = THREAD_ARG(t); struct bfd_dplane_ctx *bdc = EVENT_ARG(t);
/* Handle connection stage. */ /* Handle connection stage. */
if (bdc->connecting && bfd_dplane_client_connecting(bdc)) if (bdc->connecting && bfd_dplane_client_connecting(bdc))
@ -601,7 +601,7 @@ skip_read:
static void bfd_dplane_read(struct event *t) static void bfd_dplane_read(struct event *t)
{ {
struct bfd_dplane_ctx *bdc = THREAD_ARG(t); struct bfd_dplane_ctx *bdc = EVENT_ARG(t);
int rv; int rv;
rv = bfd_dplane_expect(bdc, 0, bfd_dplane_handle_message, NULL); rv = bfd_dplane_expect(bdc, 0, bfd_dplane_handle_message, NULL);
@ -672,7 +672,7 @@ static void bfd_dplane_ctx_free(struct bfd_dplane_ctx *bdc)
/* Client mode has special treatment. */ /* Client mode has special treatment. */
if (bdc->client) { if (bdc->client) {
/* Disable connection event if any. */ /* Disable connection event if any. */
THREAD_OFF(bdc->connectev); EVENT_OFF(bdc->connectev);
/* Normal treatment on shutdown. */ /* Normal treatment on shutdown. */
if (bglobal.bg_shutdown) if (bglobal.bg_shutdown)
@ -680,8 +680,8 @@ static void bfd_dplane_ctx_free(struct bfd_dplane_ctx *bdc)
/* Attempt reconnection. */ /* Attempt reconnection. */
socket_close(&bdc->sock); socket_close(&bdc->sock);
THREAD_OFF(bdc->inbufev); EVENT_OFF(bdc->inbufev);
THREAD_OFF(bdc->outbufev); EVENT_OFF(bdc->outbufev);
event_add_timer(master, bfd_dplane_client_connect, bdc, 3, event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
&bdc->connectev); &bdc->connectev);
return; return;
@ -699,8 +699,8 @@ free_resources:
socket_close(&bdc->sock); socket_close(&bdc->sock);
stream_free(bdc->inbuf); stream_free(bdc->inbuf);
stream_free(bdc->outbuf); stream_free(bdc->outbuf);
THREAD_OFF(bdc->inbufev); EVENT_OFF(bdc->inbufev);
THREAD_OFF(bdc->outbufev); EVENT_OFF(bdc->outbufev);
XFREE(MTYPE_BFDD_DPLANE_CTX, bdc); XFREE(MTYPE_BFDD_DPLANE_CTX, bdc);
} }
@ -821,7 +821,7 @@ static uint16_t bfd_dplane_request_counters(const struct bfd_session *bs)
*/ */
static void bfd_dplane_accept(struct event *t) static void bfd_dplane_accept(struct event *t)
{ {
struct bfd_global *bg = THREAD_ARG(t); struct bfd_global *bg = EVENT_ARG(t);
struct bfd_dplane_ctx *bdc; struct bfd_dplane_ctx *bdc;
int sock; int sock;
@ -901,7 +901,7 @@ static bool bfd_dplane_client_connecting(struct bfd_dplane_ctx *bdc)
static void bfd_dplane_client_connect(struct event *t) static void bfd_dplane_client_connect(struct event *t)
{ {
struct bfd_dplane_ctx *bdc = THREAD_ARG(t); struct bfd_dplane_ctx *bdc = EVENT_ARG(t);
int rv, sock; int rv, sock;
socklen_t rvlen = sizeof(rv); socklen_t rvlen = sizeof(rv);
@ -949,8 +949,8 @@ static void bfd_dplane_client_connect(struct event *t)
} }
reschedule_connect: reschedule_connect:
THREAD_OFF(bdc->inbufev); EVENT_OFF(bdc->inbufev);
THREAD_OFF(bdc->outbufev); EVENT_OFF(bdc->outbufev);
socket_close(&sock); socket_close(&sock);
event_add_timer(master, bfd_dplane_client_connect, bdc, 3, event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
&bdc->connectev); &bdc->connectev);
@ -997,7 +997,7 @@ static int bfd_dplane_finish_late(void)
bfd_dplane_ctx_free(bdc); bfd_dplane_ctx_free(bdc);
/* Cancel accept thread and close socket. */ /* Cancel accept thread and close socket. */
THREAD_OFF(bglobal.bg_dplane_sockev); EVENT_OFF(bglobal.bg_dplane_sockev);
close(bglobal.bg_dplane_sock); close(bglobal.bg_dplane_sock);
return 0; return 0;

8
bfdd/event.c
View File

@ -95,20 +95,20 @@ void bfd_echo_xmttimer_update(struct bfd_session *bs, uint64_t jitter)
void bfd_recvtimer_delete(struct bfd_session *bs) void bfd_recvtimer_delete(struct bfd_session *bs)
{ {
THREAD_OFF(bs->recvtimer_ev); EVENT_OFF(bs->recvtimer_ev);
} }
void bfd_echo_recvtimer_delete(struct bfd_session *bs) void bfd_echo_recvtimer_delete(struct bfd_session *bs)
{ {
THREAD_OFF(bs->echo_recvtimer_ev); EVENT_OFF(bs->echo_recvtimer_ev);
} }
void bfd_xmttimer_delete(struct bfd_session *bs) void bfd_xmttimer_delete(struct bfd_session *bs)
{ {
THREAD_OFF(bs->xmttimer_ev); EVENT_OFF(bs->xmttimer_ev);
} }
void bfd_echo_xmttimer_delete(struct bfd_session *bs) void bfd_echo_xmttimer_delete(struct bfd_session *bs)
{ {
THREAD_OFF(bs->echo_xmttimer_ev); EVENT_OFF(bs->echo_xmttimer_ev);
} }

36
bgpd/bgp_bmp.c
View File

@ -1337,7 +1337,7 @@ static void bmp_stat_put_u32(struct stream *s, size_t *cnt, uint16_t type,
static void bmp_stats(struct event *thread) static void bmp_stats(struct event *thread)
{ {
struct bmp_targets *bt = THREAD_ARG(thread); struct bmp_targets *bt = EVENT_ARG(thread);
struct stream *s; struct stream *s;
struct peer *peer; struct peer *peer;
struct listnode *node; struct listnode *node;
@ -1390,7 +1390,7 @@ static void bmp_stats(struct event *thread)
/* read from the BMP socket to detect session termination */ /* read from the BMP socket to detect session termination */
static void bmp_read(struct event *t) static void bmp_read(struct event *t)
{ {
struct bmp *bmp = THREAD_ARG(t); struct bmp *bmp = EVENT_ARG(t);
char buf[1024]; char buf[1024];
ssize_t n; ssize_t n;
@ -1495,7 +1495,7 @@ static struct bmp *bmp_open(struct bmp_targets *bt, int bmp_sock)
static void bmp_accept(struct event *thread) static void bmp_accept(struct event *thread)
{ {
union sockunion su; union sockunion su;
struct bmp_listener *bl = THREAD_ARG(thread); struct bmp_listener *bl = EVENT_ARG(thread);
int bmp_sock; int bmp_sock;
/* We continue hearing BMP socket. */ /* We continue hearing BMP socket. */
@ -1517,7 +1517,7 @@ static void bmp_close(struct bmp *bmp)
struct bmp_queue_entry *bqe; struct bmp_queue_entry *bqe;
struct bmp_mirrorq *bmq; struct bmp_mirrorq *bmq;
THREAD_OFF(bmp->t_read); EVENT_OFF(bmp->t_read);
if (bmp->active) if (bmp->active)
bmp_active_disconnected(bmp->active); bmp_active_disconnected(bmp->active);
@ -1529,7 +1529,7 @@ static void bmp_close(struct bmp *bmp)
if (!bqe->refcount) if (!bqe->refcount)
XFREE(MTYPE_BMP_QUEUE, bqe); XFREE(MTYPE_BMP_QUEUE, bqe);
THREAD_OFF(bmp->t_read); EVENT_OFF(bmp->t_read);
pullwr_del(bmp->pullwr); pullwr_del(bmp->pullwr);
close(bmp->socket); close(bmp->socket);
} }
@ -1644,7 +1644,7 @@ static void bmp_targets_put(struct bmp_targets *bt)
struct bmp *bmp; struct bmp *bmp;
struct bmp_active *ba; struct bmp_active *ba;
THREAD_OFF(bt->t_stats); EVENT_OFF(bt->t_stats);
frr_each_safe (bmp_actives, &bt->actives, ba) frr_each_safe (bmp_actives, &bt->actives, ba)
bmp_active_put(ba); bmp_active_put(ba);
@ -1729,7 +1729,7 @@ out_sock:
static void bmp_listener_stop(struct bmp_listener *bl) static void bmp_listener_stop(struct bmp_listener *bl)
{ {
THREAD_OFF(bl->t_accept); EVENT_OFF(bl->t_accept);
if (bl->sock != -1) if (bl->sock != -1)
close(bl->sock); close(bl->sock);
@ -1768,9 +1768,9 @@ static struct bmp_active *bmp_active_get(struct bmp_targets *bt,
static void bmp_active_put(struct bmp_active *ba) static void bmp_active_put(struct bmp_active *ba)
{ {
THREAD_OFF(ba->t_timer); EVENT_OFF(ba->t_timer);
THREAD_OFF(ba->t_read); EVENT_OFF(ba->t_read);
THREAD_OFF(ba->t_write); EVENT_OFF(ba->t_write);
bmp_actives_del(&ba->targets->actives, ba); bmp_actives_del(&ba->targets->actives, ba);
@ -1904,16 +1904,16 @@ static void bmp_active_resolved(struct resolver_query *resq, const char *errstr,
static void bmp_active_thread(struct event *t) static void bmp_active_thread(struct event *t)
{ {
struct bmp_active *ba = THREAD_ARG(t); struct bmp_active *ba = EVENT_ARG(t);
socklen_t slen; socklen_t slen;
int status, ret; int status, ret;
vrf_id_t vrf_id; vrf_id_t vrf_id;
/* all 3 end up here, though only timer or read+write are active /* all 3 end up here, though only timer or read+write are active
* at a time */ * at a time */
THREAD_OFF(ba->t_timer); EVENT_OFF(ba->t_timer);
THREAD_OFF(ba->t_read); EVENT_OFF(ba->t_read);
THREAD_OFF(ba->t_write); EVENT_OFF(ba->t_write);
ba->last_err = NULL; ba->last_err = NULL;
@ -1967,9 +1967,9 @@ static void bmp_active_disconnected(struct bmp_active *ba)
static void bmp_active_setup(struct bmp_active *ba) static void bmp_active_setup(struct bmp_active *ba)
{ {
THREAD_OFF(ba->t_timer); EVENT_OFF(ba->t_timer);
THREAD_OFF(ba->t_read); EVENT_OFF(ba->t_read);
THREAD_OFF(ba->t_write); EVENT_OFF(ba->t_write);
if (ba->bmp) if (ba->bmp)
return; return;
@ -2190,7 +2190,7 @@ DEFPY(bmp_stats_cfg,
{ {
VTY_DECLVAR_CONTEXT_SUB(bmp_targets, bt); VTY_DECLVAR_CONTEXT_SUB(bmp_targets, bt);
THREAD_OFF(bt->t_stats); EVENT_OFF(bt->t_stats);
if (no) if (no)
bt->stat_msec = 0; bt->stat_msec = 0;
else if (interval_str) else if (interval_str)

4
bgpd/bgp_conditional_adv.c
View File

@ -165,7 +165,7 @@ static void bgp_conditional_adv_timer(struct event *t)
route_map_result_t ret; route_map_result_t ret;
bool advmap_table_changed = false; bool advmap_table_changed = false;
bgp = THREAD_ARG(t); bgp = EVENT_ARG(t);
assert(bgp); assert(bgp);
event_add_timer(bm->master, bgp_conditional_adv_timer, bgp, event_add_timer(bm->master, bgp_conditional_adv_timer, bgp,
@ -351,7 +351,7 @@ void bgp_conditional_adv_disable(struct peer *peer, afi_t afi, safi_t safi)
} }
/* Last filter removed. So cancel conditional routes polling thread. */ /* Last filter removed. So cancel conditional routes polling thread. */
THREAD_OFF(bgp->t_condition_check); EVENT_OFF(bgp->t_condition_check);
} }
static void peer_advertise_map_filter_update(struct peer *peer, afi_t afi, static void peer_advertise_map_filter_update(struct peer *peer, afi_t afi,

4
bgpd/bgp_damp.c
View File

@ -104,7 +104,7 @@ static void bgp_reuse_timer(struct event *t)
struct bgp_damp_info *next; struct bgp_damp_info *next;
time_t t_now, t_diff; time_t t_now, t_diff;
struct bgp_damp_config *bdc = THREAD_ARG(t); struct bgp_damp_config *bdc = EVENT_ARG(t);
bdc->t_reuse = NULL; bdc->t_reuse = NULL;
event_add_timer(bm->master, bgp_reuse_timer, bdc, DELTA_REUSE, event_add_timer(bm->master, bgp_reuse_timer, bdc, DELTA_REUSE,
@ -451,7 +451,7 @@ int bgp_damp_disable(struct bgp *bgp, afi_t afi, safi_t safi)
return 0; return 0;
/* Cancel reuse event. */ /* Cancel reuse event. */
THREAD_OFF(bdc->t_reuse); EVENT_OFF(bdc->t_reuse);
/* Clean BGP dampening information. */ /* Clean BGP dampening information. */
bgp_damp_info_clean(afi, safi); bgp_damp_info_clean(afi, safi);

4
bgpd/bgp_dump.c
View File

@ -431,7 +431,7 @@ static unsigned int bgp_dump_routes_func(int afi, int first_run,
static void bgp_dump_interval_func(struct event *t) static void bgp_dump_interval_func(struct event *t)
{ {
struct bgp_dump *bgp_dump; struct bgp_dump *bgp_dump;
bgp_dump = THREAD_ARG(t); bgp_dump = EVENT_ARG(t);
/* Reschedule dump even if file couldn't be opened this time... */ /* Reschedule dump even if file couldn't be opened this time... */
if (bgp_dump_open_file(bgp_dump) != NULL) { if (bgp_dump_open_file(bgp_dump) != NULL) {
@ -691,7 +691,7 @@ static int bgp_dump_unset(struct bgp_dump *bgp_dump)
} }
/* Removing interval event. */ /* Removing interval event. */
THREAD_OFF(bgp_dump->t_interval); EVENT_OFF(bgp_dump->t_interval);
bgp_dump->interval = 0; bgp_dump->interval = 0;

2
bgpd/bgp_evpn_mh.c
View File

@ -4936,7 +4936,7 @@ void bgp_evpn_mh_finish(void)
bgp_evpn_es_local_info_clear(es, true); bgp_evpn_es_local_info_clear(es, true);
} }
if (bgp_mh_info->t_cons_check) if (bgp_mh_info->t_cons_check)
THREAD_OFF(bgp_mh_info->t_cons_check); EVENT_OFF(bgp_mh_info->t_cons_check);
list_delete(&bgp_mh_info->local_es_list); list_delete(&bgp_mh_info->local_es_list);
list_delete(&bgp_mh_info->pend_es_list); list_delete(&bgp_mh_info->pend_es_list);
list_delete(&bgp_mh_info->ead_es_export_rtl); list_delete(&bgp_mh_info->ead_es_export_rtl);

198
bgpd/bgp_fsm.c
View File

@ -169,17 +169,17 @@ static struct peer *peer_xfer_conn(struct peer *from_peer)
*/ */
bgp_keepalives_off(from_peer); bgp_keepalives_off(from_peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
THREAD_OFF(peer->t_connect_check_r); EVENT_OFF(peer->t_connect_check_r);
THREAD_OFF(peer->t_connect_check_w); EVENT_OFF(peer->t_connect_check_w);
THREAD_OFF(from_peer->t_routeadv); EVENT_OFF(from_peer->t_routeadv);
THREAD_OFF(from_peer->t_connect); EVENT_OFF(from_peer->t_connect);
THREAD_OFF(from_peer->t_delayopen); EVENT_OFF(from_peer->t_delayopen);
THREAD_OFF(from_peer->t_connect_check_r); EVENT_OFF(from_peer->t_connect_check_r);
THREAD_OFF(from_peer->t_connect_check_w); EVENT_OFF(from_peer->t_connect_check_w);
THREAD_OFF(from_peer->t_process_packet); EVENT_OFF(from_peer->t_process_packet);
/* /*
* At this point in time, it is possible that there are packets pending * At this point in time, it is possible that there are packets pending
@ -364,23 +364,23 @@ void bgp_timer_set(struct peer *peer)
inactive. All other timer must be turned off */ inactive. All other timer must be turned off */
if (BGP_PEER_START_SUPPRESSED(peer) || !peer_active(peer) if (BGP_PEER_START_SUPPRESSED(peer) || !peer_active(peer)
|| peer->bgp->vrf_id == VRF_UNKNOWN) { || peer->bgp->vrf_id == VRF_UNKNOWN) {
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
} else { } else {
BGP_TIMER_ON(peer->t_start, bgp_start_timer, BGP_TIMER_ON(peer->t_start, bgp_start_timer,
peer->v_start); peer->v_start);
} }
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
break; break;
case Connect: case Connect:
/* After start timer is expired, the peer moves to Connect /* After start timer is expired, the peer moves to Connect
status. Make sure start timer is off and connect timer is status. Make sure start timer is off and connect timer is
on. */ on. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN)) if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN))
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer, BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
(peer->v_delayopen + peer->v_connect)); (peer->v_delayopen + peer->v_connect));
@ -388,19 +388,19 @@ void bgp_timer_set(struct peer *peer)
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer, BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
peer->v_connect); peer->v_connect);
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
break; break;
case Active: case Active:
/* Active is waiting connection from remote peer. And if /* Active is waiting connection from remote peer. And if
connect timer is expired, change status to Connect. */ connect timer is expired, change status to Connect. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
/* If peer is passive mode, do not set connect timer. */ /* If peer is passive mode, do not set connect timer. */
if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSIVE) if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSIVE)
|| CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) { || CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
} else { } else {
if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN)) if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN))
BGP_TIMER_ON( BGP_TIMER_ON(
@ -410,30 +410,30 @@ void bgp_timer_set(struct peer *peer)
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer, BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
peer->v_connect); peer->v_connect);
} }
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
break; break;
case OpenSent: case OpenSent:
/* OpenSent status. */ /* OpenSent status. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
if (peer->v_holdtime != 0) { if (peer->v_holdtime != 0) {
BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer, BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
peer->v_holdtime); peer->v_holdtime);
} else { } else {
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
} }
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
break; break;
case OpenConfirm: case OpenConfirm:
/* OpenConfirm status. */ /* OpenConfirm status. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
/* /*
* If the negotiated Hold Time value is zero, then the Hold Time * If the negotiated Hold Time value is zero, then the Hold Time
@ -441,7 +441,7 @@ void bgp_timer_set(struct peer *peer)
* Additionally if a different hold timer has been negotiated * Additionally if a different hold timer has been negotiated
* than we must stop then start the timer again * than we must stop then start the timer again
*/ */
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
if (peer->v_holdtime == 0) if (peer->v_holdtime == 0)
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
else { else {
@ -449,16 +449,16 @@ void bgp_timer_set(struct peer *peer)
peer->v_holdtime); peer->v_holdtime);
bgp_keepalives_on(peer); bgp_keepalives_on(peer);
} }
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
break; break;
case Established: case Established:
/* In Established status start and connect timer is turned /* In Established status start and connect timer is turned
off. */ off. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
/* /*
* Same as OpenConfirm, if holdtime is zero then both holdtime * Same as OpenConfirm, if holdtime is zero then both holdtime
@ -466,7 +466,7 @@ void bgp_timer_set(struct peer *peer)
* Additionally if a different hold timer has been negotiated * Additionally if a different hold timer has been negotiated
* then we must stop then start the timer again * then we must stop then start the timer again
*/ */
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
if (peer->v_holdtime == 0) if (peer->v_holdtime == 0)
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
else { else {
@ -476,22 +476,22 @@ void bgp_timer_set(struct peer *peer)
} }
break; break;
case Deleted: case Deleted:
THREAD_OFF(peer->t_gr_restart); EVENT_OFF(peer->t_gr_restart);
THREAD_OFF(peer->t_gr_stale); EVENT_OFF(peer->t_gr_stale);
FOREACH_AFI_SAFI (afi, safi) FOREACH_AFI_SAFI (afi, safi)
THREAD_OFF(peer->t_llgr_stale[afi][safi]); EVENT_OFF(peer->t_llgr_stale[afi][safi]);
THREAD_OFF(peer->t_pmax_restart); EVENT_OFF(peer->t_pmax_restart);
THREAD_OFF(peer->t_refresh_stalepath); EVENT_OFF(peer->t_refresh_stalepath);
/* fallthru */ /* fallthru */
case Clearing: case Clearing:
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer); bgp_keepalives_off(peer);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
break; break;
case BGP_STATUS_MAX: case BGP_STATUS_MAX:
flog_err(EC_LIB_DEVELOPMENT, flog_err(EC_LIB_DEVELOPMENT,
@ -506,12 +506,12 @@ static void bgp_start_timer(struct event *thread)
{ {
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (start timer expire).", peer->host); zlog_debug("%s [FSM] Timer (start timer expire).", peer->host);
THREAD_VAL(thread) = BGP_Start; EVENT_VAL(thread) = BGP_Start;
bgp_event(thread); /* bgp_event unlocks peer */ bgp_event(thread); /* bgp_event unlocks peer */
} }
@ -520,10 +520,10 @@ static void bgp_connect_timer(struct event *thread)
{ {
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
/* stop the DelayOpenTimer if it is running */ /* stop the DelayOpenTimer if it is running */
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
assert(!peer->t_write); assert(!peer->t_write);
assert(!peer->t_read); assert(!peer->t_read);
@ -534,7 +534,7 @@ static void bgp_connect_timer(struct event *thread)
if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)) if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER))
bgp_stop(peer); bgp_stop(peer);
else { else {
THREAD_VAL(thread) = ConnectRetry_timer_expired; EVENT_VAL(thread) = ConnectRetry_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */ bgp_event(thread); /* bgp_event unlocks peer */
} }
} }
@ -545,7 +545,7 @@ static void bgp_holdtime_timer(struct event *thread)
atomic_size_t inq_count; atomic_size_t inq_count;
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (holdtime timer expire)", zlog_debug("%s [FSM] Timer (holdtime timer expire)",
@ -567,7 +567,7 @@ static void bgp_holdtime_timer(struct event *thread)
BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer, BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
peer->v_holdtime); peer->v_holdtime);
THREAD_VAL(thread) = Hold_Timer_expired; EVENT_VAL(thread) = Hold_Timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */ bgp_event(thread); /* bgp_event unlocks peer */
} }
@ -575,7 +575,7 @@ void bgp_routeadv_timer(struct event *thread)
{ {
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (routeadv timer expire)", zlog_debug("%s [FSM] Timer (routeadv timer expire)",
@ -596,13 +596,13 @@ void bgp_delayopen_timer(struct event *thread)
{ {
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (DelayOpentimer expire)", zlog_debug("%s [FSM] Timer (DelayOpentimer expire)",
peer->host); peer->host);
THREAD_VAL(thread) = DelayOpen_timer_expired; EVENT_VAL(thread) = DelayOpen_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */ bgp_event(thread); /* bgp_event unlocks peer */
} }
@ -655,7 +655,7 @@ static void bgp_graceful_restart_timer_off(struct peer *peer)
return; return;
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT); UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
THREAD_OFF(peer->t_gr_stale); EVENT_OFF(peer->t_gr_stale);
if (peer_dynamic_neighbor(peer) && if (peer_dynamic_neighbor(peer) &&
!(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) { !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
@ -675,7 +675,7 @@ static void bgp_llgr_stale_timer_expire(struct event *thread)
afi_t afi; afi_t afi;
safi_t safi; safi_t safi;
paf = THREAD_ARG(thread); paf = EVENT_ARG(thread);
peer = paf->peer; peer = paf->peer;
afi = paf->afi; afi = paf->afi;
@ -778,7 +778,7 @@ static void bgp_graceful_restart_timer_expire(struct event *thread)
afi_t afi; afi_t afi;
safi_t safi; safi_t safi;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) { if (bgp_debug_neighbor_events(peer)) {
zlog_debug("%pBP graceful restart timer expired", peer); zlog_debug("%pBP graceful restart timer expired", peer);
@ -841,7 +841,7 @@ static void bgp_graceful_stale_timer_expire(struct event *thread)
afi_t afi; afi_t afi;
safi_t safi; safi_t safi;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart stalepath timer expired", zlog_debug("%pBP graceful restart stalepath timer expired",
@ -861,7 +861,7 @@ static void bgp_graceful_deferral_timer_expire(struct event *thread)
safi_t safi; safi_t safi;
struct bgp *bgp; struct bgp *bgp;
info = THREAD_ARG(thread); info = EVENT_ARG(thread);
afi = info->afi; afi = info->afi;
safi = info->safi; safi = info->safi;
bgp = info->bgp; bgp = info->bgp;
@ -908,8 +908,8 @@ bool bgp_update_delay_configured(struct bgp *bgp)
on ending the update delay. */ on ending the update delay. */
void bgp_update_delay_end(struct bgp *bgp) void bgp_update_delay_end(struct bgp *bgp)
{ {
THREAD_OFF(bgp->t_update_delay); EVENT_OFF(bgp->t_update_delay);
THREAD_OFF(bgp->t_establish_wait); EVENT_OFF(bgp->t_establish_wait);
/* Reset update-delay related state */ /* Reset update-delay related state */
bgp->update_delay_over = 1; bgp->update_delay_over = 1;
@ -972,7 +972,7 @@ void bgp_start_routeadv(struct bgp *bgp)
for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) { for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
if (!peer_established(peer)) if (!peer_established(peer))
continue; continue;
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0); BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
} }
} }
@ -992,7 +992,7 @@ void bgp_adjust_routeadv(struct peer *peer)
* different * different
* duration and schedule write thread immediately. * duration and schedule write thread immediately.
*/ */
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
peer->synctime = monotime(NULL); peer->synctime = monotime(NULL);
/* If suppress fib pending is enabled, route is advertised to /* If suppress fib pending is enabled, route is advertised to
@ -1024,7 +1024,7 @@ void bgp_adjust_routeadv(struct peer *peer)
*/ */
diff = difftime(nowtime, peer->last_update); diff = difftime(nowtime, peer->last_update);
if (diff > (double)peer->v_routeadv) { if (diff > (double)peer->v_routeadv) {
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0); BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
return; return;
} }
@ -1051,7 +1051,7 @@ void bgp_adjust_routeadv(struct peer *peer)
remain = peer->v_routeadv; remain = peer->v_routeadv;
diff = peer->v_routeadv - diff; diff = peer->v_routeadv - diff;
if (diff <= (double)remain) { if (diff <= (double)remain) {
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, diff); BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, diff);
} }
} }
@ -1130,8 +1130,8 @@ static void bgp_maxmed_onstartup_timer(struct event *thread)
zlog_info("Max med on startup ended - timer expired."); zlog_info("Max med on startup ended - timer expired.");
bgp = THREAD_ARG(thread); bgp = EVENT_ARG(thread);
THREAD_OFF(bgp->t_maxmed_onstartup); EVENT_OFF(bgp->t_maxmed_onstartup);
bgp->maxmed_onstartup_over = 1; bgp->maxmed_onstartup_over = 1;
bgp_maxmed_update(bgp); bgp_maxmed_update(bgp);
@ -1172,8 +1172,8 @@ static void bgp_update_delay_timer(struct event *thread)
zlog_info("Update delay ended - timer expired."); zlog_info("Update delay ended - timer expired.");
bgp = THREAD_ARG(thread); bgp = EVENT_ARG(thread);
THREAD_OFF(bgp->t_update_delay); EVENT_OFF(bgp->t_update_delay);
bgp_update_delay_end(bgp); bgp_update_delay_end(bgp);
} }
@ -1184,8 +1184,8 @@ static void bgp_establish_wait_timer(struct event *thread)
zlog_info("Establish wait - timer expired."); zlog_info("Establish wait - timer expired.");
bgp = THREAD_ARG(thread); bgp = EVENT_ARG(thread);
THREAD_OFF(bgp->t_establish_wait); EVENT_OFF(bgp->t_establish_wait);
bgp_check_update_delay(bgp); bgp_check_update_delay(bgp);
} }
@ -1412,7 +1412,7 @@ enum bgp_fsm_state_progress bgp_stop(struct peer *peer)
/* graceful restart */ /* graceful restart */
if (peer->t_gr_stale) { if (peer->t_gr_stale) {
THREAD_OFF(peer->t_gr_stale); EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP graceful restart stalepath timer stopped", "%pBP graceful restart stalepath timer stopped",
@ -1442,7 +1442,7 @@ enum bgp_fsm_state_progress bgp_stop(struct peer *peer)
/* Stop route-refresh stalepath timer */ /* Stop route-refresh stalepath timer */
if (peer->t_refresh_stalepath) { if (peer->t_refresh_stalepath) {
THREAD_OFF(peer->t_refresh_stalepath); EVENT_OFF(peer->t_refresh_stalepath);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
@ -1476,11 +1476,11 @@ enum bgp_fsm_state_progress bgp_stop(struct peer *peer)
/* There is no pending EOR message */ /* There is no pending EOR message */
if (gr_info->eor_required == 0) { if (gr_info->eor_required == 0) {
if (gr_info->t_select_deferral) { if (gr_info->t_select_deferral) {
void *info = THREAD_ARG( void *info = EVENT_ARG(
gr_info->t_select_deferral); gr_info->t_select_deferral);
XFREE(MTYPE_TMP, info); XFREE(MTYPE_TMP, info);
} }
THREAD_OFF(gr_info->t_select_deferral); EVENT_OFF(gr_info->t_select_deferral);
gr_info->eor_received = 0; gr_info->eor_received = 0;
} }
} }
@ -1505,15 +1505,15 @@ enum bgp_fsm_state_progress bgp_stop(struct peer *peer)
bgp_writes_off(peer); bgp_writes_off(peer);
bgp_reads_off(peer); bgp_reads_off(peer);
THREAD_OFF(peer->t_connect_check_r); EVENT_OFF(peer->t_connect_check_r);
THREAD_OFF(peer->t_connect_check_w); EVENT_OFF(peer->t_connect_check_w);
/* Stop all timers. */ /* Stop all timers. */
THREAD_OFF(peer->t_start); EVENT_OFF(peer->t_start);
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
/* Clear input and output buffer. */ /* Clear input and output buffer. */
frr_with_mutex (&peer->io_mtx) { frr_with_mutex (&peer->io_mtx) {
@ -1660,14 +1660,14 @@ static void bgp_connect_check(struct event *thread)
int ret; int ret;
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON)); assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON));
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON)); assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON));
assert(!peer->t_read); assert(!peer->t_read);
assert(!peer->t_write); assert(!peer->t_write);
THREAD_OFF(peer->t_connect_check_r); EVENT_OFF(peer->t_connect_check_r);
THREAD_OFF(peer->t_connect_check_w); EVENT_OFF(peer->t_connect_check_w);
/* Check file descriptor. */ /* Check file descriptor. */
slen = sizeof(status); slen = sizeof(status);
@ -2012,7 +2012,7 @@ static enum bgp_fsm_state_progress
bgp_fsm_delayopen_timer_expire(struct peer *peer) bgp_fsm_delayopen_timer_expire(struct peer *peer)
{ {
/* Stop the DelayOpenTimer */ /* Stop the DelayOpenTimer */
THREAD_OFF(peer->t_delayopen); EVENT_OFF(peer->t_delayopen);
/* Send open message to peer */ /* Send open message to peer */
bgp_open_send(peer); bgp_open_send(peer);
@ -2225,7 +2225,7 @@ static enum bgp_fsm_state_progress bgp_establish(struct peer *peer)
else { else {
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE); UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
if (peer->t_gr_stale) { if (peer->t_gr_stale) {
THREAD_OFF(peer->t_gr_stale); EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP graceful restart stalepath timer stopped", "%pBP graceful restart stalepath timer stopped",
@ -2234,7 +2234,7 @@ static enum bgp_fsm_state_progress bgp_establish(struct peer *peer)
} }
if (peer->t_gr_restart) { if (peer->t_gr_restart) {
THREAD_OFF(peer->t_gr_restart); EVENT_OFF(peer->t_gr_restart);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart timer stopped", peer); zlog_debug("%pBP graceful restart timer stopped", peer);
} }
@ -2250,7 +2250,7 @@ static enum bgp_fsm_state_progress bgp_establish(struct peer *peer)
*/ */
FOREACH_AFI_SAFI (afi, safi) { FOREACH_AFI_SAFI (afi, safi) {
if (peer->t_llgr_stale[afi][safi]) { if (peer->t_llgr_stale[afi][safi]) {
THREAD_OFF(peer->t_llgr_stale[afi][safi]); EVENT_OFF(peer->t_llgr_stale[afi][safi]);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP Long-lived stale timer stopped for afi/safi: %d/%d", "%pBP Long-lived stale timer stopped for afi/safi: %d/%d",
@ -2295,7 +2295,7 @@ static enum bgp_fsm_state_progress bgp_establish(struct peer *peer)
* of read-only mode. * of read-only mode.
*/ */
if (!bgp_update_delay_active(peer->bgp)) { if (!bgp_update_delay_active(peer->bgp)) {
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0); BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
} }
@ -2330,14 +2330,14 @@ static enum bgp_fsm_state_progress bgp_establish(struct peer *peer)
/* Keepalive packet is received. */ /* Keepalive packet is received. */
static enum bgp_fsm_state_progress bgp_fsm_keepalive(struct peer *peer) static enum bgp_fsm_state_progress bgp_fsm_keepalive(struct peer *peer)
{ {
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
return BGP_FSM_SUCCESS; return BGP_FSM_SUCCESS;
} }
/* Update packet is received. */ /* Update packet is received. */
static enum bgp_fsm_state_progress bgp_fsm_update(struct peer *peer) static enum bgp_fsm_state_progress bgp_fsm_update(struct peer *peer)
{ {
THREAD_OFF(peer->t_holdtime); EVENT_OFF(peer->t_holdtime);
return BGP_FSM_SUCCESS; return BGP_FSM_SUCCESS;
} }
@ -2379,13 +2379,13 @@ void bgp_fsm_nht_update(struct peer *peer, bool has_valid_nexthops)
break; break;
case Connect: case Connect:
if (!has_valid_nexthops) { if (!has_valid_nexthops) {
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
BGP_EVENT_ADD(peer, TCP_fatal_error); BGP_EVENT_ADD(peer, TCP_fatal_error);
} }
break; break;
case Active: case Active:
if (has_valid_nexthops) { if (has_valid_nexthops) {
THREAD_OFF(peer->t_connect); EVENT_OFF(peer->t_connect);
BGP_EVENT_ADD(peer, ConnectRetry_timer_expired); BGP_EVENT_ADD(peer, ConnectRetry_timer_expired);
} }
break; break;
@ -2576,8 +2576,8 @@ void bgp_event(struct event *thread)
enum bgp_fsm_events event; enum bgp_fsm_events event;
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
event = THREAD_VAL(thread); event = EVENT_VAL(thread);
peer_lock(peer); peer_lock(peer);
bgp_event_update(peer, event); bgp_event_update(peer, event);

12
bgpd/bgp_io.c
View File

@ -17,7 +17,7 @@
#include "network.h" // for ERRNO_IO_RETRY #include "network.h" // for ERRNO_IO_RETRY
#include "stream.h" // for stream_get_endp, stream_getw_from, str... #include "stream.h" // for stream_get_endp, stream_getw_from, str...
#include "ringbuf.h" // for ringbuf_remain, ringbuf_peek, ringbuf_... #include "ringbuf.h" // for ringbuf_remain, ringbuf_peek, ringbuf_...
#include "event.h" // for THREAD_OFF, THREAD_ARG, thread... #include "event.h" // for EVENT_OFF, EVENT_ARG, thread...
#include "bgpd/bgp_io.h" #include "bgpd/bgp_io.h"
#include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events, bgp_type_str #include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events, bgp_type_str
@ -66,7 +66,7 @@ void bgp_writes_off(struct peer *peer)
assert(fpt->running); assert(fpt->running);
event_cancel_async(fpt->master, &peer->t_write, NULL); event_cancel_async(fpt->master, &peer->t_write, NULL);
THREAD_OFF(peer->t_generate_updgrp_packets); EVENT_OFF(peer->t_generate_updgrp_packets);
UNSET_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON); UNSET_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON);
} }
@ -97,8 +97,8 @@ void bgp_reads_off(struct peer *peer)
assert(fpt->running); assert(fpt->running);
event_cancel_async(fpt->master, &peer->t_read, NULL); event_cancel_async(fpt->master, &peer->t_read, NULL);
THREAD_OFF(peer->t_process_packet); EVENT_OFF(peer->t_process_packet);
THREAD_OFF(peer->t_process_packet_error); EVENT_OFF(peer->t_process_packet_error);
UNSET_FLAG(peer->thread_flags, PEER_THREAD_READS_ON); UNSET_FLAG(peer->thread_flags, PEER_THREAD_READS_ON);
} }
@ -111,7 +111,7 @@ void bgp_reads_off(struct peer *peer)
static void bgp_process_writes(struct event *thread) static void bgp_process_writes(struct event *thread)
{ {
static struct peer *peer; static struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
uint16_t status; uint16_t status;
bool reschedule; bool reschedule;
bool fatal = false; bool fatal = false;
@ -223,7 +223,7 @@ static void bgp_process_reads(struct event *thread)
int ret = 1; int ret = 1;
/* clang-format on */ /* clang-format on */
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
if (peer->fd < 0 || bm->terminating) if (peer->fd < 0 || bm->terminating)
return; return;

2
bgpd/bgp_keepalives.c
View File

@ -15,7 +15,7 @@
#include "memory.h" // for MTYPE_TMP, XFREE, XCALLOC, XMALLOC #include "memory.h" // for MTYPE_TMP, XFREE, XCALLOC, XMALLOC
#include "monotime.h" // for monotime, monotime_since #include "monotime.h" // for monotime, monotime_since
#include "bgpd/bgpd.h" // for peer, PEER_THREAD_KEEPALIVES_ON, peer... #include "bgpd/bgpd.h" // for peer, PEER_EVENT_KEEPALIVES_ON, peer...
#include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events #include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events
#include "bgpd/bgp_packet.h" // for bgp_keepalive_send #include "bgpd/bgp_packet.h" // for bgp_keepalive_send
#include "bgpd/bgp_keepalives.h" #include "bgpd/bgp_keepalives.h"

14
bgpd/bgp_network.c
View File

@ -343,7 +343,7 @@ static void bgp_accept(struct event *thread)
int bgp_sock; int bgp_sock;
int accept_sock; int accept_sock;
union sockunion su; union sockunion su;
struct bgp_listener *listener = THREAD_ARG(thread); struct bgp_listener *listener = EVENT_ARG(thread);
struct peer *peer; struct peer *peer;
struct peer *peer1; struct peer *peer1;
char buf[SU_ADDRSTRLEN]; char buf[SU_ADDRSTRLEN];
@ -354,7 +354,7 @@ static void bgp_accept(struct event *thread)
bgp = bgp_lookup_by_name(listener->name); bgp = bgp_lookup_by_name(listener->name);
/* Register accept thread. */ /* Register accept thread. */
accept_sock = THREAD_FD(thread); accept_sock = EVENT_FD(thread);
if (accept_sock < 0) { if (accept_sock < 0) {
flog_err_sys(EC_LIB_SOCKET, flog_err_sys(EC_LIB_SOCKET,
"[Error] BGP accept socket fd is negative: %d", "[Error] BGP accept socket fd is negative: %d",
@ -391,7 +391,7 @@ static void bgp_accept(struct event *thread)
"[Error] accept() failed with error \"%s\" on BGP listener socket %d for BGP instance in VRF \"%s\"; refreshing socket", "[Error] accept() failed with error \"%s\" on BGP listener socket %d for BGP instance in VRF \"%s\"; refreshing socket",
safe_strerror(save_errno), accept_sock, safe_strerror(save_errno), accept_sock,
VRF_LOGNAME(vrf)); VRF_LOGNAME(vrf));
THREAD_OFF(listener->thread); EVENT_OFF(listener->thread);
} else { } else {
flog_err_sys( flog_err_sys(
EC_LIB_SOCKET, EC_LIB_SOCKET,
@ -436,7 +436,7 @@ static void bgp_accept(struct event *thread)
sockopt_tcp_mss_set(bgp_sock, peer1->tcp_mss); sockopt_tcp_mss_set(bgp_sock, peer1->tcp_mss);
bgp_fsm_change_status(peer1, Active); bgp_fsm_change_status(peer1, Active);
THREAD_OFF( EVENT_OFF(
peer1->t_start); /* created in peer_create() */ peer1->t_start); /* created in peer_create() */
if (peer_active(peer1)) { if (peer_active(peer1)) {
@ -569,7 +569,7 @@ static void bgp_accept(struct event *thread)
} }
bgp_peer_reg_with_nht(peer); bgp_peer_reg_with_nht(peer);
bgp_fsm_change_status(peer, Active); bgp_fsm_change_status(peer, Active);
THREAD_OFF(peer->t_start); /* created in peer_create() */ EVENT_OFF(peer->t_start); /* created in peer_create() */
SET_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER); SET_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER);
/* Make dummy peer until read Open packet. */ /* Make dummy peer until read Open packet. */
@ -961,7 +961,7 @@ void bgp_close_vrf_socket(struct bgp *bgp)
for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) { for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) {
if (listener->bgp == bgp) { if (listener->bgp == bgp) {
THREAD_OFF(listener->thread); EVENT_OFF(listener->thread);
close(listener->fd); close(listener->fd);
listnode_delete(bm->listen_sockets, listener); listnode_delete(bm->listen_sockets, listener);
XFREE(MTYPE_BGP_LISTENER, listener->name); XFREE(MTYPE_BGP_LISTENER, listener->name);
@ -983,7 +983,7 @@ void bgp_close(void)
for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) { for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) {
if (listener->bgp) if (listener->bgp)
continue; continue;
THREAD_OFF(listener->thread); EVENT_OFF(listener->thread);
close(listener->fd); close(listener->fd);
listnode_delete(bm->listen_sockets, listener); listnode_delete(bm->listen_sockets, listener);
XFREE(MTYPE_BGP_LISTENER, listener->name); XFREE(MTYPE_BGP_LISTENER, listener->name);

4
bgpd/bgp_nht.c
View File

@ -758,8 +758,8 @@ void bgp_nht_ifp_down(struct interface *ifp)
static void bgp_nht_ifp_initial(struct event *thread) static void bgp_nht_ifp_initial(struct event *thread)
{ {
ifindex_t ifindex = THREAD_VAL(thread); ifindex_t ifindex = EVENT_VAL(thread);
struct bgp *bgp = THREAD_ARG(thread); struct bgp *bgp = EVENT_ARG(thread);
struct interface *ifp = if_lookup_by_index(ifindex, bgp->vrf_id); struct interface *ifp = if_lookup_by_index(ifindex, bgp->vrf_id);
if (!ifp) if (!ifp)

18
bgpd/bgp_packet.c
View File

@ -444,7 +444,7 @@ static void bgp_write_proceed_actions(struct peer *peer)
*/ */
void bgp_generate_updgrp_packets(struct event *thread) void bgp_generate_updgrp_packets(struct event *thread)
{ {
struct peer *peer = THREAD_ARG(thread); struct peer *peer = EVENT_ARG(thread);
struct stream *s; struct stream *s;
struct peer_af *paf; struct peer_af *paf;
@ -1796,7 +1796,7 @@ static void bgp_refresh_stalepath_timer_expire(struct event *thread)
{ {
struct peer_af *paf; struct peer_af *paf;
paf = THREAD_ARG(thread); paf = EVENT_ARG(thread);
afi_t afi = paf->afi; afi_t afi = paf->afi;
safi_t safi = paf->safi; safi_t safi = paf->safi;
@ -2106,11 +2106,11 @@ static int bgp_update_receive(struct peer *peer, bgp_size_t size)
"EOR RCV", "EOR RCV",
gr_info->eor_received); gr_info->eor_received);
if (gr_info->t_select_deferral) { if (gr_info->t_select_deferral) {
void *info = THREAD_ARG( void *info = EVENT_ARG(
gr_info->t_select_deferral); gr_info->t_select_deferral);
XFREE(MTYPE_TMP, info); XFREE(MTYPE_TMP, info);
} }
THREAD_OFF(gr_info->t_select_deferral); EVENT_OFF(gr_info->t_select_deferral);
gr_info->eor_required = 0; gr_info->eor_required = 0;
gr_info->eor_received = 0; gr_info->eor_received = 0;
/* Best path selection */ /* Best path selection */
@ -2613,7 +2613,7 @@ static int bgp_route_refresh_receive(struct peer *peer, bgp_size_t size)
return BGP_PACKET_NOOP; return BGP_PACKET_NOOP;
} }
THREAD_OFF(peer->t_refresh_stalepath); EVENT_OFF(peer->t_refresh_stalepath);
SET_FLAG(peer->af_sflags[afi][safi], PEER_STATUS_EORR_RECEIVED); SET_FLAG(peer->af_sflags[afi][safi], PEER_STATUS_EORR_RECEIVED);
UNSET_FLAG(peer->af_sflags[afi][safi], UNSET_FLAG(peer->af_sflags[afi][safi],
@ -2863,7 +2863,7 @@ int bgp_capability_receive(struct peer *peer, bgp_size_t size)
* would not, making event flow difficult to understand. Please think twice * would not, making event flow difficult to understand. Please think twice
* before hacking this. * before hacking this.
* *
* Thread type: THREAD_EVENT * Thread type: EVENT_EVENT
* @param thread * @param thread
* @return 0 * @return 0
*/ */
@ -2875,7 +2875,7 @@ void bgp_process_packet(struct event *thread)
int fsm_update_result; // return code of bgp_event_update() int fsm_update_result; // return code of bgp_event_update()
int mprc; // message processing return code int mprc; // message processing return code
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
rpkt_quanta_old = atomic_load_explicit(&peer->bgp->rpkt_quanta, rpkt_quanta_old = atomic_load_explicit(&peer->bgp->rpkt_quanta,
memory_order_relaxed); memory_order_relaxed);
fsm_update_result = 0; fsm_update_result = 0;
@ -3049,8 +3049,8 @@ void bgp_packet_process_error(struct event *thread)
struct peer *peer; struct peer *peer;
int code; int code;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
code = THREAD_VAL(thread); code = EVENT_VAL(thread);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [Event] BGP error %d on fd %d", zlog_debug("%s [Event] BGP error %d on fd %d",

20
bgpd/bgp_route.c
View File

@ -2625,7 +2625,7 @@ static void bgp_route_select_timer_expire(struct event *thread)
safi_t safi; safi_t safi;
struct bgp *bgp; struct bgp *bgp;
info = THREAD_ARG(thread); info = EVENT_ARG(thread);
afi = info->afi; afi = info->afi;
safi = info->safi; safi = info->safi;
bgp = info->bgp; bgp = info->bgp;
@ -3383,9 +3383,9 @@ void bgp_best_path_select_defer(struct bgp *bgp, afi_t afi, safi_t safi)
if (bgp->gr_info[afi][safi].t_route_select) { if (bgp->gr_info[afi][safi].t_route_select) {
struct event *t = bgp->gr_info[afi][safi].t_route_select; struct event *t = bgp->gr_info[afi][safi].t_route_select;
thread_info = THREAD_ARG(t); thread_info = EVENT_ARG(t);
XFREE(MTYPE_TMP, thread_info); XFREE(MTYPE_TMP, thread_info);
THREAD_OFF(bgp->gr_info[afi][safi].t_route_select); EVENT_OFF(bgp->gr_info[afi][safi].t_route_select);
} }
if (BGP_DEBUG(update, UPDATE_OUT)) { if (BGP_DEBUG(update, UPDATE_OUT)) {
@ -3589,7 +3589,7 @@ static void bgp_maximum_prefix_restart_timer(struct event *thread)
{ {
struct peer *peer; struct peer *peer;
peer = THREAD_ARG(thread); peer = EVENT_ARG(thread);
peer->t_pmax_restart = NULL; peer->t_pmax_restart = NULL;
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
@ -5046,7 +5046,7 @@ void bgp_stop_announce_route_timer(struct peer_af *paf)
if (!paf->t_announce_route) if (!paf->t_announce_route)
return; return;
THREAD_OFF(paf->t_announce_route); EVENT_OFF(paf->t_announce_route);
} }
/* /*
@ -5060,7 +5060,7 @@ static void bgp_announce_route_timer_expired(struct event *t)
struct peer_af *paf; struct peer_af *paf;
struct peer *peer; struct peer *peer;
paf = THREAD_ARG(t); paf = EVENT_ARG(t);
peer = paf->peer; peer = paf->peer;
if (!peer_established(peer)) if (!peer_established(peer))
@ -5225,7 +5225,7 @@ static void bgp_soft_reconfig_table_task(struct event *thread)
struct prefix_rd *prd; struct prefix_rd *prd;
struct listnode *node, *nnode; struct listnode *node, *nnode;
table = THREAD_ARG(thread); table = EVENT_ARG(thread);
prd = NULL; prd = NULL;
max_iter = SOFT_RECONFIG_TASK_MAX_PREFIX; max_iter = SOFT_RECONFIG_TASK_MAX_PREFIX;
@ -5319,7 +5319,7 @@ void bgp_soft_reconfig_table_task_cancel(const struct bgp *bgp,
list_delete(&ntable->soft_reconfig_peers); list_delete(&ntable->soft_reconfig_peers);
bgp_soft_reconfig_table_flag(ntable, false); bgp_soft_reconfig_table_flag(ntable, false);
THREAD_OFF(ntable->soft_reconfig_thread); EVENT_OFF(ntable->soft_reconfig_thread);
} }
} }
@ -13346,7 +13346,7 @@ static void bgp_table_stats_walker(struct event *t)
{ {
struct bgp_dest *dest, *ndest; struct bgp_dest *dest, *ndest;
struct bgp_dest *top; struct bgp_dest *top;
struct bgp_table_stats *ts = THREAD_ARG(t); struct bgp_table_stats *ts = EVENT_ARG(t);
unsigned int space = 0; unsigned int space = 0;
if (!(top = bgp_table_top(ts->table))) if (!(top = bgp_table_top(ts->table)))
@ -13743,7 +13743,7 @@ static void bgp_peer_count_walker(struct event *t)
{ {
struct bgp_dest *rn, *rm; struct bgp_dest *rn, *rm;
const struct bgp_table *table; const struct bgp_table *table;
struct peer_pcounts *pc = THREAD_ARG(t); struct peer_pcounts *pc = EVENT_ARG(t);
if (pc->safi == SAFI_MPLS_VPN || pc->safi == SAFI_ENCAP if (pc->safi == SAFI_MPLS_VPN || pc->safi == SAFI_ENCAP
|| pc->safi == SAFI_EVPN) { || pc->safi == SAFI_EVPN) {

2
bgpd/bgp_routemap.c
View File

@ -4357,7 +4357,7 @@ static void bgp_route_map_mark_update(const char *rmap_name)
/* If new update is received before the current timer timed out, /* If new update is received before the current timer timed out,
* turn it off and start a new timer. * turn it off and start a new timer.
*/ */
THREAD_OFF(bm->t_rmap_update); EVENT_OFF(bm->t_rmap_update);
/* rmap_update_timer of 0 means don't do route updates */ /* rmap_update_timer of 0 means don't do route updates */
if (bm->rmap_update_timer) { if (bm->rmap_update_timer) {

6
bgpd/bgp_rpki.c
View File

@ -383,7 +383,7 @@ struct rpki_revalidate_prefix {
static void rpki_revalidate_prefix(struct event *thread) static void rpki_revalidate_prefix(struct event *thread)
{ {
struct rpki_revalidate_prefix *rrp = THREAD_ARG(thread); struct rpki_revalidate_prefix *rrp = EVENT_ARG(thread);
struct bgp_dest *match, *node; struct bgp_dest *match, *node;
match = bgp_table_subtree_lookup(rrp->bgp->rib[rrp->afi][rrp->safi], match = bgp_table_subtree_lookup(rrp->bgp->rib[rrp->afi][rrp->safi],
@ -491,7 +491,7 @@ struct rpki_revalidate_peer {
static void bgp_rpki_revalidate_peer(struct event *thread) static void bgp_rpki_revalidate_peer(struct event *thread)
{ {
struct rpki_revalidate_peer *rvp = THREAD_ARG(thread); struct rpki_revalidate_peer *rvp = EVENT_ARG(thread);
/* /*
* Here's the expensive bit of gnomish deviousness * Here's the expensive bit of gnomish deviousness
@ -693,7 +693,7 @@ static void stop(void)
{ {
rtr_is_stopping = true; rtr_is_stopping = true;
if (is_running()) { if (is_running()) {
THREAD_OFF(t_rpki_sync); EVENT_OFF(t_rpki_sync);
rtr_mgr_stop(rtr_config); rtr_mgr_stop(rtr_config);
rtr_mgr_free(rtr_config); rtr_mgr_free(rtr_config);
rtr_is_running = false; rtr_is_running = false;

10
bgpd/bgp_updgrp.c
View File

@ -1099,8 +1099,8 @@ static void update_subgroup_delete(struct update_subgroup *subgrp)
if (subgrp->update_group) if (subgrp->update_group)
UPDGRP_INCR_STAT(subgrp->update_group, subgrps_deleted); UPDGRP_INCR_STAT(subgrp->update_group, subgrps_deleted);
THREAD_OFF(subgrp->t_merge_check); EVENT_OFF(subgrp->t_merge_check);
THREAD_OFF(subgrp->t_coalesce); EVENT_OFF(subgrp->t_coalesce);
bpacket_queue_cleanup(SUBGRP_PKTQ(subgrp)); bpacket_queue_cleanup(SUBGRP_PKTQ(subgrp));
subgroup_clear_table(subgrp); subgroup_clear_table(subgrp);
@ -1422,7 +1422,7 @@ static void update_subgroup_merge_check_thread_cb(struct event *thread)
{ {
struct update_subgroup *subgrp; struct update_subgroup *subgrp;
subgrp = THREAD_ARG(thread); subgrp = EVENT_ARG(thread);
subgrp->t_merge_check = NULL; subgrp->t_merge_check = NULL;
@ -2112,10 +2112,10 @@ void update_group_refresh_default_originate_route_map(struct event *thread)
struct bgp *bgp; struct bgp *bgp;
char reason[] = "refresh default-originate route-map"; char reason[] = "refresh default-originate route-map";
bgp = THREAD_ARG(thread); bgp = EVENT_ARG(thread);
update_group_walk(bgp, update_group_default_originate_route_map_walkcb, update_group_walk(bgp, update_group_default_originate_route_map_walkcb,
reason); reason);
THREAD_OFF(bgp->t_rmap_def_originate_eval); EVENT_OFF(bgp->t_rmap_def_originate_eval);
bgp_unlock(bgp); bgp_unlock(bgp);
} }

4
bgpd/bgp_updgrp_adv.c
View File

@ -303,7 +303,7 @@ static void subgroup_coalesce_timer(struct event *thread)
struct update_subgroup *subgrp; struct update_subgroup *subgrp;
struct bgp *bgp; struct bgp *bgp;
subgrp = THREAD_ARG(thread); subgrp = EVENT_ARG(thread);
if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
zlog_debug("u%" PRIu64 ":s%" PRIu64" announcing routes upon coalesce timer expiry(%u ms)", zlog_debug("u%" PRIu64 ":s%" PRIu64" announcing routes upon coalesce timer expiry(%u ms)",
(SUBGRP_UPDGRP(subgrp))->id, subgrp->id, (SUBGRP_UPDGRP(subgrp))->id, subgrp->id,
@ -329,7 +329,7 @@ static void subgroup_coalesce_timer(struct event *thread)
SUBGRP_FOREACH_PEER (subgrp, paf) { SUBGRP_FOREACH_PEER (subgrp, paf) {
peer = PAF_PEER(paf); peer = PAF_PEER(paf);
THREAD_OFF(peer->t_routeadv); EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0); BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
} }
} }

8
bgpd/bgp_vty.c
View File

@ -2194,7 +2194,7 @@ DEFUN (no_bgp_maxmed_onstartup,
/* Cancel max-med onstartup if its on */ /* Cancel max-med onstartup if its on */
if (bgp->t_maxmed_onstartup) { if (bgp->t_maxmed_onstartup) {
THREAD_OFF(bgp->t_maxmed_onstartup); EVENT_OFF(bgp->t_maxmed_onstartup);
bgp->maxmed_onstartup_over = 1; bgp->maxmed_onstartup_over = 1;
} }
@ -7518,7 +7518,7 @@ DEFUN (bgp_set_route_map_delay_timer,
* fired. * fired.
*/ */
if (!rmap_delay_timer && bm->t_rmap_update) { if (!rmap_delay_timer && bm->t_rmap_update) {
THREAD_OFF(bm->t_rmap_update); EVENT_OFF(bm->t_rmap_update);
event_execute(bm->master, bgp_route_map_update_timer, event_execute(bm->master, bgp_route_map_update_timer,
NULL, 0); NULL, 0);
} }
@ -18783,7 +18783,7 @@ static void bgp_config_finish(struct event *t)
static void bgp_config_start(void) static void bgp_config_start(void)
{ {
#define BGP_PRE_CONFIG_MAX_WAIT_SECONDS 600 #define BGP_PRE_CONFIG_MAX_WAIT_SECONDS 600
THREAD_OFF(t_bgp_cfg); EVENT_OFF(t_bgp_cfg);
event_add_timer(bm->master, bgp_config_finish, NULL, event_add_timer(bm->master, bgp_config_finish, NULL,
BGP_PRE_CONFIG_MAX_WAIT_SECONDS, &t_bgp_cfg); BGP_PRE_CONFIG_MAX_WAIT_SECONDS, &t_bgp_cfg);
} }
@ -18807,7 +18807,7 @@ static void bgp_config_end(void)
if (!bgp_config_inprocess()) if (!bgp_config_inprocess())
return; return;
THREAD_OFF(t_bgp_cfg); EVENT_OFF(t_bgp_cfg);
/* Start a new timer to make sure we don't send EoR /* Start a new timer to make sure we don't send EoR
* before route-maps are processed. * before route-maps are processed.

2
bgpd/bgp_zebra.c
View File

@ -1058,7 +1058,7 @@ static void bgp_zebra_tm_connect(struct event *t)
struct zclient *zclient; struct zclient *zclient;
int delay = 10, ret = 0; int delay = 10, ret = 0;
zclient = THREAD_ARG(t); zclient = EVENT_ARG(t);
if (bgp_tm_status_connected && zclient->sock > 0) if (bgp_tm_status_connected && zclient->sock > 0)
delay = 60; delay = 60;
else { else {

42
bgpd/bgpd.c
View File

@ -1128,7 +1128,7 @@ static void peer_free(struct peer *peer)
bgp_writes_off(peer); bgp_writes_off(peer);
event_cancel_event_ready(bm->master, peer); event_cancel_event_ready(bm->master, peer);
FOREACH_AFI_SAFI (afi, safi) FOREACH_AFI_SAFI (afi, safi)
THREAD_OFF(peer->t_revalidate_all[afi][safi]); EVENT_OFF(peer->t_revalidate_all[afi][safi]);
assert(!peer->t_write); assert(!peer->t_write);
assert(!peer->t_read); assert(!peer->t_read);
BGP_EVENT_FLUSH(peer); BGP_EVENT_FLUSH(peer);
@ -2467,16 +2467,16 @@ void peer_nsf_stop(struct peer *peer)
FOREACH_AFI_SAFI_NSF (afi, safi) { FOREACH_AFI_SAFI_NSF (afi, safi) {
peer->nsf[afi][safi] = 0; peer->nsf[afi][safi] = 0;
THREAD_OFF(peer->t_llgr_stale[afi][safi]); EVENT_OFF(peer->t_llgr_stale[afi][safi]);
} }
if (peer->t_gr_restart) { if (peer->t_gr_restart) {
THREAD_OFF(peer->t_gr_restart); EVENT_OFF(peer->t_gr_restart);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart timer stopped", peer); zlog_debug("%pBP graceful restart timer stopped", peer);
} }
if (peer->t_gr_stale) { if (peer->t_gr_stale) {
THREAD_OFF(peer->t_gr_stale); EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP graceful restart stalepath timer stopped", "%pBP graceful restart stalepath timer stopped",
@ -2518,7 +2518,7 @@ int peer_delete(struct peer *peer)
bgp_writes_off(peer); bgp_writes_off(peer);
event_cancel_event_ready(bm->master, peer); event_cancel_event_ready(bm->master, peer);
FOREACH_AFI_SAFI (afi, safi) FOREACH_AFI_SAFI (afi, safi)
THREAD_OFF(peer->t_revalidate_all[afi][safi]); EVENT_OFF(peer->t_revalidate_all[afi][safi]);
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON)); assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON));
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON)); assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON));
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON)); assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON));
@ -3201,7 +3201,7 @@ static void bgp_startup_timer_expire(struct event *thread)
{ {
struct bgp *bgp; struct bgp *bgp;
bgp = THREAD_ARG(thread); bgp = EVENT_ARG(thread);
bgp->t_startup = NULL; bgp->t_startup = NULL;
} }
@ -3696,7 +3696,7 @@ void bgp_instance_down(struct bgp *bgp)
/* Stop timers. */ /* Stop timers. */
if (bgp->t_rmap_def_originate_eval) { if (bgp->t_rmap_def_originate_eval) {
THREAD_OFF(bgp->t_rmap_def_originate_eval); EVENT_OFF(bgp->t_rmap_def_originate_eval);
bgp_unlock(bgp); /* TODO - This timer is started with a lock - bgp_unlock(bgp); /* TODO - This timer is started with a lock -
why? */ why? */
} }
@ -3748,13 +3748,13 @@ int bgp_delete(struct bgp *bgp)
hook_call(bgp_inst_delete, bgp); hook_call(bgp_inst_delete, bgp);
FOREACH_AFI_SAFI (afi, safi) FOREACH_AFI_SAFI (afi, safi)
THREAD_OFF(bgp->t_revalidate[afi][safi]); EVENT_OFF(bgp->t_revalidate[afi][safi]);
THREAD_OFF(bgp->t_condition_check); EVENT_OFF(bgp->t_condition_check);
THREAD_OFF(bgp->t_startup); EVENT_OFF(bgp->t_startup);
THREAD_OFF(bgp->t_maxmed_onstartup); EVENT_OFF(bgp->t_maxmed_onstartup);
THREAD_OFF(bgp->t_update_delay); EVENT_OFF(bgp->t_update_delay);
THREAD_OFF(bgp->t_establish_wait); EVENT_OFF(bgp->t_establish_wait);
/* Set flag indicating bgp instance delete in progress */ /* Set flag indicating bgp instance delete in progress */
SET_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS); SET_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS);
@ -3768,19 +3768,19 @@ int bgp_delete(struct bgp *bgp)
continue; continue;
t = gr_info->t_select_deferral; t = gr_info->t_select_deferral;
if (t) { if (t) {
void *info = THREAD_ARG(t); void *info = EVENT_ARG(t);
XFREE(MTYPE_TMP, info); XFREE(MTYPE_TMP, info);
} }
THREAD_OFF(gr_info->t_select_deferral); EVENT_OFF(gr_info->t_select_deferral);
t = gr_info->t_route_select; t = gr_info->t_route_select;
if (t) { if (t) {
void *info = THREAD_ARG(t); void *info = EVENT_ARG(t);
XFREE(MTYPE_TMP, info); XFREE(MTYPE_TMP, info);
} }
THREAD_OFF(gr_info->t_route_select); EVENT_OFF(gr_info->t_route_select);
} }
if (BGP_DEBUG(zebra, ZEBRA)) { if (BGP_DEBUG(zebra, ZEBRA)) {
@ -3803,7 +3803,7 @@ int bgp_delete(struct bgp *bgp)
/* Stop timers. */ /* Stop timers. */
if (bgp->t_rmap_def_originate_eval) { if (bgp->t_rmap_def_originate_eval) {
THREAD_OFF(bgp->t_rmap_def_originate_eval); EVENT_OFF(bgp->t_rmap_def_originate_eval);
bgp_unlock(bgp); /* TODO - This timer is started with a lock - bgp_unlock(bgp); /* TODO - This timer is started with a lock -
why? */ why? */
} }
@ -4528,7 +4528,7 @@ static void peer_flag_modify_action(struct peer *peer, uint64_t flag)
UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW); UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
if (peer->t_pmax_restart) { if (peer->t_pmax_restart) {
THREAD_OFF(peer->t_pmax_restart); EVENT_OFF(peer->t_pmax_restart);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP Maximum-prefix restart timer canceled", "%pBP Maximum-prefix restart timer canceled",
@ -7398,7 +7398,7 @@ static bool peer_maximum_prefix_clear_overflow(struct peer *peer)
UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW); UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
if (peer->t_pmax_restart) { if (peer->t_pmax_restart) {
THREAD_OFF(peer->t_pmax_restart); EVENT_OFF(peer->t_pmax_restart);
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
zlog_debug( zlog_debug(
"%pBP Maximum-prefix restart timer cancelled", "%pBP Maximum-prefix restart timer cancelled",
@ -8276,7 +8276,7 @@ void bgp_terminate(void)
if (bm->listen_sockets) if (bm->listen_sockets)
list_delete(&bm->listen_sockets); list_delete(&bm->listen_sockets);
THREAD_OFF(bm->t_rmap_update); EVENT_OFF(bm->t_rmap_update);
bgp_mac_finish(); bgp_mac_finish();
} }

33
bgpd/rfapi/rfapi_import.c
View File

@ -848,10 +848,10 @@ static void rfapiBgpInfoChainFree(struct bgp_path_info *bpi)
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED) if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) { && bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = struct rfapi_withdraw *wcb =
THREAD_ARG(bpi->extra->vnc.import.timer); EVENT_ARG(bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb); XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
THREAD_OFF(bpi->extra->vnc.import.timer); EVENT_OFF(bpi->extra->vnc.import.timer);
} }
next = bpi->next; next = bpi->next;
@ -2347,7 +2347,7 @@ static void rfapiMonitorEncapDelete(struct bgp_path_info *vpn_bpi)
*/ */
static void rfapiWithdrawTimerVPN(struct event *t) static void rfapiWithdrawTimerVPN(struct event *t)
{ {
struct rfapi_withdraw *wcb = THREAD_ARG(t); struct rfapi_withdraw *wcb = EVENT_ARG(t);
struct bgp_path_info *bpi = wcb->info; struct bgp_path_info *bpi = wcb->info;
struct bgp *bgp = bgp_get_default(); struct bgp *bgp = bgp_get_default();
const struct prefix *p; const struct prefix *p;
@ -2656,7 +2656,7 @@ rfapiWithdrawEncapUpdateCachedUn(struct rfapi_import_table *import_table,
static void rfapiWithdrawTimerEncap(struct event *t) static void rfapiWithdrawTimerEncap(struct event *t)
{ {
struct rfapi_withdraw *wcb = THREAD_ARG(t); struct rfapi_withdraw *wcb = EVENT_ARG(t);
struct bgp_path_info *bpi = wcb->info; struct bgp_path_info *bpi = wcb->info;
int was_first_route = 0; int was_first_route = 0;
struct rfapi_monitor_encap *em; struct rfapi_monitor_encap *em;
@ -3076,12 +3076,11 @@ static void rfapiBgpInfoFilteredImportEncap(
*/ */
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED) if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) { && bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = THREAD_ARG( struct rfapi_withdraw *wcb = EVENT_ARG(
bpi->extra->vnc.import.timer); bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb); XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
THREAD_OFF( EVENT_OFF(bpi->extra->vnc.import.timer);
bpi->extra->vnc.import.timer);
} }
if (action == FIF_ACTION_UPDATE) { if (action == FIF_ACTION_UPDATE) {
@ -3169,10 +3168,10 @@ static void rfapiBgpInfoFilteredImportEncap(
__func__); __func__);
if (bpi->extra->vnc.import.timer) { if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = struct rfapi_withdraw *wcb =
THREAD_ARG(bpi->extra->vnc.import.timer); EVENT_ARG(bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb); XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
THREAD_OFF(bpi->extra->vnc.import.timer); EVENT_OFF(bpi->extra->vnc.import.timer);
} }
rfapiExpireEncapNow(import_table, rn, bpi); rfapiExpireEncapNow(import_table, rn, bpi);
} }
@ -3529,12 +3528,11 @@ void rfapiBgpInfoFilteredImportVPN(
*/ */
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED) if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) { && bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = THREAD_ARG( struct rfapi_withdraw *wcb = EVENT_ARG(
bpi->extra->vnc.import.timer); bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb); XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
THREAD_OFF( EVENT_OFF(bpi->extra->vnc.import.timer);
bpi->extra->vnc.import.timer);
import_table->holddown_count[afi] -= 1; import_table->holddown_count[afi] -= 1;
RFAPI_UPDATE_ITABLE_COUNT( RFAPI_UPDATE_ITABLE_COUNT(
@ -3748,10 +3746,10 @@ void rfapiBgpInfoFilteredImportVPN(
__func__); __func__);
if (bpi->extra->vnc.import.timer) { if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = struct rfapi_withdraw *wcb =
THREAD_ARG(bpi->extra->vnc.import.timer); EVENT_ARG(bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb); XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
THREAD_OFF(bpi->extra->vnc.import.timer); EVENT_OFF(bpi->extra->vnc.import.timer);
} }
rfapiExpireVpnNow(import_table, rn, bpi, 0); rfapiExpireVpnNow(import_table, rn, bpi, 0);
} }
@ -4485,7 +4483,7 @@ static void rfapiDeleteRemotePrefixesIt(
continue; continue;
if (bpi->extra->vnc.import.timer) { if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb = struct rfapi_withdraw *wcb =
THREAD_ARG( EVENT_ARG(
bpi->extra->vnc bpi->extra->vnc
.import .import
.timer); .timer);
@ -4498,9 +4496,8 @@ static void rfapiDeleteRemotePrefixesIt(
afi, 1); afi, 1);
XFREE(MTYPE_RFAPI_WITHDRAW, XFREE(MTYPE_RFAPI_WITHDRAW,
wcb); wcb);
THREAD_OFF( EVENT_OFF(bpi->extra->vnc.import
bpi->extra->vnc.import .timer);
.timer);
} }
} else { } else {
if (!delete_active) if (!delete_active)

16
bgpd/rfapi/rfapi_monitor.c
View File

@ -619,7 +619,7 @@ void rfapiMonitorDel(struct bgp *bgp, struct rfapi_descriptor *rfd,
rfapiMonitorDetachImport(m); rfapiMonitorDetachImport(m);
} }
THREAD_OFF(m->timer); EVENT_OFF(m->timer);
/* /*
* remove from rfd list * remove from rfd list
@ -656,7 +656,7 @@ int rfapiMonitorDelHd(struct rfapi_descriptor *rfd)
rfapiMonitorDetachImport(m); rfapiMonitorDetachImport(m);
} }
THREAD_OFF(m->timer); EVENT_OFF(m->timer);
XFREE(MTYPE_RFAPI_MONITOR, m); XFREE(MTYPE_RFAPI_MONITOR, m);
rn->info = NULL; rn->info = NULL;
@ -690,7 +690,7 @@ int rfapiMonitorDelHd(struct rfapi_descriptor *rfd)
#endif #endif
} }
THREAD_OFF(mon_eth->timer); EVENT_OFF(mon_eth->timer);
/* /*
* remove from rfd list * remove from rfd list
@ -732,7 +732,7 @@ void rfapiMonitorResponseRemovalOn(struct bgp *bgp)
static void rfapiMonitorTimerExpire(struct event *t) static void rfapiMonitorTimerExpire(struct event *t)
{ {
struct rfapi_monitor_vpn *m = THREAD_ARG(t); struct rfapi_monitor_vpn *m = EVENT_ARG(t);
/* forget reference to thread, it's gone */ /* forget reference to thread, it's gone */
m->timer = NULL; m->timer = NULL;
@ -753,7 +753,7 @@ static void rfapiMonitorTimerRestart(struct rfapi_monitor_vpn *m)
if (m->rfd->response_lifetime - remain < 2) if (m->rfd->response_lifetime - remain < 2)
return; return;
THREAD_OFF(m->timer); EVENT_OFF(m->timer);
{ {
char buf[BUFSIZ]; char buf[BUFSIZ];
@ -1038,7 +1038,7 @@ void rfapiMonitorMovedUp(struct rfapi_import_table *import_table,
static void rfapiMonitorEthTimerExpire(struct event *t) static void rfapiMonitorEthTimerExpire(struct event *t)
{ {
struct rfapi_monitor_eth *m = THREAD_ARG(t); struct rfapi_monitor_eth *m = EVENT_ARG(t);
/* forget reference to thread, it's gone */ /* forget reference to thread, it's gone */
m->timer = NULL; m->timer = NULL;
@ -1061,7 +1061,7 @@ static void rfapiMonitorEthTimerRestart(struct rfapi_monitor_eth *m)
if (m->rfd->response_lifetime - remain < 2) if (m->rfd->response_lifetime - remain < 2)
return; return;
THREAD_OFF(m->timer); EVENT_OFF(m->timer);
{ {
char buf[BUFSIZ]; char buf[BUFSIZ];
@ -1399,7 +1399,7 @@ void rfapiMonitorEthDel(struct bgp *bgp, struct rfapi_descriptor *rfd,
rfapiMonitorEthDetachImport(bgp, val); rfapiMonitorEthDetachImport(bgp, val);
} }
THREAD_OFF(val->timer); EVENT_OFF(val->timer);
/* /*
* remove from rfd list * remove from rfd list

22
bgpd/rfapi/rfapi_rib.c
View File

@ -255,8 +255,8 @@ static void rfapi_info_free(struct rfapi_info *goner)
if (goner->timer) { if (goner->timer) {
struct rfapi_rib_tcb *tcb; struct rfapi_rib_tcb *tcb;
tcb = THREAD_ARG(goner->timer); tcb = EVENT_ARG(goner->timer);
THREAD_OFF(goner->timer); EVENT_OFF(goner->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb); XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
} }
XFREE(MTYPE_RFAPI_INFO, goner); XFREE(MTYPE_RFAPI_INFO, goner);
@ -280,7 +280,7 @@ struct rfapi_rib_tcb {
*/ */
static void rfapiRibExpireTimer(struct event *t) static void rfapiRibExpireTimer(struct event *t)
{ {
struct rfapi_rib_tcb *tcb = THREAD_ARG(t); struct rfapi_rib_tcb *tcb = EVENT_ARG(t);
RFAPI_RIB_CHECK_COUNTS(1, 0); RFAPI_RIB_CHECK_COUNTS(1, 0);
@ -325,8 +325,8 @@ static void rfapiRibStartTimer(struct rfapi_descriptor *rfd,
struct rfapi_rib_tcb *tcb = NULL; struct rfapi_rib_tcb *tcb = NULL;
if (ri->timer) { if (ri->timer) {
tcb = THREAD_ARG(ri->timer); tcb = EVENT_ARG(ri->timer);
THREAD_OFF(ri->timer); EVENT_OFF(ri->timer);
} else { } else {
tcb = XCALLOC(MTYPE_RFAPI_RECENT_DELETE, tcb = XCALLOC(MTYPE_RFAPI_RECENT_DELETE,
sizeof(struct rfapi_rib_tcb)); sizeof(struct rfapi_rib_tcb));
@ -900,8 +900,8 @@ static void process_pending_node(struct bgp *bgp, struct rfapi_descriptor *rfd,
if (ri->timer) { if (ri->timer) {
struct rfapi_rib_tcb *tcb; struct rfapi_rib_tcb *tcb;
tcb = THREAD_ARG(ri->timer); tcb = EVENT_ARG(ri->timer);
THREAD_OFF(ri->timer); EVENT_OFF(ri->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb); XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
} }
@ -985,8 +985,8 @@ static void process_pending_node(struct bgp *bgp, struct rfapi_descriptor *rfd,
if (ori->timer) { if (ori->timer) {
struct rfapi_rib_tcb *tcb; struct rfapi_rib_tcb *tcb;
tcb = THREAD_ARG(ori->timer); tcb = EVENT_ARG(ori->timer);
THREAD_OFF(ori->timer); EVENT_OFF(ori->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb); XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
} }
@ -1319,8 +1319,8 @@ callback:
if (ri->timer) { if (ri->timer) {
struct rfapi_rib_tcb *tcb; struct rfapi_rib_tcb *tcb;
tcb = THREAD_ARG(ri->timer); tcb = EVENT_ARG(ri->timer);
THREAD_OFF(ri->timer); EVENT_OFF(ri->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb); XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
} }
RFAPI_RIB_CHECK_COUNTS(0, delete_list->count); RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);

8
bgpd/rfapi/vnc_export_bgp.c
View File

@ -1692,7 +1692,7 @@ void vnc_direct_bgp_rh_add_route(struct bgp *bgp, afi_t afi,
* export expiration timer is already running on * export expiration timer is already running on
* this route: cancel it * this route: cancel it
*/ */
THREAD_OFF(eti->timer); EVENT_OFF(eti->timer);
bgp_update(peer, prefix, /* prefix */ bgp_update(peer, prefix, /* prefix */
0, /* addpath_id */ 0, /* addpath_id */
@ -1706,7 +1706,7 @@ void vnc_direct_bgp_rh_add_route(struct bgp *bgp, afi_t afi,
static void vncExportWithdrawTimer(struct event *t) static void vncExportWithdrawTimer(struct event *t)
{ {
struct vnc_export_info *eti = THREAD_ARG(t); struct vnc_export_info *eti = EVENT_ARG(t);
const struct prefix *p = agg_node_get_prefix(eti->node); const struct prefix *p = agg_node_get_prefix(eti->node);
/* /*
@ -1922,7 +1922,7 @@ void vnc_direct_bgp_rh_vpn_enable(struct bgp *bgp, afi_t afi)
* already running on * already running on
* this route: cancel it * this route: cancel it
*/ */
THREAD_OFF(eti->timer); EVENT_OFF(eti->timer);
vnc_zlog_debug_verbose( vnc_zlog_debug_verbose(
"%s: calling bgp_update", "%s: calling bgp_update",
@ -1991,7 +1991,7 @@ void vnc_direct_bgp_rh_vpn_disable(struct bgp *bgp, afi_t afi)
ZEBRA_ROUTE_VNC_DIRECT_RH, ZEBRA_ROUTE_VNC_DIRECT_RH,
BGP_ROUTE_REDISTRIBUTE); BGP_ROUTE_REDISTRIBUTE);
if (eti) { if (eti) {
THREAD_OFF(eti->timer); EVENT_OFF(eti->timer);
vnc_eti_delete(eti); vnc_eti_delete(eti);
} }

4
eigrpd/eigrp_filter.c
View File

@ -246,7 +246,7 @@ void eigrp_distribute_timer_process(struct event *thread)
{ {
struct eigrp *eigrp; struct eigrp *eigrp;
eigrp = THREAD_ARG(thread); eigrp = EVENT_ARG(thread);
/* execute GR for whole process */ /* execute GR for whole process */
eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL); eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL);
@ -267,7 +267,7 @@ void eigrp_distribute_timer_interface(struct event *thread)
{ {
struct eigrp_interface *ei; struct eigrp_interface *ei;
ei = THREAD_ARG(thread); ei = EVENT_ARG(thread);
ei->t_distribute = NULL; ei->t_distribute = NULL;
/* execute GR for interface */ /* execute GR for interface */

2
eigrpd/eigrp_hello.c
View File

@ -70,7 +70,7 @@ void eigrp_hello_timer(struct event *thread)
{ {
struct eigrp_interface *ei; struct eigrp_interface *ei;
ei = THREAD_ARG(thread); ei = EVENT_ARG(thread);
if (IS_DEBUG_EIGRP(0, TIMERS)) if (IS_DEBUG_EIGRP(0, TIMERS))
zlog_debug("Start Hello Timer (%s) Expire [%u]", IF_NAME(ei), zlog_debug("Start Hello Timer (%s) Expire [%u]", IF_NAME(ei),

2
eigrpd/eigrp_interface.c
View File

@ -333,7 +333,7 @@ int eigrp_if_down(struct eigrp_interface *ei)
return 0; return 0;
/* Shutdown packet reception and sending */ /* Shutdown packet reception and sending */
THREAD_OFF(ei->t_hello); EVENT_OFF(ei->t_hello);
eigrp_if_stream_unset(ei); eigrp_if_stream_unset(ei);

14
eigrpd/eigrp_neighbor.c
View File

@ -167,7 +167,7 @@ void eigrp_nbr_delete(struct eigrp_neighbor *nbr)
event_cancel_event(master, nbr); event_cancel_event(master, nbr);
eigrp_fifo_free(nbr->multicast_queue); eigrp_fifo_free(nbr->multicast_queue);
eigrp_fifo_free(nbr->retrans_queue); eigrp_fifo_free(nbr->retrans_queue);
THREAD_OFF(nbr->t_holddown); EVENT_OFF(nbr->t_holddown);
if (nbr->ei) if (nbr->ei)
listnode_delete(nbr->ei->nbrs, nbr); listnode_delete(nbr->ei->nbrs, nbr);
@ -176,7 +176,7 @@ void eigrp_nbr_delete(struct eigrp_neighbor *nbr)
void holddown_timer_expired(struct event *thread) void holddown_timer_expired(struct event *thread)
{ {
struct eigrp_neighbor *nbr = THREAD_ARG(thread); struct eigrp_neighbor *nbr = EVENT_ARG(thread);
struct eigrp *eigrp = nbr->ei->eigrp; struct eigrp *eigrp = nbr->ei->eigrp;
zlog_info("Neighbor %pI4 (%s) is down: holding time expired", &nbr->src, zlog_info("Neighbor %pI4 (%s) is down: holding time expired", &nbr->src,
@ -210,7 +210,7 @@ void eigrp_nbr_state_set(struct eigrp_neighbor *nbr, uint8_t state)
// hold time.. // hold time..
nbr->v_holddown = EIGRP_HOLD_INTERVAL_DEFAULT; nbr->v_holddown = EIGRP_HOLD_INTERVAL_DEFAULT;
THREAD_OFF(nbr->t_holddown); EVENT_OFF(nbr->t_holddown);
/* out with the old */ /* out with the old */
if (nbr->multicast_queue) if (nbr->multicast_queue)
@ -252,22 +252,22 @@ void eigrp_nbr_state_update(struct eigrp_neighbor *nbr)
switch (nbr->state) { switch (nbr->state) {
case EIGRP_NEIGHBOR_DOWN: { case EIGRP_NEIGHBOR_DOWN: {
/*Start Hold Down Timer for neighbor*/ /*Start Hold Down Timer for neighbor*/
// THREAD_OFF(nbr->t_holddown); // EVENT_OFF(nbr->t_holddown);
// THREAD_TIMER_ON(master, nbr->t_holddown, // EVENT_TIMER_ON(master, nbr->t_holddown,
// holddown_timer_expired, // holddown_timer_expired,
// nbr, nbr->v_holddown); // nbr, nbr->v_holddown);
break; break;
} }
case EIGRP_NEIGHBOR_PENDING: { case EIGRP_NEIGHBOR_PENDING: {
/*Reset Hold Down Timer for neighbor*/ /*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown); EVENT_OFF(nbr->t_holddown);
event_add_timer(master, holddown_timer_expired, nbr, event_add_timer(master, holddown_timer_expired, nbr,
nbr->v_holddown, &nbr->t_holddown); nbr->v_holddown, &nbr->t_holddown);
break; break;
} }
case EIGRP_NEIGHBOR_UP: { case EIGRP_NEIGHBOR_UP: {
/*Reset Hold Down Timer for neighbor*/ /*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown); EVENT_OFF(nbr->t_holddown);
event_add_timer(master, holddown_timer_expired, nbr, event_add_timer(master, holddown_timer_expired, nbr,
nbr->v_holddown, &nbr->t_holddown); nbr->v_holddown, &nbr->t_holddown);
break; break;

10
eigrpd/eigrp_packet.c
View File

@ -307,7 +307,7 @@ int eigrp_check_sha256_digest(struct stream *s,
void eigrp_write(struct event *thread) void eigrp_write(struct event *thread)
{ {
struct eigrp *eigrp = THREAD_ARG(thread); struct eigrp *eigrp = EVENT_ARG(thread);
struct eigrp_header *eigrph; struct eigrp_header *eigrph;
struct eigrp_interface *ei; struct eigrp_interface *ei;
struct eigrp_packet *ep; struct eigrp_packet *ep;
@ -474,7 +474,7 @@ void eigrp_read(struct event *thread)
uint16_t length = 0; uint16_t length = 0;
/* first of all get interface pointer. */ /* first of all get interface pointer. */
eigrp = THREAD_ARG(thread); eigrp = EVENT_ARG(thread);
/* prepare for next packet. */ /* prepare for next packet. */
event_add_read(master, eigrp_read, eigrp, eigrp->fd, &eigrp->t_read); event_add_read(master, eigrp_read, eigrp, eigrp->fd, &eigrp->t_read);
@ -923,7 +923,7 @@ void eigrp_packet_free(struct eigrp_packet *ep)
if (ep->s) if (ep->s)
stream_free(ep->s); stream_free(ep->s);
THREAD_OFF(ep->t_retrans_timer); EVENT_OFF(ep->t_retrans_timer);
XFREE(MTYPE_EIGRP_PACKET, ep); XFREE(MTYPE_EIGRP_PACKET, ep);
} }
@ -973,7 +973,7 @@ static int eigrp_check_network_mask(struct eigrp_interface *ei,
void eigrp_unack_packet_retrans(struct event *thread) void eigrp_unack_packet_retrans(struct event *thread)
{ {
struct eigrp_neighbor *nbr; struct eigrp_neighbor *nbr;
nbr = (struct eigrp_neighbor *)THREAD_ARG(thread); nbr = (struct eigrp_neighbor *)EVENT_ARG(thread);
struct eigrp_packet *ep; struct eigrp_packet *ep;
ep = eigrp_fifo_next(nbr->retrans_queue); ep = eigrp_fifo_next(nbr->retrans_queue);
@ -1009,7 +1009,7 @@ void eigrp_unack_packet_retrans(struct event *thread)
void eigrp_unack_multicast_packet_retrans(struct event *thread) void eigrp_unack_multicast_packet_retrans(struct event *thread)
{ {
struct eigrp_neighbor *nbr; struct eigrp_neighbor *nbr;
nbr = (struct eigrp_neighbor *)THREAD_ARG(thread); nbr = (struct eigrp_neighbor *)EVENT_ARG(thread);
struct eigrp_packet *ep; struct eigrp_packet *ep;
ep = eigrp_fifo_next(nbr->multicast_queue); ep = eigrp_fifo_next(nbr->multicast_queue);

2
eigrpd/eigrp_update.c
View File

@ -900,7 +900,7 @@ void eigrp_update_send_GR_thread(struct event *thread)
struct eigrp_neighbor *nbr; struct eigrp_neighbor *nbr;
/* get argument from thread */ /* get argument from thread */
nbr = THREAD_ARG(thread); nbr = EVENT_ARG(thread);
/* remove this thread pointer */ /* remove this thread pointer */
/* if there is packet waiting in queue, /* if there is packet waiting in queue,

4
eigrpd/eigrpd.c
View File

@ -260,8 +260,8 @@ void eigrp_finish_final(struct eigrp *eigrp)
eigrp_if_free(ei, INTERFACE_DOWN_BY_FINAL); eigrp_if_free(ei, INTERFACE_DOWN_BY_FINAL);
} }
THREAD_OFF(eigrp->t_write); EVENT_OFF(eigrp->t_write);
THREAD_OFF(eigrp->t_read); EVENT_OFF(eigrp->t_read);
close(eigrp->fd); close(eigrp->fd);
list_delete(&eigrp->eiflist); list_delete(&eigrp->eiflist);

20
isisd/fabricd.c
View File

@ -225,11 +225,11 @@ struct fabricd *fabricd_new(struct isis_area *area)
void fabricd_finish(struct fabricd *f) void fabricd_finish(struct fabricd *f)
{ {
THREAD_OFF(f->initial_sync_timeout); EVENT_OFF(f->initial_sync_timeout);
THREAD_OFF(f->tier_calculation_timer); EVENT_OFF(f->tier_calculation_timer);
THREAD_OFF(f->tier_set_timer); EVENT_OFF(f->tier_set_timer);
isis_spftree_del(f->spftree); isis_spftree_del(f->spftree);
neighbor_lists_clear(f); neighbor_lists_clear(f);
@ -239,7 +239,7 @@ void fabricd_finish(struct fabricd *f)
static void fabricd_initial_sync_timeout(struct event *thread) static void fabricd_initial_sync_timeout(struct event *thread)
{ {
struct fabricd *f = THREAD_ARG(thread); struct fabricd *f = EVENT_ARG(thread);
if (IS_DEBUG_ADJ_PACKETS) if (IS_DEBUG_ADJ_PACKETS)
zlog_debug( zlog_debug(
@ -325,7 +325,7 @@ void fabricd_initial_sync_finish(struct isis_area *area)
f->initial_sync_circuit->interface->name); f->initial_sync_circuit->interface->name);
f->initial_sync_state = FABRICD_SYNC_COMPLETE; f->initial_sync_state = FABRICD_SYNC_COMPLETE;
f->initial_sync_circuit = NULL; f->initial_sync_circuit = NULL;
THREAD_OFF(f->initial_sync_timeout); EVENT_OFF(f->initial_sync_timeout);
} }
static void fabricd_bump_tier_calculation_timer(struct fabricd *f); static void fabricd_bump_tier_calculation_timer(struct fabricd *f);
@ -391,14 +391,14 @@ static uint8_t fabricd_calculate_fabric_tier(struct isis_area *area)
static void fabricd_tier_set_timer(struct event *thread) static void fabricd_tier_set_timer(struct event *thread)
{ {
struct fabricd *f = THREAD_ARG(thread); struct fabricd *f = EVENT_ARG(thread);
fabricd_set_tier(f, f->tier_pending); fabricd_set_tier(f, f->tier_pending);
} }
static void fabricd_tier_calculation_cb(struct event *thread) static void fabricd_tier_calculation_cb(struct event *thread)
{ {
struct fabricd *f = THREAD_ARG(thread); struct fabricd *f = EVENT_ARG(thread);
uint8_t tier = ISIS_TIER_UNDEFINED; uint8_t tier = ISIS_TIER_UNDEFINED;
tier = fabricd_calculate_fabric_tier(f->area); tier = fabricd_calculate_fabric_tier(f->area);
@ -417,14 +417,14 @@ static void fabricd_bump_tier_calculation_timer(struct fabricd *f)
{ {
/* Cancel timer if we already know our tier */ /* Cancel timer if we already know our tier */
if (f->tier != ISIS_TIER_UNDEFINED || f->tier_set_timer) { if (f->tier != ISIS_TIER_UNDEFINED || f->tier_set_timer) {
THREAD_OFF(f->tier_calculation_timer); EVENT_OFF(f->tier_calculation_timer);
return; return;
} }
/* If we need to calculate the tier, wait some /* If we need to calculate the tier, wait some
* time for the topology to settle before running * time for the topology to settle before running
* the calculation */ * the calculation */
THREAD_OFF(f->tier_calculation_timer); EVENT_OFF(f->tier_calculation_timer);
event_add_timer(master, fabricd_tier_calculation_cb, f, event_add_timer(master, fabricd_tier_calculation_cb, f,
2 * f->area->lsp_gen_interval[ISIS_LEVEL2 - 1], 2 * f->area->lsp_gen_interval[ISIS_LEVEL2 - 1],
@ -709,7 +709,7 @@ void fabricd_trigger_csnp(struct isis_area *area, bool circuit_scoped)
if (!circuit->t_send_csnp[1]) if (!circuit->t_send_csnp[1])
continue; continue;
THREAD_OFF(circuit->t_send_csnp[ISIS_LEVEL2 - 1]); EVENT_OFF(circuit->t_send_csnp[ISIS_LEVEL2 - 1]);
event_add_timer_msec(master, send_l2_csnp, circuit, event_add_timer_msec(master, send_l2_csnp, circuit,
isis_jitter(f->csnp_delay, CSNP_JITTER), isis_jitter(f->csnp_delay, CSNP_JITTER),
&circuit->t_send_csnp[ISIS_LEVEL2 - 1]); &circuit->t_send_csnp[ISIS_LEVEL2 - 1]);

4
isisd/isis_adjacency.c
View File

@ -148,7 +148,7 @@ void isis_delete_adj(void *arg)
/* Remove self from snmp list without walking the list*/ /* Remove self from snmp list without walking the list*/
list_delete_node(adj->circuit->snmp_adj_list, adj->snmp_list_node); list_delete_node(adj->circuit->snmp_adj_list, adj->snmp_list_node);
THREAD_OFF(adj->t_expire); EVENT_OFF(adj->t_expire);
if (adj->adj_state != ISIS_ADJ_DOWN) if (adj->adj_state != ISIS_ADJ_DOWN)
adj->adj_state = ISIS_ADJ_DOWN; adj->adj_state = ISIS_ADJ_DOWN;
@ -485,7 +485,7 @@ void isis_adj_expire(struct event *thread)
/* /*
* Get the adjacency * Get the adjacency
*/ */
adj = THREAD_ARG(thread); adj = EVENT_ARG(thread);
assert(adj); assert(adj);
adj->t_expire = NULL; adj->t_expire = NULL;

24
isisd/isis_circuit.c
View File

@ -863,12 +863,12 @@ void isis_circuit_down(struct isis_circuit *circuit)
memset(circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1); memset(circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
memset(circuit->u.bc.snpa, 0, ETH_ALEN); memset(circuit->u.bc.snpa, 0, ETH_ALEN);
THREAD_OFF(circuit->u.bc.t_send_lan_hello[0]); EVENT_OFF(circuit->u.bc.t_send_lan_hello[0]);
THREAD_OFF(circuit->u.bc.t_send_lan_hello[1]); EVENT_OFF(circuit->u.bc.t_send_lan_hello[1]);
THREAD_OFF(circuit->u.bc.t_run_dr[0]); EVENT_OFF(circuit->u.bc.t_run_dr[0]);
THREAD_OFF(circuit->u.bc.t_run_dr[1]); EVENT_OFF(circuit->u.bc.t_run_dr[1]);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[0]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[0]);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[1]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[1]);
circuit->lsp_regenerate_pending[0] = 0; circuit->lsp_regenerate_pending[0] = 0;
circuit->lsp_regenerate_pending[1] = 0; circuit->lsp_regenerate_pending[1] = 0;
@ -878,7 +878,7 @@ void isis_circuit_down(struct isis_circuit *circuit)
} else if (circuit->circ_type == CIRCUIT_T_P2P) { } else if (circuit->circ_type == CIRCUIT_T_P2P) {
isis_delete_adj(circuit->u.p2p.neighbor); isis_delete_adj(circuit->u.p2p.neighbor);
circuit->u.p2p.neighbor = NULL; circuit->u.p2p.neighbor = NULL;
THREAD_OFF(circuit->u.p2p.t_send_p2p_hello); EVENT_OFF(circuit->u.p2p.t_send_p2p_hello);
} }
/* /*
@ -891,11 +891,11 @@ void isis_circuit_down(struct isis_circuit *circuit)
circuit->snmp_adj_idx_gen = 0; circuit->snmp_adj_idx_gen = 0;
/* Cancel all active threads */ /* Cancel all active threads */
THREAD_OFF(circuit->t_send_csnp[0]); EVENT_OFF(circuit->t_send_csnp[0]);
THREAD_OFF(circuit->t_send_csnp[1]); EVENT_OFF(circuit->t_send_csnp[1]);
THREAD_OFF(circuit->t_send_psnp[0]); EVENT_OFF(circuit->t_send_psnp[0]);
THREAD_OFF(circuit->t_send_psnp[1]); EVENT_OFF(circuit->t_send_psnp[1]);
THREAD_OFF(circuit->t_read); EVENT_OFF(circuit->t_read);
if (circuit->tx_queue) { if (circuit->tx_queue) {
isis_tx_queue_free(circuit->tx_queue); isis_tx_queue_free(circuit->tx_queue);

8
isisd/isis_dr.c
View File

@ -50,7 +50,7 @@ const char *isis_disflag2string(int disflag)
void isis_run_dr(struct event *thread) void isis_run_dr(struct event *thread)
{ {
struct isis_circuit_arg *arg = THREAD_ARG(thread); struct isis_circuit_arg *arg = EVENT_ARG(thread);
assert(arg); assert(arg);
@ -211,8 +211,8 @@ int isis_dr_resign(struct isis_circuit *circuit, int level)
circuit->u.bc.is_dr[level - 1] = 0; circuit->u.bc.is_dr[level - 1] = 0;
circuit->u.bc.run_dr_elect[level - 1] = 0; circuit->u.bc.run_dr_elect[level - 1] = 0;
THREAD_OFF(circuit->u.bc.t_run_dr[level - 1]); EVENT_OFF(circuit->u.bc.t_run_dr[level - 1]);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
circuit->lsp_regenerate_pending[level - 1] = 0; circuit->lsp_regenerate_pending[level - 1] = 0;
memcpy(id, circuit->isis->sysid, ISIS_SYS_ID_LEN); memcpy(id, circuit->isis->sysid, ISIS_SYS_ID_LEN);
@ -236,7 +236,7 @@ int isis_dr_resign(struct isis_circuit *circuit, int level)
&circuit->t_send_psnp[1]); &circuit->t_send_psnp[1]);
} }
THREAD_OFF(circuit->t_send_csnp[level - 1]); EVENT_OFF(circuit->t_send_csnp[level - 1]);
event_add_timer(master, isis_run_dr, &circuit->level_arg[level - 1], event_add_timer(master, isis_run_dr, &circuit->level_arg[level - 1],
2 * circuit->hello_interval[level - 1], 2 * circuit->hello_interval[level - 1],

4
isisd/isis_dynhn.c
View File

@ -44,7 +44,7 @@ void dyn_cache_finish(struct isis *isis)
struct listnode *node, *nnode; struct listnode *node, *nnode;
struct isis_dynhn *dyn; struct isis_dynhn *dyn;
THREAD_OFF(isis->t_dync_clean); EVENT_OFF(isis->t_dync_clean);
for (ALL_LIST_ELEMENTS(isis->dyn_cache, node, nnode, dyn)) { for (ALL_LIST_ELEMENTS(isis->dyn_cache, node, nnode, dyn)) {
list_delete_node(isis->dyn_cache, node); list_delete_node(isis->dyn_cache, node);
@ -61,7 +61,7 @@ static void dyn_cache_cleanup(struct event *thread)
time_t now = time(NULL); time_t now = time(NULL);
struct isis *isis = NULL; struct isis *isis = NULL;
isis = THREAD_ARG(thread); isis = EVENT_ARG(thread);
isis->t_dync_clean = NULL; isis->t_dync_clean = NULL;

12
isisd/isis_events.c
View File

@ -96,13 +96,13 @@ static void circuit_resign_level(struct isis_circuit *circuit, int level)
circuit->area->area_tag, circuit->circuit_id, circuit->area->area_tag, circuit->circuit_id,
circuit->interface->name, level); circuit->interface->name, level);
THREAD_OFF(circuit->t_send_csnp[idx]); EVENT_OFF(circuit->t_send_csnp[idx]);
THREAD_OFF(circuit->t_send_psnp[idx]); EVENT_OFF(circuit->t_send_psnp[idx]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST) { if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
THREAD_OFF(circuit->u.bc.t_send_lan_hello[idx]); EVENT_OFF(circuit->u.bc.t_send_lan_hello[idx]);
THREAD_OFF(circuit->u.bc.t_run_dr[idx]); EVENT_OFF(circuit->u.bc.t_run_dr[idx]);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
circuit->lsp_regenerate_pending[idx] = 0; circuit->lsp_regenerate_pending[idx] = 0;
circuit->u.bc.run_dr_elect[idx] = 0; circuit->u.bc.run_dr_elect[idx] = 0;
circuit->u.bc.is_dr[idx] = 0; circuit->u.bc.is_dr[idx] = 0;
@ -200,7 +200,7 @@ void isis_event_dis_status_change(struct event *thread)
{ {
struct isis_circuit *circuit; struct isis_circuit *circuit;
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
/* invalid arguments */ /* invalid arguments */
if (!circuit || !circuit->area) if (!circuit || !circuit->area)

8
isisd/isis_ldp_sync.c
View File

@ -171,7 +171,7 @@ void isis_ldp_sync_if_complete(struct isis_circuit *circuit)
if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP) if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP)
ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_UP; ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_UP;
THREAD_OFF(ldp_sync_info->t_holddown); EVENT_OFF(ldp_sync_info->t_holddown);
isis_ldp_sync_set_if_metric(circuit, true); isis_ldp_sync_set_if_metric(circuit, true);
} }
@ -191,7 +191,7 @@ void isis_ldp_sync_ldp_fail(struct isis_circuit *circuit)
if (ldp_sync_info && if (ldp_sync_info &&
ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
ldp_sync_info->state != LDP_IGP_SYNC_STATE_NOT_REQUIRED) { ldp_sync_info->state != LDP_IGP_SYNC_STATE_NOT_REQUIRED) {
THREAD_OFF(ldp_sync_info->t_holddown); EVENT_OFF(ldp_sync_info->t_holddown);
ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP; ldp_sync_info->state = LDP_IGP_SYNC_STATE_REQUIRED_NOT_UP;
isis_ldp_sync_set_if_metric(circuit, true); isis_ldp_sync_set_if_metric(circuit, true);
} }
@ -340,7 +340,7 @@ static void isis_ldp_sync_holddown_timer(struct event *thread)
* didn't receive msg from LDP indicating sync-complete * didn't receive msg from LDP indicating sync-complete
* restore interface cost to original value * restore interface cost to original value
*/ */
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
if (circuit->ldp_sync_info == NULL) if (circuit->ldp_sync_info == NULL)
return; return;
@ -516,7 +516,7 @@ void isis_if_ldp_sync_disable(struct isis_circuit *circuit)
if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE)) if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
return; return;
THREAD_OFF(ldp_sync_info->t_holddown); EVENT_OFF(ldp_sync_info->t_holddown);
ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED; ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
isis_ldp_sync_set_if_metric(circuit, true); isis_ldp_sync_set_if_metric(circuit, true);
} }

6
isisd/isis_lfa.c
View File

@ -1390,7 +1390,7 @@ static struct rlfa *rlfa_lookup(struct isis_spftree *spftree,
static void isis_area_verify_routes_cb(struct event *thread) static void isis_area_verify_routes_cb(struct event *thread)
{ {
struct isis_area *area = THREAD_ARG(thread); struct isis_area *area = EVENT_ARG(thread);
if (IS_DEBUG_LFA) if (IS_DEBUG_LFA)
zlog_debug("ISIS-LFA: updating RLFAs in the RIB"); zlog_debug("ISIS-LFA: updating RLFAs in the RIB");
@ -1506,7 +1506,7 @@ int isis_rlfa_activate(struct isis_spftree *spftree, struct rlfa *rlfa,
spftree->route_table_backup); spftree->route_table_backup);
spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] += 1; spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] += 1;
THREAD_OFF(area->t_rlfa_rib_update); EVENT_OFF(area->t_rlfa_rib_update);
event_add_timer(master, isis_area_verify_routes_cb, area, 2, event_add_timer(master, isis_area_verify_routes_cb, area, 2,
&area->t_rlfa_rib_update); &area->t_rlfa_rib_update);
@ -1525,7 +1525,7 @@ void isis_rlfa_deactivate(struct isis_spftree *spftree, struct rlfa *rlfa)
isis_route_delete(area, rn, spftree->route_table_backup); isis_route_delete(area, rn, spftree->route_table_backup);
spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] -= 1; spftree->lfa.protection_counters.rlfa[vertex->N.ip.priority] -= 1;
THREAD_OFF(area->t_rlfa_rib_update); EVENT_OFF(area->t_rlfa_rib_update);
event_add_timer(master, isis_area_verify_routes_cb, area, 2, event_add_timer(master, isis_area_verify_routes_cb, area, 2,
&area->t_rlfa_rib_update); &area->t_rlfa_rib_update);
} }

18
isisd/isis_lsp.c
View File

@ -431,7 +431,7 @@ bool isis_level2_adj_up(struct isis_area *area)
*/ */
void set_overload_on_start_timer(struct event *thread) void set_overload_on_start_timer(struct event *thread)
{ {
struct isis_area *area = THREAD_ARG(thread); struct isis_area *area = EVENT_ARG(thread);
assert(area); assert(area);
area->t_overload_on_startup_timer = NULL; area->t_overload_on_startup_timer = NULL;
@ -1418,7 +1418,7 @@ int lsp_generate(struct isis_area *area, int level)
refresh_time = lsp_refresh_time(newlsp, rem_lifetime); refresh_time = lsp_refresh_time(newlsp, rem_lifetime);
THREAD_OFF(area->t_lsp_refresh[level - 1]); EVENT_OFF(area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0; area->lsp_regenerate_pending[level - 1] = 0;
event_add_timer(master, lsp_refresh, &area->lsp_refresh_arg[level - 1], event_add_timer(master, lsp_refresh, &area->lsp_refresh_arg[level - 1],
refresh_time, &area->t_lsp_refresh[level - 1]); refresh_time, &area->t_lsp_refresh[level - 1]);
@ -1523,7 +1523,7 @@ static int lsp_regenerate(struct isis_area *area, int level)
*/ */
static void lsp_refresh(struct event *thread) static void lsp_refresh(struct event *thread)
{ {
struct lsp_refresh_arg *arg = THREAD_ARG(thread); struct lsp_refresh_arg *arg = EVENT_ARG(thread);
assert(arg); assert(arg);
@ -1627,7 +1627,7 @@ int _lsp_regenerate_schedule(struct isis_area *area, int level,
"ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld", "ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld",
area->area_tag, (long long)lsp->last_generated, area->area_tag, (long long)lsp->last_generated,
(long long)now); (long long)now);
THREAD_OFF(area->t_lsp_refresh[lvl - 1]); EVENT_OFF(area->t_lsp_refresh[lvl - 1]);
diff = now - lsp->last_generated; diff = now - lsp->last_generated;
if (diff < area->lsp_gen_interval[lvl - 1] if (diff < area->lsp_gen_interval[lvl - 1]
&& !(area->bfd_signalled_down)) { && !(area->bfd_signalled_down)) {
@ -1819,7 +1819,7 @@ int lsp_generate_pseudo(struct isis_circuit *circuit, int level)
lsp_flood(lsp, NULL); lsp_flood(lsp, NULL);
refresh_time = lsp_refresh_time(lsp, rem_lifetime); refresh_time = lsp_refresh_time(lsp, rem_lifetime);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
circuit->lsp_regenerate_pending[level - 1] = 0; circuit->lsp_regenerate_pending[level - 1] = 0;
if (level == IS_LEVEL_1) if (level == IS_LEVEL_1)
event_add_timer(master, lsp_l1_refresh_pseudo, circuit, event_add_timer(master, lsp_l1_refresh_pseudo, circuit,
@ -1905,7 +1905,7 @@ static void lsp_l1_refresh_pseudo(struct event *thread)
struct isis_circuit *circuit; struct isis_circuit *circuit;
uint8_t id[ISIS_SYS_ID_LEN + 2]; uint8_t id[ISIS_SYS_ID_LEN + 2];
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
circuit->u.bc.t_refresh_pseudo_lsp[0] = NULL; circuit->u.bc.t_refresh_pseudo_lsp[0] = NULL;
circuit->lsp_regenerate_pending[0] = 0; circuit->lsp_regenerate_pending[0] = 0;
@ -1927,7 +1927,7 @@ static void lsp_l2_refresh_pseudo(struct event *thread)
struct isis_circuit *circuit; struct isis_circuit *circuit;
uint8_t id[ISIS_SYS_ID_LEN + 2]; uint8_t id[ISIS_SYS_ID_LEN + 2];
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
circuit->u.bc.t_refresh_pseudo_lsp[1] = NULL; circuit->u.bc.t_refresh_pseudo_lsp[1] = NULL;
circuit->lsp_regenerate_pending[1] = 0; circuit->lsp_regenerate_pending[1] = 0;
@ -2010,7 +2010,7 @@ int lsp_regenerate_schedule_pseudo(struct isis_circuit *circuit, int level)
"ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld", "ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld",
area->area_tag, (long long)lsp->last_generated, area->area_tag, (long long)lsp->last_generated,
(long long)now); (long long)now);
THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]); EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
diff = now - lsp->last_generated; diff = now - lsp->last_generated;
if (diff < circuit->area->lsp_gen_interval[lvl - 1]) { if (diff < circuit->area->lsp_gen_interval[lvl - 1]) {
timeout = timeout =
@ -2054,7 +2054,7 @@ void lsp_tick(struct event *thread)
uint16_t rem_lifetime; uint16_t rem_lifetime;
bool fabricd_sync_incomplete = false; bool fabricd_sync_incomplete = false;
area = THREAD_ARG(thread); area = EVENT_ARG(thread);
assert(area); assert(area);
area->t_tick = NULL; area->t_tick = NULL;
event_add_timer(master, lsp_tick, area, 1, &area->t_tick); event_add_timer(master, lsp_tick, area, 1, &area->t_tick);

4
isisd/isis_main.c
View File

@ -185,7 +185,7 @@ static void isis_config_start(void)
{ {
/* Max wait time for config to load before generating lsp */ /* Max wait time for config to load before generating lsp */
#define ISIS_PRE_CONFIG_MAX_WAIT_SECONDS 600 #define ISIS_PRE_CONFIG_MAX_WAIT_SECONDS 600
THREAD_OFF(t_isis_cfg); EVENT_OFF(t_isis_cfg);
event_add_timer(im->master, isis_config_finish, NULL, event_add_timer(im->master, isis_config_finish, NULL,
ISIS_PRE_CONFIG_MAX_WAIT_SECONDS, &t_isis_cfg); ISIS_PRE_CONFIG_MAX_WAIT_SECONDS, &t_isis_cfg);
} }
@ -198,7 +198,7 @@ static void isis_config_end(void)
if (!event_is_scheduled(t_isis_cfg)) if (!event_is_scheduled(t_isis_cfg))
return; return;
THREAD_OFF(t_isis_cfg); EVENT_OFF(t_isis_cfg);
isis_config_finish(t_isis_cfg); isis_config_finish(t_isis_cfg);
} }

18
isisd/isis_pdu.c
View File

@ -192,7 +192,7 @@ static int process_p2p_hello(struct iih_info *iih)
adj); adj);
/* lets take care of the expiry */ /* lets take care of the expiry */
THREAD_OFF(adj->t_expire); EVENT_OFF(adj->t_expire);
event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time, event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
&adj->t_expire); &adj->t_expire);
@ -484,7 +484,7 @@ static int process_lan_hello(struct iih_info *iih)
adj); adj);
/* lets take care of the expiry */ /* lets take care of the expiry */
THREAD_OFF(adj->t_expire); EVENT_OFF(adj->t_expire);
event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time, event_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
&adj->t_expire); &adj->t_expire);
@ -1788,7 +1788,7 @@ void isis_receive(struct event *thread)
/* /*
* Get the circuit * Get the circuit
*/ */
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
assert(circuit); assert(circuit);
circuit->t_read = NULL; circuit->t_read = NULL;
@ -2011,7 +2011,7 @@ int send_hello(struct isis_circuit *circuit, int level)
static void send_hello_cb(struct event *thread) static void send_hello_cb(struct event *thread)
{ {
struct isis_circuit_arg *arg = THREAD_ARG(thread); struct isis_circuit_arg *arg = EVENT_ARG(thread);
assert(arg); assert(arg);
struct isis_circuit *circuit = arg->circuit; struct isis_circuit *circuit = arg->circuit;
@ -2056,7 +2056,7 @@ static void _send_hello_sched(struct isis_circuit *circuit,
if (event_timer_remain_msec(*threadp) < (unsigned long)delay) if (event_timer_remain_msec(*threadp) < (unsigned long)delay)
return; return;
THREAD_OFF(*threadp); EVENT_OFF(*threadp);
} }
event_add_timer_msec(master, send_hello_cb, event_add_timer_msec(master, send_hello_cb,
@ -2242,7 +2242,7 @@ void send_l1_csnp(struct event *thread)
{ {
struct isis_circuit *circuit; struct isis_circuit *circuit;
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
assert(circuit); assert(circuit);
circuit->t_send_csnp[0] = NULL; circuit->t_send_csnp[0] = NULL;
@ -2262,7 +2262,7 @@ void send_l2_csnp(struct event *thread)
{ {
struct isis_circuit *circuit; struct isis_circuit *circuit;
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
assert(circuit); assert(circuit);
circuit->t_send_csnp[1] = NULL; circuit->t_send_csnp[1] = NULL;
@ -2397,7 +2397,7 @@ void send_l1_psnp(struct event *thread)
struct isis_circuit *circuit; struct isis_circuit *circuit;
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
assert(circuit); assert(circuit);
circuit->t_send_psnp[0] = NULL; circuit->t_send_psnp[0] = NULL;
@ -2417,7 +2417,7 @@ void send_l2_psnp(struct event *thread)
{ {
struct isis_circuit *circuit; struct isis_circuit *circuit;
circuit = THREAD_ARG(thread); circuit = EVENT_ARG(thread);
assert(circuit); assert(circuit);
circuit->t_send_psnp[1] = NULL; circuit->t_send_psnp[1] = NULL;

4
isisd/isis_spf.c
View File

@ -1855,7 +1855,7 @@ void isis_spf_switchover_routes(struct isis_area *area,
static void isis_run_spf_cb(struct event *thread) static void isis_run_spf_cb(struct event *thread)
{ {
struct isis_spf_run *run = THREAD_ARG(thread); struct isis_spf_run *run = EVENT_ARG(thread);
struct isis_area *area = run->area; struct isis_area *area = run->area;
int level = run->level; int level = run->level;
int have_run = 0; int have_run = 0;
@ -1950,7 +1950,7 @@ int _isis_spf_schedule(struct isis_area *area, int level,
area->area_tag, level, diff, func, file, line); area->area_tag, level, diff, func, file, line);
} }
THREAD_OFF(area->t_rlfa_rib_update); EVENT_OFF(area->t_rlfa_rib_update);
if (area->spf_delay_ietf[level - 1]) { if (area->spf_delay_ietf[level - 1]) {
/* Need to call schedule function also if spf delay is running /* Need to call schedule function also if spf delay is running
* to * to

4
isisd/isis_sr.c
View File

@ -1085,7 +1085,7 @@ static void sr_start_label_manager(struct event *start)
{ {
struct isis_area *area; struct isis_area *area;
area = THREAD_ARG(start); area = EVENT_ARG(start);
/* re-attempt to start SR & Label Manager connection */ /* re-attempt to start SR & Label Manager connection */
isis_sr_start(area); isis_sr_start(area);
@ -1168,7 +1168,7 @@ void isis_sr_stop(struct isis_area *area)
area->area_tag); area->area_tag);
/* Disable any re-attempt to connect to Label Manager */ /* Disable any re-attempt to connect to Label Manager */
THREAD_OFF(srdb->t_start_lm); EVENT_OFF(srdb->t_start_lm);
/* Uninstall all local Adjacency-SIDs. */ /* Uninstall all local Adjacency-SIDs. */
for (ALL_LIST_ELEMENTS(area->srdb.adj_sids, node, nnode, sra)) for (ALL_LIST_ELEMENTS(area->srdb.adj_sids, node, nnode, sra))

8
isisd/isis_tx_queue.c
View File

@ -79,7 +79,7 @@ static void tx_queue_element_free(void *element)
{ {
struct isis_tx_queue_entry *e = element; struct isis_tx_queue_entry *e = element;
THREAD_OFF(e->retry); EVENT_OFF(e->retry);
XFREE(MTYPE_TX_QUEUE_ENTRY, e); XFREE(MTYPE_TX_QUEUE_ENTRY, e);
} }
@ -102,7 +102,7 @@ static struct isis_tx_queue_entry *tx_queue_find(struct isis_tx_queue *queue,
static void tx_queue_send_event(struct event *thread) static void tx_queue_send_event(struct event *thread)
{ {
struct isis_tx_queue_entry *e = THREAD_ARG(thread); struct isis_tx_queue_entry *e = EVENT_ARG(thread);
struct isis_tx_queue *queue = e->queue; struct isis_tx_queue *queue = e->queue;
event_add_timer(master, tx_queue_send_event, e, 5, &e->retry); event_add_timer(master, tx_queue_send_event, e, 5, &e->retry);
@ -147,7 +147,7 @@ void _isis_tx_queue_add(struct isis_tx_queue *queue,
e->type = type; e->type = type;
THREAD_OFF(e->retry); EVENT_OFF(e->retry);
event_add_event(master, tx_queue_send_event, e, 0, &e->retry); event_add_event(master, tx_queue_send_event, e, 0, &e->retry);
e->is_retry = false; e->is_retry = false;
@ -170,7 +170,7 @@ void _isis_tx_queue_del(struct isis_tx_queue *queue, struct isis_lsp *lsp,
func, file, line); func, file, line);
} }
THREAD_OFF(e->retry); EVENT_OFF(e->retry);
hash_release(queue->hash, e); hash_release(queue->hash, e);
XFREE(MTYPE_TX_QUEUE_ENTRY, e); XFREE(MTYPE_TX_QUEUE_ENTRY, e);

24
isisd/isisd.c
View File

@ -519,11 +519,11 @@ void isis_area_destroy(struct isis_area *area)
spftree_area_del(area); spftree_area_del(area);
if (area->spf_timer[0]) if (area->spf_timer[0])
isis_spf_timer_free(THREAD_ARG(area->spf_timer[0])); isis_spf_timer_free(EVENT_ARG(area->spf_timer[0]));
THREAD_OFF(area->spf_timer[0]); EVENT_OFF(area->spf_timer[0]);
if (area->spf_timer[1]) if (area->spf_timer[1])
isis_spf_timer_free(THREAD_ARG(area->spf_timer[1])); isis_spf_timer_free(EVENT_ARG(area->spf_timer[1]));
THREAD_OFF(area->spf_timer[1]); EVENT_OFF(area->spf_timer[1]);
spf_backoff_free(area->spf_delay_ietf[0]); spf_backoff_free(area->spf_delay_ietf[0]);
spf_backoff_free(area->spf_delay_ietf[1]); spf_backoff_free(area->spf_delay_ietf[1]);
@ -543,10 +543,10 @@ void isis_area_destroy(struct isis_area *area)
isis_lfa_tiebreakers_clear(area, ISIS_LEVEL1); isis_lfa_tiebreakers_clear(area, ISIS_LEVEL1);
isis_lfa_tiebreakers_clear(area, ISIS_LEVEL2); isis_lfa_tiebreakers_clear(area, ISIS_LEVEL2);
THREAD_OFF(area->t_tick); EVENT_OFF(area->t_tick);
THREAD_OFF(area->t_lsp_refresh[0]); EVENT_OFF(area->t_lsp_refresh[0]);
THREAD_OFF(area->t_lsp_refresh[1]); EVENT_OFF(area->t_lsp_refresh[1]);
THREAD_OFF(area->t_rlfa_rib_update); EVENT_OFF(area->t_rlfa_rib_update);
event_cancel_event(master, area); event_cancel_event(master, area);
@ -3119,14 +3119,14 @@ static void area_resign_level(struct isis_area *area, int level)
} }
if (area->spf_timer[level - 1]) if (area->spf_timer[level - 1])
isis_spf_timer_free(THREAD_ARG(area->spf_timer[level - 1])); isis_spf_timer_free(EVENT_ARG(area->spf_timer[level - 1]));
THREAD_OFF(area->spf_timer[level - 1]); EVENT_OFF(area->spf_timer[level - 1]);
sched_debug( sched_debug(
"ISIS (%s): Resigned from L%d - canceling LSP regeneration timer.", "ISIS (%s): Resigned from L%d - canceling LSP regeneration timer.",
area->area_tag, level); area->area_tag, level);
THREAD_OFF(area->t_lsp_refresh[level - 1]); EVENT_OFF(area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0; area->lsp_regenerate_pending[level - 1] = 0;
} }
@ -3215,7 +3215,7 @@ void isis_area_overload_bit_set(struct isis_area *area, bool overload_bit)
} else { } else {
/* Cancel overload on startup timer if it's running */ /* Cancel overload on startup timer if it's running */
if (area->t_overload_on_startup_timer) { if (area->t_overload_on_startup_timer) {
THREAD_OFF(area->t_overload_on_startup_timer); EVENT_OFF(area->t_overload_on_startup_timer);
area->t_overload_on_startup_timer = NULL; area->t_overload_on_startup_timer = NULL;
} }
} }

8
ldpd/accept.c
View File

@ -61,7 +61,7 @@ accept_del(int fd)
LIST_FOREACH(av, &accept_queue.queue, entry) LIST_FOREACH(av, &accept_queue.queue, entry)
if (av->fd == fd) { if (av->fd == fd) {
log_debug("%s: %d removed from queue", __func__, fd); log_debug("%s: %d removed from queue", __func__, fd);
THREAD_OFF(av->ev); EVENT_OFF(av->ev);
LIST_REMOVE(av, entry); LIST_REMOVE(av, entry);
free(av); free(av);
return; return;
@ -81,7 +81,7 @@ accept_unpause(void)
{ {
if (accept_queue.evt != NULL) { if (accept_queue.evt != NULL) {
log_debug(__func__); log_debug(__func__);
THREAD_OFF(accept_queue.evt); EVENT_OFF(accept_queue.evt);
accept_arm(); accept_arm();
} }
} }
@ -100,12 +100,12 @@ accept_unarm(void)
{ {
struct accept_ev *av; struct accept_ev *av;
LIST_FOREACH(av, &accept_queue.queue, entry) LIST_FOREACH(av, &accept_queue.queue, entry)
THREAD_OFF(av->ev); EVENT_OFF(av->ev);
} }
static void accept_cb(struct event *thread) static void accept_cb(struct event *thread)
{ {
struct accept_ev *av = THREAD_ARG(thread); struct accept_ev *av = EVENT_ARG(thread);
event_add_read(master, accept_cb, av, av->fd, &av->ev); event_add_read(master, accept_cb, av, av->fd, &av->ev);
av->accept_cb(thread); av->accept_cb(thread);
} }

12
ldpd/adjacency.c
View File

@ -163,7 +163,7 @@ adj_get_af(const struct adj *adj)
/* ARGSUSED */ /* ARGSUSED */
static void adj_itimer(struct event *thread) static void adj_itimer(struct event *thread)
{ {
struct adj *adj = THREAD_ARG(thread); struct adj *adj = EVENT_ARG(thread);
adj->inactivity_timer = NULL; adj->inactivity_timer = NULL;
@ -185,7 +185,7 @@ static void adj_itimer(struct event *thread)
void void
adj_start_itimer(struct adj *adj) adj_start_itimer(struct adj *adj)
{ {
THREAD_OFF(adj->inactivity_timer); EVENT_OFF(adj->inactivity_timer);
adj->inactivity_timer = NULL; adj->inactivity_timer = NULL;
event_add_timer(master, adj_itimer, adj, adj->holdtime, event_add_timer(master, adj_itimer, adj, adj->holdtime,
&adj->inactivity_timer); &adj->inactivity_timer);
@ -194,7 +194,7 @@ adj_start_itimer(struct adj *adj)
void void
adj_stop_itimer(struct adj *adj) adj_stop_itimer(struct adj *adj)
{ {
THREAD_OFF(adj->inactivity_timer); EVENT_OFF(adj->inactivity_timer);
} }
/* targeted neighbors */ /* targeted neighbors */
@ -333,7 +333,7 @@ tnbr_get_hello_interval(struct tnbr *tnbr)
/* ARGSUSED */ /* ARGSUSED */
static void tnbr_hello_timer(struct event *thread) static void tnbr_hello_timer(struct event *thread)
{ {
struct tnbr *tnbr = THREAD_ARG(thread); struct tnbr *tnbr = EVENT_ARG(thread);
tnbr->hello_timer = NULL; tnbr->hello_timer = NULL;
send_hello(HELLO_TARGETED, NULL, tnbr); send_hello(HELLO_TARGETED, NULL, tnbr);
@ -343,7 +343,7 @@ static void tnbr_hello_timer(struct event *thread)
static void static void
tnbr_start_hello_timer(struct tnbr *tnbr) tnbr_start_hello_timer(struct tnbr *tnbr)
{ {
THREAD_OFF(tnbr->hello_timer); EVENT_OFF(tnbr->hello_timer);
tnbr->hello_timer = NULL; tnbr->hello_timer = NULL;
event_add_timer(master, tnbr_hello_timer, tnbr, event_add_timer(master, tnbr_hello_timer, tnbr,
tnbr_get_hello_interval(tnbr), &tnbr->hello_timer); tnbr_get_hello_interval(tnbr), &tnbr->hello_timer);
@ -352,7 +352,7 @@ tnbr_start_hello_timer(struct tnbr *tnbr)
static void static void
tnbr_stop_hello_timer(struct tnbr *tnbr) tnbr_stop_hello_timer(struct tnbr *tnbr)
{ {
THREAD_OFF(tnbr->hello_timer); EVENT_OFF(tnbr->hello_timer);
} }
struct ctl_adj * struct ctl_adj *

10
ldpd/control.c
View File

@ -98,8 +98,8 @@ static void control_accept(struct event *thread)
struct ctl_conn *c; struct ctl_conn *c;
len = sizeof(s_un); len = sizeof(s_un);
if ((connfd = accept(THREAD_FD(thread), (struct sockaddr *)&s_un, if ((connfd = accept(EVENT_FD(thread), (struct sockaddr *)&s_un,
&len)) == -1) { &len)) == -1) {
/* /*
* Pause accept if we are out of file descriptors, or * Pause accept if we are out of file descriptors, or
* libevent will haunt us here too. * libevent will haunt us here too.
@ -169,8 +169,8 @@ control_close(int fd)
msgbuf_clear(&c->iev.ibuf.w); msgbuf_clear(&c->iev.ibuf.w);
TAILQ_REMOVE(&ctl_conns, c, entry); TAILQ_REMOVE(&ctl_conns, c, entry);
THREAD_OFF(c->iev.ev_read); EVENT_OFF(c->iev.ev_read);
THREAD_OFF(c->iev.ev_write); EVENT_OFF(c->iev.ev_write);
close(c->iev.ibuf.fd); close(c->iev.ibuf.fd);
accept_unpause(); accept_unpause();
free(c); free(c);
@ -179,7 +179,7 @@ control_close(int fd)
/* ARGSUSED */ /* ARGSUSED */
static void control_dispatch_imsg(struct event *thread) static void control_dispatch_imsg(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
struct ctl_conn *c; struct ctl_conn *c;
struct imsg imsg; struct imsg imsg;
ssize_t n; ssize_t n;

12
ldpd/interface.c
View File

@ -446,7 +446,7 @@ if_get_wait_for_sync_interval(void)
/* ARGSUSED */ /* ARGSUSED */
static void if_hello_timer(struct event *thread) static void if_hello_timer(struct event *thread)
{ {
struct iface_af *ia = THREAD_ARG(thread); struct iface_af *ia = EVENT_ARG(thread);
ia->hello_timer = NULL; ia->hello_timer = NULL;
send_hello(HELLO_LINK, ia, NULL); send_hello(HELLO_LINK, ia, NULL);
@ -456,7 +456,7 @@ static void if_hello_timer(struct event *thread)
static void static void
if_start_hello_timer(struct iface_af *ia) if_start_hello_timer(struct iface_af *ia)
{ {
THREAD_OFF(ia->hello_timer); EVENT_OFF(ia->hello_timer);
event_add_timer(master, if_hello_timer, ia, if_get_hello_interval(ia), event_add_timer(master, if_hello_timer, ia, if_get_hello_interval(ia),
&ia->hello_timer); &ia->hello_timer);
} }
@ -464,7 +464,7 @@ if_start_hello_timer(struct iface_af *ia)
static void static void
if_stop_hello_timer(struct iface_af *ia) if_stop_hello_timer(struct iface_af *ia)
{ {
THREAD_OFF(ia->hello_timer); EVENT_OFF(ia->hello_timer);
} }
struct ctl_iface * struct ctl_iface *
@ -722,7 +722,7 @@ ldp_sync_act_iface_start_sync(struct iface *iface)
static void iface_wait_for_ldp_sync_timer(struct event *thread) static void iface_wait_for_ldp_sync_timer(struct event *thread)
{ {
struct iface *iface = THREAD_ARG(thread); struct iface *iface = EVENT_ARG(thread);
ldp_sync_fsm(iface, LDP_SYNC_EVT_LDP_SYNC_COMPLETE); ldp_sync_fsm(iface, LDP_SYNC_EVT_LDP_SYNC_COMPLETE);
} }
@ -732,7 +732,7 @@ static void start_wait_for_ldp_sync_timer(struct iface *iface)
if (iface->ldp_sync.wait_for_sync_timer) if (iface->ldp_sync.wait_for_sync_timer)
return; return;
THREAD_OFF(iface->ldp_sync.wait_for_sync_timer); EVENT_OFF(iface->ldp_sync.wait_for_sync_timer);
event_add_timer(master, iface_wait_for_ldp_sync_timer, iface, event_add_timer(master, iface_wait_for_ldp_sync_timer, iface,
if_get_wait_for_sync_interval(), if_get_wait_for_sync_interval(),
&iface->ldp_sync.wait_for_sync_timer); &iface->ldp_sync.wait_for_sync_timer);
@ -740,7 +740,7 @@ static void start_wait_for_ldp_sync_timer(struct iface *iface)
static void stop_wait_for_ldp_sync_timer(struct iface *iface) static void stop_wait_for_ldp_sync_timer(struct iface *iface)
{ {
THREAD_OFF(iface->ldp_sync.wait_for_sync_timer); EVENT_OFF(iface->ldp_sync.wait_for_sync_timer);
} }
static int static int

12
ldpd/lde.c
View File

@ -234,7 +234,7 @@ lde_imsg_compose_ldpe(int type, uint32_t peerid, pid_t pid, void *data,
/* ARGSUSED */ /* ARGSUSED */
static void lde_dispatch_imsg(struct event *thread) static void lde_dispatch_imsg(struct event *thread)
{ {
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
struct imsg imsg; struct imsg imsg;
struct lde_nbr *ln; struct lde_nbr *ln;
@ -395,8 +395,8 @@ static void lde_dispatch_imsg(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
lde_shutdown(); lde_shutdown();
} }
} }
@ -415,7 +415,7 @@ static void lde_dispatch_parent(struct event *thread)
struct kif *kif; struct kif *kif;
struct kroute *kr; struct kroute *kr;
int fd; int fd;
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
ssize_t n; ssize_t n;
int shut = 0; int shut = 0;
@ -673,8 +673,8 @@ static void lde_dispatch_parent(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
lde_shutdown(); lde_shutdown();
} }
} }

4
ldpd/lde_lib.c
View File

@ -1057,12 +1057,12 @@ void lde_gc_timer(struct event *thread)
void void
lde_gc_start_timer(void) lde_gc_start_timer(void)
{ {
THREAD_OFF(gc_timer); EVENT_OFF(gc_timer);
event_add_timer(master, lde_gc_timer, NULL, LDE_GC_INTERVAL, &gc_timer); event_add_timer(master, lde_gc_timer, NULL, LDE_GC_INTERVAL, &gc_timer);
} }
void void
lde_gc_stop_timer(void) lde_gc_stop_timer(void)
{ {
THREAD_OFF(gc_timer); EVENT_OFF(gc_timer);
} }

20
ldpd/ldpd.c
View File

@ -559,7 +559,7 @@ start_child(enum ldpd_process p, char *argv0, int fd_async, int fd_sync)
/* ARGSUSED */ /* ARGSUSED */
static void main_dispatch_ldpe(struct event *thread) static void main_dispatch_ldpe(struct event *thread)
{ {
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
struct imsg imsg; struct imsg imsg;
int af; int af;
@ -613,8 +613,8 @@ static void main_dispatch_ldpe(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
ldpe_pid = 0; ldpe_pid = 0;
if (lde_pid == 0) if (lde_pid == 0)
@ -627,7 +627,7 @@ static void main_dispatch_ldpe(struct event *thread)
/* ARGSUSED */ /* ARGSUSED */
static void main_dispatch_lde(struct event *thread) static void main_dispatch_lde(struct event *thread)
{ {
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
struct imsg imsg; struct imsg imsg;
ssize_t n; ssize_t n;
@ -722,8 +722,8 @@ static void main_dispatch_lde(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
lde_pid = 0; lde_pid = 0;
if (ldpe_pid == 0) if (ldpe_pid == 0)
ldpd_shutdown(); ldpd_shutdown();
@ -735,7 +735,7 @@ static void main_dispatch_lde(struct event *thread)
/* ARGSUSED */ /* ARGSUSED */
void ldp_write_handler(struct event *thread) void ldp_write_handler(struct event *thread)
{ {
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
ssize_t n; ssize_t n;
@ -745,8 +745,8 @@ void ldp_write_handler(struct event *thread)
fatal("msgbuf_write"); fatal("msgbuf_write");
if (n == 0) { if (n == 0) {
/* this pipe is dead, so remove the event handlers */ /* this pipe is dead, so remove the event handlers */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
return; return;
} }
@ -835,7 +835,7 @@ void evbuf_init(struct evbuf *eb, int fd, void (*handler)(struct event *),
void void
evbuf_clear(struct evbuf *eb) evbuf_clear(struct evbuf *eb)
{ {
THREAD_OFF(eb->ev); EVENT_OFF(eb->ev);
msgbuf_clear(&eb->wbuf); msgbuf_clear(&eb->wbuf);
eb->wbuf.fd = -1; eb->wbuf.fd = -1;
} }

20
ldpd/ldpe.c
View File

@ -200,7 +200,7 @@ ldpe_shutdown(void)
#ifdef __OpenBSD__ #ifdef __OpenBSD__
if (sysdep.no_pfkey == 0) { if (sysdep.no_pfkey == 0) {
THREAD_OFF(pfkey_ev); EVENT_OFF(pfkey_ev);
close(global.pfkeysock); close(global.pfkeysock);
} }
#endif #endif
@ -273,7 +273,7 @@ static void ldpe_dispatch_main(struct event *thread)
struct l2vpn_pw *pw, *npw; struct l2vpn_pw *pw, *npw;
struct imsg imsg; struct imsg imsg;
int fd; int fd;
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
struct iface *iface = NULL; struct iface *iface = NULL;
struct kif *kif; struct kif *kif;
@ -615,8 +615,8 @@ static void ldpe_dispatch_main(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
ldpe_shutdown(); ldpe_shutdown();
} }
} }
@ -624,7 +624,7 @@ static void ldpe_dispatch_main(struct event *thread)
/* ARGSUSED */ /* ARGSUSED */
static void ldpe_dispatch_lde(struct event *thread) static void ldpe_dispatch_lde(struct event *thread)
{ {
struct imsgev *iev = THREAD_ARG(thread); struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf; struct imsgbuf *ibuf = &iev->ibuf;
struct imsg imsg; struct imsg imsg;
struct map *map; struct map *map;
@ -751,8 +751,8 @@ static void ldpe_dispatch_lde(struct event *thread)
imsg_event_add(iev); imsg_event_add(iev);
else { else {
/* this pipe is dead, so remove the event handlers and exit */ /* this pipe is dead, so remove the event handlers and exit */
THREAD_OFF(iev->ev_read); EVENT_OFF(iev->ev_read);
THREAD_OFF(iev->ev_write); EVENT_OFF(iev->ev_write);
ldpe_shutdown(); ldpe_shutdown();
} }
} }
@ -761,7 +761,7 @@ static void ldpe_dispatch_lde(struct event *thread)
/* ARGSUSED */ /* ARGSUSED */
static void ldpe_dispatch_pfkey(struct event *thread) static void ldpe_dispatch_pfkey(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
event_add_read(master, ldpe_dispatch_pfkey, NULL, global.pfkeysock, event_add_read(master, ldpe_dispatch_pfkey, NULL, global.pfkeysock,
&pfkey_ev); &pfkey_ev);
@ -802,14 +802,14 @@ ldpe_close_sockets(int af)
af_global = ldp_af_global_get(&global, af); af_global = ldp_af_global_get(&global, af);
/* discovery socket */ /* discovery socket */
THREAD_OFF(af_global->disc_ev); EVENT_OFF(af_global->disc_ev);
if (af_global->ldp_disc_socket != -1) { if (af_global->ldp_disc_socket != -1) {
close(af_global->ldp_disc_socket); close(af_global->ldp_disc_socket);
af_global->ldp_disc_socket = -1; af_global->ldp_disc_socket = -1;
} }
/* extended discovery socket */ /* extended discovery socket */
THREAD_OFF(af_global->edisc_ev); EVENT_OFF(af_global->edisc_ev);
if (af_global->ldp_edisc_socket != -1) { if (af_global->ldp_edisc_socket != -1) {
close(af_global->ldp_edisc_socket); close(af_global->ldp_edisc_socket);
af_global->ldp_edisc_socket = -1; af_global->ldp_edisc_socket = -1;

28
ldpd/neighbor.c
View File

@ -296,7 +296,7 @@ nbr_del(struct nbr *nbr)
nbr->auth.method = AUTH_NONE; nbr->auth.method = AUTH_NONE;
if (nbr_pending_connect(nbr)) if (nbr_pending_connect(nbr))
THREAD_OFF(nbr->ev_connect); EVENT_OFF(nbr->ev_connect);
nbr_stop_ktimer(nbr); nbr_stop_ktimer(nbr);
nbr_stop_ktimeout(nbr); nbr_stop_ktimeout(nbr);
nbr_stop_itimeout(nbr); nbr_stop_itimeout(nbr);
@ -409,7 +409,7 @@ nbr_session_active_role(struct nbr *nbr)
static void nbr_ktimer(struct event *thread) static void nbr_ktimer(struct event *thread)
{ {
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
nbr->keepalive_timer = NULL; nbr->keepalive_timer = NULL;
send_keepalive(nbr); send_keepalive(nbr);
@ -423,7 +423,7 @@ nbr_start_ktimer(struct nbr *nbr)
/* send three keepalives per period */ /* send three keepalives per period */
secs = nbr->keepalive / KEEPALIVE_PER_PERIOD; secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
THREAD_OFF(nbr->keepalive_timer); EVENT_OFF(nbr->keepalive_timer);
nbr->keepalive_timer = NULL; nbr->keepalive_timer = NULL;
event_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer); event_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer);
} }
@ -431,14 +431,14 @@ nbr_start_ktimer(struct nbr *nbr)
void void
nbr_stop_ktimer(struct nbr *nbr) nbr_stop_ktimer(struct nbr *nbr)
{ {
THREAD_OFF(nbr->keepalive_timer); EVENT_OFF(nbr->keepalive_timer);
} }
/* Keepalive timeout: if the nbr hasn't sent keepalive */ /* Keepalive timeout: if the nbr hasn't sent keepalive */
static void nbr_ktimeout(struct event *thread) static void nbr_ktimeout(struct event *thread)
{ {
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
nbr->keepalive_timeout = NULL; nbr->keepalive_timeout = NULL;
@ -450,7 +450,7 @@ static void nbr_ktimeout(struct event *thread)
static void static void
nbr_start_ktimeout(struct nbr *nbr) nbr_start_ktimeout(struct nbr *nbr)
{ {
THREAD_OFF(nbr->keepalive_timeout); EVENT_OFF(nbr->keepalive_timeout);
nbr->keepalive_timeout = NULL; nbr->keepalive_timeout = NULL;
event_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive, event_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive,
&nbr->keepalive_timeout); &nbr->keepalive_timeout);
@ -459,14 +459,14 @@ nbr_start_ktimeout(struct nbr *nbr)
void void
nbr_stop_ktimeout(struct nbr *nbr) nbr_stop_ktimeout(struct nbr *nbr)
{ {
THREAD_OFF(nbr->keepalive_timeout); EVENT_OFF(nbr->keepalive_timeout);
} }
/* Session initialization timeout: if nbr got stuck in the initialization FSM */ /* Session initialization timeout: if nbr got stuck in the initialization FSM */
static void nbr_itimeout(struct event *thread) static void nbr_itimeout(struct event *thread)
{ {
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
log_debug("%s: lsr-id %pI4", __func__, &nbr->id); log_debug("%s: lsr-id %pI4", __func__, &nbr->id);
@ -479,7 +479,7 @@ nbr_start_itimeout(struct nbr *nbr)
int secs; int secs;
secs = INIT_FSM_TIMEOUT; secs = INIT_FSM_TIMEOUT;
THREAD_OFF(nbr->init_timeout); EVENT_OFF(nbr->init_timeout);
nbr->init_timeout = NULL; nbr->init_timeout = NULL;
event_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout); event_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout);
} }
@ -487,14 +487,14 @@ nbr_start_itimeout(struct nbr *nbr)
void void
nbr_stop_itimeout(struct nbr *nbr) nbr_stop_itimeout(struct nbr *nbr)
{ {
THREAD_OFF(nbr->init_timeout); EVENT_OFF(nbr->init_timeout);
} }
/* Init delay timer: timer to retry to iniziatize session */ /* Init delay timer: timer to retry to iniziatize session */
static void nbr_idtimer(struct event *thread) static void nbr_idtimer(struct event *thread)
{ {
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
nbr->initdelay_timer = NULL; nbr->initdelay_timer = NULL;
@ -525,7 +525,7 @@ nbr_start_idtimer(struct nbr *nbr)
break; break;
} }
THREAD_OFF(nbr->initdelay_timer); EVENT_OFF(nbr->initdelay_timer);
nbr->initdelay_timer = NULL; nbr->initdelay_timer = NULL;
event_add_timer(master, nbr_idtimer, nbr, secs, &nbr->initdelay_timer); event_add_timer(master, nbr_idtimer, nbr, secs, &nbr->initdelay_timer);
} }
@ -533,7 +533,7 @@ nbr_start_idtimer(struct nbr *nbr)
void void
nbr_stop_idtimer(struct nbr *nbr) nbr_stop_idtimer(struct nbr *nbr)
{ {
THREAD_OFF(nbr->initdelay_timer); EVENT_OFF(nbr->initdelay_timer);
} }
int int
@ -550,7 +550,7 @@ nbr_pending_connect(struct nbr *nbr)
static void nbr_connect_cb(struct event *thread) static void nbr_connect_cb(struct event *thread)
{ {
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
int error; int error;
socklen_t len; socklen_t len;

20
ldpd/packet.c
View File

@ -97,8 +97,8 @@ send_packet(int fd, int af, union ldpd_addr *dst, struct iface_af *ia,
/* Discovery functions */ /* Discovery functions */
void disc_recv_packet(struct event *thread) void disc_recv_packet(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
struct event **threadp = THREAD_ARG(thread); struct event **threadp = EVENT_ARG(thread);
union { union {
struct cmsghdr hdr; struct cmsghdr hdr;
@ -292,7 +292,7 @@ disc_find_iface(unsigned int ifindex, int af, union ldpd_addr *src)
void session_accept(struct event *thread) void session_accept(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
struct sockaddr_storage src; struct sockaddr_storage src;
socklen_t len = sizeof(src); socklen_t len = sizeof(src);
int newfd; int newfd;
@ -396,8 +396,8 @@ session_accept_nbr(struct nbr *nbr, int fd)
static void session_read(struct event *thread) static void session_read(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
struct nbr *nbr = THREAD_ARG(thread); struct nbr *nbr = EVENT_ARG(thread);
struct tcp_conn *tcp = nbr->tcp; struct tcp_conn *tcp = nbr->tcp;
struct ldp_hdr *ldp_hdr; struct ldp_hdr *ldp_hdr;
struct ldp_msg *msg; struct ldp_msg *msg;
@ -612,7 +612,7 @@ static void session_read(struct event *thread)
static void session_write(struct event *thread) static void session_write(struct event *thread)
{ {
struct tcp_conn *tcp = THREAD_ARG(thread); struct tcp_conn *tcp = EVENT_ARG(thread);
struct nbr *nbr = tcp->nbr; struct nbr *nbr = tcp->nbr;
tcp->wbuf.ev = NULL; tcp->wbuf.ev = NULL;
@ -640,7 +640,7 @@ session_shutdown(struct nbr *nbr, uint32_t status, uint32_t msg_id,
switch (nbr->state) { switch (nbr->state) {
case NBR_STA_PRESENT: case NBR_STA_PRESENT:
if (nbr_pending_connect(nbr)) if (nbr_pending_connect(nbr))
THREAD_OFF(nbr->ev_connect); EVENT_OFF(nbr->ev_connect);
break; break;
case NBR_STA_INITIAL: case NBR_STA_INITIAL:
case NBR_STA_OPENREC: case NBR_STA_OPENREC:
@ -745,7 +745,7 @@ tcp_close(struct tcp_conn *tcp)
evbuf_clear(&tcp->wbuf); evbuf_clear(&tcp->wbuf);
if (tcp->nbr) { if (tcp->nbr) {
THREAD_OFF(tcp->rev); EVENT_OFF(tcp->rev);
free(tcp->rbuf); free(tcp->rbuf);
tcp->nbr->tcp = NULL; tcp->nbr->tcp = NULL;
} }
@ -777,7 +777,7 @@ pending_conn_new(int fd, int af, union ldpd_addr *addr)
void void
pending_conn_del(struct pending_conn *pconn) pending_conn_del(struct pending_conn *pconn)
{ {
THREAD_OFF(pconn->ev_timeout); EVENT_OFF(pconn->ev_timeout);
TAILQ_REMOVE(&global.pending_conns, pconn, entry); TAILQ_REMOVE(&global.pending_conns, pconn, entry);
free(pconn); free(pconn);
} }
@ -797,7 +797,7 @@ pending_conn_find(int af, union ldpd_addr *addr)
static void pending_conn_timeout(struct event *thread) static void pending_conn_timeout(struct event *thread)
{ {
struct pending_conn *pconn = THREAD_ARG(thread); struct pending_conn *pconn = EVENT_ARG(thread);
struct tcp_conn *tcp; struct tcp_conn *tcp;
pconn->ev_timeout = NULL; pconn->ev_timeout = NULL;

14
lib/agentx.c
View File

@ -46,13 +46,13 @@ static void agentx_read(struct event *t)
fd_set fds; fd_set fds;
int flags, new_flags = 0; int flags, new_flags = 0;
int nonblock = false; int nonblock = false;
struct listnode *ln = THREAD_ARG(t); struct listnode *ln = EVENT_ARG(t);
struct event **thr = listgetdata(ln); struct event **thr = listgetdata(ln);
XFREE(MTYPE_TMP, thr); XFREE(MTYPE_TMP, thr);
list_delete_node(events, ln); list_delete_node(events, ln);
/* fix for non blocking socket */ /* fix for non blocking socket */
flags = fcntl(THREAD_FD(t), F_GETFL, 0); flags = fcntl(EVENT_FD(t), F_GETFL, 0);
if (-1 == flags) { if (-1 == flags) {
flog_err(EC_LIB_SYSTEM_CALL, "Failed to get FD settings fcntl: %s(%d)", flog_err(EC_LIB_SYSTEM_CALL, "Failed to get FD settings fcntl: %s(%d)",
strerror(errno), errno); strerror(errno), errno);
@ -62,19 +62,19 @@ static void agentx_read(struct event *t)
if (flags & O_NONBLOCK) if (flags & O_NONBLOCK)
nonblock = true; nonblock = true;
else else
new_flags = fcntl(THREAD_FD(t), F_SETFL, flags | O_NONBLOCK); new_flags = fcntl(EVENT_FD(t), F_SETFL, flags | O_NONBLOCK);
if (new_flags == -1) if (new_flags == -1)
flog_err(EC_LIB_SYSTEM_CALL, "Failed to set snmp fd non blocking: %s(%d)", flog_err(EC_LIB_SYSTEM_CALL, "Failed to set snmp fd non blocking: %s(%d)",
strerror(errno), errno); strerror(errno), errno);
FD_ZERO(&fds); FD_ZERO(&fds);
FD_SET(THREAD_FD(t), &fds); FD_SET(EVENT_FD(t), &fds);
snmp_read(&fds); snmp_read(&fds);
/* Reset the flag */ /* Reset the flag */
if (!nonblock) { if (!nonblock) {
new_flags = fcntl(THREAD_FD(t), F_SETFL, flags); new_flags = fcntl(EVENT_FD(t), F_SETFL, flags);
if (new_flags == -1) if (new_flags == -1)
flog_err( flog_err(
@ -109,7 +109,7 @@ static void agentx_events_update(void)
ln = listhead(events); ln = listhead(events);
thr = ln ? listgetdata(ln) : NULL; thr = ln ? listgetdata(ln) : NULL;
thr_fd = thr ? THREAD_FD(*thr) : -1; thr_fd = thr ? EVENT_FD(*thr) : -1;
/* "two-pointer" / two-list simultaneous iteration /* "two-pointer" / two-list simultaneous iteration
* ln/thr/thr_fd point to the next existing event listener to hit while * ln/thr/thr_fd point to the next existing event listener to hit while
@ -125,7 +125,7 @@ static void agentx_events_update(void)
} }
ln = nextln; ln = nextln;
thr = ln ? listgetdata(ln) : NULL; thr = ln ? listgetdata(ln) : NULL;
thr_fd = thr ? THREAD_FD(*thr) : -1; thr_fd = thr ? EVENT_FD(*thr) : -1;
} }
/* need listener, but haven't hit one where it would be */ /* need listener, but haven't hit one where it would be */
else if (FD_ISSET(fd, &fds)) { else if (FD_ISSET(fd, &fds)) {

6
lib/bfd.c
View File

@ -487,7 +487,7 @@ static bool _bfd_sess_valid(const struct bfd_session_params *bsp)
static void _bfd_sess_send(struct event *t) static void _bfd_sess_send(struct event *t)
{ {
struct bfd_session_params *bsp = THREAD_ARG(t); struct bfd_session_params *bsp = EVENT_ARG(t);
int rv; int rv;
/* Validate configuration before trying to send bogus data. */ /* Validate configuration before trying to send bogus data. */
@ -533,7 +533,7 @@ static void _bfd_sess_send(struct event *t)
static void _bfd_sess_remove(struct bfd_session_params *bsp) static void _bfd_sess_remove(struct bfd_session_params *bsp)
{ {
/* Cancel any pending installation request. */ /* Cancel any pending installation request. */
THREAD_OFF(bsp->installev); EVENT_OFF(bsp->installev);
/* Not installed, nothing to do. */ /* Not installed, nothing to do. */
if (!bsp->installed) if (!bsp->installed)
@ -890,7 +890,7 @@ int zclient_bfd_session_replay(ZAPI_CALLBACK_ARGS)
bsp->installed = false; bsp->installed = false;
/* Cancel any pending installation request. */ /* Cancel any pending installation request. */
THREAD_OFF(bsp->installev); EVENT_OFF(bsp->installev);
/* Ask for installation. */ /* Ask for installation. */
bsp->lastev = BSE_INSTALL; bsp->lastev = BSE_INSTALL;

8
lib/event.h
View File

@ -153,14 +153,14 @@ struct cpu_event_history {
#define EVENT_TIMER_STRLEN 12 #define EVENT_TIMER_STRLEN 12
/* Macros. */ /* Macros. */
#define THREAD_ARG(X) ((X)->arg) #define EVENT_ARG(X) ((X)->arg)
#define THREAD_FD(X) ((X)->u.fd) #define EVENT_FD(X) ((X)->u.fd)
#define THREAD_VAL(X) ((X)->u.val) #define EVENT_VAL(X) ((X)->u.val)
/* /*
* Please consider this macro deprecated, and do not use it in new code. * Please consider this macro deprecated, and do not use it in new code.
*/ */
#define THREAD_OFF(thread) \ #define EVENT_OFF(thread) \
do { \ do { \
if ((thread)) \ if ((thread)) \
event_cancel(&(thread)); \ event_cancel(&(thread)); \

2
lib/frr_pthread.c
View File

@ -231,7 +231,7 @@ static void fpt_dummy(struct event *thread)
/* poison pill task to end event loop */ /* poison pill task to end event loop */
static void fpt_finish(struct event *thread) static void fpt_finish(struct event *thread)
{ {
struct frr_pthread *fpt = THREAD_ARG(thread); struct frr_pthread *fpt = EVENT_ARG(thread);
atomic_store_explicit(&fpt->running, false, memory_order_relaxed); atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
} }

4
lib/frr_zmq.c
View File

@ -45,7 +45,7 @@ void frrzmq_finish(void)
static void frrzmq_read_msg(struct event *t) static void frrzmq_read_msg(struct event *t)
{ {
struct frrzmq_cb **cbp = THREAD_ARG(t); struct frrzmq_cb **cbp = EVENT_ARG(t);
struct frrzmq_cb *cb; struct frrzmq_cb *cb;
zmq_msg_t msg; zmq_msg_t msg;
unsigned partno; unsigned partno;
@ -202,7 +202,7 @@ int _frrzmq_event_add_read(const struct xref_eventsched *xref,
static void frrzmq_write_msg(struct event *t) static void frrzmq_write_msg(struct event *t)
{ {
struct frrzmq_cb **cbp = THREAD_ARG(t); struct frrzmq_cb **cbp = EVENT_ARG(t);
struct frrzmq_cb *cb; struct frrzmq_cb *cb;
unsigned char written = 0; unsigned char written = 0;
int ret; int ret;

2
lib/ldp_sync.c
View File

@ -66,7 +66,7 @@ bool ldp_sync_if_down(struct ldp_sync_info *ldp_sync_info)
* update state * update state
*/ */
if (ldp_sync_info && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED) { if (ldp_sync_info && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED) {
THREAD_OFF(ldp_sync_info->t_holddown); EVENT_OFF(ldp_sync_info->t_holddown);
if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_UP) if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_UP)
ldp_sync_info->state = ldp_sync_info->state =

20
lib/mgmt_be_client.c
View File

@ -899,7 +899,7 @@ static void mgmt_be_client_process_msg(void *user_ctx, uint8_t *data,
static void mgmt_be_client_proc_msgbufs(struct event *thread) static void mgmt_be_client_proc_msgbufs(struct event *thread)
{ {
struct mgmt_be_client_ctx *client_ctx = THREAD_ARG(thread); struct mgmt_be_client_ctx *client_ctx = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_be_client_process_msg, if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_be_client_process_msg,
client_ctx, mgmt_debug_be_client)) client_ctx, mgmt_debug_be_client))
@ -908,7 +908,7 @@ static void mgmt_be_client_proc_msgbufs(struct event *thread)
static void mgmt_be_client_read(struct event *thread) static void mgmt_be_client_read(struct event *thread)
{ {
struct mgmt_be_client_ctx *client_ctx = THREAD_ARG(thread); struct mgmt_be_client_ctx *client_ctx = EVENT_ARG(thread);
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd,
@ -964,7 +964,7 @@ static int mgmt_be_client_send_msg(struct mgmt_be_client_ctx *client_ctx,
static void mgmt_be_client_write(struct event *thread) static void mgmt_be_client_write(struct event *thread)
{ {
struct mgmt_be_client_ctx *client_ctx = THREAD_ARG(thread); struct mgmt_be_client_ctx *client_ctx = EVENT_ARG(thread);
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd,
@ -985,7 +985,7 @@ static void mgmt_be_client_resume_writes(struct event *thread)
{ {
struct mgmt_be_client_ctx *client_ctx; struct mgmt_be_client_ctx *client_ctx;
client_ctx = (struct mgmt_be_client_ctx *)THREAD_ARG(thread); client_ctx = (struct mgmt_be_client_ctx *)EVENT_ARG(thread);
assert(client_ctx && client_ctx->conn_fd != -1); assert(client_ctx && client_ctx->conn_fd != -1);
mgmt_be_client_writes_on(client_ctx); mgmt_be_client_writes_on(client_ctx);
@ -1042,7 +1042,7 @@ static void mgmt_be_server_connect(struct mgmt_be_client_ctx *client_ctx)
static void mgmt_be_client_conn_timeout(struct event *thread) static void mgmt_be_client_conn_timeout(struct event *thread)
{ {
mgmt_be_server_connect(THREAD_ARG(thread)); mgmt_be_server_connect(EVENT_ARG(thread));
} }
static void static void
@ -1213,11 +1213,11 @@ void mgmt_be_client_lib_destroy(uintptr_t lib_hndl)
mgmt_msg_destroy(&client_ctx->mstate); mgmt_msg_destroy(&client_ctx->mstate);
THREAD_OFF(client_ctx->conn_retry_tmr); EVENT_OFF(client_ctx->conn_retry_tmr);
THREAD_OFF(client_ctx->conn_read_ev); EVENT_OFF(client_ctx->conn_read_ev);
THREAD_OFF(client_ctx->conn_write_ev); EVENT_OFF(client_ctx->conn_write_ev);
THREAD_OFF(client_ctx->conn_writes_on); EVENT_OFF(client_ctx->conn_writes_on);
THREAD_OFF(client_ctx->msg_proc_ev); EVENT_OFF(client_ctx->msg_proc_ev);
mgmt_be_cleanup_all_txns(client_ctx); mgmt_be_cleanup_all_txns(client_ctx);
mgmt_be_txns_fini(&client_ctx->txn_head); mgmt_be_txns_fini(&client_ctx->txn_head);
} }

20
lib/mgmt_fe_client.c
View File

@ -179,7 +179,7 @@ static void mgmt_fe_client_write(struct event *thread)
struct mgmt_fe_client_ctx *client_ctx; struct mgmt_fe_client_ctx *client_ctx;
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
client_ctx = (struct mgmt_fe_client_ctx *)THREAD_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_fe_client); mgmt_debug_fe_client);
if (rv == MSW_SCHED_STREAM) if (rv == MSW_SCHED_STREAM)
@ -198,7 +198,7 @@ static void mgmt_fe_client_resume_writes(struct event *thread)
{ {
struct mgmt_fe_client_ctx *client_ctx; struct mgmt_fe_client_ctx *client_ctx;
client_ctx = (struct mgmt_fe_client_ctx *)THREAD_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
assert(client_ctx && client_ctx->conn_fd != -1); assert(client_ctx && client_ctx->conn_fd != -1);
mgmt_fe_client_writes_on(client_ctx); mgmt_fe_client_writes_on(client_ctx);
@ -674,7 +674,7 @@ static void mgmt_fe_client_proc_msgbufs(struct event *thread)
{ {
struct mgmt_fe_client_ctx *client_ctx; struct mgmt_fe_client_ctx *client_ctx;
client_ctx = (struct mgmt_fe_client_ctx *)THREAD_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_fe_client_process_msg, if (mgmt_msg_procbufs(&client_ctx->mstate, mgmt_fe_client_process_msg,
client_ctx, mgmt_debug_fe_client)) client_ctx, mgmt_debug_fe_client))
mgmt_fe_client_register_event(client_ctx, MGMTD_FE_PROC_MSG); mgmt_fe_client_register_event(client_ctx, MGMTD_FE_PROC_MSG);
@ -685,7 +685,7 @@ static void mgmt_fe_client_read(struct event *thread)
struct mgmt_fe_client_ctx *client_ctx; struct mgmt_fe_client_ctx *client_ctx;
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
client_ctx = (struct mgmt_fe_client_ctx *)THREAD_ARG(thread); client_ctx = (struct mgmt_fe_client_ctx *)EVENT_ARG(thread);
rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd, rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd,
mgmt_debug_fe_client); mgmt_debug_fe_client);
@ -727,7 +727,7 @@ static void mgmt_fe_server_connect(struct mgmt_fe_client_ctx *client_ctx)
static void mgmt_fe_client_conn_timeout(struct event *thread) static void mgmt_fe_client_conn_timeout(struct event *thread)
{ {
mgmt_fe_server_connect(THREAD_ARG(thread)); mgmt_fe_server_connect(EVENT_ARG(thread));
} }
static void static void
@ -1067,10 +1067,10 @@ void mgmt_fe_client_lib_destroy(uintptr_t lib_hndl)
mgmt_fe_destroy_client_sessions(lib_hndl); mgmt_fe_destroy_client_sessions(lib_hndl);
THREAD_OFF(client_ctx->conn_retry_tmr); EVENT_OFF(client_ctx->conn_retry_tmr);
THREAD_OFF(client_ctx->conn_read_ev); EVENT_OFF(client_ctx->conn_read_ev);
THREAD_OFF(client_ctx->conn_write_ev); EVENT_OFF(client_ctx->conn_write_ev);
THREAD_OFF(client_ctx->conn_writes_on); EVENT_OFF(client_ctx->conn_writes_on);
THREAD_OFF(client_ctx->msg_proc_ev); EVENT_OFF(client_ctx->msg_proc_ev);
mgmt_msg_destroy(&client_ctx->mstate); mgmt_msg_destroy(&client_ctx->mstate);
} }

2
lib/northbound_cli.c
View File

@ -302,7 +302,7 @@ int nb_cli_confirmed_commit_rollback(struct vty *vty)
static void nb_cli_confirmed_commit_timeout(struct event *thread) static void nb_cli_confirmed_commit_timeout(struct event *thread)
{ {
struct vty *vty = THREAD_ARG(thread); struct vty *vty = EVENT_ARG(thread);
/* XXX: broadcast this message to all logged-in users? */ /* XXX: broadcast this message to all logged-in users? */
vty_out(vty, vty_out(vty,

16
lib/northbound_confd.c
View File

@ -403,7 +403,7 @@ static int frr_confd_cdb_read_cb_abort(int fd, int *subp, int reslen)
static void frr_confd_cdb_read_cb(struct event *thread) static void frr_confd_cdb_read_cb(struct event *thread)
{ {
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
enum cdb_sub_notification cdb_ev; enum cdb_sub_notification cdb_ev;
int flags; int flags;
int *subp = NULL; int *subp = NULL;
@ -588,7 +588,7 @@ error:
static void frr_confd_finish_cdb(void) static void frr_confd_finish_cdb(void)
{ {
if (cdb_sub_sock > 0) { if (cdb_sub_sock > 0) {
THREAD_OFF(t_cdb_sub); EVENT_OFF(t_cdb_sub);
cdb_close(cdb_sub_sock); cdb_close(cdb_sub_sock);
} }
} }
@ -1175,8 +1175,8 @@ static int frr_confd_dp_read(struct confd_daemon_ctx *dctx, int fd)
static void frr_confd_dp_ctl_read(struct event *thread) static void frr_confd_dp_ctl_read(struct event *thread)
{ {
struct confd_daemon_ctx *dctx = THREAD_ARG(thread); struct confd_daemon_ctx *dctx = EVENT_ARG(thread);
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
event_add_read(master, frr_confd_dp_ctl_read, dctx, fd, &t_dp_ctl); event_add_read(master, frr_confd_dp_ctl_read, dctx, fd, &t_dp_ctl);
@ -1185,8 +1185,8 @@ static void frr_confd_dp_ctl_read(struct event *thread)
static void frr_confd_dp_worker_read(struct event *thread) static void frr_confd_dp_worker_read(struct event *thread)
{ {
struct confd_daemon_ctx *dctx = THREAD_ARG(thread); struct confd_daemon_ctx *dctx = EVENT_ARG(thread);
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
event_add_read(master, frr_confd_dp_worker_read, dctx, fd, event_add_read(master, frr_confd_dp_worker_read, dctx, fd,
&t_dp_worker); &t_dp_worker);
@ -1337,11 +1337,11 @@ error:
static void frr_confd_finish_dp(void) static void frr_confd_finish_dp(void)
{ {
if (dp_worker_sock > 0) { if (dp_worker_sock > 0) {
THREAD_OFF(t_dp_worker); EVENT_OFF(t_dp_worker);
close(dp_worker_sock); close(dp_worker_sock);
} }
if (dp_ctl_sock > 0) { if (dp_ctl_sock > 0) {
THREAD_OFF(t_dp_ctl); EVENT_OFF(t_dp_ctl);
close(dp_ctl_sock); close(dp_ctl_sock);
} }
if (dctx != NULL) if (dctx != NULL)

2
lib/northbound_grpc.cpp
View File

@ -184,7 +184,7 @@ class RpcStateBase
static void c_callback(struct event *thread) static void c_callback(struct event *thread)
{ {
auto _tag = static_cast<RpcStateBase *>(THREAD_ARG(thread)); auto _tag = static_cast<RpcStateBase *>(EVENT_ARG(thread));
/* /*
* We hold the lock until the callback finishes and has updated * We hold the lock until the callback finishes and has updated
* _tag->state, then we signal done and release. * _tag->state, then we signal done and release.

6
lib/northbound_sysrepo.c
View File

@ -516,8 +516,8 @@ static int frr_sr_notification_send(const char *xpath, struct list *arguments)
static void frr_sr_read_cb(struct event *thread) static void frr_sr_read_cb(struct event *thread)
{ {
struct yang_module *module = THREAD_ARG(thread); struct yang_module *module = EVENT_ARG(thread);
int fd = THREAD_FD(thread); int fd = EVENT_FD(thread);
int ret; int ret;
ret = sr_subscription_process_events(module->sr_subscription, session, ret = sr_subscription_process_events(module->sr_subscription, session,
@ -710,7 +710,7 @@ static int frr_sr_finish(void)
if (!module->sr_subscription) if (!module->sr_subscription)
continue; continue;
sr_unsubscribe(module->sr_subscription); sr_unsubscribe(module->sr_subscription);
THREAD_OFF(module->sr_thread); EVENT_OFF(module->sr_thread);
} }
if (session) if (session)

4
lib/pullwr.c
View File

@ -61,7 +61,7 @@ struct pullwr *_pullwr_new(struct event_master *tm, int fd, void *arg,
void pullwr_del(struct pullwr *pullwr) void pullwr_del(struct pullwr *pullwr)
{ {
THREAD_OFF(pullwr->writer); EVENT_OFF(pullwr->writer);
XFREE(MTYPE_PULLWR_BUF, pullwr->buffer); XFREE(MTYPE_PULLWR_BUF, pullwr->buffer);
XFREE(MTYPE_PULLWR_HEAD, pullwr); XFREE(MTYPE_PULLWR_HEAD, pullwr);
@ -177,7 +177,7 @@ void pullwr_write(struct pullwr *pullwr, const void *data, size_t len)
static void pullwr_run(struct event *t) static void pullwr_run(struct event *t)
{ {
struct pullwr *pullwr = THREAD_ARG(t); struct pullwr *pullwr = EVENT_ARG(t);
struct iovec iov[2]; struct iovec iov[2];
size_t niov, lastvalid; size_t niov, lastvalid;
ssize_t nwr; ssize_t nwr;

18
lib/resolver.c
View File

@ -102,7 +102,7 @@ static void resolver_update_timeouts(struct resolver_state *r);
static void resolver_cb_timeout(struct event *t) static void resolver_cb_timeout(struct event *t)
{ {
struct resolver_state *r = THREAD_ARG(t); struct resolver_state *r = EVENT_ARG(t);
ares_process(r->channel, NULL, NULL); ares_process(r->channel, NULL, NULL);
resolver_update_timeouts(r); resolver_update_timeouts(r);
@ -110,13 +110,13 @@ static void resolver_cb_timeout(struct event *t)
static void resolver_cb_socket_readable(struct event *t) static void resolver_cb_socket_readable(struct event *t)
{ {
struct resolver_fd *resfd = THREAD_ARG(t); struct resolver_fd *resfd = EVENT_ARG(t);
struct resolver_state *r = resfd->state; struct resolver_state *r = resfd->state;
event_add_read(r->master, resolver_cb_socket_readable, resfd, resfd->fd, event_add_read(r->master, resolver_cb_socket_readable, resfd, resfd->fd,
&resfd->t_read); &resfd->t_read);
/* ^ ordering important: /* ^ ordering important:
* ares_process_fd may transitively call THREAD_OFF(resfd->t_read) * ares_process_fd may transitively call EVENT_OFF(resfd->t_read)
* combined with resolver_fd_drop_maybe, so resfd may be free'd after! * combined with resolver_fd_drop_maybe, so resfd may be free'd after!
*/ */
ares_process_fd(r->channel, resfd->fd, ARES_SOCKET_BAD); ares_process_fd(r->channel, resfd->fd, ARES_SOCKET_BAD);
@ -125,13 +125,13 @@ static void resolver_cb_socket_readable(struct event *t)
static void resolver_cb_socket_writable(struct event *t) static void resolver_cb_socket_writable(struct event *t)
{ {
struct resolver_fd *resfd = THREAD_ARG(t); struct resolver_fd *resfd = EVENT_ARG(t);
struct resolver_state *r = resfd->state; struct resolver_state *r = resfd->state;
event_add_write(r->master, resolver_cb_socket_writable, resfd, event_add_write(r->master, resolver_cb_socket_writable, resfd,
resfd->fd, &resfd->t_write); resfd->fd, &resfd->t_write);
/* ^ ordering important: /* ^ ordering important:
* ares_process_fd may transitively call THREAD_OFF(resfd->t_write) * ares_process_fd may transitively call EVENT_OFF(resfd->t_write)
* combined with resolver_fd_drop_maybe, so resfd may be free'd after! * combined with resolver_fd_drop_maybe, so resfd may be free'd after!
*/ */
ares_process_fd(r->channel, ARES_SOCKET_BAD, resfd->fd); ares_process_fd(r->channel, ARES_SOCKET_BAD, resfd->fd);
@ -142,7 +142,7 @@ static void resolver_update_timeouts(struct resolver_state *r)
{ {
struct timeval *tv, tvbuf; struct timeval *tv, tvbuf;
THREAD_OFF(r->timeout); EVENT_OFF(r->timeout);
tv = ares_timeout(r->channel, NULL, &tvbuf); tv = ares_timeout(r->channel, NULL, &tvbuf);
if (tv) { if (tv) {
unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000; unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
@ -165,13 +165,13 @@ static void ares_socket_cb(void *data, ares_socket_t fd, int readable,
assert(resfd->state == r); assert(resfd->state == r);
if (!readable) if (!readable)
THREAD_OFF(resfd->t_read); EVENT_OFF(resfd->t_read);
else if (!resfd->t_read) else if (!resfd->t_read)
event_add_read(r->master, resolver_cb_socket_readable, resfd, event_add_read(r->master, resolver_cb_socket_readable, resfd,
fd, &resfd->t_read); fd, &resfd->t_read);
if (!writable) if (!writable)
THREAD_OFF(resfd->t_write); EVENT_OFF(resfd->t_write);
else if (!resfd->t_write) else if (!resfd->t_write)
event_add_write(r->master, resolver_cb_socket_writable, resfd, event_add_write(r->master, resolver_cb_socket_writable, resfd,
fd, &resfd->t_write); fd, &resfd->t_write);
@ -224,7 +224,7 @@ static void ares_address_cb(void *arg, int status, int timeouts,
static void resolver_cb_literal(struct event *t) static void resolver_cb_literal(struct event *t)
{ {
struct resolver_query *query = THREAD_ARG(t); struct resolver_query *query = EVENT_ARG(t);
void (*callback)(struct resolver_query *, const char *, int, void (*callback)(struct resolver_query *, const char *, int,
union sockunion *); union sockunion *);

2
lib/sigevent.c
View File

@ -131,7 +131,7 @@ void frr_signal_timer(struct event *t)
{ {
struct frr_sigevent_master_t *sigm; struct frr_sigevent_master_t *sigm;
sigm = THREAD_ARG(t); sigm = EVENT_ARG(t);
sigm->t = NULL; sigm->t = NULL;
event_add_timer(sigm->t->master, frr_signal_timer, &sigmaster, event_add_timer(sigm->t->master, frr_signal_timer, &sigmaster,
FRR_SIGNAL_TIMER_INTERVAL, &sigm->t); FRR_SIGNAL_TIMER_INTERVAL, &sigm->t);

6
lib/spf_backoff.c
View File

@ -106,7 +106,7 @@ void spf_backoff_free(struct spf_backoff *backoff)
static void spf_backoff_timetolearn_elapsed(struct event *thread) static void spf_backoff_timetolearn_elapsed(struct event *thread)
{ {
struct spf_backoff *backoff = THREAD_ARG(thread); struct spf_backoff *backoff = EVENT_ARG(thread);
backoff->state = SPF_BACKOFF_LONG_WAIT; backoff->state = SPF_BACKOFF_LONG_WAIT;
backoff_debug("SPF Back-off(%s) TIMETOLEARN elapsed, move to state %s", backoff_debug("SPF Back-off(%s) TIMETOLEARN elapsed, move to state %s",
@ -115,9 +115,9 @@ static void spf_backoff_timetolearn_elapsed(struct event *thread)
static void spf_backoff_holddown_elapsed(struct event *thread) static void spf_backoff_holddown_elapsed(struct event *thread)
{ {
struct spf_backoff *backoff = THREAD_ARG(thread); struct spf_backoff *backoff = EVENT_ARG(thread);
THREAD_OFF(backoff->t_timetolearn); EVENT_OFF(backoff->t_timetolearn);
timerclear(&backoff->first_event_time); timerclear(&backoff->first_event_time);
backoff->state = SPF_BACKOFF_QUIET; backoff->state = SPF_BACKOFF_QUIET;
backoff_debug("SPF Back-off(%s) HOLDDOWN elapsed, move to state %s", backoff_debug("SPF Back-off(%s) HOLDDOWN elapsed, move to state %s",

36
lib/vty.c
View File

@ -1366,7 +1366,7 @@ static void vty_read(struct event *thread)
int nbytes; int nbytes;
unsigned char buf[VTY_READ_BUFSIZ]; unsigned char buf[VTY_READ_BUFSIZ];
struct vty *vty = THREAD_ARG(thread); struct vty *vty = EVENT_ARG(thread);
/* Read raw data from socket */ /* Read raw data from socket */
if ((nbytes = read(vty->fd, buf, VTY_READ_BUFSIZ)) <= 0) { if ((nbytes = read(vty->fd, buf, VTY_READ_BUFSIZ)) <= 0) {
@ -1567,11 +1567,11 @@ static void vty_flush(struct event *thread)
{ {
int erase; int erase;
buffer_status_t flushrc; buffer_status_t flushrc;
struct vty *vty = THREAD_ARG(thread); struct vty *vty = EVENT_ARG(thread);
/* Tempolary disable read thread. */ /* Tempolary disable read thread. */
if (vty->lines == 0) if (vty->lines == 0)
THREAD_OFF(vty->t_read); EVENT_OFF(vty->t_read);
/* Function execution continue. */ /* Function execution continue. */
erase = ((vty->status == VTY_MORE || vty->status == VTY_MORELINE)); erase = ((vty->status == VTY_MORE || vty->status == VTY_MORELINE));
@ -1757,9 +1757,9 @@ void vty_stdio_suspend(void)
if (!stdio_vty) if (!stdio_vty)
return; return;
THREAD_OFF(stdio_vty->t_write); EVENT_OFF(stdio_vty->t_write);
THREAD_OFF(stdio_vty->t_read); EVENT_OFF(stdio_vty->t_read);
THREAD_OFF(stdio_vty->t_timeout); EVENT_OFF(stdio_vty->t_timeout);
if (stdio_termios) if (stdio_termios)
tcsetattr(0, TCSANOW, &stdio_orig_termios); tcsetattr(0, TCSANOW, &stdio_orig_termios);
@ -1825,7 +1825,7 @@ struct vty *vty_stdio(void (*atclose)(int isexit))
/* Accept connection from the network. */ /* Accept connection from the network. */
static void vty_accept(struct event *thread) static void vty_accept(struct event *thread)
{ {
struct vty_serv *vtyserv = THREAD_ARG(thread); struct vty_serv *vtyserv = EVENT_ARG(thread);
int vty_sock; int vty_sock;
union sockunion su; union sockunion su;
int ret; int ret;
@ -2038,7 +2038,7 @@ static void vty_serv_un(const char *path)
static void vtysh_accept(struct event *thread) static void vtysh_accept(struct event *thread)
{ {
struct vty_serv *vtyserv = THREAD_ARG(thread); struct vty_serv *vtyserv = EVENT_ARG(thread);
int accept_sock = vtyserv->sock; int accept_sock = vtyserv->sock;
int sock; int sock;
int client_len; int client_len;
@ -2176,8 +2176,8 @@ static void vtysh_read(struct event *thread)
unsigned char *p; unsigned char *p;
uint8_t header[4] = {0, 0, 0, 0}; uint8_t header[4] = {0, 0, 0, 0};
sock = THREAD_FD(thread); sock = EVENT_FD(thread);
vty = THREAD_ARG(thread); vty = EVENT_ARG(thread);
if ((nbytes = read(sock, buf, VTY_READ_BUFSIZ)) <= 0) { if ((nbytes = read(sock, buf, VTY_READ_BUFSIZ)) <= 0) {
if (nbytes < 0) { if (nbytes < 0) {
@ -2277,7 +2277,7 @@ static void vtysh_read(struct event *thread)
static void vtysh_write(struct event *thread) static void vtysh_write(struct event *thread)
{ {
struct vty *vty = THREAD_ARG(thread); struct vty *vty = EVENT_ARG(thread);
vtysh_flush(vty); vtysh_flush(vty);
} }
@ -2322,9 +2322,9 @@ void vty_close(struct vty *vty)
vty_config_exit(vty); vty_config_exit(vty);
/* Cancel threads.*/ /* Cancel threads.*/
THREAD_OFF(vty->t_read); EVENT_OFF(vty->t_read);
THREAD_OFF(vty->t_write); EVENT_OFF(vty->t_write);
THREAD_OFF(vty->t_timeout); EVENT_OFF(vty->t_timeout);
if (vty->pass_fd != -1) { if (vty->pass_fd != -1) {
close(vty->pass_fd); close(vty->pass_fd);
@ -2386,7 +2386,7 @@ static void vty_timeout(struct event *thread)
{ {
struct vty *vty; struct vty *vty;
vty = THREAD_ARG(thread); vty = EVENT_ARG(thread);
vty->v_timeout = 0; vty->v_timeout = 0;
/* Clear buffer*/ /* Clear buffer*/
@ -2844,7 +2844,7 @@ static void vty_event(enum vty_event event, struct vty *vty)
/* Time out treatment. */ /* Time out treatment. */
if (vty->v_timeout) { if (vty->v_timeout) {
THREAD_OFF(vty->t_timeout); EVENT_OFF(vty->t_timeout);
event_add_timer(vty_master, vty_timeout, vty, event_add_timer(vty_master, vty_timeout, vty,
vty->v_timeout, &vty->t_timeout); vty->v_timeout, &vty->t_timeout);
} }
@ -2854,7 +2854,7 @@ static void vty_event(enum vty_event event, struct vty *vty)
&vty->t_write); &vty->t_write);
break; break;
case VTY_TIMEOUT_RESET: case VTY_TIMEOUT_RESET:
THREAD_OFF(vty->t_timeout); EVENT_OFF(vty->t_timeout);
if (vty->v_timeout) if (vty->v_timeout)
event_add_timer(vty_master, vty_timeout, vty, event_add_timer(vty_master, vty_timeout, vty,
vty->v_timeout, &vty->t_timeout); vty->v_timeout, &vty->t_timeout);
@ -3726,7 +3726,7 @@ void vty_terminate(void)
vtys_init(vtysh_sessions); vtys_init(vtysh_sessions);
while ((vtyserv = vtyservs_pop(vty_servs))) { while ((vtyserv = vtyservs_pop(vty_servs))) {
THREAD_OFF(vtyserv->t_accept); EVENT_OFF(vtyserv->t_accept);
close(vtyserv->sock); close(vtyserv->sock);
XFREE(MTYPE_VTY_SERV, vtyserv); XFREE(MTYPE_VTY_SERV, vtyserv);
} }

6
lib/wheel.c
View File

@ -26,7 +26,7 @@ static void wheel_timer_thread_helper(struct event *t)
struct timer_wheel *wheel; struct timer_wheel *wheel;
void *data; void *data;
wheel = THREAD_ARG(t); wheel = EVENT_ARG(t);
wheel->curr_slot += wheel->slots_to_skip; wheel->curr_slot += wheel->slots_to_skip;
@ -55,7 +55,7 @@ static void wheel_timer_thread(struct event *t)
{ {
struct timer_wheel *wheel; struct timer_wheel *wheel;
wheel = THREAD_ARG(t); wheel = EVENT_ARG(t);
event_execute(wheel->master, wheel_timer_thread_helper, wheel, 0); event_execute(wheel->master, wheel_timer_thread_helper, wheel, 0);
} }
@ -99,7 +99,7 @@ void wheel_delete(struct timer_wheel *wheel)
list_delete(&wheel->wheel_slot_lists[i]); list_delete(&wheel->wheel_slot_lists[i]);
} }
THREAD_OFF(wheel->timer); EVENT_OFF(wheel->timer);
XFREE(MTYPE_TIMER_WHEEL_LIST, wheel->wheel_slot_lists); XFREE(MTYPE_TIMER_WHEEL_LIST, wheel->wheel_slot_lists);
XFREE(MTYPE_TIMER_WHEEL, wheel->name); XFREE(MTYPE_TIMER_WHEEL, wheel->name);
XFREE(MTYPE_TIMER_WHEEL, wheel); XFREE(MTYPE_TIMER_WHEEL, wheel);

6
lib/workqueue.c
View File

@ -88,7 +88,7 @@ void work_queue_free_and_null(struct work_queue **wqp)
{ {
struct work_queue *wq = *wqp; struct work_queue *wq = *wqp;
THREAD_OFF(wq->thread); EVENT_OFF(wq->thread);
while (!work_queue_empty(wq)) { while (!work_queue_empty(wq)) {
struct work_queue_item *item = work_queue_last_item(wq); struct work_queue_item *item = work_queue_last_item(wq);
@ -198,7 +198,7 @@ void workqueue_cmd_init(void)
*/ */
void work_queue_plug(struct work_queue *wq) void work_queue_plug(struct work_queue *wq)
{ {
THREAD_OFF(wq->thread); EVENT_OFF(wq->thread);
UNSET_FLAG(wq->flags, WQ_UNPLUGGED); UNSET_FLAG(wq->flags, WQ_UNPLUGGED);
} }
@ -226,7 +226,7 @@ void work_queue_run(struct event *thread)
unsigned int cycles = 0; unsigned int cycles = 0;
char yielded = 0; char yielded = 0;
wq = THREAD_ARG(thread); wq = EVENT_ARG(thread);
assert(wq); assert(wq);

14
lib/zclient.c
View File

@ -160,9 +160,9 @@ void zclient_stop(struct zclient *zclient)
zlog_debug("zclient %p stopped", zclient); zlog_debug("zclient %p stopped", zclient);
/* Stop threads. */ /* Stop threads. */
THREAD_OFF(zclient->t_read); EVENT_OFF(zclient->t_read);
THREAD_OFF(zclient->t_connect); EVENT_OFF(zclient->t_connect);
THREAD_OFF(zclient->t_write); EVENT_OFF(zclient->t_write);
/* Reset streams. */ /* Reset streams. */
stream_reset(zclient->ibuf); stream_reset(zclient->ibuf);
@ -251,7 +251,7 @@ static enum zclient_send_status zclient_failed(struct zclient *zclient)
static void zclient_flush_data(struct event *thread) static void zclient_flush_data(struct event *thread)
{ {
struct zclient *zclient = THREAD_ARG(thread); struct zclient *zclient = EVENT_ARG(thread);
zclient->t_write = NULL; zclient->t_write = NULL;
if (zclient->sock < 0) if (zclient->sock < 0)
@ -295,7 +295,7 @@ enum zclient_send_status zclient_send_message(struct zclient *zclient)
__func__, zclient->sock); __func__, zclient->sock);
return zclient_failed(zclient); return zclient_failed(zclient);
case BUFFER_EMPTY: case BUFFER_EMPTY:
THREAD_OFF(zclient->t_write); EVENT_OFF(zclient->t_write);
return ZCLIENT_SEND_SUCCESS; return ZCLIENT_SEND_SUCCESS;
case BUFFER_PENDING: case BUFFER_PENDING:
event_add_write(zclient->master, zclient_flush_data, zclient, event_add_write(zclient->master, zclient_flush_data, zclient,
@ -748,7 +748,7 @@ static void zclient_connect(struct event *t)
{ {
struct zclient *zclient; struct zclient *zclient;
zclient = THREAD_ARG(t); zclient = EVENT_ARG(t);
zclient->t_connect = NULL; zclient->t_connect = NULL;
if (zclient_debug) if (zclient_debug)
@ -4035,7 +4035,7 @@ static void zclient_read(struct event *thread)
struct zclient *zclient; struct zclient *zclient;
/* Get socket to zebra. */ /* Get socket to zebra. */
zclient = THREAD_ARG(thread); zclient = EVENT_ARG(thread);
zclient->t_read = NULL; zclient->t_read = NULL;
/* Read zebra header (if we don't have it already). */ /* Read zebra header (if we don't have it already). */

4
lib/zlog_5424.c
View File

@ -791,8 +791,8 @@ static void zlog_5424_cycle(struct zlog_cfg_5424 *zcf, int fd)
static void zlog_5424_reconnect(struct event *t) static void zlog_5424_reconnect(struct event *t)
{ {
struct zlog_cfg_5424 *zcf = THREAD_ARG(t); struct zlog_cfg_5424 *zcf = EVENT_ARG(t);
int fd = THREAD_FD(t); int fd = EVENT_FD(t);
char dummy[256]; char dummy[256];
ssize_t ret; ssize_t ret;

20
mgmtd/mgmt_be_adapter.c
View File

@ -616,7 +616,7 @@ static void mgmt_be_adapter_process_msg(void *user_ctx, uint8_t *data,
static void mgmt_be_adapter_proc_msgbufs(struct event *thread) static void mgmt_be_adapter_proc_msgbufs(struct event *thread)
{ {
struct mgmt_be_client_adapter *adapter = THREAD_ARG(thread); struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&adapter->mstate, mgmt_be_adapter_process_msg, if (mgmt_msg_procbufs(&adapter->mstate, mgmt_be_adapter_process_msg,
adapter, mgmt_debug_be)) adapter, mgmt_debug_be))
@ -628,7 +628,7 @@ static void mgmt_be_adapter_read(struct event *thread)
struct mgmt_be_client_adapter *adapter; struct mgmt_be_client_adapter *adapter;
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
adapter = (struct mgmt_be_client_adapter *)THREAD_ARG(thread); adapter = (struct mgmt_be_client_adapter *)EVENT_ARG(thread);
rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_be); rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_be);
if (rv == MSR_DISCONNECT) { if (rv == MSR_DISCONNECT) {
@ -642,7 +642,7 @@ static void mgmt_be_adapter_read(struct event *thread)
static void mgmt_be_adapter_write(struct event *thread) static void mgmt_be_adapter_write(struct event *thread)
{ {
struct mgmt_be_client_adapter *adapter = THREAD_ARG(thread); struct mgmt_be_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_be); rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_be);
@ -662,7 +662,7 @@ static void mgmt_be_adapter_resume_writes(struct event *thread)
{ {
struct mgmt_be_client_adapter *adapter; struct mgmt_be_client_adapter *adapter;
adapter = (struct mgmt_be_client_adapter *)THREAD_ARG(thread); adapter = (struct mgmt_be_client_adapter *)EVENT_ARG(thread);
assert(adapter && adapter->conn_fd >= 0); assert(adapter && adapter->conn_fd >= 0);
mgmt_be_adapter_writes_on(adapter); mgmt_be_adapter_writes_on(adapter);
@ -699,7 +699,7 @@ static void mgmt_be_adapter_conn_init(struct event *thread)
{ {
struct mgmt_be_client_adapter *adapter; struct mgmt_be_client_adapter *adapter;
adapter = (struct mgmt_be_client_adapter *)THREAD_ARG(thread); adapter = (struct mgmt_be_client_adapter *)EVENT_ARG(thread);
assert(adapter && adapter->conn_fd >= 0); assert(adapter && adapter->conn_fd >= 0);
/* /*
@ -793,11 +793,11 @@ extern void mgmt_be_adapter_unlock(struct mgmt_be_client_adapter **adapter)
(*adapter)->refcount--; (*adapter)->refcount--;
if (!(*adapter)->refcount) { if (!(*adapter)->refcount) {
mgmt_be_adapters_del(&mgmt_be_adapters, *adapter); mgmt_be_adapters_del(&mgmt_be_adapters, *adapter);
THREAD_OFF((*adapter)->conn_init_ev); EVENT_OFF((*adapter)->conn_init_ev);
THREAD_OFF((*adapter)->conn_read_ev); EVENT_OFF((*adapter)->conn_read_ev);
THREAD_OFF((*adapter)->conn_write_ev); EVENT_OFF((*adapter)->conn_write_ev);
THREAD_OFF((*adapter)->conn_writes_on); EVENT_OFF((*adapter)->conn_writes_on);
THREAD_OFF((*adapter)->proc_msg_ev); EVENT_OFF((*adapter)->proc_msg_ev);
mgmt_msg_destroy(&(*adapter)->mstate); mgmt_msg_destroy(&(*adapter)->mstate);
XFREE(MTYPE_MGMTD_BE_ADPATER, *adapter); XFREE(MTYPE_MGMTD_BE_ADPATER, *adapter);
} }

2
mgmtd/mgmt_be_server.c
View File

@ -146,7 +146,7 @@ void mgmt_be_server_destroy(void)
MGMTD_BE_SRVR_DBG("Closing MGMTD Backend Server!"); MGMTD_BE_SRVR_DBG("Closing MGMTD Backend Server!");
if (mgmt_be_listen_ev) { if (mgmt_be_listen_ev) {
THREAD_OFF(mgmt_be_listen_ev); EVENT_OFF(mgmt_be_listen_ev);
mgmt_be_listen_ev = NULL; mgmt_be_listen_ev = NULL;
} }

20
mgmtd/mgmt_fe_adapter.c
View File

@ -633,7 +633,7 @@ static void mgmt_fe_session_cfg_txn_clnup(struct event *thread)
{ {
struct mgmt_fe_session_ctx *session; struct mgmt_fe_session_ctx *session;
session = (struct mgmt_fe_session_ctx *)THREAD_ARG(thread); session = (struct mgmt_fe_session_ctx *)EVENT_ARG(thread);
mgmt_fe_session_cfg_txn_cleanup(session); mgmt_fe_session_cfg_txn_cleanup(session);
} }
@ -642,7 +642,7 @@ static void mgmt_fe_session_show_txn_clnup(struct event *thread)
{ {
struct mgmt_fe_session_ctx *session; struct mgmt_fe_session_ctx *session;
session = (struct mgmt_fe_session_ctx *)THREAD_ARG(thread); session = (struct mgmt_fe_session_ctx *)EVENT_ARG(thread);
mgmt_fe_session_show_txn_cleanup(session); mgmt_fe_session_show_txn_cleanup(session);
} }
@ -1437,7 +1437,7 @@ static void mgmt_fe_adapter_process_msg(void *user_ctx, uint8_t *data,
static void mgmt_fe_adapter_proc_msgbufs(struct event *thread) static void mgmt_fe_adapter_proc_msgbufs(struct event *thread)
{ {
struct mgmt_fe_client_adapter *adapter = THREAD_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
if (mgmt_msg_procbufs(&adapter->mstate, mgmt_fe_adapter_process_msg, if (mgmt_msg_procbufs(&adapter->mstate, mgmt_fe_adapter_process_msg,
adapter, mgmt_debug_fe)) adapter, mgmt_debug_fe))
@ -1446,7 +1446,7 @@ static void mgmt_fe_adapter_proc_msgbufs(struct event *thread)
static void mgmt_fe_adapter_read(struct event *thread) static void mgmt_fe_adapter_read(struct event *thread)
{ {
struct mgmt_fe_client_adapter *adapter = THREAD_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_rsched rv; enum mgmt_msg_rsched rv;
rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe); rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe);
@ -1461,7 +1461,7 @@ static void mgmt_fe_adapter_read(struct event *thread)
static void mgmt_fe_adapter_write(struct event *thread) static void mgmt_fe_adapter_write(struct event *thread)
{ {
struct mgmt_fe_client_adapter *adapter = THREAD_ARG(thread); struct mgmt_fe_client_adapter *adapter = EVENT_ARG(thread);
enum mgmt_msg_wsched rv; enum mgmt_msg_wsched rv;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe); rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe);
@ -1481,7 +1481,7 @@ static void mgmt_fe_adapter_resume_writes(struct event *thread)
{ {
struct mgmt_fe_client_adapter *adapter; struct mgmt_fe_client_adapter *adapter;
adapter = (struct mgmt_fe_client_adapter *)THREAD_ARG(thread); adapter = (struct mgmt_fe_client_adapter *)EVENT_ARG(thread);
assert(adapter && adapter->conn_fd != -1); assert(adapter && adapter->conn_fd != -1);
mgmt_fe_adapter_writes_on(adapter); mgmt_fe_adapter_writes_on(adapter);
@ -1538,10 +1538,10 @@ mgmt_fe_adapter_unlock(struct mgmt_fe_client_adapter **adapter)
(*adapter)->refcount--; (*adapter)->refcount--;
if (!(*adapter)->refcount) { if (!(*adapter)->refcount) {
mgmt_fe_adapters_del(&mgmt_fe_adapters, *adapter); mgmt_fe_adapters_del(&mgmt_fe_adapters, *adapter);
THREAD_OFF((*adapter)->conn_read_ev); EVENT_OFF((*adapter)->conn_read_ev);
THREAD_OFF((*adapter)->conn_write_ev); EVENT_OFF((*adapter)->conn_write_ev);
THREAD_OFF((*adapter)->proc_msg_ev); EVENT_OFF((*adapter)->proc_msg_ev);
THREAD_OFF((*adapter)->conn_writes_on); EVENT_OFF((*adapter)->conn_writes_on);
mgmt_msg_destroy(&(*adapter)->mstate); mgmt_msg_destroy(&(*adapter)->mstate);
XFREE(MTYPE_MGMTD_FE_ADPATER, *adapter); XFREE(MTYPE_MGMTD_FE_ADPATER, *adapter);
} }

2
mgmtd/mgmt_fe_server.c
View File

@ -146,7 +146,7 @@ void mgmt_fe_server_destroy(void)
MGMTD_FE_SRVR_DBG("Closing MGMTD Frontend Server!"); MGMTD_FE_SRVR_DBG("Closing MGMTD Frontend Server!");
if (mgmt_fe_listen_ev) { if (mgmt_fe_listen_ev) {
THREAD_OFF(mgmt_fe_listen_ev); EVENT_OFF(mgmt_fe_listen_ev);
mgmt_fe_listen_ev = NULL; mgmt_fe_listen_ev = NULL;
} }

24
mgmtd/mgmt_txn.c
View File

@ -628,7 +628,7 @@ static void mgmt_txn_process_set_cfg(struct event *thread)
struct mgmt_commit_stats *cmt_stats; struct mgmt_commit_stats *cmt_stats;
int ret = 0; int ret = 0;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
cmt_stats = mgmt_fe_get_session_commit_stats(txn->session_id); cmt_stats = mgmt_fe_get_session_commit_stats(txn->session_id);
@ -780,7 +780,7 @@ static int mgmt_txn_send_commit_cfg_reply(struct mgmt_txn_ctx *txn,
if (success) { if (success) {
/* Stop the commit-timeout timer */ /* Stop the commit-timeout timer */
THREAD_OFF(txn->comm_cfg_timeout); EVENT_OFF(txn->comm_cfg_timeout);
create_cmt_info_rec = create_cmt_info_rec =
(result != MGMTD_NO_CFG_CHANGES && (result != MGMTD_NO_CFG_CHANGES &&
@ -1458,7 +1458,7 @@ static void mgmt_txn_cfg_commit_timedout(struct event *thread)
{ {
struct mgmt_txn_ctx *txn; struct mgmt_txn_ctx *txn;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
assert(txn->type == MGMTD_TXN_TYPE_CONFIG); assert(txn->type == MGMTD_TXN_TYPE_CONFIG);
@ -1549,7 +1549,7 @@ static void mgmt_txn_process_commit_cfg(struct event *thread)
struct mgmt_txn_ctx *txn; struct mgmt_txn_ctx *txn;
struct mgmt_commit_cfg_req *cmtcfg_req; struct mgmt_commit_cfg_req *cmtcfg_req;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
MGMTD_TXN_DBG( MGMTD_TXN_DBG(
@ -1615,7 +1615,7 @@ static void mgmt_txn_process_commit_cfg(struct event *thread)
* cleanup. Please see mgmt_fe_send_commit_cfg_reply() for * cleanup. Please see mgmt_fe_send_commit_cfg_reply() for
* more details. * more details.
*/ */
THREAD_OFF(txn->comm_cfg_timeout); EVENT_OFF(txn->comm_cfg_timeout);
mgmt_txn_send_commit_cfg_reply(txn, MGMTD_SUCCESS, NULL); mgmt_txn_send_commit_cfg_reply(txn, MGMTD_SUCCESS, NULL);
break; break;
case MGMTD_COMMIT_PHASE_MAX: case MGMTD_COMMIT_PHASE_MAX:
@ -1882,7 +1882,7 @@ static void mgmt_txn_process_get_cfg(struct event *thread)
int num_processed = 0; int num_processed = 0;
bool error; bool error;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
MGMTD_TXN_DBG( MGMTD_TXN_DBG(
@ -1949,7 +1949,7 @@ static void mgmt_txn_process_get_data(struct event *thread)
int num_processed = 0; int num_processed = 0;
bool error; bool error;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
MGMTD_TXN_DBG( MGMTD_TXN_DBG(
@ -2170,10 +2170,10 @@ static void mgmt_txn_unlock(struct mgmt_txn_ctx **txn, const char *file,
if ((*txn)->type == MGMTD_TXN_TYPE_CONFIG) if ((*txn)->type == MGMTD_TXN_TYPE_CONFIG)
if (mgmt_txn_mm->cfg_txn == *txn) if (mgmt_txn_mm->cfg_txn == *txn)
mgmt_txn_mm->cfg_txn = NULL; mgmt_txn_mm->cfg_txn = NULL;
THREAD_OFF((*txn)->proc_get_cfg); EVENT_OFF((*txn)->proc_get_cfg);
THREAD_OFF((*txn)->proc_get_data); EVENT_OFF((*txn)->proc_get_data);
THREAD_OFF((*txn)->proc_comm_cfg); EVENT_OFF((*txn)->proc_comm_cfg);
THREAD_OFF((*txn)->comm_cfg_timeout); EVENT_OFF((*txn)->comm_cfg_timeout);
hash_release(mgmt_txn_mm->txn_hash, *txn); hash_release(mgmt_txn_mm->txn_hash, *txn);
mgmt_txns_del(&mgmt_txn_mm->txn_list, *txn); mgmt_txns_del(&mgmt_txn_mm->txn_list, *txn);
@ -2210,7 +2210,7 @@ static void mgmt_txn_cleanup(struct event *thread)
{ {
struct mgmt_txn_ctx *txn; struct mgmt_txn_ctx *txn;
txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread); txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn); assert(txn);
mgmt_txn_cleanup_txn(&txn); mgmt_txn_cleanup_txn(&txn);

2
nhrpd/netlink_arp.c
View File

@ -99,7 +99,7 @@ static void netlink_log_indication(struct nlmsghdr *msg, struct zbuf *zb)
static void netlink_log_recv(struct event *t) static void netlink_log_recv(struct event *t)
{ {
uint8_t buf[ZNL_BUFFER_SIZE]; uint8_t buf[ZNL_BUFFER_SIZE];
int fd = THREAD_FD(t); int fd = EVENT_FD(t);
struct zbuf payload, zb; struct zbuf payload, zb;
struct nlmsghdr *n; struct nlmsghdr *n;

14
nhrpd/nhrp_cache.c
View File

@ -72,8 +72,8 @@ static void nhrp_cache_free(struct nhrp_cache *c)
hash_release(nifp->cache_hash, c); hash_release(nifp->cache_hash, c);
nhrp_peer_unref(c->cur.peer); nhrp_peer_unref(c->cur.peer);
nhrp_peer_unref(c->new.peer); nhrp_peer_unref(c->new.peer);
THREAD_OFF(c->t_timeout); EVENT_OFF(c->t_timeout);
THREAD_OFF(c->t_auth); EVENT_OFF(c->t_auth);
XFREE(MTYPE_NHRP_CACHE, c); XFREE(MTYPE_NHRP_CACHE, c);
} }
@ -197,7 +197,7 @@ struct nhrp_cache *nhrp_cache_get(struct interface *ifp,
static void nhrp_cache_do_free(struct event *t) static void nhrp_cache_do_free(struct event *t)
{ {
struct nhrp_cache *c = THREAD_ARG(t); struct nhrp_cache *c = EVENT_ARG(t);
c->t_timeout = NULL; c->t_timeout = NULL;
nhrp_cache_free(c); nhrp_cache_free(c);
@ -205,7 +205,7 @@ static void nhrp_cache_do_free(struct event *t)
static void nhrp_cache_do_timeout(struct event *t) static void nhrp_cache_do_timeout(struct event *t)
{ {
struct nhrp_cache *c = THREAD_ARG(t); struct nhrp_cache *c = EVENT_ARG(t);
c->t_timeout = NULL; c->t_timeout = NULL;
if (c->cur.type != NHRP_CACHE_INVALID) if (c->cur.type != NHRP_CACHE_INVALID)
@ -310,7 +310,7 @@ static void nhrp_cache_peer_notifier(struct notifier_block *n,
static void nhrp_cache_reset_new(struct nhrp_cache *c) static void nhrp_cache_reset_new(struct nhrp_cache *c)
{ {
THREAD_OFF(c->t_auth); EVENT_OFF(c->t_auth);
if (notifier_list_anywhere(&c->newpeer_notifier)) if (notifier_list_anywhere(&c->newpeer_notifier))
nhrp_peer_notify_del(c->new.peer, &c->newpeer_notifier); nhrp_peer_notify_del(c->new.peer, &c->newpeer_notifier);
nhrp_peer_unref(c->new.peer); nhrp_peer_unref(c->new.peer);
@ -320,7 +320,7 @@ static void nhrp_cache_reset_new(struct nhrp_cache *c)
static void nhrp_cache_update_timers(struct nhrp_cache *c) static void nhrp_cache_update_timers(struct nhrp_cache *c)
{ {
THREAD_OFF(c->t_timeout); EVENT_OFF(c->t_timeout);
switch (c->cur.type) { switch (c->cur.type) {
case NHRP_CACHE_INVALID: case NHRP_CACHE_INVALID:
@ -397,7 +397,7 @@ static void nhrp_cache_authorize_binding(struct nhrp_reqid *r, void *arg)
static void nhrp_cache_do_auth_timeout(struct event *t) static void nhrp_cache_do_auth_timeout(struct event *t)
{ {
struct nhrp_cache *c = THREAD_ARG(t); struct nhrp_cache *c = EVENT_ARG(t);
c->t_auth = NULL; c->t_auth = NULL;
nhrp_cache_authorize_binding(&c->eventid, (void *)"timeout"); nhrp_cache_authorize_binding(&c->eventid, (void *)"timeout");
} }

10
nhrpd/nhrp_event.c
View File

@ -31,8 +31,8 @@ static void evmgr_reconnect(struct event *t);
static void evmgr_connection_error(struct event_manager *evmgr) static void evmgr_connection_error(struct event_manager *evmgr)
{ {
THREAD_OFF(evmgr->t_read); EVENT_OFF(evmgr->t_read);
THREAD_OFF(evmgr->t_write); EVENT_OFF(evmgr->t_write);
zbuf_reset(&evmgr->ibuf); zbuf_reset(&evmgr->ibuf);
zbufq_reset(&evmgr->obuf); zbufq_reset(&evmgr->obuf);
@ -76,7 +76,7 @@ static void evmgr_recv_message(struct event_manager *evmgr, struct zbuf *zb)
static void evmgr_read(struct event *t) static void evmgr_read(struct event *t)
{ {
struct event_manager *evmgr = THREAD_ARG(t); struct event_manager *evmgr = EVENT_ARG(t);
struct zbuf *ibuf = &evmgr->ibuf; struct zbuf *ibuf = &evmgr->ibuf;
struct zbuf msg; struct zbuf msg;
@ -94,7 +94,7 @@ static void evmgr_read(struct event *t)
static void evmgr_write(struct event *t) static void evmgr_write(struct event *t)
{ {
struct event_manager *evmgr = THREAD_ARG(t); struct event_manager *evmgr = EVENT_ARG(t);
int r; int r;
r = zbufq_write(&evmgr->obuf, evmgr->fd); r = zbufq_write(&evmgr->obuf, evmgr->fd);
@ -181,7 +181,7 @@ static void evmgr_submit(struct event_manager *evmgr, struct zbuf *obuf)
static void evmgr_reconnect(struct event *t) static void evmgr_reconnect(struct event *t)
{ {
struct event_manager *evmgr = THREAD_ARG(t); struct event_manager *evmgr = EVENT_ARG(t);
int fd; int fd;
if (evmgr->fd >= 0 || !nhrp_event_socket_path) if (evmgr->fd >= 0 || !nhrp_event_socket_path)

4
nhrpd/nhrp_multicast.c
View File

@ -141,7 +141,7 @@ static void netlink_mcast_log_handler(struct nlmsghdr *msg, struct zbuf *zb)
static void netlink_mcast_log_recv(struct event *t) static void netlink_mcast_log_recv(struct event *t)
{ {
uint8_t buf[65535]; /* Max OSPF Packet size */ uint8_t buf[65535]; /* Max OSPF Packet size */
int fd = THREAD_FD(t); int fd = EVENT_FD(t);
struct zbuf payload, zb; struct zbuf payload, zb;
struct nlmsghdr *n; struct nlmsghdr *n;
@ -190,7 +190,7 @@ static void netlink_mcast_log_register(int fd, int group)
void netlink_mcast_set_nflog_group(int nlgroup) void netlink_mcast_set_nflog_group(int nlgroup)
{ {
if (netlink_mcast_log_fd >= 0) { if (netlink_mcast_log_fd >= 0) {
THREAD_OFF(netlink_mcast_log_thread); EVENT_OFF(netlink_mcast_log_thread);
close(netlink_mcast_log_fd); close(netlink_mcast_log_fd);
netlink_mcast_log_fd = -1; netlink_mcast_log_fd = -1;
debugf(NHRP_DEBUG_COMMON, "De-register nflog group"); debugf(NHRP_DEBUG_COMMON, "De-register nflog group");

14
nhrpd/nhrp_nhs.c
View File

@ -88,7 +88,7 @@ static void nhrp_reg_reply(struct nhrp_reqid *reqid, void *arg)
/* Success - schedule next registration, and route NHS */ /* Success - schedule next registration, and route NHS */
r->timeout = 2; r->timeout = 2;
holdtime = nifp->afi[nhs->afi].holdtime; holdtime = nifp->afi[nhs->afi].holdtime;
THREAD_OFF(r->t_register); EVENT_OFF(r->t_register);
/* RFC 2332 5.2.3 - Registration is recommend to be renewed /* RFC 2332 5.2.3 - Registration is recommend to be renewed
* every one third of holdtime */ * every one third of holdtime */
@ -105,7 +105,7 @@ static void nhrp_reg_reply(struct nhrp_reqid *reqid, void *arg)
static void nhrp_reg_timeout(struct event *t) static void nhrp_reg_timeout(struct event *t)
{ {
struct nhrp_registration *r = THREAD_ARG(t); struct nhrp_registration *r = EVENT_ARG(t);
struct nhrp_cache *c; struct nhrp_cache *c;
@ -148,7 +148,7 @@ static void nhrp_reg_peer_notify(struct notifier_block *n, unsigned long cmd)
case NOTIFY_PEER_MTU_CHANGED: case NOTIFY_PEER_MTU_CHANGED:
debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %pSU", debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %pSU",
&r->peer->vc->remote.nbma); &r->peer->vc->remote.nbma);
THREAD_OFF(r->t_register); EVENT_OFF(r->t_register);
event_add_timer_msec(master, nhrp_reg_send_req, r, 10, event_add_timer_msec(master, nhrp_reg_send_req, r, 10,
&r->t_register); &r->t_register);
break; break;
@ -157,7 +157,7 @@ static void nhrp_reg_peer_notify(struct notifier_block *n, unsigned long cmd)
static void nhrp_reg_send_req(struct event *t) static void nhrp_reg_send_req(struct event *t)
{ {
struct nhrp_registration *r = THREAD_ARG(t); struct nhrp_registration *r = EVENT_ARG(t);
struct nhrp_nhs *nhs = r->nhs; struct nhrp_nhs *nhs = r->nhs;
struct interface *ifp = nhs->ifp; struct interface *ifp = nhs->ifp;
struct nhrp_interface *nifp = ifp->info; struct nhrp_interface *nifp = ifp->info;
@ -244,7 +244,7 @@ static void nhrp_reg_delete(struct nhrp_registration *r)
nhrp_peer_notify_del(r->peer, &r->peer_notifier); nhrp_peer_notify_del(r->peer, &r->peer_notifier);
nhrp_peer_unref(r->peer); nhrp_peer_unref(r->peer);
nhrp_reglist_del(&r->nhs->reglist_head, r); nhrp_reglist_del(&r->nhs->reglist_head, r);
THREAD_OFF(r->t_register); EVENT_OFF(r->t_register);
XFREE(MTYPE_NHRP_REGISTRATION, r); XFREE(MTYPE_NHRP_REGISTRATION, r);
} }
@ -311,7 +311,7 @@ static void nhrp_nhs_resolve_cb(struct resolver_query *q, const char *errstr,
static void nhrp_nhs_resolve(struct event *t) static void nhrp_nhs_resolve(struct event *t)
{ {
struct nhrp_nhs *nhs = THREAD_ARG(t); struct nhrp_nhs *nhs = EVENT_ARG(t);
resolver_resolve(&nhs->dns_resolve, AF_INET, VRF_DEFAULT, resolver_resolve(&nhs->dns_resolve, AF_INET, VRF_DEFAULT,
nhs->nbma_fqdn, nhrp_nhs_resolve_cb); nhs->nbma_fqdn, nhrp_nhs_resolve_cb);
@ -383,7 +383,7 @@ int nhrp_nhs_free(struct nhrp_interface *nifp, afi_t afi, struct nhrp_nhs *nhs)
frr_each_safe (nhrp_reglist, &nhs->reglist_head, r) frr_each_safe (nhrp_reglist, &nhs->reglist_head, r)
nhrp_reg_delete(r); nhrp_reg_delete(r);
THREAD_OFF(nhs->t_resolve); EVENT_OFF(nhs->t_resolve);
nhrp_nhslist_del(&nifp->afi[afi].nhslist_head, nhs); nhrp_nhslist_del(&nifp->afi[afi].nhslist_head, nhs);
free((void *)nhs->nbma_fqdn); free((void *)nhs->nbma_fqdn);
XFREE(MTYPE_NHRP_NHS, nhs); XFREE(MTYPE_NHRP_NHS, nhs);

2
nhrpd/nhrp_packet.c
View File

@ -288,7 +288,7 @@ err:
static void nhrp_packet_recvraw(struct event *t) static void nhrp_packet_recvraw(struct event *t)
{ {
int fd = THREAD_FD(t), ifindex; int fd = EVENT_FD(t), ifindex;
struct zbuf *zb; struct zbuf *zb;
struct interface *ifp; struct interface *ifp;
struct nhrp_peer *p; struct nhrp_peer *p;

14
nhrpd/nhrp_peer.c
View File

@ -43,8 +43,8 @@ static void nhrp_peer_check_delete(struct nhrp_peer *p)
debugf(NHRP_DEBUG_COMMON, "Deleting peer ref:%d remote:%pSU local:%pSU", debugf(NHRP_DEBUG_COMMON, "Deleting peer ref:%d remote:%pSU local:%pSU",
p->ref, &p->vc->remote.nbma, &p->vc->local.nbma); p->ref, &p->vc->remote.nbma, &p->vc->local.nbma);
THREAD_OFF(p->t_fallback); EVENT_OFF(p->t_fallback);
THREAD_OFF(p->t_timer); EVENT_OFF(p->t_timer);
hash_release(nifp->peer_hash, p); hash_release(nifp->peer_hash, p);
nhrp_interface_notify_del(p->ifp, &p->ifp_notifier); nhrp_interface_notify_del(p->ifp, &p->ifp_notifier);
nhrp_vc_notify_del(p->vc, &p->vc_notifier); nhrp_vc_notify_del(p->vc, &p->vc_notifier);
@ -53,7 +53,7 @@ static void nhrp_peer_check_delete(struct nhrp_peer *p)
static void nhrp_peer_notify_up(struct event *t) static void nhrp_peer_notify_up(struct event *t)
{ {
struct nhrp_peer *p = THREAD_ARG(t); struct nhrp_peer *p = EVENT_ARG(t);
struct nhrp_vc *vc = p->vc; struct nhrp_vc *vc = p->vc;
struct interface *ifp = p->ifp; struct interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info; struct nhrp_interface *nifp = ifp->info;
@ -76,7 +76,7 @@ static void __nhrp_peer_check(struct nhrp_peer *p)
online = nifp->enabled && (!nifp->ipsec_profile || vc->ipsec); online = nifp->enabled && (!nifp->ipsec_profile || vc->ipsec);
if (p->online != online) { if (p->online != online) {
THREAD_OFF(p->t_fallback); EVENT_OFF(p->t_fallback);
if (online && notifier_active(&p->notifier_list)) { if (online && notifier_active(&p->notifier_list)) {
/* If we requested the IPsec connection, delay /* If we requested the IPsec connection, delay
* the up notification a bit to allow things * the up notification a bit to allow things
@ -250,7 +250,7 @@ void nhrp_peer_unref(struct nhrp_peer *p)
static void nhrp_peer_request_timeout(struct event *t) static void nhrp_peer_request_timeout(struct event *t)
{ {
struct nhrp_peer *p = THREAD_ARG(t); struct nhrp_peer *p = EVENT_ARG(t);
struct nhrp_vc *vc = p->vc; struct nhrp_vc *vc = p->vc;
struct interface *ifp = p->ifp; struct interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info; struct nhrp_interface *nifp = ifp->info;
@ -273,12 +273,12 @@ static void nhrp_peer_request_timeout(struct event *t)
static void nhrp_peer_defer_vici_request(struct event *t) static void nhrp_peer_defer_vici_request(struct event *t)
{ {
struct nhrp_peer *p = THREAD_ARG(t); struct nhrp_peer *p = EVENT_ARG(t);
struct nhrp_vc *vc = p->vc; struct nhrp_vc *vc = p->vc;
struct interface *ifp = p->ifp; struct interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info; struct nhrp_interface *nifp = ifp->info;
THREAD_OFF(p->t_timer); EVENT_OFF(p->t_timer);
if (p->online) { if (p->online) {
debugf(NHRP_DEBUG_COMMON, debugf(NHRP_DEBUG_COMMON,

14
nhrpd/nhrp_shortcut.c
View File

@ -33,7 +33,7 @@ static void nhrp_shortcut_check_use(struct nhrp_shortcut *s)
static void nhrp_shortcut_do_expire(struct event *t) static void nhrp_shortcut_do_expire(struct event *t)
{ {
struct nhrp_shortcut *s = THREAD_ARG(t); struct nhrp_shortcut *s = EVENT_ARG(t);
event_add_timer(master, nhrp_shortcut_do_purge, s, s->holding_time / 3, event_add_timer(master, nhrp_shortcut_do_purge, s, s->holding_time / 3,
&s->t_timer); &s->t_timer);
@ -123,7 +123,7 @@ static void nhrp_shortcut_update_binding(struct nhrp_shortcut *s,
s->route_installed = 0; s->route_installed = 0;
} }
THREAD_OFF(s->t_timer); EVENT_OFF(s->t_timer);
if (holding_time) { if (holding_time) {
s->expiring = 0; s->expiring = 0;
s->holding_time = holding_time; s->holding_time = holding_time;
@ -137,7 +137,7 @@ static void nhrp_shortcut_delete(struct nhrp_shortcut *s)
struct route_node *rn; struct route_node *rn;
afi_t afi = family2afi(PREFIX_FAMILY(s->p)); afi_t afi = family2afi(PREFIX_FAMILY(s->p));
THREAD_OFF(s->t_timer); EVENT_OFF(s->t_timer);
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid); nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
debugf(NHRP_DEBUG_ROUTE, "Shortcut %pFX purged", s->p); debugf(NHRP_DEBUG_ROUTE, "Shortcut %pFX purged", s->p);
@ -156,7 +156,7 @@ static void nhrp_shortcut_delete(struct nhrp_shortcut *s)
static void nhrp_shortcut_do_purge(struct event *t) static void nhrp_shortcut_do_purge(struct event *t)
{ {
struct nhrp_shortcut *s = THREAD_ARG(t); struct nhrp_shortcut *s = EVENT_ARG(t);
s->t_timer = NULL; s->t_timer = NULL;
nhrp_shortcut_delete(s); nhrp_shortcut_delete(s);
} }
@ -204,7 +204,7 @@ static void nhrp_shortcut_recv_resolution_rep(struct nhrp_reqid *reqid,
int holding_time = pp->if_ad->holdtime; int holding_time = pp->if_ad->holdtime;
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid); nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
THREAD_OFF(s->t_timer); EVENT_OFF(s->t_timer);
event_add_timer(master, nhrp_shortcut_do_purge, s, 1, &s->t_timer); event_add_timer(master, nhrp_shortcut_do_purge, s, 1, &s->t_timer);
if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) { if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) {
@ -454,7 +454,7 @@ void nhrp_shortcut_initiate(union sockunion *addr)
s = nhrp_shortcut_get(&p); s = nhrp_shortcut_get(&p);
if (s && s->type != NHRP_CACHE_INCOMPLETE) { if (s && s->type != NHRP_CACHE_INCOMPLETE) {
s->addr = *addr; s->addr = *addr;
THREAD_OFF(s->t_timer); EVENT_OFF(s->t_timer);
event_add_timer(master, nhrp_shortcut_do_purge, s, 30, event_add_timer(master, nhrp_shortcut_do_purge, s, 30,
&s->t_timer); &s->t_timer);
nhrp_shortcut_send_resolution_req(s); nhrp_shortcut_send_resolution_req(s);
@ -499,7 +499,7 @@ struct purge_ctx {
void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force) void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force)
{ {
THREAD_OFF(s->t_timer); EVENT_OFF(s->t_timer);
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid); nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
if (force) { if (force) {

10
nhrpd/vici.c
View File

@ -70,8 +70,8 @@ static void vici_connection_error(struct vici_conn *vici)
{ {
nhrp_vc_reset(); nhrp_vc_reset();
THREAD_OFF(vici->t_read); EVENT_OFF(vici->t_read);
THREAD_OFF(vici->t_write); EVENT_OFF(vici->t_write);
zbuf_reset(&vici->ibuf); zbuf_reset(&vici->ibuf);
zbufq_reset(&vici->obuf); zbufq_reset(&vici->obuf);
@ -359,7 +359,7 @@ static void vici_recv_message(struct vici_conn *vici, struct zbuf *msg)
static void vici_read(struct event *t) static void vici_read(struct event *t)
{ {
struct vici_conn *vici = THREAD_ARG(t); struct vici_conn *vici = EVENT_ARG(t);
struct zbuf *ibuf = &vici->ibuf; struct zbuf *ibuf = &vici->ibuf;
struct zbuf pktbuf; struct zbuf pktbuf;
@ -389,7 +389,7 @@ static void vici_read(struct event *t)
static void vici_write(struct event *t) static void vici_write(struct event *t)
{ {
struct vici_conn *vici = THREAD_ARG(t); struct vici_conn *vici = EVENT_ARG(t);
int r; int r;
r = zbufq_write(&vici->obuf, vici->fd); r = zbufq_write(&vici->obuf, vici->fd);
@ -502,7 +502,7 @@ static char *vici_get_charon_filepath(void)
static void vici_reconnect(struct event *t) static void vici_reconnect(struct event *t)
{ {
struct vici_conn *vici = THREAD_ARG(t); struct vici_conn *vici = EVENT_ARG(t);
int fd; int fd;
char *file_path; char *file_path;

4
ospf6d/ospf6_area.c
View File

@ -421,8 +421,8 @@ void ospf6_area_disable(struct ospf6_area *oa)
ospf6_spf_table_finish(oa->spf_table); ospf6_spf_table_finish(oa->spf_table);
ospf6_route_remove_all(oa->route_table); ospf6_route_remove_all(oa->route_table);
THREAD_OFF(oa->thread_router_lsa); EVENT_OFF(oa->thread_router_lsa);
THREAD_OFF(oa->thread_intra_prefix_lsa); EVENT_OFF(oa->thread_intra_prefix_lsa);
} }

12
ospf6d/ospf6_asbr.c
View File

@ -186,7 +186,7 @@ void ospf6_orig_as_external_lsa(struct event *thread)
struct ospf6_lsa *lsa; struct ospf6_lsa *lsa;
uint32_t type, adv_router; uint32_t type, adv_router;
oi = (struct ospf6_interface *)THREAD_ARG(thread); oi = (struct ospf6_interface *)EVENT_ARG(thread);
if (oi->state == OSPF6_INTERFACE_DOWN) if (oi->state == OSPF6_INTERFACE_DOWN)
return; return;
@ -1067,7 +1067,7 @@ static void ospf6_asbr_routemap_unset(struct ospf6_redist *red)
static void ospf6_asbr_routemap_update_timer(struct event *thread) static void ospf6_asbr_routemap_update_timer(struct event *thread)
{ {
struct ospf6 *ospf6 = THREAD_ARG(thread); struct ospf6 *ospf6 = EVENT_ARG(thread);
struct ospf6_redist *red; struct ospf6_redist *red;
int type; int type;
@ -3022,7 +3022,7 @@ static void ospf6_aggr_handle_external_info(void *data)
if (IS_OSPF6_DEBUG_AGGR) if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s: LSA found, refresh it", zlog_debug("%s: LSA found, refresh it",
__func__); __func__);
THREAD_OFF(lsa->refresh); EVENT_OFF(lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0, event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh); &lsa->refresh);
return; return;
@ -3225,7 +3225,7 @@ static void ospf6_handle_exnl_rt_after_aggr_del(struct ospf6 *ospf6,
lsa = ospf6_find_external_lsa(ospf6, &rt->prefix); lsa = ospf6_find_external_lsa(ospf6, &rt->prefix);
if (lsa) { if (lsa) {
THREAD_OFF(lsa->refresh); EVENT_OFF(lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0, event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh); &lsa->refresh);
} else { } else {
@ -3333,7 +3333,7 @@ ospf6_handle_external_aggr_add(struct ospf6 *ospf6)
static void ospf6_asbr_summary_process(struct event *thread) static void ospf6_asbr_summary_process(struct event *thread)
{ {
struct ospf6 *ospf6 = THREAD_ARG(thread); struct ospf6 *ospf6 = EVENT_ARG(thread);
int operation = 0; int operation = 0;
operation = ospf6->aggr_action; operation = ospf6->aggr_action;
@ -3376,7 +3376,7 @@ ospf6_start_asbr_summary_delay_timer(struct ospf6 *ospf6,
if (IS_OSPF6_DEBUG_AGGR) if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s, Restarting Aggregator delay timer.", zlog_debug("%s, Restarting Aggregator delay timer.",
__func__); __func__);
THREAD_OFF(ospf6->t_external_aggr); EVENT_OFF(ospf6->t_external_aggr);
} }
} }

2
ospf6d/ospf6_bfd.c
View File

@ -105,7 +105,7 @@ static void ospf6_bfd_callback(struct bfd_session_params *bsp,
if (bss->state == BFD_STATUS_DOWN if (bss->state == BFD_STATUS_DOWN
&& bss->previous_state == BFD_STATUS_UP) { && bss->previous_state == BFD_STATUS_UP) {
THREAD_OFF(on->inactivity_timer); EVENT_OFF(on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL); event_add_event(master, inactivity_timer, on, 0, NULL);
} }
} }

12
ospf6d/ospf6_flood.c
View File

@ -103,7 +103,7 @@ void ospf6_lsa_originate(struct ospf6 *ospf6, struct ospf6_lsa *lsa)
lsdb_self = ospf6_get_scoped_lsdb_self(lsa); lsdb_self = ospf6_get_scoped_lsdb_self(lsa);
ospf6_lsdb_add(ospf6_lsa_copy(lsa), lsdb_self); ospf6_lsdb_add(ospf6_lsa_copy(lsa), lsdb_self);
THREAD_OFF(lsa->refresh); EVENT_OFF(lsa->refresh);
event_add_timer(master, ospf6_lsa_refresh, lsa, OSPF_LS_REFRESH_TIME, event_add_timer(master, ospf6_lsa_refresh, lsa, OSPF_LS_REFRESH_TIME,
&lsa->refresh); &lsa->refresh);
@ -168,8 +168,8 @@ void ospf6_lsa_purge(struct ospf6_lsa *lsa)
self = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id, self = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
lsa->header->adv_router, lsdb_self); lsa->header->adv_router, lsdb_self);
if (self) { if (self) {
THREAD_OFF(self->expire); EVENT_OFF(self->expire);
THREAD_OFF(self->refresh); EVENT_OFF(self->refresh);
ospf6_lsdb_remove(self, lsdb_self); ospf6_lsdb_remove(self, lsdb_self);
} }
@ -250,8 +250,8 @@ void ospf6_install_lsa(struct ospf6_lsa *lsa)
lsa->name); lsa->name);
lsa->external_lsa_id = old->external_lsa_id; lsa->external_lsa_id = old->external_lsa_id;
} }
THREAD_OFF(old->expire); EVENT_OFF(old->expire);
THREAD_OFF(old->refresh); EVENT_OFF(old->refresh);
ospf6_flood_clear(old); ospf6_flood_clear(old);
} }
@ -525,7 +525,7 @@ void ospf6_flood_interface(struct ospf6_neighbor *from, struct ospf6_lsa *lsa,
} else { } else {
/* reschedule retransmissions to all neighbors */ /* reschedule retransmissions to all neighbors */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) { for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
THREAD_OFF(on->thread_send_lsupdate); EVENT_OFF(on->thread_send_lsupdate);
event_add_event(master, ospf6_lsupdate_send_neighbor, event_add_event(master, ospf6_lsupdate_send_neighbor,
on, 0, &on->thread_send_lsupdate); on, 0, &on->thread_send_lsupdate);
} }

4
ospf6d/ospf6_gr.c
View File

@ -134,7 +134,7 @@ static void ospf6_gr_restart_exit(struct ospf6 *ospf6, const char *reason)
ospf6->gr_info.restart_in_progress = false; ospf6->gr_info.restart_in_progress = false;
ospf6->gr_info.finishing_restart = true; ospf6->gr_info.finishing_restart = true;
THREAD_OFF(ospf6->gr_info.t_grace_period); EVENT_OFF(ospf6->gr_info.t_grace_period);
/* Record in non-volatile memory that the restart is complete. */ /* Record in non-volatile memory that the restart is complete. */
ospf6_gr_nvm_delete(ospf6); ospf6_gr_nvm_delete(ospf6);
@ -461,7 +461,7 @@ static bool ospf6_gr_check_adjs(struct ospf6 *ospf6)
/* Handling of grace period expiry. */ /* Handling of grace period expiry. */
static void ospf6_gr_grace_period_expired(struct event *thread) static void ospf6_gr_grace_period_expired(struct event *thread)
{ {
struct ospf6 *ospf6 = THREAD_ARG(thread); struct ospf6 *ospf6 = EVENT_ARG(thread);
ospf6_gr_restart_exit(ospf6, "grace period has expired"); ospf6_gr_restart_exit(ospf6, "grace period has expired");
} }

Some files were not shown because too many files have changed in this diff Show More