New nested timer system that avoids constantly reallocating timer memory

Author: arr2036

src/bin/radiusd.c

@@ -168,32 +168,32 @@ do { \
 	goto cleanup; \
 } while (0)
 
-static fr_event_timer_t const *fr_time_sync_ev = NULL;
+static fr_timer_t *fr_time_sync_ev = NULL;
 
-static void fr_time_sync_event(fr_event_list_t *el, UNUSED fr_time_t now, UNUSED void *uctx)
+static void fr_time_sync_event(fr_timer_list_t *tl, UNUSED fr_time_t now, UNUSED void *uctx)
 {
 	fr_time_delta_t when = fr_time_delta_from_sec(1);
 
-	(void) fr_event_timer_in(el, el, &fr_time_sync_ev, when, fr_time_sync_event, NULL);
+	(void) fr_timer_in(tl, tl, &fr_time_sync_ev, when, false, fr_time_sync_event, NULL);
 	(void) fr_time_sync();
 }
 
 #ifndef NDEBUG
 /** Encourage the server to exit after a period of time
  *
- * @param[in] el	The main loop.
+ * @param[in] tl	The main loop.
  * @param[in] now	Current time.  Should be 0, when adding the event.
  * @param[in] uctx	Pointer to a fr_time_delta_t indicating how long
  *			the server should run before exit.
  */
