Import of the watch repository from Pebble

src/fw/kernel/task_timer.c

@@ -0,0 +1,368 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "task_timer.h"
+#include "task_timer_manager.h"
+
+#include "kernel/pebble_tasks.h"
+#include "kernel/pbl_malloc.h"
+#include "os/mutex.h"
+#include "os/tick.h"
+#include "system/logging.h"
+#include "system/passert.h"
+#include "util/list.h"
+
+#include "FreeRTOS.h"
+#include "queue.h"
+#include "semphr.h"
+
+
+// Structure of a timer
+typedef struct TaskTimer {
+  //! Entry into either the running timers (manager->running_timers) list or the idle timers
+  //! (manager->idle_timers)
+  ListNode list_node;
+
+  //! The tick value when this timer will expire (in ticks). If the timer isn't currently
+  //! running (scheduled) this value will be zero.
+  RtcTicks expire_time;
+
+  RtcTicks period_ticks;
+
+  TaskTimerID id;            //<! ID assigned to this timer
+
+  //! client provided callback function and argument
+  TaskTimerCallback cb;
+  void* cb_data;
+
+  //! True if this timer should automatically be rescheduled for period_time ticks from now
+  bool repeating:1;
+
+  //! True if this timer is currently having its callback executed.
+  bool executing:1;
+
+  //! Set by the delete function of client tries to delete a timer currently executing its
+  //! callback
+  bool defer_delete:1;
+} TaskTimer;
+
+// ------------------------------------------------------------------------------------
+// Comparator function for list_sorted_add
+// Returns the order in which (a, b) occurs
+// returns negative int for a descending value (a > b), positive for an ascending value (b > a),
+// 0 for equal
+static int prv_timer_expire_compare_func(void* a, void* b) {
+  if (((TaskTimer*)b)->expire_time < ((TaskTimer*)a)->expire_time) {
+    return -1;
+  } else if (((TaskTimer*)b)->expire_time > ((TaskTimer*)a)->expire_time) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+
+// ------------------------------------------------------------------------------------
+// Find timer by id
+static bool prv_id_list_filter(ListNode* node, void* data) {
+  TaskTimer* timer = (TaskTimer*)node;
+  return timer->id == (uint32_t) data;
+}
+
+static TaskTimer* prv_find_timer(TaskTimerManager *manager, TaskTimerID timer_id) {
+  PBL_ASSERTN(timer_id != TASK_TIMER_INVALID_ID);
+  // Look for this timer in either the running or idle list
+  ListNode* node = list_find(manager->running_timers, prv_id_list_filter, (void*)timer_id);
+  if (!node) {
+    node = list_find(manager->idle_timers, prv_id_list_filter, (void*)timer_id);
+  }
+  PBL_ASSERTN(node);
+  return (TaskTimer *)node;
+}
+
+
+// =======================================================================================
+// Client-side Implementation
+
+// ---------------------------------------------------------------------------------------
+// Create a new timer
+TaskTimerID task_timer_create(TaskTimerManager *manager) {
+  TaskTimer *timer = kernel_malloc(sizeof(TaskTimer));
+  if (!timer) {
+    return TASK_TIMER_INVALID_ID;
+  }
+
+  // Grab lock on timer structures, create a unique ID for this timer and put it into our idle
+  // timers list
+  mutex_lock(manager->mutex);
+  *timer = (TaskTimer) {
+    .id = manager->next_id++,
+  };
+
+  // We don't expect to wrap around, this would take over 100 years if we allocated a timer every
+  // second
+  PBL_ASSERTN(timer->id != TASK_TIMER_INVALID_ID);
+
+  manager->idle_timers = list_insert_before(manager->idle_timers, &timer->list_node);
+  mutex_unlock(manager->mutex);
+
+  return timer->id;
+}
+
+
+// --------------------------------------------------------------------------------
+// Schedule a timer to run.
+bool task_timer_start(TaskTimerManager *manager, TaskTimerID timer_id,
+                      uint32_t timeout_ms, TaskTimerCallback cb, void *cb_data, uint32_t flags) {
+  TickType_t timeout_ticks = milliseconds_to_ticks(timeout_ms);
+  RtcTicks current_time = rtc_get_ticks();
+
+  // Grab lock on timer structures
+  mutex_lock(manager->mutex);
+
+  // Find this timer
+  TaskTimer* timer = prv_find_timer(manager, timer_id);
+  PBL_ASSERTN(!timer->defer_delete);
+
+  // If this timer is currently executing it's callback, return false if
+  // TIMER_START_FLAG_FAIL_IF_EXECUTING is on
+  if (timer->executing && (flags & TIMER_START_FLAG_FAIL_IF_EXECUTING)) {
+    mutex_unlock(manager->mutex);
+    return false;
+  }
+
+  // If the TIMER_START_FLAG_FAIL_IF_SCHEDULED flag is on, make sure timer is not already scheduled
+  if ((flags & TIMER_START_FLAG_FAIL_IF_SCHEDULED) && timer->expire_time) {
+    mutex_unlock(manager->mutex);
+    return false;
+  }
+
+  // Remove it from its current list
+  if (timer->expire_time) {
+    PBL_ASSERTN(list_contains(manager->running_timers, &timer->list_node));
+    list_remove(&timer->list_node, &manager->running_timers /* &head */, NULL /* &tail */);
+  } else {
+    PBL_ASSERTN(list_contains(manager->idle_timers, &timer->list_node));
+    list_remove(&timer->list_node, &manager->idle_timers /* &head */, NULL /* &tail */);
+  }
+
+  // Set timer variables
+  timer->cb = cb;
+  timer->cb_data = cb_data;
+  timer->expire_time = current_time + timeout_ticks;
+  timer->repeating = flags & TIMER_START_FLAG_REPEATING;
+  timer->period_ticks = timeout_ticks;
+
+  // Insert into sorted order in the running list
+  manager->running_timers = list_sorted_add(manager->running_timers, &timer->list_node,
+                                            prv_timer_expire_compare_func, true);
+
+  // Wake up our service task if this is the new head so that it can recompute its wait timeout
+  if (manager->running_timers == &timer->list_node) {
+    xSemaphoreGive(manager->semaphore);
+  }
+  mutex_unlock(manager->mutex);
+  return true;
+}
+
+
+// --------------------------------------------------------------------------------
+// Return scheduled status
+bool task_timer_scheduled(TaskTimerManager *manager, TaskTimerID timer_id, uint32_t *expire_ms_p) {
+  mutex_lock(manager->mutex);
+
+  // Find this timer in our list
+  TaskTimer* timer = prv_find_timer(manager, timer_id);
+  PBL_ASSERTN(!timer->defer_delete);
+
+  // If expire timer is not 0, it means we are scheduled
+  bool retval = (timer->expire_time != 0);
+
+  // Figure out expire timer?
+  if (expire_ms_p != NULL && retval) {
+    RtcTicks current_ticks = rtc_get_ticks();
+    if (timer->expire_time > current_ticks) {
+      *expire_ms_p = ((timer->expire_time - current_ticks) * 1000)  / configTICK_RATE_HZ;
+    } else {
+      *expire_ms_p = 0;
+    }
+  }
+
+  mutex_unlock(manager->mutex);
+  return retval;
+}
+
+
+// --------------------------------------------------------------------------------
+// Stop a timer. If the timer callback is currently executing, return false, else return true.
+bool task_timer_stop(TaskTimerManager *manager, TaskTimerID timer_id) {
+  mutex_lock(manager->mutex);
+
+  // Find this timer in our list
+  TaskTimer* timer = prv_find_timer(manager, timer_id);
+  PBL_ASSERTN(!timer->defer_delete);
+
+  // Move it to the idle list if it's currently running
+  if (timer->expire_time) {
+    PBL_ASSERTN(list_contains(manager->running_timers, &timer->list_node));
+    list_remove(&timer->list_node, &manager->running_timers /* &head */, NULL /* &tail */);
+    manager->idle_timers = list_insert_before(manager->idle_timers, &timer->list_node);
+  }
+
+  // Clear the repeating flag so that if they call this method from a callback it won't get
+  // rescheduled.
+  timer->repeating = false;
+  timer->expire_time = 0;
+
+  mutex_unlock(manager->mutex);
+  return (!timer->executing);
+}
+
+
+// --------------------------------------------------------------------------------
+// Delete a timer
+void task_timer_delete(TaskTimerManager *manager, TaskTimerID timer_id) {
+  mutex_lock(manager->mutex);
+
+  // Find this timer in our list
+  TaskTimer* timer = prv_find_timer(manager, timer_id);
+
+  // If it's already marked for deletion return
+  if (timer->defer_delete) {
+    mutex_unlock(manager->mutex);
+    return;
+  }
+
+  // Automatically stop it if it it's not stopped already
+  if (timer->expire_time) {
+    timer->expire_time = 0;
+    PBL_ASSERTN(list_contains(manager->running_timers, &timer->list_node));
+    list_remove(&timer->list_node, &manager->running_timers /* &head */, NULL /* &tail */);
+    manager->idle_timers = list_insert_before(manager->idle_timers, &timer->list_node);
+  }
+  timer->repeating = false; // In case it's currently executing, make sure we don't reschedule it
+
+  // If it's currently executing, defer the delete till after the callback returns. The next call
+  // to task_timer_manager_execute_expired_timers service loop will take care of this for us.
+  if (timer->executing) {
+    timer->defer_delete = true;
+    mutex_unlock(manager->mutex);
+  } else {
+    PBL_ASSERTN(list_contains(manager->idle_timers, &timer->list_node));
+    list_remove(&timer->list_node, &manager->idle_timers /* &head */, NULL /* &tail */);
+    mutex_unlock(manager->mutex);
+    kernel_free(timer);
+  }
+}
+
+
+void task_timer_manager_init(TaskTimerManager *manager, SemaphoreHandle_t semaphore) {
+  *manager = (TaskTimerManager) {
+    .mutex = mutex_create(),
+    // Initialize next id to be a number that's theoretically unique per-task
+    .next_id = (pebble_task_get_current() << 28) + 1,
+    .semaphore = semaphore
+  };
+
+  // The above shift assumes next_id is a 32-bit int and there are fewer than 16 tasks.
+  _Static_assert(sizeof(((TaskTimerManager*)0)->next_id) == 4, "next_id is not the right width");
+  _Static_assert(NumPebbleTask < 16, "Too many tasks");
+}
+
+
+TickType_t task_timer_manager_execute_expired_timers(TaskTimerManager *manager) {
+  while (1) {
+    TickType_t ticks_to_wait = 0;
+    RtcTicks next_expiry_time = 0;
+
+    // -------------------------------------------------------------------------------------
+    // If a timer is ready to run, set time_to_wait to 0 and put the timer into 'next_timer'.
+    // If no timer is ready yet, then ticks_to_wait will be > 0.
+    mutex_lock(manager->mutex);
+
+    TaskTimer *next_timer = (TaskTimer*) manager->running_timers;
+    if (next_timer != NULL) {
+      next_expiry_time = next_timer->expire_time;
+      RtcTicks current_time = rtc_get_ticks();
+
+      if (next_expiry_time <= current_time) {
+        // Found a timer that has expired! Move it from the running list to the idle talk and
+        // mark it as executing.
+        manager->running_timers = list_pop_head(manager->running_timers);
+        manager->idle_timers = list_insert_before(manager->idle_timers, &next_timer->list_node);
+
+        next_timer->executing = true;
+        next_timer->expire_time = 0;
+
+        // If we fell way behind (at least 1 timer period + 5 seconds) on a repeating timer
+        // (presumably because we were in the debugger) advance next_expiry_time so that we don't
+        // need to call this callback more than twice in a row in order to catch up.
+        if (next_timer->repeating
+            && (int64_t)next_expiry_time < (int64_t)(current_time - next_timer->period_ticks
+                                            - 5 * RTC_TICKS_HZ)) {
+          PBL_LOG(LOG_LEVEL_WARNING, "NT: Skipping some callbacks for %p because we fell behind",
+                  next_timer->cb);
+        }
+      } else {
+        // The next timer hasn't expired yet. Update
+        ticks_to_wait = next_expiry_time - current_time;
+      }
+    } else {
+      // No timers running
+      ticks_to_wait = portMAX_DELAY;
+    }
+
+    mutex_unlock(manager->mutex);
+
+    if (ticks_to_wait) {
+      return ticks_to_wait;
+    }
+
+    // Run the timer callback now
+    manager->current_cb = next_timer->cb_data;
+    next_timer->cb(next_timer->cb_data);
+    manager->current_cb = NULL;
+
+    // Update state after the callback
+    mutex_lock(manager->mutex);
+    next_timer->executing = false;
+
+    // Re-insert into timers list now if it's a repeating timer and wasn't re-scheduled by the
+    // callback (next_timer->expire_time != 0)
+    if (next_timer->repeating && !next_timer->expire_time) {
+      next_timer->expire_time = next_expiry_time + next_timer->period_ticks;
+      list_remove(&next_timer->list_node, &manager->idle_timers /* &head */, NULL /* &tail */);
+      manager->running_timers = list_sorted_add(manager->running_timers, &next_timer->list_node,
+                                                prv_timer_expire_compare_func, true);
+    }
+
+    // If it's been marked for deletion, take care of that now
+    if (next_timer->defer_delete) {
+      PBL_ASSERTN(list_contains(manager->idle_timers, &next_timer->list_node));
+      list_remove(&next_timer->list_node, &manager->idle_timers /* &head */, NULL /* &tail */);
+      mutex_unlock(manager->mutex);
+
+      kernel_free(next_timer);
+
+    } else {
+      mutex_unlock(manager->mutex);
+    }
+  }
+}
+
+void* task_timer_manager_get_current_cb(const TaskTimerManager *manager) {
+  return manager->current_cb;
+}