proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-06-12 22:47:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #408 from qlyoung/remove-thread-macros

Browse Source 
*: remove THREAD_ON macros, add nullity check
This commit is contained in:
Russ White 2017-05-10 13:51:47 -04:00 committed by GitHub
commit 00a1578051
120 changed files with 1175 additions and 1099 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
bgpd/bgp_damp.c
View File

@ -116,8 +116,8 @@ bgp_reuse_timer (struct thread *t)
time_t t_now, t_diff;
damp->t_reuse = NULL;
damp->t_reuse =
thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
thread_add_timer(bm->master, bgp_reuse_timer, NULL, DELTA_REUSE,
&damp->t_reuse);
t_now = bgp_clock ();
@ -447,9 +447,8 @@ bgp_damp_enable (struct bgp *bgp, afi_t afi, safi_t safi, time_t half,
bgp_damp_parameter_set (half, reuse, suppress, max);
/* Register reuse timer. */
if (! damp->t_reuse)
damp->t_reuse =
thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
thread_add_timer(bm->master, bgp_reuse_timer, NULL, DELTA_REUSE,
&damp->t_reuse);
return 0;
}

10
bgpd/bgp_dump.c
View File

@ -171,14 +171,16 @@ bgp_dump_interval_add (struct bgp_dump *bgp_dump, int interval)
secs_into_day = tm->tm_sec + 60*tm->tm_min + 60*60*tm->tm_hour;
interval = interval - secs_into_day % interval; /* always > 0 */
}
bgp_dump->t_interval = thread_add_timer (bm->master, bgp_dump_interval_func,
bgp_dump, interval);
bgp_dump->t_interval = NULL;
thread_add_timer(bm->master, bgp_dump_interval_func, bgp_dump, interval,
&bgp_dump->t_interval);
}
else
{
/* One-off dump: execute immediately, don't affect any scheduled dumps */
bgp_dump->t_interval = thread_add_event (bm->master, bgp_dump_interval_func,
bgp_dump, 0);
bgp_dump->t_interval = NULL;
thread_add_event(bm->master, bgp_dump_interval_func, bgp_dump, 0,
&bgp_dump->t_interval);
}
return 0;

13
bgpd/bgp_fsm.c
View File

@ -808,9 +808,8 @@ bgp_maxmed_onstartup_begin (struct bgp *bgp)
zlog_info ("Begin maxmed onstartup mode - timer %d seconds",
bgp->v_maxmed_onstartup);
THREAD_TIMER_ON (bm->master, bgp->t_maxmed_onstartup,
bgp_maxmed_onstartup_timer,
bgp, bgp->v_maxmed_onstartup);
thread_add_timer(bm->master, bgp_maxmed_onstartup_timer, bgp,
bgp->v_maxmed_onstartup, &bgp->t_maxmed_onstartup);
if (!bgp->v_maxmed_admin)
{
@ -877,12 +876,12 @@ bgp_update_delay_begin (struct bgp *bgp)
peer->update_delay_over = 0;
/* Start the update-delay timer */
THREAD_TIMER_ON (bm->master, bgp->t_update_delay, bgp_update_delay_timer,
bgp, bgp->v_update_delay);
thread_add_timer(bm->master, bgp_update_delay_timer, bgp,
bgp->v_update_delay, &bgp->t_update_delay);
if (bgp->v_establish_wait != bgp->v_update_delay)
THREAD_TIMER_ON (bm->master, bgp->t_establish_wait, bgp_establish_wait_timer,
bgp, bgp->v_establish_wait);
thread_add_timer(bm->master, bgp_establish_wait_timer, bgp,
bgp->v_establish_wait, &bgp->t_establish_wait);
quagga_timestamp(3, bgp->update_delay_begin_time,
sizeof(bgp->update_delay_begin_time));

72
bgpd/bgp_fsm.h
View File

@ -23,58 +23,58 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#define _QUAGGA_BGP_FSM_H
/* Macro for BGP read, write and timer thread. */
#define BGP_READ_ON(T,F,V) \
do { \
if (!(T) && (peer->status != Deleted)) \
THREAD_READ_ON(bm->master,T,F,peer,V); \
#define BGP_READ_ON(T,F,V) \
do { \
if ((peer->status != Deleted)) \
thread_add_read (bm->master,(F),peer,(V),&(T)); \
} while (0)
#define BGP_READ_OFF(T) \
do { \
if (T) \
THREAD_READ_OFF(T); \
#define BGP_READ_OFF(T) \
do { \
if (T) \
THREAD_READ_OFF(T); \
} while (0)
#define BGP_WRITE_ON(T,F,V) \
do { \
if (!(T) && (peer->status != Deleted)) \
THREAD_WRITE_ON(bm->master,(T),(F),peer,(V)); \
#define BGP_WRITE_ON(T,F,V) \
do { \
if ((peer)->status != Deleted) \
thread_add_write (bm->master,(F),(peer),(V),&(T)); \
} while (0)
#define BGP_PEER_WRITE_ON(T,F,V, peer) \
do { \
if (!(T) && ((peer)->status != Deleted)) \
THREAD_WRITE_ON(bm->master,(T),(F),(peer),(V)); \
#define BGP_PEER_WRITE_ON(T,F,V, peer) \
do { \
if ((peer)->status != Deleted) \
thread_add_write (bm->master,(F),(peer),(V),&(T)); \
} while (0)
#define BGP_WRITE_OFF(T) \
do { \
if (T) \
THREAD_WRITE_OFF(T); \
#define BGP_WRITE_OFF(T) \
do { \
if (T) \
THREAD_WRITE_OFF(T); \
} while (0)
#define BGP_TIMER_ON(T,F,V) \
do { \
if (!(T) && (peer->status != Deleted)) \
THREAD_TIMER_ON(bm->master,(T),(F),peer,(V)); \
#define BGP_TIMER_ON(T,F,V) \
do { \
if ((peer->status != Deleted)) \
thread_add_timer (bm->master,(F),peer,(V),&(T)); \
} while (0)
#define BGP_TIMER_OFF(T) \
do { \
if (T) \
THREAD_TIMER_OFF(T); \
#define BGP_TIMER_OFF(T) \
do { \
if (T) \
THREAD_TIMER_OFF(T); \
} while (0)
#define BGP_EVENT_ADD(P,E) \
do { \
if ((P)->status != Deleted) \
thread_add_event (bm->master, bgp_event, (P), (E)); \
#define BGP_EVENT_ADD(P,E) \
do { \
if ((P)->status != Deleted) \
thread_add_event (bm->master, bgp_event, (P), (E), NULL); \
} while (0)
#define BGP_EVENT_FLUSH(P) \
do { \
assert (peer); \
thread_cancel_event (bm->master, (P)); \
#define BGP_EVENT_FLUSH(P) \
do { \
assert (peer); \
thread_cancel_event (bm->master, (P)); \
} while (0)
#define BGP_MSEC_JITTER 10

7
bgpd/bgp_network.c
View File

@ -297,7 +297,9 @@ bgp_accept (struct thread *thread)
zlog_err ("accept_sock is nevative value %d", accept_sock);
return -1;
}
listener->thread = thread_add_read (bm->master, bgp_accept, listener, accept_sock);
listener->thread = NULL;
thread_add_read(bm->master, bgp_accept, listener, accept_sock,
&listener->thread);
/* Accept client connection. */
bgp_sock = sockunion_accept (accept_sock, &su);
@ -704,7 +706,8 @@ bgp_listener (int sock, struct sockaddr *sa, socklen_t salen)
listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener));
listener->fd = sock;
memcpy(&listener->su, sa, salen);
listener->thread = thread_add_read (bm->master, bgp_accept, listener, sock);
listener->thread = NULL;
thread_add_read(bm->master, bgp_accept, listener, sock, &listener->thread);
listnode_add (bm->listen_sockets, listener);
return 0;

18
bgpd/bgp_route.c
View File

@ -2017,9 +2017,10 @@ bgp_process_main (struct work_queue *wq, void *data)
if (!bgp->t_rmap_def_originate_eval)
{
bgp_lock (bgp);
THREAD_TIMER_ON(bm->master, bgp->t_rmap_def_originate_eval,
update_group_refresh_default_originate_route_map,
bgp, RMAP_DEFAULT_ORIGINATE_EVAL_TIMER);
thread_add_timer(bm->master,
update_group_refresh_default_originate_route_map,
bgp, RMAP_DEFAULT_ORIGINATE_EVAL_TIMER,
&bgp->t_rmap_def_originate_eval);
}
}
@ -3088,9 +3089,6 @@ bgp_announce_route_timer_expired (struct thread *t)
paf = THREAD_ARG (t);
peer = paf->peer;
assert (paf->t_announce_route);
paf->t_announce_route = NULL;
if (peer->status != Established)
return 0;
@ -3130,11 +3128,9 @@ bgp_announce_route (struct peer *peer, afi_t afi, safi_t safi)
* multiple peers and the announcement doesn't happen in the
* vty context.
*/
THREAD_TIMER_MSEC_ON (bm->master, paf->t_announce_route,
bgp_announce_route_timer_expired, paf,
(subgrp->peer_count == 1) ?
BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS :
BGP_ANNOUNCE_ROUTE_DELAY_MS);
thread_add_timer_msec(bm->master, bgp_announce_route_timer_expired, paf,
(subgrp->peer_count == 1) ? BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS : BGP_ANNOUNCE_ROUTE_DELAY_MS,
&paf->t_announce_route);
}
/*

6
bgpd/bgp_routemap.c
View File

@ -3176,9 +3176,9 @@ bgp_route_map_mark_update (const char *rmap_name)
/* rmap_update_timer of 0 means don't do route updates */
if (bm->rmap_update_timer)
{
bm->t_rmap_update =
thread_add_timer(bm->master, bgp_route_map_update_timer, NULL,
bm->rmap_update_timer);
bm->t_rmap_update = NULL;
thread_add_timer(bm->master, bgp_route_map_update_timer, NULL, bm->rmap_update_timer,
&bm->t_rmap_update);
/* Signal the groups that a route-map update event has started */
for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))

7
bgpd/bgp_updgrp.c
View File

@ -1169,10 +1169,9 @@ update_subgroup_trigger_merge_check (struct update_subgroup *subgrp,
if (!force && !update_subgroup_ready_for_merge (subgrp))
return 0;
subgrp->t_merge_check =
thread_add_background (bm->master,
update_subgroup_merge_check_thread_cb,
subgrp, 0);
subgrp->t_merge_check = NULL;
thread_add_background(bm->master, update_subgroup_merge_check_thread_cb, subgrp, 0,
&subgrp->t_merge_check);
SUBGRP_INCR_STAT (subgrp, merge_checks_triggered);

4
bgpd/bgp_updgrp_adv.c
View File

@ -828,8 +828,8 @@ subgroup_announce_all (struct update_subgroup *subgrp)
*/
if (!subgrp->t_coalesce)
{
THREAD_TIMER_MSEC_ON (bm->master, subgrp->t_coalesce, subgroup_coalesce_timer,
subgrp, subgrp->v_coalesce);
thread_add_timer_msec(bm->master, subgroup_coalesce_timer, subgrp,
subgrp->v_coalesce, &subgrp->t_coalesce);
}
}

4
bgpd/bgpd.c
View File

@ -2970,8 +2970,8 @@ bgp_create (as_t *as, const char *name, enum bgp_instance_type inst_type)
else
{
/* TODO - The startup timer needs to be run for the whole of BGP */
THREAD_TIMER_ON (bm->master, bgp->t_startup, bgp_startup_timer_expire,
bgp, bgp->restart_time);
thread_add_timer(bm->master, bgp_startup_timer_expire, bgp,
bgp->restart_time, &bgp->t_startup);
}
bgp->wpkt_quanta = BGP_WRITE_PACKET_MAX;

13
bgpd/rfapi/rfapi_import.c
View File

@ -3033,9 +3033,9 @@ rfapiBiStartWithdrawTimer (
if (lifetime > UINT32_MAX / 1001)
{
/* sub-optimal case, but will probably never happen */
bi->extra->vnc.import.timer = thread_add_timer (bm->master,
timer_service_func,
wcb, lifetime);
bi->extra->vnc.import.timer = NULL;
thread_add_timer(bm->master, timer_service_func, wcb, lifetime,
&bi->extra->vnc.import.timer);
}
else
{
@ -3051,10 +3051,9 @@ rfapiBiStartWithdrawTimer (
lifetime_msec = (lifetime * 1000) + jitter;
bi->extra->vnc.import.timer = thread_add_background (bm->master,
timer_service_func,
wcb,
lifetime_msec);
bi->extra->vnc.import.timer = NULL;
thread_add_background(bm->master, timer_service_func, wcb, lifetime_msec,
&bi->extra->vnc.import.timer);
}
/* re-sort route list (BGP_INFO_REMOVED routes are last) */

10
bgpd/rfapi/rfapi_monitor.c
View File

@ -852,8 +852,9 @@ rfapiMonitorTimerRestart (struct rfapi_monitor_vpn *m)
rfapi_ntop (m->p.family, m->p.u.val, buf, BUFSIZ),
m->rfd->response_lifetime);
}
m->timer = thread_add_timer (bm->master, rfapiMonitorTimerExpire, m,
m->rfd->response_lifetime);
m->timer = NULL;
thread_add_timer(bm->master, rfapiMonitorTimerExpire, m, m->rfd->response_lifetime,
&m->timer);
}
/*
@ -1183,8 +1184,9 @@ rfapiMonitorEthTimerRestart (struct rfapi_monitor_eth *m)
rfapiEthAddr2Str (&m->macaddr, buf, BUFSIZ),
m->rfd->response_lifetime);
}
m->timer = thread_add_timer (bm->master, rfapiMonitorEthTimerExpire, m,
m->rfd->response_lifetime);
m->timer = NULL;
thread_add_timer(bm->master, rfapiMonitorEthTimerExpire, m, m->rfd->response_lifetime,
&m->timer);
}
static int

5
bgpd/rfapi/rfapi_rib.c
View File

@ -400,8 +400,9 @@ rfapiRibStartTimer (
prefix2str (&rn->p, buf_prefix, BUFSIZ);
vnc_zlog_debug_verbose ("%s: rfd %p pfx %s life %u", __func__, rfd, buf_prefix,
ri->lifetime);
ri->timer = thread_add_timer (bm->master, rfapiRibExpireTimer,
tcb, ri->lifetime);
ri->timer = NULL;
thread_add_timer(bm->master, rfapiRibExpireTimer, tcb, ri->lifetime,
&ri->timer);
assert (ri->timer);
}

6
bgpd/rfapi/vnc_export_bgp.c
View File

@ -1856,9 +1856,9 @@ vnc_direct_bgp_rh_del_route (
if (!eti->timer && eti->lifetime <= INT32_MAX)
{
eti->timer = thread_add_timer (bm->master,
vncExportWithdrawTimer,
eti, eti->lifetime);
eti->timer = NULL;
thread_add_timer(bm->master, vncExportWithdrawTimer, eti, eti->lifetime,
&eti->timer);
vnc_zlog_debug_verbose ("%s: set expiration timer for %u seconds",
__func__, eti->lifetime);
}

8
eigrpd/eigrp_filter.c
View File

@ -181,7 +181,9 @@ eigrp_distribute_update (struct distribute *dist)
thread_cancel(e->t_distribute);
}
/* schedule Graceful restart for whole process in 10sec */
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_process, e,(10));
e->t_distribute = NULL;
thread_add_timer(master, eigrp_distribute_timer_process, e, (10),
&e->t_distribute);
return;
}
@ -305,7 +307,9 @@ eigrp_distribute_update (struct distribute *dist)
thread_cancel(ei->t_distribute);
}
/* schedule Graceful restart for interface in 10sec */
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_interface, ei, 10);
e->t_distribute = NULL;
thread_add_timer(master, eigrp_distribute_timer_interface, ei, 10,
&e->t_distribute);
}
/*

17
eigrpd/eigrp_hello.c
View File

@ -101,8 +101,9 @@ eigrp_hello_timer (struct thread *thread)
eigrp_hello_send(ei, EIGRP_HELLO_NORMAL, NULL);
/* Hello timer set. */
ei->t_hello = thread_add_timer(master, eigrp_hello_timer, ei,
EIGRP_IF_PARAM(ei, v_hello));
ei->t_hello = NULL;
thread_add_timer(master, eigrp_hello_timer, ei, EIGRP_IF_PARAM(ei, v_hello),
&ei->t_hello);
return 0;
}
@ -713,9 +714,8 @@ eigrp_hello_send_ack (struct eigrp_neighbor *nbr)
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd,
&nbr->ei->eigrp->t_write);
}
}
@ -766,13 +766,12 @@ eigrp_hello_send (struct eigrp_interface *ei, u_char flags, struct in_addr *nbr_
{
if(flags & EIGRP_HELLO_GRACEFUL_SHUTDOWN)
{
ei->eigrp->t_write =
thread_execute(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
thread_execute(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
}
else
{
ei->eigrp->t_write =
thread_add_write(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
thread_add_write(master, eigrp_write, ei->eigrp, ei->eigrp->fd,
&ei->eigrp->t_write);
}
}
}

2
eigrpd/eigrp_interface.c
View File

@ -276,7 +276,7 @@ eigrp_if_up (struct eigrp_interface *ei)
/* Set multicast memberships appropriately for new state. */
eigrp_if_set_multicast (ei);
thread_add_event (master, eigrp_hello_timer, ei, (1));
thread_add_event(master, eigrp_hello_timer, ei, (1), NULL);
/*Prepare metrics*/
metric.bandwith = eigrp_bandwidth_to_scaled (EIGRP_IF_PARAM (ei,bandwidth));

8
eigrpd/eigrp_neighbor.c
View File

@ -298,16 +298,16 @@ eigrp_nbr_state_update (struct eigrp_neighbor *nbr)
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
thread_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);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
thread_add_timer(master, holddown_timer_expired, nbr,
nbr->v_holddown, &nbr->t_holddown);
break;
}
}

38
eigrpd/eigrp_packet.c
View File

@ -448,8 +448,10 @@ eigrp_write (struct thread *thread)
}
/* If packets still remain in queue, call write thread. */
if (!list_isempty(eigrp->oi_write_q))
eigrp->t_write = thread_add_write(master, eigrp_write, eigrp, eigrp->fd);
if (!list_isempty(eigrp->oi_write_q)) {
eigrp->t_write = NULL;
thread_add_write(master, eigrp_write, eigrp, eigrp->fd, &eigrp->t_write);
}
return 0;
}
@ -474,7 +476,8 @@ eigrp_read (struct thread *thread)
eigrp = THREAD_ARG(thread);
/* prepare for next packet. */
eigrp->t_read = thread_add_read(master, eigrp_read, eigrp, eigrp->fd);
eigrp->t_read = NULL;
thread_add_read(master, eigrp_read, eigrp, eigrp->fd, &eigrp->t_read);
stream_reset(eigrp->ibuf);
if (!(ibuf = eigrp_recv_packet(eigrp->fd, &ifp, eigrp->ibuf)))
@ -846,8 +849,8 @@ eigrp_send_packet_reliably (struct eigrp_neighbor *nbr)
eigrp_fifo_push_head(nbr->ei->obuf, duplicate);
/*Start retransmission timer*/
THREAD_TIMER_ON(master, ep->t_retrans_timer, eigrp_unack_packet_retrans,
nbr, EIGRP_PACKET_RETRANS_TIME);
thread_add_timer(master, eigrp_unack_packet_retrans, nbr,
EIGRP_PACKET_RETRANS_TIME, &ep->t_retrans_timer);
/*Increment sequence number counter*/
nbr->ei->eigrp->sequence_number++;
@ -858,9 +861,8 @@ eigrp_send_packet_reliably (struct eigrp_neighbor *nbr)
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd,
&nbr->ei->eigrp->t_write);
}
}
@ -1048,8 +1050,9 @@ eigrp_unack_packet_retrans (struct thread *thread)
return eigrp_retrans_count_exceeded(ep, nbr);
/*Start retransmission timer*/
ep->t_retrans_timer =
thread_add_timer(master, eigrp_unack_packet_retrans, nbr,EIGRP_PACKET_RETRANS_TIME);
ep->t_retrans_timer = NULL;
thread_add_timer(master, eigrp_unack_packet_retrans, nbr, EIGRP_PACKET_RETRANS_TIME,
&ep->t_retrans_timer);
/* Hook thread to write packet. */
if (nbr->ei->on_write_q == 0)
@ -1057,9 +1060,8 @@ eigrp_unack_packet_retrans (struct thread *thread)
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd,
&nbr->ei->eigrp->t_write);
}
return 0;
@ -1086,8 +1088,9 @@ eigrp_unack_multicast_packet_retrans (struct thread *thread)
return eigrp_retrans_count_exceeded(ep, nbr);
/*Start retransmission timer*/
ep->t_retrans_timer =
thread_add_timer(master, eigrp_unack_multicast_packet_retrans, nbr,EIGRP_PACKET_RETRANS_TIME);
ep->t_retrans_timer = NULL;
thread_add_timer(master, eigrp_unack_multicast_packet_retrans, nbr, EIGRP_PACKET_RETRANS_TIME,
&ep->t_retrans_timer);
/* Hook thread to write packet. */
if (nbr->ei->on_write_q == 0)
@ -1095,9 +1098,8 @@ eigrp_unack_multicast_packet_retrans (struct thread *thread)
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd,
&nbr->ei->eigrp->t_write);
}
return 0;

13
eigrpd/eigrp_update.c
View File

