[tasklet] fix Unpost() behavior during tasklet processing (openthread#13039)

This commit fixes an issue where a tasklet could not be successfully
unposted if it was already scheduled for execution in the current
event loop iteration.

Previously, `Scheduler::ProcessQueuedTasklets()` copied and cleared the
queued tasklets before running them. If a running tasklet called
`Unpost()` on another tasklet that was also in the copied list, the
unpost operation would fail to remove it because it only checked the
main queue.

To address this, the `Scheduler` now explicitly maintains two separate
queues: `mPostedQueue` and `mRuningQueue`. The `Tasklet::Unpost()`
method is updated to remove the target tasklet from both queues,
ensuring it is correctly dequeued even if it is pending in the running
list.

The queue logic is encapsulated into a nested `Queue` class to manage
the circular singly linked-list operations cleanly. Additionally, unit
tests are expanded to cover scenarios where tasklets post or unpost
other tasklets during execution.

Author: abtink

src/core/common/tasklet.cpp

@@ -42,19 +42,17 @@ void Tasklet::Post(void)
 {
     if (!IsPosted())
     {
-        Get<Scheduler>().PostTasklet(*this);
+        Get<Scheduler>().mPostedQueue.PostTasklet(*this);
     }
 }
 
 void Tasklet::Unpost(void)
 {
-    if (IsPosted())
-    {
-        Get<Scheduler>().RemoveTasklet(*this);
-    }
+    Get<Scheduler>().mPostedQueue.RemoveTasklet(*this);
+    Get<Scheduler>().mRunningQueue.RemoveTasklet(*this);
 }
 
-void Tasklet::Scheduler::PostTasklet(Tasklet &aTasklet)
+void Tasklet::Scheduler::Queue::PostTasklet(Tasklet &aTasklet)
 {
     // Tasklets are saved in a circular singly linked list.
 
@@ -72,13 +70,24 @@ void Tasklet::Scheduler::PostTasklet(Tasklet &aTasklet)
     }
 }
 
-void Tasklet::Scheduler::RemoveTasklet(Tasklet &aTasklet)
+void Tasklet::Scheduler::Queue::RemoveTasklet(Tasklet &aTasklet)
 {
-    Tasklet *prev = mTail;
+    Tasklet *prev;
+
+    VerifyOrExit(aTasklet.IsPosted());
+
+    VerifyOrExit(!IsEmpty());
+
+    prev = mTail;
 
     while (prev->mNext != &aTasklet)
     {
         prev = prev->mNext;
+
+        if (prev == mTail)
+        {
+            ExitNow();
+        }
     }
 
     prev->mNext    = aTasklet.mNext;
@@ -88,34 +97,42 @@ void Tasklet::Scheduler::RemoveTasklet(Tasklet &aTasklet)
     {
         mTail = (prev != &aTasklet) ? prev : nullptr;
     }
+
+exit:
+    return;
 }
 
-void Tasklet::Scheduler::ProcessQueuedTasklets(void)
+Tasklet *Tasklet::Scheduler::Queue::PopTasklet(void)
 {
-    Tasklet *tail = mTail;
+    Tasklet *tasklet;
 
-    // This method processes all tasklets queued when this is called. We
-    // keep a copy the current list and then clear the main list by
-    // setting `mTail` to `nullptr`. A newly posted tasklet while
-    // processing the currently queued tasklets will then trigger a call
-    // to `otTaskletsSignalPending()`.
+    if (IsEmpty())
+    {
+        tasklet = nullptr;
+    }
+    else
+    {
+        tasklet = mTail->mNext;
+        RemoveTasklet(*tasklet);
+    }
 
-    mTail = nullptr;
+    return tasklet;
+}
 
-    while (tail != nullptr)
-    {
-        Tasklet *tasklet = tail->mNext;
+void Tasklet::Scheduler::ProcessQueuedTasklets(void)
+{
+    Tasklet *tasklet;
 
-        if (tasklet == tail)
-        {
-            tail = nullptr;
-        }
-        else
-        {
-            tail->mNext = tasklet->mNext;
-        }
+    // We transfer all currently posted tasklets to the `mRunningQueue` and
+    // clear the `mPostedQueue`. This ensures that any new tasklet posted
+    // while we are processing `mRunningQueue` will be added to `mPostedQueue`
+    // and will trigger a call to `otTaskletsSignalPending()`.
+
+    mRunningQueue = mPostedQueue;
+    mPostedQueue.Clear();
 
-        tasklet->mNext = nullptr;
+    while ((tasklet = mRunningQueue.PopTasklet()) != nullptr)
+    {
         tasklet->RunTask();
     }
 }

src/core/common/tasklet.hpp

@@ -68,32 +68,40 @@ class Tasklet : public InstanceLocator
         friend class Tasklet;
 
     public:
-        /**
-         * Initializes the object.
-         */
-        Scheduler(void)
-            : mTail(nullptr)
-        {
-        }
-
         /**
          * Indicates whether or not there are tasklets pending.
          *
          * @retval TRUE   If there are tasklets pending.
          * @retval FALSE  If there are no tasklets pending.
          */
-        bool AreTaskletsPending(void) const { return mTail != nullptr; }
+        bool AreTaskletsPending(void) const { return !mPostedQueue.IsEmpty(); }
 
         /**
          * Processes all tasklets queued when this is called.
          */
         void ProcessQueuedTasklets(void);
 
     private:
-        void PostTasklet(Tasklet &aTasklet);
-        void RemoveTasklet(Tasklet &aTasklet);
-
-        Tasklet *mTail; // A circular singly linked-list
+        class Queue // A circular singly linked-list
+        {
+        public:
+            Queue(void)
+                : mTail(nullptr)
+            {
+            }
+
+            void     Clear(void) { mTail = nullptr; }
+            bool     IsEmpty(void) const { return (mTail == nullptr); }
+            void     PostTasklet(Tasklet &aTasklet);
+            void     RemoveTasklet(Tasklet &aTasklet);
+            Tasklet *PopTasklet(void);
+
+        private:
+            Tasklet *mTail;
+        };
+
+        Queue mPostedQueue;
+        Queue mRunningQueue;
     };
 
     /**