Add background event handling for CASE establish

examples/platform/esp32/common/CHIPDeviceManager.cpp

@@ -79,6 +79,9 @@ CHIP_ERROR CHIPDeviceManager::Init(CHIPDeviceManagerCallbacks * cb)
     // this function will happen on the CHIP event loop thread, not the app_main thread.
     PlatformMgr().AddEventHandler(CHIPDeviceManager::CommonDeviceEventHandler, reinterpret_cast<intptr_t>(cb));
 
+    // Start a task to run the CHIP Device background event loop.
+    ReturnErrorOnFailure(PlatformMgr().StartBackgroundEventLoopTask());
+
     // Start a task to run the CHIP Device event loop.
     return PlatformMgr().StartEventLoopTask();
 }

src/credentials/FabricTable.cpp

@@ -28,6 +28,7 @@
 #include <lib/support/DefaultStorageKeyAllocator.h>
 #include <lib/support/SafeInt.h>
 #include <lib/support/ScopedBuffer.h>
+#include <platform/LockTracker.h>
 
 namespace chip {
 using namespace Credentials;
@@ -342,6 +343,7 @@ CHIP_ERROR FabricTable::VerifyCredentials(FabricIndex fabricIndex, const ByteSpa
                                           FabricId & outFabricId, NodeId & outNodeId, Crypto::P256PublicKey & outNocPubkey,
                                           Crypto::P256PublicKey * outRootPublicKey) const
 {
+    assertChipStackLockedByCurrentThread();
     uint8_t rootCertBuf[kMaxCHIPCertLength];
     MutableByteSpan rootCertSpan{ rootCertBuf };
     ReturnErrorOnFailure(FetchRootCert(fabricIndex, rootCertSpan));

src/credentials/FabricTable.h

@@ -912,13 +912,17 @@ class DLL_EXPORT FabricTable
      */
     void RevertPendingOpCertsExceptRoot();
 
-    // Verifies credentials, with the fabric's root under fabricIndex, and extract critical bits.
-    // This call is used for CASE.
+    // Verifies credentials, using the root certificate of the provided fabric index.
     CHIP_ERROR VerifyCredentials(FabricIndex fabricIndex, const ByteSpan & noc, const ByteSpan & icac,
                                  Credentials::ValidationContext & context, CompressedFabricId & outCompressedFabricId,
                                  FabricId & outFabricId, NodeId & outNodeId, Crypto::P256PublicKey & outNocPubkey,
                                  Crypto::P256PublicKey * outRootPublicKey = nullptr) const;
 
+    // Verifies credentials, using the provided root certificate.
+    static CHIP_ERROR VerifyCredentials(const ByteSpan & noc, const ByteSpan & icac, const ByteSpan & rcac,
+                                        Credentials::ValidationContext & context, CompressedFabricId & outCompressedFabricId,
+                                        FabricId & outFabricId, NodeId & outNodeId, Crypto::P256PublicKey & outNocPubkey,
+                                        Crypto::P256PublicKey * outRootPublicKey = nullptr);
     /**
      * @brief Enables FabricInfo instances to collide and reference the same logical fabric (i.e Root Public Key + FabricId).
      *
@@ -1093,13 +1097,6 @@ class DLL_EXPORT FabricTable
             mStateFlags.HasAll(StateFlags::kIsPendingFabricDataPresent, StateFlags::kIsUpdatePending);
     }
 
-    // Verifies credentials, using the provided root certificate.
-    // This call is done whenever a fabric is "directly" added
-    static CHIP_ERROR VerifyCredentials(const ByteSpan & noc, const ByteSpan & icac, const ByteSpan & rcac,
-                                        Credentials::ValidationContext & context, CompressedFabricId & outCompressedFabricId,
-                                        FabricId & outFabricId, NodeId & outNodeId, Crypto::P256PublicKey & outNocPubkey,
-                                        Crypto::P256PublicKey * outRootPublicKey);
-
     // Validate an NOC chain at time of adding/updating a fabric (uses VerifyCredentials with additional checks).
     // The `existingFabricId` is passed for UpdateNOC, and must match the Fabric, to make sure that we are
     // not trying to change FabricID with UpdateNOC. If set to kUndefinedFabricId, we are doing AddNOC and

src/include/platform/CHIPDeviceConfig.h

@@ -79,7 +79,7 @@
  * The priority of the chip task.
  */
 #ifndef CHIP_DEVICE_CONFIG_CHIP_TASK_PRIORITY
-#define CHIP_DEVICE_CONFIG_CHIP_TASK_PRIORITY 1
+#define CHIP_DEVICE_CONFIG_CHIP_TASK_PRIORITY 2
 #endif
 
 /**
@@ -91,6 +91,51 @@
 #define CHIP_DEVICE_CONFIG_MAX_EVENT_QUEUE_SIZE 100
 #endif
 
+/**
+ * CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
+ *
+ * Enable support for background event processing.
+ */
+#ifndef CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
+#define CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING 0
+#endif
+
+/**
+ * CHIP_DEVICE_CONFIG_BG_TASK_NAME
+ *
+ * The name of the background task.
+ */
+#ifndef CHIP_DEVICE_CONFIG_BG_TASK_NAME
+#define CHIP_DEVICE_CONFIG_BG_TASK_NAME "BG"
+#endif
+
+/**
+ * CHIP_DEVICE_CONFIG_BG_TASK_STACK_SIZE
+ *
+ * The size (in bytes) of the background task stack.
+ */
+#ifndef CHIP_DEVICE_CONFIG_BG_TASK_STACK_SIZE
+#define CHIP_DEVICE_CONFIG_BG_TASK_STACK_SIZE (6 * 1024)
+#endif
+
+/**
+ * CHIP_DEVICE_CONFIG_BG_TASK_PRIORITY
+ *
+ * The priority of the background task.
+ */
+#ifndef CHIP_DEVICE_CONFIG_BG_TASK_PRIORITY
+#define CHIP_DEVICE_CONFIG_BG_TASK_PRIORITY 1
+#endif
+
+/**
+ * CHIP_DEVICE_CONFIG_BG_MAX_EVENT_QUEUE_SIZE
+ *
+ * The maximum number of events that can be held in the chip background event queue.
+ */
+#ifndef CHIP_DEVICE_CONFIG_BG_MAX_EVENT_QUEUE_SIZE
+#define CHIP_DEVICE_CONFIG_BG_MAX_EVENT_QUEUE_SIZE 1
+#endif
+
 /**
  * CHIP_DEVICE_CONFIG_ENABLE_SED
  *
@@ -648,7 +693,7 @@
  * The priority of the OpenThread task.
  */
 #ifndef CHIP_DEVICE_CONFIG_THREAD_TASK_PRIORITY
-#define CHIP_DEVICE_CONFIG_THREAD_TASK_PRIORITY 2
+#define CHIP_DEVICE_CONFIG_THREAD_TASK_PRIORITY 3
 #endif
 
 /**

src/include/platform/CHIPDeviceLayer.h

@@ -41,7 +41,7 @@
 namespace chip {
 namespace DeviceLayer {
 
-void SetSystemLayerForTesting(System::LayerImpl * layer);
+void SetSystemLayerForTesting(System::Layer * layer);
 
 // These functions are defined in src/platform/Globals.cpp
 chip::System::Layer & SystemLayer();

src/include/platform/PlatformManager.h

@@ -109,6 +109,7 @@ class PlatformManager
      * other.
      */
     CHIP_ERROR InitChipStack();
+
     CHIP_ERROR AddEventHandler(EventHandlerFunct handler, intptr_t arg = 0);
     void RemoveEventHandler(EventHandlerFunct handler, intptr_t arg = 0);
     void SetDelegate(PlatformManagerDelegate * delegate) { mDelegate = delegate; }
@@ -137,7 +138,7 @@ class PlatformManager
      * processing, the callback function may be called (on the work item
      * processing thread) before ScheduleWork returns.
      */
-    void ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg = 0);
+    CHIP_ERROR ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg = 0);
 
     /**
      * Process work items until StopEventLoopTask is called.  RunEventLoop will
@@ -183,6 +184,7 @@ class PlatformManager
      * returns.
      */
     CHIP_ERROR StopEventLoopTask();