@ -1046,7 +1046,9 @@ eigrp_update_send_GR_thread(struct thread *thread)
* schedule this thread again with small delay */
if(nbr->retrans_queue->count > 0)
{
nbr->t_nbr_send_gr = thread_add_timer_msec(master, eigrp_update_send_GR_thread, nbr, 10);
nbr->t_nbr_send_gr = NULL;
thread_add_timer_msec(master, eigrp_update_send_GR_thread, nbr, 10,
&nbr->t_nbr_send_gr);
return 0;
}
@ -1054,8 +1056,10 @@ eigrp_update_send_GR_thread(struct thread *thread)
eigrp_update_send_GR_part(nbr);
/* if it wasn't last chunk, schedule this thread again */
if(nbr->nbr_gr_packet_type != EIGRP_PACKET_PART_LAST)
nbr->t_nbr_send_gr = thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
if(nbr->nbr_gr_packet_type != EIGRP_PACKET_PART_LAST) {
thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
nbr->t_nbr_send_gr = NULL;
}
return 0;
}
@ -1115,7 +1119,8 @@ eigrp_update_send_GR (struct eigrp_neighbor *nbr, enum GR_type gr_type, struct v
/* indicate, that this is first GR Update packet chunk */
nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_FIRST;
/* execute packet sending in thread */
nbr->t_nbr_send_gr = thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
nbr->t_nbr_send_gr = NULL;
}
/**

3
eigrpd/eigrpd.c
View File

@ -181,7 +181,8 @@ eigrp_new (const char *AS)
exit(1);
}
eigrp->t_read = thread_add_read(master, eigrp_read, eigrp, eigrp->fd);
eigrp->t_read = NULL;
thread_add_read(master, eigrp_read, eigrp, eigrp->fd, &eigrp->t_read);
eigrp->oi_write_q = list_new();
eigrp->topology_table = eigrp_topology_new();

35
isisd/isis_circuit.c
View File

@ -607,11 +607,12 @@ void
isis_circuit_prepare (struct isis_circuit *circuit)
{
#ifdef GNU_LINUX
THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
circuit->fd);
thread_add_read(master, isis_receive, circuit, circuit->fd,
&circuit->t_read);
#else
THREAD_TIMER_MSEC_ON (master, circuit->t_read, isis_receive, circuit,
listcount (circuit->area->circuit_list) * 100);
thread_add_timer_msec(master, isis_receive, circuit,
listcount(circuit->area->circuit_list) * 100,
&circuit->t_read);
#endif
}
@ -672,13 +673,13 @@ isis_circuit_up (struct isis_circuit *circuit)
if (circuit->is_type & IS_LEVEL_1)
{
thread_add_event (master, send_lan_l1_hello, circuit, 0);
thread_add_event(master, send_lan_l1_hello, circuit, 0, NULL);
circuit->u.bc.lan_neighs[0] = list_new ();
}
if (circuit->is_type & IS_LEVEL_2)
{
thread_add_event (master, send_lan_l2_hello, circuit, 0);
thread_add_event(master, send_lan_l2_hello, circuit, 0, NULL);
circuit->u.bc.lan_neighs[1] = list_new ();
}
@ -688,11 +689,13 @@ isis_circuit_up (struct isis_circuit *circuit)
/* 8.4.1 d) */
/* dr election will commence in... */
if (circuit->is_type & IS_LEVEL_1)
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
thread_add_timer(master, isis_run_dr_l1, circuit,
2 * circuit->hello_interval[0],
&circuit->u.bc.t_run_dr[0]);
if (circuit->is_type & IS_LEVEL_2)
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
thread_add_timer(master, isis_run_dr_l2, circuit,
2 * circuit->hello_interval[1],
&circuit->u.bc.t_run_dr[1]);
}
else
{
@ -700,17 +703,19 @@ isis_circuit_up (struct isis_circuit *circuit)
* for a ptp IF
*/
circuit->u.p2p.neighbor = NULL;
thread_add_event (master, send_p2p_hello, circuit, 0);
thread_add_event(master, send_p2p_hello, circuit, 0, NULL);
}
/* initializing PSNP timers */
if (circuit->is_type & IS_LEVEL_1)
THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
thread_add_timer(master, send_l1_psnp, circuit,
isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
&circuit->t_send_psnp[0]);
if (circuit->is_type & IS_LEVEL_2)
THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
thread_add_timer(master, send_l2_psnp, circuit,
isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
&circuit->t_send_psnp[1]);
/* unified init for circuits; ignore warnings below this level */
retv = isis_sock_init (circuit);

58
isisd/isis_dr.c
View File

@ -259,12 +259,13 @@ isis_dr_resign (struct isis_circuit *circuit, int level)
THREAD_TIMER_OFF (circuit->t_send_csnp[0]);
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
thread_add_timer(master, isis_run_dr_l1, circuit,
2 * circuit->hello_interval[0],
&circuit->u.bc.t_run_dr[0]);
THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
isis_jitter (circuit->psnp_interval[level - 1],
PSNP_JITTER));
thread_add_timer(master, send_l1_psnp, circuit,
isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
&circuit->t_send_psnp[0]);
}
else
{
@ -272,15 +273,16 @@ isis_dr_resign (struct isis_circuit *circuit, int level)
THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
thread_add_timer(master, isis_run_dr_l2, circuit,
2 * circuit->hello_interval[1],
&circuit->u.bc.t_run_dr[1]);
THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
isis_jitter (circuit->psnp_interval[level - 1],
PSNP_JITTER));
thread_add_timer(master, send_l2_psnp, circuit,
isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
&circuit->t_send_psnp[1]);
}
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
return ISIS_OK;
}
@ -296,11 +298,13 @@ isis_dr_commence (struct isis_circuit *circuit, int level)
/* Lets keep a pause in DR election */
circuit->u.bc.run_dr_elect[level - 1] = 0;
if (level == 1)
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
thread_add_timer(master, isis_run_dr_l1, circuit,
2 * circuit->hello_interval[0],
&circuit->u.bc.t_run_dr[0]);
else
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
thread_add_timer(master, isis_run_dr_l2, circuit,
2 * circuit->hello_interval[1],
&circuit->u.bc.t_run_dr[1]);
circuit->u.bc.is_dr[level - 1] = 1;
if (level == 1)
@ -321,12 +325,13 @@ isis_dr_commence (struct isis_circuit *circuit, int level)
lsp_generate_pseudo (circuit, 1);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
thread_add_timer(master, isis_run_dr_l1, circuit,
2 * circuit->hello_interval[0],
&circuit->u.bc.t_run_dr[0]);
THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
isis_jitter (circuit->csnp_interval[level - 1],
CSNP_JITTER));
thread_add_timer(master, send_l1_csnp, circuit,
isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
&circuit->t_send_csnp[0]);
}
else
@ -347,15 +352,16 @@ isis_dr_commence (struct isis_circuit *circuit, int level)
lsp_generate_pseudo (circuit, 2);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
thread_add_timer(master, isis_run_dr_l2, circuit,
2 * circuit->hello_interval[1],
&circuit->u.bc.t_run_dr[1]);
THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
isis_jitter (circuit->csnp_interval[level - 1],
CSNP_JITTER));
thread_add_timer(master, send_l2_csnp, circuit,
isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
&circuit->t_send_csnp[1]);
}
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
return ISIS_OK;
}

4
isisd/isis_dynhn.c
View File

@ -51,7 +51,7 @@ dyn_cache_init (void)
{
if (dyn_cache == NULL)
dyn_cache = list_new ();
THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
return;
}
@ -73,7 +73,7 @@ dyn_cache_cleanup (struct thread *thread)
XFREE (MTYPE_ISIS_DYNHN, dyn);
}
THREAD_TIMER_ON (master, isis->t_dync_clean, dyn_cache_cleanup, NULL, 120);
thread_add_timer(master, dyn_cache_cleanup, NULL, 120, &isis->t_dync_clean);
return ISIS_OK;
}

34
isisd/isis_events.c
View File

@ -82,18 +82,19 @@ circuit_commence_level (struct isis_circuit *circuit, int level)
if (level == 1)
{
if (! circuit->is_passive)
THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
thread_add_timer(master, send_l1_psnp, circuit,
isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
&circuit->t_send_psnp[0]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
circuit, 2 * circuit->hello_interval[0]);
thread_add_timer(master, isis_run_dr_l1, circuit,
2 * circuit->hello_interval[0],
&circuit->u.bc.t_run_dr[0]);
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
send_lan_l1_hello, circuit,
isis_jitter (circuit->hello_interval[0],
IIH_JITTER));
thread_add_timer(master, send_lan_l1_hello, circuit,
isis_jitter(circuit->hello_interval[0], IIH_JITTER),
&circuit->u.bc.t_send_lan_hello[0]);
circuit->u.bc.lan_neighs[0] = list_new ();
}
@ -101,18 +102,19 @@ circuit_commence_level (struct isis_circuit *circuit, int level)
else
{
if (! circuit->is_passive)
THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
thread_add_timer(master, send_l2_psnp, circuit,
isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
&circuit->t_send_psnp[1]);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
circuit, 2 * circuit->hello_interval[1]);
thread_add_timer(master, isis_run_dr_l2, circuit,
2 * circuit->hello_interval[1],
&circuit->u.bc.t_run_dr[1]);
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
send_lan_l2_hello, circuit,
isis_jitter (circuit->hello_interval[1],
IIH_JITTER));
thread_add_timer(master, send_lan_l2_hello, circuit,
isis_jitter(circuit->hello_interval[1], IIH_JITTER),
&circuit->u.bc.t_send_lan_hello[1]);
circuit->u.bc.lan_neighs[1] = list_new ();
}

57
isisd/isis_lsp.c
View File

@ -2034,11 +2034,11 @@ lsp_generate (struct isis_area *area, int level)
THREAD_TIMER_OFF (area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0;
if (level == IS_LEVEL_1)
THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
lsp_l1_refresh, area, refresh_time);
thread_add_timer(master, lsp_l1_refresh, area, refresh_time,
&area->t_lsp_refresh[level - 1]);
else if (level == IS_LEVEL_2)
THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
lsp_l2_refresh, area, refresh_time);
thread_add_timer(master, lsp_l2_refresh, area, refresh_time,
&area->t_lsp_refresh[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
@ -2111,11 +2111,11 @@ lsp_regenerate (struct isis_area *area, int level)
refresh_time = lsp_refresh_time (lsp, rem_lifetime);
if (level == IS_LEVEL_1)
THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
lsp_l1_refresh, area, refresh_time);
thread_add_timer(master, lsp_l1_refresh, area, refresh_time,
&area->t_lsp_refresh[level - 1]);
else if (level == IS_LEVEL_2)
THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
lsp_l2_refresh, area, refresh_time);
thread_add_timer(master, lsp_l2_refresh, area, refresh_time,
&area->t_lsp_refresh[level - 1]);
area->lsp_regenerate_pending[level - 1] = 0;
if (isis->debugs & DEBUG_UPDATE_PACKETS)
@ -2249,13 +2249,13 @@ lsp_regenerate_schedule (struct isis_area *area, int level, int all_pseudo)
area->lsp_regenerate_pending[lvl - 1] = 1;
if (lvl == IS_LEVEL_1)
{
THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
lsp_l1_refresh, area, timeout);
thread_add_timer_msec(master, lsp_l1_refresh, area, timeout,
&area->t_lsp_refresh[lvl - 1]);
}
else if (lvl == IS_LEVEL_2)
{
THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
lsp_l2_refresh, area, timeout);
thread_add_timer_msec(master, lsp_l2_refresh, area, timeout,
&area->t_lsp_refresh[lvl - 1]);
}
}
@ -2465,11 +2465,11 @@ lsp_generate_pseudo (struct isis_circuit *circuit, int level)
THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
circuit->lsp_regenerate_pending[level - 1] = 0;
if (level == IS_LEVEL_1)
THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
lsp_l1_refresh_pseudo, circuit, refresh_time);
thread_add_timer(master, lsp_l1_refresh_pseudo, circuit, refresh_time,
&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
else if (level == IS_LEVEL_2)
THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
lsp_l2_refresh_pseudo, circuit, refresh_time);
thread_add_timer(master, lsp_l2_refresh_pseudo, circuit, refresh_time,
&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
@ -2528,11 +2528,11 @@ lsp_regenerate_pseudo (struct isis_circuit *circuit, int level)
refresh_time = lsp_refresh_time (lsp, rem_lifetime);
if (level == IS_LEVEL_1)
THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
lsp_l1_refresh_pseudo, circuit, refresh_time);
thread_add_timer(master, lsp_l1_refresh_pseudo, circuit, refresh_time,
&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
else if (level == IS_LEVEL_2)
THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
lsp_l2_refresh_pseudo, circuit, refresh_time);
thread_add_timer(master, lsp_l2_refresh_pseudo, circuit, refresh_time,
&circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
if (isis->debugs & DEBUG_UPDATE_PACKETS)
{
@ -2684,15 +2684,15 @@ lsp_regenerate_schedule_pseudo (struct isis_circuit *circuit, int level)
if (lvl == IS_LEVEL_1)
{
THREAD_TIMER_MSEC_ON(master,
circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
lsp_l1_refresh_pseudo, circuit, timeout);
thread_add_timer_msec(master, lsp_l1_refresh_pseudo, circuit,
timeout,
&circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
}
else if (lvl == IS_LEVEL_2)
{
THREAD_TIMER_MSEC_ON(master,
circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
lsp_l2_refresh_pseudo, circuit, timeout);
thread_add_timer_msec(master, lsp_l2_refresh_pseudo, circuit,
timeout,
&circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
}
}
@ -2721,7 +2721,7 @@ lsp_tick (struct thread *thread)
area = THREAD_ARG (thread);
assert (area);
area->t_tick = NULL;
THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
thread_add_timer(master, lsp_tick, area, 1, &area->t_tick);
/*
* Build a list of LSPs with (any) SRMflag set
@ -2799,7 +2799,8 @@ lsp_tick (struct thread *thread)
if (! listnode_lookup (circuit->lsp_queue, lsp))
{
listnode_add (circuit->lsp_queue, lsp);
thread_add_event (master, send_lsp, circuit, 0);
thread_add_event(master, send_lsp, circuit, 0,
NULL);
}
}
}

52
isisd/isis_pdu.c
View File

@ -569,8 +569,8 @@ process_p2p_hello (struct isis_circuit *circuit)
/* lets take care of the expiry */
THREAD_TIMER_OFF (adj->t_expire);
THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
(long) adj->hold_time);
thread_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
&adj->t_expire);
/* 8.2.5.2 a) a match was detected */
if (area_match (circuit->area->area_addrs, tlvs.area_addrs))
@ -1124,7 +1124,8 @@ process_lan_hello (int level, struct isis_circuit *circuit, const u_char *ssnpa)
case 1:
if (memcmp (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
{
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
thread_add_event(master, isis_event_dis_status_change, circuit, 0,
NULL);
memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id,
ISIS_SYS_ID_LEN + 1);
}
@ -1132,7 +1133,8 @@ process_lan_hello (int level, struct isis_circuit *circuit, const u_char *ssnpa)
case 2:
if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
{
thread_add_event (master, isis_event_dis_status_change, circuit, 0);
thread_add_event(master, isis_event_dis_status_change, circuit, 0,
NULL);
memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id,
ISIS_SYS_ID_LEN + 1);
}
@ -1167,8 +1169,8 @@ process_lan_hello (int level, struct isis_circuit *circuit, const u_char *ssnpa)
/* lets take care of the expiry */
THREAD_TIMER_OFF (adj->t_expire);
THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
(long) adj->hold_time);
thread_add_timer(master, isis_adj_expire, adj, (long)adj->hold_time,
&adj->t_expire);
/*
* If the snpa for this circuit is found from LAN Neighbours TLV
@ -2389,9 +2391,9 @@ send_lan_l1_hello (struct thread *thread)
retval = send_hello (circuit, 1);
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
send_lan_l1_hello, circuit,
isis_jitter (circuit->hello_interval[0], IIH_JITTER));
thread_add_timer(master, send_lan_l1_hello, circuit,
isis_jitter(circuit->hello_interval[0], IIH_JITTER),
&circuit->u.bc.t_send_lan_hello[0]);
return retval;
}
@ -2419,9 +2421,9 @@ send_lan_l2_hello (struct thread *thread)
retval = send_hello (circuit, 2);
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
send_lan_l2_hello, circuit,
isis_jitter (circuit->hello_interval[1], IIH_JITTER));
thread_add_timer(master, send_lan_l2_hello, circuit,
isis_jitter(circuit->hello_interval[1], IIH_JITTER),
&circuit->u.bc.t_send_lan_hello[1]);
return retval;
}
@ -2438,9 +2440,9 @@ send_p2p_hello (struct thread *thread)
send_hello (circuit, 1);
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
circuit, isis_jitter (circuit->hello_interval[1],
IIH_JITTER));
thread_add_timer(master, send_p2p_hello, circuit,
isis_jitter(circuit->hello_interval[1], IIH_JITTER),
&circuit->u.p2p.t_send_p2p_hello);
return ISIS_OK;
}
@ -2740,8 +2742,9 @@ send_l1_csnp (struct thread *thread)
send_csnp (circuit, 1);
}
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
isis_jitter (circuit->csnp_interval[0], CSNP_JITTER));
thread_add_timer(master, send_l1_csnp, circuit,
isis_jitter(circuit->csnp_interval[0], CSNP_JITTER),
&circuit->t_send_csnp[0]);
return retval;
}
@ -2762,8 +2765,9 @@ send_l2_csnp (struct thread *thread)
send_csnp (circuit, 2);
}
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
isis_jitter (circuit->csnp_interval[1], CSNP_JITTER));
thread_add_timer(master, send_l2_csnp, circuit,
isis_jitter(circuit->csnp_interval[1], CSNP_JITTER),
&circuit->t_send_csnp[1]);
return retval;
}
@ -2965,8 +2969,9 @@ send_l1_psnp (struct thread *thread)
send_psnp (1, circuit);
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
thread_add_timer(master, send_l1_psnp, circuit,
isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
&circuit->t_send_psnp[0]);
return retval;
}
@ -2989,8 +2994,9 @@ send_l2_psnp (struct thread *thread)
send_psnp (2, circuit);
/* set next timer thread */
THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
thread_add_timer(master, send_l2_psnp, circuit,
isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
&circuit->t_send_psnp[1]);
return retval;
}

12
isisd/isis_spf.c
View File

