Changes in kernel/generic/src/time/timeout.c [eda43238:583c2a3] in mainline

File:

• kernel/generic/src/time/timeout.c (modified) (5 diffs)

kernel/generic/src/time/timeout.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
- * Copyright (c) 2022 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -58 +57 @@
 }
 
+/** Reinitialize timeout
+ *
+ * Initialize all members except the lock.
+ *
+ * @param timeout Timeout to be initialized.
+ *
+ */
+void timeout_reinitialize(timeout_t *timeout)
+{
+        timeout->cpu = NULL;
+        timeout->ticks = 0;
+        timeout->handler = NULL;
+        timeout->arg = NULL;
+        link_initialize(&timeout->link);
+}
+
 /** Initialize timeout
  *
@@ -67 +82 @@
 void timeout_initialize(timeout_t *timeout)
 {
-        link_initialize(&timeout->link);
-        timeout->cpu = NULL;
+        irq_spinlock_initialize(&timeout->lock, "timeout_t_lock");
+        timeout_reinitialize(timeout);
 }
 
@@ -87 +102 @@
 {
         irq_spinlock_lock(&CPU->timeoutlock, true);
-
-        assert(!link_in_use(&timeout->link));
+        irq_spinlock_lock(&timeout->lock, false);
+
+        if (timeout->cpu)
+                panic("Unexpected: timeout->cpu != 0.");
 
         timeout->cpu = CPU;
-        timeout->deadline = CPU->current_clock_tick + us2ticks(time);
+        timeout->ticks = us2ticks(time);
+
         timeout->handler = handler;
         timeout->arg = arg;
 
-        /* Insert timeout into the active timeouts list according to timeout->deadline. */
-
-        link_t *last = list_last(&CPU->timeout_active_list);
-        if (last == NULL || timeout->deadline >= list_get_instance(last, timeout_t, link)->deadline) {
-                list_append(&timeout->link, &CPU->timeout_active_list);
-        } else {
-                for (link_t *cur = list_first(&CPU->timeout_active_list); cur != NULL;
-                    cur = list_next(cur, &CPU->timeout_active_list)) {
-
-                        if (timeout->deadline < list_get_instance(cur, timeout_t, link)->deadline) {
-                                list_insert_before(&timeout->link, cur);
-                                break;
-                        }
+        /*
+         * Insert timeout into the active timeouts list according to timeout->ticks.
+         */
+        uint64_t sum = 0;
+        timeout_t *target = NULL;
+        link_t *cur, *prev;
+        prev = NULL;
+        for (cur = list_first(&CPU->timeout_active_list);
+            cur != NULL; cur = list_next(cur, &CPU->timeout_active_list)) {
+                target = list_get_instance(cur, timeout_t, link);
+                irq_spinlock_lock(&target->lock, false);
+
+                if (timeout->ticks < sum + target->ticks) {
+                        irq_spinlock_unlock(&target->lock, false);
+                        break;
                 }
-        }
-
+
+                sum += target->ticks;
+                irq_spinlock_unlock(&target->lock, false);
+                prev = cur;
+        }
+
+        if (prev == NULL)
+                list_prepend(&timeout->link, &CPU->timeout_active_list);
+        else
+                list_insert_after(&timeout->link, prev);
+
+        /*
+         * Adjust timeout->ticks according to ticks
+         * accumulated in target's predecessors.
+         */
+        timeout->ticks -= sum;
+
+        /*
+         * Decrease ticks of timeout's immediate succesor by timeout->ticks.
+         */
+        if (cur != NULL) {
+                irq_spinlock_lock(&target->lock, false);
+                target->ticks -= timeout->ticks;
+                irq_spinlock_unlock(&target->lock, false);
+        }
+
+        irq_spinlock_unlock(&timeout->lock, false);
         irq_spinlock_unlock(&CPU->timeoutlock, true);
 }
@@ -125 +170 @@
 bool timeout_unregister(timeout_t *timeout)
 {
-        assert(timeout->cpu);
-
-        irq_spinlock_lock(&timeout->cpu->timeoutlock, true);
-
-        bool success = link_in_use(&timeout->link);
-        if (success) {
-                list_remove(&timeout->link);
-        }
-
-        irq_spinlock_unlock(&timeout->cpu->timeoutlock, true);
-        return success;
+        DEADLOCK_PROBE_INIT(p_tolock);
+
+grab_locks:
+        irq_spinlock_lock(&timeout->lock, true);
+        if (!timeout->cpu) {
+                irq_spinlock_unlock(&timeout->lock, true);
+                return false;
+        }
+
+        if (!irq_spinlock_trylock(&timeout->cpu->timeoutlock)) {
+                irq_spinlock_unlock(&timeout->lock, true);
+                DEADLOCK_PROBE(p_tolock, DEADLOCK_THRESHOLD);
+                goto grab_locks;
+        }
+
+        /*
+         * Now we know for sure that timeout hasn't been activated yet
+         * and is lurking in timeout->cpu->timeout_active_list.
+         */
+
+        link_t *cur = list_next(&timeout->link,
+            &timeout->cpu->timeout_active_list);
+        if (cur != NULL) {
+                timeout_t *tmp = list_get_instance(cur, timeout_t, link);
+                irq_spinlock_lock(&tmp->lock, false);
+                tmp->ticks += timeout->ticks;
+                irq_spinlock_unlock(&tmp->lock, false);
+        }
+
+        list_remove(&timeout->link);
+        irq_spinlock_unlock(&timeout->cpu->timeoutlock, false);
+
+        timeout_reinitialize(timeout);
+        irq_spinlock_unlock(&timeout->lock, true);
+
+        return true;
 }