+
     void LockChipStack();
     bool TryLockChipStack();
     void UnlockChipStack();
@@ -201,6 +203,47 @@ class PlatformManager
     [[nodiscard]] CHIP_ERROR PostEvent(const ChipDeviceEvent * event);
     void PostEventOrDie(const ChipDeviceEvent * event);
 
+    /**
+     * Generally this function has the same semantics as ScheduleWork
+     * except it applies to background processing.
+     *
+     * Delegates to PostBackgroundEvent (which will delegate to PostEvent if
+     * CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING is not true).
+     */
+    CHIP_ERROR ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg = 0);
+
+    /**
+     * Generally this function has the same semantics as PostEvent
+     * except it applies to background processing.
+     *
+     * If CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING is not true, will delegate
+     * to PostEvent.
+     *
+     * Only accepts events of type kCallWorkFunct or kNoOp.
+     *
+     * Returns CHIP_ERROR_INVALID_ARGUMENT if the event type is not acceptable.
+     * Returns CHIP_ERROR_NO_MEMORY if resources are exhausted.
+     */
+    CHIP_ERROR PostBackgroundEvent(const ChipDeviceEvent * event);
+
+    /**
+     * Generally this function has the same semantics as RunEventLoop
+     * except it applies to background processing.
+     */
+    void RunBackgroundEventLoop();
+
+    /**
+     * Generally this function has the same semantics as StartEventLoopTask
+     * except it applies to background processing.
+     */
+    CHIP_ERROR StartBackgroundEventLoopTask();
+
+    /**
+     * Generally this function has the same semantics as StopEventLoopTask
+     * except it applies to background processing.
+     */
+    CHIP_ERROR StopBackgroundEventLoopTask();
+
 private:
     bool mInitialized                   = false;
     PlatformManagerDelegate * mDelegate = nullptr;