@ -1279,9 +1279,9 @@ isis_spf_schedule (struct isis_area *area, int level)
if (area->spf_timer[level - 1])
return ISIS_OK;
THREAD_TIMER_MSEC_ON(master, area->spf_timer[level-1],
isis_run_spf_cb, isis_run_spf_arg(area, level),
delay);
thread_add_timer_msec (master, isis_run_spf_cb,
isis_run_spf_arg(area, level),
delay, &area->spf_timer[level-1]);
return ISIS_OK;
}
@ -1301,9 +1301,9 @@ isis_spf_schedule (struct isis_area *area, int level)
return retval;
}
THREAD_TIMER_ON (master, area->spf_timer[level-1],
isis_run_spf_cb, isis_run_spf_arg(area, level),
area->min_spf_interval[level-1] - diff);
thread_add_timer (master, isis_run_spf_cb, isis_run_spf_arg(area, level),
area->min_spf_interval[level-1] - diff,
&area->spf_timer[level-1]);
if (isis->debugs & DEBUG_SPF_EVENTS)
zlog_debug ("ISIS-Spf (%s) L%d SPF scheduled %d sec from now",

2
isisd/isisd.c
View File

@ -137,7 +137,7 @@ isis_area_create (const char *area_tag)
area->circuit_list = list_new ();
area->area_addrs = list_new ();
THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
thread_add_timer(master, lsp_tick, area, 1, &area->t_tick);
flags_initialize (&area->flags);
/*

15
ldpd/accept.c
View File

@ -58,7 +58,8 @@ accept_add(int fd, int (*cb)(struct thread *), void *arg)
av->arg = arg;
LIST_INSERT_HEAD(&accept_queue.queue, av, entry);
av->ev = thread_add_read(master, accept_cb, av, av->fd);
av->ev = NULL;
thread_add_read(master, accept_cb, av, av->fd, &av->ev);
log_debug("%s: accepting on fd %d", __func__, fd);
@ -85,7 +86,8 @@ accept_pause(void)
{
log_debug(__func__);
accept_unarm();
accept_queue.evt = thread_add_timer(master, accept_timeout, NULL, 1);
accept_queue.evt = NULL;
thread_add_timer(master, accept_timeout, NULL, 1, &accept_queue.evt);
}
void
@ -102,8 +104,10 @@ static void
accept_arm(void)
{
struct accept_ev *av;
LIST_FOREACH(av, &accept_queue.queue, entry)
av->ev = thread_add_read(master, accept_cb, av, av->fd);
LIST_FOREACH(av, &accept_queue.queue, entry) {
av->ev = NULL;
thread_add_read(master, accept_cb, av, av->fd, &av->ev);
}
}
static void
@ -118,7 +122,8 @@ static int
accept_cb(struct thread *thread)
{
struct accept_ev *av = THREAD_ARG(thread);
av->ev = thread_add_read(master, accept_cb, av, av->fd);
av->ev = NULL;
thread_add_read(master, accept_cb, av, av->fd, &av->ev);
av->accept_cb(thread);
return (0);

10
ldpd/adjacency.c
View File

@ -206,8 +206,9 @@ void
adj_start_itimer(struct adj *adj)
{
THREAD_TIMER_OFF(adj->inactivity_timer);
adj->inactivity_timer = thread_add_timer(master, adj_itimer, adj,
adj->holdtime);
adj->inactivity_timer = NULL;
thread_add_timer(master, adj_itimer, adj, adj->holdtime,
&adj->inactivity_timer);
}
void
@ -366,8 +367,9 @@ static void
tnbr_start_hello_timer(struct tnbr *tnbr)
{
THREAD_TIMER_OFF(tnbr->hello_timer);
tnbr->hello_timer = thread_add_timer(master, tnbr_hello_timer, tnbr,
tnbr_get_hello_interval(tnbr));
tnbr->hello_timer = NULL;
thread_add_timer(master, tnbr_hello_timer, tnbr, tnbr_get_hello_interval(tnbr),
&tnbr->hello_timer);
}
static void

5
ldpd/control.c
View File

@ -133,8 +133,9 @@ control_accept(struct thread *thread)
imsg_init(&c->iev.ibuf, connfd);
c->iev.handler_read = control_dispatch_imsg;
c->iev.ev_read = thread_add_read(master, c->iev.handler_read,
&c->iev, c->iev.ibuf.fd);
c->iev.ev_read = NULL;
thread_add_read(master, c->iev.handler_read, &c->iev, c->iev.ibuf.fd,
&c->iev.ev_read);
c->iev.handler_write = ldp_write_handler;
c->iev.ev_write = NULL;

5
ldpd/interface.c
View File

@ -440,8 +440,9 @@ static void
if_start_hello_timer(struct iface_af *ia)
{
THREAD_TIMER_OFF(ia->hello_timer);
ia->hello_timer = thread_add_timer(master, if_hello_timer, ia,
if_get_hello_interval(ia));
ia->hello_timer = NULL;
thread_add_timer(master, if_hello_timer, ia, if_get_hello_interval(ia),
&ia->hello_timer);
}
static void

10
ldpd/lde.c
View File

@ -140,8 +140,9 @@ lde(void)
fatal(NULL);
imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
iev_main->handler_read = lde_dispatch_parent;
iev_main->ev_read = thread_add_read(master, iev_main->handler_read,
iev_main, iev_main->ibuf.fd);
iev_main->ev_read = NULL;
thread_add_read(master, iev_main->handler_read, iev_main, iev_main->ibuf.fd,
&iev_main->ev_read);
iev_main->handler_write = ldp_write_handler;
if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
@ -526,8 +527,9 @@ lde_dispatch_parent(struct thread *thread)
fatal(NULL);
imsg_init(&iev_ldpe->ibuf, fd);
iev_ldpe->handler_read = lde_dispatch_imsg;
iev_ldpe->ev_read = thread_add_read(master,
iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd);
iev_ldpe->ev_read = NULL;
thread_add_read(master, iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd,
&iev_ldpe->ev_read);
iev_ldpe->handler_write = ldp_write_handler;
iev_ldpe->ev_write = NULL;
break;

5
ldpd/lde_lib.c
View File

@ -932,8 +932,9 @@ void
lde_gc_start_timer(void)
{
THREAD_TIMER_OFF(gc_timer);
gc_timer = thread_add_timer(master, lde_gc_timer, NULL,
LDE_GC_INTERVAL);
gc_timer = NULL;
thread_add_timer(master, lde_gc_timer, NULL, LDE_GC_INTERVAL,
&gc_timer);
}
void

32
ldpd/ldpd.c
View File

@ -358,26 +358,30 @@ main(int argc, char *argv[])
fatal(NULL);
imsg_init(&iev_ldpe->ibuf, pipe_parent2ldpe[0]);
iev_ldpe->handler_read = main_dispatch_ldpe;
iev_ldpe->ev_read = thread_add_read(master, iev_ldpe->handler_read,
iev_ldpe, iev_ldpe->ibuf.fd);
iev_ldpe->ev_read = NULL;
thread_add_read(master, iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd,
&iev_ldpe->ev_read);
iev_ldpe->handler_write = ldp_write_handler;
imsg_init(&iev_ldpe_sync->ibuf, pipe_parent2ldpe_sync[0]);
iev_ldpe_sync->handler_read = main_dispatch_ldpe;
iev_ldpe_sync->ev_read = thread_add_read(master,
iev_ldpe_sync->handler_read, iev_ldpe_sync, iev_ldpe_sync->ibuf.fd);
iev_ldpe_sync->ev_read = NULL;
thread_add_read(master, iev_ldpe_sync->handler_read, iev_ldpe_sync, iev_ldpe_sync->ibuf.fd,
&iev_ldpe_sync->ev_read);
iev_ldpe_sync->handler_write = ldp_write_handler;
imsg_init(&iev_lde->ibuf, pipe_parent2lde[0]);
iev_lde->handler_read = main_dispatch_lde;
iev_lde->ev_read = thread_add_read(master, iev_lde->handler_read,
iev_lde, iev_lde->ibuf.fd);
iev_lde->ev_read = NULL;
thread_add_read(master, iev_lde->handler_read, iev_lde, iev_lde->ibuf.fd,
&iev_lde->ev_read);
iev_lde->handler_write = ldp_write_handler;
imsg_init(&iev_lde_sync->ibuf, pipe_parent2lde_sync[0]);
iev_lde_sync->handler_read = main_dispatch_lde;
iev_lde_sync->ev_read = thread_add_read(master,
iev_lde_sync->handler_read, iev_lde_sync, iev_lde_sync->ibuf.fd);
iev_lde_sync->ev_read = NULL;
thread_add_read(master, iev_lde_sync->handler_read, iev_lde_sync, iev_lde_sync->ibuf.fd,
&iev_lde_sync->ev_read);
iev_lde_sync->handler_write = ldp_write_handler;
if (main_imsg_send_ipc_sockets(&iev_ldpe->ibuf, &iev_lde->ibuf))
@ -690,12 +694,12 @@ void
imsg_event_add(struct imsgev *iev)
{
if (iev->handler_read)
THREAD_READ_ON(master, iev->ev_read, iev->handler_read, iev,
iev->ibuf.fd);
thread_add_read(master, iev->handler_read, iev, iev->ibuf.fd,
&iev->ev_read);
if (iev->handler_write && iev->ibuf.w.queued)
THREAD_WRITE_ON(master, iev->ev_write, iev->handler_write, iev,
iev->ibuf.fd);
thread_add_write(master, iev->handler_write, iev,
iev->ibuf.fd, &iev->ev_write);
}
int
@ -721,8 +725,8 @@ void
evbuf_event_add(struct evbuf *eb)
{
if (eb->wbuf.queued)
THREAD_WRITE_ON(master, eb->ev, eb->handler, eb->arg,
eb->wbuf.fd);
thread_add_write(master, eb->handler, eb->arg, eb->wbuf.fd,
&eb->ev);
}
void

33
ldpd/ldpe.c
View File

@ -119,8 +119,9 @@ ldpe(void)
fatal(NULL);
imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
iev_main->handler_read = ldpe_dispatch_main;
iev_main->ev_read = thread_add_read(master, iev_main->handler_read,
iev_main, iev_main->ibuf.fd);
iev_main->ev_read = NULL;
thread_add_read(master, iev_main->handler_read, iev_main, iev_main->ibuf.fd,
&iev_main->ev_read);
iev_main->handler_write = ldp_write_handler;
if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
@ -164,9 +165,11 @@ ldpe_init(struct ldpd_init *init)
fatal("inet_pton");
#ifdef __OpenBSD__
global.pfkeysock = pfkey_init();
if (sysdep.no_pfkey == 0)
pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
NULL, global.pfkeysock);
if (sysdep.no_pfkey == 0) {
pfkey_ev = NULL;
thread_add_read(master, ldpe_dispatch_pfkey, NULL, global.pfkeysock,
&pfkey_ev);
}
#endif
/* mark sockets as closed */
@ -353,8 +356,9 @@ ldpe_dispatch_main(struct thread *thread)
fatal(NULL);
imsg_init(&iev_lde->ibuf, fd);
iev_lde->handler_read = ldpe_dispatch_lde;
iev_lde->ev_read = thread_add_read(master,
iev_lde->handler_read, iev_lde, iev_lde->ibuf.fd);
iev_lde->ev_read = NULL;
thread_add_read(master, iev_lde->handler_read, iev_lde, iev_lde->ibuf.fd,
&iev_lde->ev_read);
iev_lde->handler_write = ldp_write_handler;
iev_lde->ev_write = NULL;
break;
@ -694,8 +698,9 @@ ldpe_dispatch_pfkey(struct thread *thread)
{
int fd = THREAD_FD(thread);
pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
NULL, global.pfkeysock);
pfkey_ev = NULL;
thread_add_read(master, ldpe_dispatch_pfkey, NULL, global.pfkeysock,
&pfkey_ev);
if (pfkey_read(fd, NULL) == -1)
fatal("pfkey_read failed, exiting...");
@ -714,13 +719,15 @@ ldpe_setup_sockets(int af, int disc_socket, int edisc_socket,
/* discovery socket */
af_global->ldp_disc_socket = disc_socket;
af_global->disc_ev = thread_add_read(master, disc_recv_packet,
&af_global->disc_ev, af_global->ldp_disc_socket);
af_global->disc_ev = NULL;
thread_add_read(master, disc_recv_packet, &af_global->disc_ev, af_global->ldp_disc_socket,
&af_global->disc_ev);
/* extended discovery socket */
af_global->ldp_edisc_socket = edisc_socket;
af_global->edisc_ev = thread_add_read(master, disc_recv_packet,
&af_global->edisc_ev, af_global->ldp_edisc_socket);
af_global->edisc_ev = NULL;
thread_add_read(master, disc_recv_packet, &af_global->edisc_ev, af_global->ldp_edisc_socket,
&af_global->edisc_ev);
/* session socket */
af_global->ldp_session_socket = session_socket;

19
ldpd/neighbor.c
View File

@ -408,7 +408,8 @@ nbr_start_ktimer(struct nbr *nbr)
/* send three keepalives per period */
secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
THREAD_TIMER_OFF(nbr->keepalive_timer);
nbr->keepalive_timer = thread_add_timer(master, nbr_ktimer, nbr, secs);
nbr->keepalive_timer = NULL;
thread_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer);
}
void
@ -437,8 +438,9 @@ static void
nbr_start_ktimeout(struct nbr *nbr)
{
THREAD_TIMER_OFF(nbr->keepalive_timeout);
nbr->keepalive_timeout = thread_add_timer(master, nbr_ktimeout, nbr,
nbr->keepalive);
nbr->keepalive_timeout = NULL;
thread_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive,
&nbr->keepalive_timeout);
}
void
@ -468,7 +470,8 @@ nbr_start_itimeout(struct nbr *nbr)
secs = INIT_FSM_TIMEOUT;
THREAD_TIMER_OFF(nbr->init_timeout);
nbr->init_timeout = thread_add_timer(master, nbr_itimeout, nbr, secs);
nbr->init_timeout = NULL;
thread_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout);
}
void
@ -516,7 +519,9 @@ nbr_start_idtimer(struct nbr *nbr)
}
THREAD_TIMER_OFF(nbr->initdelay_timer);
nbr->initdelay_timer = thread_add_timer(master, nbr_idtimer, nbr, secs);
nbr->initdelay_timer = NULL;
thread_add_timer(master, nbr_idtimer, nbr, secs,
&nbr->initdelay_timer);
}
void
@ -633,8 +638,8 @@ nbr_establish_connection(struct nbr *nbr)
if (connect(nbr->fd, (struct sockaddr *)&remote_sa,
sockaddr_len((struct sockaddr *)&remote_sa)) == -1) {
if (errno == EINPROGRESS) {
THREAD_WRITE_ON(master, nbr->ev_connect, nbr_connect_cb,
nbr, nbr->fd);
thread_add_write(master, nbr_connect_cb, nbr, nbr->fd,
&nbr->ev_connect);
return (0);
}
log_warn("%s: error while connecting to %s", __func__,

14
ldpd/packet.c
View File

@ -143,7 +143,8 @@ disc_recv_packet(struct thread *thread)
struct in_addr lsr_id;
/* reschedule read */
*threadp = thread_add_read(master, disc_recv_packet, threadp, fd);
*threadp = NULL;
thread_add_read(master, disc_recv_packet, threadp, fd, &*threadp);
/* setup buffer */
memset(&m, 0, sizeof(m));
@ -427,7 +428,8 @@ session_read(struct thread *thread)
uint16_t pdu_len, msg_len, msg_size, max_pdu_len;
int ret;
tcp->rev = thread_add_read(master, session_read, nbr, fd);
tcp->rev = NULL;
thread_add_read(master, session_read, nbr, fd, &tcp->rev);
if ((n = read(fd, tcp->rbuf->buf + tcp->rbuf->wpos,
sizeof(tcp->rbuf->buf) - tcp->rbuf->wpos)) == -1) {
@ -731,7 +733,8 @@ tcp_new(int fd, struct nbr *nbr)
if ((tcp->rbuf = calloc(1, sizeof(struct ibuf_read))) == NULL)
fatal(__func__);
tcp->rev = thread_add_read(master, session_read, nbr, tcp->fd);
tcp->rev = NULL;
thread_add_read(master, session_read, nbr, tcp->fd, &tcp->rev);
tcp->nbr = nbr;
}
@ -777,8 +780,9 @@ pending_conn_new(int fd, int af, union ldpd_addr *addr)
pconn->af = af;
pconn->addr = *addr;
TAILQ_INSERT_TAIL(&global.pending_conns, pconn, entry);
pconn->ev_timeout = thread_add_timer(master, pending_conn_timeout,
pconn, PENDING_CONN_TIMEOUT);
pconn->ev_timeout = NULL;
thread_add_timer(master, pending_conn_timeout, pconn, PENDING_CONN_TIMEOUT,
&pconn->ev_timeout);
return (pconn);
}

10
lib/agentx.c
View File

@ -85,8 +85,11 @@ agentx_events_update(void)
FD_ZERO (&fds);
snmp_select_info (&maxfd, &fds, &timeout, &block);
if (!block)
timeout_thr = thread_add_timer_tv (agentx_tm, agentx_timeout, NULL, &timeout);
if (!block) {
timeout_thr = NULL;
thread_add_timer_tv(agentx_tm, agentx_timeout, NULL, &timeout,
&timeout_thr);
}
ln = listhead (events);
thr = ln ? listgetdata (ln) : NULL;
@ -114,7 +117,8 @@ agentx_events_update(void)
else if (FD_ISSET (fd, &fds))
{
struct listnode *newln;
thr = thread_add_read (agentx_tm, agentx_read, NULL, fd);
thr = NULL;
thread_add_read(agentx_tm, agentx_read, NULL, fd, &thr);
newln = listnode_add_before (events, ln, thr);
thr->arg = newln;
}

11
lib/sigevent.c
View File

@ -132,8 +132,9 @@ quagga_signal_timer (struct thread *t)
int i;
sigm = THREAD_ARG (t);
sigm->t = thread_add_timer (sigm->t->master, quagga_signal_timer, &sigmaster,
QUAGGA_SIGNAL_TIMER_INTERVAL);
sigm->t = NULL;
thread_add_timer(sigm->t->master, quagga_signal_timer, &sigmaster, QUAGGA_SIGNAL_TIMER_INTERVAL,
&sigm->t);
return quagga_sigevent_process ();
}
#endif /* SIGEVENT_SCHEDULE_THREAD */
@ -378,8 +379,8 @@ signal_init (struct thread_master *m, int sigc,
sigmaster.signals = signals;
#ifdef SIGEVENT_SCHEDULE_THREAD
sigmaster.t =
thread_add_timer (m, quagga_signal_timer, &sigmaster,
QUAGGA_SIGNAL_TIMER_INTERVAL);
sigmaster.t = NULL;
thread_add_timer(m, quagga_signal_timer, &sigmaster, QUAGGA_SIGNAL_TIMER_INTERVAL,
&sigmaster.t);
#endif /* SIGEVENT_SCHEDULE_THREAD */
}

11
lib/smux.c
View File

@ -1197,13 +1197,18 @@ smux_event (enum smux_event event, int sock)
switch (event)
{
case SMUX_SCHEDULE:
smux_connect_thread = thread_add_event (smux_master, smux_connect, NULL, 0);
smux_connect_thread = NULL;
thread_add_event(smux_master, smux_connect, NULL, 0,
&smux_connect_thread);
break;
case SMUX_CONNECT:
smux_connect_thread = thread_add_timer (smux_master, smux_connect, NULL, 10);
smux_connect_thread = NULL;
thread_add_timer(smux_master, smux_connect, NULL, 10,
&smux_connect_thread);
break;
case SMUX_READ:
smux_read_thread = thread_add_read (smux_master, smux_read, NULL, sock);
smux_read_thread = NULL;
thread_add_read(smux_master, smux_read, NULL, sock, &smux_read_thread);
break;
default:
break;

16
lib/spf_backoff.c
View File

@ -169,21 +169,19 @@ long spf_backoff_schedule(struct spf_backoff *backoff)
{
case SPF_BACKOFF_QUIET:
backoff->state = SPF_BACKOFF_SHORT_WAIT;
THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_timetolearn,
spf_backoff_timetolearn_elapsed, backoff,
backoff->timetolearn);
THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_holddown,
spf_backoff_holddown_elapsed, backoff,
backoff->holddown);
thread_add_timer_msec(backoff->m, spf_backoff_timetolearn_elapsed,
backoff, backoff->timetolearn,
&backoff->t_timetolearn);
thread_add_timer_msec(backoff->m, spf_backoff_holddown_elapsed, backoff,
backoff->holddown, &backoff->t_holddown);
backoff->first_event_time = now;
rv = backoff->init_delay;
break;
case SPF_BACKOFF_SHORT_WAIT:
case SPF_BACKOFF_LONG_WAIT:
THREAD_TIMER_OFF(backoff->t_holddown);
THREAD_TIMER_MSEC_ON(backoff->m, backoff->t_holddown,
spf_backoff_holddown_elapsed, backoff,
backoff->holddown);
thread_add_timer_msec(backoff->m, spf_backoff_holddown_elapsed, backoff,
backoff->holddown, &backoff->t_holddown);
if (backoff->state == SPF_BACKOFF_SHORT_WAIT)
rv = backoff->short_delay;
else

4
lib/systemd.c
View File

@ -104,7 +104,7 @@ systemd_send_watchdog (struct thread *t)
{
systemd_send_information ("WATCHDOG=1");
thread_add_timer (systemd_master, systemd_send_watchdog, NULL, wsecs);
thread_add_timer(systemd_master, systemd_send_watchdog, NULL, wsecs, NULL);
return 1;
}
@ -119,5 +119,5 @@ systemd_send_started (struct thread_master *m, int the_process)
systemd_send_information ("READY=1");
if (wsecs != 0)
thread_add_timer (m, systemd_send_watchdog, m, wsecs);
thread_add_timer(m, systemd_send_watchdog, m, wsecs, NULL);
}

126
lib/thread.c
View File

