add selective tracing support to SpawnerTraceExt

Add spawn_with_trace(), spawn_no_trace() and named variants to provide
fine-grained control over task tracing. Supports both default tracing
(rtos-trace) and selective tracing (rtos-trace-selective) modes while
maintaining backward compatibility.

Author: kat-perez

embassy-executor/Cargo.toml

@@ -95,8 +95,10 @@ executor-thread = []
 executor-interrupt = []
 ## Enable tracing support (adds some overhead)
 trace = []
-## Enable support for rtos-trace framework
+## Enable support for rtos-trace framework (traces all tasks by default)
 rtos-trace = ["dep:rtos-trace", "trace", "dep:embassy-time-driver"]
+## Only trace tasks that are explicitly marked for tracing (selective mode)
+rtos-trace-selective = ["rtos-trace"]
 
 #! ### Timer Item Payload Size
 #! Sets the size of the payload for timer items, allowing integrated timer implementors to store

embassy-executor/src/raw/mod.rs

@@ -94,6 +94,8 @@ pub(crate) struct TaskHeader {
     #[cfg(feature = "trace")]
     pub(crate) id: u32,
     #[cfg(feature = "trace")]
+    pub(crate) trace_excluded: bool,
+    #[cfg(feature = "trace")]
     all_tasks_next: AtomicPtr<TaskHeader>,
 }
 
@@ -195,6 +197,8 @@ impl<F: Future + 'static> TaskStorage<F> {
                 #[cfg(feature = "trace")]
                 id: 0,
                 #[cfg(feature = "trace")]
+                trace_excluded: cfg!(feature = "rtos-trace-selective"),
+                #[cfg(feature = "trace")]
                 all_tasks_next: AtomicPtr::new(core::ptr::null_mut()),
             },
             future: UninitCell::uninit(),

embassy-executor/src/raw/trace.rs

@@ -141,7 +141,7 @@ impl TaskTracker {
             }
         }
     }
-
+    
     /// Performs an operation on each task in the tracker
     ///
     /// This method traverses the entire list of tasks and calls the provided
@@ -181,6 +181,12 @@ pub trait TaskRefTrace {
 
     /// Set the ID for a task
     fn set_id(&self, id: u32);
+
+    /// Check if a task is excluded from tracing
+    fn is_trace_excluded(&self) -> bool;
+
+    /// Set whether a task should be excluded from tracing
+    fn set_trace_excluded(&self, excluded: bool);
 }
 
 impl TaskRefTrace for TaskRef {
@@ -205,6 +211,41 @@ impl TaskRefTrace for TaskRef {
             (*header_ptr).id = id;
         }
     }
+
+    fn is_trace_excluded(&self) -> bool {
+        self.header().trace_excluded
+    }
+
+    fn set_trace_excluded(&self, excluded: bool) {
+        unsafe {
+            let header_ptr = self.ptr.as_ptr() as *mut TaskHeader;
+            (*header_ptr).trace_excluded = excluded;
+        }
+    }
+}
+
+/// Helper function to determine if a task should be traced
+///
+/// This function supports two tracing modes based on feature flags:
+/// - `rtos-trace-selective`: Only trace tasks that are explicitly enabled for tracing
+/// - Default `rtos-trace`: Trace all tasks by default
+#[inline]
+fn should_trace_task(task: &TaskRef) -> bool {
+    #[cfg(feature = "rtos-trace-selective")]
+    {
+        // Only trace tasks that are explicitly enabled for tracing
+        !task.is_trace_excluded()
+    }
+    #[cfg(all(feature = "rtos-trace", not(feature = "rtos-trace-selective")))]
+    {
+        let _ = task; // Suppress unused parameter warning
+        true // Trace all tasks when rtos-trace feature is enabled without selective mode
+    }
+    #[cfg(not(feature = "rtos-trace"))]
+    {
+        let _ = task; // Suppress unused parameter warning
+        false // No tracing when rtos-trace is not enabled
+    }
 }
 
 #[cfg(not(feature = "rtos-trace"))]
@@ -283,10 +324,10 @@ 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);
+    if should_trace_task(task) {
+        rtos_trace::trace::task_new(task.as_ptr() as u32);
+        TASK_TRACKER.add(*task);
+    }
 }
 
 #[inline]
@@ -304,7 +345,9 @@ pub(crate) fn task_ready_begin(executor: &SyncExecutor, task: &TaskRef) {
         _embassy_trace_task_ready_begin(executor as *const _ as u32, task.as_ptr() as u32)
     }
     #[cfg(feature = "rtos-trace")]
-    rtos_trace::trace::task_ready_begin(task.as_ptr() as u32);
+    if should_trace_task(task) {
+        rtos_trace::trace::task_ready_begin(task.as_ptr() as u32);
+    }
 }
 
 #[inline]
@@ -314,7 +357,9 @@ pub(crate) fn task_exec_begin(executor: &SyncExecutor, task: &TaskRef) {
         _embassy_trace_task_exec_begin(executor as *const _ as u32, task.as_ptr() as u32)
     }
     #[cfg(feature = "rtos-trace")]
-    rtos_trace::trace::task_exec_begin(task.as_ptr() as u32);
+    if should_trace_task(task) {
+        rtos_trace::trace::task_exec_begin(task.as_ptr() as u32);
+    }
 }
 
 #[inline]