@@ -352,9 +395,9 @@ inline void PlatformManager::HandleServerShuttingDown()
     static_cast<ImplClass *>(this)->_HandleServerShuttingDown();
 }
 
-inline void PlatformManager::ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg)
+inline CHIP_ERROR PlatformManager::ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg)
 {
-    static_cast<ImplClass *>(this)->_ScheduleWork(workFunct, arg);
+    return static_cast<ImplClass *>(this)->_ScheduleWork(workFunct, arg);
 }
 
 inline void PlatformManager::RunEventLoop()
@@ -432,6 +475,31 @@ inline void PlatformManager::PostEventOrDie(const ChipDeviceEvent * event)
                        static_cast<int>(event->Type), status.Format());
 }
 
+inline CHIP_ERROR PlatformManager::ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg)
+{
+    return static_cast<ImplClass *>(this)->_ScheduleBackgroundWork(workFunct, arg);
+}
+
+inline CHIP_ERROR PlatformManager::PostBackgroundEvent(const ChipDeviceEvent * event)
+{
+    return static_cast<ImplClass *>(this)->_PostBackgroundEvent(event);
+}
+
+inline void PlatformManager::RunBackgroundEventLoop()
+{
+    static_cast<ImplClass *>(this)->_RunBackgroundEventLoop();
+}
+
+inline CHIP_ERROR PlatformManager::StartBackgroundEventLoopTask()
+{
+    return static_cast<ImplClass *>(this)->_StartBackgroundEventLoopTask();
+}
+
+inline CHIP_ERROR PlatformManager::StopBackgroundEventLoopTask()
+{
+    return static_cast<ImplClass *>(this)->_StopBackgroundEventLoopTask();
+}
+
 inline void PlatformManager::DispatchEvent(const ChipDeviceEvent * event)
 {
     static_cast<ImplClass *>(this)->_DispatchEvent(event);

src/include/platform/internal/GenericPlatformManagerImpl.h

@@ -57,7 +57,12 @@ class GenericPlatformManagerImpl
     void _RemoveEventHandler(PlatformManager::EventHandlerFunct handler, intptr_t arg);
     void _HandleServerStarted();
     void _HandleServerShuttingDown();
-    void _ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg);
+    CHIP_ERROR _ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg);
+    CHIP_ERROR _ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg);
+    CHIP_ERROR _PostBackgroundEvent(const ChipDeviceEvent * event);
+    void _RunBackgroundEventLoop(void);
+    CHIP_ERROR _StartBackgroundEventLoopTask(void);
+    CHIP_ERROR _StopBackgroundEventLoopTask();
     void _DispatchEvent(const ChipDeviceEvent * event);
 
     // ===== Support methods that can be overridden by the implementation subclass.

src/include/platform/internal/GenericPlatformManagerImpl.ipp

@@ -216,18 +216,56 @@ void GenericPlatformManagerImpl<ImplClass>::_HandleServerShuttingDown()
 }
 
 template <class ImplClass>
-void GenericPlatformManagerImpl<ImplClass>::_ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg)
+CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg)
 {
-    ChipDeviceEvent event;
-    event.Type                    = DeviceEventType::kCallWorkFunct;
-    event.CallWorkFunct.WorkFunct = workFunct;
-    event.CallWorkFunct.Arg       = arg;
+    ChipDeviceEvent event{ .Type = DeviceEventType::kCallWorkFunct };
+    event.CallWorkFunct = { .WorkFunct = workFunct, .Arg = arg };
+    CHIP_ERROR err      = Impl()->PostEvent(&event);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "Failed to schedule work: %" CHIP_ERROR_FORMAT, err.Format());
+    }
+    return err;
+}
 