@ -454,6 +454,7 @@ thread_add_unuse (struct thread_master *m, struct thread *thread)
assert (m != NULL && thread != NULL);
assert (thread->next == NULL);
assert (thread->prev == NULL);
thread->ref = NULL;
thread->type = THREAD_UNUSED;
thread->hist->total_active--;
@ -725,6 +726,7 @@ fd_select (struct thread_master *m, int size, thread_fd_set *read, thread_fd_set
num = poll (m->handler.pfds, m->handler.pfdcount + m->handler.pfdcountsnmp, timeout);
#else
struct timeval timeout;
if (m->selectpoll_timeout > 0) // use the user's timeout
{
timeout.tv_sec = m->selectpoll_timeout / 1000;
@ -774,15 +776,21 @@ fd_clear_read_write (struct thread *thread)
}
/* Add new read thread. */
struct thread *
void
funcname_thread_add_read_write (int dir, struct thread_master *m,
int (*func) (struct thread *), void *arg, int fd,
debugargdef)
int (*func) (struct thread *), void *arg, int fd, struct thread **t_ptr,
debugargdef)
{
struct thread *thread = NULL;
pthread_mutex_lock (&m->mtx);
{
if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
{
pthread_mutex_unlock (&m->mtx);
return;
}
#if defined (HAVE_POLL_CALL)
thread = generic_thread_add(m, func, arg, fd, dir, debugargpass);
#else
@ -822,19 +830,20 @@ funcname_thread_add_read_write (int dir, struct thread_master *m,
}
pthread_mutex_unlock (&thread->mtx);
}
if (t_ptr)
{
*t_ptr = thread;
thread->ref = t_ptr;
}
}
pthread_mutex_unlock (&m->mtx);
return thread;
}
static struct thread *
static void
funcname_thread_add_timer_timeval (struct thread_master *m,
int (*func) (struct thread *),
int type,
void *arg,
struct timeval *time_relative,
debugargdef)
int (*func) (struct thread *), int type, void *arg,
struct timeval *time_relative, struct thread **t_ptr, debugargdef)
{
struct thread *thread;
struct pqueue *queue;
@ -846,6 +855,12 @@ funcname_thread_add_timer_timeval (struct thread_master *m,
pthread_mutex_lock (&m->mtx);
{
if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
{
pthread_mutex_unlock (&m->mtx);
return;
}
queue = ((type == THREAD_TIMER) ? m->timer : m->background);
thread = thread_get (m, type, func, arg, debugargpass);
@ -856,19 +871,22 @@ funcname_thread_add_timer_timeval (struct thread_master *m,
pqueue_enqueue(thread, queue);
}
pthread_mutex_unlock (&thread->mtx);
if (t_ptr)
{
*t_ptr = thread;
thread->ref = t_ptr;
}
}
pthread_mutex_unlock (&m->mtx);
return thread;
}
/* Add timer event thread. */
struct thread *
void
funcname_thread_add_timer (struct thread_master *m,
int (*func) (struct thread *),
void *arg, long timer,
debugargdef)
int (*func) (struct thread *), void *arg, long timer,
struct thread **t_ptr, debugargdef)
{
struct timeval trel;
@ -877,16 +895,15 @@ funcname_thread_add_timer (struct thread_master *m,
trel.tv_sec = timer;
trel.tv_usec = 0;
return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg,
&trel, debugargpass);
return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, &trel,
t_ptr, debugargpass);
}
/* Add timer event thread with "millisecond" resolution */
struct thread *
void
funcname_thread_add_timer_msec (struct thread_master *m,
int (*func) (struct thread *),
void *arg, long timer,
debugargdef)
int (*func) (struct thread *), void *arg, long timer,
struct thread **t_ptr, debugargdef)
{
struct timeval trel;
@ -895,27 +912,25 @@ funcname_thread_add_timer_msec (struct thread_master *m,
trel.tv_sec = timer / 1000;
trel.tv_usec = 1000*(timer % 1000);
return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
arg, &trel, debugargpass);
funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, &trel,
t_ptr, debugargpass);
}
/* Add timer event thread with "millisecond" resolution */
struct thread *
void
funcname_thread_add_timer_tv (struct thread_master *m,
int (*func) (struct thread *),
void *arg, struct timeval *tv,
debugargdef)
int (*func) (struct thread *), void *arg, struct timeval *tv,
struct thread **t_ptr, debugargdef)
{
return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
arg, tv, debugargpass);
funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg, tv, t_ptr,
debugargpass);
}
/* Add a background thread, with an optional millisec delay */
struct thread *
void
funcname_thread_add_background (struct thread_master *m,
int (*func) (struct thread *),
void *arg, long delay,
debugargdef)
int (*func) (struct thread *), void *arg, long delay,
struct thread **t_ptr, debugargdef)
{
struct timeval trel;
@ -932,15 +947,15 @@ funcname_thread_add_background (struct thread_master *m,
trel.tv_usec = 0;
}
return funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND,
arg, &trel, debugargpass);
funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND, arg, &trel,
t_ptr, debugargpass);
}
/* Add simple event thread. */
struct thread *
void
funcname_thread_add_event (struct thread_master *m,
int (*func) (struct thread *), void *arg, int val,
debugargdef)
int (*func) (struct thread *), void *arg, int val,
struct thread **t_ptr, debugargdef)
{
struct thread *thread;
@ -948,6 +963,12 @@ funcname_thread_add_event (struct thread_master *m,
pthread_mutex_lock (&m->mtx);
{
if (t_ptr && *t_ptr) // thread is already scheduled; don't reschedule
{
pthread_mutex_unlock (&m->mtx);
return;
}
thread = thread_get (m, THREAD_EVENT, func, arg, debugargpass);
pthread_mutex_lock (&thread->mtx);
{
@ -955,10 +976,14 @@ funcname_thread_add_event (struct thread_master *m,
thread_list_add (&m->event, thread);
}
pthread_mutex_unlock (&thread->mtx);
if (t_ptr)
{
*t_ptr = thread;
thread->ref = t_ptr;
}
}
pthread_mutex_unlock (&m->mtx);
return thread;
}
static void
@ -1056,6 +1081,9 @@ thread_cancel (struct thread *thread)
assert(!"Thread should be either in queue or list or array!");
}
if (thread->ref)
*thread->ref = NULL;
thread_add_unuse (thread->master, thread);
done:
@ -1085,6 +1113,8 @@ thread_cancel_event (struct thread_master *m, void *arg)
{
ret++;
thread_list_delete (&m->event, t);
if (t->ref)
*t->ref = NULL;
thread_add_unuse (m, t);
}
}
@ -1104,6 +1134,8 @@ thread_cancel_event (struct thread_master *m, void *arg)
{
ret++;
thread_list_delete (&m->ready, t);
if (t->ref)
*t->ref = NULL;
thread_add_unuse (m, t);
}
}
@ -1285,6 +1317,8 @@ thread_fetch (struct thread_master *m, struct thread *fetch)
if ((thread = thread_trim_head (&m->ready)) != NULL)
{
fetch = thread_run (m, thread, fetch);
if (fetch->ref)
*fetch->ref = NULL;
pthread_mutex_unlock (&m->mtx);
return fetch;
}
@ -1354,6 +1388,8 @@ thread_fetch (struct thread_master *m, struct thread *fetch)
if ((thread = thread_trim_head (&m->ready)) != NULL)
{
fetch = thread_run (m, thread, fetch);
if (fetch->ref)
*fetch->ref = NULL;
pthread_mutex_unlock (&m->mtx);
return fetch;
}
@ -1365,6 +1401,8 @@ thread_fetch (struct thread_master *m, struct thread *fetch)
if ((thread = thread_trim_head (&m->ready)) != NULL)
{
fetch = thread_run (m, thread, fetch);
if (fetch->ref)
*fetch->ref = NULL;
pthread_mutex_unlock (&m->mtx);
return fetch;
}
@ -1472,7 +1510,7 @@ thread_call (struct thread *thread)
}
/* Execute thread */
struct thread *
void
funcname_thread_execute (struct thread_master *m,
int (*func)(struct thread *),
void *arg,
@ -1504,6 +1542,4 @@ funcname_thread_execute (struct thread_master *m,
dummy.schedfrom_line = fromln;
thread_call (&dummy);
return NULL;
}

117
lib/thread.h
View File

@ -96,26 +96,27 @@ typedef unsigned char thread_type;
/* Thread itself. */
struct thread
{
thread_type type; /* thread type */
thread_type add_type; /* thread type */
struct thread *next; /* next pointer of the thread */
struct thread *prev; /* previous pointer of the thread */
struct thread_master *master; /* pointer to the struct thread_master. */
int (*func) (struct thread *); /* event function */
void *arg; /* event argument */
thread_type type; /* thread type */
thread_type add_type; /* thread type */
struct thread *next; /* next pointer of the thread */
struct thread *prev; /* previous pointer of the thread */
struct thread **ref; /* external reference (if given) */
struct thread_master *master; /* pointer to the struct thread_master */
int (*func) (struct thread *); /* event function */
void *arg; /* event argument */
union {
int val; /* second argument of the event. */
int fd; /* file descriptor in case of read/write. */
struct timeval sands; /* rest of time sands value. */
int val; /* second argument of the event. */
int fd; /* file descriptor in case of r/w */
struct timeval sands; /* rest of time sands value. */
} u;
int index; /* used for timers to store position in queue */
int index; /* queue position for timers */
struct timeval real;
struct cpu_thread_history *hist; /* cache pointer to cpu_history */
unsigned long yield; /* yield time in us */
const char *funcname;
const char *schedfrom;
int schedfrom_line;
pthread_mutex_t mtx;
struct cpu_thread_history *hist; /* cache pointer to cpu_history */
unsigned long yield; /* yield time in microseconds */
const char *funcname; /* name of thread function */
const char *schedfrom; /* source file thread was scheduled from */
int schedfrom_line; /* line number of source file */
pthread_mutex_t mtx; /* mutex for thread.c functions */
};
struct cpu_thread_history
@ -153,30 +154,6 @@ struct cpu_thread_history
#define THREAD_FD(X) ((X)->u.fd)
#define THREAD_VAL(X) ((X)->u.val)
#define THREAD_READ_ON(master,thread,func,arg,sock) \
do { \
if (! thread) \
thread = thread_add_read (master, func, arg, sock); \
} while (0)
#define THREAD_WRITE_ON(master,thread,func,arg,sock) \
do { \
if (! thread) \
thread = thread_add_write (master, func, arg, sock); \
} while (0)
#define THREAD_TIMER_ON(master,thread,func,arg,time) \
do { \
if (! thread) \
thread = thread_add_timer (master, func, arg, time); \
} while (0)
#define THREAD_TIMER_MSEC_ON(master,thread,func,arg,time) \
do { \
if (! thread) \
thread = thread_add_timer_msec (master, func, arg, time); \
} while (0)
#define THREAD_OFF(thread) \
do { \
if (thread) \
@ -192,46 +169,42 @@ struct cpu_thread_history
#define debugargdef const char *funcname, const char *schedfrom, int fromln
#define thread_add_read(m,f,a,v) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_write(m,f,a,v) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer(m,f,a,v) funcname_thread_add_timer(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer_msec(m,f,a,v) funcname_thread_add_timer_msec(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer_tv(m,f,a,v) funcname_thread_add_timer_tv(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_event(m,f,a,v) funcname_thread_add_event(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_read(m,f,a,v,t) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_write(m,f,a,v,t) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer(m,f,a,v,t) funcname_thread_add_timer(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer_msec(m,f,a,v,t) funcname_thread_add_timer_msec(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer_tv(m,f,a,v,t) funcname_thread_add_timer_tv(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_event(m,f,a,v,t) funcname_thread_add_event(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)
/* The 4th arg to thread_add_background is the # of milliseconds to delay. */
#define thread_add_background(m,f,a,v) funcname_thread_add_background(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_background(m,f,a,v,t) funcname_thread_add_background(m,f,a,v,t,#f,__FILE__,__LINE__)
/* Prototypes. */
extern struct thread_master *thread_master_create (void);
extern void thread_master_free (struct thread_master *);
extern void thread_master_free_unused(struct thread_master *);
extern struct thread *funcname_thread_add_read_write (int dir, struct thread_master *,
int (*)(struct thread *),
void *, int, debugargdef);
extern struct thread *funcname_thread_add_timer (struct thread_master *,
int (*)(struct thread *),
void *, long, debugargdef);
extern struct thread *funcname_thread_add_timer_msec (struct thread_master *,
int (*)(struct thread *),
void *, long, debugargdef);
extern struct thread *funcname_thread_add_timer_tv (struct thread_master *,
int (*)(struct thread *),
void *, struct timeval *,
debugargdef);
extern struct thread *funcname_thread_add_event (struct thread_master *,
int (*)(struct thread *),
void *, int, debugargdef);
extern struct thread *funcname_thread_add_background (struct thread_master *,
int (*func)(struct thread *),
void *arg,
long milliseconds_to_delay,
debugargdef);
extern struct thread *funcname_thread_execute (struct thread_master *,
int (*)(struct thread *),
void *, int, debugargdef);
extern void funcname_thread_add_read_write (int dir, struct thread_master *,
int (*)(struct thread *), void *, int, struct thread **, debugargdef);
extern void funcname_thread_add_timer (struct thread_master *,
int (*)(struct thread *), void *, long, struct thread **, debugargdef);
extern void funcname_thread_add_timer_msec (struct thread_master *,
int (*)(struct thread *), void *, long, struct thread **, debugargdef);
extern void funcname_thread_add_timer_tv (struct thread_master *,
int (*)(struct thread *), void *, struct timeval *, struct thread **, debugargdef);
extern void funcname_thread_add_event (struct thread_master *,
int (*)(struct thread *), void *, int, struct thread **, debugargdef);
extern void funcname_thread_add_background (struct thread_master *,
int (*)(struct thread *), void *, long, struct thread **, debugargdef);
extern void funcname_thread_execute (struct thread_master *,
int (*)(struct thread *), void *, int, debugargdef);
#undef debugargdef
extern void thread_cancel (struct thread *);

28
lib/vty.c
View File

@ -2618,36 +2618,41 @@ vty_event (enum event event, int sock, struct vty *vty)
switch (event)
{
case VTY_SERV:
vty_serv_thread = thread_add_read (vty_master, vty_accept, vty, sock);
vty_serv_thread = NULL;
thread_add_read(vty_master, vty_accept, vty, sock, &vty_serv_thread);
vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
break;
#ifdef VTYSH
case VTYSH_SERV:
vty_serv_thread = thread_add_read (vty_master, vtysh_accept, vty, sock);
vty_serv_thread = NULL;
thread_add_read(vty_master, vtysh_accept, vty, sock, &vty_serv_thread);
vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);
break;
case VTYSH_READ:
vty->t_read = thread_add_read (vty_master, vtysh_read, vty, sock);
vty->t_read = NULL;
thread_add_read(vty_master, vtysh_read, vty, sock, &vty->t_read);
break;
case VTYSH_WRITE:
vty->t_write = thread_add_write (vty_master, vtysh_write, vty, sock);
vty->t_write = NULL;
thread_add_write(vty_master, vtysh_write, vty, sock, &vty->t_write);
break;
#endif /* VTYSH */
case VTY_READ:
vty->t_read = thread_add_read (vty_master, vty_read, vty, sock);
vty->t_read = NULL;
thread_add_read(vty_master, vty_read, vty, sock, &vty->t_read);
/* Time out treatment. */
if (vty->v_timeout)
{
if (vty->t_timeout)
thread_cancel (vty->t_timeout);
vty->t_timeout =
thread_add_timer (vty_master, vty_timeout, vty, vty->v_timeout);
vty->t_timeout = NULL;
thread_add_timer(vty_master, vty_timeout, vty, vty->v_timeout,
&vty->t_timeout);
}
break;
case VTY_WRITE:
if (! vty->t_write)
vty->t_write = thread_add_write (vty_master, vty_flush, vty, sock);
thread_add_write(vty_master, vty_flush, vty, sock, &vty->t_write);
break;
case VTY_TIMEOUT_RESET:
if (vty->t_timeout)
@ -2657,8 +2662,9 @@ vty_event (enum event event, int sock, struct vty *vty)
}
if (vty->v_timeout)
{
vty->t_timeout =
thread_add_timer (vty_master, vty_timeout, vty, vty->v_timeout);
vty->t_timeout = NULL;
thread_add_timer(vty_master, vty_timeout, vty, vty->v_timeout,
&vty->t_timeout);
}
break;
}

15
lib/wheel.c
View File

@ -60,9 +60,8 @@ wheel_timer_thread (struct thread *t)
slots_to_skip++;
wheel->slots_to_skip = slots_to_skip;
THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
wheel_timer_thread, wheel,
wheel->nexttime * slots_to_skip);
thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
wheel->nexttime * slots_to_skip, &wheel->timer);
return 0;
}
@ -91,9 +90,8 @@ wheel_init (struct thread_master *master, int period, size_t slots,
for (i = 0; i < slots; i++)
wheel->wheel_slot_lists[i] = list_new ();
THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
wheel_timer_thread, wheel,
wheel->nexttime);
thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
wheel->nexttime, &wheel->timer);
return wheel;
}
@ -124,9 +122,8 @@ int
wheel_start (struct timer_wheel *wheel)
{
if (!wheel->timer)
THREAD_TIMER_MSEC_ON (wheel->master, wheel->timer,
wheel_timer_thread, wheel,
wheel->nexttime);
thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
wheel->nexttime, &wheel->timer);
return 0;
}

5
lib/workqueue.c
View File

@ -126,8 +126,9 @@ work_queue_schedule (struct work_queue *wq, unsigned int delay)
&& (wq->thread == NULL)
&& (listcount (wq->items) > 0) )
{
wq->thread = thread_add_background (wq->master, work_queue_run,
wq, delay);
wq->thread = NULL;
thread_add_background(wq->master, work_queue_run, wq, delay,
&wq->thread);
/* set thread yield time, if needed */
if (wq->thread && wq->spec.yield != THREAD_YIELD_TIME_SLOT)
thread_set_yield_time (wq->thread, wq->spec.yield);

25
lib/zclient.c
View File

@ -310,8 +310,9 @@ zclient_flush_data(struct thread *thread)
return zclient_failed(zclient);
break;
case BUFFER_PENDING:
zclient->t_write = thread_add_write(zclient->master, zclient_flush_data,
zclient, zclient->sock);
zclient->t_write = NULL;
thread_add_write(zclient->master, zclient_flush_data, zclient, zclient->sock,
&zclient->t_write);
break;
case BUFFER_EMPTY:
break;
@ -336,8 +337,8 @@ zclient_send_message(struct zclient *zclient)
THREAD_OFF(zclient->t_write);
break;
case BUFFER_PENDING:
THREAD_WRITE_ON(zclient->master, zclient->t_write,
zclient_flush_data, zclient, zclient->sock);
thread_add_write(zclient->master, zclient_flush_data, zclient,
zclient->sock, &zclient->t_write);
break;
}
return 0;
@ -2012,22 +2013,20 @@ zclient_event (enum event event, struct zclient *zclient)
switch (event)
{
case ZCLIENT_SCHEDULE:
if (! zclient->t_connect)
zclient->t_connect =
thread_add_event (zclient->master, zclient_connect, zclient, 0);
thread_add_event(zclient->master, zclient_connect, zclient, 0,
&zclient->t_connect);
break;
case ZCLIENT_CONNECT:
if (zclient_debug)
zlog_debug ("zclient connect failures: %d schedule interval is now %d",
zclient->fail, zclient->fail < 3 ? 10 : 60);
if (! zclient->t_connect)
zclient->t_connect =
thread_add_timer (zclient->master, zclient_connect, zclient,
zclient->fail < 3 ? 10 : 60);
thread_add_timer(zclient->master, zclient_connect, zclient,
zclient->fail < 3 ? 10 : 60, &zclient->t_connect);
break;
case ZCLIENT_READ:
zclient->t_read =
thread_add_read (zclient->master, zclient_read, zclient, zclient->sock);
zclient->t_read = NULL;
thread_add_read(zclient->master, zclient_read, zclient, zclient->sock,
&zclient->t_read);
break;
}
}

11
nhrpd/netlink_arp.c
View File

@ -124,7 +124,7 @@ static int netlink_route_recv(struct thread *t)
}
}
thread_add_read(master, netlink_route_recv, 0, fd);
thread_add_read(master, netlink_route_recv, 0, fd, NULL);
return 0;
}
@ -214,7 +214,8 @@ static int netlink_log_recv(struct thread *t)
}
}
THREAD_READ_ON(master, netlink_log_thread, netlink_log_recv, 0, netlink_log_fd);
thread_add_read(master, netlink_log_recv, 0, netlink_log_fd,
&netlink_log_thread);
return 0;
}
@ -230,7 +231,8 @@ void netlink_set_nflog_group(int nlgroup)
if (nlgroup) {
netlink_log_fd = znl_open(NETLINK_NETFILTER, 0);
netlink_log_register(netlink_log_fd, nlgroup);
THREAD_READ_ON(master, netlink_log_thread, netlink_log_recv, 0, netlink_log_fd);
thread_add_read(master, netlink_log_recv, 0, netlink_log_fd,
&netlink_log_thread);
}
}
@ -238,7 +240,8 @@ int netlink_init(void)
{
netlink_req_fd = znl_open(NETLINK_ROUTE, 0);
netlink_listen_fd = znl_open(NETLINK_ROUTE, RTMGRP_NEIGH);
thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd);
thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd,
NULL);
return 0;
}

13
nhrpd/nhrp_cache.c
View File

@ -181,11 +181,14 @@ static void nhrp_cache_update_timers(struct nhrp_cache *c)
switch (c->cur.type) {
case NHRP_CACHE_INVALID:
if (!c->t_auth)
THREAD_TIMER_MSEC_ON(master, c->t_timeout, nhrp_cache_do_free, c, 10);
thread_add_timer_msec(master, nhrp_cache_do_free, c,
10, &c->t_timeout);
break;
default:
if (c->cur.expires)
THREAD_TIMER_ON(master, c->t_timeout, nhrp_cache_do_timeout, c, c->cur.expires - monotime(NULL));
thread_add_timer(master, nhrp_cache_do_timeout, c,
c->cur.expires - monotime(NULL),
&c->t_timeout);
break;
}
}
@ -239,7 +242,8 @@ static void nhrp_cache_newpeer_notifier(struct notifier_block *n, unsigned long
case NOTIFY_PEER_UP:
if (nhrp_peer_check(c->new.peer, 1)) {
evmgr_notify("authorize-binding", c, nhrp_cache_authorize_binding);
THREAD_TIMER_ON(master, c->t_auth, nhrp_cache_do_auth_timeout, c, 10);
thread_add_timer(master, nhrp_cache_do_auth_timeout,
c, 10, &c->t_auth);
}
break;
case NOTIFY_PEER_DOWN:
@ -294,7 +298,8 @@ int nhrp_cache_update_binding(struct nhrp_cache *c, enum nhrp_cache_type type, i
} else {
nhrp_peer_notify_add(c->new.peer, &c->newpeer_notifier, nhrp_cache_newpeer_notifier);
nhrp_cache_newpeer_notifier(&c->newpeer_notifier, NOTIFY_PEER_UP);
THREAD_TIMER_ON(master, c->t_auth, nhrp_cache_do_auth_timeout, c, 60);
thread_add_timer(master, nhrp_cache_do_auth_timeout,
c, 60, &c->t_auth);
}
}
nhrp_cache_update_timers(c);

20
nhrpd/nhrp_event.c
View File

