kernel: Allow late processing of timeouts

This change proposes to handle the case where the handle_timeouts
function is called after a number of ticks greater than the first
timeout delta of the _timeout_q list. In the current implementation if
the case occurs, after subtracting the number of ticks the
delta_ticks_from_prev field becomes negative and the first timeout is
never processed. It is therefore necessary to treat this case and to
prevent delta_ticks_from_prev from becoming negative. Moreover, the lag
produced by the initial delay must also be applied to following timeouts
by browsing the list until it was entirely consumed.

Fixes #5401

Signed-off-by: Holman Greenhand <[email protected]>

Author: Holman Greenhand

kernel/sys_clock.c

@@ -179,52 +179,75 @@ static inline void handle_timeouts(s32_t ticks)
 
 	key = irq_lock();
 
-	struct _timeout *head =
-		(struct _timeout *)sys_dlist_peek_head(&_timeout_q);
+	sys_dnode_t *next = sys_dlist_peek_head(&_timeout_q);
+	struct _timeout *timeout = (struct _timeout *)next;
 
 	K_DEBUG("head: %p, delta: %d\n",
-		head, head ? head->delta_ticks_from_prev : -2112);
+		timeout, timeout ? timeout->delta_ticks_from_prev : -2112);
 
-	if (!head) {
+	if (!next) {
 		irq_unlock(key);
 		return;
 	}
 
-	head->delta_ticks_from_prev -= ticks;
-
 	/*
 	 * Dequeue all expired timeouts from _timeout_q, relieving irq lock
 	 * pressure between each of them, allowing handling of higher priority
 	 * interrupts. We know that no new timeout will be prepended in front
 	 * of a timeout which delta is 0, since timeouts of 0 ticks are
 	 * prohibited.
 	 */
-	sys_dnode_t *next = &head->node;
-	struct _timeout *timeout = (struct _timeout *)next;
 
 	_handling_timeouts = 1;
 
-	while (timeout && timeout->delta_ticks_from_prev == 0) {
-
-		sys_dlist_remove(next);
+	while (next) {
 
 		/*
-		 * Reverse the order that that were queued in the timeout_q:
-		 * timeouts expiring on the same ticks are queued in the
-		 * reverse order, time-wise, that they are added to shorten the
-		 * amount of time with interrupts locked while walking the
-		 * timeout_q. By reversing the order _again_ when building the
-		 * expired queue, they end up being processed in the same order
-		 * they were added, time-wise.
+		 * In the case where ticks number is greater than the first
+		 * timeout delta of the list, the lag produced by this initial
+		 * difference must also be applied to others timeouts in list
+		 * until it was entirely consumed.
 		 */
-		sys_dlist_prepend(&expired, next);
 
-		timeout->delta_ticks_from_prev = _EXPIRED;
+		s32_t tmp = timeout->delta_ticks_from_prev;
+
+		if (timeout->delta_ticks_from_prev < ticks) {
+			timeout->delta_ticks_from_prev = 0;
+		} else {
+			timeout->delta_ticks_from_prev -= ticks;
+		}
+
+		ticks -= tmp;
+
+		next = sys_dlist_peek_next(&_timeout_q, next);
+
+		if (timeout->delta_ticks_from_prev == 0) {
+			sys_dnode_t *node = &timeout->node;
+
+			sys_dlist_remove(node);
+
+			/*
+			 * Reverse the order that that were queued in the
+			 * timeout_q: timeouts expiring on the same ticks are
+			 * queued in the reverse order, time-wise, that they are
+			 * added to shorten the amount of time with interrupts
+			 * locked while walking the timeout_q. By reversing the
+			 * order _again_ when building the expired queue, they
+			 * end up being processed in the same order they were
+			 * added, time-wise.
+			 */
+
+			sys_dlist_prepend(&expired, node);
+
+			timeout->delta_ticks_from_prev = _EXPIRED;
+
+		} else if (ticks <= 0) {
+			break;
+		}
 
 		irq_unlock(key);
 		key = irq_lock();
 
-		next = sys_dlist_peek_head(&_timeout_q);
 		timeout = (struct _timeout *)next;
 	}