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);
}
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)
ptm_bfd_echo_xmt_TO(bs);
/* Was ptm_bfd_detect_TO() */
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) {
case PTM_BFD_INIT:
/* Was ptm_bfd_echo_detect_TO() */
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) {
case PTM_BFD_INIT:
zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
/* Disable read/write poll triggering. */
- THREAD_OFF(bvrf->bg_ev[0]);
- THREAD_OFF(bvrf->bg_ev[1]);
- THREAD_OFF(bvrf->bg_ev[2]);
- THREAD_OFF(bvrf->bg_ev[3]);
- THREAD_OFF(bvrf->bg_ev[4]);
- THREAD_OFF(bvrf->bg_ev[5]);
+ EVENT_OFF(bvrf->bg_ev[0]);
+ EVENT_OFF(bvrf->bg_ev[1]);
+ EVENT_OFF(bvrf->bg_ev[2]);
+ EVENT_OFF(bvrf->bg_ev[3]);
+ EVENT_OFF(bvrf->bg_ev[4]);
+ EVENT_OFF(bvrf->bg_ev[5]);
/* Close all descriptors. */
socket_close(&bvrf->bg_echo);
static void bfd_sd_reschedule(struct bfd_vrf_global *bvrf, int sd)
{
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,
&bvrf->bg_ev[0]);
} 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,
&bvrf->bg_ev[1]);
} 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,
&bvrf->bg_ev[2]);
} 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,
&bvrf->bg_ev[3]);
} 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,
&bvrf->bg_ev[4]);
} 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,
&bvrf->bg_ev[5]);
}
void bfd_recv_cb(struct event *t)
{
- int sd = THREAD_FD(t);
+ int sd = EVENT_FD(t);
struct bfd_session *bfd;
struct bfd_pkt *cp;
bool is_mhop;
struct sockaddr_any local, peer;
uint8_t msgbuf[1516];
struct interface *ifp = NULL;
- struct bfd_vrf_global *bvrf = THREAD_ARG(t);
+ struct bfd_vrf_global *bvrf = EVENT_ARG(t);
/* Schedule next read. */
bfd_sd_reschedule(bvrf, sd);
void control_accept(struct event *t)
{
- int csock, sd = THREAD_FD(t);
+ int csock, sd = EVENT_FD(t);
csock = accept(sd, NULL, 0);
if (csock == -1) {
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;
int sd = bcs->bcs_sd;
struct bfd_control_msg bcm;
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;
int sd = bcs->bcs_sd;
ssize_t bwrite;
stream_pulldown(bdc->outbuf);
/* Disable write ready events. */
- THREAD_OFF(bdc->outbufev);
+ EVENT_OFF(bdc->outbufev);
return total;
}
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. */
if (bdc->connecting && bfd_dplane_client_connecting(bdc))
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;
rv = bfd_dplane_expect(bdc, 0, bfd_dplane_handle_message, NULL);
/* Client mode has special treatment. */
if (bdc->client) {
/* Disable connection event if any. */
- THREAD_OFF(bdc->connectev);
+ EVENT_OFF(bdc->connectev);
/* Normal treatment on shutdown. */
if (bglobal.bg_shutdown)
/* Attempt reconnection. */
socket_close(&bdc->sock);
- THREAD_OFF(bdc->inbufev);
- THREAD_OFF(bdc->outbufev);
+ EVENT_OFF(bdc->inbufev);
+ EVENT_OFF(bdc->outbufev);
event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
&bdc->connectev);
return;
socket_close(&bdc->sock);
stream_free(bdc->inbuf);
stream_free(bdc->outbuf);
- THREAD_OFF(bdc->inbufev);
- THREAD_OFF(bdc->outbufev);
+ EVENT_OFF(bdc->inbufev);
+ EVENT_OFF(bdc->outbufev);
XFREE(MTYPE_BFDD_DPLANE_CTX, bdc);
}
*/
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;
int sock;
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;
socklen_t rvlen = sizeof(rv);
}
reschedule_connect:
- THREAD_OFF(bdc->inbufev);
- THREAD_OFF(bdc->outbufev);
+ EVENT_OFF(bdc->inbufev);
+ EVENT_OFF(bdc->outbufev);
socket_close(&sock);
event_add_timer(master, bfd_dplane_client_connect, bdc, 3,
&bdc->connectev);
bfd_dplane_ctx_free(bdc);
/* Cancel accept thread and close socket. */
- THREAD_OFF(bglobal.bg_dplane_sockev);
+ EVENT_OFF(bglobal.bg_dplane_sockev);
close(bglobal.bg_dplane_sock);
return 0;
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)
{
- THREAD_OFF(bs->echo_recvtimer_ev);
+ EVENT_OFF(bs->echo_recvtimer_ev);
}
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)
{
- THREAD_OFF(bs->echo_xmttimer_ev);
+ EVENT_OFF(bs->echo_xmttimer_ev);
}
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 peer *peer;
struct listnode *node;
/* read from the BMP socket to detect session termination */
static void bmp_read(struct event *t)
{
- struct bmp *bmp = THREAD_ARG(t);
+ struct bmp *bmp = EVENT_ARG(t);
char buf[1024];
ssize_t n;
static void bmp_accept(struct event *thread)
{
union sockunion su;
- struct bmp_listener *bl = THREAD_ARG(thread);
+ struct bmp_listener *bl = EVENT_ARG(thread);
int bmp_sock;
/* We continue hearing BMP socket. */
struct bmp_queue_entry *bqe;
struct bmp_mirrorq *bmq;
- THREAD_OFF(bmp->t_read);
+ EVENT_OFF(bmp->t_read);
if (bmp->active)
bmp_active_disconnected(bmp->active);
if (!bqe->refcount)
XFREE(MTYPE_BMP_QUEUE, bqe);
- THREAD_OFF(bmp->t_read);
+ EVENT_OFF(bmp->t_read);
pullwr_del(bmp->pullwr);
close(bmp->socket);
}
struct bmp *bmp;
struct bmp_active *ba;
- THREAD_OFF(bt->t_stats);
+ EVENT_OFF(bt->t_stats);
frr_each_safe (bmp_actives, &bt->actives, ba)
bmp_active_put(ba);
static void bmp_listener_stop(struct bmp_listener *bl)
{
- THREAD_OFF(bl->t_accept);
+ EVENT_OFF(bl->t_accept);
if (bl->sock != -1)
close(bl->sock);
static void bmp_active_put(struct bmp_active *ba)
{
- THREAD_OFF(ba->t_timer);
- THREAD_OFF(ba->t_read);
- THREAD_OFF(ba->t_write);
+ EVENT_OFF(ba->t_timer);
+ EVENT_OFF(ba->t_read);
+ EVENT_OFF(ba->t_write);
bmp_actives_del(&ba->targets->actives, ba);
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;
int status, ret;
vrf_id_t vrf_id;
/* all 3 end up here, though only timer or read+write are active
* at a time */
- THREAD_OFF(ba->t_timer);
- THREAD_OFF(ba->t_read);
- THREAD_OFF(ba->t_write);
+ EVENT_OFF(ba->t_timer);
+ EVENT_OFF(ba->t_read);
+ EVENT_OFF(ba->t_write);
ba->last_err = NULL;
static void bmp_active_setup(struct bmp_active *ba)
{
- THREAD_OFF(ba->t_timer);
- THREAD_OFF(ba->t_read);
- THREAD_OFF(ba->t_write);
+ EVENT_OFF(ba->t_timer);
+ EVENT_OFF(ba->t_read);
+ EVENT_OFF(ba->t_write);
if (ba->bmp)
return;
{
VTY_DECLVAR_CONTEXT_SUB(bmp_targets, bt);
- THREAD_OFF(bt->t_stats);
+ EVENT_OFF(bt->t_stats);
if (no)
bt->stat_msec = 0;
else if (interval_str)
route_map_result_t ret;
bool advmap_table_changed = false;
- bgp = THREAD_ARG(t);
+ bgp = EVENT_ARG(t);
assert(bgp);
event_add_timer(bm->master, bgp_conditional_adv_timer, bgp,
}
/* 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,
struct bgp_damp_info *next;
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;
event_add_timer(bm->master, bgp_reuse_timer, bdc, DELTA_REUSE,
return 0;
/* Cancel reuse event. */
- THREAD_OFF(bdc->t_reuse);
+ EVENT_OFF(bdc->t_reuse);
/* Clean BGP dampening information. */
bgp_damp_info_clean(afi, safi);
static void bgp_dump_interval_func(struct event *t)
{
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... */
if (bgp_dump_open_file(bgp_dump) != NULL) {
}
/* Removing interval event. */
- THREAD_OFF(bgp_dump->t_interval);
+ EVENT_OFF(bgp_dump->t_interval);
bgp_dump->interval = 0;
bgp_evpn_es_local_info_clear(es, true);
}
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->pend_es_list);
list_delete(&bgp_mh_info->ead_es_export_rtl);
*/
bgp_keepalives_off(from_peer);
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_connect);
- THREAD_OFF(peer->t_delayopen);
- THREAD_OFF(peer->t_connect_check_r);
- THREAD_OFF(peer->t_connect_check_w);
- THREAD_OFF(from_peer->t_routeadv);
- THREAD_OFF(from_peer->t_connect);
- THREAD_OFF(from_peer->t_delayopen);
- THREAD_OFF(from_peer->t_connect_check_r);
- THREAD_OFF(from_peer->t_connect_check_w);
- THREAD_OFF(from_peer->t_process_packet);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_connect_check_r);
+ EVENT_OFF(peer->t_connect_check_w);
+ EVENT_OFF(from_peer->t_routeadv);
+ EVENT_OFF(from_peer->t_connect);
+ EVENT_OFF(from_peer->t_delayopen);
+ EVENT_OFF(from_peer->t_connect_check_r);
+ EVENT_OFF(from_peer->t_connect_check_w);
+ EVENT_OFF(from_peer->t_process_packet);
/*
* At this point in time, it is possible that there are packets pending
inactive. All other timer must be turned off */
if (BGP_PEER_START_SUPPRESSED(peer) || !peer_active(peer)
|| peer->bgp->vrf_id == VRF_UNKNOWN) {
- THREAD_OFF(peer->t_start);
+ EVENT_OFF(peer->t_start);
} else {
BGP_TIMER_ON(peer->t_start, bgp_start_timer,
peer->v_start);
}
- THREAD_OFF(peer->t_connect);
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer);
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_delayopen);
break;
case Connect:
/* After start timer is expired, the peer moves to Connect
status. Make sure start timer is off and connect timer is
on. */
- THREAD_OFF(peer->t_start);
+ EVENT_OFF(peer->t_start);
if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN))
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
(peer->v_delayopen + peer->v_connect));
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
peer->v_connect);
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer);
- THREAD_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_routeadv);
break;
case Active:
/* Active is waiting connection from remote peer. And if
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 (CHECK_FLAG(peer->flags, PEER_FLAG_PASSIVE)
|| CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)) {
- THREAD_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_connect);
} else {
if (CHECK_FLAG(peer->flags, PEER_FLAG_TIMER_DELAYOPEN))
BGP_TIMER_ON(
BGP_TIMER_ON(peer->t_connect, bgp_connect_timer,
peer->v_connect);
}
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer);
- THREAD_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_routeadv);
break;
case OpenSent:
/* OpenSent status. */
- THREAD_OFF(peer->t_start);
- THREAD_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_start);
+ EVENT_OFF(peer->t_connect);
if (peer->v_holdtime != 0) {
BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
peer->v_holdtime);
} else {
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_holdtime);
}
bgp_keepalives_off(peer);
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_delayopen);
break;
case OpenConfirm:
/* OpenConfirm status. */
- THREAD_OFF(peer->t_start);
- THREAD_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_start);
+ EVENT_OFF(peer->t_connect);
/*
* If the negotiated Hold Time value is zero, then the Hold Time
* Additionally if a different hold timer has been negotiated
* than we must stop then start the timer again
*/
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_holdtime);
if (peer->v_holdtime == 0)
bgp_keepalives_off(peer);
else {
peer->v_holdtime);
bgp_keepalives_on(peer);
}
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_delayopen);
break;
case Established:
/* In Established status start and connect timer is turned
off. */
- THREAD_OFF(peer->t_start);
- THREAD_OFF(peer->t_connect);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_start);
+ EVENT_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_delayopen);
/*
* Same as OpenConfirm, if holdtime is zero then both holdtime
* Additionally if a different hold timer has been negotiated
* then we must stop then start the timer again
*/
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_holdtime);
if (peer->v_holdtime == 0)
bgp_keepalives_off(peer);
else {
}
break;
case Deleted:
- THREAD_OFF(peer->t_gr_restart);
- THREAD_OFF(peer->t_gr_stale);
+ EVENT_OFF(peer->t_gr_restart);
+ EVENT_OFF(peer->t_gr_stale);
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);
- THREAD_OFF(peer->t_refresh_stalepath);
+ EVENT_OFF(peer->t_pmax_restart);
+ EVENT_OFF(peer->t_refresh_stalepath);
/* fallthru */
case Clearing:
- THREAD_OFF(peer->t_start);
- THREAD_OFF(peer->t_connect);
- THREAD_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_start);
+ EVENT_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_holdtime);
bgp_keepalives_off(peer);
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_delayopen);
break;
case BGP_STATUS_MAX:
flog_err(EC_LIB_DEVELOPMENT,
{
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer))
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 */
}
{
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
/* stop the DelayOpenTimer if it is running */
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_delayopen);
assert(!peer->t_write);
assert(!peer->t_read);
if (CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER))
bgp_stop(peer);
else {
- THREAD_VAL(thread) = ConnectRetry_timer_expired;
+ EVENT_VAL(thread) = ConnectRetry_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
}
}
atomic_size_t inq_count;
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (holdtime timer expire)",
BGP_TIMER_ON(peer->t_holdtime, bgp_holdtime_timer,
peer->v_holdtime);
- THREAD_VAL(thread) = Hold_Timer_expired;
+ EVENT_VAL(thread) = Hold_Timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
}
{
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (routeadv timer expire)",
{
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [FSM] Timer (DelayOpentimer expire)",
peer->host);
- THREAD_VAL(thread) = DelayOpen_timer_expired;
+ EVENT_VAL(thread) = DelayOpen_timer_expired;
bgp_event(thread); /* bgp_event unlocks peer */
}
return;
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) &&
!(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
afi_t afi;
safi_t safi;
- paf = THREAD_ARG(thread);
+ paf = EVENT_ARG(thread);
peer = paf->peer;
afi = paf->afi;
afi_t afi;
safi_t safi;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer)) {
zlog_debug("%pBP graceful restart timer expired", peer);
afi_t afi;
safi_t safi;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart stalepath timer expired",
safi_t safi;
struct bgp *bgp;
- info = THREAD_ARG(thread);
+ info = EVENT_ARG(thread);
afi = info->afi;
safi = info->safi;
bgp = info->bgp;
on ending the update delay. */
void bgp_update_delay_end(struct bgp *bgp)
{
- THREAD_OFF(bgp->t_update_delay);
- THREAD_OFF(bgp->t_establish_wait);
+ EVENT_OFF(bgp->t_update_delay);
+ EVENT_OFF(bgp->t_establish_wait);
/* Reset update-delay related state */
bgp->update_delay_over = 1;
for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
if (!peer_established(peer))
continue;
- THREAD_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
}
}
* different
* duration and schedule write thread immediately.
*/
- THREAD_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_routeadv);
peer->synctime = monotime(NULL);
/* If suppress fib pending is enabled, route is advertised to
*/
diff = difftime(nowtime, peer->last_update);
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);
return;
}
remain = peer->v_routeadv;
diff = peer->v_routeadv - diff;
if (diff <= (double)remain) {
- THREAD_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_routeadv);
BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, diff);
}
}
zlog_info("Max med on startup ended - timer expired.");
- bgp = THREAD_ARG(thread);
- THREAD_OFF(bgp->t_maxmed_onstartup);
+ bgp = EVENT_ARG(thread);
+ EVENT_OFF(bgp->t_maxmed_onstartup);
bgp->maxmed_onstartup_over = 1;
bgp_maxmed_update(bgp);
zlog_info("Update delay ended - timer expired.");
- bgp = THREAD_ARG(thread);
- THREAD_OFF(bgp->t_update_delay);
+ bgp = EVENT_ARG(thread);
+ EVENT_OFF(bgp->t_update_delay);
bgp_update_delay_end(bgp);
}
zlog_info("Establish wait - timer expired.");
- bgp = THREAD_ARG(thread);
- THREAD_OFF(bgp->t_establish_wait);
+ bgp = EVENT_ARG(thread);
+ EVENT_OFF(bgp->t_establish_wait);
bgp_check_update_delay(bgp);
}
/* graceful restart */
if (peer->t_gr_stale) {
- THREAD_OFF(peer->t_gr_stale);
+ EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
"%pBP graceful restart stalepath timer stopped",
/* Stop route-refresh stalepath timer */
if (peer->t_refresh_stalepath) {
- THREAD_OFF(peer->t_refresh_stalepath);
+ EVENT_OFF(peer->t_refresh_stalepath);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
/* There is no pending EOR message */
if (gr_info->eor_required == 0) {
if (gr_info->t_select_deferral) {
- void *info = THREAD_ARG(
+ void *info = EVENT_ARG(
gr_info->t_select_deferral);
XFREE(MTYPE_TMP, info);
}
- THREAD_OFF(gr_info->t_select_deferral);
+ EVENT_OFF(gr_info->t_select_deferral);
gr_info->eor_received = 0;
}
}
bgp_writes_off(peer);
bgp_reads_off(peer);
- THREAD_OFF(peer->t_connect_check_r);
- THREAD_OFF(peer->t_connect_check_w);
+ EVENT_OFF(peer->t_connect_check_r);
+ EVENT_OFF(peer->t_connect_check_w);
/* Stop all timers. */
- THREAD_OFF(peer->t_start);
- THREAD_OFF(peer->t_connect);
- THREAD_OFF(peer->t_holdtime);
- THREAD_OFF(peer->t_routeadv);
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_start);
+ EVENT_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_holdtime);
+ EVENT_OFF(peer->t_routeadv);
+ EVENT_OFF(peer->t_delayopen);
/* Clear input and output buffer. */
frr_with_mutex (&peer->io_mtx) {
int ret;
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_WRITES_ON));
assert(!peer->t_read);
assert(!peer->t_write);
- THREAD_OFF(peer->t_connect_check_r);
- THREAD_OFF(peer->t_connect_check_w);
+ EVENT_OFF(peer->t_connect_check_r);
+ EVENT_OFF(peer->t_connect_check_w);
/* Check file descriptor. */
slen = sizeof(status);
bgp_fsm_delayopen_timer_expire(struct peer *peer)
{
/* Stop the DelayOpenTimer */
- THREAD_OFF(peer->t_delayopen);
+ EVENT_OFF(peer->t_delayopen);
/* Send open message to peer */
bgp_open_send(peer);
else {
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
if (peer->t_gr_stale) {
- THREAD_OFF(peer->t_gr_stale);
+ EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
"%pBP graceful restart stalepath timer stopped",
}
if (peer->t_gr_restart) {
- THREAD_OFF(peer->t_gr_restart);
+ EVENT_OFF(peer->t_gr_restart);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart timer stopped", peer);
}
*/
FOREACH_AFI_SAFI (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))
zlog_debug(
"%pBP Long-lived stale timer stopped for afi/safi: %d/%d",
* of read-only mode.
*/
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);
}
/* Keepalive packet is received. */
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;
}
/* Update packet is received. */
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;
}
break;
case Connect:
if (!has_valid_nexthops) {
- THREAD_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_connect);
BGP_EVENT_ADD(peer, TCP_fatal_error);
}
break;
case Active:
if (has_valid_nexthops) {
- THREAD_OFF(peer->t_connect);
+ EVENT_OFF(peer->t_connect);
BGP_EVENT_ADD(peer, ConnectRetry_timer_expired);
}
break;
enum bgp_fsm_events event;
struct peer *peer;
- peer = THREAD_ARG(thread);
- event = THREAD_VAL(thread);
+ peer = EVENT_ARG(thread);
+ event = EVENT_VAL(thread);
peer_lock(peer);
bgp_event_update(peer, event);
#include "network.h" // for ERRNO_IO_RETRY
#include "stream.h" // for stream_get_endp, stream_getw_from, str...
#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_debug.h" // for bgp_debug_neighbor_events, bgp_type_str
assert(fpt->running);
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);
}
assert(fpt->running);
event_cancel_async(fpt->master, &peer->t_read, NULL);
- THREAD_OFF(peer->t_process_packet);
- THREAD_OFF(peer->t_process_packet_error);
+ EVENT_OFF(peer->t_process_packet);
+ EVENT_OFF(peer->t_process_packet_error);
UNSET_FLAG(peer->thread_flags, PEER_THREAD_READS_ON);
}
static void bgp_process_writes(struct event *thread)
{
static struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
uint16_t status;
bool reschedule;
bool fatal = false;
int ret = 1;
/* clang-format on */
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
if (peer->fd < 0 || bm->terminating)
return;
#include "memory.h" // for MTYPE_TMP, XFREE, XCALLOC, XMALLOC
#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_packet.h" // for bgp_keepalive_send
#include "bgpd/bgp_keepalives.h"
int bgp_sock;
int accept_sock;
union sockunion su;
- struct bgp_listener *listener = THREAD_ARG(thread);
+ struct bgp_listener *listener = EVENT_ARG(thread);
struct peer *peer;
struct peer *peer1;
char buf[SU_ADDRSTRLEN];
bgp = bgp_lookup_by_name(listener->name);
/* Register accept thread. */
- accept_sock = THREAD_FD(thread);
+ accept_sock = EVENT_FD(thread);
if (accept_sock < 0) {
flog_err_sys(EC_LIB_SOCKET,
"[Error] BGP accept socket fd is negative: %d",
"[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,
VRF_LOGNAME(vrf));
- THREAD_OFF(listener->thread);
+ EVENT_OFF(listener->thread);
} else {
flog_err_sys(
EC_LIB_SOCKET,
sockopt_tcp_mss_set(bgp_sock, peer1->tcp_mss);
bgp_fsm_change_status(peer1, Active);
- THREAD_OFF(
+ EVENT_OFF(
peer1->t_start); /* created in peer_create() */
if (peer_active(peer1)) {
}
bgp_peer_reg_with_nht(peer);
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);
/* Make dummy peer until read Open packet. */
for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) {
if (listener->bgp == bgp) {
- THREAD_OFF(listener->thread);
+ EVENT_OFF(listener->thread);
close(listener->fd);
listnode_delete(bm->listen_sockets, listener);
XFREE(MTYPE_BGP_LISTENER, listener->name);
for (ALL_LIST_ELEMENTS(bm->listen_sockets, node, next, listener)) {
if (listener->bgp)
continue;
- THREAD_OFF(listener->thread);
+ EVENT_OFF(listener->thread);
close(listener->fd);
listnode_delete(bm->listen_sockets, listener);
XFREE(MTYPE_BGP_LISTENER, listener->name);
static void bgp_nht_ifp_initial(struct event *thread)
{
- ifindex_t ifindex = THREAD_VAL(thread);
- struct bgp *bgp = THREAD_ARG(thread);
+ ifindex_t ifindex = EVENT_VAL(thread);
+ struct bgp *bgp = EVENT_ARG(thread);
struct interface *ifp = if_lookup_by_index(ifindex, bgp->vrf_id);
if (!ifp)
*/
void bgp_generate_updgrp_packets(struct event *thread)
{
- struct peer *peer = THREAD_ARG(thread);
+ struct peer *peer = EVENT_ARG(thread);
struct stream *s;
struct peer_af *paf;
{
struct peer_af *paf;
- paf = THREAD_ARG(thread);
+ paf = EVENT_ARG(thread);
afi_t afi = paf->afi;
safi_t safi = paf->safi;
"EOR RCV",
gr_info->eor_received);
if (gr_info->t_select_deferral) {
- void *info = THREAD_ARG(
+ void *info = EVENT_ARG(
gr_info->t_select_deferral);
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_received = 0;
/* Best path selection */
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);
UNSET_FLAG(peer->af_sflags[afi][safi],
* would not, making event flow difficult to understand. Please think twice
* before hacking this.
*
- * Thread type: THREAD_EVENT
+ * Thread type: EVENT_EVENT
* @param thread
* @return 0
*/
int fsm_update_result; // return code of bgp_event_update()
int mprc; // message processing return code
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
rpkt_quanta_old = atomic_load_explicit(&peer->bgp->rpkt_quanta,
memory_order_relaxed);
fsm_update_result = 0;
struct peer *peer;
int code;
- peer = THREAD_ARG(thread);
- code = THREAD_VAL(thread);
+ peer = EVENT_ARG(thread);
+ code = EVENT_VAL(thread);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [Event] BGP error %d on fd %d",
safi_t safi;
struct bgp *bgp;
- info = THREAD_ARG(thread);
+ info = EVENT_ARG(thread);
afi = info->afi;
safi = info->safi;
bgp = info->bgp;
if (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);
- 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)) {
{
struct peer *peer;
- peer = THREAD_ARG(thread);
+ peer = EVENT_ARG(thread);
peer->t_pmax_restart = NULL;
if (bgp_debug_neighbor_events(peer))
if (!paf->t_announce_route)
return;
- THREAD_OFF(paf->t_announce_route);
+ EVENT_OFF(paf->t_announce_route);
}
/*
struct peer_af *paf;
struct peer *peer;
- paf = THREAD_ARG(t);
+ paf = EVENT_ARG(t);
peer = paf->peer;
if (!peer_established(peer))
struct prefix_rd *prd;
struct listnode *node, *nnode;
- table = THREAD_ARG(thread);
+ table = EVENT_ARG(thread);
prd = NULL;
max_iter = SOFT_RECONFIG_TASK_MAX_PREFIX;
list_delete(&ntable->soft_reconfig_peers);
bgp_soft_reconfig_table_flag(ntable, false);
- THREAD_OFF(ntable->soft_reconfig_thread);
+ EVENT_OFF(ntable->soft_reconfig_thread);
}
}
{
struct bgp_dest *dest, *ndest;
struct bgp_dest *top;
- struct bgp_table_stats *ts = THREAD_ARG(t);
+ struct bgp_table_stats *ts = EVENT_ARG(t);
unsigned int space = 0;
if (!(top = bgp_table_top(ts->table)))
{
struct bgp_dest *rn, *rm;
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
|| pc->safi == SAFI_EVPN) {
/* If new update is received before the current timer timed out,
* 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 */
if (bm->rmap_update_timer) {
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;
match = bgp_table_subtree_lookup(rrp->bgp->rib[rrp->afi][rrp->safi],
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
{
rtr_is_stopping = true;
if (is_running()) {
- THREAD_OFF(t_rpki_sync);
+ EVENT_OFF(t_rpki_sync);
rtr_mgr_stop(rtr_config);
rtr_mgr_free(rtr_config);
rtr_is_running = false;
if (subgrp->update_group)
UPDGRP_INCR_STAT(subgrp->update_group, subgrps_deleted);
- THREAD_OFF(subgrp->t_merge_check);
- THREAD_OFF(subgrp->t_coalesce);
+ EVENT_OFF(subgrp->t_merge_check);
+ EVENT_OFF(subgrp->t_coalesce);
bpacket_queue_cleanup(SUBGRP_PKTQ(subgrp));
subgroup_clear_table(subgrp);
{
struct update_subgroup *subgrp;
- subgrp = THREAD_ARG(thread);
+ subgrp = EVENT_ARG(thread);
subgrp->t_merge_check = NULL;
struct bgp *bgp;
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,
reason);
- THREAD_OFF(bgp->t_rmap_def_originate_eval);
+ EVENT_OFF(bgp->t_rmap_def_originate_eval);
bgp_unlock(bgp);
}
struct update_subgroup *subgrp;
struct bgp *bgp;
- subgrp = THREAD_ARG(thread);
+ subgrp = EVENT_ARG(thread);
if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
zlog_debug("u%" PRIu64 ":s%" PRIu64" announcing routes upon coalesce timer expiry(%u ms)",
(SUBGRP_UPDGRP(subgrp))->id, subgrp->id,
SUBGRP_FOREACH_PEER (subgrp, 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);
}
}
/* Cancel max-med onstartup if its on */
if (bgp->t_maxmed_onstartup) {
- THREAD_OFF(bgp->t_maxmed_onstartup);
+ EVENT_OFF(bgp->t_maxmed_onstartup);
bgp->maxmed_onstartup_over = 1;
}
* fired.
*/
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,
NULL, 0);
}
static void bgp_config_start(void)
{
#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,
BGP_PRE_CONFIG_MAX_WAIT_SECONDS, &t_bgp_cfg);
}
if (!bgp_config_inprocess())
return;
- THREAD_OFF(t_bgp_cfg);
+ EVENT_OFF(t_bgp_cfg);
/* Start a new timer to make sure we don't send EoR
* before route-maps are processed.
struct zclient *zclient;
int delay = 10, ret = 0;
- zclient = THREAD_ARG(t);
+ zclient = EVENT_ARG(t);
if (bgp_tm_status_connected && zclient->sock > 0)
delay = 60;
else {
bgp_writes_off(peer);
event_cancel_event_ready(bm->master, peer);
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_read);
BGP_EVENT_FLUSH(peer);
FOREACH_AFI_SAFI_NSF (afi, safi) {
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) {
- THREAD_OFF(peer->t_gr_restart);
+ EVENT_OFF(peer->t_gr_restart);
if (bgp_debug_neighbor_events(peer))
zlog_debug("%pBP graceful restart timer stopped", peer);
}
if (peer->t_gr_stale) {
- THREAD_OFF(peer->t_gr_stale);
+ EVENT_OFF(peer->t_gr_stale);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
"%pBP graceful restart stalepath timer stopped",
bgp_writes_off(peer);
event_cancel_event_ready(bm->master, peer);
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_READS_ON));
assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON));
{
struct bgp *bgp;
- bgp = THREAD_ARG(thread);
+ bgp = EVENT_ARG(thread);
bgp->t_startup = NULL;
}
/* Stop timers. */
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 -
why? */
}
hook_call(bgp_inst_delete, bgp);
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);
- THREAD_OFF(bgp->t_startup);
- THREAD_OFF(bgp->t_maxmed_onstartup);
- THREAD_OFF(bgp->t_update_delay);
- THREAD_OFF(bgp->t_establish_wait);
+ EVENT_OFF(bgp->t_condition_check);
+ EVENT_OFF(bgp->t_startup);
+ EVENT_OFF(bgp->t_maxmed_onstartup);
+ EVENT_OFF(bgp->t_update_delay);
+ EVENT_OFF(bgp->t_establish_wait);
/* Set flag indicating bgp instance delete in progress */
SET_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS);
continue;
t = gr_info->t_select_deferral;
if (t) {
- void *info = THREAD_ARG(t);
+ void *info = EVENT_ARG(t);
XFREE(MTYPE_TMP, info);
}
- THREAD_OFF(gr_info->t_select_deferral);
+ EVENT_OFF(gr_info->t_select_deferral);
t = gr_info->t_route_select;
if (t) {
- void *info = THREAD_ARG(t);
+ void *info = EVENT_ARG(t);
XFREE(MTYPE_TMP, info);
}
- THREAD_OFF(gr_info->t_route_select);
+ EVENT_OFF(gr_info->t_route_select);
}
if (BGP_DEBUG(zebra, ZEBRA)) {
/* Stop timers. */
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 -
why? */
}
UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
if (peer->t_pmax_restart) {
- THREAD_OFF(peer->t_pmax_restart);
+ EVENT_OFF(peer->t_pmax_restart);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
"%pBP Maximum-prefix restart timer canceled",
UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
if (peer->t_pmax_restart) {
- THREAD_OFF(peer->t_pmax_restart);
+ EVENT_OFF(peer->t_pmax_restart);
if (bgp_debug_neighbor_events(peer))
zlog_debug(
"%pBP Maximum-prefix restart timer cancelled",
if (bm->listen_sockets)
list_delete(&bm->listen_sockets);
- THREAD_OFF(bm->t_rmap_update);
+ EVENT_OFF(bm->t_rmap_update);
bgp_mac_finish();
}
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb =
- THREAD_ARG(bpi->extra->vnc.import.timer);
+ EVENT_ARG(bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
- THREAD_OFF(bpi->extra->vnc.import.timer);
+ EVENT_OFF(bpi->extra->vnc.import.timer);
}
next = bpi->next;
*/
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 *bgp = bgp_get_default();
const struct prefix *p;
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;
int was_first_route = 0;
struct rfapi_monitor_encap *em;
*/
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) {
- struct rfapi_withdraw *wcb = THREAD_ARG(
+ struct rfapi_withdraw *wcb = EVENT_ARG(
bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
- THREAD_OFF(
- bpi->extra->vnc.import.timer);
+ EVENT_OFF(bpi->extra->vnc.import.timer);
}
if (action == FIF_ACTION_UPDATE) {
__func__);
if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb =
- THREAD_ARG(bpi->extra->vnc.import.timer);
+ EVENT_ARG(bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
- THREAD_OFF(bpi->extra->vnc.import.timer);
+ EVENT_OFF(bpi->extra->vnc.import.timer);
}
rfapiExpireEncapNow(import_table, rn, bpi);
}
*/
if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)
&& bpi->extra->vnc.import.timer) {
- struct rfapi_withdraw *wcb = THREAD_ARG(
+ struct rfapi_withdraw *wcb = EVENT_ARG(
bpi->extra->vnc.import.timer);
XFREE(MTYPE_RFAPI_WITHDRAW, wcb);
- THREAD_OFF(
- bpi->extra->vnc.import.timer);
+ EVENT_OFF(bpi->extra->vnc.import.timer);
import_table->holddown_count[afi] -= 1;
RFAPI_UPDATE_ITABLE_COUNT(
__func__);
if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb =
- THREAD_ARG(bpi->extra->vnc.import.timer);
+ EVENT_ARG(bpi->extra->vnc.import.timer);
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);
}
continue;
if (bpi->extra->vnc.import.timer) {
struct rfapi_withdraw *wcb =
- THREAD_ARG(
+ EVENT_ARG(
bpi->extra->vnc
.import
.timer);
afi, 1);
XFREE(MTYPE_RFAPI_WITHDRAW,
wcb);
- THREAD_OFF(
- bpi->extra->vnc.import
- .timer);
+ EVENT_OFF(bpi->extra->vnc.import
+ .timer);
}
} else {
if (!delete_active)
rfapiMonitorDetachImport(m);
}
- THREAD_OFF(m->timer);
+ EVENT_OFF(m->timer);
/*
* remove from rfd list
rfapiMonitorDetachImport(m);
}
- THREAD_OFF(m->timer);
+ EVENT_OFF(m->timer);
XFREE(MTYPE_RFAPI_MONITOR, m);
rn->info = NULL;
#endif
}
- THREAD_OFF(mon_eth->timer);
+ EVENT_OFF(mon_eth->timer);
/*
* remove from rfd list
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 */
m->timer = NULL;
if (m->rfd->response_lifetime - remain < 2)
return;
- THREAD_OFF(m->timer);
+ EVENT_OFF(m->timer);
{
char buf[BUFSIZ];
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 */
m->timer = NULL;
if (m->rfd->response_lifetime - remain < 2)
return;
- THREAD_OFF(m->timer);
+ EVENT_OFF(m->timer);
{
char buf[BUFSIZ];
rfapiMonitorEthDetachImport(bgp, val);
}
- THREAD_OFF(val->timer);
+ EVENT_OFF(val->timer);
/*
* remove from rfd list
if (goner->timer) {
struct rfapi_rib_tcb *tcb;
- tcb = THREAD_ARG(goner->timer);
- THREAD_OFF(goner->timer);
+ tcb = EVENT_ARG(goner->timer);
+ EVENT_OFF(goner->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
}
XFREE(MTYPE_RFAPI_INFO, goner);
*/
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);
struct rfapi_rib_tcb *tcb = NULL;
if (ri->timer) {
- tcb = THREAD_ARG(ri->timer);
- THREAD_OFF(ri->timer);
+ tcb = EVENT_ARG(ri->timer);
+ EVENT_OFF(ri->timer);
} else {
tcb = XCALLOC(MTYPE_RFAPI_RECENT_DELETE,
sizeof(struct rfapi_rib_tcb));
if (ri->timer) {
struct rfapi_rib_tcb *tcb;
- tcb = THREAD_ARG(ri->timer);
- THREAD_OFF(ri->timer);
+ tcb = EVENT_ARG(ri->timer);
+ EVENT_OFF(ri->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
}
if (ori->timer) {
struct rfapi_rib_tcb *tcb;
- tcb = THREAD_ARG(ori->timer);
- THREAD_OFF(ori->timer);
+ tcb = EVENT_ARG(ori->timer);
+ EVENT_OFF(ori->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
}
if (ri->timer) {
struct rfapi_rib_tcb *tcb;
- tcb = THREAD_ARG(ri->timer);
- THREAD_OFF(ri->timer);
+ tcb = EVENT_ARG(ri->timer);
+ EVENT_OFF(ri->timer);
XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
}
RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
* export expiration timer is already running on
* this route: cancel it
*/
- THREAD_OFF(eti->timer);
+ EVENT_OFF(eti->timer);
bgp_update(peer, prefix, /* prefix */
0, /* addpath_id */
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);
/*
* already running on
* this route: cancel it
*/
- THREAD_OFF(eti->timer);
+ EVENT_OFF(eti->timer);
vnc_zlog_debug_verbose(
"%s: calling bgp_update",
ZEBRA_ROUTE_VNC_DIRECT_RH,
BGP_ROUTE_REDISTRIBUTE);
if (eti) {
- THREAD_OFF(eti->timer);
+ EVENT_OFF(eti->timer);
vnc_eti_delete(eti);
}
{
struct eigrp *eigrp;
- eigrp = THREAD_ARG(thread);
+ eigrp = EVENT_ARG(thread);
/* execute GR for whole process */
eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL);
{
struct eigrp_interface *ei;
- ei = THREAD_ARG(thread);
+ ei = EVENT_ARG(thread);
ei->t_distribute = NULL;
/* execute GR for interface */
{
struct eigrp_interface *ei;
- ei = THREAD_ARG(thread);
+ ei = EVENT_ARG(thread);
if (IS_DEBUG_EIGRP(0, TIMERS))
zlog_debug("Start Hello Timer (%s) Expire [%u]", IF_NAME(ei),
return 0;
/* Shutdown packet reception and sending */
- THREAD_OFF(ei->t_hello);
+ EVENT_OFF(ei->t_hello);
eigrp_if_stream_unset(ei);
event_cancel_event(master, nbr);
eigrp_fifo_free(nbr->multicast_queue);
eigrp_fifo_free(nbr->retrans_queue);
- THREAD_OFF(nbr->t_holddown);
+ EVENT_OFF(nbr->t_holddown);
if (nbr->ei)
listnode_delete(nbr->ei->nbrs, nbr);
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;
zlog_info("Neighbor %pI4 (%s) is down: holding time expired", &nbr->src,
// hold time..
nbr->v_holddown = EIGRP_HOLD_INTERVAL_DEFAULT;
- THREAD_OFF(nbr->t_holddown);
+ EVENT_OFF(nbr->t_holddown);
/* out with the old */
if (nbr->multicast_queue)
switch (nbr->state) {
case EIGRP_NEIGHBOR_DOWN: {
/*Start Hold Down Timer for neighbor*/
- // THREAD_OFF(nbr->t_holddown);
- // THREAD_TIMER_ON(master, nbr->t_holddown,
+ // EVENT_OFF(nbr->t_holddown);
+ // EVENT_TIMER_ON(master, nbr->t_holddown,
// holddown_timer_expired,
// nbr, nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_PENDING: {
/*Reset Hold Down Timer for neighbor*/
- THREAD_OFF(nbr->t_holddown);
+ EVENT_OFF(nbr->t_holddown);
event_add_timer(master, holddown_timer_expired, nbr,
nbr->v_holddown, &nbr->t_holddown);
break;
}
case EIGRP_NEIGHBOR_UP: {
/*Reset Hold Down Timer for neighbor*/
- THREAD_OFF(nbr->t_holddown);
+ EVENT_OFF(nbr->t_holddown);
event_add_timer(master, holddown_timer_expired, nbr,
nbr->v_holddown, &nbr->t_holddown);
break;
void eigrp_write(struct event *thread)
{
- struct eigrp *eigrp = THREAD_ARG(thread);
+ struct eigrp *eigrp = EVENT_ARG(thread);
struct eigrp_header *eigrph;
struct eigrp_interface *ei;
struct eigrp_packet *ep;
uint16_t length = 0;
/* first of all get interface pointer. */
- eigrp = THREAD_ARG(thread);
+ eigrp = EVENT_ARG(thread);
/* prepare for next packet. */
event_add_read(master, eigrp_read, eigrp, eigrp->fd, &eigrp->t_read);
if (ep->s)
stream_free(ep->s);
- THREAD_OFF(ep->t_retrans_timer);
+ EVENT_OFF(ep->t_retrans_timer);
XFREE(MTYPE_EIGRP_PACKET, ep);
}
void eigrp_unack_packet_retrans(struct event *thread)
{
struct eigrp_neighbor *nbr;
- nbr = (struct eigrp_neighbor *)THREAD_ARG(thread);
+ nbr = (struct eigrp_neighbor *)EVENT_ARG(thread);
struct eigrp_packet *ep;
ep = eigrp_fifo_next(nbr->retrans_queue);
void eigrp_unack_multicast_packet_retrans(struct event *thread)
{
struct eigrp_neighbor *nbr;
- nbr = (struct eigrp_neighbor *)THREAD_ARG(thread);
+ nbr = (struct eigrp_neighbor *)EVENT_ARG(thread);
struct eigrp_packet *ep;
ep = eigrp_fifo_next(nbr->multicast_queue);
struct eigrp_neighbor *nbr;
/* get argument from thread */
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
/* remove this thread pointer */
/* if there is packet waiting in queue,
eigrp_if_free(ei, INTERFACE_DOWN_BY_FINAL);
}
- THREAD_OFF(eigrp->t_write);
- THREAD_OFF(eigrp->t_read);
+ EVENT_OFF(eigrp->t_write);
+ EVENT_OFF(eigrp->t_read);
close(eigrp->fd);
list_delete(&eigrp->eiflist);
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);
neighbor_lists_clear(f);
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)
zlog_debug(
f->initial_sync_circuit->interface->name);
f->initial_sync_state = FABRICD_SYNC_COMPLETE;
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_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);
}
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;
tier = fabricd_calculate_fabric_tier(f->area);
{
/* Cancel timer if we already know our tier */
if (f->tier != ISIS_TIER_UNDEFINED || f->tier_set_timer) {
- THREAD_OFF(f->tier_calculation_timer);
+ EVENT_OFF(f->tier_calculation_timer);
return;
}
/* If we need to calculate the tier, wait some
* time for the topology to settle before running
* the calculation */
- THREAD_OFF(f->tier_calculation_timer);
+ EVENT_OFF(f->tier_calculation_timer);
event_add_timer(master, fabricd_tier_calculation_cb, f,
2 * f->area->lsp_gen_interval[ISIS_LEVEL2 - 1],
if (!circuit->t_send_csnp[1])
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,
isis_jitter(f->csnp_delay, CSNP_JITTER),
&circuit->t_send_csnp[ISIS_LEVEL2 - 1]);
/* Remove self from snmp list without walking the list*/
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)
adj->adj_state = ISIS_ADJ_DOWN;
/*
* Get the adjacency
*/
- adj = THREAD_ARG(thread);
+ adj = EVENT_ARG(thread);
assert(adj);
adj->t_expire = NULL;
memset(circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
memset(circuit->u.bc.snpa, 0, ETH_ALEN);
- THREAD_OFF(circuit->u.bc.t_send_lan_hello[0]);
- THREAD_OFF(circuit->u.bc.t_send_lan_hello[1]);
- THREAD_OFF(circuit->u.bc.t_run_dr[0]);
- THREAD_OFF(circuit->u.bc.t_run_dr[1]);
- THREAD_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_send_lan_hello[0]);
+ EVENT_OFF(circuit->u.bc.t_send_lan_hello[1]);
+ EVENT_OFF(circuit->u.bc.t_run_dr[0]);
+ EVENT_OFF(circuit->u.bc.t_run_dr[1]);
+ EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[0]);
+ EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[1]);
circuit->lsp_regenerate_pending[0] = 0;
circuit->lsp_regenerate_pending[1] = 0;
} else if (circuit->circ_type == CIRCUIT_T_P2P) {
isis_delete_adj(circuit->u.p2p.neighbor);
circuit->u.p2p.neighbor = NULL;
- THREAD_OFF(circuit->u.p2p.t_send_p2p_hello);
+ EVENT_OFF(circuit->u.p2p.t_send_p2p_hello);
}
/*
circuit->snmp_adj_idx_gen = 0;
/* Cancel all active threads */
- THREAD_OFF(circuit->t_send_csnp[0]);
- THREAD_OFF(circuit->t_send_csnp[1]);
- THREAD_OFF(circuit->t_send_psnp[0]);
- THREAD_OFF(circuit->t_send_psnp[1]);
- THREAD_OFF(circuit->t_read);
+ EVENT_OFF(circuit->t_send_csnp[0]);
+ EVENT_OFF(circuit->t_send_csnp[1]);
+ EVENT_OFF(circuit->t_send_psnp[0]);
+ EVENT_OFF(circuit->t_send_psnp[1]);
+ EVENT_OFF(circuit->t_read);
if (circuit->tx_queue) {
isis_tx_queue_free(circuit->tx_queue);
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);
circuit->u.bc.is_dr[level - 1] = 0;
circuit->u.bc.run_dr_elect[level - 1] = 0;
- THREAD_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_run_dr[level - 1]);
+ EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
circuit->lsp_regenerate_pending[level - 1] = 0;
memcpy(id, circuit->isis->sysid, ISIS_SYS_ID_LEN);
&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],
2 * circuit->hello_interval[level - 1],
struct listnode *node, *nnode;
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)) {
list_delete_node(isis->dyn_cache, node);
time_t now = time(NULL);
struct isis *isis = NULL;
- isis = THREAD_ARG(thread);
+ isis = EVENT_ARG(thread);
isis->t_dync_clean = NULL;
circuit->area->area_tag, circuit->circuit_id,
circuit->interface->name, level);
- THREAD_OFF(circuit->t_send_csnp[idx]);
- THREAD_OFF(circuit->t_send_psnp[idx]);
+ EVENT_OFF(circuit->t_send_csnp[idx]);
+ EVENT_OFF(circuit->t_send_psnp[idx]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
- THREAD_OFF(circuit->u.bc.t_send_lan_hello[idx]);
- THREAD_OFF(circuit->u.bc.t_run_dr[idx]);
- THREAD_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
+ EVENT_OFF(circuit->u.bc.t_send_lan_hello[idx]);
+ EVENT_OFF(circuit->u.bc.t_run_dr[idx]);
+ EVENT_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
circuit->lsp_regenerate_pending[idx] = 0;
circuit->u.bc.run_dr_elect[idx] = 0;
circuit->u.bc.is_dr[idx] = 0;
{
struct isis_circuit *circuit;
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
/* invalid arguments */
if (!circuit || !circuit->area)
if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_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);
}
if (ldp_sync_info &&
ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
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;
isis_ldp_sync_set_if_metric(circuit, true);
}
* didn't receive msg from LDP indicating sync-complete
* restore interface cost to original value
*/
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
if (circuit->ldp_sync_info == NULL)
return;
if (!CHECK_FLAG(area->ldp_sync_cmd.flags, LDP_SYNC_FLAG_ENABLE))
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;
isis_ldp_sync_set_if_metric(circuit, true);
}
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)
zlog_debug("ISIS-LFA: updating RLFAs in the RIB");
spftree->route_table_backup);
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,
&area->t_rlfa_rib_update);
isis_route_delete(area, rn, spftree->route_table_backup);
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,
&area->t_rlfa_rib_update);
}
*/
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);
area->t_overload_on_startup_timer = NULL;
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;
event_add_timer(master, lsp_refresh, &area->lsp_refresh_arg[level - 1],
refresh_time, &area->t_lsp_refresh[level - 1]);
*/
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);
"ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld",
area->area_tag, (long long)lsp->last_generated,
(long long)now);
- THREAD_OFF(area->t_lsp_refresh[lvl - 1]);
+ EVENT_OFF(area->t_lsp_refresh[lvl - 1]);
diff = now - lsp->last_generated;
if (diff < area->lsp_gen_interval[lvl - 1]
&& !(area->bfd_signalled_down)) {
lsp_flood(lsp, NULL);
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;
if (level == IS_LEVEL_1)
event_add_timer(master, lsp_l1_refresh_pseudo, circuit,
struct isis_circuit *circuit;
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->lsp_regenerate_pending[0] = 0;
struct isis_circuit *circuit;
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->lsp_regenerate_pending[1] = 0;
"ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld",
area->area_tag, (long long)lsp->last_generated,
(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;
if (diff < circuit->area->lsp_gen_interval[lvl - 1]) {
timeout =
uint16_t rem_lifetime;
bool fabricd_sync_incomplete = false;
- area = THREAD_ARG(thread);
+ area = EVENT_ARG(thread);
assert(area);
area->t_tick = NULL;
event_add_timer(master, lsp_tick, area, 1, &area->t_tick);
{
/* Max wait time for config to load before generating lsp */
#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,
ISIS_PRE_CONFIG_MAX_WAIT_SECONDS, &t_isis_cfg);
}
if (!event_is_scheduled(t_isis_cfg))
return;
- THREAD_OFF(t_isis_cfg);
+ EVENT_OFF(t_isis_cfg);
isis_config_finish(t_isis_cfg);
}
adj);
/* 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,
&adj->t_expire);
adj);
/* 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,
&adj->t_expire);
/*
* Get the circuit
*/
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
assert(circuit);
circuit->t_read = NULL;
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);
struct isis_circuit *circuit = arg->circuit;
if (event_timer_remain_msec(*threadp) < (unsigned long)delay)
return;
- THREAD_OFF(*threadp);
+ EVENT_OFF(*threadp);
}
event_add_timer_msec(master, send_hello_cb,
{
struct isis_circuit *circuit;
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
assert(circuit);
circuit->t_send_csnp[0] = NULL;
{
struct isis_circuit *circuit;
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
assert(circuit);
circuit->t_send_csnp[1] = NULL;
struct isis_circuit *circuit;
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
assert(circuit);
circuit->t_send_psnp[0] = NULL;
{
struct isis_circuit *circuit;
- circuit = THREAD_ARG(thread);
+ circuit = EVENT_ARG(thread);
assert(circuit);
circuit->t_send_psnp[1] = NULL;
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;
int level = run->level;
int have_run = 0;
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]) {
/* Need to call schedule function also if spf delay is running
* to
{
struct isis_area *area;
- area = THREAD_ARG(start);
+ area = EVENT_ARG(start);
/* re-attempt to start SR & Label Manager connection */
isis_sr_start(area);
area->area_tag);
/* 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. */
for (ALL_LIST_ELEMENTS(area->srdb.adj_sids, node, nnode, sra))
{
struct isis_tx_queue_entry *e = element;
- THREAD_OFF(e->retry);
+ EVENT_OFF(e->retry);
XFREE(MTYPE_TX_QUEUE_ENTRY, e);
}
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;
event_add_timer(master, tx_queue_send_event, e, 5, &e->retry);
e->type = type;
- THREAD_OFF(e->retry);
+ EVENT_OFF(e->retry);
event_add_event(master, tx_queue_send_event, e, 0, &e->retry);
e->is_retry = false;
func, file, line);
}
- THREAD_OFF(e->retry);
+ EVENT_OFF(e->retry);
hash_release(queue->hash, e);
XFREE(MTYPE_TX_QUEUE_ENTRY, e);
spftree_area_del(area);
if (area->spf_timer[0])
- isis_spf_timer_free(THREAD_ARG(area->spf_timer[0]));
- THREAD_OFF(area->spf_timer[0]);
+ isis_spf_timer_free(EVENT_ARG(area->spf_timer[0]));
+ EVENT_OFF(area->spf_timer[0]);
if (area->spf_timer[1])
- isis_spf_timer_free(THREAD_ARG(area->spf_timer[1]));
- THREAD_OFF(area->spf_timer[1]);
+ isis_spf_timer_free(EVENT_ARG(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[1]);
isis_lfa_tiebreakers_clear(area, ISIS_LEVEL1);
isis_lfa_tiebreakers_clear(area, ISIS_LEVEL2);
- THREAD_OFF(area->t_tick);
- THREAD_OFF(area->t_lsp_refresh[0]);
- THREAD_OFF(area->t_lsp_refresh[1]);
- THREAD_OFF(area->t_rlfa_rib_update);
+ EVENT_OFF(area->t_tick);
+ EVENT_OFF(area->t_lsp_refresh[0]);
+ EVENT_OFF(area->t_lsp_refresh[1]);
+ EVENT_OFF(area->t_rlfa_rib_update);
event_cancel_event(master, area);
}
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(
"ISIS (%s): Resigned from L%d - canceling LSP regeneration timer.",
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;
}
} else {
/* Cancel overload on startup timer if it's running */
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;
}
}
LIST_FOREACH(av, &accept_queue.queue, entry)
if (av->fd == fd) {
log_debug("%s: %d removed from queue", __func__, fd);
- THREAD_OFF(av->ev);
+ EVENT_OFF(av->ev);
LIST_REMOVE(av, entry);
free(av);
return;
{
if (accept_queue.evt != NULL) {
log_debug(__func__);
- THREAD_OFF(accept_queue.evt);
+ EVENT_OFF(accept_queue.evt);
accept_arm();
}
}
{
struct accept_ev *av;
LIST_FOREACH(av, &accept_queue.queue, entry)
- THREAD_OFF(av->ev);
+ EVENT_OFF(av->ev);
}
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);
av->accept_cb(thread);
}
/* ARGSUSED */
static void adj_itimer(struct event *thread)
{
- struct adj *adj = THREAD_ARG(thread);
+ struct adj *adj = EVENT_ARG(thread);
adj->inactivity_timer = NULL;
void
adj_start_itimer(struct adj *adj)
{
- THREAD_OFF(adj->inactivity_timer);
+ EVENT_OFF(adj->inactivity_timer);
adj->inactivity_timer = NULL;
event_add_timer(master, adj_itimer, adj, adj->holdtime,
&adj->inactivity_timer);
void
adj_stop_itimer(struct adj *adj)
{
- THREAD_OFF(adj->inactivity_timer);
+ EVENT_OFF(adj->inactivity_timer);
}
/* targeted neighbors */
/* ARGSUSED */
static void tnbr_hello_timer(struct event *thread)
{
- struct tnbr *tnbr = THREAD_ARG(thread);
+ struct tnbr *tnbr = EVENT_ARG(thread);
tnbr->hello_timer = NULL;
send_hello(HELLO_TARGETED, NULL, tnbr);
static void
tnbr_start_hello_timer(struct tnbr *tnbr)
{
- THREAD_OFF(tnbr->hello_timer);
+ EVENT_OFF(tnbr->hello_timer);
tnbr->hello_timer = NULL;
event_add_timer(master, tnbr_hello_timer, tnbr,
tnbr_get_hello_interval(tnbr), &tnbr->hello_timer);
static void
tnbr_stop_hello_timer(struct tnbr *tnbr)
{
- THREAD_OFF(tnbr->hello_timer);
+ EVENT_OFF(tnbr->hello_timer);
}
struct ctl_adj *
struct ctl_conn *c;
len = sizeof(s_un);
- if ((connfd = accept(THREAD_FD(thread), (struct sockaddr *)&s_un,
- &len)) == -1) {
+ if ((connfd = accept(EVENT_FD(thread), (struct sockaddr *)&s_un,
+ &len)) == -1) {
/*
* Pause accept if we are out of file descriptors, or
* libevent will haunt us here too.
msgbuf_clear(&c->iev.ibuf.w);
TAILQ_REMOVE(&ctl_conns, c, entry);
- THREAD_OFF(c->iev.ev_read);
- THREAD_OFF(c->iev.ev_write);
+ EVENT_OFF(c->iev.ev_read);
+ EVENT_OFF(c->iev.ev_write);
close(c->iev.ibuf.fd);
accept_unpause();
free(c);
/* ARGSUSED */
static void control_dispatch_imsg(struct event *thread)
{
- int fd = THREAD_FD(thread);
+ int fd = EVENT_FD(thread);
struct ctl_conn *c;
struct imsg imsg;
ssize_t n;
/* ARGSUSED */
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;
send_hello(HELLO_LINK, ia, NULL);
static void
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),
&ia->hello_timer);
}
static void
if_stop_hello_timer(struct iface_af *ia)
{
- THREAD_OFF(ia->hello_timer);
+ EVENT_OFF(ia->hello_timer);
}
struct ctl_iface *
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);
}
if (iface->ldp_sync.wait_for_sync_timer)
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,
if_get_wait_for_sync_interval(),
&iface->ldp_sync.wait_for_sync_timer);
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
/* ARGSUSED */
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 imsg imsg;
struct lde_nbr *ln;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
lde_shutdown();
}
}
struct kif *kif;
struct kroute *kr;
int fd;
- struct imsgev *iev = THREAD_ARG(thread);
+ struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
ssize_t n;
int shut = 0;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
lde_shutdown();
}
}
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);
}
void
lde_gc_stop_timer(void)
{
- THREAD_OFF(gc_timer);
+ EVENT_OFF(gc_timer);
}
/* ARGSUSED */
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 imsg imsg;
int af;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
ldpe_pid = 0;
if (lde_pid == 0)
/* ARGSUSED */
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 imsg imsg;
ssize_t n;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
lde_pid = 0;
if (ldpe_pid == 0)
ldpd_shutdown();
/* ARGSUSED */
void ldp_write_handler(struct event *thread)
{
- struct imsgev *iev = THREAD_ARG(thread);
+ struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
ssize_t n;
fatal("msgbuf_write");
if (n == 0) {
/* this pipe is dead, so remove the event handlers */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
return;
}
void
evbuf_clear(struct evbuf *eb)
{
- THREAD_OFF(eb->ev);
+ EVENT_OFF(eb->ev);
msgbuf_clear(&eb->wbuf);
eb->wbuf.fd = -1;
}
#ifdef __OpenBSD__
if (sysdep.no_pfkey == 0) {
- THREAD_OFF(pfkey_ev);
+ EVENT_OFF(pfkey_ev);
close(global.pfkeysock);
}
#endif
struct l2vpn_pw *pw, *npw;
struct imsg imsg;
int fd;
- struct imsgev *iev = THREAD_ARG(thread);
+ struct imsgev *iev = EVENT_ARG(thread);
struct imsgbuf *ibuf = &iev->ibuf;
struct iface *iface = NULL;
struct kif *kif;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
ldpe_shutdown();
}
}
/* ARGSUSED */
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 imsg imsg;
struct map *map;
imsg_event_add(iev);
else {
/* this pipe is dead, so remove the event handlers and exit */
- THREAD_OFF(iev->ev_read);
- THREAD_OFF(iev->ev_write);
+ EVENT_OFF(iev->ev_read);
+ EVENT_OFF(iev->ev_write);
ldpe_shutdown();
}
}
/* ARGSUSED */
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,
&pfkey_ev);
af_global = ldp_af_global_get(&global, af);
/* discovery socket */
- THREAD_OFF(af_global->disc_ev);
+ EVENT_OFF(af_global->disc_ev);
if (af_global->ldp_disc_socket != -1) {
close(af_global->ldp_disc_socket);
af_global->ldp_disc_socket = -1;
}
/* extended discovery socket */
- THREAD_OFF(af_global->edisc_ev);
+ EVENT_OFF(af_global->edisc_ev);
if (af_global->ldp_edisc_socket != -1) {
close(af_global->ldp_edisc_socket);
af_global->ldp_edisc_socket = -1;
nbr->auth.method = AUTH_NONE;
if (nbr_pending_connect(nbr))
- THREAD_OFF(nbr->ev_connect);
+ EVENT_OFF(nbr->ev_connect);
nbr_stop_ktimer(nbr);
nbr_stop_ktimeout(nbr);
nbr_stop_itimeout(nbr);
static void nbr_ktimer(struct event *thread)
{
- struct nbr *nbr = THREAD_ARG(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
nbr->keepalive_timer = NULL;
send_keepalive(nbr);
/* send three keepalives per period */
secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
- THREAD_OFF(nbr->keepalive_timer);
+ EVENT_OFF(nbr->keepalive_timer);
nbr->keepalive_timer = NULL;
event_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer);
}
void
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 */
static void nbr_ktimeout(struct event *thread)
{
- struct nbr *nbr = THREAD_ARG(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
nbr->keepalive_timeout = NULL;
static void
nbr_start_ktimeout(struct nbr *nbr)
{
- THREAD_OFF(nbr->keepalive_timeout);
+ EVENT_OFF(nbr->keepalive_timeout);
nbr->keepalive_timeout = NULL;
event_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive,
&nbr->keepalive_timeout);
void
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 */
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);
int secs;
secs = INIT_FSM_TIMEOUT;
- THREAD_OFF(nbr->init_timeout);
+ EVENT_OFF(nbr->init_timeout);
nbr->init_timeout = NULL;
event_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout);
}
void
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 */
static void nbr_idtimer(struct event *thread)
{
- struct nbr *nbr = THREAD_ARG(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
nbr->initdelay_timer = NULL;
break;
}
- THREAD_OFF(nbr->initdelay_timer);
+ EVENT_OFF(nbr->initdelay_timer);
nbr->initdelay_timer = NULL;
event_add_timer(master, nbr_idtimer, nbr, secs, &nbr->initdelay_timer);
}
void
nbr_stop_idtimer(struct nbr *nbr)
{
- THREAD_OFF(nbr->initdelay_timer);
+ EVENT_OFF(nbr->initdelay_timer);
}
int
static void nbr_connect_cb(struct event *thread)
{
- struct nbr *nbr = THREAD_ARG(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
int error;
socklen_t len;
/* Discovery functions */
void disc_recv_packet(struct event *thread)
{
- int fd = THREAD_FD(thread);
- struct event **threadp = THREAD_ARG(thread);
+ int fd = EVENT_FD(thread);
+ struct event **threadp = EVENT_ARG(thread);
union {
struct cmsghdr hdr;
void session_accept(struct event *thread)
{
- int fd = THREAD_FD(thread);
+ int fd = EVENT_FD(thread);
struct sockaddr_storage src;
socklen_t len = sizeof(src);
int newfd;
static void session_read(struct event *thread)
{
- int fd = THREAD_FD(thread);
- struct nbr *nbr = THREAD_ARG(thread);
+ int fd = EVENT_FD(thread);
+ struct nbr *nbr = EVENT_ARG(thread);
struct tcp_conn *tcp = nbr->tcp;
struct ldp_hdr *ldp_hdr;
struct ldp_msg *msg;
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;
tcp->wbuf.ev = NULL;
switch (nbr->state) {
case NBR_STA_PRESENT:
if (nbr_pending_connect(nbr))
- THREAD_OFF(nbr->ev_connect);
+ EVENT_OFF(nbr->ev_connect);
break;
case NBR_STA_INITIAL:
case NBR_STA_OPENREC:
evbuf_clear(&tcp->wbuf);
if (tcp->nbr) {
- THREAD_OFF(tcp->rev);
+ EVENT_OFF(tcp->rev);
free(tcp->rbuf);
tcp->nbr->tcp = NULL;
}
void
pending_conn_del(struct pending_conn *pconn)
{
- THREAD_OFF(pconn->ev_timeout);
+ EVENT_OFF(pconn->ev_timeout);
TAILQ_REMOVE(&global.pending_conns, pconn, entry);
free(pconn);
}
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;
pconn->ev_timeout = NULL;
fd_set fds;
int flags, new_flags = 0;
int nonblock = false;
- struct listnode *ln = THREAD_ARG(t);
+ struct listnode *ln = EVENT_ARG(t);
struct event **thr = listgetdata(ln);
XFREE(MTYPE_TMP, thr);
list_delete_node(events, ln);
/* fix for non blocking socket */
- flags = fcntl(THREAD_FD(t), F_GETFL, 0);
+ flags = fcntl(EVENT_FD(t), F_GETFL, 0);
if (-1 == flags) {
flog_err(EC_LIB_SYSTEM_CALL, "Failed to get FD settings fcntl: %s(%d)",
strerror(errno), errno);
if (flags & O_NONBLOCK)
nonblock = true;
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)
flog_err(EC_LIB_SYSTEM_CALL, "Failed to set snmp fd non blocking: %s(%d)",
strerror(errno), errno);
FD_ZERO(&fds);
- FD_SET(THREAD_FD(t), &fds);
+ FD_SET(EVENT_FD(t), &fds);
snmp_read(&fds);
/* Reset the flag */
if (!nonblock) {
- new_flags = fcntl(THREAD_FD(t), F_SETFL, flags);
+ new_flags = fcntl(EVENT_FD(t), F_SETFL, flags);
if (new_flags == -1)
flog_err(
ln = listhead(events);
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
* ln/thr/thr_fd point to the next existing event listener to hit while
}
ln = nextln;
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 */
else if (FD_ISSET(fd, &fds)) {
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;
/* Validate configuration before trying to send bogus data. */
static void _bfd_sess_remove(struct bfd_session_params *bsp)
{
/* Cancel any pending installation request. */
- THREAD_OFF(bsp->installev);
+ EVENT_OFF(bsp->installev);
/* Not installed, nothing to do. */
if (!bsp->installed)
bsp->installed = false;
/* Cancel any pending installation request. */
- THREAD_OFF(bsp->installev);
+ EVENT_OFF(bsp->installev);
/* Ask for installation. */
bsp->lastev = BSE_INSTALL;
#define EVENT_TIMER_STRLEN 12
/* Macros. */
-#define THREAD_ARG(X) ((X)->arg)
-#define THREAD_FD(X) ((X)->u.fd)
-#define THREAD_VAL(X) ((X)->u.val)
+#define EVENT_ARG(X) ((X)->arg)
+#define EVENT_FD(X) ((X)->u.fd)
+#define EVENT_VAL(X) ((X)->u.val)
/*
* Please consider this macro deprecated, and do not use it in new code.
*/
-#define THREAD_OFF(thread) \
+#define EVENT_OFF(thread) \
do { \
if ((thread)) \
event_cancel(&(thread)); \
/* poison pill task to end event loop */
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);
}
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;
zmq_msg_t msg;
unsigned partno;
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;
unsigned char written = 0;
int ret;
* update state
*/
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)
ldp_sync_info->state =
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,
client_ctx, mgmt_debug_be_client))
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;
rv = mgmt_msg_read(&client_ctx->mstate, client_ctx->conn_fd,
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;
rv = mgmt_msg_write(&client_ctx->mstate, client_ctx->conn_fd,
{
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);
mgmt_be_client_writes_on(client_ctx);
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
mgmt_msg_destroy(&client_ctx->mstate);
- THREAD_OFF(client_ctx->conn_retry_tmr);
- THREAD_OFF(client_ctx->conn_read_ev);
- THREAD_OFF(client_ctx->conn_write_ev);
- THREAD_OFF(client_ctx->conn_writes_on);
- THREAD_OFF(client_ctx->msg_proc_ev);
+ EVENT_OFF(client_ctx->conn_retry_tmr);
+ EVENT_OFF(client_ctx->conn_read_ev);
+ EVENT_OFF(client_ctx->conn_write_ev);
+ EVENT_OFF(client_ctx->conn_writes_on);
+ EVENT_OFF(client_ctx->msg_proc_ev);
mgmt_be_cleanup_all_txns(client_ctx);
mgmt_be_txns_fini(&client_ctx->txn_head);
}
struct mgmt_fe_client_ctx *client_ctx;
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,
mgmt_debug_fe_client);
if (rv == MSW_SCHED_STREAM)
{
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);
mgmt_fe_client_writes_on(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,
client_ctx, mgmt_debug_fe_client))
mgmt_fe_client_register_event(client_ctx, MGMTD_FE_PROC_MSG);
struct mgmt_fe_client_ctx *client_ctx;
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,
mgmt_debug_fe_client);
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
mgmt_fe_destroy_client_sessions(lib_hndl);
- THREAD_OFF(client_ctx->conn_retry_tmr);
- THREAD_OFF(client_ctx->conn_read_ev);
- THREAD_OFF(client_ctx->conn_write_ev);
- THREAD_OFF(client_ctx->conn_writes_on);
- THREAD_OFF(client_ctx->msg_proc_ev);
+ EVENT_OFF(client_ctx->conn_retry_tmr);
+ EVENT_OFF(client_ctx->conn_read_ev);
+ EVENT_OFF(client_ctx->conn_write_ev);
+ EVENT_OFF(client_ctx->conn_writes_on);
+ EVENT_OFF(client_ctx->msg_proc_ev);
mgmt_msg_destroy(&client_ctx->mstate);
}
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? */
vty_out(vty,
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;
int flags;
int *subp = NULL;
static void frr_confd_finish_cdb(void)
{
if (cdb_sub_sock > 0) {
- THREAD_OFF(t_cdb_sub);
+ EVENT_OFF(t_cdb_sub);
cdb_close(cdb_sub_sock);
}
}
static void frr_confd_dp_ctl_read(struct event *thread)
{
- struct confd_daemon_ctx *dctx = THREAD_ARG(thread);
- int fd = THREAD_FD(thread);
+ struct confd_daemon_ctx *dctx = EVENT_ARG(thread);
+ int fd = EVENT_FD(thread);
event_add_read(master, frr_confd_dp_ctl_read, dctx, fd, &t_dp_ctl);
static void frr_confd_dp_worker_read(struct event *thread)
{
- struct confd_daemon_ctx *dctx = THREAD_ARG(thread);
- int fd = THREAD_FD(thread);
+ struct confd_daemon_ctx *dctx = EVENT_ARG(thread);
+ int fd = EVENT_FD(thread);
event_add_read(master, frr_confd_dp_worker_read, dctx, fd,
&t_dp_worker);
static void frr_confd_finish_dp(void)
{
if (dp_worker_sock > 0) {
- THREAD_OFF(t_dp_worker);
+ EVENT_OFF(t_dp_worker);
close(dp_worker_sock);
}
if (dp_ctl_sock > 0) {
- THREAD_OFF(t_dp_ctl);
+ EVENT_OFF(t_dp_ctl);
close(dp_ctl_sock);
}
if (dctx != NULL)
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
* _tag->state, then we signal done and release.
static void frr_sr_read_cb(struct event *thread)
{
- struct yang_module *module = THREAD_ARG(thread);
- int fd = THREAD_FD(thread);
+ struct yang_module *module = EVENT_ARG(thread);
+ int fd = EVENT_FD(thread);
int ret;
ret = sr_subscription_process_events(module->sr_subscription, session,
if (!module->sr_subscription)
continue;
sr_unsubscribe(module->sr_subscription);
- THREAD_OFF(module->sr_thread);
+ EVENT_OFF(module->sr_thread);
}
if (session)
void pullwr_del(struct pullwr *pullwr)
{
- THREAD_OFF(pullwr->writer);
+ EVENT_OFF(pullwr->writer);
XFREE(MTYPE_PULLWR_BUF, pullwr->buffer);
XFREE(MTYPE_PULLWR_HEAD, pullwr);
static void pullwr_run(struct event *t)
{
- struct pullwr *pullwr = THREAD_ARG(t);
+ struct pullwr *pullwr = EVENT_ARG(t);
struct iovec iov[2];
size_t niov, lastvalid;
ssize_t nwr;
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);
resolver_update_timeouts(r);
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;
event_add_read(r->master, resolver_cb_socket_readable, resfd, resfd->fd,
&resfd->t_read);
/* ^ 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!
*/
ares_process_fd(r->channel, resfd->fd, ARES_SOCKET_BAD);
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;
event_add_write(r->master, resolver_cb_socket_writable, resfd,
resfd->fd, &resfd->t_write);
/* ^ 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!
*/
ares_process_fd(r->channel, ARES_SOCKET_BAD, resfd->fd);
{
struct timeval *tv, tvbuf;
- THREAD_OFF(r->timeout);
+ EVENT_OFF(r->timeout);
tv = ares_timeout(r->channel, NULL, &tvbuf);
if (tv) {
unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
assert(resfd->state == r);
if (!readable)
- THREAD_OFF(resfd->t_read);
+ EVENT_OFF(resfd->t_read);
else if (!resfd->t_read)
event_add_read(r->master, resolver_cb_socket_readable, resfd,
fd, &resfd->t_read);
if (!writable)
- THREAD_OFF(resfd->t_write);
+ EVENT_OFF(resfd->t_write);
else if (!resfd->t_write)
event_add_write(r->master, resolver_cb_socket_writable, resfd,
fd, &resfd->t_write);
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,
union sockunion *);
{
struct frr_sigevent_master_t *sigm;
- sigm = THREAD_ARG(t);
+ sigm = EVENT_ARG(t);
sigm->t = NULL;
event_add_timer(sigm->t->master, frr_signal_timer, &sigmaster,
FRR_SIGNAL_TIMER_INTERVAL, &sigm->t);
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_debug("SPF Back-off(%s) TIMETOLEARN elapsed, move to state %s",
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);
backoff->state = SPF_BACKOFF_QUIET;
backoff_debug("SPF Back-off(%s) HOLDDOWN elapsed, move to state %s",
int nbytes;
unsigned char buf[VTY_READ_BUFSIZ];
- struct vty *vty = THREAD_ARG(thread);
+ struct vty *vty = EVENT_ARG(thread);
/* Read raw data from socket */
if ((nbytes = read(vty->fd, buf, VTY_READ_BUFSIZ)) <= 0) {
{
int erase;
buffer_status_t flushrc;
- struct vty *vty = THREAD_ARG(thread);
+ struct vty *vty = EVENT_ARG(thread);
/* Tempolary disable read thread. */
if (vty->lines == 0)
- THREAD_OFF(vty->t_read);
+ EVENT_OFF(vty->t_read);
/* Function execution continue. */
erase = ((vty->status == VTY_MORE || vty->status == VTY_MORELINE));
if (!stdio_vty)
return;
- THREAD_OFF(stdio_vty->t_write);
- THREAD_OFF(stdio_vty->t_read);
- THREAD_OFF(stdio_vty->t_timeout);
+ EVENT_OFF(stdio_vty->t_write);
+ EVENT_OFF(stdio_vty->t_read);
+ EVENT_OFF(stdio_vty->t_timeout);
if (stdio_termios)
tcsetattr(0, TCSANOW, &stdio_orig_termios);
/* Accept connection from the network. */
static void vty_accept(struct event *thread)
{
- struct vty_serv *vtyserv = THREAD_ARG(thread);
+ struct vty_serv *vtyserv = EVENT_ARG(thread);
int vty_sock;
union sockunion su;
int ret;
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 sock;
int client_len;
unsigned char *p;
uint8_t header[4] = {0, 0, 0, 0};
- sock = THREAD_FD(thread);
- vty = THREAD_ARG(thread);
+ sock = EVENT_FD(thread);
+ vty = EVENT_ARG(thread);
if ((nbytes = read(sock, buf, VTY_READ_BUFSIZ)) <= 0) {
if (nbytes < 0) {
static void vtysh_write(struct event *thread)
{
- struct vty *vty = THREAD_ARG(thread);
+ struct vty *vty = EVENT_ARG(thread);
vtysh_flush(vty);
}
vty_config_exit(vty);
/* Cancel threads.*/
- THREAD_OFF(vty->t_read);
- THREAD_OFF(vty->t_write);
- THREAD_OFF(vty->t_timeout);
+ EVENT_OFF(vty->t_read);
+ EVENT_OFF(vty->t_write);
+ EVENT_OFF(vty->t_timeout);
if (vty->pass_fd != -1) {
close(vty->pass_fd);
{
struct vty *vty;
- vty = THREAD_ARG(thread);
+ vty = EVENT_ARG(thread);
vty->v_timeout = 0;
/* Clear buffer*/
/* Time out treatment. */
if (vty->v_timeout) {
- THREAD_OFF(vty->t_timeout);
+ EVENT_OFF(vty->t_timeout);
event_add_timer(vty_master, vty_timeout, vty,
vty->v_timeout, &vty->t_timeout);
}
&vty->t_write);
break;
case VTY_TIMEOUT_RESET:
- THREAD_OFF(vty->t_timeout);
+ EVENT_OFF(vty->t_timeout);
if (vty->v_timeout)
event_add_timer(vty_master, vty_timeout, vty,
vty->v_timeout, &vty->t_timeout);
vtys_init(vtysh_sessions);
while ((vtyserv = vtyservs_pop(vty_servs))) {
- THREAD_OFF(vtyserv->t_accept);
+ EVENT_OFF(vtyserv->t_accept);
close(vtyserv->sock);
XFREE(MTYPE_VTY_SERV, vtyserv);
}
struct timer_wheel *wheel;
void *data;
- wheel = THREAD_ARG(t);
+ wheel = EVENT_ARG(t);
wheel->curr_slot += wheel->slots_to_skip;
{
struct timer_wheel *wheel;
- wheel = THREAD_ARG(t);
+ wheel = EVENT_ARG(t);
event_execute(wheel->master, wheel_timer_thread_helper, wheel, 0);
}
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, wheel->name);
XFREE(MTYPE_TIMER_WHEEL, wheel);
{
struct work_queue *wq = *wqp;
- THREAD_OFF(wq->thread);
+ EVENT_OFF(wq->thread);
while (!work_queue_empty(wq)) {
struct work_queue_item *item = work_queue_last_item(wq);
*/
void work_queue_plug(struct work_queue *wq)
{
- THREAD_OFF(wq->thread);
+ EVENT_OFF(wq->thread);
UNSET_FLAG(wq->flags, WQ_UNPLUGGED);
}
unsigned int cycles = 0;
char yielded = 0;
- wq = THREAD_ARG(thread);
+ wq = EVENT_ARG(thread);
assert(wq);
zlog_debug("zclient %p stopped", zclient);
/* Stop threads. */
- THREAD_OFF(zclient->t_read);
- THREAD_OFF(zclient->t_connect);
- THREAD_OFF(zclient->t_write);
+ EVENT_OFF(zclient->t_read);
+ EVENT_OFF(zclient->t_connect);
+ EVENT_OFF(zclient->t_write);
/* Reset streams. */
stream_reset(zclient->ibuf);
static void zclient_flush_data(struct event *thread)
{
- struct zclient *zclient = THREAD_ARG(thread);
+ struct zclient *zclient = EVENT_ARG(thread);
zclient->t_write = NULL;
if (zclient->sock < 0)
__func__, zclient->sock);
return zclient_failed(zclient);
case BUFFER_EMPTY:
- THREAD_OFF(zclient->t_write);
+ EVENT_OFF(zclient->t_write);
return ZCLIENT_SEND_SUCCESS;
case BUFFER_PENDING:
event_add_write(zclient->master, zclient_flush_data, zclient,
{
struct zclient *zclient;
- zclient = THREAD_ARG(t);
+ zclient = EVENT_ARG(t);
zclient->t_connect = NULL;
if (zclient_debug)
struct zclient *zclient;
/* Get socket to zebra. */
- zclient = THREAD_ARG(thread);
+ zclient = EVENT_ARG(thread);
zclient->t_read = NULL;
/* Read zebra header (if we don't have it already). */
static void zlog_5424_reconnect(struct event *t)
{
- struct zlog_cfg_5424 *zcf = THREAD_ARG(t);
- int fd = THREAD_FD(t);
+ struct zlog_cfg_5424 *zcf = EVENT_ARG(t);
+ int fd = EVENT_FD(t);
char dummy[256];
ssize_t ret;
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,
adapter, mgmt_debug_be))
struct mgmt_be_client_adapter *adapter;
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);
if (rv == MSR_DISCONNECT) {
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;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_be);
{
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);
mgmt_be_adapter_writes_on(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);
/*
(*adapter)->refcount--;
if (!(*adapter)->refcount) {
mgmt_be_adapters_del(&mgmt_be_adapters, *adapter);
- THREAD_OFF((*adapter)->conn_init_ev);
- THREAD_OFF((*adapter)->conn_read_ev);
- THREAD_OFF((*adapter)->conn_write_ev);
- THREAD_OFF((*adapter)->conn_writes_on);
- THREAD_OFF((*adapter)->proc_msg_ev);
+ EVENT_OFF((*adapter)->conn_init_ev);
+ EVENT_OFF((*adapter)->conn_read_ev);
+ EVENT_OFF((*adapter)->conn_write_ev);
+ EVENT_OFF((*adapter)->conn_writes_on);
+ EVENT_OFF((*adapter)->proc_msg_ev);
mgmt_msg_destroy(&(*adapter)->mstate);
XFREE(MTYPE_MGMTD_BE_ADPATER, *adapter);
}
MGMTD_BE_SRVR_DBG("Closing MGMTD Backend Server!");
if (mgmt_be_listen_ev) {
- THREAD_OFF(mgmt_be_listen_ev);
+ EVENT_OFF(mgmt_be_listen_ev);
mgmt_be_listen_ev = NULL;
}
{
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);
}
{
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);
}
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,
adapter, mgmt_debug_fe))
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;
rv = mgmt_msg_read(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe);
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;
rv = mgmt_msg_write(&adapter->mstate, adapter->conn_fd, mgmt_debug_fe);
{
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);
mgmt_fe_adapter_writes_on(adapter);
(*adapter)->refcount--;
if (!(*adapter)->refcount) {
mgmt_fe_adapters_del(&mgmt_fe_adapters, *adapter);
- THREAD_OFF((*adapter)->conn_read_ev);
- THREAD_OFF((*adapter)->conn_write_ev);
- THREAD_OFF((*adapter)->proc_msg_ev);
- THREAD_OFF((*adapter)->conn_writes_on);
+ EVENT_OFF((*adapter)->conn_read_ev);
+ EVENT_OFF((*adapter)->conn_write_ev);
+ EVENT_OFF((*adapter)->proc_msg_ev);
+ EVENT_OFF((*adapter)->conn_writes_on);
mgmt_msg_destroy(&(*adapter)->mstate);
XFREE(MTYPE_MGMTD_FE_ADPATER, *adapter);
}
MGMTD_FE_SRVR_DBG("Closing MGMTD Frontend Server!");
if (mgmt_fe_listen_ev) {
- THREAD_OFF(mgmt_fe_listen_ev);
+ EVENT_OFF(mgmt_fe_listen_ev);
mgmt_fe_listen_ev = NULL;
}
struct mgmt_commit_stats *cmt_stats;
int ret = 0;
- txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread);
+ txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn);
cmt_stats = mgmt_fe_get_session_commit_stats(txn->session_id);
if (success) {
/* Stop the commit-timeout timer */
- THREAD_OFF(txn->comm_cfg_timeout);
+ EVENT_OFF(txn->comm_cfg_timeout);
create_cmt_info_rec =
(result != MGMTD_NO_CFG_CHANGES &&
{
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->type == MGMTD_TXN_TYPE_CONFIG);
struct mgmt_txn_ctx *txn;
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);
MGMTD_TXN_DBG(
* cleanup. Please see mgmt_fe_send_commit_cfg_reply() for
* more details.
*/
- THREAD_OFF(txn->comm_cfg_timeout);
+ EVENT_OFF(txn->comm_cfg_timeout);
mgmt_txn_send_commit_cfg_reply(txn, MGMTD_SUCCESS, NULL);
break;
case MGMTD_COMMIT_PHASE_MAX:
int num_processed = 0;
bool error;
- txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread);
+ txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn);
MGMTD_TXN_DBG(
int num_processed = 0;
bool error;
- txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread);
+ txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn);
MGMTD_TXN_DBG(
if ((*txn)->type == MGMTD_TXN_TYPE_CONFIG)
if (mgmt_txn_mm->cfg_txn == *txn)
mgmt_txn_mm->cfg_txn = NULL;
- THREAD_OFF((*txn)->proc_get_cfg);
- THREAD_OFF((*txn)->proc_get_data);
- THREAD_OFF((*txn)->proc_comm_cfg);
- THREAD_OFF((*txn)->comm_cfg_timeout);
+ EVENT_OFF((*txn)->proc_get_cfg);
+ EVENT_OFF((*txn)->proc_get_data);
+ EVENT_OFF((*txn)->proc_comm_cfg);
+ EVENT_OFF((*txn)->comm_cfg_timeout);
hash_release(mgmt_txn_mm->txn_hash, *txn);
mgmt_txns_del(&mgmt_txn_mm->txn_list, *txn);
{
struct mgmt_txn_ctx *txn;
- txn = (struct mgmt_txn_ctx *)THREAD_ARG(thread);
+ txn = (struct mgmt_txn_ctx *)EVENT_ARG(thread);
assert(txn);
mgmt_txn_cleanup_txn(&txn);
static void netlink_log_recv(struct event *t)
{
uint8_t buf[ZNL_BUFFER_SIZE];
- int fd = THREAD_FD(t);
+ int fd = EVENT_FD(t);
struct zbuf payload, zb;
struct nlmsghdr *n;
hash_release(nifp->cache_hash, c);
nhrp_peer_unref(c->cur.peer);
nhrp_peer_unref(c->new.peer);
- THREAD_OFF(c->t_timeout);
- THREAD_OFF(c->t_auth);
+ EVENT_OFF(c->t_timeout);
+ EVENT_OFF(c->t_auth);
XFREE(MTYPE_NHRP_CACHE, c);
}
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;
nhrp_cache_free(c);
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;
if (c->cur.type != NHRP_CACHE_INVALID)
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))
nhrp_peer_notify_del(c->new.peer, &c->newpeer_notifier);
nhrp_peer_unref(c->new.peer);
static void nhrp_cache_update_timers(struct nhrp_cache *c)
{
- THREAD_OFF(c->t_timeout);
+ EVENT_OFF(c->t_timeout);
switch (c->cur.type) {
case NHRP_CACHE_INVALID:
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;
nhrp_cache_authorize_binding(&c->eventid, (void *)"timeout");
}
static void evmgr_connection_error(struct event_manager *evmgr)
{
- THREAD_OFF(evmgr->t_read);
- THREAD_OFF(evmgr->t_write);
+ EVENT_OFF(evmgr->t_read);
+ EVENT_OFF(evmgr->t_write);
zbuf_reset(&evmgr->ibuf);
zbufq_reset(&evmgr->obuf);
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 msg;
static void evmgr_write(struct event *t)
{
- struct event_manager *evmgr = THREAD_ARG(t);
+ struct event_manager *evmgr = EVENT_ARG(t);
int r;
r = zbufq_write(&evmgr->obuf, evmgr->fd);
static void evmgr_reconnect(struct event *t)
{
- struct event_manager *evmgr = THREAD_ARG(t);
+ struct event_manager *evmgr = EVENT_ARG(t);
int fd;
if (evmgr->fd >= 0 || !nhrp_event_socket_path)
static void netlink_mcast_log_recv(struct event *t)
{
uint8_t buf[65535]; /* Max OSPF Packet size */
- int fd = THREAD_FD(t);
+ int fd = EVENT_FD(t);
struct zbuf payload, zb;
struct nlmsghdr *n;
void netlink_mcast_set_nflog_group(int nlgroup)
{
if (netlink_mcast_log_fd >= 0) {
- THREAD_OFF(netlink_mcast_log_thread);
+ EVENT_OFF(netlink_mcast_log_thread);
close(netlink_mcast_log_fd);
netlink_mcast_log_fd = -1;
debugf(NHRP_DEBUG_COMMON, "De-register nflog group");
/* Success - schedule next registration, and route NHS */
r->timeout = 2;
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
* every one third of holdtime */
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;
case NOTIFY_PEER_MTU_CHANGED:
debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %pSU",
&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,
&r->t_register);
break;
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 interface *ifp = nhs->ifp;
struct nhrp_interface *nifp = ifp->info;
nhrp_peer_notify_del(r->peer, &r->peer_notifier);
nhrp_peer_unref(r->peer);
nhrp_reglist_del(&r->nhs->reglist_head, r);
- THREAD_OFF(r->t_register);
+ EVENT_OFF(r->t_register);
XFREE(MTYPE_NHRP_REGISTRATION, r);
}
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,
nhs->nbma_fqdn, nhrp_nhs_resolve_cb);
frr_each_safe (nhrp_reglist, &nhs->reglist_head, r)
nhrp_reg_delete(r);
- THREAD_OFF(nhs->t_resolve);
+ EVENT_OFF(nhs->t_resolve);
nhrp_nhslist_del(&nifp->afi[afi].nhslist_head, nhs);
free((void *)nhs->nbma_fqdn);
XFREE(MTYPE_NHRP_NHS, nhs);
static void nhrp_packet_recvraw(struct event *t)
{
- int fd = THREAD_FD(t), ifindex;
+ int fd = EVENT_FD(t), ifindex;
struct zbuf *zb;
struct interface *ifp;
struct nhrp_peer *p;
debugf(NHRP_DEBUG_COMMON, "Deleting peer ref:%d remote:%pSU local:%pSU",
p->ref, &p->vc->remote.nbma, &p->vc->local.nbma);
- THREAD_OFF(p->t_fallback);
- THREAD_OFF(p->t_timer);
+ EVENT_OFF(p->t_fallback);
+ EVENT_OFF(p->t_timer);
hash_release(nifp->peer_hash, p);
nhrp_interface_notify_del(p->ifp, &p->ifp_notifier);
nhrp_vc_notify_del(p->vc, &p->vc_notifier);
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 interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info;
online = nifp->enabled && (!nifp->ipsec_profile || vc->ipsec);
if (p->online != online) {
- THREAD_OFF(p->t_fallback);
+ EVENT_OFF(p->t_fallback);
if (online && notifier_active(&p->notifier_list)) {
/* If we requested the IPsec connection, delay
* the up notification a bit to allow things
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 interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info;
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 interface *ifp = p->ifp;
struct nhrp_interface *nifp = ifp->info;
- THREAD_OFF(p->t_timer);
+ EVENT_OFF(p->t_timer);
if (p->online) {
debugf(NHRP_DEBUG_COMMON,
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,
&s->t_timer);
s->route_installed = 0;
}
- THREAD_OFF(s->t_timer);
+ EVENT_OFF(s->t_timer);
if (holding_time) {
s->expiring = 0;
s->holding_time = holding_time;
struct route_node *rn;
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);
debugf(NHRP_DEBUG_ROUTE, "Shortcut %pFX purged", s->p);
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;
nhrp_shortcut_delete(s);
}
int holding_time = pp->if_ad->holdtime;
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);
if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) {
s = nhrp_shortcut_get(&p);
if (s && s->type != NHRP_CACHE_INCOMPLETE) {
s->addr = *addr;
- THREAD_OFF(s->t_timer);
+ EVENT_OFF(s->t_timer);
event_add_timer(master, nhrp_shortcut_do_purge, s, 30,
&s->t_timer);
nhrp_shortcut_send_resolution_req(s);
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);
if (force) {
{
nhrp_vc_reset();
- THREAD_OFF(vici->t_read);
- THREAD_OFF(vici->t_write);
+ EVENT_OFF(vici->t_read);
+ EVENT_OFF(vici->t_write);
zbuf_reset(&vici->ibuf);
zbufq_reset(&vici->obuf);
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 pktbuf;
static void vici_write(struct event *t)
{
- struct vici_conn *vici = THREAD_ARG(t);
+ struct vici_conn *vici = EVENT_ARG(t);
int r;
r = zbufq_write(&vici->obuf, vici->fd);
static void vici_reconnect(struct event *t)
{
- struct vici_conn *vici = THREAD_ARG(t);
+ struct vici_conn *vici = EVENT_ARG(t);
int fd;
char *file_path;
ospf6_spf_table_finish(oa->spf_table);
ospf6_route_remove_all(oa->route_table);
- THREAD_OFF(oa->thread_router_lsa);
- THREAD_OFF(oa->thread_intra_prefix_lsa);
+ EVENT_OFF(oa->thread_router_lsa);
+ EVENT_OFF(oa->thread_intra_prefix_lsa);
}
struct ospf6_lsa *lsa;
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)
return;
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;
int type;
if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s: LSA found, refresh it",
__func__);
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh);
return;
lsa = ospf6_find_external_lsa(ospf6, &rt->prefix);
if (lsa) {
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa, 0,
&lsa->refresh);
} else {
static void ospf6_asbr_summary_process(struct event *thread)
{
- struct ospf6 *ospf6 = THREAD_ARG(thread);
+ struct ospf6 *ospf6 = EVENT_ARG(thread);
int operation = 0;
operation = ospf6->aggr_action;
if (IS_OSPF6_DEBUG_AGGR)
zlog_debug("%s, Restarting Aggregator delay timer.",
__func__);
- THREAD_OFF(ospf6->t_external_aggr);
+ EVENT_OFF(ospf6->t_external_aggr);
}
}
if (bss->state == BFD_STATUS_DOWN
&& 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);
}
}
lsdb_self = ospf6_get_scoped_lsdb_self(lsa);
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,
&lsa->refresh);
self = ospf6_lsdb_lookup(lsa->header->type, lsa->header->id,
lsa->header->adv_router, lsdb_self);
if (self) {
- THREAD_OFF(self->expire);
- THREAD_OFF(self->refresh);
+ EVENT_OFF(self->expire);
+ EVENT_OFF(self->refresh);
ospf6_lsdb_remove(self, lsdb_self);
}
lsa->name);
lsa->external_lsa_id = old->external_lsa_id;
}
- THREAD_OFF(old->expire);
- THREAD_OFF(old->refresh);
+ EVENT_OFF(old->expire);
+ EVENT_OFF(old->refresh);
ospf6_flood_clear(old);
}
} else {
/* reschedule retransmissions to all neighbors */
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,
on, 0, &on->thread_send_lsupdate);
}
ospf6->gr_info.restart_in_progress = false;
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. */
ospf6_gr_nvm_delete(ospf6);
/* Handling of grace period expiry. */
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");
}
*/
static void ospf6_handle_grace_timer_expiry(struct event *thread)
{
- struct ospf6_neighbor *nbr = THREAD_ARG(thread);
+ struct ospf6_neighbor *nbr = EVENT_ARG(thread);
ospf6_gr_helper_exit(nbr, OSPF6_GR_HELPER_GRACE_TIMEOUT);
}
}
if (OSPF6_GR_IS_ACTIVE_HELPER(restarter)) {
- THREAD_OFF(restarter->gr_helper_info.t_grace_timer);
+ EVENT_OFF(restarter->gr_helper_info.t_grace_timer);
if (ospf6->ospf6_helper_cfg.active_restarter_cnt > 0)
ospf6->ospf6_helper_cfg.active_restarter_cnt--;
* expiry, stop the grace timer.
*/
if (reason != OSPF6_GR_HELPER_GRACE_TIMEOUT)
- THREAD_OFF(nbr->gr_helper_info.t_grace_timer);
+ EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
if (ospf6->ospf6_helper_cfg.active_restarter_cnt <= 0) {
zlog_err(
list_delete(&oi->neighbor_list);
- THREAD_OFF(oi->thread_send_hello);
- THREAD_OFF(oi->thread_send_lsupdate);
- THREAD_OFF(oi->thread_send_lsack);
- THREAD_OFF(oi->thread_sso);
- THREAD_OFF(oi->thread_wait_timer);
+ EVENT_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_send_lsupdate);
+ EVENT_OFF(oi->thread_send_lsack);
+ EVENT_OFF(oi->thread_sso);
+ EVENT_OFF(oi->thread_wait_timer);
ospf6_lsdb_remove_all(oi->lsdb);
ospf6_lsdb_remove_all(oi->lsupdate_list);
ospf6_lsdb_remove_all(oi->lsupdate_list);
ospf6_lsdb_remove_all(oi->lsack_list);
- THREAD_OFF(oi->thread_send_hello);
- THREAD_OFF(oi->thread_send_lsupdate);
- THREAD_OFF(oi->thread_send_lsack);
- THREAD_OFF(oi->thread_sso);
+ EVENT_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_send_lsupdate);
+ EVENT_OFF(oi->thread_send_lsack);
+ EVENT_OFF(oi->thread_sso);
- THREAD_OFF(oi->thread_network_lsa);
- THREAD_OFF(oi->thread_link_lsa);
- THREAD_OFF(oi->thread_intra_prefix_lsa);
- THREAD_OFF(oi->thread_as_extern_lsa);
- THREAD_OFF(oi->thread_wait_timer);
+ EVENT_OFF(oi->thread_network_lsa);
+ EVENT_OFF(oi->thread_link_lsa);
+ EVENT_OFF(oi->thread_intra_prefix_lsa);
+ EVENT_OFF(oi->thread_as_extern_lsa);
+ EVENT_OFF(oi->thread_wait_timer);
}
static struct in6_addr *
struct ospf6_interface *oi;
struct ospf6 *ospf6;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi && oi->interface);
if (!oi->type_cfg)
{
struct ospf6_interface *oi;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
{
struct ospf6_interface *oi;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
{
struct ospf6_interface *oi;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
struct ospf6_neighbor *on;
struct ospf6 *ospf6;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi && oi->interface);
if (IS_OSPF6_DEBUG_INTERFACE)
oi->interface->name);
/* Stop Hellos */
- THREAD_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_send_hello);
/* Stop trying to set socket options. */
- THREAD_OFF(oi->thread_sso);
+ EVENT_OFF(oi->thread_sso);
/* Cease the HELPER role for all the neighbours
* of this interface.
/* re-establish adjacencies */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- THREAD_OFF(on->inactivity_timer);
+ EVENT_OFF(on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
/* re-establish adjacencies */
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- THREAD_OFF(on->inactivity_timer);
+ EVENT_OFF(on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
* If the thread is scheduled, send the new hello now.
*/
if (event_is_scheduled(oi->thread_send_hello)) {
- THREAD_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_send_hello);
event_add_timer(master, ospf6_hello_send, oi, 0,
&oi->thread_send_hello);
assert(oi);
SET_FLAG(oi->flag, OSPF6_INTERFACE_PASSIVE);
- THREAD_OFF(oi->thread_send_hello);
- THREAD_OFF(oi->thread_sso);
+ EVENT_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_sso);
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
- THREAD_OFF(on->inactivity_timer);
+ EVENT_OFF(on->inactivity_timer);
event_add_event(master, inactivity_timer, on, 0, NULL);
}
assert(oi);
UNSET_FLAG(oi->flag, OSPF6_INTERFACE_PASSIVE);
- THREAD_OFF(oi->thread_send_hello);
- THREAD_OFF(oi->thread_sso);
+ EVENT_OFF(oi->thread_send_hello);
+ EVENT_OFF(oi->thread_sso);
/* don't send hellos over loopback interface */
if (!if_is_loopback(oi->interface))
uint32_t router;
int count;
- oa = (struct ospf6_area *)THREAD_ARG(thread);
+ oa = (struct ospf6_area *)EVENT_ARG(thread);
if (oa->ospf6->gr_info.restart_in_progress) {
if (IS_DEBUG_OSPF6_GR)
struct listnode *i;
uint16_t type;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
/* The interface must be enabled until here. A Network-LSA of a
disabled interface (but was once enabled) should be flushed
struct ospf6_route *route;
struct ospf6_prefix *op;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi->area);
struct ospf6_route_table *route_advertise;
int ls_id = 0;
- oa = (struct ospf6_area *)THREAD_ARG(thread);
+ oa = (struct ospf6_area *)EVENT_ARG(thread);
if (oa->ospf6->gr_info.restart_in_progress) {
if (IS_DEBUG_OSPF6_GR)
char *start, *end, *current;
uint16_t type;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
assert(oi->area);
#define OSPF6_NETWORK_LSA_EXECUTE(oi) \
do { \
- THREAD_OFF((oi)->thread_network_lsa); \
+ EVENT_OFF((oi)->thread_network_lsa); \
event_execute(master, ospf6_network_lsa_originate, oi, 0); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_EXECUTE_TRANSIT(oi) \
do { \
- THREAD_OFF((oi)->thread_intra_prefix_lsa); \
+ EVENT_OFF((oi)->thread_intra_prefix_lsa); \
event_execute(master, \
ospf6_intra_prefix_lsa_originate_transit, oi, \
0); \
#define OSPF6_AS_EXTERN_LSA_EXECUTE(oi) \
do { \
- THREAD_OFF((oi)->thread_as_extern_lsa); \
+ EVENT_OFF((oi)->thread_as_extern_lsa); \
event_execute(master, ospf6_orig_as_external_lsa, oi, 0); \
} while (0)
if (IS_OSPF6_DEBUG_LSA_TYPE(lsa->header->type))
zlog_debug("LSA: Premature aging: %s", lsa->name);
- THREAD_OFF(lsa->expire);
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->expire);
+ EVENT_OFF(lsa->refresh);
/*
* We clear the LSA from the neighbor retx lists now because it
assert(lsa->lock == 0);
/* cancel threads */
- THREAD_OFF(lsa->expire);
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->expire);
+ EVENT_OFF(lsa->refresh);
/* do free */
XFREE(MTYPE_OSPF6_LSA_HEADER, lsa->header);
struct ospf6_lsa *lsa;
struct ospf6 *ospf6;
- lsa = (struct ospf6_lsa *)THREAD_ARG(thread);
+ lsa = (struct ospf6_lsa *)EVENT_ARG(thread);
assert(lsa && lsa->header);
assert(OSPF6_LSA_IS_MAXAGE(lsa));
struct ospf6_lsa *old, *self, *new;
struct ospf6_lsdb *lsdb_self;
- old = (struct ospf6_lsa *)THREAD_ARG(thread);
+ old = (struct ospf6_lsa *)EVENT_ARG(thread);
assert(old && old->header);
old->refresh = (struct event *)NULL;
htonl(OSPF_MAX_SEQUENCE_NUMBER + 1);
ospf6_lsa_checksum(lsa->header);
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->refresh);
event_execute(master, ospf6_lsa_refresh, lsa, 0);
} else {
zlog_debug("calling ospf6_lsdb_remove %s", lsa->name);
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
/* More bit check */
if (!CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT)
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV_HDR))
zlog_debug(
"Duplicated dbdesc causes retransmit");
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
return;
if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV_HDR))
zlog_debug(
"Duplicated dbdesc causes retransmit");
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
return;
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send_newone, on, 0,
&on->thread_send_dbdesc);
assert(p == OSPF6_MESSAGE_END(oh));
/* schedule send lsupdate */
- THREAD_OFF(on->thread_send_lsupdate);
+ EVENT_OFF(on->thread_send_lsupdate);
event_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
&on->thread_send_lsupdate);
}
int count = 0;
/* add next read thread */
- ospf6 = THREAD_ARG(thread);
- sockfd = THREAD_FD(thread);
+ ospf6 = EVENT_ARG(thread);
+ sockfd = EVENT_FD(thread);
event_add_read(master, ospf6_receive, ospf6, ospf6->fd,
&ospf6->t_ospf6_receive);
static void ospf6_write(struct event *thread)
{
- struct ospf6 *ospf6 = THREAD_ARG(thread);
+ struct ospf6 *ospf6 = EVENT_ARG(thread);
struct ospf6_interface *oi;
struct ospf6_header *oh;
struct ospf6_packet *op;
struct ospf6_packet *op;
uint16_t length = OSPF6_HEADER_SIZE;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
if (oi->state <= OSPF6_INTERFACE_DOWN) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_HELLO, SEND_HDR))
uint16_t length = OSPF6_HEADER_SIZE;
struct ospf6_packet *op;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
if (on->state < OSPF6_NEIGHBOR_EXSTART) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_DBDESC, SEND))
struct ospf6_lsa *lsa, *lsanext;
unsigned int size = 0;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
ospf6_lsdb_remove_all(on->dbdesc_list);
/* move LSAs from summary_list to dbdesc_list (within neighbor
struct ospf6_packet *op;
uint16_t length = OSPF6_HEADER_SIZE;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
/* LSReq will be sent only in ExStart or Loading */
if (on->state != OSPF6_NEIGHBOR_EXCHANGE
uint16_t length = OSPF6_HEADER_SIZE;
int lsa_cnt = 0;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND_HDR))
zlog_debug("LSUpdate to neighbor %s", on->name);
uint16_t length = OSPF6_HEADER_SIZE;
int lsa_cnt = 0;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
if (oi->state <= OSPF6_INTERFACE_WAITING) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE,
struct ospf6_packet *op;
uint16_t length = OSPF6_HEADER_SIZE;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
if (on->state < OSPF6_NEIGHBOR_EXCHANGE) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSACK, SEND_HDR))
> ospf6_packet_max(oi)) {
/* if we run out of packet size/space here,
better to try again soon. */
- THREAD_OFF(oi->thread_send_lsack);
+ EVENT_OFF(oi->thread_send_lsack);
event_add_event(master, ospf6_lsack_send_interface, oi,
0, &oi->thread_send_lsack);
struct ospf6_packet *op;
uint16_t length = OSPF6_HEADER_SIZE;
- oi = (struct ospf6_interface *)THREAD_ARG(thread);
+ oi = (struct ospf6_interface *)EVENT_ARG(thread);
if (oi->state <= OSPF6_INTERFACE_WAITING) {
if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSACK, SEND_HDR))
ospf6_lsdb_delete(on->lsupdate_list);
ospf6_lsdb_delete(on->lsack_list);
- THREAD_OFF(on->inactivity_timer);
+ EVENT_OFF(on->inactivity_timer);
- THREAD_OFF(on->last_dbdesc_release_timer);
+ EVENT_OFF(on->last_dbdesc_release_timer);
- THREAD_OFF(on->thread_send_dbdesc);
- THREAD_OFF(on->thread_send_lsreq);
- THREAD_OFF(on->thread_send_lsupdate);
- THREAD_OFF(on->thread_send_lsack);
- THREAD_OFF(on->thread_exchange_done);
- THREAD_OFF(on->thread_adj_ok);
+ EVENT_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_lsreq);
+ EVENT_OFF(on->thread_send_lsupdate);
+ EVENT_OFF(on->thread_send_lsack);
+ EVENT_OFF(on->thread_exchange_done);
+ EVENT_OFF(on->thread_adj_ok);
- THREAD_OFF(on->gr_helper_info.t_grace_timer);
+ EVENT_OFF(on->gr_helper_info.t_grace_timer);
bfd_sess_free(&on->bfd_session);
XFREE(MTYPE_OSPF6_NEIGHBOR, on);
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *HelloReceived*", on->name);
/* reset Inactivity Timer */
- THREAD_OFF(on->inactivity_timer);
+ EVENT_OFF(on->inactivity_timer);
event_add_timer(master, inactivity_timer, on,
on->ospf6_if->dead_interval, &on->inactivity_timer);
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state > OSPF6_NEIGHBOR_INIT)
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
}
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa, *lsanext;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state != OSPF6_NEIGHBOR_EXSTART)
static void ospf6_neighbor_last_dbdesc_release(struct event *thread)
{
- struct ospf6_neighbor *on = THREAD_ARG(thread);
+ struct ospf6_neighbor *on = EVENT_ARG(thread);
assert(on);
memset(&on->dbdesc_last, 0, sizeof(struct ospf6_dbdesc));
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state != OSPF6_NEIGHBOR_EXCHANGE)
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
zlog_debug("Neighbor Event %s: *ExchangeDone*", on->name);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
ospf6_lsdb_remove_all(on->dbdesc_list);
/* RFC 2328 (10.8): Release the last dbdesc after dead_interval */
if (!CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT)) {
- THREAD_OFF(on->last_dbdesc_release_timer);
+ EVENT_OFF(on->last_dbdesc_release_timer);
event_add_timer(master, ospf6_neighbor_last_dbdesc_release, on,
on->ospf6_if->dead_interval,
&on->last_dbdesc_release_timer);
if (on->request_list->count == 0)
event_add_event(master, loading_done, on, 0, NULL);
else if (on->last_ls_req == NULL) {
- THREAD_OFF(on->thread_send_lsreq);
+ EVENT_OFF(on->thread_send_lsreq);
event_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
}
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state != OSPF6_NEIGHBOR_LOADING)
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
event_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state < OSPF6_NEIGHBOR_EXCHANGE)
ospf6_neighbor_clear_ls_lists(on);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
event_add_event(master, ospf6_dbdesc_send, on, 0,
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state < OSPF6_NEIGHBOR_EXCHANGE)
ospf6_neighbor_clear_ls_lists(on);
- THREAD_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
event_add_event(master, ospf6_dbdesc_send, on, 0,
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
ospf6_neighbor_clear_ls_lists(on);
- THREAD_OFF(on->thread_send_dbdesc);
- THREAD_OFF(on->thread_send_lsreq);
- THREAD_OFF(on->thread_send_lsupdate);
- THREAD_OFF(on->thread_send_lsack);
- THREAD_OFF(on->thread_exchange_done);
- THREAD_OFF(on->thread_adj_ok);
+ EVENT_OFF(on->thread_send_dbdesc);
+ EVENT_OFF(on->thread_send_lsreq);
+ EVENT_OFF(on->thread_send_lsupdate);
+ EVENT_OFF(on->thread_send_lsack);
+ EVENT_OFF(on->thread_exchange_done);
+ EVENT_OFF(on->thread_adj_ok);
}
void inactivity_timer(struct event *thread)
{
struct ospf6_neighbor *on;
- on = (struct ospf6_neighbor *)THREAD_ARG(thread);
+ on = (struct ospf6_neighbor *)EVENT_ARG(thread);
assert(on);
if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT))
/* This function performs ABR related processing */
static void ospf6_abr_task_timer(struct event *thread)
{
- struct ospf6 *ospf6 = THREAD_ARG(thread);
+ struct ospf6 *ospf6 = EVENT_ARG(thread);
if (IS_OSPF6_DEBUG_ABR)
zlog_debug("Running ABR task on timer");
route->path.origin.id, o->router_id,
o->lsdb);
if (old) {
- THREAD_OFF(old->refresh);
+ EVENT_OFF(old->refresh);
event_add_event(master, ospf6_lsa_refresh, old, 0,
&old->refresh);
} else {
lsa)) {
if (IS_OSPF6_DEBUG_NSSA)
ospf6_lsa_header_print(lsa);
- THREAD_OFF(lsa->refresh);
+ EVENT_OFF(lsa->refresh);
event_add_event(master, ospf6_lsa_refresh, lsa,
0, &lsa->refresh);
}
int areas_processed = 0;
char rbuf[32];
- ospf6 = (struct ospf6 *)THREAD_ARG(t);
+ ospf6 = (struct ospf6 *)EVENT_ARG(t);
/* execute SPF calculation */
monotime(&start);
if (IS_OSPF6_DEBUG_SPF(PROCESS) || IS_OSPF6_DEBUG_SPF(TIME))
zlog_debug("SPF: Rescheduling in %ld msec", delay);
- THREAD_OFF(ospf6->t_spf_calc);
+ EVENT_OFF(ospf6->t_spf_calc);
event_add_timer_msec(master, ospf6_spf_calculation_thread, ospf6, delay,
&ospf6->t_spf_calc);
}
struct ospf6_area *area;
uint16_t type;
- ospf6 = THREAD_ARG(t);
+ ospf6 = EVENT_ARG(t);
/* Calculate external route for each AS-external-LSA */
type = htons(OSPF6_LSTYPE_AS_EXTERNAL);
ospf6_route_remove_all(o->route_table);
ospf6_route_remove_all(o->brouter_table);
- THREAD_OFF(o->maxage_remover);
- THREAD_OFF(o->t_spf_calc);
- THREAD_OFF(o->t_ase_calc);
- THREAD_OFF(o->t_distribute_update);
- THREAD_OFF(o->t_ospf6_receive);
- THREAD_OFF(o->t_external_aggr);
- THREAD_OFF(o->gr_info.t_grace_period);
- THREAD_OFF(o->t_write);
- THREAD_OFF(o->t_abr_task);
+ EVENT_OFF(o->maxage_remover);
+ EVENT_OFF(o->t_spf_calc);
+ EVENT_OFF(o->t_ase_calc);
+ EVENT_OFF(o->t_distribute_update);
+ EVENT_OFF(o->t_ospf6_receive);
+ EVENT_OFF(o->t_external_aggr);
+ EVENT_OFF(o->gr_info.t_grace_period);
+ EVENT_OFF(o->t_write);
+ EVENT_OFF(o->t_abr_task);
}
}
static void ospf6_maxage_remover(struct event *thread)
{
- struct ospf6 *o = (struct ospf6 *)THREAD_ARG(thread);
+ struct ospf6 *o = (struct ospf6 *)EVENT_ARG(thread);
struct ospf6_area *oa;
struct ospf6_interface *oi;
struct ospf6_neighbor *on;
struct in_addr area_id;
int rc;
- oclient = THREAD_ARG(t);
+ oclient = EVENT_ARG(t);
rc = inet_aton(args[6], &area_id);
if (rc <= 0) {
static uint32_t counter = 1; /* Incremented each time invoked */
int rc;
- cl = THREAD_ARG(t);
+ cl = EVENT_ARG(t);
rc = inet_aton(args[5], &ifaddr);
if (rc <= 0) {
printf("lsa_read called\n");
- oclient = THREAD_ARG(thread);
- fd = THREAD_FD(thread);
+ oclient = EVENT_ARG(thread);
+ fd = EVENT_FD(thread);
/* Handle asynchronous message */
ret = ospf_apiclient_handle_async(oclient);
{
struct ospf_area *area;
struct listnode *node;
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
- THREAD_OFF(ospf->t_abr_fr);
+ EVENT_OFF(ospf->t_abr_fr);
if (!IS_OSPF_ABR(ospf))
return;
static void ospf_abr_task_timer(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
ospf->t_abr_task = 0;
struct listnode *node;
/* Cancel read and write threads. */
- THREAD_OFF(apiserv->t_sync_read);
+ EVENT_OFF(apiserv->t_sync_read);
#ifdef USE_ASYNC_READ
- THREAD_OFF(apiserv->t_async_read);
+ EVENT_OFF(apiserv->t_async_read);
#endif /* USE_ASYNC_READ */
- THREAD_OFF(apiserv->t_sync_write);
- THREAD_OFF(apiserv->t_async_write);
+ EVENT_OFF(apiserv->t_sync_write);
+ EVENT_OFF(apiserv->t_async_write);
/* Unregister all opaque types that application registered
and flush opaque LSAs if still in LSDB. */
int fd;
enum ospf_apiserver_event event;
- apiserv = THREAD_ARG(thread);
- fd = THREAD_FD(thread);
+ apiserv = EVENT_ARG(thread);
+ fd = EVENT_FD(thread);
if (fd == apiserv->fd_sync) {
event = OSPF_APISERVER_SYNC_READ;
int fd;
int rc = -1;
- apiserv = THREAD_ARG(thread);
+ apiserv = EVENT_ARG(thread);
assert(apiserv);
- fd = THREAD_FD(thread);
+ fd = EVENT_FD(thread);
apiserv->t_sync_write = NULL;
int fd;
int rc = -1;
- apiserv = THREAD_ARG(thread);
+ apiserv = EVENT_ARG(thread);
assert(apiserv);
- fd = THREAD_FD(thread);
+ fd = EVENT_FD(thread);
apiserv->t_async_write = NULL;
unsigned int peerlen;
int ret;
- /* THREAD_ARG (thread) is NULL */
- accept_sock = THREAD_FD(thread);
+ /* EVENT_ARG (thread) is NULL */
+ accept_sock = EVENT_FD(thread);
/* Keep hearing on socket for further connections. */
ospf_apiserver_event(OSPF_APISERVER_ACCEPT, accept_sock, NULL);
*/
static void ospf_asbr_nssa_redist_update_timer(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
int type;
ospf->t_asbr_nssa_redist_update = NULL;
static void ospf_asbr_external_aggr_process(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
int operation = 0;
ospf->t_external_aggr = NULL;
zlog_debug(
"%s, Restarting Aggregator delay timer.",
__func__);
- THREAD_OFF(ospf->t_external_aggr);
+ EVENT_OFF(ospf->t_external_aggr);
}
}
struct ospf_area *area;
struct timeval start_time, stop_time;
- ospf = THREAD_ARG(t);
+ ospf = EVENT_ARG(t);
ospf->t_ase_calc = NULL;
if (ospf->ase_calc) {
zlog_debug("GR: exiting graceful restart: %s", reason);
ospf->gr_info.restart_in_progress = false;
- THREAD_OFF(ospf->gr_info.t_grace_period);
+ EVENT_OFF(ospf->gr_info.t_grace_period);
/* Record in non-volatile memory that the restart is complete. */
ospf_gr_nvm_delete(ospf);
/* Handling of grace period expiry. */
static void ospf_gr_grace_period_expired(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
ospf->gr_info.t_grace_period = NULL;
ospf_gr_restart_exit(ospf, "grace period has expired");
*/
static void ospf_handle_grace_timer_expiry(struct event *thread)
{
- struct ospf_neighbor *nbr = THREAD_ARG(thread);
+ struct ospf_neighbor *nbr = EVENT_ARG(thread);
nbr->gr_helper_info.t_grace_timer = NULL;
if (OSPF_GR_IS_ACTIVE_HELPER(restarter)) {
if (restarter->gr_helper_info.t_grace_timer)
- THREAD_OFF(restarter->gr_helper_info.t_grace_timer);
+ EVENT_OFF(restarter->gr_helper_info.t_grace_timer);
if (ospf->active_restarter_cnt > 0)
ospf->active_restarter_cnt--;
* expiry, stop the grace timer.
*/
if (reason != OSPF_GR_HELPER_GRACE_TIMEOUT)
- THREAD_OFF(nbr->gr_helper_info.t_grace_timer);
+ EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
/* check exit triggered due to successful completion
* of graceful restart.
/* oi->nbrs and oi->nbr_nbma should be deleted on InterfaceDown event */
/* delete all static neighbors attached to this interface */
for (ALL_LIST_ELEMENTS(oi->nbr_nbma, node, nnode, nbr_nbma)) {
- THREAD_OFF(nbr_nbma->t_poll);
+ EVENT_OFF(nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
if (oi->on_write_q) {
listnode_delete(ospf->oi_write_q, oi);
if (list_isempty(ospf->oi_write_q))
- THREAD_OFF(ospf->t_write);
+ EVENT_OFF(ospf->t_write);
oi->on_write_q = 0;
}
}
ospf_hello_send(oi);
/* Restart hello timer for this interface */
- THREAD_OFF(oi->t_hello);
+ EVENT_OFF(oi->t_hello);
OSPF_HELLO_TIMER_ON(oi);
}
ospf_hello_send(oi);
/* Restart the hello timer. */
- THREAD_OFF(oi->t_hello);
+ EVENT_OFF(oi->t_hello);
OSPF_HELLO_TIMER_ON(oi);
}
}
{
struct ospf_interface *oi;
- oi = THREAD_ARG(thread);
+ oi = EVENT_ARG(thread);
oi->t_hello = NULL;
if (IS_DEBUG_OSPF(ism, ISM_TIMERS))
{
struct ospf_interface *oi;
- oi = THREAD_ARG(thread);
+ oi = EVENT_ARG(thread);
oi->t_wait = NULL;
if (IS_DEBUG_OSPF(ism, ISM_TIMERS))
interface parameters must be set to initial values, and
timers are
reset also. */
- THREAD_OFF(oi->t_hello);
- THREAD_OFF(oi->t_wait);
- THREAD_OFF(oi->t_ls_ack);
+ EVENT_OFF(oi->t_hello);
+ EVENT_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_ls_ack);
break;
case ISM_Loopback:
/* In this state, the interface may be looped back and will be
unavailable for regular data traffic. */
- THREAD_OFF(oi->t_hello);
- THREAD_OFF(oi->t_wait);
- THREAD_OFF(oi->t_ls_ack);
+ EVENT_OFF(oi->t_hello);
+ EVENT_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_ls_ack);
break;
case ISM_Waiting:
/* The router is trying to determine the identity of DRouter and
OSPF_ISM_TIMER_MSEC_ON(oi->t_hello, ospf_hello_timer, 1);
OSPF_ISM_TIMER_ON(oi->t_wait, ospf_wait_timer,
OSPF_IF_PARAM(oi, v_wait));
- THREAD_OFF(oi->t_ls_ack);
+ EVENT_OFF(oi->t_ls_ack);
break;
case ISM_PointToPoint:
/* The interface connects to a physical Point-to-point network
neighboring router. Hello packets are also sent. */
/* send first hello immediately */
OSPF_ISM_TIMER_MSEC_ON(oi->t_hello, ospf_hello_timer, 1);
- THREAD_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_wait);
OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer,
oi->v_ls_ack);
break;
and the router itself is neither Designated Router nor
Backup Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- THREAD_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_wait);
OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer,
oi->v_ls_ack);
break;
network,
and the router is Backup Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- THREAD_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_wait);
OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer,
oi->v_ls_ack);
break;
network,
and the router is Designated Router. */
OSPF_HELLO_TIMER_ON(oi);
- THREAD_OFF(oi->t_wait);
+ EVENT_OFF(oi->t_wait);
OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer,
oi->v_ls_ack);
break;
int next_state;
struct ospf_interface *oi;
- oi = THREAD_ARG(thread);
- event = THREAD_VAL(thread);
+ oi = EVENT_ARG(thread);
+ event = EVENT_VAL(thread);
/* Call function. */
next_state = (*(ISM[oi->state][event].func))(oi);
if (ldp_sync_info && ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED) {
if (ldp_sync_info->state == LDP_IGP_SYNC_STATE_REQUIRED_NOT_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);
ospf_if_recalculate_output_cost(ifp);
}
}
if (ldp_sync_info &&
ldp_sync_info->enabled == LDP_IGP_SYNC_ENABLED &&
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;
ospf_if_recalculate_output_cost(ifp);
}
*/
ols_debug("%s: Removed from if %s", __func__, ifp->name);
- THREAD_OFF(ldp_sync_info->t_holddown);
+ EVENT_OFF(ldp_sync_info->t_holddown);
ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
ospf_if_recalculate_output_cost(ifp);
* didn't receive msg from LDP indicating sync-complete
* restore interface cost to original value
*/
- ifp = THREAD_ARG(thread);
+ ifp = EVENT_ARG(thread);
params = IF_DEF_PARAMS(ifp);
if (params->ldp_sync_info) {
ldp_sync_info = params->ldp_sync_info;
SET_FLAG(ldp_sync_info->flags, LDP_SYNC_FLAG_IF_CONFIG);
ldp_sync_info->enabled = LDP_IGP_SYNC_DEFAULT;
ldp_sync_info->state = LDP_IGP_SYNC_STATE_NOT_REQUIRED;
- THREAD_OFF(ldp_sync_info->t_holddown);
+ EVENT_OFF(ldp_sync_info->t_holddown);
ospf_if_recalculate_output_cost(ifp);
return CMD_SUCCESS;
static void ospf_stub_router_timer(struct event *t)
{
- struct ospf_area *area = THREAD_ARG(t);
+ struct ospf_area *area = EVENT_ARG(t);
area->t_stub_router = NULL;
void ospf_maxage_lsa_remover(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
struct ospf_lsa *lsa, *old;
struct route_node *rn;
int reschedule = 0;
/* Periodical check of MaxAge LSA. */
void ospf_lsa_maxage_walker(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
struct route_node *rn;
struct ospf_lsa *lsa;
struct ospf_area *area;
* without conflicting to other threads.
*/
if (ospf->t_maxage != NULL) {
- THREAD_OFF(ospf->t_maxage);
+ EVENT_OFF(ospf->t_maxage);
event_execute(master, ospf_maxage_lsa_remover, ospf, 0);
}
{
struct lsa_action *data;
- data = THREAD_ARG(t);
+ data = EVENT_ARG(t);
if (IS_DEBUG_OSPF(lsa, LSA) == OSPF_DEBUG_LSA)
zlog_debug("LSA[Action]: Performing scheduled LSA action: %d",
{
struct list *refresh_list;
struct listnode *node, *nnode;
- struct ospf *ospf = THREAD_ARG(t);
+ struct ospf *ospf = EVENT_ARG(t);
struct ospf_lsa *lsa;
int i;
struct list *lsa_to_refresh = list_new();
}
/* Cancel all timers. */
- THREAD_OFF(nbr->t_inactivity);
- THREAD_OFF(nbr->t_db_desc);
- THREAD_OFF(nbr->t_ls_req);
- THREAD_OFF(nbr->t_ls_upd);
+ EVENT_OFF(nbr->t_inactivity);
+ EVENT_OFF(nbr->t_db_desc);
+ EVENT_OFF(nbr->t_ls_req);
+ EVENT_OFF(nbr->t_ls_upd);
/* Cancel all events. */ /* Thread lookup cost would be negligible. */
event_cancel_event(master, nbr);
bfd_sess_free(&nbr->bfd_session);
- THREAD_OFF(nbr->gr_helper_info.t_grace_timer);
+ EVENT_OFF(nbr->gr_helper_info.t_grace_timer);
nbr->oi = NULL;
XFREE(MTYPE_OSPF_NEIGHBOR, nbr);
nbr->nbr_nbma = nbr_nbma;
if (nbr_nbma->t_poll)
- THREAD_OFF(nbr_nbma->t_poll);
+ EVENT_OFF(nbr_nbma->t_poll);
nbr->state_change = nbr_nbma->state_change + 1;
}
{
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
nbr->t_inactivity = NULL;
if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
{
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
nbr->t_db_desc = NULL;
if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
switch (nbr->state) {
case NSM_Deleted:
case NSM_Down:
- THREAD_OFF(nbr->t_inactivity);
- THREAD_OFF(nbr->t_hello_reply);
+ EVENT_OFF(nbr->t_inactivity);
+ EVENT_OFF(nbr->t_hello_reply);
/* fallthru */
case NSM_Attempt:
case NSM_Init:
case NSM_TwoWay:
- THREAD_OFF(nbr->t_db_desc);
- THREAD_OFF(nbr->t_ls_upd);
- THREAD_OFF(nbr->t_ls_req);
+ EVENT_OFF(nbr->t_db_desc);
+ EVENT_OFF(nbr->t_ls_upd);
+ EVENT_OFF(nbr->t_ls_req);
break;
case NSM_ExStart:
OSPF_NSM_TIMER_ON(nbr->t_db_desc, ospf_db_desc_timer,
nbr->v_db_desc);
- THREAD_OFF(nbr->t_ls_upd);
- THREAD_OFF(nbr->t_ls_req);
+ EVENT_OFF(nbr->t_ls_upd);
+ EVENT_OFF(nbr->t_ls_req);
break;
case NSM_Exchange:
OSPF_NSM_TIMER_ON(nbr->t_ls_upd, ospf_ls_upd_timer,
nbr->v_ls_upd);
if (!IS_SET_DD_MS(nbr->dd_flags))
- THREAD_OFF(nbr->t_db_desc);
+ EVENT_OFF(nbr->t_db_desc);
break;
case NSM_Loading:
case NSM_Full:
default:
- THREAD_OFF(nbr->t_db_desc);
+ EVENT_OFF(nbr->t_db_desc);
break;
}
}
static int nsm_hello_received(struct ospf_neighbor *nbr)
{
/* Start or Restart Inactivity Timer. */
- THREAD_OFF(nbr->t_inactivity);
+ EVENT_OFF(nbr->t_inactivity);
OSPF_NSM_TIMER_ON(nbr->t_inactivity, ospf_inactivity_timer,
nbr->v_inactivity);
if (nbr->oi->type == OSPF_IFTYPE_NBMA && nbr->nbr_nbma)
- THREAD_OFF(nbr->nbr_nbma->t_poll);
+ EVENT_OFF(nbr->nbr_nbma->t_poll);
/* Send proactive ARP requests */
if (nbr->state < NSM_Exchange)
static int nsm_start(struct ospf_neighbor *nbr)
{
if (nbr->nbr_nbma)
- THREAD_OFF(nbr->nbr_nbma->t_poll);
+ EVENT_OFF(nbr->nbr_nbma->t_poll);
- THREAD_OFF(nbr->t_inactivity);
+ EVENT_OFF(nbr->t_inactivity);
OSPF_NSM_TIMER_ON(nbr->t_inactivity, ospf_inactivity_timer,
nbr->v_inactivity);
int next_state;
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
- event = THREAD_VAL(thread);
+ nbr = EVENT_ARG(thread);
+ event = EVENT_VAL(thread);
if (IS_DEBUG_OSPF(nsm, NSM_EVENTS))
zlog_debug("NSM[%s:%pI4:%s]: %s (%s)", IF_NAME(nbr->oi),
void ospf_opaque_type9_lsa_term(struct ospf_interface *oi)
{
- THREAD_OFF(oi->t_opaque_lsa_self);
+ EVENT_OFF(oi->t_opaque_lsa_self);
if (oi->opaque_lsa_self != NULL)
list_delete(&oi->opaque_lsa_self);
oi->opaque_lsa_self = NULL;
area->lsdb->new_lsa_hook = area->lsdb->del_lsa_hook = NULL;
#endif /* MONITOR_LSDB_CHANGE */
- THREAD_OFF(area->t_opaque_lsa_self);
+ EVENT_OFF(area->t_opaque_lsa_self);
if (area->opaque_lsa_self != NULL)
list_delete(&area->opaque_lsa_self);
return;
top->lsdb->new_lsa_hook = top->lsdb->del_lsa_hook = NULL;
#endif /* MONITOR_LSDB_CHANGE */
- THREAD_OFF(top->t_opaque_lsa_self);
+ EVENT_OFF(top->t_opaque_lsa_self);
if (top->opaque_lsa_self != NULL)
list_delete(&top->opaque_lsa_self);
return;
ospf_opaque_lsa_flush_schedule(lsa);
}
- THREAD_OFF(oipt->t_opaque_lsa_self);
+ EVENT_OFF(oipt->t_opaque_lsa_self);
list_delete(&oipt->id_list);
if (cleanup_owner) {
/* Remove from its owner's self-originated LSA list. */
{
struct opaque_info_per_id *oipi = (struct opaque_info_per_id *)val;
- THREAD_OFF(oipi->t_opaque_lsa_self);
+ EVENT_OFF(oipi->t_opaque_lsa_self);
if (oipi->lsa != NULL)
ospf_lsa_unlock(&oipi->lsa);
XFREE(MTYPE_OPAQUE_INFO_PER_ID, oipi);
{
struct ospf_interface *oi;
- oi = THREAD_ARG(t);
+ oi = EVENT_ARG(t);
oi->t_opaque_lsa_self = NULL;
if (IS_DEBUG_OSPF_EVENT)
{
struct ospf_area *area;
- area = THREAD_ARG(t);
+ area = EVENT_ARG(t);
area->t_opaque_lsa_self = NULL;
if (IS_DEBUG_OSPF_EVENT)
{
struct ospf *top;
- top = THREAD_ARG(t);
+ top = EVENT_ARG(t);
top->t_opaque_lsa_self = NULL;
if (IS_DEBUG_OSPF_EVENT)
struct ospf *top;
struct ospf_interface *oi;
- oipt = THREAD_ARG(t);
+ oipt = EVENT_ARG(t);
if ((functab = oipt->functab) == NULL
|| functab->lsa_originator == NULL) {
struct ospf_interface *oi;
int n;
- oipt = THREAD_ARG(t);
+ oipt = EVENT_ARG(t);
if ((functab = oipt->functab) == NULL
|| functab->lsa_originator == NULL) {
struct ospf_opaque_functab *functab;
struct ospf *top;
- oipt = THREAD_ARG(t);
+ oipt = EVENT_ARG(t);
if ((functab = oipt->functab) == NULL
|| functab->lsa_originator == NULL) {
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("Timer[Opaque-LSA]: (Opaque-LSA Refresh expire)");
- oipi = THREAD_ARG(t);
+ oipi = EVENT_ARG(t);
if ((lsa = oipi->lsa) != NULL)
if ((functab = oipi->opqctl_type->functab) != NULL)
{
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
nbr->t_ls_req = NULL;
/* Send Link State Request. */
void ospf_ls_req_event(struct ospf_neighbor *nbr)
{
- THREAD_OFF(nbr->t_ls_req);
+ EVENT_OFF(nbr->t_ls_req);
event_add_event(master, ospf_ls_req_timer, nbr, 0, &nbr->t_ls_req);
}
{
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
nbr->t_ls_upd = NULL;
/* Send Link State Update. */
{
struct ospf_interface *oi;
- oi = THREAD_ARG(thread);
+ oi = EVENT_ARG(thread);
oi->t_ls_ack = NULL;
/* Send Link State Acknowledgment. */
static void ospf_write(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
struct ospf_interface *oi;
struct ospf_packet *op;
struct sockaddr_in sa_dst;
enum ospf_read_return_enum ret;
/* first of all get interface pointer. */
- ospf = THREAD_ARG(thread);
+ ospf = EVENT_ARG(thread);
/* prepare for next packet. */
event_add_read(master, ospf_read, ospf, ospf->fd, &ospf->t_read);
{
struct ospf_nbr_nbma *nbr_nbma;
- nbr_nbma = THREAD_ARG(thread);
+ nbr_nbma = EVENT_ARG(thread);
nbr_nbma->t_poll = NULL;
if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
{
struct ospf_neighbor *nbr;
- nbr = THREAD_ARG(thread);
+ nbr = EVENT_ARG(thread);
nbr->t_hello_reply = NULL;
if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
* is actually turned off.
*/
if (list_isempty(oi->ospf->oi_write_q))
- THREAD_OFF(oi->ospf->t_write);
+ EVENT_OFF(oi->ospf->t_write);
} else {
/* Hook thread to write packet. */
OSPF_ISM_WRITE_ON(oi->ospf);
static void ospf_ls_upd_send_queue_event(struct event *thread)
{
- struct ospf_interface *oi = THREAD_ARG(thread);
+ struct ospf_interface *oi = EVENT_ARG(thread);
struct route_node *rn;
struct route_node *rnext;
struct list *update;
static void ospf_ls_ack_send_event(struct event *thread)
{
- struct ospf_interface *oi = THREAD_ARG(thread);
+ struct ospf_interface *oi = EVENT_ARG(thread);
oi->t_ls_ack_direct = NULL;
/* Worker for SPF calculation scheduler. */
static void ospf_spf_calculate_schedule_worker(struct event *thread)
{
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
struct route_table *new_table, *new_rtrs;
struct route_table *all_rtrs = NULL;
struct timeval start_time, spf_start_time;
{
struct ospf *ospf;
- ospf = THREAD_ARG(start);
+ ospf = EVENT_ARG(start);
/* re-attempt to start SR & Label Manager connection */
ospf_sr_start(ospf);
osr_debug("SR (%s): Stop Segment Routing", __func__);
/* Disable any re-attempt to connect to Label Manager */
- THREAD_OFF(OspfSR.t_start_lm);
+ EVENT_OFF(OspfSR.t_start_lm);
/* Release SRGB if active */
sr_global_block_delete();
for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
SET_FLAG(area->stub_router_state,
OSPF_AREA_WAS_START_STUB_ROUTED);
- THREAD_OFF(area->t_stub_router);
+ EVENT_OFF(area->t_stub_router);
/* Don't trample on admin stub routed */
if (!CHECK_FLAG(area->stub_router_state,
else
ospf->maxage_delay = value;
- THREAD_OFF(ospf->t_maxage);
+ EVENT_OFF(ospf->t_maxage);
OSPF_TIMER_ON(ospf->t_maxage, ospf_maxage_lsa_remover,
ospf->maxage_delay);
static void ospf_external_lsa_default_routemap_timer(struct event *thread)
{
struct list *ext_list;
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
struct prefix_ipv4 p;
int type;
int ret = 0;
struct route_table *rt;
struct ospf_lsa *lsa;
int type, default_refresh = 0;
- struct ospf *ospf = THREAD_ARG(thread);
+ struct ospf *ospf = EVENT_ARG(thread);
if (ospf == NULL)
return;
static void ospf_deferred_shutdown_finish(struct ospf *ospf)
{
ospf->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
- THREAD_OFF(ospf->t_deferred_shutdown);
+ EVENT_OFF(ospf->t_deferred_shutdown);
ospf_finish_final(ospf);
/* Timer thread for G-R */
static void ospf_deferred_shutdown_timer(struct event *t)
{
- struct ospf *ospf = THREAD_ARG(t);
+ struct ospf *ospf = EVENT_ARG(t);
ospf_deferred_shutdown_finish(ospf);
}
/* Clear static neighbors */
for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
if ((nbr_nbma = rn->info)) {
- THREAD_OFF(nbr_nbma->t_poll);
+ EVENT_OFF(nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
}
/* Cancel all timers. */
- THREAD_OFF(ospf->t_read);
- THREAD_OFF(ospf->t_write);
- THREAD_OFF(ospf->t_spf_calc);
- THREAD_OFF(ospf->t_ase_calc);
- THREAD_OFF(ospf->t_maxage);
- THREAD_OFF(ospf->t_maxage_walker);
- THREAD_OFF(ospf->t_abr_task);
- THREAD_OFF(ospf->t_abr_fr);
- THREAD_OFF(ospf->t_asbr_check);
- THREAD_OFF(ospf->t_asbr_nssa_redist_update);
- THREAD_OFF(ospf->t_distribute_update);
- THREAD_OFF(ospf->t_lsa_refresher);
- THREAD_OFF(ospf->t_opaque_lsa_self);
- THREAD_OFF(ospf->t_sr_update);
- THREAD_OFF(ospf->t_default_routemap_timer);
- THREAD_OFF(ospf->t_external_aggr);
- THREAD_OFF(ospf->gr_info.t_grace_period);
+ EVENT_OFF(ospf->t_read);
+ EVENT_OFF(ospf->t_write);
+ EVENT_OFF(ospf->t_spf_calc);
+ EVENT_OFF(ospf->t_ase_calc);
+ EVENT_OFF(ospf->t_maxage);
+ EVENT_OFF(ospf->t_maxage_walker);
+ EVENT_OFF(ospf->t_abr_task);
+ EVENT_OFF(ospf->t_abr_fr);
+ EVENT_OFF(ospf->t_asbr_check);
+ EVENT_OFF(ospf->t_asbr_nssa_redist_update);
+ EVENT_OFF(ospf->t_distribute_update);
+ EVENT_OFF(ospf->t_lsa_refresher);
+ EVENT_OFF(ospf->t_opaque_lsa_self);
+ EVENT_OFF(ospf->t_sr_update);
+ EVENT_OFF(ospf->t_default_routemap_timer);
+ EVENT_OFF(ospf->t_external_aggr);
+ EVENT_OFF(ospf->gr_info.t_grace_period);
LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
ospf_discard_from_db(ospf, ospf->lsdb, lsa);
free(IMPORT_NAME(area));
/* Cancel timer. */
- THREAD_OFF(area->t_stub_router);
- THREAD_OFF(area->t_opaque_lsa_self);
+ EVENT_OFF(area->t_stub_router);
+ EVENT_OFF(area->t_opaque_lsa_self);
if (OSPF_IS_AREA_BACKBONE(area))
area->ospf->backbone = NULL;
}
/* remove update event */
- THREAD_OFF(oi->t_ls_upd_event);
+ EVENT_OFF(oi->t_ls_upd_event);
}
void ospf_if_update(struct ospf *ospf, struct interface *ifp)
- (monotime(NULL) - ospf->lsa_refresher_started);
if (time_left > interval) {
- THREAD_OFF(ospf->t_lsa_refresher);
+ EVENT_OFF(ospf->t_lsa_refresher);
event_add_timer(master, ospf_lsa_refresh_walker, ospf, interval,
&ospf->t_lsa_refresher);
}
- (monotime(NULL) - ospf->lsa_refresher_started);
if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT) {
- THREAD_OFF(ospf->t_lsa_refresher);
+ EVENT_OFF(ospf->t_lsa_refresher);
ospf->t_lsa_refresher = NULL;
event_add_timer(master, ospf_lsa_refresh_walker, ospf,
OSPF_LSA_REFRESH_INTERVAL_DEFAULT,
static void ospf_nbr_nbma_down(struct ospf_nbr_nbma *nbr_nbma)
{
- THREAD_OFF(nbr_nbma->t_poll);
+ EVENT_OFF(nbr_nbma->t_poll);
if (nbr_nbma->nbr) {
nbr_nbma->nbr->nbr_nbma = NULL;
if (nbr_nbma->v_poll != interval) {
nbr_nbma->v_poll = interval;
if (nbr_nbma->oi && ospf_if_is_up(nbr_nbma->oi)) {
- THREAD_OFF(nbr_nbma->t_poll);
+ EVENT_OFF(nbr_nbma->t_poll);
OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
nbr_nbma->v_poll);
}
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("%s: ospf old_vrf_id %d unlinked", __func__,
old_vrf_id);
- THREAD_OFF(ospf->t_read);
+ EVENT_OFF(ospf->t_read);
close(ospf->fd);
ospf->fd = -1;
}
void pcep_refine_path_event_cb(struct event *thread)
{
- struct pcep_refine_path_event_data *data = THREAD_ARG(thread);
+ struct pcep_refine_path_event_data *data = EVENT_ARG(thread);
assert(data != NULL);
struct ctrl_state *ctrl_state = data->ctrl_state;
struct path *path = data->path;
return;
}
- struct pcep_ctrl_timer_data *data = THREAD_ARG(*thread);
+ struct pcep_ctrl_timer_data *data = EVENT_ARG(*thread);
PCEP_DEBUG("Timer %s / %s canceled", timer_type_name(data->timer_type),
timeout_type_name(data->timeout_type));
if (data != NULL) {
void pcep_thread_finish_event_handler(struct event *thread)
{
int i;
- struct frr_pthread *fpt = THREAD_ARG(thread);
+ struct frr_pthread *fpt = EVENT_ARG(thread);
struct ctrl_state *ctrl_state = fpt->data;
assert(ctrl_state != NULL);
void pcep_thread_timer_handler(struct event *thread)
{
/* data unpacking */
- struct pcep_ctrl_timer_data *data = THREAD_ARG(thread);
+ struct pcep_ctrl_timer_data *data = EVENT_ARG(thread);
assert(data != NULL);
struct ctrl_state *ctrl_state = data->ctrl_state;
assert(ctrl_state != NULL);
void pcep_thread_pcep_event(struct event *thread)
{
- struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
+ struct pcep_ctrl_event_data *data = EVENT_ARG(thread);
assert(data != NULL);
struct ctrl_state *ctrl_state = data->ctrl_state;
pcep_event *event = data->payload;
void pcep_thread_event_handler(struct event *thread)
{
/* data unpacking */
- struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
+ struct pcep_ctrl_event_data *data = EVENT_ARG(thread);
assert(data != NULL);
struct ctrl_state *ctrl_state = data->ctrl_state;
assert(ctrl_state != NULL);
void pcep_main_event_handler(struct event *thread)
{
/* data unpacking */
- struct pcep_main_event_data *data = THREAD_ARG(thread);
+ struct pcep_main_event_data *data = EVENT_ARG(thread);
assert(data != NULL);
pcep_main_event_handler_t handler = data->handler;
enum pcep_main_event_type type = data->type;
void pcep_lib_socket_write_ready(struct event *thread)
{
- struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
+ struct pcep_ctrl_socket_data *data = EVENT_ARG(thread);
assert(data != NULL);
pceplib_external_socket_write(data->fd, data->payload);
void pcep_lib_socket_read_ready(struct event *thread)
{
- struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
+ struct pcep_ctrl_socket_data *data = EVENT_ARG(thread);
assert(data != NULL);
pceplib_external_socket_read(data->fd, data->payload);
void path_ted_timer_handler_sync(struct event *thread)
{
/* data unpacking */
- struct ted_state *data = THREAD_ARG(thread);
+ struct ted_state *data = EVENT_ARG(thread);
assert(data != NULL);
/* Retry the sync */
PATH_TED_DEBUG("%s: PATHD-TED: Refresh sid from current TED", __func__);
/* data unpacking */
- struct ted_state *data = THREAD_ARG(thread);
+ struct ted_state *data = EVENT_ARG(thread);
assert(data != NULL);
void trigger_pathd_candidate_created_timer(struct event *thread)
{
- struct srte_candidate *candidate = THREAD_ARG(thread);
+ struct srte_candidate *candidate = EVENT_ARG(thread);
candidate->hook_timer = NULL;
hook_call(pathd_candidate_created, candidate);
}
void trigger_pathd_candidate_updated_timer(struct event *thread)
{
- struct srte_candidate *candidate = THREAD_ARG(thread);
+ struct srte_candidate *candidate = EVENT_ARG(thread);
candidate->hook_timer = NULL;
hook_call(pathd_candidate_updated, candidate);
}
static void gm_sg_free(struct gm_sg *sg)
{
/* t_sg_expiry is handled before this is reached */
- THREAD_OFF(sg->t_sg_query);
+ EVENT_OFF(sg->t_sg_query);
gm_packet_sg_subs_fini(sg->subs_negative);
gm_packet_sg_subs_fini(sg->subs_positive);
XFREE(MTYPE_GM_SG, sg);
gm_expiry_calc(&timers);
gm_sg_timer_start(gm_ifp, sg, timers.expire_wait);
- THREAD_OFF(sg->t_sg_query);
+ EVENT_OFF(sg->t_sg_query);
sg->n_query = gm_ifp->cur_lmqc;
sg->query_sbit = false;
gm_trigger_specific(sg);
* another path.
*/
if (has_expired)
- THREAD_OFF(sg->t_sg_expire);
+ EVENT_OFF(sg->t_sg_expire);
assertf((!sg->t_sg_expire &&
!gm_packet_sg_subs_count(sg->subs_positive) &&
{
if (sg->t_sg_expire && PIM_DEBUG_GM_TRACE)
zlog_debug(log_sg(sg, "alive, cancelling expiry timer"));
- THREAD_OFF(sg->t_sg_expire);
+ EVENT_OFF(sg->t_sg_expire);
sg->query_sbit = true;
}
*/
static void gm_t_expire(struct event *t)
{
- struct gm_if *gm_ifp = THREAD_ARG(t);
+ struct gm_if *gm_ifp = EVENT_ARG(t);
struct gm_packet_state *pkt;
zlog_info(log_ifp("general expiry timer"));
gm_ifp->n_pending--;
if (!gm_ifp->n_pending)
- THREAD_OFF(gm_ifp->t_expire);
+ EVENT_OFF(gm_ifp->t_expire);
}
/* people might be messing with their configs or something */
static void gm_t_sg_expire(struct event *t)
{
- struct gm_sg *sg = THREAD_ARG(t);
+ struct gm_sg *sg = EVENT_ARG(t);
struct gm_if *gm_ifp = sg->iface;
struct gm_packet_sg *item;
if (timercmp(&remain, &expire_wait, <=))
return;
- THREAD_OFF(sg->t_sg_expire);
+ EVENT_OFF(sg->t_sg_expire);
}
event_add_timer_tv(router->master, gm_t_sg_expire, sg, &expire_wait,
* receive a report, so that work is left to gm_t_sg_expire and we
* shouldn't worry about it here.
*/
- struct gm_grp_pending *pend = THREAD_ARG(t);
+ struct gm_grp_pending *pend = EVENT_ARG(t);
struct gm_if *gm_ifp = pend->iface;
struct gm_sg *sg, *sg_start, sg_ref = {};
* parallel. But if we received nothing for the *,G query,
* the S,G query is kinda irrelevant.
*/
- THREAD_OFF(sg->t_sg_expire);
+ EVENT_OFF(sg->t_sg_expire);
frr_each_safe (gm_packet_sg_subs, sg->subs_positive, item)
/* this will also drop the EXCLUDE S,G lists */
if (timercmp(&remain, &timers->expire_wait, <=))
return;
- THREAD_OFF(pend->t_expire);
+ EVENT_OFF(pend->t_expire);
} else {
pend = XCALLOC(MTYPE_GM_GRP_PENDING, sizeof(*pend));
pend->grp = grp;
{
struct pim_interface *pim_ifp = gm_ifp->ifp->info;
- THREAD_OFF(gm_ifp->t_query);
+ EVENT_OFF(gm_ifp->t_query);
if (pim_addr_is_any(pim_ifp->ll_lowest))
return;
static void gm_t_other_querier(struct event *t)
{
- struct gm_if *gm_ifp = THREAD_ARG(t);
+ struct gm_if *gm_ifp = EVENT_ARG(t);
struct pim_interface *pim_ifp = gm_ifp->ifp->info;
zlog_info(log_ifp("other querier timer expired"));
if (IPV6_ADDR_CMP(&pkt_src->sin6_addr, &pim_ifp->ll_lowest) < 0) {
unsigned int other_ms;
- THREAD_OFF(gm_ifp->t_query);
- THREAD_OFF(gm_ifp->t_other_querier);
+ EVENT_OFF(gm_ifp->t_query);
+ EVENT_OFF(gm_ifp->t_other_querier);
other_ms = timers.qrv * timers.qqic_ms + timers.max_resp_ms / 2;
event_add_timer_msec(router->master, gm_t_other_querier, gm_ifp,
static void gm_t_recv(struct event *t)
{
- struct pim_instance *pim = THREAD_ARG(t);
+ struct pim_instance *pim = EVENT_ARG(t);
union {
char buf[CMSG_SPACE(sizeof(struct in6_pktinfo)) +
CMSG_SPACE(256) /* hop options */ +
static void gm_t_query(struct event *t)
{
- struct gm_if *gm_ifp = THREAD_ARG(t);
+ struct gm_if *gm_ifp = EVENT_ARG(t);
unsigned int timer_ms = gm_ifp->cur_query_intv;
if (gm_ifp->n_startup) {
static void gm_t_sg_query(struct event *t)
{
- struct gm_sg *sg = THREAD_ARG(t);
+ struct gm_sg *sg = EVENT_ARG(t);
gm_trigger_specific(sg);
}
static void gm_t_gsq_pend(struct event *t)
{
- struct gm_gsq_pending *pend_gsq = THREAD_ARG(t);
+ struct gm_gsq_pending *pend_gsq = EVENT_ARG(t);
gm_send_specific(pend_gsq);
}
pend_gsq->n_src++;
if (pend_gsq->n_src == array_size(pend_gsq->srcs)) {
- THREAD_OFF(pend_gsq->t_send);
+ EVENT_OFF(pend_gsq->t_send);
gm_send_specific(pend_gsq);
pend_gsq = NULL;
}
if (--pim->gm_socket_if_count)
return;
- THREAD_OFF(pim->t_gm_recv);
+ EVENT_OFF(pim->t_gm_recv);
close(pim->gm_socket);
pim->gm_socket = -1;
}
gm_packet_drop(pkt, false);
while ((pend_grp = gm_grp_pends_pop(gm_ifp->grp_pends))) {
- THREAD_OFF(pend_grp->t_expire);
+ EVENT_OFF(pend_grp->t_expire);
XFREE(MTYPE_GM_GRP_PENDING, pend_grp);
}
while ((pend_gsq = gm_gsq_pends_pop(gm_ifp->gsq_pends))) {
- THREAD_OFF(pend_gsq->t_send);
+ EVENT_OFF(pend_gsq->t_send);
XFREE(MTYPE_GM_GSQ_PENDING, pend_gsq);
}
while ((sg = gm_sgs_pop(gm_ifp->sgs))) {
- THREAD_OFF(sg->t_sg_expire);
+ EVENT_OFF(sg->t_sg_expire);
assertf(!gm_packet_sg_subs_count(sg->subs_negative), "%pSG",
&sg->sgaddr);
assertf(!gm_packet_sg_subs_count(sg->subs_positive), "%pSG",
if (PIM_DEBUG_GM_EVENTS)
zlog_debug(log_ifp("MLD stop"));
- THREAD_OFF(gm_ifp->t_query);
- THREAD_OFF(gm_ifp->t_other_querier);
- THREAD_OFF(gm_ifp->t_expire);
+ EVENT_OFF(gm_ifp->t_query);
+ EVENT_OFF(gm_ifp->t_other_querier);
+ EVENT_OFF(gm_ifp->t_expire);
frr_with_privs (&pimd_privs) {
struct ipv6_mreq mreq;
gm_ifp->cur_ll_lowest = pim_ifp->ll_lowest;
if (was_querier)
gm_ifp->querier = pim_ifp->ll_lowest;
- THREAD_OFF(gm_ifp->t_query);
+ EVENT_OFF(gm_ifp->t_query);
if (pim_addr_is_any(gm_ifp->cur_ll_lowest)) {
if (was_querier)
struct pim_ifchannel *ch;
struct interface *ifp;
- ch = THREAD_ARG(t);
+ ch = EVENT_ARG(t);
ifp = ch->interface;
__func__, ch->sg_str, ch->interface->name);
}
}
- THREAD_OFF(ch->t_ifassert_timer);
+ EVENT_OFF(ch->t_ifassert_timer);
}
static void pim_assert_timer_set(struct pim_ifchannel *ch, int interval)
static void pim_bsm_rpinfo_free(struct bsm_rpinfo *bsrp_info)
{
- THREAD_OFF(bsrp_info->g2rp_timer);
+ EVENT_OFF(bsrp_info->g2rp_timer);
XFREE(MTYPE_PIM_BSRP_INFO, bsrp_info);
}
struct bsgrp_node *bsgrp_node;
struct bsm_rpinfo *bsrp;
- scope = THREAD_ARG(t);
- THREAD_OFF(scope->bs_timer);
+ scope = EVENT_ARG(t);
+ EVENT_OFF(scope->bs_timer);
if (PIM_DEBUG_BSM)
zlog_debug("%s: Bootstrap Timer expired for scope: %d",
if (PIM_DEBUG_BSM)
zlog_debug("%s : BS timer being stopped of sz: %d", __func__,
scope->sz_id);
- THREAD_OFF(scope->bs_timer);
+ EVENT_OFF(scope->bs_timer);
}
static void pim_bs_timer_start(struct bsm_scope *scope, int bs_timeout)
zlog_debug("%s : Invalid scope(NULL).", __func__);
return;
}
- THREAD_OFF(scope->bs_timer);
+ EVENT_OFF(scope->bs_timer);
if (PIM_DEBUG_BSM)
zlog_debug(
"%s : starting bs timer for scope %d with timeout %d secs",
uint16_t elapse;
pim_addr bsrp_addr;
- bsrp = THREAD_ARG(t);
- THREAD_OFF(bsrp->g2rp_timer);
+ bsrp = EVENT_ARG(t);
+ EVENT_OFF(bsrp->g2rp_timer);
bsgrp_node = bsrp->bsgrp_node;
/* elapse time is the hold time of expired node */
zlog_debug("%s : Invalid brsp(NULL).", __func__);
return;
}
- THREAD_OFF(bsrp->g2rp_timer);
+ EVENT_OFF(bsrp->g2rp_timer);
if (PIM_DEBUG_BSM)
zlog_debug(
"%s : starting g2rp timer for grp: %pFX - rp: %pPAs with timeout %d secs(Actual Hold time : %d secs)",
__func__, &bsrp->bsgrp_node->group,
&bsrp->rp_address);
- THREAD_OFF(bsrp->g2rp_timer);
+ EVENT_OFF(bsrp->g2rp_timer);
}
static bool is_hold_time_zero(void *data)
ch->upstream = NULL;
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
- THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
- THREAD_OFF(ch->t_ifassert_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(ch->t_ifassert_timer);
if (ch->parent) {
listnode_delete(ch->parent->sources, ch);
*/
void reset_ifassert_state(struct pim_ifchannel *ch)
{
- THREAD_OFF(ch->t_ifassert_timer);
+ EVENT_OFF(ch->t_ifassert_timer);
pim_ifassert_winner_set(ch, PIM_IFASSERT_NOINFO, PIMADDR_ANY,
router->infinite_assert_metric);
{
struct pim_ifchannel *ch;
- ch = THREAD_ARG(t);
+ ch = EVENT_ARG(t);
if (PIM_DEBUG_PIM_TRACE)
zlog_debug("%s: ifchannel %s expiry timer", __func__,
struct interface *ifp;
struct pim_interface *pim_ifp;
- ch = THREAD_ARG(t);
+ ch = EVENT_ARG(t);
if (PIM_DEBUG_PIM_TRACE)
zlog_debug("%s: IFCHANNEL%pSG %s Prune Pending Timer Popped",
return;
}
}
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT) {
pim_ifchannel_ifjoin_switch(__func__, ch,
PIM_IFJOIN_NOINFO);
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
delete_on_noinfo(ch);
return;
} else
* maximum of its current value and the HoldTime from the
* triggering Join/Prune message.
*/
- THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
/* Check if SGRpt join Received */
if ((source_flags & PIM_ENCODE_RPT_BIT) &&
* I transitions to the NoInfo state.The ET and PPT are
* cancelled.
*/
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
pim_ifchannel_ifjoin_switch(__func__, ch,
PIM_IFJOIN_NOINFO);
return;
if (remain > holdtime)
return;
}
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
break;
case PIM_IFJOIN_PRUNE_TMP:
be taken not to use "ch" afterwards since it would be
deleted. */
- THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
event_add_timer_msec(router->master,
on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
/* If we called ifjoin_prune() directly instead, care should
be taken not to use "ch" afterwards since it would be
deleted. */
- THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
event_add_timer_msec(router->master,
on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT) {
- THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(ch->t_ifjoin_prune_pending_timer);
/*
* While in Prune State, Receive SGRpt Prune.
* RFC 7761 Sec 4.5.3:
if (rem > holdtime)
return;
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
}
event_add_timer(router->master, on_ifjoin_expiry_timer,
case PIM_IFJOIN_PRUNE_TMP:
if (source_flags & PIM_ENCODE_RPT_BIT) {
ch->ifjoin_state = PIM_IFJOIN_PRUNE;
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
event_add_timer(router->master, on_ifjoin_expiry_timer,
ch, holdtime,
&ch->t_ifjoin_expiry_timer);
case PIM_IFJOIN_PRUNE_PENDING_TMP:
if (source_flags & PIM_ENCODE_RPT_BIT) {
ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
- THREAD_OFF(ch->t_ifjoin_expiry_timer);
+ EVENT_OFF(ch->t_ifjoin_expiry_timer);
event_add_timer(router->master, on_ifjoin_expiry_timer,
ch, holdtime,
&ch->t_ifjoin_expiry_timer);
break;
if (child->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING_TMP)
- THREAD_OFF(child->t_ifjoin_prune_pending_timer);
- THREAD_OFF(child->t_ifjoin_expiry_timer);
+ EVENT_OFF(child->t_ifjoin_prune_pending_timer);
+ EVENT_OFF(child->t_ifjoin_expiry_timer);
PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
child->ifjoin_state = PIM_IFJOIN_NOINFO;
{
struct gm_sock *igmp;
- igmp = THREAD_ARG(t);
+ igmp = EVENT_ARG(t);
assert(!igmp->t_igmp_query_timer);
"Querier %s resetting TIMER event for Other-Querier-Present",
ifaddr_str);
}
- THREAD_OFF(igmp->t_other_querier_timer);
+ EVENT_OFF(igmp->t_other_querier_timer);
} else {
/*
We are the current querier, then stop sending general queries:
ifaddr_str, igmp->fd, igmp->interface->name);
}
}
- THREAD_OFF(igmp->t_other_querier_timer);
+ EVENT_OFF(igmp->t_other_querier_timer);
}
int igmp_validate_checksum(char *igmp_msg, int igmp_msg_len)
ifaddr_str, igmp->fd, igmp->interface->name);
}
}
- THREAD_OFF(igmp->t_igmp_query_timer);
+ EVENT_OFF(igmp->t_igmp_query_timer);
}
/* Issue IGMP general query */
struct pim_interface *pim_ifp;
int query_buf_size;
- igmp = THREAD_ARG(t);
+ igmp = EVENT_ARG(t);
assert(igmp->interface);
assert(igmp->interface->info);
igmp->interface->name);
}
}
- THREAD_OFF(igmp->t_igmp_read);
+ EVENT_OFF(igmp->t_igmp_read);
if (close(igmp->fd)) {
flog_err(
igmp_source_delete(src);
}
- THREAD_OFF(group->t_group_query_retransmit_timer);
+ EVENT_OFF(group->t_group_query_retransmit_timer);
group_timer_off(group);
igmp_group_count_decr(pim_ifp);
static void pim_igmp_read(struct event *t)
{
uint8_t buf[10000];
- struct gm_sock *igmp = (struct gm_sock *)THREAD_ARG(t);
+ struct gm_sock *igmp = (struct gm_sock *)EVENT_ARG(t);
struct sockaddr_storage from;
struct sockaddr_storage to;
socklen_t fromlen = sizeof(from);
{
struct gm_group *group;
- group = THREAD_ARG(t);
+ group = EVENT_ARG(t);
if (PIM_DEBUG_GM_TRACE) {
char group_str[INET_ADDRSTRLEN];
zlog_debug("Cancelling TIMER event for group %s on %s",
group_str, group->interface->name);
}
- THREAD_OFF(group->t_group_timer);
+ EVENT_OFF(group->t_group_timer);
}
void igmp_group_timer_on(struct gm_group *group, long interval_msec,
struct gm_source *source;
struct gm_group *group;
- source = THREAD_ARG(t);
+ source = EVENT_ARG(t);
group = source->source_group;
group_str, source_str, group->interface->name);
}
- THREAD_OFF(source->t_source_timer);
+ EVENT_OFF(source->t_source_timer);
}
static void igmp_source_timer_on(struct gm_group *group,
int num_retransmit_sources_left;
int send_with_sflag_set; /* boolean */
- group = THREAD_ARG(t);
+ group = EVENT_ARG(t);
if (PIM_DEBUG_GM_TRACE) {
char group_str[INET_ADDRSTRLEN];
if (PIM_IF_FLAG_TEST_S_G_RPT(child->flags)) {
if (child->ifjoin_state
== PIM_IFJOIN_PRUNE_PENDING_TMP)
- THREAD_OFF(
+ EVENT_OFF(
child->t_ifjoin_prune_pending_timer);
- THREAD_OFF(
- child->t_ifjoin_expiry_timer);
+ EVENT_OFF(child->t_ifjoin_expiry_timer);
PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
child->ifjoin_state = PIM_IFJOIN_NOINFO;
delete_on_noinfo(child);
int cont = 1;
int rd;
ifindex_t ifindex;
- pim = THREAD_ARG(t);
+ pim = EVENT_ARG(t);
while (cont) {
rd = pim_socket_recvfromto(pim->mroute_socket, (uint8_t *)buf,
static void mroute_read_off(struct pim_instance *pim)
{
- THREAD_OFF(pim->thread);
+ EVENT_OFF(pim->thread);
}
int pim_mroute_socket_enable(struct pim_instance *pim)
/* RFC-3618:Sec-5.1 - global active source advertisement timer */
static void pim_msdp_sa_adv_timer_cb(struct event *t)
{
- struct pim_instance *pim = THREAD_ARG(t);
+ struct pim_instance *pim = EVENT_ARG(t);
if (PIM_DEBUG_MSDP_EVENTS) {
zlog_debug("MSDP SA advertisement timer expired");
static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start)
{
- THREAD_OFF(pim->msdp.sa_adv_timer);
+ EVENT_OFF(pim->msdp.sa_adv_timer);
if (start) {
event_add_timer(pim->msdp.master, pim_msdp_sa_adv_timer_cb, pim,
PIM_MSDP_SA_ADVERTISMENT_TIME,
{
struct pim_msdp_sa *sa;
- sa = THREAD_ARG(t);
+ sa = EVENT_ARG(t);
if (PIM_DEBUG_MSDP_EVENTS) {
pim_msdp_sa_timer_expiry_log(sa, "state");
static void pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
{
- THREAD_OFF(sa->sa_state_timer);
+ EVENT_OFF(sa->sa_state_timer);
if (start) {
event_add_timer(sa->pim->msdp.master,
pim_msdp_sa_state_timer_cb, sa,
{
struct pim_msdp_peer *mp;
- mp = THREAD_ARG(t);
+ mp = EVENT_ARG(t);
if (PIM_DEBUG_MSDP_EVENTS) {
pim_msdp_peer_timer_expiry_log(mp, "hold");
static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
{
struct pim_instance *pim = mp->pim;
- THREAD_OFF(mp->hold_timer);
+ EVENT_OFF(mp->hold_timer);
if (start) {
event_add_timer(pim->msdp.master, pim_msdp_peer_hold_timer_cb,
mp, pim->msdp.hold_time, &mp->hold_timer);
{
struct pim_msdp_peer *mp;
- mp = THREAD_ARG(t);
+ mp = EVENT_ARG(t);
if (PIM_DEBUG_MSDP_EVENTS) {
pim_msdp_peer_timer_expiry_log(mp, "ka");
static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
{
- THREAD_OFF(mp->ka_timer);
+ EVENT_OFF(mp->ka_timer);
if (start) {
event_add_timer(mp->pim->msdp.master, pim_msdp_peer_ka_timer_cb,
mp, mp->pim->msdp.keep_alive, &mp->ka_timer);
{
struct pim_msdp_peer *mp;
- mp = THREAD_ARG(t);
+ mp = EVENT_ARG(t);
if (PIM_DEBUG_MSDP_EVENTS) {
pim_msdp_peer_timer_expiry_log(mp, "connect-retry");
static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
{
- THREAD_OFF(mp->cr_timer);
+ EVENT_OFF(mp->cr_timer);
if (start) {
event_add_timer(mp->pim->msdp.master, pim_msdp_peer_cr_timer_cb,
mp, mp->pim->msdp.connection_retry,
int work_cnt = 0;
int work_max_cnt = 100;
- mp = THREAD_ARG(thread);
+ mp = EVENT_ARG(thread);
mp->t_write = NULL;
if (PIM_DEBUG_MSDP_INTERNAL) {
int rc;
uint32_t len;
- mp = THREAD_ARG(thread);
+ mp = EVENT_ARG(thread);
mp->t_read = NULL;
if (PIM_DEBUG_MSDP_INTERNAL) {
static void pim_msdp_sock_accept(struct event *thread)
{
union sockunion su;
- struct pim_instance *pim = THREAD_ARG(thread);
+ struct pim_instance *pim = EVENT_ARG(thread);
int accept_sock;
int msdp_sock;
struct pim_msdp_peer *mp;
sockunion_init(&su);
/* re-register accept thread */
- accept_sock = THREAD_FD(thread);
+ accept_sock = EVENT_FD(thread);
if (accept_sock < 0) {
flog_err(EC_LIB_DEVELOPMENT, "accept_sock is negative value %d",
accept_sock);
struct interface *ifp;
char msg[100];
- neigh = THREAD_ARG(t);
+ neigh = EVENT_ARG(t);
ifp = neigh->interface;
{
neigh->holdtime = holdtime;
- THREAD_OFF(neigh->t_expire_timer);
+ EVENT_OFF(neigh->t_expire_timer);
/*
0xFFFF is request for no holdtime
static void on_neighbor_jp_timer(struct event *t)
{
- struct pim_neighbor *neigh = THREAD_ARG(t);
+ struct pim_neighbor *neigh = EVENT_ARG(t);
struct pim_rpf rpf;
if (PIM_DEBUG_PIM_TRACE)
static void pim_neighbor_start_jp_timer(struct pim_neighbor *neigh)
{
- THREAD_OFF(neigh->jp_timer);
+ EVENT_OFF(neigh->jp_timer);
event_add_timer(router->master, on_neighbor_jp_timer, neigh,
router->t_periodic, &neigh->jp_timer);
}
delete_prefix_list(neigh);
list_delete(&neigh->upstream_jp_agg);
- THREAD_OFF(neigh->jp_timer);
+ EVENT_OFF(neigh->jp_timer);
bfd_sess_free(&neigh->bfd_session);
zlog_notice("PIM NEIGHBOR DOWN: neighbor %pPA on interface %s: %s",
&neigh->source_addr, ifp->name, delete_message);
- THREAD_OFF(neigh->t_expire_timer);
+ EVENT_OFF(neigh->t_expire_timer);
pim_if_assert_on_neighbor_down(ifp, neigh->source_addr);
pim_ifp->pim_sock_fd, ifp->name);
}
}
- THREAD_OFF(pim_ifp->t_pim_sock_read);
+ EVENT_OFF(pim_ifp->t_pim_sock_read);
if (PIM_DEBUG_PIM_TRACE) {
if (pim_ifp->t_pim_hello_timer) {
ifp->name);
}
}
- THREAD_OFF(pim_ifp->t_pim_hello_timer);
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
if (PIM_DEBUG_PIM_TRACE) {
zlog_debug("Deleting PIM socket fd=%d on interface %s",
static long long count = 0;
int cont = 1;
- orig_ifp = ifp = THREAD_ARG(t);
- fd = THREAD_FD(t);
+ orig_ifp = ifp = EVENT_ARG(t);
+ fd = EVENT_FD(t);
pim_ifp = ifp->info;
zlog_debug("Rescheduling %d sec hello on interface %s",
pim_ifp->pim_hello_period, ifp->name);
}
- THREAD_OFF(pim_ifp->t_pim_hello_timer);
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
event_add_timer(router->master, on_pim_hello_send, ifp,
pim_ifp->pim_hello_period, &pim_ifp->t_pim_hello_timer);
}
struct pim_interface *pim_ifp;
struct interface *ifp;
- ifp = THREAD_ARG(t);
+ ifp = EVENT_ARG(t);
pim_ifp = ifp->info;
/*
return;
}
- THREAD_OFF(pim_ifp->t_pim_hello_timer);
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
}
random_msec = triggered_hello_delay_msec;
&& (up->reg_state != PIM_REG_NOINFO)) {
pim_channel_del_oif(up->channel_oil, pim->regiface,
PIM_OIF_FLAG_PROTO_PIM, __func__);
- THREAD_OFF(up->t_rs_timer);
+ EVENT_OFF(up->t_rs_timer);
up->reg_state = PIM_REG_NOINFO;
}
}
{
assert(ss);
- THREAD_OFF(ss->t_sock_read);
+ EVENT_OFF(ss->t_sock_read);
if (close(ss->sock_fd)) {
zlog_warn(
{
struct ssmpingd_sock *ss;
- ss = THREAD_ARG(t);
+ ss = EVENT_ARG(t);
ssmpingd_read_msg(ss);
static void pim_upstream_timers_stop(struct pim_upstream *up)
{
- THREAD_OFF(up->t_ka_timer);
- THREAD_OFF(up->t_rs_timer);
- THREAD_OFF(up->t_msdp_reg_timer);
- THREAD_OFF(up->t_join_timer);
+ EVENT_OFF(up->t_ka_timer);
+ EVENT_OFF(up->t_rs_timer);
+ EVENT_OFF(up->t_msdp_reg_timer);
+ EVENT_OFF(up->t_join_timer);
}
struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
{
struct pim_upstream *up;
- up = THREAD_ARG(t);
+ up = EVENT_ARG(t);
if (!up->rpf.source_nexthop.interface) {
if (PIM_DEBUG_PIM_TRACE)
{
struct pim_neighbor *nbr = NULL;
- THREAD_OFF(up->t_join_timer);
+ EVENT_OFF(up->t_join_timer);
if (up->rpf.source_nexthop.interface)
nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
if (nbr)
pim_jp_agg_add_group(nbr->upstream_jp_agg, up, 1, nbr);
else {
- THREAD_OFF(up->t_join_timer);
+ EVENT_OFF(up->t_join_timer);
event_add_timer(router->master, on_join_timer, up,
router->t_periodic, &up->t_join_timer);
}
void pim_upstream_join_timer_restart(struct pim_upstream *up,
struct pim_rpf *old)
{
- // THREAD_OFF(up->t_join_timer);
+ // EVENT_OFF(up->t_join_timer);
join_timer_start(up);
}
__func__, interval_msec, up->sg_str);
}
- THREAD_OFF(up->t_join_timer);
+ EVENT_OFF(up->t_join_timer);
event_add_timer_msec(router->master, on_join_timer, up, interval_msec,
&up->t_join_timer);
}
up->sg_str);
/* stop reg-stop timer */
- THREAD_OFF(up->t_rs_timer);
+ EVENT_OFF(up->t_rs_timer);
/* remove regiface from the OIL if it is there*/
pim_channel_del_oif(up->channel_oil, pim->regiface,
PIM_OIF_FLAG_PROTO_PIM, __func__);
{
struct pim_upstream *up;
- up = THREAD_ARG(t);
+ up = EVENT_ARG(t);
/* pull the stats and re-check */
if (pim_upstream_sg_running_proc(up))
zlog_debug("kat start on %s with no stream reference",
up->sg_str);
}
- THREAD_OFF(up->t_ka_timer);
+ EVENT_OFF(up->t_ka_timer);
event_add_timer(router->master, pim_upstream_keep_alive_timer, up, time,
&up->t_ka_timer);
/* MSDP on RP needs to know if a source is registerable to this RP */
static void pim_upstream_msdp_reg_timer(struct event *t)
{
- struct pim_upstream *up = THREAD_ARG(t);
+ struct pim_upstream *up = EVENT_ARG(t);
struct pim_instance *pim = up->channel_oil->pim;
/* source is no longer active - pull the SA from MSDP's cache */
void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
{
- THREAD_OFF(up->t_msdp_reg_timer);
+ EVENT_OFF(up->t_msdp_reg_timer);
event_add_timer(router->master, pim_upstream_msdp_reg_timer, up,
PIM_MSDP_REG_RXED_PERIOD, &up->t_msdp_reg_timer);
struct pim_interface *pim_ifp;
struct pim_instance *pim;
struct pim_upstream *up;
- up = THREAD_ARG(t);
+ up = EVENT_ARG(t);
pim = up->channel_oil->pim;
if (PIM_DEBUG_PIM_TRACE) {
{
uint32_t time;
- THREAD_OFF(up->t_rs_timer);
+ EVENT_OFF(up->t_rs_timer);
if (!null_register) {
uint32_t lower = (0.5 * router->register_suppress_time);
/* global 1second timer used for periodic processing */
static void pim_vxlan_work_timer_setup(bool start)
{
- THREAD_OFF(vxlan_info.work_timer);
+ EVENT_OFF(vxlan_info.work_timer);
if (start)
event_add_timer(router->master, pim_vxlan_work_timer_cb, NULL,
PIM_VXLAN_WORK_TIME, &vxlan_info.work_timer);
* if there are no other references.
*/
if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
- THREAD_OFF(up->t_ka_timer);
+ EVENT_OFF(up->t_ka_timer);
up = pim_upstream_keep_alive_timer_proc(up);
} else {
/* this is really unexpected as we force vxlan
static void on_rpf_cache_refresh(struct event *t)
{
- struct pim_instance *pim = THREAD_ARG(t);
+ struct pim_instance *pim = EVENT_ARG(t);
/* update kernel multicast forwarding cache (MFC) */
pim_scan_oil(pim);
{
struct zclient *zlookup;
- zlookup = THREAD_ARG(t);
+ zlookup = EVENT_ARG(t);
if (zlookup->sock >= 0) {
return;
void zclient_lookup_free(void)
{
- THREAD_OFF(zlookup_read);
+ EVENT_OFF(zlookup_read);
zclient_stop(zlookup);
zclient_free(zlookup);
zlookup = NULL;
void zclient_lookup_read_pipe(struct event *thread)
{
- struct zclient *zlookup = THREAD_ARG(thread);
+ struct zclient *zlookup = EVENT_ARG(thread);
struct pim_instance *pim = pim_get_pim_instance(VRF_DEFAULT);
struct pim_zlookup_nexthop nexthop_tab[10];
pim_addr l = PIMADDR_ANY;
ri->enable_interface = 0;
ri->running = 0;
- THREAD_OFF(ri->t_wakeup);
+ EVENT_OFF(ri->t_wakeup);
}
void rip_interfaces_clean(struct rip *rip)
ri = ifp->info;
- THREAD_OFF(ri->t_wakeup);
+ EVENT_OFF(ri->t_wakeup);
rip = ri->rip;
if (rip) {
struct rip_interface *ri;
/* Get interface. */
- ifp = THREAD_ARG(t);
+ ifp = EVENT_ARG(t);
ri = ifp->info;
}
if (rinfo) {
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
rip_info_free(rinfo);
}
static void rip_peer_free(struct rip_peer *peer)
{
- THREAD_OFF(peer->t_timeout);
+ EVENT_OFF(peer->t_timeout);
XFREE(MTYPE_RIP_PEER, peer);
}
{
struct rip_peer *peer;
- peer = THREAD_ARG(t);
+ peer = EVENT_ARG(t);
listnode_delete(peer->rip->peer_list, peer);
rip_peer_free(peer);
}
peer = rip_peer_lookup(rip, addr);
if (peer) {
- THREAD_OFF(peer->t_timeout);
+ EVENT_OFF(peer->t_timeout);
} else {
peer = rip_peer_new();
peer->rip = rip;
struct rip_info *rinfo;
struct route_node *rp;
- rinfo = THREAD_ARG(t);
+ rinfo = EVENT_ARG(t);
/* Off timeout timer. */
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
/* Get route_node pointer. */
rp = rinfo->rp;
if (tmp_rinfo == rinfo)
continue;
- THREAD_OFF(tmp_rinfo->t_timeout);
- THREAD_OFF(tmp_rinfo->t_garbage_collect);
+ EVENT_OFF(tmp_rinfo->t_timeout);
+ EVENT_OFF(tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
rip_info_free(tmp_rinfo);
}
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
memcpy(rinfo, rinfo_new, sizeof(struct rip_info));
if (rip_route_rte(rinfo)) {
struct route_node *rp = rinfo->rp;
struct list *list = (struct list *)rp->info;
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
if (listcount(list) > 1) {
/* Some other ECMP entries still exist. Just delete this entry.
*/
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
if (rip_route_rte(rinfo)
&& CHECK_FLAG(rinfo->flags, RIP_RTF_FIB))
/* Timeout RIP routes. */
static void rip_timeout(struct event *t)
{
- struct rip_info *rinfo = THREAD_ARG(t);
+ struct rip_info *rinfo = EVENT_ARG(t);
struct rip *rip = rip_info_get_instance(rinfo);
rip_ecmp_delete(rip, rinfo);
static void rip_timeout_update(struct rip *rip, struct rip_info *rinfo)
{
if (rinfo->metric != RIP_METRIC_INFINITY) {
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
event_add_timer(master, rip_timeout, rinfo, rip->timeout_time,
&rinfo->t_timeout);
}
assert(newinfo.metric
!= RIP_METRIC_INFINITY);
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
memcpy(rinfo, &newinfo,
sizeof(struct rip_info));
rip_timeout_update(rip, rinfo);
RIP_TIMER_ON(rinfo->t_garbage_collect,
rip_garbage_collect,
rip->garbage_time);
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
rinfo->flags |= RIP_RTF_CHANGED;
if (IS_RIP_DEBUG_EVENT)
/* First entry point of RIP packet. */
static void rip_read(struct event *t)
{
- struct rip *rip = THREAD_ARG(t);
+ struct rip *rip = EVENT_ARG(t);
int sock;
int ret;
int rtenum;
struct prefix p;
/* Fetch socket then register myself. */
- sock = THREAD_FD(t);
+ sock = EVENT_FD(t);
/* Add myself to tne next event */
rip_event(rip, RIP_READ, sock);
/* RIP's periodical timer. */
static void rip_update(struct event *t)
{
- struct rip *rip = THREAD_ARG(t);
+ struct rip *rip = EVENT_ARG(t);
if (IS_RIP_DEBUG_EVENT)
zlog_debug("update timer fire!");
/* Triggered updates may be suppressed if a regular update is due by
the time the triggered update would be sent. */
- THREAD_OFF(rip->t_triggered_interval);
+ EVENT_OFF(rip->t_triggered_interval);
rip->trigger = 0;
/* Register myself. */
/* Triggered update interval timer. */
static void rip_triggered_interval(struct event *t)
{
- struct rip *rip = THREAD_ARG(t);
+ struct rip *rip = EVENT_ARG(t);
if (rip->trigger) {
rip->trigger = 0;
/* Execute triggered update. */
static void rip_triggered_update(struct event *t)
{
- struct rip *rip = THREAD_ARG(t);
+ struct rip *rip = EVENT_ARG(t);
int interval;
/* Cancel interval timer. */
- THREAD_OFF(rip->t_triggered_interval);
+ EVENT_OFF(rip->t_triggered_interval);
rip->trigger = 0;
/* Logging triggered update. */
rinfo->metric = RIP_METRIC_INFINITY;
RIP_TIMER_ON(rinfo->t_garbage_collect, rip_garbage_collect,
rip->garbage_time);
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
rinfo->flags |= RIP_RTF_CHANGED;
if (IS_RIP_DEBUG_EVENT) {
event_add_read(master, rip_read, rip, sock, &rip->t_read);
break;
case RIP_UPDATE_EVENT:
- THREAD_OFF(rip->t_update);
+ EVENT_OFF(rip->t_update);
jitter = rip_update_jitter(rip->update_time);
event_add_timer(master, rip_update, rip,
sock ? 2 : rip->update_time + jitter,
if (tmp_rinfo == rinfo)
continue;
- THREAD_OFF(tmp_rinfo->t_timeout);
- THREAD_OFF(tmp_rinfo->t_garbage_collect);
+ EVENT_OFF(tmp_rinfo->t_timeout);
+ EVENT_OFF(tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
rip_info_free(tmp_rinfo);
}
rip_zebra_ipv4_delete(rip, rp);
for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
rip_info_free(rinfo);
}
list_delete(&list);
rip_redistribute_disable(rip);
/* Cancel RIP related timers. */
- THREAD_OFF(rip->t_update);
- THREAD_OFF(rip->t_triggered_update);
- THREAD_OFF(rip->t_triggered_interval);
+ EVENT_OFF(rip->t_update);
+ EVENT_OFF(rip->t_triggered_update);
+ EVENT_OFF(rip->t_triggered_interval);
/* Cancel read thread. */
- THREAD_OFF(rip->t_read);
+ EVENT_OFF(rip->t_read);
/* Close RIP socket. */
close(rip->sock);
ri = ifp->info;
- THREAD_OFF(ri->t_wakeup);
+ EVENT_OFF(ri->t_wakeup);
ripng = ri->ripng;
ri->enable_interface = 0;
ri->running = 0;
- THREAD_OFF(ri->t_wakeup);
+ EVENT_OFF(ri->t_wakeup);
}
}
struct ripng_interface *ri;
/* Get interface. */
- ifp = THREAD_ARG(t);
+ ifp = EVENT_ARG(t);
ri = ifp->info;
}
if (rinfo) {
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
ripng_info_free(rinfo);
}
static void ripng_peer_free(struct ripng_peer *peer)
{
- THREAD_OFF(peer->t_timeout);
+ EVENT_OFF(peer->t_timeout);
XFREE(MTYPE_RIPNG_PEER, peer);
}
{
struct ripng_peer *peer;
- peer = THREAD_ARG(t);
+ peer = EVENT_ARG(t);
listnode_delete(peer->ripng->peer_list, peer);
ripng_peer_free(peer);
}
peer = ripng_peer_lookup(ripng, addr);
if (peer) {
- THREAD_OFF(peer->t_timeout);
+ EVENT_OFF(peer->t_timeout);
} else {
peer = ripng_peer_new();
peer->ripng = ripng;
struct ripng_info *rinfo;
struct agg_node *rp;
- rinfo = THREAD_ARG(t);
+ rinfo = EVENT_ARG(t);
/* Off timeout timer. */
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
/* Get route_node pointer. */
rp = rinfo->rp;
/* Re-use the first entry, and delete the others. */
for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
if (tmp_rinfo != rinfo) {
- THREAD_OFF(tmp_rinfo->t_timeout);
- THREAD_OFF(tmp_rinfo->t_garbage_collect);
+ EVENT_OFF(tmp_rinfo->t_timeout);
+ EVENT_OFF(tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
ripng_info_free(tmp_rinfo);
}
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
memcpy(rinfo, rinfo_new, sizeof(struct ripng_info));
if (ripng_route_rte(rinfo)) {
struct agg_node *rp = rinfo->rp;
struct list *list = (struct list *)rp->info;
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
if (rinfo->metric != RIPNG_METRIC_INFINITY)
ripng_aggregate_decrement(rp, rinfo);
if (listcount(list) > 1) {
/* Some other ECMP entries still exist. Just delete this entry.
*/
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_garbage_collect);
listnode_delete(list, rinfo);
if (ripng_route_rte(rinfo)
&& CHECK_FLAG(rinfo->flags, RIPNG_RTF_FIB))
/* Timeout RIPng routes. */
static void ripng_timeout(struct event *t)
{
- struct ripng_info *rinfo = THREAD_ARG(t);
+ struct ripng_info *rinfo = EVENT_ARG(t);
struct ripng *ripng = ripng_info_get_instance(rinfo);
ripng_ecmp_delete(ripng, rinfo);
static void ripng_timeout_update(struct ripng *ripng, struct ripng_info *rinfo)
{
if (rinfo->metric != RIPNG_METRIC_INFINITY) {
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
event_add_timer(master, ripng_timeout, rinfo,
ripng->timeout_time, &rinfo->t_timeout);
}
RIPNG_TIMER_ON(rinfo->t_garbage_collect,
ripng_garbage_collect,
ripng->garbage_time);
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
/* Aggregate count decrement. */
ripng_aggregate_decrement(rp, rinfo);
RIPNG_TIMER_ON(rinfo->t_garbage_collect,
ripng_garbage_collect,
ripng->garbage_time);
- THREAD_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_timeout);
/* Aggregate count decrement. */
ripng_aggregate_decrement(rp, rinfo);
/* First entry point of reading RIPng packet. */
static void ripng_read(struct event *thread)
{
- struct ripng *ripng = THREAD_ARG(thread);
+ struct ripng *ripng = EVENT_ARG(thread);
int len;
int sock;
struct sockaddr_in6 from;
/* Fetch thread data and set read pointer to empty for event
managing. `sock' sould be same as ripng->sock. */
- sock = THREAD_FD(thread);
+ sock = EVENT_FD(thread);
/* Add myself to the next event. */
ripng_event(ripng, RIPNG_READ, sock);
enabled interface. */
static void ripng_update(struct event *t)
{
- struct ripng *ripng = THREAD_ARG(t);
+ struct ripng *ripng = EVENT_ARG(t);
struct interface *ifp;
struct ripng_interface *ri;
/* Triggered updates may be suppressed if a regular update is due by
the time the triggered update would be sent. */
- THREAD_OFF(ripng->t_triggered_interval);
+ EVENT_OFF(ripng->t_triggered_interval);
ripng->trigger = 0;
/* Reset flush event. */
/* Triggered update interval timer. */
static void ripng_triggered_interval(struct event *t)
{
- struct ripng *ripng = THREAD_ARG(t);
+ struct ripng *ripng = EVENT_ARG(t);
if (ripng->trigger) {
ripng->trigger = 0;
/* Execute triggered update. */
void ripng_triggered_update(struct event *t)
{
- struct ripng *ripng = THREAD_ARG(t);
+ struct ripng *ripng = EVENT_ARG(t);
struct interface *ifp;
struct ripng_interface *ri;
int interval;
/* Cancel interval timer. */
- THREAD_OFF(ripng->t_triggered_interval);
+ EVENT_OFF(ripng->t_triggered_interval);
ripng->trigger = 0;
/* Logging triggered update. */
event_add_read(master, ripng_read, ripng, sock, &ripng->t_read);
break;
case RIPNG_UPDATE_EVENT:
- THREAD_OFF(ripng->t_update);
+ EVENT_OFF(ripng->t_update);
/* Update timer jitter. */
jitter = ripng_update_jitter(ripng->update_time);
/* Drop all other entries, except the first one. */
for (ALL_LIST_ELEMENTS(list, node, nextnode, tmp_rinfo))
if (tmp_rinfo != rinfo) {
- THREAD_OFF(tmp_rinfo->t_timeout);
- THREAD_OFF(
- tmp_rinfo->t_garbage_collect);
+ EVENT_OFF(tmp_rinfo->t_timeout);
+ EVENT_OFF(tmp_rinfo->t_garbage_collect);
list_delete_node(list, node);
ripng_info_free(tmp_rinfo);
}
ripng_zebra_ipv6_delete(ripng, rp);
for (ALL_LIST_ELEMENTS_RO(list, listnode, rinfo)) {
- THREAD_OFF(rinfo->t_timeout);
- THREAD_OFF(rinfo->t_garbage_collect);
+ EVENT_OFF(rinfo->t_timeout);
+ EVENT_OFF(rinfo->t_garbage_collect);
ripng_info_free(rinfo);
}
list_delete(&list);
ripng_redistribute_disable(ripng);
/* Cancel the RIPng timers */
- THREAD_OFF(ripng->t_update);
- THREAD_OFF(ripng->t_triggered_update);
- THREAD_OFF(ripng->t_triggered_interval);
+ EVENT_OFF(ripng->t_update);
+ EVENT_OFF(ripng->t_triggered_update);
+ EVENT_OFF(ripng->t_triggered_interval);
/* Cancel the read thread */
- THREAD_OFF(ripng->t_read);
+ EVENT_OFF(ripng->t_read);
/* Close the RIPng socket */
if (ripng->sock >= 0) {
static int timer_count;
static void test_timer(struct event *thread)
{
- int *count = THREAD_ARG(thread);
+ int *count = EVENT_ARG(thread);
printf("run %d of timer\n", (*count)++);
event_add_timer(master, test_timer, count, 5, NULL);
static void clear_something(struct event *thread)
{
- struct work_state *ws = THREAD_ARG(thread);
+ struct work_state *ws = EVENT_ARG(thread);
/* this could be like iterating through 150k of route_table
* or worse, iterating through a list of peers, to bgp_stop them with
if (pkt->hdr.priority == 0) {
vrrp_send_advertisement(r);
- THREAD_OFF(r->t_adver_timer);
+ EVENT_OFF(r->t_adver_timer);
event_add_timer_msec(master, vrrp_adver_timer_expire, r,
r->vr->advertisement_interval *
CS2MS,
"Received advertisement from %s w/ priority %hhu; switching to Backup",
r->vr->vrid, family2str(r->family), sipstr,
pkt->hdr.priority);
- THREAD_OFF(r->t_adver_timer);
+ EVENT_OFF(r->t_adver_timer);
if (r->vr->version == 3) {
r->master_adver_interval =
htons(pkt->hdr.v3.adver_int);
}
vrrp_recalculate_timers(r);
- THREAD_OFF(r->t_master_down_timer);
+ EVENT_OFF(r->t_master_down_timer);
event_add_timer_msec(master,
vrrp_master_down_timer_expire, r,
r->master_down_interval * CS2MS,
break;
case VRRP_STATE_BACKUP:
if (pkt->hdr.priority == 0) {
- THREAD_OFF(r->t_master_down_timer);
+ EVENT_OFF(r->t_master_down_timer);
event_add_timer_msec(
master, vrrp_master_down_timer_expire, r,
r->skew_time * CS2MS, &r->t_master_down_timer);
ntohs(pkt->hdr.v3.adver_int);
}
vrrp_recalculate_timers(r);
- THREAD_OFF(r->t_master_down_timer);
+ EVENT_OFF(r->t_master_down_timer);
event_add_timer_msec(master,
vrrp_master_down_timer_expire, r,
r->master_down_interval * CS2MS,
*/
static void vrrp_read(struct event *thread)
{
- struct vrrp_router *r = THREAD_ARG(thread);
+ struct vrrp_router *r = EVENT_ARG(thread);
struct vrrp_pkt *pkt;
ssize_t pktsize;
vrrp_zebra_radv_set(r, false);
/* Disable Adver_Timer */
- THREAD_OFF(r->t_adver_timer);
+ EVENT_OFF(r->t_adver_timer);
r->advert_pending = false;
r->garp_pending = false;
*/
static void vrrp_adver_timer_expire(struct event *thread)
{
- struct vrrp_router *r = THREAD_ARG(thread);
+ struct vrrp_router *r = EVENT_ARG(thread);
DEBUGD(&vrrp_dbg_proto,
VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
*/
static void vrrp_master_down_timer_expire(struct event *thread)
{
- struct vrrp_router *r = THREAD_ARG(thread);
+ struct vrrp_router *r = EVENT_ARG(thread);
zlog_info(VRRP_LOGPFX VRRP_LOGPFX_VRID VRRP_LOGPFX_FAM
"Master_Down_Timer expired",
}
/* Cancel all timers */
- THREAD_OFF(r->t_adver_timer);
- THREAD_OFF(r->t_master_down_timer);
- THREAD_OFF(r->t_read);
- THREAD_OFF(r->t_write);
+ EVENT_OFF(r->t_adver_timer);
+ EVENT_OFF(r->t_master_down_timer);
+ EVENT_OFF(r->t_read);
+ EVENT_OFF(r->t_write);
/* Protodown macvlan */
if (r->mvl_ifp)
static void vtysh_log_read(struct event *thread)
{
- struct vtysh_client *vclient = THREAD_ARG(thread);
+ struct vtysh_client *vclient = EVENT_ARG(thread);
struct {
struct zlog_live_hdr hdr;
char text[4096];
"log monitor connection closed unexpectedly");
buf.hdr.textlen = strlen(buf.text);
- THREAD_OFF(vclient->log_reader);
+ EVENT_OFF(vclient->log_reader);
close(vclient->log_fd);
vclient->log_fd = -1;
* a close notification...
*/
if (vclient->log_fd != -1) {
- THREAD_OFF(vclient->log_reader);
+ EVENT_OFF(vclient->log_reader);
close(vclient->log_fd);
vclient->log_fd = -1;
static void restart_kill(struct event *t_kill)
{
- struct restart_info *restart = THREAD_ARG(t_kill);
+ struct restart_info *restart = EVENT_ARG(t_kill);
struct timeval delay;
time_elapsed(&delay, &restart->time);
static void wakeup_down(struct event *t_wakeup)
{
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
dmn->t_wakeup = NULL;
if (try_connect(dmn) < 0)
static void wakeup_init(struct event *t_wakeup)
{
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
dmn->t_wakeup = NULL;
if (try_connect(dmn) < 0) {
dmn->name, state_str[dmn->state]);
return;
}
- THREAD_OFF(dmn->t_wakeup);
+ EVENT_OFF(dmn->t_wakeup);
if (try_connect(dmn) < 0)
SET_WAKEUP_DOWN(dmn);
close(dmn->fd);
dmn->fd = -1;
}
- THREAD_OFF(dmn->t_read);
- THREAD_OFF(dmn->t_write);
- THREAD_OFF(dmn->t_wakeup);
+ EVENT_OFF(dmn->t_read);
+ EVENT_OFF(dmn->t_write);
+ EVENT_OFF(dmn->t_wakeup);
if (try_connect(dmn) < 0)
SET_WAKEUP_DOWN(dmn);
static void handle_read(struct event *t_read)
{
- struct daemon *dmn = THREAD_ARG(t_read);
+ struct daemon *dmn = EVENT_ARG(t_read);
static const char resp[sizeof(PING_TOKEN) + 4] = PING_TOKEN "\n";
char buf[sizeof(resp) + 100];
ssize_t rc;
if (gs.numdown == 0) {
daemon_send_ready(0);
- THREAD_OFF(gs.t_operational);
+ EVENT_OFF(gs.t_operational);
event_add_timer(master, daemon_restarting_operational, NULL,
gs.operational_timeout, &gs.t_operational);
static void check_connect(struct event *t_write)
{
- struct daemon *dmn = THREAD_ARG(t_write);
+ struct daemon *dmn = EVENT_ARG(t_write);
int sockerr;
socklen_t reslen = sizeof(sockerr);
static void wakeup_connect_hanging(struct event *t_wakeup)
{
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
char why[100];
dmn->t_wakeup = NULL;
gs.start_command, 1, 0);
}
gs.phase = PHASE_NONE;
- THREAD_OFF(gs.t_phase_hanging);
+ EVENT_OFF(gs.t_phase_hanging);
zlog_notice("Phased global restart has completed.");
break;
}
static void wakeup_unresponsive(struct event *t_wakeup)
{
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
dmn->t_wakeup = NULL;
if (dmn->state != DAEMON_UNRESPONSIVE)
static void wakeup_no_answer(struct event *t_wakeup)
{
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
dmn->t_wakeup = NULL;
dmn->state = DAEMON_UNRESPONSIVE;
{
static const char echocmd[] = "echo " PING_TOKEN;
ssize_t rc;
- struct daemon *dmn = THREAD_ARG(t_wakeup);
+ struct daemon *dmn = EVENT_ARG(t_wakeup);
dmn->t_wakeup = NULL;
if (((rc = write(dmn->fd, echocmd, sizeof(echocmd))) < 0)
stream_reset(fnc->ibuf);
stream_reset(fnc->obuf);
- THREAD_OFF(fnc->t_read);
- THREAD_OFF(fnc->t_write);
+ EVENT_OFF(fnc->t_read);
+ EVENT_OFF(fnc->t_write);
/* FPM is disabled, don't attempt to connect. */
if (fnc->disabled)
static void fpm_read(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
fpm_msg_hdr_t fpm;
ssize_t rv;
char buf[65535];
static void fpm_write(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
socklen_t statuslen;
ssize_t bwritten;
int rv, status;
static void fpm_connect(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
struct sockaddr_in *sin = (struct sockaddr_in *)&fnc->addr;
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&fnc->addr;
socklen_t slen;
static void fpm_lsp_send(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
struct fpm_lsp_arg fla;
static void fpm_nhg_send(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
struct fpm_nhg_arg fna;
fna.fnc = fnc;
*/
static void fpm_rib_send(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
rib_dest_t *dest;
struct route_node *rn;
struct route_table *rt;
{
struct fpm_rmac_arg fra;
- fra.fnc = THREAD_ARG(t);
+ fra.fnc = EVENT_ARG(t);
fra.ctx = dplane_ctx_alloc();
fra.complete = true;
hash_iterate(zrouter.l3vni_table, fpm_enqueue_l3vni_table, &fra);
static void fpm_nhg_reset(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
hash_iterate(zrouter.nhgs_id, fpm_nhg_reset_cb, NULL);
static void fpm_lsp_reset(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
struct zebra_vrf *zvrf = vrf_info_lookup(VRF_DEFAULT);
hash_iterate(zvrf->lsp_table, fpm_lsp_reset_cb, NULL);
*/
static void fpm_rib_reset(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
rib_dest_t *dest;
struct route_node *rn;
struct route_table *rt;
static void fpm_rmac_reset(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
hash_iterate(zrouter.l3vni_table, fpm_unset_l3vni_table, NULL);
static void fpm_process_queue(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
struct zebra_dplane_ctx *ctx;
bool no_bufs = false;
uint64_t processed_contexts = 0;
*/
static void fpm_process_event(struct event *t)
{
- struct fpm_nl_ctx *fnc = THREAD_ARG(t);
- enum fpm_nl_events event = THREAD_VAL(t);
+ struct fpm_nl_ctx *fnc = EVENT_ARG(t);
+ enum fpm_nl_events event = EVENT_VAL(t);
switch (event) {
case FNE_DISABLE:
static int fpm_nl_finish_early(struct fpm_nl_ctx *fnc)
{
/* Disable all events and close socket. */
- THREAD_OFF(fnc->t_lspreset);
- THREAD_OFF(fnc->t_lspwalk);
- THREAD_OFF(fnc->t_nhgreset);
- THREAD_OFF(fnc->t_nhgwalk);
- THREAD_OFF(fnc->t_ribreset);
- THREAD_OFF(fnc->t_ribwalk);
- THREAD_OFF(fnc->t_rmacreset);
- THREAD_OFF(fnc->t_rmacwalk);
- THREAD_OFF(fnc->t_event);
- THREAD_OFF(fnc->t_nhg);
+ EVENT_OFF(fnc->t_lspreset);
+ EVENT_OFF(fnc->t_lspwalk);
+ EVENT_OFF(fnc->t_nhgreset);
+ EVENT_OFF(fnc->t_nhgwalk);
+ EVENT_OFF(fnc->t_ribreset);
+ EVENT_OFF(fnc->t_ribwalk);
+ EVENT_OFF(fnc->t_rmacreset);
+ EVENT_OFF(fnc->t_rmacwalk);
+ EVENT_OFF(fnc->t_event);
+ EVENT_OFF(fnc->t_nhg);
event_cancel_async(fnc->fthread->master, &fnc->t_read, NULL);
event_cancel_async(fnc->fthread->master, &fnc->t_write, NULL);
event_cancel_async(fnc->fthread->master, &fnc->t_connect, NULL);
static void if_zebra_speed_update(struct event *thread)
{
- struct interface *ifp = THREAD_ARG(thread);
+ struct interface *ifp = EVENT_ARG(thread);
struct zebra_if *zif = ifp->info;
uint32_t new_speed;
bool changed = false;
XFREE(MTYPE_ZIF_DESC, zebra_if->desc);
- THREAD_OFF(zebra_if->speed_update);
+ EVENT_OFF(zebra_if->speed_update);
XFREE(MTYPE_ZINFO, zebra_if);
}
void irdp_send_thread(struct event *t_advert)
{
uint32_t timer, tmp;
- struct interface *ifp = THREAD_ARG(t_advert);
+ struct interface *ifp = EVENT_ARG(t_advert);
struct zebra_if *zi = ifp->info;
struct irdp_interface *irdp = zi->irdp;
struct prefix *p;
if (!irdp)
return;
- THREAD_OFF(irdp->t_advertise);
+ EVENT_OFF(irdp->t_advertise);
if (ifp->connected)
for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
return;
irdp->flags |= IF_SOLICIT;
- THREAD_OFF(irdp->t_advertise);
+ EVENT_OFF(irdp->t_advertise);
timer = (frr_weak_random() % MAX_RESPONSE_DELAY) + 1;
char buf[IRDP_RX_BUF];
int ret, ifindex = 0;
- int irdp_sock = THREAD_FD(r);
+ int irdp_sock = EVENT_FD(r);
event_add_read(zrouter.master, irdp_read_raw, NULL, irdp_sock,
&t_irdp_raw);
static void kernel_read(struct event *thread)
{
- struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
+ struct zebra_ns *zns = (struct zebra_ns *)EVENT_ARG(thread);
struct zebra_dplane_info dp_info;
/* Capture key info from ns struct */
void kernel_terminate(struct zebra_ns *zns, bool complete)
{
- THREAD_OFF(zns->t_netlink);
+ EVENT_OFF(zns->t_netlink);
kernel_nlsock_fini(&zns->netlink);
} buf;
/* Fetch routing socket. */
- sock = THREAD_FD(thread);
+ sock = EVENT_FD(thread);
nbytes = read(sock, &buf, sizeof(buf));
static void rtadv_timer(struct event *thread)
{
- struct zebra_vrf *zvrf = THREAD_ARG(thread);
+ struct zebra_vrf *zvrf = EVENT_ARG(thread);
struct vrf *vrf;
struct interface *ifp;
struct zebra_if *zif;
struct sockaddr_in6 from;
ifindex_t ifindex = 0;
int hoplimit = -1;
- struct zebra_vrf *zvrf = THREAD_ARG(thread);
+ struct zebra_vrf *zvrf = EVENT_ARG(thread);
- sock = THREAD_FD(thread);
+ sock = EVENT_FD(thread);
zvrf->rtadv.ra_read = NULL;
/* Register myself. */
&rtadv->ra_timer);
break;
case RTADV_STOP:
- THREAD_OFF(rtadv->ra_timer);
- THREAD_OFF(rtadv->ra_read);
+ EVENT_OFF(rtadv->ra_timer);
+ EVENT_OFF(rtadv->ra_read);
break;
case RTADV_TIMER:
event_add_timer(zrouter.master, rtadv_timer, zvrf, val,
*/
static void dplane_incoming_read(struct event *event)
{
- struct dplane_zns_info *zi = THREAD_ARG(event);
+ struct dplane_zns_info *zi = EVENT_ARG(event);
kernel_dplane_read(&zi->info);
*/
static void dplane_incoming_request(struct event *event)
{
- struct dplane_zns_info *zi = THREAD_ARG(event);
+ struct dplane_zns_info *zi = EVENT_ARG(event);
/* Start read task */
event_add_read(zdplane_info.dg_master, dplane_incoming_read, zi,
zns_info_list_del(&zdplane_info.dg_zns_list, zi);
if (zdplane_info.dg_master) {
- THREAD_OFF(zi->t_read);
- THREAD_OFF(zi->t_request);
+ EVENT_OFF(zi->t_read);
+ EVENT_OFF(zi->t_request);
}
XFREE(MTYPE_DP_NS, zi);
struct listnode *node = NULL;
struct zebra_neigh *nbr = NULL;
- mac = THREAD_ARG(t);
+ mac = EVENT_ARG(t);
/* since this is asynchronous we need sanity checks*/
zvrf = vrf_info_lookup(mac->zevpn->vrf_id);
}
/* Start auto recovery timer for this MAC */
- THREAD_OFF(mac->dad_mac_auto_recovery_timer);
+ EVENT_OFF(mac->dad_mac_auto_recovery_timer);
if (zvrf->dad_freeze && zvrf->dad_freeze_time) {
if (IS_ZEBRA_DEBUG_VXLAN) {
char mac_buf[MAC_BUF_SIZE];
zebra_evpn_mac_stop_hold_timer(mac);
/* Cancel auto recovery */
- THREAD_OFF(mac->dad_mac_auto_recovery_timer);
+ EVENT_OFF(mac->dad_mac_auto_recovery_timer);
/* If the MAC is freed before the neigh we will end up
* with a stale pointer against the neigh.
bool old_static;
bool new_static;
- mac = THREAD_ARG(t);
+ mac = EVENT_ARG(t);
/* the purpose of the hold timer is to age out the peer-active
* flag
*/
sizeof(mac_buf)));
}
- THREAD_OFF(mac->hold_timer);
+ EVENT_OFF(mac->hold_timer);
}
void zebra_evpn_sync_mac_del(struct zebra_mac *mac)
{
struct zebra_evpn_es *es;
- es = THREAD_ARG(t);
+ es = EVENT_ARG(t);
if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
zlog_debug("es %s df-delay expired", es->esi_str);
es->flags &= ~(ZEBRA_EVPNES_LOCAL | ZEBRA_EVPNES_READY_FOR_BGP);
- THREAD_OFF(es->df_delay_timer);
+ EVENT_OFF(es->df_delay_timer);
/* clear EVPN protodown flags on the access port */
zebra_evpn_mh_clear_protodown_es(es);
if (zmh_info->startup_delay_timer) {
if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
zlog_debug("startup-delay timer cancelled");
- THREAD_OFF(zmh_info->startup_delay_timer);
+ EVENT_OFF(zmh_info->startup_delay_timer);
}
if (zmh_info->startup_delay_time) {
bool old_n_static;
bool new_n_static;
- n = THREAD_ARG(t);
+ n = EVENT_ARG(t);
/* the purpose of the hold timer is to age out the peer-active
* flag
*/
listnode_delete(n->mac->neigh_list, n);
/* Cancel auto recovery */
- THREAD_OFF(n->dad_ip_auto_recovery_timer);
+ EVENT_OFF(n->dad_ip_auto_recovery_timer);
/* Cancel proxy hold timer */
zebra_evpn_neigh_stop_hold_timer(n);
struct zebra_neigh *nbr = NULL;
struct zebra_evpn *zevpn = NULL;
- nbr = THREAD_ARG(t);
+ nbr = EVENT_ARG(t);
/* since this is asynchronous we need sanity checks*/
zvrf = vrf_info_lookup(nbr->zevpn->vrf_id);
nbr->dad_dup_detect_time = monotime(NULL);
/* Start auto recovery timer for this IP */
- THREAD_OFF(nbr->dad_ip_auto_recovery_timer);
+ EVENT_OFF(nbr->dad_ip_auto_recovery_timer);
if (zvrf->dad_freeze && zvrf->dad_freeze_time) {
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
nbr->detect_start_time.tv_sec = 0;
nbr->detect_start_time.tv_usec = 0;
nbr->dad_dup_detect_time = 0;
- THREAD_OFF(nbr->dad_ip_auto_recovery_timer);
+ EVENT_OFF(nbr->dad_ip_auto_recovery_timer);
if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
zebra_evpn_neigh_send_add_to_client(zevpn->vni, &nbr->ip,
if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
zlog_debug("sync-neigh vni %u ip %pIA mac %pEA 0x%x hold stop",
n->zevpn->vni, &n->ip, &n->emac, n->flags);
- THREAD_OFF(n->hold_timer);
+ EVENT_OFF(n->hold_timer);
}
void zebra_evpn_sync_neigh_static_chg(struct zebra_neigh *n, bool old_n_static,
*/
static inline void zfpm_read_off(void)
{
- THREAD_OFF(zfpm_g->t_read);
+ EVENT_OFF(zfpm_g->t_read);
}
/*
*/
static inline void zfpm_write_off(void)
{
- THREAD_OFF(zfpm_g->t_write);
+ EVENT_OFF(zfpm_g->t_write);
}
static inline void zfpm_connect_off(void)
{
- THREAD_OFF(zfpm_g->t_connect);
+ EVENT_OFF(zfpm_g->t_connect);
}
/*
/*
* Start thread to push existing routes to the FPM.
*/
- THREAD_OFF(zfpm_g->t_conn_up);
+ EVENT_OFF(zfpm_g->t_conn_up);
zfpm_rnodes_iter_init(&zfpm_g->t_conn_up_state.iter);
zfpm_g->fpm_mac_dump_done = false;
return;
zfpm_debug("Stopping existing stats timer");
- THREAD_OFF(zfpm_g->t_stats);
+ EVENT_OFF(zfpm_g->t_stats);
}
/*
/* Cancel the stale timer */
if (info->t_stale_removal != NULL) {
- THREAD_OFF(info->t_stale_removal);
+ EVENT_OFF(info->t_stale_removal);
info->t_stale_removal = NULL;
/* Process the stale routes */
event_execute(
TAILQ_REMOVE(&(client->gr_info_queue), info, gr_info);
- THREAD_OFF(info->t_stale_removal);
+ EVENT_OFF(info->t_stale_removal);
XFREE(MTYPE_ZEBRA_GR, info->current_prefix);
*/
static void zebra_gr_route_stale_delete_timer_expiry(struct event *thread)
{
- struct client_gr_info *info = THREAD_ARG(thread);
+ struct client_gr_info *info = EVENT_ARG(thread);
int32_t cnt = 0;
struct zserv *client;
struct vrf *vrf = vrf_lookup_by_id(info->vrf_id);
LOG_GR("%s: Client %s canceled stale delete timer vrf %s(%d)",
__func__, zebra_route_string(client->proto),
VRF_LOGNAME(vrf), info->vrf_id);
- THREAD_OFF(info->t_stale_removal);
+ EVENT_OFF(info->t_stale_removal);
event_execute(zrouter.master,
zebra_gr_route_stale_delete_timer_expiry, info,
0);
*/
static void zebra_mlag_post_data_from_main_thread(struct event *thread)
{
- struct stream *s = THREAD_ARG(thread);
+ struct stream *s = EVENT_ARG(thread);
struct stream *zebra_s = NULL;
struct listnode *node;
struct zserv *client;
static void zebra_ns_ready_read(struct event *t)
{
- struct zebra_netns_info *zns_info = THREAD_ARG(t);
+ struct zebra_netns_info *zns_info = EVENT_ARG(t);
const char *netnspath;
int err, stop_retry = 0;
static void zebra_ns_notify_read(struct event *t)
{
- int fd_monitor = THREAD_FD(t);
+ int fd_monitor = EVENT_FD(t);
struct inotify_event *event;
char buf[BUFSIZ];
ssize_t len;
fd = zebra_netns_notify_current->u.fd;
if (zebra_netns_notify_current->master != NULL)
- THREAD_OFF(zebra_netns_notify_current);
+ EVENT_OFF(zebra_netns_notify_current);
/* auto-removal of notify items */
if (fd > 0)
nhe->nhg.nexthop);
}
- THREAD_OFF(nhe->timer);
+ EVENT_OFF(nhe->timer);
zebra_nhg_free_members(nhe);
nhe->nhg.nexthop);
}
- THREAD_OFF(nhe->timer);
+ EVENT_OFF(nhe->timer);
nexthops_free(nhe->nhg.nexthop);
static void zebra_nhg_timer(struct event *thread)
{
- struct nhg_hash_entry *nhe = THREAD_ARG(thread);
+ struct nhg_hash_entry *nhe = EVENT_ARG(thread);
if (IS_ZEBRA_DEBUG_NHG_DETAIL)
zlog_debug("Nexthop Timer for nhe: %pNG", nhe);
nhe->refcnt++;
if (event_is_scheduled(nhe->timer)) {
- THREAD_OFF(nhe->timer);
+ EVENT_OFF(nhe->timer);
nhe->refcnt--;
UNSET_FLAG(nhe->flags, NEXTHOP_GROUP_KEEP_AROUND);
}
/* Dont call the dec API, we dont want to uninstall the ID */
old->refcnt = 0;
- THREAD_OFF(old->timer);
+ EVENT_OFF(old->timer);
zebra_nhg_free(old);
old = NULL;
}
free(ptm_cb.in_data);
/* Cancel events. */
- THREAD_OFF(ptm_cb.t_read);
- THREAD_OFF(ptm_cb.t_write);
- THREAD_OFF(ptm_cb.t_timer);
+ EVENT_OFF(ptm_cb.t_read);
+ EVENT_OFF(ptm_cb.t_write);
+ EVENT_OFF(ptm_cb.t_timer);
if (ptm_cb.wb)
buffer_free(ptm_cb.wb);
ptm_cb.reconnect_time, &ptm_cb.t_timer);
return -1;
case BUFFER_EMPTY:
- THREAD_OFF(ptm_cb.t_write);
+ EVENT_OFF(ptm_cb.t_write);
break;
case BUFFER_PENDING:
event_add_write(zrouter.master, zebra_ptm_flush_messages, NULL,
int rc;
errno = 0;
- sock = THREAD_FD(thread);
+ sock = EVENT_FD(thread);
if (sock == -1)
return;
dplane_pw_uninstall(pw);
}
- THREAD_OFF(pw->install_retry_timer);
+ EVENT_OFF(pw->install_retry_timer);
/* unlink and release memory */
RB_REMOVE(zebra_pw_head, &zvrf->pseudowires, pw);
pw->vrf_id, pw->ifname, PW_INSTALL_RETRY_INTERVAL);
/* schedule to retry later */
- THREAD_OFF(pw->install_retry_timer);
+ EVENT_OFF(pw->install_retry_timer);
event_add_timer(zrouter.master, zebra_pw_install_retry, pw,
PW_INSTALL_RETRY_INTERVAL, &pw->install_retry_timer);
static void zebra_pw_install_retry(struct event *thread)
{
- struct zebra_pw *pw = THREAD_ARG(thread);
+ struct zebra_pw *pw = EVENT_ARG(thread);
zebra_pw_install(pw);
}
{
struct rib_update_ctx *ctx;
- ctx = THREAD_ARG(thread);
+ ctx = EVENT_ARG(thread);
rib_update_handle_vrf_all(ctx->event, ZEBRA_ROUTE_ALL);
if (!value && zebra_t_rmap_update) {
/* Event driven route map updates is being disabled */
/* But there's a pending timer. Fire it off now */
- THREAD_OFF(zebra_t_rmap_update);
+ EVENT_OFF(zebra_t_rmap_update);
zebra_route_map_update_timer(NULL);
}
}
/* Set zebra_rmap_update_timer to 0 so that it wont schedule again */
zebra_rmap_update_timer = 0;
/* Thread off if any scheduled already */
- THREAD_OFF(zebra_t_rmap_update);
+ EVENT_OFF(zebra_t_rmap_update);
route_map_finish();
}
{
/* rmap_update_timer of 0 means don't do route updates */
if (zebra_rmap_update_timer)
- THREAD_OFF(zebra_t_rmap_update);
+ EVENT_OFF(zebra_t_rmap_update);
event_add_timer(zrouter.master, zebra_route_map_update_timer, NULL,
zebra_rmap_update_timer, &zebra_t_rmap_update);
{
struct zebra_router_table *zrt, *tmp;
- THREAD_OFF(zrouter.sweeper);
+ EVENT_OFF(zrouter.sweeper);
RB_FOREACH_SAFE (zrt, zebra_router_table_head, &zrouter.tables, tmp)
zebra_router_free_table(zrt);
mac->detect_start_time.tv_sec = 0;
mac->detect_start_time.tv_usec = 0;
mac->dad_dup_detect_time = 0;
- THREAD_OFF(mac->dad_mac_auto_recovery_timer);
+ EVENT_OFF(mac->dad_mac_auto_recovery_timer);
/* warn-only action return */
if (!zvrf->dad_freeze)
nbr->detect_start_time.tv_sec = 0;
nbr->detect_start_time.tv_usec = 0;
nbr->dad_dup_detect_time = 0;
- THREAD_OFF(nbr->dad_ip_auto_recovery_timer);
+ EVENT_OFF(nbr->dad_ip_auto_recovery_timer);
if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
zebra_evpn_neigh_send_add_to_client(zevpn->vni, ip, &nbr->emac,
mac->detect_start_time.tv_sec = 0;
mac->detect_start_time.tv_usec = 0;
mac->dad_dup_detect_time = 0;
- THREAD_OFF(mac->dad_mac_auto_recovery_timer);
+ EVENT_OFF(mac->dad_mac_auto_recovery_timer);
/* Remove all IPs as duplicate associcated with this MAC */
for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, nbr)) {
#include "lib/sockopt.h" /* for setsockopt_so_recvbuf, setsockopt... */
#include "lib/sockunion.h" /* for sockopt_reuseaddr, sockopt_reuseport */
#include "lib/stream.h" /* for STREAM_SIZE, stream (ptr only), ... */
-#include "event.h" /* for thread (ptr only), THREAD_ARG, ... */
+#include "event.h" /* for thread (ptr only), EVENT_ARG, ... */
#include "lib/vrf.h" /* for vrf_info_lookup, VRF_DEFAULT */
#include "lib/vty.h" /* for vty_out, vty (ptr only) */
#include "lib/zclient.h" /* for zmsghdr, ZEBRA_HEADER_SIZE, ZEBRA... */
atomic_store_explicit(&client->pthread->running, false,
memory_order_relaxed);
- THREAD_OFF(client->t_read);
- THREAD_OFF(client->t_write);
+ EVENT_OFF(client->t_read);
+ EVENT_OFF(client->t_write);
zserv_event(client, ZSERV_HANDLE_CLIENT_FAIL);
}
*/
static void zserv_write(struct event *thread)
{
- struct zserv *client = THREAD_ARG(thread);
+ struct zserv *client = EVENT_ARG(thread);
struct stream *msg;
uint32_t wcmd = 0;
struct stream_fifo *cache;
*/
static void zserv_read(struct event *thread)
{
- struct zserv *client = THREAD_ARG(thread);
+ struct zserv *client = EVENT_ARG(thread);
int sock;
size_t already;
struct stream_fifo *cache;
memory_order_relaxed);
cache = stream_fifo_new();
p2p = p2p_orig;
- sock = THREAD_FD(thread);
+ sock = EVENT_FD(thread);
while (p2p) {
ssize_t nb;
*/
static void zserv_process_messages(struct event *thread)
{
- struct zserv *client = THREAD_ARG(thread);
+ struct zserv *client = EVENT_ARG(thread);
struct stream *msg;
struct stream_fifo *cache = stream_fifo_new();
uint32_t p2p = zrouter.packets_to_process;
zebra_route_string(client->proto));
event_cancel_event(zrouter.master, client);
- THREAD_OFF(client->t_cleanup);
- THREAD_OFF(client->t_process);
+ EVENT_OFF(client->t_cleanup);
+ EVENT_OFF(client->t_process);
/* destroy pthread */
frr_pthread_destroy(client->pthread);
*/
static void zserv_handle_client_fail(struct event *thread)
{
- struct zserv *client = THREAD_ARG(thread);
+ struct zserv *client = EVENT_ARG(thread);
zserv_close_client(client);
}
struct sockaddr_in client;
socklen_t len;
- accept_sock = THREAD_FD(thread);
+ accept_sock = EVENT_FD(thread);
/* Reregister myself. */
zserv_event(NULL, ZSERV_ACCEPT);
projects / mirror / frr.git / commitdiff