@ -40,8 +40,8 @@ static void evmgr_connection_error(struct event_manager *evmgr)
close(evmgr->fd);
evmgr->fd = -1;
if (nhrp_event_socket_path)
THREAD_TIMER_MSEC_ON(master, evmgr->t_reconnect, evmgr_reconnect,
evmgr, 10);
thread_add_timer_msec(master, evmgr_reconnect, evmgr, 10,
&evmgr->t_reconnect);
}
static void evmgr_recv_message(struct event_manager *evmgr, struct zbuf *zb)
@ -85,7 +85,7 @@ static int evmgr_read(struct thread *t)
while (zbuf_may_pull_until(ibuf, "\n\n", &msg))
evmgr_recv_message(evmgr, &msg);
THREAD_READ_ON(master, evmgr->t_read, evmgr_read, evmgr, evmgr->fd);
thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
return 0;
}
@ -97,7 +97,8 @@ static int evmgr_write(struct thread *t)
evmgr->t_write = NULL;
r = zbufq_write(&evmgr->obuf, evmgr->fd);
if (r > 0) {
THREAD_WRITE_ON(master, evmgr->t_write, evmgr_write, evmgr, evmgr->fd);
thread_add_write(master, evmgr_write, evmgr, evmgr->fd,
&evmgr->t_write);
} else if (r < 0) {
evmgr_connection_error(evmgr);
}
@ -170,7 +171,8 @@ static void evmgr_submit(struct event_manager *evmgr, struct zbuf *obuf)
zbuf_put(obuf, "\n", 1);
zbufq_queue(&evmgr->obuf, obuf);
if (evmgr->fd >= 0)
THREAD_WRITE_ON(master, evmgr->t_write, evmgr_write, evmgr, evmgr->fd);
thread_add_write(master, evmgr_write, evmgr, evmgr->fd,
&evmgr->t_write);
}
static int evmgr_reconnect(struct thread *t)
@ -186,13 +188,14 @@ static int evmgr_reconnect(struct thread *t)
zlog_warn("%s: failure connecting nhrp-event socket: %s",
__PRETTY_FUNCTION__, strerror(errno));
zbufq_reset(&evmgr->obuf);
THREAD_TIMER_ON(master, evmgr->t_reconnect, evmgr_reconnect, evmgr, 10);
thread_add_timer(master, evmgr_reconnect, evmgr, 10,
&evmgr->t_reconnect);
return 0;
}
zlog_info("Connected to Event Manager");
evmgr->fd = fd;
THREAD_READ_ON(master, evmgr->t_read, evmgr_read, evmgr, evmgr->fd);
thread_add_read(master, evmgr_read, evmgr, evmgr->fd, &evmgr->t_read);
return 0;
}
@ -206,7 +209,8 @@ void evmgr_init(void)
evmgr->fd = -1;
zbuf_init(&evmgr->ibuf, evmgr->ibuf_data, sizeof(evmgr->ibuf_data), 0);
zbufq_init(&evmgr->obuf);
THREAD_TIMER_MSEC_ON(master, evmgr->t_reconnect, evmgr_reconnect, evmgr, 10);
thread_add_timer_msec(master, evmgr_reconnect, evmgr, 10,
&evmgr->t_reconnect);
}
void evmgr_set_socket(const char *socket)

27
nhrpd/nhrp_nhs.c
View File

@ -81,7 +81,8 @@ static void nhrp_reg_reply(struct nhrp_reqid *reqid, void *arg)
/* RFC 2332 5.2.3 - Registration is recommend to be renewed
* every one third of holdtime */
THREAD_TIMER_ON(master, r->t_register, nhrp_reg_send_req, r, holdtime / 3);
thread_add_timer(master, nhrp_reg_send_req, r, holdtime / 3,
&r->t_register);
r->proto_addr = p->dst_proto;
c = nhrp_cache_get(ifp, &p->dst_proto, 1);
@ -104,7 +105,8 @@ static int nhrp_reg_timeout(struct thread *t)
r->timeout <<= 1;
if (r->timeout > 64) r->timeout = 2;
THREAD_TIMER_MSEC_ON(master, r->t_register, nhrp_reg_send_req, r, 10);
thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
&r->t_register);
return 0;
}
@ -122,7 +124,8 @@ static void nhrp_reg_peer_notify(struct notifier_block *n, unsigned long cmd)
debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %s",
sockunion2str(&r->peer->vc->remote.nbma, buf, sizeof buf));
THREAD_TIMER_OFF(r->t_register);
THREAD_TIMER_MSEC_ON(master, r->t_register, nhrp_reg_send_req, r, 10);
thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
&r->t_register);
break;
}
}
@ -145,11 +148,13 @@ static int nhrp_reg_send_req(struct thread *t)
if (!nhrp_peer_check(r->peer, 2)) {
debugf(NHRP_DEBUG_COMMON, "NHS: Waiting link for %s",
sockunion2str(&r->peer->vc->remote.nbma, buf1, sizeof buf1));
THREAD_TIMER_ON(master, r->t_register, nhrp_reg_send_req, r, 120);
thread_add_timer(master, nhrp_reg_send_req, r, 120,
&r->t_register);
return 0;
}
THREAD_TIMER_ON(master, r->t_register, nhrp_reg_timeout, r, r->timeout);
thread_add_timer(master, nhrp_reg_timeout, r, r->timeout,
&r->t_register);
/* RFC2332 5.2.3 NHC uses it's own address as dst if NHS is unknown */
dst_proto = &nhs->proto_addr;
@ -223,11 +228,13 @@ static void nhrp_nhs_resolve_cb(struct resolver_query *q, int n, union sockunion
nhs->t_resolve = NULL;
if (n < 0) {
/* Failed, retry in a moment */
THREAD_TIMER_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 5);
thread_add_timer(master, nhrp_nhs_resolve, nhs, 5,
&nhs->t_resolve);
return;
}
THREAD_TIMER_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 2*60*60);
thread_add_timer(master, nhrp_nhs_resolve, nhs, 2 * 60 * 60,
&nhs->t_resolve);
list_for_each_entry(reg, &nhs->reglist_head, reglist_entry)
reg->mark = 1;
@ -252,7 +259,8 @@ static void nhrp_nhs_resolve_cb(struct resolver_query *q, int n, union sockunion
list_init(&reg->reglist_entry);
list_add_tail(&reg->reglist_entry, &nhs->reglist_head);
nhrp_peer_notify_add(reg->peer, &reg->peer_notifier, nhrp_reg_peer_notify);
THREAD_TIMER_MSEC_ON(master, reg->t_register, nhrp_reg_send_req, reg, 50);
thread_add_timer_msec(master, nhrp_reg_send_req, reg, 50,
&reg->t_register);
}
list_for_each_entry_safe(reg, regn, &nhs->reglist_head, reglist_entry) {
@ -300,7 +308,8 @@ int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
.reglist_head = LIST_INITIALIZER(nhs->reglist_head),
};
list_add_tail(&nhs->nhslist_entry, &nifp->afi[afi].nhslist_head);
THREAD_TIMER_MSEC_ON(master, nhs->t_resolve, nhrp_nhs_resolve, nhs, 1000);
thread_add_timer_msec(master, nhrp_nhs_resolve, nhs, 1000,
&nhs->t_resolve);
return NHRP_OK;
}

4
nhrpd/nhrp_packet.c
View File

@ -269,7 +269,7 @@ static int nhrp_packet_recvraw(struct thread *t)
uint8_t addr[64];
size_t len, addrlen;
thread_add_read(master, nhrp_packet_recvraw, 0, fd);
thread_add_read(master, nhrp_packet_recvraw, 0, fd, NULL);
zb = zbuf_alloc(1500);
if (!zb) return 0;
@ -307,6 +307,6 @@ err:
int nhrp_packet_init(void)
{
thread_add_read(master, nhrp_packet_recvraw, 0, os_socket());
thread_add_read(master, nhrp_packet_recvraw, 0, os_socket(), NULL);
return 0;
}

13
nhrpd/nhrp_peer.c
View File

@ -79,9 +79,8 @@ static void __nhrp_peer_check(struct nhrp_peer *p)
* the up notification a bit to allow things
* settle down. This allows IKE to install
* SPDs and SAs. */
THREAD_TIMER_MSEC_ON(
master, p->t_fallback,
nhrp_peer_notify_up, p, 50);
thread_add_timer_msec(master, nhrp_peer_notify_up, p,
50, &p->t_fallback);
} else {
nhrp_peer_ref(p);
p->online = online;
@ -230,7 +229,8 @@ static int nhrp_peer_request_timeout(struct thread *t)
p->fallback_requested = 1;
vici_request_vc(nifp->ipsec_fallback_profile,
&vc->local.nbma, &vc->remote.nbma, p->prio);
THREAD_TIMER_ON(master, p->t_fallback, nhrp_peer_request_timeout, p, 30);
thread_add_timer(master, nhrp_peer_request_timeout, p, 30,
&p->t_fallback);
} else {
p->requested = p->fallback_requested = 0;
}
@ -258,8 +258,9 @@ int nhrp_peer_check(struct nhrp_peer *p, int establish)
p->prio = establish > 1;
p->requested = 1;
vici_request_vc(nifp->ipsec_profile, &vc->local.nbma, &vc->remote.nbma, p->prio);
THREAD_TIMER_ON(master, p->t_fallback, nhrp_peer_request_timeout, p,
(nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30);
thread_add_timer(master, nhrp_peer_request_timeout, p,
(nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30,
&p->t_fallback);
return 0;
}

17
nhrpd/nhrp_shortcut.c
View File

@ -38,7 +38,8 @@ static int nhrp_shortcut_do_expire(struct thread *t)
struct nhrp_shortcut *s = THREAD_ARG(t);
s->t_timer = NULL;
THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, s->holding_time/3);
thread_add_timer(master, nhrp_shortcut_do_purge, s,
s->holding_time / 3, &s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
@ -103,7 +104,8 @@ static void nhrp_shortcut_update_binding(struct nhrp_shortcut *s, enum nhrp_cach
if (holding_time) {
s->expiring = 0;
s->holding_time = holding_time;
THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_expire, s, 2*holding_time/3);
thread_add_timer(master, nhrp_shortcut_do_expire, s,
2 * holding_time / 3, &s->t_timer);
}
}
@ -180,7 +182,7 @@ static void nhrp_shortcut_recv_resolution_rep(struct nhrp_reqid *reqid, void *ar
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
THREAD_OFF(s->t_timer);
THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 1);
thread_add_timer(master, nhrp_shortcut_do_purge, s, 1, &s->t_timer);
if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) {
if (pp->hdr->type == NHRP_PACKET_ERROR_INDICATION &&
@ -326,7 +328,8 @@ void nhrp_shortcut_initiate(union sockunion *addr)
if (s && s->type != NHRP_CACHE_INCOMPLETE) {
s->addr = *addr;
THREAD_OFF(s->t_timer);
THREAD_TIMER_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 30);
thread_add_timer(master, nhrp_shortcut_do_purge, s, 30,
&s->t_timer);
nhrp_shortcut_send_resolution_req(s);
}
}
@ -370,7 +373,8 @@ void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force)
if (force) {
/* Immediate purge on route with draw or pending shortcut */
THREAD_TIMER_MSEC_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 5);
thread_add_timer_msec(master, nhrp_shortcut_do_purge, s, 5,
&s->t_timer);
} else {
/* Soft expire - force immediate renewal, but purge
* in few seconds to make sure stale route is not
@ -379,7 +383,8 @@ void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force)
* This allows to keep nhrp route up, and to not
* cause temporary rerouting via hubs causing latency
* jitter. */
THREAD_TIMER_MSEC_ON(master, s->t_timer, nhrp_shortcut_do_purge, s, 3000);
thread_add_timer_msec(master, nhrp_shortcut_do_purge, s, 3000,
&s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
}

15
nhrpd/resolver.c
View File

@ -47,7 +47,8 @@ static int resolver_cb_socket_readable(struct thread *t)
ares_process_fd(r->channel, fd, ARES_SOCKET_BAD);
if (vector_lookup(r->read_threads, fd) == THREAD_RUNNING) {
t = NULL;
THREAD_READ_ON(master, t, resolver_cb_socket_readable, r, fd);
thread_add_read(master, resolver_cb_socket_readable, r, fd,
&t);
vector_set_index(r->read_threads, fd, t);
}
resolver_update_timeouts(r);
@ -64,7 +65,8 @@ static int resolver_cb_socket_writable(struct thread *t)
ares_process_fd(r->channel, ARES_SOCKET_BAD, fd);
if (vector_lookup(r->write_threads, fd) == THREAD_RUNNING) {
t = NULL;
THREAD_WRITE_ON(master, t, resolver_cb_socket_writable, r, fd);
thread_add_write(master, resolver_cb_socket_writable, r, fd,
&t);
vector_set_index(r->write_threads, fd, t);
}
resolver_update_timeouts(r);
@ -82,7 +84,8 @@ static void resolver_update_timeouts(struct resolver_state *r)
tv = ares_timeout(r->channel, NULL, &tvbuf);
if (tv) {
unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
THREAD_TIMER_MSEC_ON(master, r->timeout, resolver_cb_timeout, r, timeoutms);
thread_add_timer_msec(master, resolver_cb_timeout, r,
timeoutms, &r->timeout);
}
}
@ -94,7 +97,8 @@ static void ares_socket_cb(void *data, ares_socket_t fd, int readable, int writa
if (readable) {
t = vector_lookup_ensure(r->read_threads, fd);
if (!t) {
THREAD_READ_ON(master, t, resolver_cb_socket_readable, r, fd);
thread_add_read(master, resolver_cb_socket_readable,
r, fd, &t);
vector_set_index(r->read_threads, fd, t);
}
} else {
@ -110,7 +114,8 @@ static void ares_socket_cb(void *data, ares_socket_t fd, int readable, int writa
if (writable) {
t = vector_lookup_ensure(r->write_threads, fd);
if (!t) {
THREAD_READ_ON(master, t, resolver_cb_socket_writable, r, fd);
thread_add_read(master, resolver_cb_socket_writable,
r, fd, &t);
vector_set_index(r->write_threads, fd, t);
}
} else {

17
nhrpd/vici.c
View File

@ -73,7 +73,7 @@ static void vici_connection_error(struct vici_conn *vici)
close(vici->fd);
vici->fd = -1;
THREAD_TIMER_ON(master, vici->t_reconnect, vici_reconnect, vici, 2);
thread_add_timer(master, vici_reconnect, vici, 2, &vici->t_reconnect);
}
static void vici_parse_message(
@ -324,7 +324,7 @@ static int vici_read(struct thread *t)
vici_recv_message(vici, &pktbuf);
} while (1);
THREAD_READ_ON(master, vici->t_read, vici_read, vici, vici->fd);
thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
return 0;
}
@ -336,7 +336,8 @@ static int vici_write(struct thread *t)
vici->t_write = NULL;
r = zbufq_write(&vici->obuf, vici->fd);
if (r > 0) {
THREAD_WRITE_ON(master, vici->t_write, vici_write, vici, vici->fd);
thread_add_write(master, vici_write, vici, vici->fd,
&vici->t_write);
} else if (r < 0) {
vici_connection_error(vici);
}
@ -352,7 +353,7 @@ static void vici_submit(struct vici_conn *vici, struct zbuf *obuf)
}
zbufq_queue(&vici->obuf, obuf);
THREAD_WRITE_ON(master, vici->t_write, vici_write, vici, vici->fd);
thread_add_write(master, vici_write, vici, vici->fd, &vici->t_write);
}
static void vici_submit_request(struct vici_conn *vici, const char *name, ...)
@ -422,13 +423,14 @@ static int vici_reconnect(struct thread *t)
if (fd < 0) {
zlog_warn("%s: failure connecting VICI socket: %s",
__PRETTY_FUNCTION__, strerror(errno));
THREAD_TIMER_ON(master, vici->t_reconnect, vici_reconnect, vici, 2);
thread_add_timer(master, vici_reconnect, vici, 2,
&vici->t_reconnect);
return 0;
}
debugf(NHRP_DEBUG_COMMON, "VICI: Connected");
vici->fd = fd;
THREAD_READ_ON(master, vici->t_read, vici_read, vici, vici->fd);
thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
/* Send event subscribtions */
//vici_register_event(vici, "child-updown");
@ -451,7 +453,8 @@ void vici_init(void)
vici->fd = -1;
zbuf_init(&vici->ibuf, vici->ibuf_data, sizeof(vici->ibuf_data), 0);
zbufq_init(&vici->obuf);
THREAD_TIMER_MSEC_ON(master, vici->t_reconnect, vici_reconnect, vici, 10);
thread_add_timer_msec(master, vici_reconnect, vici, 10,
&vici->t_reconnect);
}
void vici_terminate(void)

2
ospf6d/ospf6_bfd.c
View File

@ -251,7 +251,7 @@ ospf6_bfd_interface_dest_update (int command, struct zclient *zclient,
if ((status == BFD_STATUS_DOWN) && (old_status == BFD_STATUS_UP))
{
THREAD_OFF (on->inactivity_timer);
thread_add_event (master, inactivity_timer, on, 0);
thread_add_event(master, inactivity_timer, on, 0, NULL);
}
}

69
ospf6d/ospf6_flood.c
View File

@ -112,8 +112,9 @@ ospf6_lsa_originate (struct ospf6_lsa *lsa)
lsdb_self = ospf6_get_scoped_lsdb_self (lsa);
ospf6_lsdb_add (ospf6_lsa_copy (lsa), lsdb_self);
lsa->refresh = thread_add_timer (master, ospf6_lsa_refresh, lsa,
OSPF_LS_REFRESH_TIME);
lsa->refresh = NULL;
thread_add_timer(master, ospf6_lsa_refresh, lsa, OSPF_LS_REFRESH_TIME,
&lsa->refresh);
if (IS_OSPF6_DEBUG_LSA_TYPE (lsa->header->type) ||
IS_OSPF6_DEBUG_ORIGINATE_TYPE (lsa->header->type))
@ -225,9 +226,11 @@ ospf6_install_lsa (struct ospf6_lsa *lsa)
}
monotime(&now);
if (! OSPF6_LSA_IS_MAXAGE (lsa))
lsa->expire = thread_add_timer (master, ospf6_lsa_expire, lsa,
OSPF_LSA_MAXAGE + lsa->birth.tv_sec - now.tv_sec);
if (! OSPF6_LSA_IS_MAXAGE (lsa)) {
lsa->expire = NULL;
thread_add_timer(master, ospf6_lsa_expire, lsa, OSPF_LSA_MAXAGE + lsa->birth.tv_sec - now.tv_sec,
&lsa->expire);
}
else
lsa->expire = NULL;
@ -361,10 +364,8 @@ ospf6_flood_interface (struct ospf6_neighbor *from,
zlog_debug ("Add retrans-list of this neighbor");
ospf6_increment_retrans_count (lsa);
ospf6_lsdb_add (ospf6_lsa_copy (lsa), on->retrans_list);
if (on->thread_send_lsupdate == NULL)
on->thread_send_lsupdate =
thread_add_timer (master, ospf6_lsupdate_send_neighbor,
on, on->ospf6_if->rxmt_interval);
thread_add_timer(master, ospf6_lsupdate_send_neighbor, on, on->ospf6_if->rxmt_interval,
&on->thread_send_lsupdate);
retrans_added++;
}
@ -406,9 +407,8 @@ ospf6_flood_interface (struct ospf6_neighbor *from,
(oi->type == OSPF_IFTYPE_POINTOPOINT))
{
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsupdate_list);
if (oi->thread_send_lsupdate == NULL)
oi->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_interface, oi, 0);
thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0,
&oi->thread_send_lsupdate);
}
else
{
@ -416,8 +416,9 @@ ospf6_flood_interface (struct ospf6_neighbor *from,
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->thread_send_lsupdate);
on->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
on->thread_send_lsupdate = NULL;
thread_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
&on->thread_send_lsupdate);
}
}
}
@ -577,9 +578,8 @@ ospf6_acknowledge_lsa_bdrouter (struct ospf6_lsa *lsa, int ismore_recent,
zlog_debug ("Delayed acknowledgement (BDR & MoreRecent & from DR)");
/* Delayed acknowledgement */
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
&oi->thread_send_lsack);
}
else
{
@ -601,9 +601,8 @@ ospf6_acknowledge_lsa_bdrouter (struct ospf6_lsa *lsa, int ismore_recent,
zlog_debug ("Delayed acknowledgement (BDR & Duplicate & ImpliedAck & from DR)");
/* Delayed acknowledgement */
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
&oi->thread_send_lsack);
}
else
{
@ -621,9 +620,8 @@ ospf6_acknowledge_lsa_bdrouter (struct ospf6_lsa *lsa, int ismore_recent,
if (is_debug)
zlog_debug ("Direct acknowledgement (BDR & Duplicate)");
ospf6_lsdb_add (ospf6_lsa_copy (lsa), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
&from->thread_send_lsack);
return;
}
@ -665,9 +663,8 @@ ospf6_acknowledge_lsa_allother (struct ospf6_lsa *lsa, int ismore_recent,
zlog_debug ("Delayed acknowledgement (AllOther & MoreRecent)");
/* Delayed acknowledgement */
ospf6_lsdb_add (ospf6_lsa_copy (lsa), oi->lsack_list);
if (oi->thread_send_lsack == NULL)
oi->thread_send_lsack =
thread_add_timer (master, ospf6_lsack_send_interface, oi, 3);
thread_add_timer(master, ospf6_lsack_send_interface, oi, 3,
&oi->thread_send_lsack);
return;
}
@ -689,9 +686,8 @@ ospf6_acknowledge_lsa_allother (struct ospf6_lsa *lsa, int ismore_recent,
if (is_debug)
zlog_debug ("Direct acknowledgement (AllOther & Duplicate)");
ospf6_lsdb_add (ospf6_lsa_copy (lsa), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
&from->thread_send_lsack);
return;
}
@ -828,9 +824,8 @@ ospf6_receive_lsa (struct ospf6_neighbor *from,
/* a) Acknowledge back to neighbor (Direct acknowledgement, 13.5) */
ospf6_lsdb_add (ospf6_lsa_copy (new), from->lsack_list);
if (from->thread_send_lsack == NULL)
from->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_neighbor, from, 0);
thread_add_event(master, ospf6_lsack_send_neighbor, from, 0,
&from->thread_send_lsack);
/* b) Discard */
ospf6_lsa_delete (new);
@ -912,7 +907,8 @@ ospf6_receive_lsa (struct ospf6_neighbor *from,
zlog_debug ("Newer instance of the self-originated LSA");
zlog_debug ("Schedule reorigination");
}
new->refresh = thread_add_event (master, ospf6_lsa_refresh, new, 0);
new->refresh = NULL;
thread_add_event(master, ospf6_lsa_refresh, new, 0, &new->refresh);
}
return;
@ -932,7 +928,7 @@ ospf6_receive_lsa (struct ospf6_neighbor *from,
}
/* BadLSReq */
thread_add_event (master, bad_lsreq, from, 0);
thread_add_event(master, bad_lsreq, from, 0, NULL);
ospf6_lsa_delete (new);
return;
@ -998,9 +994,8 @@ ospf6_receive_lsa (struct ospf6_neighbor *from,
/* XXX, MinLSArrival check !? RFC 2328 13 (8) */
ospf6_lsdb_add (ospf6_lsa_copy (old), from->lsupdate_list);
if (from->thread_send_lsupdate == NULL)
from->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_neighbor, from, 0);
thread_add_event(master, ospf6_lsupdate_send_neighbor, from, 0,
&from->thread_send_lsupdate);
ospf6_lsa_delete (new);
return;
}