-    CHIP_ERROR status = Impl()->PostEvent(&event);
-    if (status != CHIP_NO_ERROR)
+template <class ImplClass>
+CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg)
+{
+    ChipDeviceEvent event{ .Type = DeviceEventType::kCallWorkFunct };
+    event.CallWorkFunct = { .WorkFunct = workFunct, .Arg = arg };
+    CHIP_ERROR err      = Impl()->PostBackgroundEvent(&event);
+    if (err != CHIP_NO_ERROR)
     {
-        ChipLogError(DeviceLayer, "Failed to schedule work: %" CHIP_ERROR_FORMAT, status.Format());
+        ChipLogError(DeviceLayer, "Failed to schedule background work: %" CHIP_ERROR_FORMAT, err.Format());
     }
+    return err;
+}
+
+template <class ImplClass>
+CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_PostBackgroundEvent(const ChipDeviceEvent * event)
+{
+    // Impl class must override to implement background event processing
+    return Impl()->PostEvent(event);
+}
+
+template <class ImplClass>
+void GenericPlatformManagerImpl<ImplClass>::_RunBackgroundEventLoop(void)
+{
+    // Impl class must override to implement background event processing
+}
+
+template <class ImplClass>
+CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_StartBackgroundEventLoopTask(void)
+{
+    // Impl class must override to implement background event processing
+    return CHIP_NO_ERROR;
+}
+
+template <class ImplClass>
+CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_StopBackgroundEventLoopTask(void)
+{
+    // Impl class must override to implement background event processing
+    return CHIP_NO_ERROR;
 }
 
 template <class ImplClass>

src/include/platform/internal/GenericPlatformManagerImpl_FreeRTOS.h

@@ -65,12 +65,19 @@ class GenericPlatformManagerImpl_FreeRTOS : public GenericPlatformManagerImpl<Im
     TaskHandle_t mEventLoopTask      = NULL;
     bool mChipTimerActive;
 
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
+    QueueHandle_t mBackgroundEventQueue   = NULL;
+    TaskHandle_t mBackgroundEventLoopTask = NULL;
+#endif
+
     // ===== Methods that implement the PlatformManager abstract interface.
 
     CHIP_ERROR _InitChipStack();
+
     void _LockChipStack(void);
     bool _TryLockChipStack(void);
     void _UnlockChipStack(void);
+
     CHIP_ERROR _PostEvent(const ChipDeviceEvent * event);
     void _RunEventLoop(void);
     CHIP_ERROR _StartEventLoopTask(void);
@@ -80,7 +87,12 @@ class GenericPlatformManagerImpl_FreeRTOS : public GenericPlatformManagerImpl<Im
 
 #if CHIP_STACK_LOCK_TRACKING_ENABLED
     bool _IsChipStackLockedByCurrentThread() const;
-#endif // CHIP_STACK_LOCK_TRACKING_ENABLED
+#endif
+
+    CHIP_ERROR _PostBackgroundEvent(const ChipDeviceEvent * event);
+    void _RunBackgroundEventLoop(void);
+    CHIP_ERROR _StartBackgroundEventLoopTask(void);
+    CHIP_ERROR _StopBackgroundEventLoopTask();
 
     // ===== Methods available to the implementation subclass.
 
@@ -97,11 +109,26 @@ class GenericPlatformManagerImpl_FreeRTOS : public GenericPlatformManagerImpl<Im
     uint8_t mEventQueueBuffer[CHIP_DEVICE_CONFIG_MAX_EVENT_QUEUE_SIZE * sizeof(ChipDeviceEvent)];
     StaticQueue_t mEventQueueStruct;
 #endif
+#if defined(CHIP_CONFIG_FREERTOS_USE_STATIC_TASK) && CHIP_CONFIG_FREERTOS_USE_STATIC_TASK
+    StackType_t mEventLoopStack[CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE / sizeof(StackType_t)];
+    StaticTask_t mEventLoopTaskStruct;
+#endif
 
     std::atomic<bool> mShouldRunEventLoop;
+
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
+    static void BackgroundEventLoopTaskMain(void * arg);
+
+#if defined(CHIP_CONFIG_FREERTOS_USE_STATIC_QUEUE) && CHIP_CONFIG_FREERTOS_USE_STATIC_QUEUE
+    uint8_t mBackgroundQueueBuffer[CHIP_DEVICE_CONFIG_BG_MAX_EVENT_QUEUE_SIZE * sizeof(ChipDeviceEvent)];
+    StaticQueue_t mBackgroundQueueStruct;
+#endif
 #if defined(CHIP_CONFIG_FREERTOS_USE_STATIC_TASK) && CHIP_CONFIG_FREERTOS_USE_STATIC_TASK
-    StackType_t mEventLoopStack[CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE / sizeof(StackType_t)];
-    StaticTask_t mventLoopTaskStruct;
+    StackType_t mBackgroundEventLoopStack[CHIP_DEVICE_CONFIG_BG_TASK_STACK_SIZE / sizeof(StackType_t)];
+    StaticTask_t mBackgroundEventLoopTaskStruct;
+#endif
+
+    std::atomic<bool> mShouldRunBackgroundEventLoop;
 #endif
 
 #if defined(CHIP_CONFIG_FREERTOS_USE_STATIC_SEMAPHORE) && CHIP_CONFIG_FREERTOS_USE_STATIC_SEMAPHORE