@@ -324,7 +369,9 @@ pub(crate) fn task_exec_end(executor: &SyncExecutor, task: &TaskRef) {
         _embassy_trace_task_exec_end(executor as *const _ as u32, task.as_ptr() as u32)
     }
     #[cfg(feature = "rtos-trace")]
-    rtos_trace::trace::task_exec_end();
+    if should_trace_task(task) {
+        rtos_trace::trace::task_exec_end();
+    }
 }
 
 #[inline]
@@ -384,14 +431,17 @@ where
 impl rtos_trace::RtosTraceOSCallbacks for crate::raw::SyncExecutor {
     fn task_list() {
         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.id(), info);
+            // Only send task info for tasks that should be traced
+            if should_trace_task(&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.id(), info);
+            }
         });
     }
     fn time() -> u64 {

embassy-executor/src/spawner.rs

@@ -184,8 +184,13 @@ 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.
+/// This trait provides additional methods to spawn tasks with tracing controls.
+///
+/// **Default workflow** (`rtos-trace` feature): All tasks are traced by default.
+/// You can use `spawn_no_trace()` methods to exclude specific tasks.
+///
+/// **Selective workflow** (`rtos-trace-selective` feature): No tasks are traced by default.
+/// You must use `spawn_with_trace()` methods to include specific tasks.
 pub trait SpawnerTraceExt {
     /// Spawns a new task with a specified name.
     ///
@@ -196,6 +201,50 @@ pub trait SpawnerTraceExt {
     /// # Returns
     /// Result indicating whether the spawn was successful
     fn spawn_named<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
+
+    /// Spawns a new task and explicitly enables it for tracing.
+    ///
+    /// **In default mode** (`rtos-trace`): This behaves the same as `spawn()` since all tasks are traced.
+    /// **In selective mode** (`rtos-trace-selective`): Only tasks spawned with this method will be traced.
+    ///
+    /// # Arguments
+    /// * `token` - Token representing the task to spawn
+    ///
+    /// # Returns
+    /// Result indicating whether the spawn was successful
+    fn spawn_with_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError>;
+
+    /// Spawns a new task with a name and explicitly enables it for tracing.
+    ///
+    /// # 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_with_trace<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
+
+    /// Spawns a new task and excludes it from tracing.
+    ///
+    /// **In default mode** (`rtos-trace`): Use this to exclude specific tasks from tracing.
+    /// **In selective mode** (`rtos-trace-selective`): This behaves the same as `spawn()` since tasks are excluded by default.
+    ///
+    /// # Arguments
+    /// * `token` - Token representing the task to spawn
+    ///
+    /// # Returns
+    /// Result indicating whether the spawn was successful
+    fn spawn_no_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError>;
+
+    /// Spawns a new task with a name but excludes it from tracing.
+    ///
+    /// # 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_no_trace<S>(&self, name: &'static str, token: SpawnToken<S>) -> Result<(), SpawnError>;
 }
 
 /// Implementation of the SpawnerTraceExt trait for Spawner when trace is enabled
@@ -212,6 +261,87 @@ impl SpawnerTraceExt for Spawner {
                 let task_id = task.as_ptr() as u32;
                 task.set_id(task_id);
 
+                // In selective mode, tasks are excluded by default (must use spawn_named_with_trace)
+                // In default mode, all tasks are traced
+                #[cfg(feature = "rtos-trace-selective")]
+                task.set_trace_excluded(true);
+                #[cfg(not(feature = "rtos-trace-selective"))]
+                task.set_trace_excluded(false);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+
+    fn spawn_with_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        let task = token.raw_task;
+        core::mem::forget(token);
+
+        match task {
+            Some(task) => {
+                // Explicitly enable tracing for this task
+                task.set_trace_excluded(false);
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+
+    fn spawn_named_with_trace<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 explicitly enable tracing
+                task.set_name(Some(name));
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+                task.set_trace_excluded(false);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+
+    fn spawn_no_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        let task = token.raw_task;
+        core::mem::forget(token);
+
+        match task {
+            Some(task) => {
+                // Explicitly exclude this task from tracing
+                task.set_trace_excluded(true);
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+
+                unsafe { self.executor.spawn(task) };
+                Ok(())
+            }
+            None => Err(SpawnError::Busy),
+        }
+    }
+
+    fn spawn_named_no_trace<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 but exclude from tracing
+                task.set_name(Some(name));
+                let task_id = task.as_ptr() as u32;
+                task.set_id(task_id);
+                task.set_trace_excluded(true);
+
                 unsafe { self.executor.spawn(task) };
                 Ok(())
             }
@@ -227,6 +357,26 @@ impl SpawnerTraceExt for Spawner {
         // When trace is disabled, just forward to regular spawn and ignore the name
         self.spawn(token)
     }
+
+    fn spawn_with_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        // When trace is disabled, just forward to regular spawn
+        self.spawn(token)
+    }
+
+    fn spawn_named_with_trace<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)
+    }
+
+    fn spawn_no_trace<S>(&self, token: SpawnToken<S>) -> Result<(), SpawnError> {
+        // When trace is disabled, just forward to regular spawn
+        self.spawn(token)
+    }
+
+    fn spawn_named_no_trace<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.