40
ospf6d/ospf6_interface.c
View File

@ -392,9 +392,9 @@ ospf6_interface_state_update (struct interface *ifp)
if (if_is_operative (ifp)
&& (ospf6_interface_get_linklocal_address(oi->interface)
|| if_is_loopback(oi->interface)))
thread_add_event (master, interface_up, oi, 0);
thread_add_event(master, interface_up, oi, 0, NULL);
else
thread_add_event (master, interface_down, oi, 0);
thread_add_event(master, interface_down, oi, 0, NULL);
return;
}
@ -671,7 +671,7 @@ dr_election (struct ospf6_interface *oi)
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
continue;
/* Schedule AdjOK. */
thread_add_event (master, adj_ok, on, 0);
thread_add_event(master, adj_ok, on, 0, NULL);
}
}
@ -740,8 +740,8 @@ interface_up (struct thread *thread)
{
zlog_info("Scheduling %s for sso retry, trial count: %d",
oi->interface->name, oi->sso_try_cnt);
thread_add_timer (master, interface_up, oi,
OSPF6_INTERFACE_SSO_RETRY_INT);
thread_add_timer(master, interface_up, oi,
OSPF6_INTERFACE_SSO_RETRY_INT, NULL);
}
return 0;
}
@ -752,8 +752,10 @@ interface_up (struct thread *thread)
/* Schedule Hello */
if (! CHECK_FLAG (oi->flag, OSPF6_INTERFACE_PASSIVE) &&
!if_is_loopback (oi->interface))
oi->thread_send_hello = thread_add_event (master, ospf6_hello_send, oi, 0);
!if_is_loopback (oi->interface)) {
oi->thread_send_hello = NULL;
thread_add_event(master, ospf6_hello_send, oi, 0, &oi->thread_send_hello);
}
/* decide next interface state */
if ((if_is_pointopoint (oi->interface)) ||
@ -765,7 +767,7 @@ interface_up (struct thread *thread)
else
{
ospf6_interface_state_change (OSPF6_INTERFACE_WAITING, oi);
thread_add_timer (master, wait_timer, oi, oi->dead_interval);
thread_add_timer(master, wait_timer, oi, oi->dead_interval, NULL);
}
return 0;
@ -1140,7 +1142,7 @@ DEFUN (ipv6_ospf6_ifmtu,
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
thread_add_event (master, inactivity_timer, on, 0);
thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
@ -1187,7 +1189,7 @@ DEFUN (no_ipv6_ospf6_ifmtu,
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
thread_add_event (master, inactivity_timer, on, 0);
thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
@ -1490,7 +1492,7 @@ DEFUN (ipv6_ospf6_passive,
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
{
THREAD_OFF (on->inactivity_timer);
thread_add_event (master, inactivity_timer, on, 0);
thread_add_event(master, inactivity_timer, on, 0, NULL);
}
return CMD_SUCCESS;
@ -1516,8 +1518,8 @@ DEFUN (no_ipv6_ospf6_passive,
UNSET_FLAG (oi->flag, OSPF6_INTERFACE_PASSIVE);
THREAD_OFF (oi->thread_send_hello);
oi->thread_send_hello =
thread_add_event (master, ospf6_hello_send, oi, 0);
oi->thread_send_hello = NULL;
thread_add_event(master, ospf6_hello_send, oi, 0, &oi->thread_send_hello);
return CMD_SUCCESS;
}
@ -1685,8 +1687,8 @@ DEFUN (ipv6_ospf6_network,
}
/* Reset the interface */
thread_add_event (master, interface_down, oi, 0);
thread_add_event (master, interface_up, oi, 0);
thread_add_event(master, interface_down, oi, 0, NULL);
thread_add_event(master, interface_up, oi, 0, NULL);
return CMD_SUCCESS;
}
@ -1720,8 +1722,8 @@ DEFUN (no_ipv6_ospf6_network,
oi->type = type;
/* Reset the interface */
thread_add_event (master, interface_down, oi, 0);
thread_add_event (master, interface_up, oi, 0);
thread_add_event(master, interface_down, oi, 0, NULL);
thread_add_event(master, interface_up, oi, 0, NULL);
return CMD_SUCCESS;
}
@ -1864,8 +1866,8 @@ ospf6_interface_clear (struct vty *vty, struct interface *ifp)
zlog_debug ("Interface %s: clear by reset", ifp->name);
/* Reset the interface */
thread_add_event (master, interface_down, oi, 0);
thread_add_event (master, interface_up, oi, 0);
thread_add_event(master, interface_down, oi, 0, NULL);
thread_add_event(master, interface_up, oi, 0, NULL);
}
/* Clear interface */

34
ospf6d/ospf6_intra.h
View File

@ -156,40 +156,30 @@ struct ospf6_intra_prefix_lsa
#define OSPF6_ROUTER_LSA_SCHEDULE(oa) \
do { \
if (! (oa)->thread_router_lsa \
&& CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
(oa)->thread_router_lsa = \
thread_add_event (master, ospf6_router_lsa_originate, oa, 0); \
if (CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
thread_add_event (master, ospf6_router_lsa_originate, oa, 0, &(oa)->thread_router_lsa); \
} while (0)
#define OSPF6_NETWORK_LSA_SCHEDULE(oi) \
do { \
if (! (oi)->thread_network_lsa \
&& ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
(oi)->thread_network_lsa = \
thread_add_event (master, ospf6_network_lsa_originate, oi, 0); \
if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
thread_add_event (master, ospf6_network_lsa_originate, oi, 0, &(oi)->thread_network_lsa); \
} while (0)
#define OSPF6_LINK_LSA_SCHEDULE(oi) \
do { \
if (! (oi)->thread_link_lsa \
&& ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
(oi)->thread_link_lsa = \
thread_add_event (master, ospf6_link_lsa_originate, oi, 0); \
if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
thread_add_event (master, ospf6_link_lsa_originate, oi, 0, &(oi)->thread_link_lsa); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB(oa) \
do { \
if (! (oa)->thread_intra_prefix_lsa \
&& CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
(oa)->thread_intra_prefix_lsa = \
thread_add_event (master, ospf6_intra_prefix_lsa_originate_stub, \
oa, 0); \
if (CHECK_FLAG((oa)->flag, OSPF6_AREA_ENABLE)) \
thread_add_event (master, ospf6_intra_prefix_lsa_originate_stub, \
oa, 0, &(oa)->thread_intra_prefix_lsa); \
} while (0)
#define OSPF6_INTRA_PREFIX_LSA_SCHEDULE_TRANSIT(oi) \
do { \
if (! (oi)->thread_intra_prefix_lsa \
&& ! CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
(oi)->thread_intra_prefix_lsa = \
thread_add_event (master, ospf6_intra_prefix_lsa_originate_transit, \
oi, 0); \
if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
thread_add_event (master, ospf6_intra_prefix_lsa_originate_transit, \
oi, 0, &(oi)->thread_intra_prefix_lsa); \
} while (0)
#define OSPF6_NETWORK_LSA_EXECUTE(oi) \

6
ospf6d/ospf6_lsa.c
View File

@ -696,7 +696,6 @@ ospf6_lsa_refresh (struct thread *thread)
struct ospf6_lsa *old, *self, *new;
struct ospf6_lsdb *lsdb_self;
assert (thread);
old = (struct ospf6_lsa *) THREAD_ARG (thread);
assert (old && old->header);
@ -722,8 +721,9 @@ ospf6_lsa_refresh (struct thread *thread)
new = ospf6_lsa_create (self->header);
new->lsdb = old->lsdb;
new->refresh = thread_add_timer (master, ospf6_lsa_refresh, new,
OSPF_LS_REFRESH_TIME);
new->refresh = NULL;
thread_add_timer(master, ospf6_lsa_refresh, new, OSPF_LS_REFRESH_TIME,
&new->refresh);
/* store it in the LSDB for self-originated LSAs */
ospf6_lsdb_add (ospf6_lsa_copy (new), lsdb_self);

129
ospf6d/ospf6_message.c
View File

@ -352,9 +352,9 @@ ospf6_hello_recv (struct in6_addr *src, struct in6_addr *dst,
/* Schedule interface events */
if (backupseen)
thread_add_event (master, backup_seen, oi, 0);
thread_add_event (master, backup_seen, oi, 0, NULL);
if (neighborchange)
thread_add_event (master, neighbor_change, oi, 0);
thread_add_event (master, neighbor_change, oi, 0, NULL);
if (neighbor_ifindex_change && on->state == OSPF6_NEIGHBOR_FULL)
OSPF6_ROUTER_LSA_SCHEDULE (oi->area);
@ -428,7 +428,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Master/Slave bit mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -436,7 +436,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Initialize bit mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -444,7 +444,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Option field mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -453,7 +453,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Sequence number mismatch (%#lx expected)",
(u_long) on->dbdesc_seqnum);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
break;
@ -471,7 +471,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Not duplicate dbdesc in state %s",
ospf6_neighbor_state_str[on->state]);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
default:
@ -517,7 +517,7 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("SeqNumMismatch (E-bit mismatch), discard");
ospf6_lsa_delete (his);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -549,19 +549,20 @@ ospf6_dbdesc_recv_master (struct ospf6_header *oh,
on->dbdesc_seqnum ++;
/* schedule send lsreq */
if (on->request_list->count && (on->thread_send_lsreq == NULL))
on->thread_send_lsreq =
thread_add_event (master, ospf6_lsreq_send, on, 0);
if (on->request_list->count)
thread_add_event (master, ospf6_lsreq_send, on, 0, &on->thread_send_lsreq);
THREAD_OFF (on->thread_send_dbdesc);
/* More bit check */
if (! CHECK_FLAG (dbdesc->bits, OSPF6_DBDESC_MBIT) &&
! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT))
thread_add_event (master, exchange_done, on, 0);
else
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send_newone, on, 0);
thread_add_event (master, exchange_done, on, 0, NULL);
else {
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send_newone, on, 0,
&on->thread_send_dbdesc);
}
/* save last received dbdesc */
memcpy (&on->dbdesc_last, dbdesc, sizeof (struct ospf6_dbdesc));
@ -637,8 +638,9 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Duplicated dbdesc causes retransmit");
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
return;
}
@ -646,7 +648,7 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Master/Slave bit mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -654,7 +656,7 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Initialize bit mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -662,7 +664,7 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
{
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Option field mismatch");
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -671,7 +673,7 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Sequence number mismatch (%#lx expected)",
(u_long) on->dbdesc_seqnum + 1);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
break;
@ -684,15 +686,14 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Duplicated dbdesc causes retransmit");
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
thread_add_event (master, ospf6_dbdesc_send, on, 0, &on->thread_send_dbdesc);
return;
}
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("Not duplicate dbdesc in state %s",
ospf6_neighbor_state_str[on->state]);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
default:
@ -735,7 +736,7 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
if (IS_OSPF6_DEBUG_MESSAGE (oh->type, RECV))
zlog_debug ("E-bit mismatch with LSA Headers");
ospf6_lsa_delete (his);
thread_add_event (master, seqnumber_mismatch, on, 0);
thread_add_event (master, seqnumber_mismatch, on, 0, NULL);
return;
}
@ -756,14 +757,11 @@ ospf6_dbdesc_recv_slave (struct ospf6_header *oh,
on->dbdesc_seqnum = ntohl (dbdesc->seqnum);
/* schedule send lsreq */
if ((on->thread_send_lsreq == NULL) &&
(on->request_list->count))
on->thread_send_lsreq =
thread_add_event (master, ospf6_lsreq_send, on, 0);
if (on->request_list->count)
thread_add_event (master, ospf6_lsreq_send, on, 0, &on->thread_send_lsreq);
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send_newone, on, 0);
thread_add_event (master, ospf6_dbdesc_send_newone, on, 0, &on->thread_send_dbdesc);
/* save last received dbdesc */
memcpy (&on->dbdesc_last, dbdesc, sizeof (struct ospf6_dbdesc));
@ -880,7 +878,7 @@ ospf6_lsreq_recv (struct in6_addr *src, struct in6_addr *dst,
zlog_debug ("Can't find requested [%s Id:%s Adv:%s]",
ospf6_lstype_name (e->type), id, adv_router);
}
thread_add_event (master, bad_lsreq, on, 0);
thread_add_event (master, bad_lsreq, on, 0, NULL);
return;
}
@ -891,8 +889,7 @@ ospf6_lsreq_recv (struct in6_addr *src, struct in6_addr *dst,
/* schedule send lsupdate */
THREAD_OFF (on->thread_send_lsupdate);
on->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0, &on->thread_send_lsupdate);
}
/* Verify, that the specified memory area contains exactly N valid IPv6
@ -1532,7 +1529,7 @@ ospf6_receive (struct thread *thread)
/* add next read thread */
sockfd = THREAD_FD (thread);
thread_add_read (master, ospf6_receive, NULL, sockfd);
thread_add_read (master, ospf6_receive, NULL, sockfd, NULL);
/* initialize */
memset (&src, 0, sizeof (src));
@ -1739,8 +1736,7 @@ ospf6_hello_send (struct thread *thread)
}
/* set next thread */
oi->thread_send_hello = thread_add_timer (master, ospf6_hello_send,
oi, oi->hello_interval);
thread_add_timer (master, ospf6_hello_send, oi, oi->hello_interval, &oi->thread_send_hello);
memset (sendbuf, 0, iobuflen);
oh = (struct ospf6_header *) sendbuf;
@ -1804,9 +1800,9 @@ ospf6_dbdesc_send (struct thread *thread)
/* set next thread if master */
if (CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT))
on->thread_send_dbdesc =
thread_add_timer (master, ospf6_dbdesc_send, on,
on->ospf6_if->rxmt_interval);
thread_add_timer (master, ospf6_dbdesc_send, on,
on->ospf6_if->rxmt_interval,
&on->thread_send_dbdesc);
memset (sendbuf, 0, iobuflen);
oh = (struct ospf6_header *) sendbuf;
@ -1896,7 +1892,7 @@ ospf6_dbdesc_send_newone (struct thread *thread)
if (! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT) && /* Slave */
! CHECK_FLAG (on->dbdesc_last.bits, OSPF6_DBDESC_MBIT) &&
! CHECK_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT))
thread_add_event (master, exchange_done, on, 0);
thread_add_event (master, exchange_done, on, 0, NULL);
thread_execute (master, ospf6_dbdesc_send, on, 0);
return 0;
@ -1927,7 +1923,7 @@ ospf6_lsreq_send (struct thread *thread)
/* schedule loading_done if request list is empty */
if (on->request_list->count == 0)
{
thread_add_event (master, loading_done, on, 0);
thread_add_event (master, loading_done, on, 0, NULL);
return 0;
}
@ -1978,9 +1974,9 @@ ospf6_lsreq_send (struct thread *thread)
/* set next thread */
if (on->request_list->count != 0)
{
on->thread_send_lsreq =
thread_add_timer (master, ospf6_lsreq_send, on,
on->ospf6_if->rxmt_interval);
on->thread_send_lsreq = NULL;
thread_add_timer(master, ospf6_lsreq_send, on, on->ospf6_if->rxmt_interval,
&on->thread_send_lsreq);
}
return 0;
@ -2097,13 +2093,16 @@ ospf6_lsupdate_send_neighbor (struct thread *thread)
on->ospf6_if, oh);
}
if (on->lsupdate_list->count != 0)
on->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_neighbor, on, 0);
else if (on->retrans_list->count != 0)
on->thread_send_lsupdate =
thread_add_timer (master, ospf6_lsupdate_send_neighbor, on,
on->ospf6_if->rxmt_interval);
if (on->lsupdate_list->count != 0) {
on->thread_send_lsupdate = NULL;
thread_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
&on->thread_send_lsupdate);
}
else if (on->retrans_list->count != 0) {
on->thread_send_lsupdate = NULL;
thread_add_timer(master, ospf6_lsupdate_send_neighbor, on, on->ospf6_if->rxmt_interval,
&on->thread_send_lsupdate);
}
return 0;
}
@ -2178,8 +2177,9 @@ ospf6_lsupdate_send_interface (struct thread *thread)
if (oi->lsupdate_list->count > 0)
{
oi->thread_send_lsupdate =
thread_add_event (master, ospf6_lsupdate_send_interface, oi, 0);
oi->thread_send_lsupdate = NULL;
thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0,
&oi->thread_send_lsupdate);
}
return 0;
@ -2223,8 +2223,7 @@ ospf6_lsack_send_neighbor (struct thread *thread)
/* if we run out of packet size/space here,
better to try again soon. */
THREAD_OFF (on->thread_send_lsack);
on->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_neighbor, on, 0);
thread_add_event (master, ospf6_lsack_send_neighbor, on, 0, &on->thread_send_lsack);
ospf6_lsdb_lsa_unlock (lsa);
break;
@ -2248,11 +2247,8 @@ ospf6_lsack_send_neighbor (struct thread *thread)
on->ospf6_if, oh);
}
if (on->thread_send_lsack == NULL && on->lsack_list->count > 0)
{
on->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_neighbor, on, 0);
}
if (on->lsack_list->count > 0)
thread_add_event (master, ospf6_lsack_send_neighbor, on, 0, &on->thread_send_lsack);
return 0;
}
@ -2295,8 +2291,8 @@ ospf6_lsack_send_interface (struct thread *thread)
/* if we run out of packet size/space here,
better to try again soon. */
THREAD_OFF (oi->thread_send_lsack);
oi->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_interface, oi, 0);
thread_add_event (master, ospf6_lsack_send_interface, oi, 0,
&oi->thread_send_lsack);
ospf6_lsdb_lsa_unlock (lsa);
break;
@ -2324,11 +2320,8 @@ ospf6_lsack_send_interface (struct thread *thread)
ospf6_send (oi->linklocal_addr, &alldrouters6, oi, oh);
}
if (oi->thread_send_lsack == NULL && oi->lsack_list->count > 0)
{
oi->thread_send_lsack =
thread_add_event (master, ospf6_lsack_send_interface, oi, 0);
}
if (oi->lsack_list->count > 0)
thread_add_event (master, ospf6_lsack_send_interface, oi, 0, &oi->thread_send_lsack);
return 0;
}

40
ospf6d/ospf6_neighbor.c
View File

@ -238,8 +238,9 @@ hello_received (struct thread *thread)
/* reset Inactivity Timer */
THREAD_OFF (on->inactivity_timer);
on->inactivity_timer = thread_add_timer (master, inactivity_timer, on,
on->ospf6_if->dead_interval);
on->inactivity_timer = NULL;
thread_add_timer(master, inactivity_timer, on, on->ospf6_if->dead_interval,
&on->inactivity_timer);
if (on->state <= OSPF6_NEIGHBOR_DOWN)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on,
@ -262,7 +263,7 @@ twoway_received (struct thread *thread)
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_debug ("Neighbor Event %s: *2Way-Received*", on->name);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
if (! need_adjacency (on))
{
@ -278,8 +279,8 @@ twoway_received (struct thread *thread)
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_IBIT);
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0, &on->thread_send_dbdesc);
return 0;
}
@ -385,9 +386,8 @@ exchange_done (struct thread *thread)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_LOADING, on,
OSPF6_NEIGHBOR_EVENT_EXCHANGE_DONE);
if (on->thread_send_lsreq == NULL)
on->thread_send_lsreq =
thread_add_event (master, ospf6_lsreq_send, on, 0);
thread_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
}
return 0;
@ -406,13 +406,14 @@ ospf6_check_nbr_loading (struct ospf6_neighbor *on)
(on->state == OSPF6_NEIGHBOR_EXCHANGE))
{
if (on->request_list->count == 0)
thread_add_event (master, loading_done, on, 0);
thread_add_event(master, loading_done, on, 0, NULL);
else if (on->last_ls_req == NULL)
{
if (on->thread_send_lsreq != NULL)
THREAD_OFF (on->thread_send_lsreq);
on->thread_send_lsreq =
thread_add_event (master, ospf6_lsreq_send, on, 0);
on->thread_send_lsreq = NULL;
thread_add_event(master, ospf6_lsreq_send, on, 0,
&on->thread_send_lsreq);
}
}
}
@ -460,8 +461,9 @@ adj_ok (struct thread *thread)
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_IBIT);
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0,
&on->thread_send_dbdesc);
}
else if (on->state >= OSPF6_NEIGHBOR_EXSTART &&
@ -515,8 +517,8 @@ seqnumber_mismatch (struct thread *thread)
THREAD_OFF (on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0, &on->thread_send_dbdesc);
return 0;
}
@ -554,8 +556,8 @@ bad_lsreq (struct thread *thread)
THREAD_OFF (on->thread_send_dbdesc);
on->dbdesc_seqnum++; /* Incr seqnum as per RFC2328, sec 10.3 */
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
on->thread_send_dbdesc = NULL;
thread_add_event(master, ospf6_dbdesc_send, on, 0, &on->thread_send_dbdesc);
return 0;
}
@ -577,7 +579,7 @@ oneway_received (struct thread *thread)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on,
OSPF6_NEIGHBOR_EVENT_ONEWAY_RCVD);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
ospf6_lsdb_remove_all (on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
@ -613,7 +615,7 @@ inactivity_timer (struct thread *thread)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_DOWN, on,
OSPF6_NEIGHBOR_EVENT_INACTIVITY_TIMER);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
thread_add_event(master, neighbor_change, on->ospf6_if, 0, NULL);
listnode_delete (on->ospf6_if->neighbor_list, on);
ospf6_neighbor_delete (on);

