zephyr: work: Fix lifetimes of submitted work

Using the return code from submitting work, distinguish the cases where
work is actually submitted vs those where the work was not submitted
(either "already submitted" or an error).  If it was not submitted, turn
the value back into an Arc, so that it can be properly dropped.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr/src/work.rs

@@ -526,11 +526,15 @@ impl<T: SimpleAction + Send> Work<T> {
         // SAFETY: C the code does not perform moves on the data, and the `from_raw` below puts it
         // back into a Pin when it reconstructs the Arc.
         let this = unsafe { Pin::into_inner_unchecked(this) };
-        let _ = Arc::into_raw(this);
+        let _ = Arc::into_raw(this.clone());
 
         // SAFETY: The Pin ensures this will not move.  Our implementation of drop ensures that the
         // work item is no longer queued when the data is dropped.
-        SubmitResult::to_result(unsafe { k_work_submit(work) })
+        let result = SubmitResult::to_result(unsafe { k_work_submit(work) });
+
+        Self::check_drop(work, &result);
+
+        result
     }
 
     /// Submit this work to a specified work queue.
@@ -550,7 +554,11 @@ impl<T: SimpleAction + Send> Work<T> {
 
         // SAFETY: The Pin ensures this will not move.  Our implementation of drop ensures that the
         // work item is no longer queued when the data is dropped.
-        SubmitResult::to_result(unsafe { k_work_submit_to_queue(queue.item.get(), work) })
+        let result = SubmitResult::to_result(unsafe { k_work_submit_to_queue(queue.item.get(), work) });
+
+        Self::check_drop(work, &result);
+
+        result
     }
 
     /// Callback, through C, but bound by a specific type.
@@ -590,6 +598,20 @@ impl<T: SimpleAction + Send> Work<T> {
         Pin::new_unchecked(this)
     }
 
+    /// Determine if this work was submitted, and cause a drop of the Arc to happen if it was not.
+    pub fn check_drop(work: *const k_work, result: &crate::Result<SubmitResult>) {
+        if matches!(result, Ok(SubmitResult::AlreadySubmitted) | Err(_)) {
+            // SAFETY: If the above submit indicates that it was already running, the work will not
+            // be submitted (no additional handle will be called).  "un leak" the work so that it
+            // will be dropped.  Also, any error indicates that the work did not enqueue.
+            unsafe {
+                let this = Self::from_raw(work);
+                drop(this);
+            }
+        }
+
+    }
+
     /// Access the inner action.
     pub fn action(&self) -> &T {
         &self.action