-static void fr_exit_after(fr_event_list_t *el, fr_time_t now, void *uctx)
+static void fr_exit_after(fr_timer_list_t *tl, fr_time_t now, void *uctx)
 {
-	static fr_event_timer_t const *ev;
+	static fr_timer_t *ev;
 
 	fr_time_delta_t	exit_after = *(fr_time_delta_t *)uctx;
 
 	if (fr_time_eq(now, fr_time_wrap(0))) {
-		if (fr_event_timer_in(el, el, &ev, exit_after, fr_exit_after, uctx) < 0) {
+		if (fr_timer_in(tl, tl, &ev, exit_after, false, fr_exit_after, uctx) < 0) {
 			PERROR("%s: Failed inserting exit event", program);
 		}
 		return;
@@ -978,9 +978,9 @@ int main(int argc, char *argv[])
 		DEBUG("Global memory protected");
 	}
 
-	fr_time_sync_event(main_loop_event_list(), fr_time(), NULL);
+	fr_time_sync_event(main_loop_event_list()->tl, fr_time(), NULL);
 #ifndef NDEBUG
-	if (fr_time_delta_ispos(exit_after)) fr_exit_after(main_loop_event_list(), fr_time_wrap(0), &exit_after);
+	if (fr_time_delta_ispos(exit_after)) fr_exit_after(main_loop_event_list()->tl, fr_time_wrap(0), &exit_after);
 #endif
 	/*
 	 *  Process requests until HUP or exit.

src/bin/radsniff.c

@@ -841,7 +841,7 @@ static void rs_stats_print_csv(rs_update_t *this, rs_stats_t *stats, UNUSED stru
 /** Process stats for a single interval
  *
  */
-static void rs_stats_process(fr_event_list_t *el, fr_time_t now_t, void *ctx)
+static void rs_stats_process(fr_timer_list_t *tl, fr_time_t now_t, void *ctx)
 {
 	size_t		i;
 	size_t		rs_codes_len = (NUM_ELEMENTS(rs_useful_codes));
@@ -903,13 +903,14 @@ static void rs_stats_process(fr_event_list_t *el, fr_time_t now_t, void *ctx)
 	}
 
 	{
-		static fr_event_timer_t const *event;
+		static fr_timer_t *event;
 
 		now.tv_sec += conf->stats.interval;
 		now.tv_usec = 0;
 
-		if (fr_event_timer_at(NULL, el, &event,
-				      fr_time_from_timeval(&now), rs_stats_process, ctx) < 0) {
+		if (fr_timer_at(NULL, tl, &event,
+				fr_time_from_timeval(&now),
+				false, rs_stats_process, ctx) < 0) {
 			ERROR("Failed inserting stats interval event");
 		}
 	}
@@ -939,7 +940,7 @@ static void rs_stats_update_latency(rs_latency_t *stats, struct timeval *latency
 static int rs_install_stats_processor(rs_stats_t *stats, fr_event_list_t *el,
 				      fr_pcap_t *in, struct timeval *now, bool live)
 {
-	static fr_event_timer_t	const *event;
+	static fr_timer_t	const *event;
 	static rs_update_t	update;
 
 	memset(&update, 0, sizeof(update));
@@ -978,8 +979,9 @@ static int rs_install_stats_processor(rs_stats_t *stats, fr_event_list_t *el,
 		rs_tv_add_ms(now, conf->stats.timeout, &(stats->quiet));
 	}
 
-	if (fr_event_timer_at(NULL, events, (void *) &event,
-			      fr_time_from_timeval(now), rs_stats_process, &update) < 0) {
+	if (fr_timer_at(NULL, events->tl, (void *) &event,
+			fr_time_from_timeval(now),
+			false, rs_stats_process, &update) < 0) {
 		ERROR("Failed inserting stats event");
 		return -1;
 	}
@@ -1044,7 +1046,7 @@ static int _request_free(rs_request_t *request)
 	}
 
 	if (request->event) {
-		ret = fr_event_timer_delete(&request->event);
+		ret = fr_timer_delete(&request->event);
 		if (ret < 0) {
 			fr_perror("Failed deleting timer");
 			RS_ASSERT(0 == 1);
@@ -1129,7 +1131,7 @@ static void rs_packet_cleanup(rs_request_t *request)
 	talloc_free(request);
 }
 
-static void _rs_event(UNUSED fr_event_list_t *el, UNUSED fr_time_t now, void *ctx)
+static void _rs_event(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *ctx)
 {
 	rs_request_t *request = talloc_get_type_abort(ctx, rs_request_t);
 
@@ -1528,7 +1530,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 				 */
 				fr_pair_list_free(&original->link_vps);
 				fr_packet_free(&original->linked);
-				fr_event_timer_delete(&original->event);
+				fr_timer_delete(&original->event);
 			/*
 			 *	...nope it's the first response to a request.
 			 */
@@ -1544,8 +1546,9 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 			original->linked = talloc_steal(original, packet);
 			fr_pair_list_append(&original->link_vps, &decoded);		/* Move the vps over */
 			rs_tv_add_ms(&header->ts, conf->stats.timeout, &original->when);
-			if (fr_event_timer_at(NULL, event->list, &original->event,
-					      fr_time_from_timeval(&original->when), _rs_event, original) < 0) {
+			if (fr_timer_at(NULL, event->list->tl, &original->event,
+					fr_time_from_timeval(&original->when),
+					false, _rs_event, original) < 0) {
 				REDEBUG("Failed inserting new event");
 				/*
 				 *	Delete the original request/event, it's no longer valid
@@ -1752,7 +1755,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 			fr_pair_list_append(&original->expect_vps, &search.expect_vps);
 
 			/* Disarm the timer for the cleanup event for the original request */
-			fr_event_timer_delete(&original->event);
+			fr_timer_delete(&original->event);
 		/*
 		 *	...nope it's a new request.
 		 */
@@ -1813,8 +1816,9 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 		 */
 		original->packet->timestamp = fr_time_from_timeval(&header->ts);
 		rs_tv_add_ms(&header->ts, conf->stats.timeout, &original->when);
-		if (fr_event_timer_at(NULL, event->list, &original->event,
-				      fr_time_from_timeval(&original->when), _rs_event, original) < 0) {
+		if (fr_timer_at(NULL, event->list->tl, &original->event,
+				fr_time_from_timeval(&original->when),
+				false, _rs_event, original) < 0) {
 			REDEBUG("Failed inserting new event");
 
 			talloc_free(original);
@@ -1986,9 +1990,7 @@ static void rs_got_packet(fr_event_list_t *el, int fd, UNUSED int flags, void *c
 				stats_started = true;
 			}
 
-			do {
-				now = fr_time_from_timeval(&header->ts);
-			} while (fr_event_timer_run(el, &now) == 1);
+			fr_timer_list_run(el->tl, &now);
 			count++;
 
 			rs_packet_process(count, event, header, data);
@@ -2172,19 +2174,19 @@ static void _unmark_link(void *request)
 /** Exit the event loop after a given timeout.
  *
  */
-static void timeout_event(fr_event_list_t *el, UNUSED fr_time_t now_t, UNUSED void *ctx)
+static void timeout_event(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now_t, void *ctx)
 {
-	fr_event_loop_exit(el, 1);
+	fr_event_loop_exit(talloc_get_type_abort(ctx, fr_event_list_t), 1);
 }
 
 
 #ifdef HAVE_COLLECTDC_H
 /** Re-open the collectd socket
  *
  */
-static void rs_collectd_reopen(fr_event_list_t *el, fr_time_t now, UNUSED void *ctx)
+static void rs_collectd_reopen(fr_timer_list_t *tl, fr_time_t now, UNUSED void *ctx)
 {
-	static fr_event_timer_t const *event;
+	static fr_timer_t *event;
 
 	if (rs_stats_collectd_open(conf) == 0) {
 		DEBUG2("Stats output socket (re)opened");
@@ -2193,9 +2195,9 @@ static void rs_collectd_reopen(fr_event_list_t *el, fr_time_t now, UNUSED void *
 
 	ERROR("Will attempt to re-establish connection in %i ms", RS_SOCKET_REOPEN_DELAY);
 
-	if (fr_event_timer_at(NULL, el, &event,
-			      fr_time_add(now, fr_time_delta_from_msec(RS_SOCKET_REOPEN_DELAY)),
-			      rs_collectd_reopen, el) < 0) {
+	if (fr_timer_at(NULL, tl, &event,
+		        fr_time_add(now, fr_time_delta_from_msec(RS_SOCKET_REOPEN_DELAY)),
+		        false, rs_collectd_reopen, NULL) < 0) {
 		ERROR("Failed inserting re-open event");
 		RS_ASSERT(0);
 	}
@@ -2328,7 +2330,7 @@ int main(int argc, char *argv[])
 
 	int			c;
 	unsigned int		timeout = 0;
-	fr_event_timer_t const	*timeout_ev = NULL;
+	fr_timer_t		*timeout_ev = NULL;
 	char const		*raddb_dir = RADDBDIR;
 	char const		*dict_dir = DICTDIR;
 	TALLOC_CTX		*autofree;
@@ -3112,8 +3114,8 @@ int main(int argc, char *argv[])
 		}
 
 		if (timeout) {
-			if (fr_event_timer_in(NULL, events, &timeout_ev, fr_time_delta_from_sec(timeout),
-					      timeout_event, NULL) < 0) {
+			if (fr_timer_in(NULL, events->tl, &timeout_ev, fr_time_delta_from_sec(timeout),
+					false, timeout_event, events) < 0) {
 				ERROR("Failed inserting timeout event");
 			}
 		}

src/bin/radsniff.h

@@ -183,18 +183,18 @@ typedef struct {
  */
 typedef struct {
 	uint64_t		id;			//!< Monotonically increasing packet counter.
-	fr_event_timer_t const	*event;			//!< Event created when we received the original request.
+	fr_timer_t		*event;			//!< Event created when we received the original request.
 
 	bool			logged;			//!< Whether any messages regarding this request were logged.
 
 	struct timeval		when;			//!< Time when the packet was received, or next time an event
 							//!< is scheduled.
 	fr_pcap_t		*in;			//!< PCAP handle the original request was received on.
-	fr_packet_t	*packet;		//!< The original packet.
+	fr_packet_t		*packet;		//!< The original packet.
 	fr_pair_list_t		packet_vps;
-	fr_packet_t	*expect;		//!< Request/response.
+	fr_packet_t		*expect;		//!< Request/response.
 	fr_pair_list_t		expect_vps;
-	fr_packet_t	*linked;		//!< The subsequent response or forwarded request the packet
+	fr_packet_t		*linked;		//!< The subsequent response or forwarded request the packet
 							//!< was linked against.
 	fr_pair_list_t		link_vps;		//!< fr_pair_ts used to link retransmissions.
 

src/bin/unit_test_module.c

@@ -626,7 +626,7 @@ static request_t *request_clone(request_t *old, int number, CONF_SECTION *server
 	return request;
 }
 
-static void cancel_request(UNUSED fr_event_list_t *el, UNUSED fr_time_t when, void *uctx)
+static void cancel_request(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t when, void *uctx)
 {
 	request_t	*request = talloc_get_type_abort(uctx, request_t);
 	unlang_interpret_signal(request, FR_SIGNAL_CANCEL);
@@ -651,7 +651,7 @@ int main(int argc, char *argv[])
 	fr_pair_list_t		filter_vps;
 	bool			xlat_only = false;
 	fr_event_list_t		*el = NULL;
-	fr_event_timer_t const	*cancel_timer = NULL;
+	fr_timer_t		*cancel_timer = NULL;
 	fr_client_t		*client = NULL;
 	fr_dict_t		*dict = NULL;
 	fr_dict_t const		*dict_check;
@@ -1072,7 +1072,7 @@ int main(int argc, char *argv[])
 	}
 
 	if (count == 1) {
-		fr_event_timer_in(request, el, &cancel_timer, config->max_request_time, cancel_request, request);
+		fr_timer_in(request, el->tl, &cancel_timer, config->max_request_time, false, cancel_request, request);
 		unlang_interpret_synchronous(el, request);
 
 	} else {
@@ -1105,7 +1105,7 @@ int main(int argc, char *argv[])
 			}
 #endif
 
-			fr_event_timer_in(request, el, &cancel_timer, config->max_request_time, cancel_request, request);
+			fr_timer_in(request, el->tl, &cancel_timer, config->max_request_time, false, cancel_request, request);
 			unlang_interpret_synchronous(el, request);
 			talloc_free(request);
 

src/lib/bio/dedup.c

@@ -128,7 +128,7 @@ struct fr_bio_dedup_s {
 
 	fr_bio_dedup_config_t	config;
 
-	fr_event_timer_t const	*ev;
+	fr_timer_t		*ev;
 
 	/*
 	 *	The "first" entry is cached here so that we can detect when it changes.  The insert / delete
@@ -159,7 +159,7 @@ struct fr_bio_dedup_s {
 	FR_DLIST_HEAD(fr_bio_dedup_list) free;	//!< free list
 };
 
-static void fr_bio_dedup_timer(UNUSED fr_event_list_t *el, fr_time_t now, void *uctx);
+static void fr_bio_dedup_timer(UNUSED fr_timer_list_t *el, fr_time_t now, void *uctx);
 static ssize_t fr_bio_dedup_write(fr_bio_t *bio, void *packet_ctx, void const *buffer, size_t size);
 static ssize_t fr_bio_dedup_blocked(fr_bio_dedup_t *my, fr_bio_dedup_entry_t *item, ssize_t rcode);
 static void fr_bio_dedup_release(fr_bio_dedup_t *my, fr_bio_dedup_entry_t *item, fr_bio_dedup_release_reason_t reason);
@@ -226,7 +226,7 @@ ssize_t fr_bio_dedup_respond(fr_bio_t *bio, fr_bio_dedup_entry_t *item)
 	case FR_BIO_DEDUP_STATE_ACTIVE:
 		/*
 		 *	If we're not writing to the socket, just insert the packet into the pending list.
-		 */	
+		 */
 		if (my->bio.write != fr_bio_dedup_write) {
 			(void) fr_bio_dedup_list_remove(&my->active, item);
 			fr_bio_dedup_list_insert_tail(&my->pending, item);
@@ -364,7 +364,7 @@ static int fr_bio_dedup_timer_reset(fr_bio_dedup_t *my)
 	/*
 	 *	Update the timer.  This should never fail.
 	 */
-	if (fr_event_timer_at(my, my->el, &my->ev, first->expires, fr_bio_dedup_timer, my) < 0) return -1;
+	if (fr_timer_at(my, my->el->tl, &my->ev, first->expires, false, fr_bio_dedup_timer, my) < 0) return -1;
 
 	my->first = first;
 	return 0;
@@ -761,7 +761,7 @@ static ssize_t fr_bio_dedup_blocked_data(fr_bio_dedup_t *my, uint8_t const *buff
  *
  *  @todo - expire items from the pending list, too
  */
-static void fr_bio_dedup_timer(UNUSED fr_event_list_t *el, fr_time_t now, void *uctx)
+static void fr_bio_dedup_timer(UNUSED fr_timer_list_t *tl, fr_time_t now, void *uctx)
 {
 	fr_bio_dedup_t *my = talloc_get_type_abort(uctx, fr_bio_dedup_t);
 	fr_bio_dedup_entry_t *item;
@@ -811,7 +811,7 @@ static ssize_t fr_bio_dedup_write(fr_bio_t *bio, void *packet_ctx, void const *b
 	 */
 	next = fr_bio_next(&my->bio);
 	fr_assert(next != NULL);
-	
+
 	/*
 	 *	The caller is trying to flush partial data.  But we don't have any partial data, so just call
 	 *	the next bio to flush it.

src/lib/bio/fd.c

@@ -1222,7 +1222,7 @@ static void fr_bio_fd_el_connect(NDEBUG_UNUSED fr_event_list_t *el, NDEBUG_UNUSE
 /**  We have a timeout on the conenction
  *
  */
-static void fr_bio_fd_el_timeout(UNUSED fr_event_list_t *el, UNUSED fr_time_t now, void *uctx)
+static void fr_bio_fd_el_timeout(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *uctx)
 {
 	fr_bio_fd_t *my = talloc_get_type_abort(uctx, fr_bio_fd_t);
 
@@ -1327,7 +1327,7 @@ int fr_bio_fd_connect_full(fr_bio_t *bio, fr_event_list_t *el, fr_bio_callback_t
 	 *	Set the timeout callback if asked.
 	 */
 	if (timeout_cb) {
-		if (fr_event_timer_in(my, el, &my->connect.ev, *timeout, fr_bio_fd_el_timeout, my) < 0) {
+		if (fr_timer_in(my, el->tl, &my->connect.ev, *timeout, false, fr_bio_fd_el_timeout, my) < 0) {
 			goto error;
 		}
 	}

src/lib/bio/fd_open.c

@@ -754,7 +754,7 @@ static int fr_bio_fd_socket_bind(fr_bio_fd_t *my, fr_bio_fd_config_t const *cfg)
 		 *	We've picked a random port in what is hopefully a large range.  If that works, we're
 		 *	done.
 		 */
-		if (bind(my->info.socket.fd, (struct sockaddr *) &salocal, salen) >= 0) goto done;
+		if (bind(my->info.socket.fd, (struct sockaddr *) &salocal, salen) == 0) goto done;
 
 		/*
 		 *	Hunt & peck.  Which is horrible.
@@ -774,10 +774,14 @@ static int fr_bio_fd_socket_bind(fr_bio_fd_t *my, fr_bio_fd_config_t const *cfg)
 
 			sin->sin_port = htons(my->info.cfg->src_port_start + current);
 
-			if (bind(my->info.socket.fd, (struct sockaddr *) &salocal, salen) >= 0) goto done;
+			if (bind(my->info.socket.fd, (struct sockaddr *) &salocal, salen) == 0) goto done;
 		}
 
-		fr_strerror_const("There are no open ports between 'src_port_start' and 'src_port_end'");
+		/*
+		 *	The error is a good hint at _why_ we failed to bind.
+		 *	We expect errno to be EADDRINUSE, anything else is a surprise.
+		 */
+		fr_strerror_printf("Failed binding port between 'src_port_start' and 'src_port_end': %s", fr_syserror(errno));
 		return -1;
 	}