5
ospf6d/ospf6_spf.c
View File

@ -727,8 +727,9 @@ ospf6_spf_schedule (struct ospf6 *ospf6, unsigned int reason)
zlog_info ("SPF: Scheduled in %ld msec", delay);
ospf6->t_spf_calc =
thread_add_timer_msec (master, ospf6_spf_calculation_thread, ospf6, delay);
ospf6->t_spf_calc = NULL;
thread_add_timer_msec(master, ospf6_spf_calculation_thread, ospf6, delay,
&ospf6->t_spf_calc);
}
void

6
ospf6d/ospf6_top.c
View File

@ -286,9 +286,9 @@ ospf6_maxage_remover (struct thread *thread)
void
ospf6_maxage_remove (struct ospf6 *o)
{
if (o && ! o->maxage_remover)
o->maxage_remover = thread_add_timer (master, ospf6_maxage_remover, o,
OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT);
if (o)
thread_add_timer(master, ospf6_maxage_remover, o, OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT,
&o->maxage_remover);
}
/* start ospf6 */

2
ospf6d/ospf6d.c
View File

@ -1252,7 +1252,7 @@ ospf6_init (void)
/* Make ospf protocol socket. */
ospf6_serv_sock ();
thread_add_read (master, ospf6_receive, NULL, ospf6_sock);
thread_add_read(master, ospf6_receive, NULL, ospf6_sock, NULL);
}
void

10
ospfclient/ospfclient.c
View File

@ -168,7 +168,7 @@ lsa_read (struct thread *thread)
}
/* Reschedule read thread */
thread_add_read (master, lsa_read, oclient, fd);
thread_add_read(master, lsa_read, oclient, fd, NULL);
return 0;
}
@ -224,13 +224,13 @@ ready_callback (u_char lsa_type, u_char opaque_type, struct in_addr addr)
lsa_type, opaque_type, inet_ntoa (addr));
/* Schedule opaque LSA originate in 5 secs */
thread_add_timer (master, lsa_inject, oclient, 5);
thread_add_timer(master, lsa_inject, oclient, 5, NULL);
/* Schedule opaque LSA update with new value */
thread_add_timer (master, lsa_inject, oclient, 10);
thread_add_timer(master, lsa_inject, oclient, 10, NULL);
/* Schedule delete */
thread_add_timer (master, lsa_delete, oclient, 30);
thread_add_timer(master, lsa_delete, oclient, 30, NULL);
}
static void
@ -340,7 +340,7 @@ main (int argc, char *argv[])
ospf_apiclient_sync_lsdb (oclient);
/* Schedule thread that handles asynchronous messages */
thread_add_read (master, lsa_read, oclient, oclient->fd_async);
thread_add_read(master, lsa_read, oclient, oclient->fd_async, NULL);
/* Now connection is established, run loop */
while (1)

5
ospfd/ospf_abr.c
View File

@ -1881,7 +1881,6 @@ ospf_schedule_abr_task (struct ospf *ospf)
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Scheduling ABR task");
if (ospf->t_abr_task == NULL)
ospf->t_abr_task = thread_add_timer (master, ospf_abr_task_timer,
ospf, OSPF_ABR_TASK_DELAY);
thread_add_timer(master, ospf_abr_task_timer, ospf, OSPF_ABR_TASK_DELAY,
&ospf->t_abr_task);
}

26
ospfd/ospf_apiserver.c
View File

@ -301,31 +301,27 @@ ospf_apiserver_event (enum event event, int fd,
switch (event)
{
case OSPF_APISERVER_ACCEPT:
(void)thread_add_read (master, ospf_apiserver_accept, apiserv, fd);
(void) thread_add_read(master, ospf_apiserver_accept, apiserv, fd, NULL);
break;
case OSPF_APISERVER_SYNC_READ:
apiserv->t_sync_read =
thread_add_read (master, ospf_apiserver_read, apiserv, fd);
apiserv->t_sync_read = NULL;
thread_add_read(master, ospf_apiserver_read, apiserv, fd,
&apiserv->t_sync_read);
break;
#ifdef USE_ASYNC_READ
case OSPF_APISERVER_ASYNC_READ:
apiserv->t_async_read =
thread_add_read (master, ospf_apiserver_read, apiserv, fd);
apiserv->t_async_read = NULL;
thread_add_read(master, ospf_apiserver_read, apiserv, fd,
&apiserv->t_async_read);
break;
#endif /* USE_ASYNC_READ */
case OSPF_APISERVER_SYNC_WRITE:
if (!apiserv->t_sync_write)
{
apiserv->t_sync_write =
thread_add_write (master, ospf_apiserver_sync_write, apiserv, fd);
}
thread_add_write(master, ospf_apiserver_sync_write, apiserv, fd,
&apiserv->t_sync_write);
break;
case OSPF_APISERVER_ASYNC_WRITE:
if (!apiserv->t_async_write)
{
apiserv->t_async_write =
thread_add_write (master, ospf_apiserver_async_write, apiserv, fd);
}
thread_add_write(master, ospf_apiserver_async_write, apiserv, fd,
&apiserv->t_async_write);
break;
}
}

5
ospfd/ospf_ase.c
View File

@ -705,9 +705,8 @@ ospf_ase_calculate_timer_add (struct ospf *ospf)
if (ospf == NULL)
return;
if (! ospf->t_ase_calc)
ospf->t_ase_calc = thread_add_timer (master, ospf_ase_calculate_timer,
ospf, OSPF_ASE_CALC_INTERVAL);
thread_add_timer(master, ospf_ase_calculate_timer, ospf,
OSPF_ASE_CALC_INTERVAL, &ospf->t_ase_calc);
}
void

35
ospfd/ospf_ism.h
View File

@ -48,30 +48,23 @@
#define ISM_InterfaceDown 7
#define OSPF_ISM_EVENT_MAX 8
#define OSPF_ISM_WRITE_ON(O) \
do \
{ \
if (oi->on_write_q == 0) \
{ \
listnode_add ((O)->oi_write_q, oi); \
oi->on_write_q = 1; \
} \
if ((O)->t_write == NULL) \
(O)->t_write = \
thread_add_write (master, ospf_write, (O), (O)->fd); \
} while (0)
#define OSPF_ISM_WRITE_ON(O) \
do \
{ \
if (oi->on_write_q == 0) \
{ \
listnode_add ((O)->oi_write_q, oi); \
oi->on_write_q = 1; \
} \
thread_add_write (master, ospf_write, (O), (O)->fd, &(O)->t_write); \
} while (0)
/* Macro for OSPF ISM timer turn on. */
#define OSPF_ISM_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), oi, (V)); \
} while (0)
thread_add_timer (master, (F), oi, (V), &(T))
#define OSPF_ISM_TIMER_MSEC_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer_msec (master, (F), oi, (V)); \
} while (0)
thread_add_timer_msec (master, (F), oi, (V), &(T))
/* convenience macro to set hello timer correctly, according to
* whether fast-hello is set or not
@ -98,7 +91,7 @@
/* Macro for OSPF schedule event. */
#define OSPF_ISM_EVENT_SCHEDULE(I,E) \
thread_add_event (master, ospf_ism_event, (I), (E))
thread_add_event (master, ospf_ism_event, (I), (E), NULL)
/* Macro for OSPF execute event. */
#define OSPF_ISM_EVENT_EXECUTE(I,E) \

9
ospfd/ospf_lsa.c
View File

@ -3553,7 +3553,7 @@ ospf_schedule_lsa_flood_area (struct ospf_area *area, struct ospf_lsa *lsa)
data->area = area;
data->lsa = ospf_lsa_lock (lsa); /* Message / Flood area */
thread_add_event (master, ospf_lsa_action, data, 0);
thread_add_event(master, ospf_lsa_action, data, 0, NULL);
}
void
@ -3566,7 +3566,7 @@ ospf_schedule_lsa_flush_area (struct ospf_area *area, struct ospf_lsa *lsa)
data->area = area;
data->lsa = ospf_lsa_lock (lsa); /* Message / Flush area */
thread_add_event (master, ospf_lsa_action, data, 0);
thread_add_event(master, ospf_lsa_action, data, 0, NULL);
}
@ -3741,8 +3741,9 @@ ospf_lsa_refresh_walker (struct thread *t)
}
}
ospf->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
ospf, ospf->lsa_refresh_interval);
ospf->t_lsa_refresher = NULL;
thread_add_timer(master, ospf_lsa_refresh_walker, ospf, ospf->lsa_refresh_interval,
&ospf->t_lsa_refresher);
ospf->lsa_refresher_started = monotime(NULL);
for (ALL_LIST_ELEMENTS (lsa_to_refresh, node, nnode, lsa))

8
ospfd/ospf_nsm.h
View File

@ -57,11 +57,7 @@
#define OSPF_NSM_EVENT_MAX 14
/* Macro for OSPF NSM timer turn on. */
#define OSPF_NSM_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), nbr, (V)); \
} while (0)
#define OSPF_NSM_TIMER_ON(T,F,V) thread_add_timer (master, (F), nbr, (V), &(T))
/* Macro for OSPF NSM timer turn off. */
#define OSPF_NSM_TIMER_OFF(X) \
@ -75,7 +71,7 @@
/* Macro for OSPF NSM schedule event. */
#define OSPF_NSM_EVENT_SCHEDULE(N,E) \
thread_add_event (master, ospf_nsm_event, (N), (E))
thread_add_event (master, ospf_nsm_event, (N), (E), NULL)
/* Macro for OSPF NSM execute event. */
#define OSPF_NSM_EVENT_EXECUTE(N,E) \

21
ospfd/ospf_opaque.c
View File

@ -1342,8 +1342,9 @@ ospf_opaque_lsa_originate_schedule (struct ospf_interface *oi, int *delay0)
{
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-9 Opaque-LSA origination in %d ms later.", delay);
oi->t_opaque_lsa_self =
thread_add_timer_msec (master, ospf_opaque_type9_lsa_originate, oi, delay);
oi->t_opaque_lsa_self = NULL;
thread_add_timer_msec(master, ospf_opaque_type9_lsa_originate, oi, delay,
&oi->t_opaque_lsa_self);
delay += top->min_ls_interval;
}
@ -1358,9 +1359,9 @@ ospf_opaque_lsa_originate_schedule (struct ospf_interface *oi, int *delay0)
*/
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-10 Opaque-LSA origination in %d ms later.", delay);
area->t_opaque_lsa_self =
thread_add_timer_msec (master, ospf_opaque_type10_lsa_originate,
area, delay);
area->t_opaque_lsa_self = NULL;
thread_add_timer_msec(master, ospf_opaque_type10_lsa_originate, area, delay,
&area->t_opaque_lsa_self);
delay += top->min_ls_interval;
}
@ -1375,9 +1376,9 @@ ospf_opaque_lsa_originate_schedule (struct ospf_interface *oi, int *delay0)
*/
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("Schedule Type-11 Opaque-LSA origination in %d ms later.", delay);
top->t_opaque_lsa_self =
thread_add_timer_msec (master, ospf_opaque_type11_lsa_originate,
top, delay);
top->t_opaque_lsa_self = NULL;
thread_add_timer_msec(master, ospf_opaque_type11_lsa_originate, top, delay,
&top->t_opaque_lsa_self);
delay += top->min_ls_interval;
}
@ -1654,9 +1655,7 @@ ospf_opaque_lsa_refresh (struct ospf_lsa *lsa)
* triggered by external interventions (vty session, signaling, etc).
*------------------------------------------------------------------------*/
#define OSPF_OPAQUE_TIMER_ON(T,F,L,V) \
if (!(T)) \
(T) = thread_add_timer_msec (master, (F), (L), (V))
#define OSPF_OPAQUE_TIMER_ON(T,F,L,V) thread_add_timer_msec (master, (F), (L), (V), &(T))
static struct ospf_lsa *pseudo_lsa (struct ospf_interface *oi, struct ospf_area *area, u_char lsa_type, u_char opaque_type);
static int ospf_opaque_type9_lsa_reoriginate_timer (struct thread *t);

28
ospfd/ospf_packet.c
View File

@ -487,7 +487,8 @@ ospf_ls_req_event (struct ospf_neighbor *nbr)
thread_cancel (nbr->t_ls_req);
nbr->t_ls_req = NULL;
}
nbr->t_ls_req = thread_add_event (master, ospf_ls_req_timer, nbr, 0);
nbr->t_ls_req = NULL;
thread_add_event(master, ospf_ls_req_timer, nbr, 0, &nbr->t_ls_req);
}
/* Cyclic timer function. Fist registered in ospf_nbr_new () in
@ -850,9 +851,10 @@ ospf_write (struct thread *thread)
}
/* If packets still remain in queue, call write thread. */
if (!list_isempty (ospf->oi_write_q))
ospf->t_write =
thread_add_write (master, ospf_write, ospf, ospf->fd);
if (!list_isempty (ospf->oi_write_q)) {
ospf->t_write = NULL;
thread_add_write(master, ospf_write, ospf, ospf->fd, &ospf->t_write);
}
return 0;
}
@ -2772,7 +2774,8 @@ ospf_read (struct thread *thread)
ospf = THREAD_ARG (thread);
/* prepare for next packet. */
ospf->t_read = thread_add_read (master, ospf_read, ospf, ospf->fd);
ospf->t_read = NULL;
thread_add_read(master, ospf_read, ospf, ospf->fd, &ospf->t_read);
stream_reset(ospf->ibuf);
if (!(ibuf = ospf_recv_packet (ospf->fd, &ifp, ospf->ibuf)))
@ -3802,8 +3805,9 @@ ospf_ls_upd_send_queue_event (struct thread *thread)
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("ospf_ls_upd_send_queue: update lists not cleared,"
" %d nodes to try again, raising new event", again);
oi->t_ls_upd_event =
thread_add_event (master, ospf_ls_upd_send_queue_event, oi, 0);
oi->t_ls_upd_event = NULL;
thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
&oi->t_ls_upd_event);
}
if (IS_DEBUG_OSPF_EVENT)
@ -3858,9 +3862,8 @@ ospf_ls_upd_send (struct ospf_neighbor *nbr, struct list *update, int flag)
for (ALL_LIST_ELEMENTS_RO (update, node, lsa))
listnode_add (rn->info, ospf_lsa_lock (lsa)); /* oi->ls_upd_queue */
if (oi->t_ls_upd_event == NULL)
oi->t_ls_upd_event =
thread_add_event (master, ospf_ls_upd_send_queue_event, oi, 0);
thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
&oi->t_ls_upd_event);
}
static void
@ -3921,9 +3924,8 @@ ospf_ls_ack_send (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
listnode_add (oi->ls_ack_direct.ls_ack, ospf_lsa_lock (lsa));
if (oi->t_ls_ack_direct == NULL)
oi->t_ls_ack_direct =
thread_add_event (master, ospf_ls_ack_send_event, oi, 0);
thread_add_event(master, ospf_ls_ack_send_event, oi, 0,
&oi->t_ls_ack_direct);
}
/* Send Link State Acknowledgment delayed. */

5
ospfd/ospf_spf.c
View File

@ -1464,6 +1464,7 @@ ospf_spf_calculate_schedule (struct ospf *ospf, ospf_spf_reason_t reason)
zlog_info ("SPF: Scheduled in %ld msec", delay);
ospf->t_spf_calc =
thread_add_timer_msec (master, ospf_spf_calculate_timer, ospf, delay);
ospf->t_spf_calc = NULL;
thread_add_timer_msec(master, ospf_spf_calculate_timer, ospf, delay,
&ospf->t_spf_calc);
}

8
ospfd/ospf_zebra.c
View File

@ -883,7 +883,7 @@ ospf_redistribute_default_set (struct ospf *ospf, int originate,
if (ospf->router_id.s_addr == 0)
ospf->external_origin |= (1 << DEFAULT_ROUTE);
else
thread_add_timer (master, ospf_default_originate_timer, ospf, 1);
thread_add_timer(master, ospf_default_originate_timer, ospf, 1, NULL);
ospf_asbr_status_update (ospf, ++ospf->redistribute);
@ -1278,9 +1278,9 @@ ospf_distribute_list_update (struct ospf *ospf, uintptr_t type,
return;
/* Set timer. */
ospf->t_distribute_update =
thread_add_timer_msec (master, ospf_distribute_list_update_timer,
(void *) type, ospf->min_ls_interval);
ospf->t_distribute_update = NULL;
thread_add_timer_msec(master, ospf_distribute_list_update_timer, (void *)type, ospf->min_ls_interval,
&ospf->t_distribute_update);
}
/* If access-list is updated, apply some check. */

37
ospfd/ospfd.c
View File

@ -135,11 +135,12 @@ ospf_router_id_update (struct ospf *ospf)
/* Originate each redistributed external route. */
for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
if (ospf->external_origin & (1 << type))
thread_add_event (master, ospf_external_lsa_originate_timer,
ospf, type);
thread_add_event(master, ospf_external_lsa_originate_timer,
ospf, type, NULL);
/* Originate Deafult. */
if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
thread_add_event (master, ospf_default_originate_timer, ospf, 0);
thread_add_event(master, ospf_default_originate_timer, ospf, 0,
NULL);
ospf->external_origin = 0;
}
@ -184,9 +185,9 @@ ospf_router_id_update (struct ospf *ospf)
/* Originate each redistributed external route. */
for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
thread_add_event (master, ospf_external_lsa_originate_timer,
ospf, type);
thread_add_event (master, ospf_default_originate_timer, ospf, 0);
thread_add_event(master, ospf_external_lsa_originate_timer, ospf,
type, NULL);
thread_add_event(master, ospf_default_originate_timer, ospf, 0, NULL);
/* update router-lsa's for each area */
ospf_router_lsa_update (ospf);
@ -263,17 +264,18 @@ ospf_new (u_short instance)
/* MaxAge init. */
new->maxage_delay = OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT;
new->maxage_lsa = route_table_init();
new->t_maxage_walker =
thread_add_timer (master, ospf_lsa_maxage_walker,
new, OSPF_LSA_MAXAGE_CHECK_INTERVAL);
new->t_maxage_walker = NULL;
thread_add_timer(master, ospf_lsa_maxage_walker, new, OSPF_LSA_MAXAGE_CHECK_INTERVAL,
&new->t_maxage_walker);
/* Distance table init. */
new->distance_table = route_table_init ();
new->lsa_refresh_queue.index = 0;
new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
new->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
new, new->lsa_refresh_interval);
new->t_lsa_refresher = NULL;
thread_add_timer(master, ospf_lsa_refresh_walker, new, new->lsa_refresh_interval,
&new->t_lsa_refresher);
new->lsa_refresher_started = monotime(NULL);
if ((new->fd = ospf_sock_init()) < 0)
@ -288,7 +290,8 @@ ospf_new (u_short instance)
OSPF_MAX_PACKET_SIZE+1);
exit(1);
}
new->t_read = thread_add_read (master, ospf_read, new, new->fd);
new->t_read = NULL;
thread_add_read(master, ospf_read, new, new->fd, &new->t_read);
new->oi_write_q = list_new ();
new->write_oi_count = OSPF_WRITE_INTERFACE_COUNT_DEFAULT;
@ -1592,8 +1595,8 @@ ospf_timers_refresh_set (struct ospf *ospf, int interval)
if (time_left > interval)
{
OSPF_TIMER_OFF (ospf->t_lsa_refresher);
ospf->t_lsa_refresher =
thread_add_timer (master, ospf_lsa_refresh_walker, ospf, interval);
thread_add_timer(master, ospf_lsa_refresh_walker, ospf, interval,
&ospf->t_lsa_refresher);
}
ospf->lsa_refresh_interval = interval;
@ -1611,9 +1614,9 @@ ospf_timers_refresh_unset (struct ospf *ospf)
if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
{
OSPF_TIMER_OFF (ospf->t_lsa_refresher);
ospf->t_lsa_refresher =
thread_add_timer (master, ospf_lsa_refresh_walker, ospf,
OSPF_LSA_REFRESH_INTERVAL_DEFAULT);
ospf->t_lsa_refresher = NULL;
thread_add_timer(master, ospf_lsa_refresh_walker, ospf, OSPF_LSA_REFRESH_INTERVAL_DEFAULT,
&ospf->t_lsa_refresher);
}
ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;

24
ospfd/ospfd.h
View File

@ -480,26 +480,10 @@ struct ospf_nbr_nbma
#define LSA_OPTIONS_NSSA_GET(area) \
(((area)->external_routing == OSPF_AREA_NSSA) ? OSPF_OPTION_NP : 0)
#define OSPF_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), ospf, (V)); \
} while (0)
#define OSPF_AREA_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), area, (V)); \
} while (0)
#define OSPF_POLL_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), nbr_nbma, (V)); \
} while (0)
#define OSPF_POLL_TIMER_OFF(X) OSPF_TIMER_OFF((X))
#define OSPF_TIMER_ON(T,F,V) thread_add_timer (master,(F),ospf,(V),&(T))
#define OSPF_AREA_TIMER_ON(T,F,V) thread_add_timer (master, (F), area, (V), &(T))
#define OSPF_POLL_TIMER_ON(T,F,V) thread_add_timer (master, (F), nbr_nbma, (V), &(T))
#define OSPF_POLL_TIMER_OFF(X) OSPF_TIMER_OFF((X))
#define OSPF_TIMER_OFF(X) \
do { \
if (X) \

5
pimd/pim_assert.c
View File

@ -576,9 +576,8 @@ static void pim_assert_timer_set(struct pim_ifchannel *ch,
ch->sg_str, interval, ch->interface->name);
}
THREAD_TIMER_ON(master, ch->t_ifassert_timer,
on_assert_timer,
ch, interval);
thread_add_timer(master, on_assert_timer, ch, interval,
&ch->t_ifassert_timer);
}
static void pim_assert_timer_reset(struct pim_ifchannel *ch)

