From f8f9c38b2e2527c6e3b8396e06fbb18fc1ce2a1c Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 29 Apr 2025 08:49:19 -0400
Subject: [PATCH 01/20] add a task registry to tracing infrastructure

---
 embassy-executor/src/raw/mod.rs   |   2 +-
 embassy-executor/src/raw/trace.rs | 139 +++++++++++++++++++++++++++++-
 embassy-executor/src/spawner.rs   |  27 ++++++
 3 files changed, 166 insertions(+), 2 deletions(-)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 88d839e07..35c82557c 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -18,7 +18,7 @@ mod state;
 
 pub mod timer_queue;
 #[cfg(feature = "trace")]
-mod trace;
+pub mod trace;
 pub(crate) mod util;
 #[cfg_attr(feature = "turbowakers", path = "waker_turbo.rs")]
 mod waker;
diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index aba519c8f..bdd3e4706 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -83,6 +83,129 @@
 
 use crate::raw::{SyncExecutor, TaskRef};
 
+use core::cell::UnsafeCell;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use rtos_trace::TaskInfo;
+
+const MAX_TASKS: usize = 1000;
+
+/// Represents a task being tracked in the task registry.
+///
+/// Contains the task's unique identifier and optional name.
+#[derive(Clone)]
+pub struct TrackedTask {
+    task_id: u32,
+    name: Option<&'static str>,
+}
+
+/// A thread-safe registry for tracking tasks in the system.
+///
+/// This registry maintains a list of active tasks with their IDs and optional names.
+/// It supports registering, unregistering, and querying information about tasks.
+/// The registry has a fixed capacity of `MAX_TASKS`.
+pub struct TaskRegistry {
+    tasks: [UnsafeCell<Option<TrackedTask>>; MAX_TASKS],
+    count: AtomicUsize,
+}
+
+impl TaskRegistry {
+    /// Creates a new empty task registry.
+    ///
+    /// This initializes a registry that can track up to `MAX_TASKS` tasks.  
+    pub const fn new() -> Self {
+        const EMPTY: UnsafeCell<Option<TrackedTask>> = UnsafeCell::new(None);
+        Self {
+            tasks: [EMPTY; MAX_TASKS],
+            count: AtomicUsize::new(0),
+        }
+    }
+
+    /// Registers a new task in the registry.
+    ///
+    /// # Arguments
+    /// * `task_id` - Unique identifier for the task
+    /// * `name` - Optional name for the task
+    ///
+    /// # Note
+    /// If the registry is full, the task will not be registered.
+    pub fn register(&self, task_id: u32, name: Option<&'static str>) {
+        let count = self.count.load(Ordering::Relaxed);
+        if count < MAX_TASKS {
+            for i in 0..MAX_TASKS {
+                unsafe {
+                    let slot = &self.tasks[i];
+                    let slot_ref = &mut *slot.get();
+                    if slot_ref.is_none() {
+                        *slot_ref = Some(TrackedTask { task_id, name });
+                        self.count.fetch_add(1, Ordering::Relaxed);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    /// Removes a task from the registry.
+    ///
+    /// # Arguments
+    /// * `task_id` - Unique identifier of the task to remove
+    pub fn unregister(&self, task_id: u32) {
+        for i in 0..MAX_TASKS {
+            unsafe {
+                let slot = &self.tasks[i];
+                let slot_ref = &mut *slot.get();
+                if let Some(task) = slot_ref {
+                    if task.task_id == task_id {
+                        *slot_ref = None;
+                        self.count.fetch_sub(1, Ordering::Relaxed);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    /// Returns an iterator over all registered tasks.
+    ///
+    /// This allows accessing information about all tasks currently in the registry.
+    pub fn get_all_tasks(&self) -> impl Iterator<Item = TrackedTask> + '_ {
+        (0..MAX_TASKS).filter_map(move |i| unsafe {
+            let slot = &self.tasks[i];
+            (*slot.get()).clone()
+        })
+    }
+
+    /// Retrieves the name of a task with the given ID.
+    ///
+    /// # Arguments
+    /// * `task_id` - Unique identifier of the task
+    ///
+    /// # Returns
+    /// The name of the task if found and named, or `None` otherwise
+    pub fn get_task_name(&self, task_id: u32) -> Option<&'static str> {
+        for i in 0..MAX_TASKS {
+            unsafe {
+                let slot = &self.tasks[i];
+                let slot_ref = &*slot.get();
+                if let Some(task) = slot_ref {
+                    if task.task_id == task_id {
+                        return task.name;
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+
+unsafe impl Sync for TaskRegistry {}
+unsafe impl Send for TaskRegistry {}
+
+/// Global task registry instance used for tracking all tasks in the system.
+///
+/// This provides a centralized registry accessible from anywhere in the application.
+pub static TASK_REGISTRY: TaskRegistry = TaskRegistry::new();
+
 #[cfg(not(feature = "rtos-trace"))]
 extern "Rust" {
     /// This callback is called when the executor begins polling. This will always
@@ -153,6 +276,8 @@ pub(crate) fn poll_start(executor: &SyncExecutor) {
 
 #[inline]
 pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
+    let task_id = task.as_ptr() as u32;
+
     #[cfg(not(feature = "rtos-trace"))]
     unsafe {
         _embassy_trace_task_new(executor as *const _ as u32, task.as_ptr() as u32)
@@ -164,10 +289,14 @@ pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
 
 #[inline]
 pub(crate) fn task_end(executor: *const SyncExecutor, task: &TaskRef) {
+    let task_id = task.as_ptr() as u32;
+
     #[cfg(not(feature = "rtos-trace"))]
     unsafe {
         _embassy_trace_task_end(executor as u32, task.as_ptr() as u32)
     }
+
+    TASK_REGISTRY.unregister(task_id);
 }
 
 #[inline]
@@ -213,7 +342,15 @@ pub(crate) fn executor_idle(executor: &SyncExecutor) {
 #[cfg(feature = "rtos-trace")]
 impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
     fn task_list() {
-        // We don't know what tasks exist, so we can't send them.
+        for task in TASK_REGISTRY.get_all_tasks() {
+            let info = rtos_trace::TaskInfo {
+                name: TASK_REGISTRY.get_task_name(task.task_id).unwrap(),
+                priority: 0,
+                stack_base: 0,
+                stack_size: 0,
+            };
+            rtos_trace::trace::task_send_info(task.task_id, info);
+        }
     }
     fn time() -> u64 {
         const fn gcd(a: u64, b: u64) -> u64 {
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index ff243081c..ea754341b 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -5,6 +5,8 @@ use core::sync::atomic::Ordering;
 use core::task::Poll;
 
 use super::raw;
+#[cfg(feature = "rtos-trace")]
+use super::raw::trace::TASK_REGISTRY;
 
 /// Token to spawn a newly-created task in an executor.
 ///
@@ -154,6 +156,31 @@ impl Spawner {
         }
     }
 
+    /// Spawns a new task with a specified name.
+    ///
+    /// # Arguments
+    /// * `name` - Static string name to associate with the task
+    /// * `token` - Token representing the task to spawn
+    ///
+    /// # Returns
+    /// Result indicating whether the spawn was successful
+    #[cfg(feature = "rtos-trace")]
+    pub fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        let task = token.raw_task;
+        mem::forget(token);
+
+        match task {
+            Some(task) => {
+                let task_id = task.as_ptr() as u32;
+                TASK_REGISTRY.register(task_id, Some(name));
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+
     // Used by the `embassy_executor_macros::main!` macro to throw an error when spawn
     // fails. This is here to allow conditional use of `defmt::unwrap!`
     // without introducing a `defmt` feature in the `embassy_executor_macros` package,

From 032898adf5848da237e4bf55b8c06c2ff73cae7c Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Mon, 5 May 2025 12:14:14 -0400
Subject: [PATCH 02/20] add a stub implementation for spawn_named

When rtos-trace is not enabled, spawn_named will use spawn instead
---
 embassy-executor/src/spawner.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index ea754341b..f87700be6 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -181,6 +181,13 @@ impl Spawner {
         }
     }
 
+    /// When rtos-trace is disabled, spawn_named falls back to regular spawn.
+/// This maintains API compatibility while optimizing out the name parameter.
+    #[cfg(not(feature = "rtos-trace"))]
+    pub fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        self.spawn(token)
+    }
+
     // Used by the `embassy_executor_macros::main!` macro to throw an error when spawn
     // fails. This is here to allow conditional use of `defmt::unwrap!`
     // without introducing a `defmt` feature in the `embassy_executor_macros` package,

From bbffd2b3f9f27dd9c3ae3f66ac88bcd1ee1dcb93 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Mon, 5 May 2025 12:17:03 -0400
Subject: [PATCH 03/20] whitespace in the documentation

---
 embassy-executor/src/spawner.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index f87700be6..4fc4312b9 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -182,7 +182,7 @@ impl Spawner {
     }
 
     /// When rtos-trace is disabled, spawn_named falls back to regular spawn.
-/// This maintains API compatibility while optimizing out the name parameter.
+    /// This maintains API compatibility while optimizing out the name parameter.
     #[cfg(not(feature = "rtos-trace"))]
     pub fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
         self.spawn(token)

From 05d52decb2a98ad5111962b71e667c692e68c23e Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 09:04:21 -0400
Subject: [PATCH 04/20] add name to TaskHeader

---
 embassy-executor/src/raw/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 35c82557c..2928848b8 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -89,6 +89,8 @@ pub(crate) struct TaskHeader {
 
     /// Integrated timer queue storage. This field should not be accessed outside of the timer queue.
     pub(crate) timer_queue_item: timer_queue::TimerQueueItem,
+    #[cfg(feature = "trace")]
+    pub(crate) name: Option<&'static str>,
 }
 
 /// This is essentially a `&'static TaskStorage<F>` where the type of the future has been erased.
@@ -190,6 +192,8 @@ impl<F: Future + 'static> TaskStorage<F> {
                 poll_fn: SyncUnsafeCell::new(None),
 
                 timer_queue_item: timer_queue::TimerQueueItem::new(),
+                #[cfg(feature = "trace")]
+                name: None,
             },
             future: UninitCell::uninit(),
         }

From 61f0f889a0dc89410218be725a43dcd967e53003 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 09:23:39 -0400
Subject: [PATCH 05/20] add get/set for task name

---
 embassy-executor/src/raw/mod.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 2928848b8..3f4e06350 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -151,6 +151,21 @@ impl TaskRef {
     pub fn as_id(self) -> u32 {
         self.ptr.as_ptr() as u32
     }
+
+    /// Get the name for a task
+    #[cfg(feature = "trace")]
+    pub fn name(&self) -> Option<&'static str> {
+        self.header().name
+    }
+
+    /// Set the name for a task
+    #[cfg(feature = "trace")]
+    pub fn set_name(&self, name: Option<&'static str>) {
+        unsafe {
+            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
+            (*header_ptr).name = name;
+        }
+    }
 }
 
 /// Raw storage in which a task can be spawned.

From 54b3fb6e7a12598e0f6299c18a333060d6a3f9c7 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 09:27:19 -0400
Subject: [PATCH 06/20] remove name from TaskRegistry and retrieve from task
 header instead

---
 embassy-executor/src/raw/trace.rs | 33 ++++++-------------------------
 embassy-executor/src/spawner.rs   |  3 ++-
 2 files changed, 8 insertions(+), 28 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index bdd3e4706..28be79cee 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -81,7 +81,7 @@
 
 #![allow(unused)]
 
-use crate::raw::{SyncExecutor, TaskRef};
+use crate::raw::{SyncExecutor, TaskHeader, TaskRef};
 
 use core::cell::UnsafeCell;
 use core::sync::atomic::{AtomicUsize, Ordering};
@@ -95,7 +95,6 @@ const MAX_TASKS: usize = 1000;
 #[derive(Clone)]
 pub struct TrackedTask {
     task_id: u32,
-    name: Option<&'static str>,
 }
 
 /// A thread-safe registry for tracking tasks in the system.
@@ -128,7 +127,7 @@ impl TaskRegistry {
     ///
     /// # Note
     /// If the registry is full, the task will not be registered.
-    pub fn register(&self, task_id: u32, name: Option<&'static str>) {
+    pub fn register(&self, task_id: u32) {
         let count = self.count.load(Ordering::Relaxed);
         if count < MAX_TASKS {
             for i in 0..MAX_TASKS {
@@ -136,7 +135,7 @@ impl TaskRegistry {
                     let slot = &self.tasks[i];
                     let slot_ref = &mut *slot.get();
                     if slot_ref.is_none() {
-                        *slot_ref = Some(TrackedTask { task_id, name });
+                        *slot_ref = Some(TrackedTask { task_id });
                         self.count.fetch_add(1, Ordering::Relaxed);
                         break;
                     }
@@ -174,28 +173,6 @@ impl TaskRegistry {
             (*slot.get()).clone()
         })
     }
-
-    /// Retrieves the name of a task with the given ID.
-    ///
-    /// # Arguments
-    /// * `task_id` - Unique identifier of the task
-    ///
-    /// # Returns
-    /// The name of the task if found and named, or `None` otherwise
-    pub fn get_task_name(&self, task_id: u32) -> Option<&'static str> {
-        for i in 0..MAX_TASKS {
-            unsafe {
-                let slot = &self.tasks[i];
-                let slot_ref = &*slot.get();
-                if let Some(task) = slot_ref {
-                    if task.task_id == task_id {
-                        return task.name;
-                    }
-                }
-            }
-        }
-        None
-    }
 }
 
 unsafe impl Sync for TaskRegistry {}
@@ -343,8 +320,10 @@ pub(crate) fn executor_idle(executor: &SyncExecutor) {
 impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
     fn task_list() {
         for task in TASK_REGISTRY.get_all_tasks() {
+            let task_ref = unsafe { TaskRef::from_ptr(task.task_id as *const TaskHeader) };
+            let name = task_ref.name().unwrap_or("unnamed\0");
             let info = rtos_trace::TaskInfo {
-                name: TASK_REGISTRY.get_task_name(task.task_id).unwrap(),
+                name,
                 priority: 0,
                 stack_base: 0,
                 stack_size: 0,
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index 4fc4312b9..40202299f 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -171,8 +171,9 @@ impl Spawner {
 
         match task {
             Some(task) => {
+                task.set_name(Some(name));
                 let task_id = task.as_ptr() as u32;
-                TASK_REGISTRY.register(task_id, Some(name));
+                TASK_REGISTRY.register(task_id);
 
                 unsafe { self.executor.spawn(task) };
                 Ok(())

From f4e0cbb7cc476b171acd0b21448e9bbc848a616d Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 09:59:27 -0400
Subject: [PATCH 07/20] add ID field to TaskHeader

---
 embassy-executor/src/raw/mod.rs | 19 +++++++++++++++++++
 embassy-executor/src/spawner.rs |  1 +
 2 files changed, 20 insertions(+)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 3f4e06350..075d8a254 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -91,6 +91,8 @@ pub(crate) struct TaskHeader {
     pub(crate) timer_queue_item: timer_queue::TimerQueueItem,
     #[cfg(feature = "trace")]
     pub(crate) name: Option<&'static str>,
+    #[cfg(feature = "trace")]
+    pub(crate) id: u32,
 }
 
 /// This is essentially a `&'static TaskStorage<F>` where the type of the future has been erased.
@@ -166,6 +168,21 @@ impl TaskRef {
             (*header_ptr).name = name;
         }
     }
+
+    /// Get the ID for a task
+    #[cfg(feature = "trace")]
+    pub fn id(&self) -> u32 {
+        self.header().id
+    } 
+
+    /// Set the ID for a task
+    #[cfg(feature = "trace")]
+    pub fn set_id(&self, id: u32) {
+        unsafe {
+            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
+            (*header_ptr).id = id;
+        }
+    }
 }
 
 /// Raw storage in which a task can be spawned.
@@ -209,6 +226,8 @@ impl<F: Future + 'static> TaskStorage<F> {
                 timer_queue_item: timer_queue::TimerQueueItem::new(),
                 #[cfg(feature = "trace")]
                 name: None,
+                #[cfg(feature = "trace")]
+                id: 0,
             },
             future: UninitCell::uninit(),
         }
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index 40202299f..7f907346d 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -174,6 +174,7 @@ impl Spawner {
                 task.set_name(Some(name));
                 let task_id = task.as_ptr() as u32;
                 TASK_REGISTRY.register(task_id);
+                task.set_id(task_id);
 
                 unsafe { self.executor.spawn(task) };
                 Ok(())

From 6085916714b79a888e117a2d7223e78c9a5de9d3 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 11:47:04 -0400
Subject: [PATCH 08/20] use an intrusive linked list in TaskHeader to track
 tasks

---
 embassy-executor/src/raw/mod.rs   |  76 +++++++++++-
 embassy-executor/src/raw/trace.rs | 190 ++++++++++++++----------------
 embassy-executor/src/spawner.rs   |   3 -
 3 files changed, 163 insertions(+), 106 deletions(-)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 075d8a254..b4adfe01b 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -93,6 +93,78 @@ pub(crate) struct TaskHeader {
     pub(crate) name: Option<&'static str>,
     #[cfg(feature = "trace")]
     pub(crate) id: u32,
+    #[cfg(feature = "trace")]
+    all_tasks_next: AtomicPtr<TaskHeader>,
+}
+
+/// A thread-safe tracker for all tasks in the system
+///
+/// This struct uses an intrusive linked list approach to track all tasks
+/// without additional memory allocations. It maintains a global list of
+/// tasks that can be traversed to find all currently existing tasks.
+#[cfg(feature = "trace")]
+pub struct TaskTracker {
+    head: AtomicPtr<TaskHeader>,
+}
+
+#[cfg(feature = "trace")]
+impl TaskTracker {
+    /// Creates a new empty task tracker
+    ///
+    /// Initializes a tracker with no tasks in its list.
+    pub const fn new() -> Self {
+        Self {
+            head: AtomicPtr::new(core::ptr::null_mut()),
+        }
+    }
+
+    /// Adds a task to the tracker
+    ///
+    /// This method inserts a task at the head of the intrusive linked list.
+    /// The operation is thread-safe and lock-free, using atomic operations
+    /// to ensure consistency even when called from different contexts.
+    ///
+    /// # Arguments
+    /// * `task` - The task reference to add to the tracker
+    pub fn add(&self, task: TaskRef) {
+        let task_ptr = task.as_ptr() as *mut TaskHeader;
+
+        loop {
+            let current_head = self.head.load(Ordering::Acquire);
+            unsafe {
+                (*task_ptr).all_tasks_next.store(current_head, Ordering::Relaxed);
+            }
+
+            if self
+                .head
+                .compare_exchange(current_head, task_ptr, Ordering::Release, Ordering::Relaxed)
+                .is_ok()
+            {
+                break;
+            }
+        }
+    }
+
+    /// Performs an operation on each task in the tracker
+    ///
+    /// This method traverses the entire list of tasks and calls the provided
+    /// function for each task. This allows inspecting or processing all tasks
+    /// in the system without modifying the tracker's structure.
+    ///
+    /// # Arguments
+    /// * `f` - A function to call for each task in the tracker
+    pub fn for_each<F>(&self, mut f: F)
+    where
+        F: FnMut(TaskRef),
+    {
+        let mut current = self.head.load(Ordering::Acquire);
+        while !current.is_null() {
+            let task = unsafe { TaskRef::from_ptr(current) };
+            f(task);
+
+            current = unsafe { (*current).all_tasks_next.load(Ordering::Acquire) };
+        }
+    }
 }
 
 /// This is essentially a `&'static TaskStorage<F>` where the type of the future has been erased.
@@ -173,7 +245,7 @@ impl TaskRef {
     #[cfg(feature = "trace")]
     pub fn id(&self) -> u32 {
         self.header().id
-    } 
+    }
 
     /// Set the ID for a task
     #[cfg(feature = "trace")]
@@ -228,6 +300,8 @@ impl<F: Future + 'static> TaskStorage<F> {
                 name: None,
                 #[cfg(feature = "trace")]
                 id: 0,
+                #[cfg(feature = "trace")]
+                all_tasks_next: AtomicPtr::new(core::ptr::null_mut()),
             },
             future: UninitCell::uninit(),
         }
diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 28be79cee..81c8a0024 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -81,107 +81,19 @@
 
 #![allow(unused)]
 
-use crate::raw::{SyncExecutor, TaskHeader, TaskRef};
+use crate::raw::{SyncExecutor, TaskHeader, TaskRef, TaskTracker};
 
 use core::cell::UnsafeCell;
 use core::sync::atomic::{AtomicUsize, Ordering};
 use rtos_trace::TaskInfo;
 
-const MAX_TASKS: usize = 1000;
-
-/// Represents a task being tracked in the task registry.
+/// Global task tracker instance
 ///
-/// Contains the task's unique identifier and optional name.
-#[derive(Clone)]
-pub struct TrackedTask {
-    task_id: u32,
-}
-
-/// A thread-safe registry for tracking tasks in the system.
-///
-/// This registry maintains a list of active tasks with their IDs and optional names.
-/// It supports registering, unregistering, and querying information about tasks.
-/// The registry has a fixed capacity of `MAX_TASKS`.
-pub struct TaskRegistry {
-    tasks: [UnsafeCell<Option<TrackedTask>>; MAX_TASKS],
-    count: AtomicUsize,
-}
-
-impl TaskRegistry {
-    /// Creates a new empty task registry.
-    ///
-    /// This initializes a registry that can track up to `MAX_TASKS` tasks.  
-    pub const fn new() -> Self {
-        const EMPTY: UnsafeCell<Option<TrackedTask>> = UnsafeCell::new(None);
-        Self {
-            tasks: [EMPTY; MAX_TASKS],
-            count: AtomicUsize::new(0),
-        }
-    }
-
-    /// Registers a new task in the registry.
-    ///
-    /// # Arguments
-    /// * `task_id` - Unique identifier for the task
-    /// * `name` - Optional name for the task
-    ///
-    /// # Note
-    /// If the registry is full, the task will not be registered.
-    pub fn register(&self, task_id: u32) {
-        let count = self.count.load(Ordering::Relaxed);
-        if count < MAX_TASKS {
-            for i in 0..MAX_TASKS {
-                unsafe {
-                    let slot = &self.tasks[i];
-                    let slot_ref = &mut *slot.get();
-                    if slot_ref.is_none() {
-                        *slot_ref = Some(TrackedTask { task_id });
-                        self.count.fetch_add(1, Ordering::Relaxed);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Removes a task from the registry.
-    ///
-    /// # Arguments
-    /// * `task_id` - Unique identifier of the task to remove
-    pub fn unregister(&self, task_id: u32) {
-        for i in 0..MAX_TASKS {
-            unsafe {
-                let slot = &self.tasks[i];
-                let slot_ref = &mut *slot.get();
-                if let Some(task) = slot_ref {
-                    if task.task_id == task_id {
-                        *slot_ref = None;
-                        self.count.fetch_sub(1, Ordering::Relaxed);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Returns an iterator over all registered tasks.
-    ///
-    /// This allows accessing information about all tasks currently in the registry.
-    pub fn get_all_tasks(&self) -> impl Iterator<Item = TrackedTask> + '_ {
-        (0..MAX_TASKS).filter_map(move |i| unsafe {
-            let slot = &self.tasks[i];
-            (*slot.get()).clone()
-        })
-    }
-}
-
-unsafe impl Sync for TaskRegistry {}
-unsafe impl Send for TaskRegistry {}
-
-/// Global task registry instance used for tracking all tasks in the system.
-///
-/// This provides a centralized registry accessible from anywhere in the application.
-pub static TASK_REGISTRY: TaskRegistry = TaskRegistry::new();
+/// This static provides access to the global task tracker which maintains
+/// a list of all tasks in the system. It's automatically updated by the
+/// task lifecycle hooks in the trace module.
+#[cfg(feature = "trace")]
+pub static TASK_TRACKER: TaskTracker = TaskTracker::new();
 
 #[cfg(not(feature = "rtos-trace"))]
 extern "Rust" {
@@ -262,6 +174,9 @@ pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
 
     #[cfg(feature = "rtos-trace")]
     rtos_trace::trace::task_new(task.as_ptr() as u32);
+
+    #[cfg(feature = "rtos-trace")]
+    TASK_TRACKER.add(*task);
 }
 
 #[inline]
@@ -272,8 +187,6 @@ pub(crate) fn task_end(executor: *const SyncExecutor, task: &TaskRef) {
     unsafe {
         _embassy_trace_task_end(executor as u32, task.as_ptr() as u32)
     }
-
-    TASK_REGISTRY.unregister(task_id);
 }
 
 #[inline]
@@ -316,20 +229,93 @@ pub(crate) fn executor_idle(executor: &SyncExecutor) {
     rtos_trace::trace::system_idle();
 }
 
+/// Returns an iterator over all active tasks in the system
+///
+/// This function provides a convenient way to iterate over all tasks
+/// that are currently tracked in the system. The returned iterator
+/// yields each task in the global task tracker.
+///
+/// # Returns
+/// An iterator that yields `TaskRef` items for each task
+#[cfg(feature = "trace")]
+pub fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
+    struct TaskIterator<'a> {
+        tracker: &'a TaskTracker,
+        current: *mut TaskHeader,
+    }
+
+    impl<'a> Iterator for TaskIterator<'a> {
+        type Item = TaskRef;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            if self.current.is_null() {
+                return None;
+            }
+
+            let task = unsafe { TaskRef::from_ptr(self.current) };
+            self.current = unsafe { (*self.current).all_tasks_next.load(Ordering::Acquire) };
+
+            Some(task)
+        }
+    }
+
+    TaskIterator {
+        tracker: &TASK_TRACKER,
+        current: TASK_TRACKER.head.load(Ordering::Acquire),
+    }
+}
+
+/// Get all active tasks, filtered by a predicate function
+#[cfg(feature = "trace")]
+pub fn filter_active_tasks<F>(predicate: F) -> impl Iterator<Item = TaskRef> + 'static
+where
+    F: Fn(&TaskRef) -> bool + 'static,
+{
+    get_all_active_tasks().filter(move |task| predicate(task))
+}
+
+/// Count the number of active tasks
+#[cfg(feature = "trace")]
+pub fn count_active_tasks() -> usize {
+    let mut count = 0;
+    TASK_TRACKER.for_each(|_| count += 1);
+    count
+}
+
+/// Perform an action on each active task
+#[cfg(feature = "trace")]
+pub fn with_all_active_tasks<F>(f: F)
+where
+    F: FnMut(TaskRef),
+{
+    TASK_TRACKER.for_each(f);
+}
+
+/// Get tasks by name
+#[cfg(feature = "trace")]
+pub fn get_tasks_by_name(name: &'static str) -> impl Iterator<Item = TaskRef> + 'static {
+    filter_active_tasks(move |task| task.name() == Some(name))
+}
+
+/// Get tasks by ID
+#[cfg(feature = "trace")]
+pub fn get_task_by_id(id: u32) -> Option<TaskRef> {
+    filter_active_tasks(move |task| task.id() == id).next()
+}
+
 #[cfg(feature = "rtos-trace")]
 impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
     fn task_list() {
-        for task in TASK_REGISTRY.get_all_tasks() {
-            let task_ref = unsafe { TaskRef::from_ptr(task.task_id as *const TaskHeader) };
-            let name = task_ref.name().unwrap_or("unnamed\0");
+        with_all_active_tasks(|task| {
+            let name = task.name().unwrap_or("unnamed task\0");
             let info = rtos_trace::TaskInfo {
                 name,
                 priority: 0,
                 stack_base: 0,
                 stack_size: 0,
             };
-            rtos_trace::trace::task_send_info(task.task_id, info);
-        }
+            rtos_trace::trace::task_send_info(task.as_id(), info);
+        });
     }
     fn time() -> u64 {
         const fn gcd(a: u64, b: u64) -> u64 {
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index 7f907346d..5e42f01bf 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -5,8 +5,6 @@ use core::sync::atomic::Ordering;
 use core::task::Poll;
 
 use super::raw;
-#[cfg(feature = "rtos-trace")]
-use super::raw::trace::TASK_REGISTRY;
 
 /// Token to spawn a newly-created task in an executor.
 ///
@@ -173,7 +171,6 @@ impl Spawner {
             Some(task) => {
                 task.set_name(Some(name));
                 let task_id = task.as_ptr() as u32;
-                TASK_REGISTRY.register(task_id);
                 task.set_id(task_id);
 
                 unsafe { self.executor.spawn(task) };

From f2429c212e77969bacfe726cd293bf0ab5903664 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Tue, 6 May 2025 11:54:45 -0400
Subject: [PATCH 09/20] fix whitespace in the imports in trace.rs

---
 embassy-executor/src/raw/trace.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 81c8a0024..c0599d2c7 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -81,12 +81,13 @@
 
 #![allow(unused)]
 
-use crate::raw::{SyncExecutor, TaskHeader, TaskRef, TaskTracker};
-
 use core::cell::UnsafeCell;
 use core::sync::atomic::{AtomicUsize, Ordering};
+
 use rtos_trace::TaskInfo;
 
+use crate::raw::{SyncExecutor, TaskHeader, TaskRef, TaskTracker};
+
 /// Global task tracker instance
 ///
 /// This static provides access to the global task tracker which maintains

From b3e13cc6de744a241521cff20725706a1e40ef25 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 10:58:07 -0400
Subject: [PATCH 10/20] make tracing API functions internal

---
 embassy-executor/src/raw/trace.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index c0599d2c7..503d806bd 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -239,7 +239,7 @@ pub(crate) fn executor_idle(executor: &SyncExecutor) {
 /// # Returns
 /// An iterator that yields `TaskRef` items for each task
 #[cfg(feature = "trace")]
-pub fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
+fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
     struct TaskIterator<'a> {
         tracker: &'a TaskTracker,
         current: *mut TaskHeader,
@@ -285,7 +285,7 @@ pub fn count_active_tasks() -> usize {
 
 /// Perform an action on each active task
 #[cfg(feature = "trace")]
-pub fn with_all_active_tasks<F>(f: F)
+fn with_all_active_tasks<F>(f: F)
 where
     F: FnMut(TaskRef),
 {

From 8f18810ec61ce235a4c895413936e0216ed22c4f Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 10:58:27 -0400
Subject: [PATCH 11/20] remove unused tracing API

---
 embassy-executor/src/raw/trace.rs | 29 -----------------------------
 1 file changed, 29 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 503d806bd..fec3a4834 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -266,23 +266,6 @@ fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
     }
 }
 
-/// Get all active tasks, filtered by a predicate function
-#[cfg(feature = "trace")]
-pub fn filter_active_tasks<F>(predicate: F) -> impl Iterator<Item = TaskRef> + 'static
-where
-    F: Fn(&TaskRef) -> bool + 'static,
-{
-    get_all_active_tasks().filter(move |task| predicate(task))
-}
-
-/// Count the number of active tasks
-#[cfg(feature = "trace")]
-pub fn count_active_tasks() -> usize {
-    let mut count = 0;
-    TASK_TRACKER.for_each(|_| count += 1);
-    count
-}
-
 /// Perform an action on each active task
 #[cfg(feature = "trace")]
 fn with_all_active_tasks<F>(f: F)
@@ -292,18 +275,6 @@ where
     TASK_TRACKER.for_each(f);
 }
 
-/// Get tasks by name
-#[cfg(feature = "trace")]
-pub fn get_tasks_by_name(name: &'static str) -> impl Iterator<Item = TaskRef> + 'static {
-    filter_active_tasks(move |task| task.name() == Some(name))
-}
-
-/// Get tasks by ID
-#[cfg(feature = "trace")]
-pub fn get_task_by_id(id: u32) -> Option<TaskRef> {
-    filter_active_tasks(move |task| task.id() == id).next()
-}
-
 #[cfg(feature = "rtos-trace")]
 impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
     fn task_list() {

From 56b5e35c60743d65aacee753d1db391c3cbeae16 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 10:58:59 -0400
Subject: [PATCH 12/20] change rtos-trace feature flag on tracing API to trace
 feature flag

---
 embassy-executor/src/spawner.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index 5e42f01bf..a0d246616 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -162,7 +162,7 @@ impl Spawner {
     ///
     /// # Returns
     /// Result indicating whether the spawn was successful
-    #[cfg(feature = "rtos-trace")]
+    #[cfg(feature = "trace")]
     pub fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
         let task = token.raw_task;
         mem::forget(token);
@@ -182,7 +182,7 @@ impl Spawner {
 
     /// When rtos-trace is disabled, spawn_named falls back to regular spawn.
     /// This maintains API compatibility while optimizing out the name parameter.
-    #[cfg(not(feature = "rtos-trace"))]
+    #[cfg(not(feature = "trace"))]
     pub fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
         self.spawn(token)
     }

From 8a8deb704fdd58cecf463f033cd3c3d1cc3534c7 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 11:20:22 -0400
Subject: [PATCH 13/20] move spawn_named into trace.rs through TraceExt trait

---
 embassy-executor/src/raw/trace.rs | 43 +++++++++++++++++++++++++++++++
 embassy-executor/src/spawner.rs   | 37 ++------------------------
 2 files changed, 45 insertions(+), 35 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index fec3a4834..eb960f721 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -87,6 +87,49 @@ use core::sync::atomic::{AtomicUsize, Ordering};
 use rtos_trace::TaskInfo;
 
 use crate::raw::{SyncExecutor, TaskHeader, TaskRef, TaskTracker};
+use crate::spawner::{SpawnError, SpawnToken, Spawner};
+
+/// Extension trait adding tracing capabilities to the Spawner
+pub trait TraceExt {
+    /// Spawns a new task with a specified name.
+    ///
+    /// # Arguments
+    /// * `name` - Static string name to associate with the task
+    /// * `token` - Token representing the task to spawn
+    ///
+    /// # Returns
+    /// Result indicating whether the spawn was successful
+    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
+}
+
+#[cfg(feature = "trace")]
+impl TraceExt for Spawner {
+    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        let task = token.raw_task;
+        core::mem::forget(token);
+
+        match task {
+            Some(task) => {
+                task.set_name(Some(name));
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+}
+
+/// When trace is disabled, spawn_named falls back to regular spawn.
+/// This maintains API compatibility while optimizing out the name parameter.
+#[cfg(not(feature = "trace"))]
+impl TraceExt for Spawner {
+    fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        self.spawn(token)
+    }
+}
 
 /// Global task tracker instance
 ///
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index a0d246616..6b8db4f8f 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -22,7 +22,7 @@ use super::raw;
 /// Once you've invoked a task function and obtained a SpawnToken, you *must* spawn it.
 #[must_use = "Calling a task function does nothing on its own. You must spawn the returned SpawnToken, typically with Spawner::spawn()"]
 pub struct SpawnToken<S> {
-    raw_task: Option<raw::TaskRef>,
+    pub(crate) raw_task: Option<raw::TaskRef>,
     phantom: PhantomData<*mut S>,
 }
 
@@ -103,7 +103,7 @@ impl core::error::Error for SpawnError {}
 /// If you want to spawn tasks from another thread, use [SendSpawner].
 #[derive(Copy, Clone)]
 pub struct Spawner {
-    executor: &'static raw::Executor,
+    pub(crate) executor: &'static raw::Executor,
     not_send: PhantomData<*mut ()>,
 }
 
@@ -154,39 +154,6 @@ impl Spawner {
         }
     }
 
-    /// Spawns a new task with a specified name.
-    ///
-    /// # Arguments
-    /// * `name` - Static string name to associate with the task
-    /// * `token` - Token representing the task to spawn
-    ///
-    /// # Returns
-    /// Result indicating whether the spawn was successful
-    #[cfg(feature = "trace")]
-    pub fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
-        let task = token.raw_task;
-        mem::forget(token);
-
-        match task {
-            Some(task) => {
-                task.set_name(Some(name));
-                let task_id = task.as_ptr() as u32;
-                task.set_id(task_id);
-
-                unsafe { self.executor.spawn(task) };
-                Ok(())
-            }
-            None => Err(SpawnError::Busy),
-        }
-    }
-
-    /// When rtos-trace is disabled, spawn_named falls back to regular spawn.
-    /// This maintains API compatibility while optimizing out the name parameter.
-    #[cfg(not(feature = "trace"))]
-    pub fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
-        self.spawn(token)
-    }
-
     // Used by the `embassy_executor_macros::main!` macro to throw an error when spawn
     // fails. This is here to allow conditional use of `defmt::unwrap!`
     // without introducing a `defmt` feature in the `embassy_executor_macros` package,

From 462d04c6d5a0fc6072cf9bdb0faa60da74ff46d2 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 13:34:32 -0400
Subject: [PATCH 14/20] move TaskTracker to trace

---
 embassy-executor/src/raw/mod.rs   | 70 -----------------------------
 embassy-executor/src/raw/trace.rs | 74 ++++++++++++++++++++++++++++++-
 2 files changed, 72 insertions(+), 72 deletions(-)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index b4adfe01b..882e4605b 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -97,76 +97,6 @@ pub(crate) struct TaskHeader {
     all_tasks_next: AtomicPtr<TaskHeader>,
 }
 
-/// A thread-safe tracker for all tasks in the system
-///
-/// This struct uses an intrusive linked list approach to track all tasks
-/// without additional memory allocations. It maintains a global list of
-/// tasks that can be traversed to find all currently existing tasks.
-#[cfg(feature = "trace")]
-pub struct TaskTracker {
-    head: AtomicPtr<TaskHeader>,
-}
-
-#[cfg(feature = "trace")]
-impl TaskTracker {
-    /// Creates a new empty task tracker
-    ///
-    /// Initializes a tracker with no tasks in its list.
-    pub const fn new() -> Self {
-        Self {
-            head: AtomicPtr::new(core::ptr::null_mut()),
-        }
-    }
-
-    /// Adds a task to the tracker
-    ///
-    /// This method inserts a task at the head of the intrusive linked list.
-    /// The operation is thread-safe and lock-free, using atomic operations
-    /// to ensure consistency even when called from different contexts.
-    ///
-    /// # Arguments
-    /// * `task` - The task reference to add to the tracker
-    pub fn add(&self, task: TaskRef) {
-        let task_ptr = task.as_ptr() as *mut TaskHeader;
-
-        loop {
-            let current_head = self.head.load(Ordering::Acquire);
-            unsafe {
-                (*task_ptr).all_tasks_next.store(current_head, Ordering::Relaxed);
-            }
-
-            if self
-                .head
-                .compare_exchange(current_head, task_ptr, Ordering::Release, Ordering::Relaxed)
-                .is_ok()
-            {
-                break;
-            }
-        }
-    }
-
-    /// Performs an operation on each task in the tracker
-    ///
-    /// This method traverses the entire list of tasks and calls the provided
-    /// function for each task. This allows inspecting or processing all tasks
-    /// in the system without modifying the tracker's structure.
-    ///
-    /// # Arguments
-    /// * `f` - A function to call for each task in the tracker
-    pub fn for_each<F>(&self, mut f: F)
-    where
-        F: FnMut(TaskRef),
-    {
-        let mut current = self.head.load(Ordering::Acquire);
-        while !current.is_null() {
-            let task = unsafe { TaskRef::from_ptr(current) };
-            f(task);
-
-            current = unsafe { (*current).all_tasks_next.load(Ordering::Acquire) };
-        }
-    }
-}
-
 /// This is essentially a `&'static TaskStorage<F>` where the type of the future has been erased.
 #[derive(Clone, Copy, PartialEq)]
 pub struct TaskRef {
diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index eb960f721..b59da0526 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -82,11 +82,11 @@
 #![allow(unused)]
 
 use core::cell::UnsafeCell;
-use core::sync::atomic::{AtomicUsize, Ordering};
+use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 
 use rtos_trace::TaskInfo;
 
-use crate::raw::{SyncExecutor, TaskHeader, TaskRef, TaskTracker};
+use crate::raw::{SyncExecutor, TaskHeader, TaskRef};
 use crate::spawner::{SpawnError, SpawnToken, Spawner};
 
 /// Extension trait adding tracing capabilities to the Spawner
@@ -139,6 +139,76 @@ impl TraceExt for Spawner {
 #[cfg(feature = "trace")]
 pub static TASK_TRACKER: TaskTracker = TaskTracker::new();
 
+/// A thread-safe tracker for all tasks in the system
+///
+/// This struct uses an intrusive linked list approach to track all tasks
+/// without additional memory allocations. It maintains a global list of
+/// tasks that can be traversed to find all currently existing tasks.
+#[cfg(feature = "trace")]
+pub struct TaskTracker {
+    head: AtomicPtr<TaskHeader>,
+}
+
+#[cfg(feature = "trace")]
+impl TaskTracker {
+    /// Creates a new empty task tracker
+    ///
+    /// Initializes a tracker with no tasks in its list.
+    pub const fn new() -> Self {
+        Self {
+            head: AtomicPtr::new(core::ptr::null_mut()),
+        }
+    }
+
+    /// Adds a task to the tracker
+    ///
+    /// This method inserts a task at the head of the intrusive linked list.
+    /// The operation is thread-safe and lock-free, using atomic operations
+    /// to ensure consistency even when called from different contexts.
+    ///
+    /// # Arguments
+    /// * `task` - The task reference to add to the tracker
+    pub fn add(&self, task: TaskRef) {
+        let task_ptr = task.as_ptr() as *mut TaskHeader;
+
+        loop {
+            let current_head = self.head.load(Ordering::Acquire);
+            unsafe {
+                (*task_ptr).all_tasks_next.store(current_head, Ordering::Relaxed);
+            }
+
+            if self
+                .head
+                .compare_exchange(current_head, task_ptr, Ordering::Release, Ordering::Relaxed)
+                .is_ok()
+            {
+                break;
+            }
+        }
+    }
+
+    /// Performs an operation on each task in the tracker
+    ///
+    /// This method traverses the entire list of tasks and calls the provided
+    /// function for each task. This allows inspecting or processing all tasks
+    /// in the system without modifying the tracker's structure.
+    ///
+    /// # Arguments
+    /// * `f` - A function to call for each task in the tracker
+    pub fn for_each<F>(&self, mut f: F)
+    where
+        F: FnMut(TaskRef),
+    {
+        let mut current = self.head.load(Ordering::Acquire);
+        while !current.is_null() {
+            let task = unsafe { TaskRef::from_ptr(current) };
+            f(task);
+
+            current = unsafe { (*current).all_tasks_next.load(Ordering::Acquire) };
+        }
+    }
+}
+
 #[cfg(not(feature = "rtos-trace"))]
 extern "Rust" {
     /// This callback is called when the executor begins polling. This will always

From 3b873bb6bb51b9bdac9272b5ec629a6ac54a89f7 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 13:40:32 -0400
Subject: [PATCH 15/20] implement TaskRefTrace for tracing-only fields in
 TaskRef

---
 embassy-executor/src/raw/mod.rs   | 36 ---------------------
 embassy-executor/src/raw/trace.rs | 52 +++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 36 deletions(-)

diff --git a/embassy-executor/src/raw/mod.rs b/embassy-executor/src/raw/mod.rs
index 882e4605b..e7a27035a 100644
--- a/embassy-executor/src/raw/mod.rs
+++ b/embassy-executor/src/raw/mod.rs
@@ -149,42 +149,6 @@ impl TaskRef {
     pub(crate) fn as_ptr(self) -> *const TaskHeader {
         self.ptr.as_ptr()
     }
-
-    /// Get the ID for a task
-    #[cfg(feature = "trace")]
-    pub fn as_id(self) -> u32 {
-        self.ptr.as_ptr() as u32
-    }
-
-    /// Get the name for a task
-    #[cfg(feature = "trace")]
-    pub fn name(&self) -> Option<&'static str> {
-        self.header().name
-    }
-
-    /// Set the name for a task
-    #[cfg(feature = "trace")]
-    pub fn set_name(&self, name: Option<&'static str>) {
-        unsafe {
-            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
-            (*header_ptr).name = name;
-        }
-    }
-
-    /// Get the ID for a task
-    #[cfg(feature = "trace")]
-    pub fn id(&self) -> u32 {
-        self.header().id
-    }
-
-    /// Set the ID for a task
-    #[cfg(feature = "trace")]
-    pub fn set_id(&self, id: u32) {
-        unsafe {
-            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
-            (*header_ptr).id = id;
-        }
-    }
 }
 
 /// Raw storage in which a task can be spawned.
diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index b59da0526..b30f23468 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -209,6 +209,58 @@ impl TaskTracker {
     }
 }
 
+/// Extension trait for `TaskRef` that provides tracing functionality.
+///
+/// This trait is only available when the `trace` feature is enabled.
+/// It extends `TaskRef` with methods for accessing and modifying task identifiers
+/// and names, which are useful for debugging, logging, and performance analysis.
+#[cfg(feature = "trace")]
+pub trait TaskRefTrace {
+    /// Get the ID for a task
+    fn as_id(self) -> u32;
+
+    /// Get the name for a task
+    fn name(&self) -> Option<&'static str>;
+
+    /// Set the name for a task
+    fn set_name(&self, name: Option<&'static str>);
+
+    /// Get the ID for a task
+    fn id(&self) -> u32;
+
+    /// Set the ID for a task
+    fn set_id(&self, id: u32);
+}
+
+#[cfg(feature = "trace")]
+impl TaskRefTrace for TaskRef {
+    fn as_id(self) -> u32 {
+        self.ptr.as_ptr() as u32
+    }
+
+    fn name(&self) -> Option<&'static str> {
+        self.header().name
+    }
+
+    fn set_name(&self, name: Option<&'static str>) {
+        unsafe {
+            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
+            (*header_ptr).name = name;
+        }
+    }
+
+    fn id(&self) -> u32 {
+        self.header().id
+    }
+
+    fn set_id(&self, id: u32) {
+        unsafe {
+            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
+            (*header_ptr).id = id;
+        }
+    }
+}
+
 #[cfg(not(feature = "rtos-trace"))]
 extern "Rust" {
     /// This callback is called when the executor begins polling. This will always

From 194a3044acb5cd9691ced78596b9fd81e6884667 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 13:41:23 -0400
Subject: [PATCH 16/20] remove unused task_id

---
 embassy-executor/src/raw/trace.rs | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index b30f23468..04e9d234f 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -216,9 +216,6 @@ impl TaskTracker {
 /// and names, which are useful for debugging, logging, and performance analysis.
 #[cfg(feature = "trace")]
 pub trait TaskRefTrace {
-    /// Get the ID for a task
-    fn as_id(self) -> u32;
-
     /// Get the name for a task
     fn name(&self) -> Option<&'static str>;
 
@@ -234,10 +231,6 @@ pub trait TaskRefTrace {
 
 #[cfg(feature = "trace")]
 impl TaskRefTrace for TaskRef {
-    fn as_id(self) -> u32 {
-        self.ptr.as_ptr() as u32
-    }
-
     fn name(&self) -> Option<&'static str> {
         self.header().name
     }
@@ -331,8 +324,6 @@ pub(crate) fn poll_start(executor: &SyncExecutor) {
 
 #[inline]
 pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
-    let task_id = task.as_ptr() as u32;
-
     #[cfg(not(feature = "rtos-trace"))]
     unsafe {
         _embassy_trace_task_new(executor as *const _ as u32, task.as_ptr() as u32)
@@ -347,8 +338,6 @@ pub(crate) fn task_new(executor: &SyncExecutor, task: &TaskRef) {
 
 #[inline]
 pub(crate) fn task_end(executor: *const SyncExecutor, task: &TaskRef) {
-    let task_id = task.as_ptr() as u32;
-
     #[cfg(not(feature = "rtos-trace"))]
     unsafe {
         _embassy_trace_task_end(executor as u32, task.as_ptr() as u32)
@@ -451,7 +440,7 @@ impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
                 stack_base: 0,
                 stack_size: 0,
             };
-            rtos_trace::trace::task_send_info(task.as_id(), info);
+            rtos_trace::trace::task_send_info(task.id(), info);
         });
     }
     fn time() -> u64 {

From e968c4763694d676cca6f1bd30949619dd12e962 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 14:03:03 -0400
Subject: [PATCH 17/20] update TraceExt trait name for Spawner

---
 embassy-executor/src/raw/trace.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 04e9d234f..f55033530 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -90,7 +90,7 @@ use crate::raw::{SyncExecutor, TaskHeader, TaskRef};
 use crate::spawner::{SpawnError, SpawnToken, Spawner};
 
 /// Extension trait adding tracing capabilities to the Spawner
-pub trait TraceExt {
+pub trait SpawnerTraceExt {
     /// Spawns a new task with a specified name.
     ///
     /// # Arguments
@@ -103,7 +103,7 @@ pub trait TraceExt {
 }
 
 #[cfg(feature = "trace")]
-impl TraceExt for Spawner {
+impl SpawnerTraceExt for Spawner {
     fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
         let task = token.raw_task;
         core::mem::forget(token);
@@ -125,7 +125,7 @@ impl TraceExt for Spawner {
 /// When trace is disabled, spawn_named falls back to regular spawn.
 /// This maintains API compatibility while optimizing out the name parameter.
 #[cfg(not(feature = "trace"))]
-impl TraceExt for Spawner {
+impl SpawnerTraceExt for Spawner {
     fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
         self.spawn(token)
     }

From dfaab013ebaaa4a19c06f2eb00821712ff13cf7a Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 14:35:43 -0400
Subject: [PATCH 18/20] move SpawnerTraceExt back into Spawner

---
 embassy-executor/src/raw/trace.rs | 42 --------------------------
 embassy-executor/src/spawner.rs   | 50 +++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 42 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index f55033530..593f7b0ba 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -89,48 +89,6 @@ use rtos_trace::TaskInfo;
 use crate::raw::{SyncExecutor, TaskHeader, TaskRef};
 use crate::spawner::{SpawnError, SpawnToken, Spawner};
 
-/// Extension trait adding tracing capabilities to the Spawner
-pub trait SpawnerTraceExt {
-    /// Spawns a new task with a specified name.
-    ///
-    /// # Arguments
-    /// * `name` - Static string name to associate with the task
-    /// * `token` - Token representing the task to spawn
-    ///
-    /// # Returns
-    /// Result indicating whether the spawn was successful
-    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
-}
-
-#[cfg(feature = "trace")]
-impl SpawnerTraceExt for Spawner {
-    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
-        let task = token.raw_task;
-        core::mem::forget(token);
-
-        match task {
-            Some(task) => {
-                task.set_name(Some(name));
-                let task_id = task.as_ptr() as u32;
-                task.set_id(task_id);
-
-                unsafe { self.executor.spawn(task) };
-                Ok(())
-            }
-            None => Err(SpawnError::Busy),
-        }
-    }
-}
-
-/// When trace is disabled, spawn_named falls back to regular spawn.
-/// This maintains API compatibility while optimizing out the name parameter.
-#[cfg(not(feature = "trace"))]
-impl SpawnerTraceExt for Spawner {
-    fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
-        self.spawn(token)
-    }
-}
-
 /// Global task tracker instance
 ///
 /// This static provides access to the global task tracker which maintains
diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index 6b8db4f8f..bfb32ebcc 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -6,6 +6,9 @@ use core::task::Poll;
 
 use super::raw;
 
+#[cfg(feature = "trace")]
+use crate::raw::trace::TaskRefTrace;
+
 /// Token to spawn a newly-created task in an executor.
 ///
 /// When calling a task function (like `#[embassy_executor::task] async fn my_task() { ... }`), the returned
@@ -180,6 +183,53 @@ impl Spawner {
     }
 }
 
+/// Extension trait adding tracing capabilities to the Spawner
+///
+/// This trait provides an additional method to spawn tasks with an associated name,
+/// which can be useful for debugging and tracing purposes.
+pub trait SpawnerTraceExt {
+    /// Spawns a new task with a specified name.
+    ///
+    /// # Arguments
+    /// * `name` - Static string name to associate with the task
+    /// * `token` - Token representing the task to spawn
+    ///
+    /// # Returns
+    /// Result indicating whether the spawn was successful
+    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
+}
+
+/// Implementation of the SpawnerTraceExt trait for Spawner when trace is enabled
+#[cfg(feature = "trace")]
+impl SpawnerTraceExt for Spawner {
+    fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        let task = token.raw_task;
+        core::mem::forget(token);
+
+        match task {
+            Some(task) => {
+                // Set the name and ID when trace is enabled
+                task.set_name(Some(name));
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+}
+
+/// Implementation of the SpawnerTraceExt trait for Spawner when trace is disabled
+#[cfg(not(feature = "trace"))]
+impl SpawnerTraceExt for Spawner {
+    fn spawn_named<S>(&self, _name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        // When trace is disabled, just forward to regular spawn and ignore the name
+        self.spawn(token)
+    }
+}
+
 /// Handle to spawn tasks into an executor from any thread.
 ///
 /// This Spawner can be used from any thread (it is Send), but it can

From 3ffa2e4f3f9ecbca8637ae1603194a63d55b4396 Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 16:30:06 -0400
Subject: [PATCH 19/20] remove unnecessary trace flags

---
 embassy-executor/src/raw/trace.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 593f7b0ba..6c9cfda25 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -94,7 +94,6 @@ use crate::spawner::{SpawnError, SpawnToken, Spawner};
 /// This static provides access to the global task tracker which maintains
 /// a list of all tasks in the system. It's automatically updated by the
 /// task lifecycle hooks in the trace module.
-#[cfg(feature = "trace")]
 pub static TASK_TRACKER: TaskTracker = TaskTracker::new();
 
 /// A thread-safe tracker for all tasks in the system
@@ -102,12 +101,10 @@ pub static TASK_TRACKER: TaskTracker = TaskTracker::new();
 /// This struct uses an intrusive linked list approach to track all tasks
 /// without additional memory allocations. It maintains a global list of
 /// tasks that can be traversed to find all currently existing tasks.
-#[cfg(feature = "trace")]
 pub struct TaskTracker {
     head: AtomicPtr<TaskHeader>,
 }
 
-#[cfg(feature = "trace")]
 impl TaskTracker {
     /// Creates a new empty task tracker
     ///
@@ -172,7 +169,6 @@ impl TaskTracker {
 /// This trait is only available when the `trace` feature is enabled.
 /// It extends `TaskRef` with methods for accessing and modifying task identifiers
 /// and names, which are useful for debugging, logging, and performance analysis.
-#[cfg(feature = "trace")]
 pub trait TaskRefTrace {
     /// Get the name for a task
     fn name(&self) -> Option<&'static str>;
@@ -187,7 +183,6 @@ pub trait TaskRefTrace {
     fn set_id(&self, id: u32);
 }
 
-#[cfg(feature = "trace")]
 impl TaskRefTrace for TaskRef {
     fn name(&self) -> Option<&'static str> {
         self.header().name
@@ -350,7 +345,6 @@ pub(crate) fn executor_idle(executor: &SyncExecutor) {
 ///
 /// # Returns
 /// An iterator that yields `TaskRef` items for each task
-#[cfg(feature = "trace")]
 fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
     struct TaskIterator<'a> {
         tracker: &'a TaskTracker,
@@ -379,7 +373,6 @@ fn get_all_active_tasks() -> impl Iterator<Item = TaskRef> + 'static {
 }
 
 /// Perform an action on each active task
-#[cfg(feature = "trace")]
 fn with_all_active_tasks<F>(f: F)
 where
     F: FnMut(TaskRef),

From ebb6132f5f9c55ad4ced2602134f8e2c69135c1e Mon Sep 17 00:00:00 2001
From: Kat Perez <katperez@microsoft.com>
Date: Thu, 8 May 2025 16:31:47 -0400
Subject: [PATCH 20/20] rustfmt

---
 embassy-executor/src/spawner.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/embassy-executor/src/spawner.rs b/embassy-executor/src/spawner.rs
index bfb32ebcc..522d97db3 100644
--- a/embassy-executor/src/spawner.rs
+++ b/embassy-executor/src/spawner.rs
@@ -5,7 +5,6 @@ use core::sync::atomic::Ordering;
 use core::task::Poll;
 
 use super::raw;
-
 #[cfg(feature = "trace")]
 use crate::raw::trace::TaskRefTrace;