Changes in kernel/generic/src/time/timeout.c [583c2a3:4760793] 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.
  *
@@ -57 +58 @@
 }
 
-/** 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
  *
@@ -82 +67 @@
 void timeout_initialize(timeout_t *timeout)
 {
-        irq_spinlock_initialize(&timeout->lock, "timeout_t_lock");
-        timeout_reinitialize(timeout);
+        link_initialize(&timeout->link);
+        timeout->cpu = NULL;
+}
+
+/* Only call when interrupts are disabled. */
+deadline_t timeout_deadline_in_usec(uint32_t usec)
+{
+        if (usec == 0)
+                return 0;
+
+        return CPU_LOCAL->current_clock_tick + us2ticks(usec);
+}
+
+static void timeout_register_deadline_locked(timeout_t *timeout, deadline_t deadline,
+    timeout_handler_t handler, void *arg)
+{
+        assert(!link_in_use(&timeout->link));
+
+        *timeout = (timeout_t) {
+                .cpu = CPU,
+                .deadline = deadline,
+                .handler = handler,
+                .arg = arg,
+                .finished = ATOMIC_VAR_INIT(false),
+        };
+
+        /* 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;
+                        }
+                }
+        }
 }
 
@@ -102 +126 @@
 {
         irq_spinlock_lock(&CPU->timeoutlock, true);
-        irq_spinlock_lock(&timeout->lock, false);
+        timeout_register_deadline_locked(timeout, timeout_deadline_in_usec(time), handler, arg);
+        irq_spinlock_unlock(&CPU->timeoutlock, true);
+}
 
-        if (timeout->cpu)
-                panic("Unexpected: timeout->cpu != 0.");
-
-        timeout->cpu = CPU;
-        timeout->ticks = us2ticks(time);
-
-        timeout->handler = handler;
-        timeout->arg = arg;
-
-        /*
-         * 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);
+void timeout_register_deadline(timeout_t *timeout, deadline_t deadline,
+    timeout_handler_t handler, void *arg)
+{
+        irq_spinlock_lock(&CPU->timeoutlock, true);
+        timeout_register_deadline_locked(timeout, deadline, handler, arg);
         irq_spinlock_unlock(&CPU->timeoutlock, true);
 }
@@ -170 +149 @@
 bool timeout_unregister(timeout_t *timeout)
 {
-        DEADLOCK_PROBE_INIT(p_tolock);
+        if (atomic_load_explicit(&timeout->finished, memory_order_acquire))
+                /* The timeout fired and finished already, no need to check the list. */
+                return false;
 
-grab_locks:
-        irq_spinlock_lock(&timeout->lock, true);
-        if (!timeout->cpu) {
-                irq_spinlock_unlock(&timeout->lock, true);
-                return false;
+        assert(timeout->cpu);
+
+        irq_spinlock_lock(&timeout->cpu->timeoutlock, true);
+
+        bool success = link_in_use(&timeout->link);
+        if (success) {
+                list_remove(&timeout->link);
         }
 
-        if (!irq_spinlock_trylock(&timeout->cpu->timeoutlock)) {
-                irq_spinlock_unlock(&timeout->lock, true);
-                DEADLOCK_PROBE(p_tolock, DEADLOCK_THRESHOLD);
-                goto grab_locks;
+        irq_spinlock_unlock(&timeout->cpu->timeoutlock, true);
+
+        if (!success) {
+                /* Timeout was fired, we need to wait for the callback to finish. */
+                while (!atomic_load_explicit(&timeout->finished, memory_order_acquire))
+                        cpu_spin_hint();
         }
 
-        /*
-         * 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;
+        return success;
 }