37
pimd/pim_ifchannel.c
View File

@ -855,9 +855,8 @@ void pim_ifchannel_join_add(struct interface *ifp,
}
if (holdtime != 0xFFFF) {
THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
on_ifjoin_expiry_timer,
ch, holdtime);
thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
&ch->t_ifjoin_expiry_timer);
}
}
@ -907,12 +906,11 @@ void pim_ifchannel_prune(struct interface *ifp,
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
THREAD_OFF(ch->t_ifjoin_expiry_timer);
THREAD_TIMER_MSEC_ON(master, ch->t_ifjoin_prune_pending_timer,
on_ifjoin_prune_pending_timer,
ch, jp_override_interval_msec);
THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
on_ifjoin_expiry_timer,
ch, holdtime);
thread_add_timer_msec(master, on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
&ch->t_ifjoin_prune_pending_timer);
thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
&ch->t_ifjoin_expiry_timer);
pim_upstream_update_join_desired(ch->upstream);
}
break;
@ -932,17 +930,16 @@ void pim_ifchannel_prune(struct interface *ifp,
be taken not to use "ch" afterwards since it would be
deleted. */
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
THREAD_TIMER_MSEC_ON(master, ch->t_ifjoin_prune_pending_timer,
on_ifjoin_prune_pending_timer,
ch, jp_override_interval_msec);
thread_add_timer_msec(master, on_ifjoin_prune_pending_timer, ch,
jp_override_interval_msec,
&ch->t_ifjoin_prune_pending_timer);
break;
case PIM_IFJOIN_PRUNE:
if (source_flags & PIM_ENCODE_RPT_BIT)
{
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
on_ifjoin_expiry_timer,
ch, holdtime);
thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
&ch->t_ifjoin_expiry_timer);
}
break;
case PIM_IFJOIN_PRUNE_TMP:
@ -950,9 +947,8 @@ void pim_ifchannel_prune(struct interface *ifp,
{
ch->ifjoin_state = PIM_IFJOIN_PRUNE;
THREAD_OFF(ch->t_ifjoin_expiry_timer);
THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
on_ifjoin_expiry_timer,
ch, holdtime);
thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
&ch->t_ifjoin_expiry_timer);
}
break;
case PIM_IFJOIN_PRUNE_PENDING_TMP:
@ -960,9 +956,8 @@ void pim_ifchannel_prune(struct interface *ifp,
{
ch->ifjoin_state = PIM_IFJOIN_PRUNE_PENDING;
THREAD_OFF(ch->t_ifjoin_expiry_timer);
THREAD_TIMER_ON(master, ch->t_ifjoin_expiry_timer,
on_ifjoin_expiry_timer,
ch, holdtime);
thread_add_timer(master, on_ifjoin_expiry_timer, ch, holdtime,
&ch->t_ifjoin_expiry_timer);
}
break;
}

18
pimd/pim_igmp.c
View File

@ -247,9 +247,9 @@ void pim_igmp_other_querier_timer_on(struct igmp_sock *igmp)
other_querier_present_interval_msec % 1000);
}
THREAD_TIMER_MSEC_ON(master, igmp->t_other_querier_timer,
pim_igmp_other_querier_expire,
igmp, other_querier_present_interval_msec);
thread_add_timer_msec(master, pim_igmp_other_querier_expire, igmp,
other_querier_present_interval_msec,
&igmp->t_other_querier_timer);
}
void pim_igmp_other_querier_timer_off(struct igmp_sock *igmp)
@ -551,9 +551,8 @@ void pim_igmp_general_query_on(struct igmp_sock *igmp)
igmp->fd);
}
igmp->t_igmp_query_timer = NULL;
THREAD_TIMER_ON(master, igmp->t_igmp_query_timer,
pim_igmp_general_query,
igmp, query_interval);
thread_add_timer(master, pim_igmp_general_query, igmp, query_interval,
&igmp->t_igmp_query_timer);
}
void pim_igmp_general_query_off(struct igmp_sock *igmp)
@ -896,7 +895,7 @@ igmp_read_on (struct igmp_sock *igmp)
igmp->fd);
}
igmp->t_igmp_read = NULL;
THREAD_READ_ON(master, igmp->t_igmp_read, pim_igmp_read, igmp, igmp->fd);
thread_add_read(master, pim_igmp_read, igmp, igmp->fd, &igmp->t_igmp_read);
}
@ -1029,9 +1028,8 @@ void igmp_group_timer_on(struct igmp_group *group,
*/
zassert(group->group_filtermode_isexcl);
THREAD_TIMER_MSEC_ON(master, group->t_group_timer,
igmp_group_timer,
group, interval_msec);
thread_add_timer_msec(master, igmp_group_timer, group, interval_msec,
&group->t_group_timer);
}
struct igmp_group *

10
pimd/pim_igmpv3.c
View File

@ -215,9 +215,8 @@ static void igmp_source_timer_on(struct igmp_group *group,
group->group_igmp_sock->interface->name);
}
THREAD_TIMER_MSEC_ON(master, source->t_source_timer,
igmp_source_timer,
source, interval_msec);
thread_add_timer_msec(master, igmp_source_timer, source, interval_msec,
&source->t_source_timer);
zassert(source->t_source_timer);
/*
@ -1328,9 +1327,8 @@ static void group_retransmit_timer_on(struct igmp_group *group)
igmp->interface->name);
}
THREAD_TIMER_MSEC_ON(master, group->t_group_query_retransmit_timer,
igmp_group_retransmit,
group, lmqi_msec);
thread_add_timer_msec(master, igmp_group_retransmit, group, lmqi_msec,
&group->t_group_query_retransmit_timer);
}
static long igmp_group_timer_remain_msec(struct igmp_group *group)

4
pimd/pim_mroute.c
View File

@ -636,8 +636,8 @@ static void mroute_read_on()
{
zassert(!qpim_mroute_socket_reader);
THREAD_READ_ON(master, qpim_mroute_socket_reader,
mroute_read, 0, qpim_mroute_socket_fd);
thread_add_read(master, mroute_read, 0, qpim_mroute_socket_fd,
&qpim_mroute_socket_reader);
}
static void mroute_read_off()

20
pimd/pim_msdp.c
View File

@ -82,8 +82,8 @@ pim_msdp_sa_adv_timer_setup(bool start)
{
THREAD_OFF(msdp->sa_adv_timer);
if (start) {
THREAD_TIMER_ON(msdp->master, msdp->sa_adv_timer,
pim_msdp_sa_adv_timer_cb, NULL, PIM_MSDP_SA_ADVERTISMENT_TIME);
thread_add_timer(msdp->master, pim_msdp_sa_adv_timer_cb, NULL,
PIM_MSDP_SA_ADVERTISMENT_TIME, &msdp->sa_adv_timer);
}
}
@ -108,8 +108,8 @@ pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
{
THREAD_OFF(sa->sa_state_timer);
if (start) {
THREAD_TIMER_ON(msdp->master, sa->sa_state_timer,
pim_msdp_sa_state_timer_cb, sa, PIM_MSDP_SA_HOLD_TIME);
thread_add_timer(msdp->master, pim_msdp_sa_state_timer_cb, sa,
PIM_MSDP_SA_HOLD_TIME, &sa->sa_state_timer);
}
}
@ -920,8 +920,8 @@ pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->hold_timer);
if (start) {
THREAD_TIMER_ON(msdp->master, mp->hold_timer,
pim_msdp_peer_hold_timer_cb, mp, PIM_MSDP_PEER_HOLD_TIME);
thread_add_timer(msdp->master, pim_msdp_peer_hold_timer_cb, mp,
PIM_MSDP_PEER_HOLD_TIME, &mp->hold_timer);
}
}
@ -948,8 +948,8 @@ pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->ka_timer);
if (start) {
THREAD_TIMER_ON(msdp->master, mp->ka_timer,
pim_msdp_peer_ka_timer_cb, mp, PIM_MSDP_PEER_KA_TIME);
thread_add_timer(msdp->master, pim_msdp_peer_ka_timer_cb, mp,
PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
}
}
@ -1013,8 +1013,8 @@ pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->cr_timer);
if (start) {
THREAD_TIMER_ON(msdp->master, mp->cr_timer,
pim_msdp_peer_cr_timer_cb, mp, PIM_MSDP_PEER_CONNECT_RETRY_TIME);
thread_add_timer(msdp->master, pim_msdp_peer_cr_timer_cb, mp,
PIM_MSDP_PEER_CONNECT_RETRY_TIME, &mp->cr_timer);
}
}

7
pimd/pim_msdp.h
View File

@ -197,8 +197,11 @@ struct pim_msdp {
struct pim_msdp_mg *mg;
};
#define PIM_MSDP_PEER_READ_ON(mp) THREAD_READ_ON(msdp->master, mp->t_read, pim_msdp_read, mp, mp->fd);
#define PIM_MSDP_PEER_WRITE_ON(mp) THREAD_WRITE_ON(msdp->master, mp->t_write, pim_msdp_write, mp, mp->fd);
#define PIM_MSDP_PEER_READ_ON(mp) \
thread_add_read (msdp->master, pim_msdp_read, mp, mp->fd, &mp->t_read)
#define PIM_MSDP_PEER_WRITE_ON(mp) \
thread_add_write (msdp->master, pim_msdp_write, mp, mp->fd, &mp->t_write)
#define PIM_MSDP_PEER_READ_OFF(mp) THREAD_READ_OFF(mp->t_read)
#define PIM_MSDP_PEER_WRITE_OFF(mp) THREAD_WRITE_OFF(mp->t_write)

9
pimd/pim_msdp_socket.c
View File

@ -70,8 +70,9 @@ pim_msdp_sock_accept(struct thread *thread)
zlog_err ("accept_sock is negative value %d", accept_sock);
return -1;
}
listener->thread = thread_add_read(master, pim_msdp_sock_accept,
listener, accept_sock);
listener->thread = NULL;
thread_add_read(master, pim_msdp_sock_accept, listener, accept_sock,
&listener->thread);
/* accept client connection. */
msdp_sock = sockunion_accept(accept_sock, &su);
@ -173,7 +174,9 @@ pim_msdp_sock_listen(void)
/* add accept thread */
listener->fd = sock;
memcpy(&listener->su, &sin, socklen);
listener->thread = thread_add_read(msdp->master, pim_msdp_sock_accept, listener, sock);
listener->thread = NULL;
thread_add_read(msdp->master, pim_msdp_sock_accept, listener, sock,
&listener->thread);
msdp->flags |= PIM_MSDPF_LISTENER;
return 0;

15
pimd/pim_neighbor.c
View File

@ -262,9 +262,8 @@ void pim_neighbor_timer_reset(struct pim_neighbor *neigh, uint16_t holdtime)
neigh->holdtime, src_str, neigh->interface->name);
}
THREAD_TIMER_ON(master, neigh->t_expire_timer,
on_neighbor_timer,
neigh, neigh->holdtime);
thread_add_timer(master, on_neighbor_timer, neigh, neigh->holdtime,
&neigh->t_expire_timer);
}
static int
@ -286,9 +285,8 @@ on_neighbor_jp_timer (struct thread *t)
rpf.rpf_addr.u.prefix4 = neigh->source_addr;
pim_joinprune_send(&rpf, neigh->upstream_jp_agg);
THREAD_TIMER_ON(master, neigh->jp_timer,
on_neighbor_jp_timer,
neigh, qpim_t_periodic);
thread_add_timer(master, on_neighbor_jp_timer, neigh, qpim_t_periodic,
&neigh->jp_timer);
return 0;
}
@ -297,9 +295,8 @@ static void
pim_neighbor_start_jp_timer (struct pim_neighbor *neigh)
{
THREAD_TIMER_OFF(neigh->jp_timer);
THREAD_TIMER_ON(master, neigh->jp_timer,
on_neighbor_jp_timer,
neigh, qpim_t_periodic);
thread_add_timer(master, on_neighbor_jp_timer, neigh, qpim_t_periodic,
&neigh->jp_timer);
}
static struct pim_neighbor *pim_neighbor_new(struct interface *ifp,

14
pimd/pim_pim.c
View File

@ -383,8 +383,8 @@ static void pim_sock_read_on(struct interface *ifp)
pim_ifp->pim_sock_fd);
}
pim_ifp->t_pim_sock_read = NULL;
THREAD_READ_ON(master, pim_ifp->t_pim_sock_read, pim_sock_read, ifp,
pim_ifp->pim_sock_fd);
thread_add_read(master, pim_sock_read, ifp, pim_ifp->pim_sock_fd,
&pim_ifp->t_pim_sock_read);
}
static int pim_sock_open(struct interface *ifp)
@ -703,9 +703,8 @@ static void hello_resched(struct interface *ifp)
pim_ifp->pim_hello_period, ifp->name);
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
THREAD_TIMER_ON(master, pim_ifp->t_pim_hello_timer,
on_pim_hello_send,
ifp, pim_ifp->pim_hello_period);
thread_add_timer(master, on_pim_hello_send, ifp, pim_ifp->pim_hello_period,
&pim_ifp->t_pim_hello_timer);
}
/*
@ -814,9 +813,8 @@ void pim_hello_restart_triggered(struct interface *ifp)
random_msec, ifp->name);
}
THREAD_TIMER_MSEC_ON(master, pim_ifp->t_pim_hello_timer,
on_pim_hello_send,
ifp, random_msec);
thread_add_timer_msec(master, on_pim_hello_send, ifp, random_msec,
&pim_ifp->t_pim_hello_timer);
}
int pim_sock_add(struct interface *ifp)

4
pimd/pim_ssmpingd.c
View File

@ -331,8 +331,8 @@ static int ssmpingd_sock_read(struct thread *t)
static void ssmpingd_read_on(struct ssmpingd_sock *ss)
{
zassert(!ss->t_sock_read);
THREAD_READ_ON(master, ss->t_sock_read,
ssmpingd_sock_read, ss, ss->sock_fd);
thread_add_read(master, ssmpingd_sock_read, ss, ss->sock_fd,
&ss->t_sock_read);
}
static struct ssmpingd_sock *ssmpingd_new(struct in_addr source_addr)

25
pimd/pim_upstream.c
View File

@ -340,9 +340,8 @@ join_timer_start(struct pim_upstream *up)
else
{
THREAD_OFF (up->t_join_timer);
THREAD_TIMER_ON(master, up->t_join_timer,
on_join_timer,
up, qpim_t_periodic);
thread_add_timer(master, on_join_timer, up, qpim_t_periodic,
&up->t_join_timer);
}
pim_jp_agg_upstream_verification (up, true);
}
@ -371,9 +370,8 @@ static void pim_upstream_join_timer_restart_msec(struct pim_upstream *up,
}
THREAD_OFF(up->t_join_timer);
THREAD_TIMER_MSEC_ON(master, up->t_join_timer,
on_join_timer,
up, interval_msec);
thread_add_timer_msec(master, on_join_timer, up, interval_msec,
&up->t_join_timer);
}
void pim_upstream_join_suppress(struct pim_upstream *up,
@ -1119,10 +1117,8 @@ pim_upstream_keep_alive_timer_start (struct pim_upstream *up,
zlog_debug ("kat start on %s with no stream reference", up->sg_str);
}
THREAD_OFF (up->t_ka_timer);
THREAD_TIMER_ON (master,
up->t_ka_timer,
pim_upstream_keep_alive_timer,
up, time);
thread_add_timer(master, pim_upstream_keep_alive_timer, up, time,
&up->t_ka_timer);
/* any time keepalive is started against a SG we will have to
* re-evaluate our active source database */
@ -1146,8 +1142,8 @@ void
pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
{
THREAD_OFF(up->t_msdp_reg_timer);
THREAD_TIMER_ON(master, up->t_msdp_reg_timer,
pim_upstream_msdp_reg_timer, up, PIM_MSDP_REG_RXED_PERIOD);
thread_add_timer(master, pim_upstream_msdp_reg_timer, up,
PIM_MSDP_REG_RXED_PERIOD, &up->t_msdp_reg_timer);
pim_msdp_sa_local_update(up);
}
@ -1408,9 +1404,8 @@ pim_upstream_start_register_stop_timer (struct pim_upstream *up, int null_regist
zlog_debug ("%s: (S,G)=%s Starting upstream register stop timer %d",
__PRETTY_FUNCTION__, up->sg_str, time);
}
THREAD_TIMER_ON (master, up->t_rs_timer,
pim_upstream_register_stop_timer,
up, time);
thread_add_timer(master, pim_upstream_register_stop_timer, up, time,
&up->t_rs_timer);
}
int

6
pimd/pim_zebra.c
View File

@ -617,9 +617,9 @@ void sched_rpf_cache_refresh(void)
qpim_rpf_cache_refresh_delay_msec);
}
THREAD_TIMER_MSEC_ON(master, qpim_rpf_cache_refresher,
on_rpf_cache_refresh,
0, qpim_rpf_cache_refresh_delay_msec);
thread_add_timer_msec(master, on_rpf_cache_refresh, 0,
qpim_rpf_cache_refresh_delay_msec,
&qpim_rpf_cache_refresher);
}
static void

10
pimd/pim_zlookup.c
View File

@ -77,9 +77,8 @@ static void zclient_lookup_sched(struct zclient *zlookup, int delay)
{
zassert(!zlookup->t_connect);
THREAD_TIMER_ON(master, zlookup->t_connect,
zclient_lookup_connect,
zlookup, delay);
thread_add_timer(master, zclient_lookup_connect, zlookup, delay,
&zlookup->t_connect);
zlog_notice("%s: zclient lookup connection scheduled for %d seconds",
__PRETTY_FUNCTION__, delay);
@ -89,9 +88,8 @@ static void zclient_lookup_sched(struct zclient *zlookup, int delay)
static void zclient_lookup_sched_now(struct zclient *zlookup)
{
zassert(!zlookup->t_connect);
zlookup->t_connect = thread_add_event(master, zclient_lookup_connect,
zlookup, 0);
thread_add_event(master, zclient_lookup_connect, zlookup, 0,
&zlookup->t_connect);
zlog_notice("%s: zclient lookup immediate connection scheduled",
__PRETTY_FUNCTION__);

5
ripd/rip_interface.c
View File

@ -1011,9 +1011,8 @@ rip_enable_apply (struct interface *ifp)
zlog_debug ("turn on %s", ifp->name);
/* Add interface wake up thread. */
if (! ri->t_wakeup)
ri->t_wakeup = thread_add_timer (master, rip_interface_wakeup,
ifp, 1);
thread_add_timer(master, rip_interface_wakeup, ifp, 1,
&ri->t_wakeup);
rip_connect_set (ifp, 1);
}
}

5
ripd/rip_peer.c
View File

@ -107,8 +107,9 @@ rip_peer_get (struct in_addr *addr)
}
/* Update timeout thread. */
peer->t_timeout = thread_add_timer (master, rip_peer_timeout, peer,
RIP_PEER_TIMER_DEFAULT);
peer->t_timeout = NULL;
thread_add_timer(master, rip_peer_timeout, peer, RIP_PEER_TIMER_DEFAULT,
&peer->t_timeout);
/* Last update time set. */
time (&peer->uptime);

20
ripd/ripd.c
View File

@ -2625,8 +2625,9 @@ rip_triggered_update (struct thread *t)
update is triggered when the timer expires. */
interval = (random () % 5) + 1;
rip->t_triggered_interval =
thread_add_timer (master, rip_triggered_interval, NULL, interval);
rip->t_triggered_interval = NULL;
thread_add_timer(master, rip_triggered_interval, NULL, interval,
&rip->t_triggered_interval);
return 0;
}
@ -2781,21 +2782,20 @@ rip_event (enum rip_event event, int sock)
switch (event)
{
case RIP_READ:
rip->t_read = thread_add_read (master, rip_read, NULL, sock);
rip->t_read = NULL;
thread_add_read(master, rip_read, NULL, sock, &rip->t_read);
break;
case RIP_UPDATE_EVENT:
RIP_TIMER_OFF (rip->t_update);
jitter = rip_update_jitter (rip->update_time);
rip->t_update =
thread_add_timer (master, rip_update, NULL,
sock ? 2 : rip->update_time + jitter);
thread_add_timer(master, rip_update, NULL, sock ? 2 : rip->update_time + jitter,
&rip->t_update);
break;
case RIP_TRIGGERED_UPDATE:
if (rip->t_triggered_interval)
rip->trigger = 1;
else if (! rip->t_triggered_update)
rip->t_triggered_update =
thread_add_event (master, rip_triggered_update, NULL, 0);
rip->trigger = 1;
else thread_add_event(master, rip_triggered_update, NULL, 0,
&rip->t_triggered_update);
break;
default:
break;

6
ripd/ripd.h
View File

@ -371,11 +371,7 @@ enum rip_event
};
/* Macro for timer turn on. */
#define RIP_TIMER_ON(T,F,V) \
do { \
if (!(T)) \
(T) = thread_add_timer (master, (F), rinfo, (V)); \
} while (0)
#define RIP_TIMER_ON(T,F,V) thread_add_timer (master, (F), rinfo, (V), &(T))
/* Macro for timer turn off. */
#define RIP_TIMER_OFF(X) THREAD_TIMER_OFF(X)

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