Recursive locking mechanism with timeout

So I figured this one out on my own. I found this forum which helped me clear some explanations that were misleading about binary semaphores.

Here's the general idea behind my solution:

• I use a global variable that stores the task handle of the "current" owner
• I use a GateMutex to access (read & write) the current owner variable
• I use a semaphore with pend (this allows me to use a timeout)
• The semaphore is a binary semaphore in PRIORITY mode (the highest priority task will be given ownership first

Here is the sample code (Note: this has not been thoroughly tested, but should give an idea on how it's done).

// Function to take ownership
bool OwnershipTake(uint32 timeoutTicks)
{
   Task_Handle currentOwner;
   Task_Handle selfHandle = Task_self();
   
   // Copy protected variable
   IArg key = GateMutexPri_enter(someGateMutex);
   {
      currentOwner = mCurrentOwner;
   }
   GateMutexPri_leave(someGateMutex, key);
   
   // Check who is the owner
   if (currentOwner == selfHandle)
   {
      // We are already the owner
      return TRUE;
   }
   else
   {      
      // Pend on semaphore for ownership
      if (Semaphore_pend(ownerSemaphore, timeoutTicks))
      {
         // Take ownership
         key = GateMutexPri_enter(someGateMutex);
         {
            mCurrentOwner = selfHandle;
         }
         GateMutexPri_leave(someGateMutex, key);
         return TRUE;
      }
      else
      {
         // We timed out.
         return FALSE;
      }
   }
}

// Function to release ownership
bool OwnershipRelease(void)
{
   Task_Handle currentOwner;
   Task_Handle selfHandle = Task_self();
   
   // Copy protected variable
   IArg key = GateMutexPri_enter(someGateMutex);
   {
      currentOwner = mCurrentOwner;
   }
   GateMutexPri_leave(someGateMutex, key);
   
   // Check who is the owner
   if (currentOwner != selfHandle)
   {
      // Could already be released or another task has the ownership
      return FALSE;
   }
   else
   {
      // Release ownership
      IArg key = GateMutexPri_enter(someGateMutex);
      {
         mCurrentOwner = NULL;
         Semaphore_post(ownerSemaphore);
      }
      GateMutexPri_leave(someGateMutex, key);
      return TRUE;
   }
}

//Pseudo-code when accessing the protected resource
 Task_Handle currentOwner;
 Task_Handle selfHandle = Task_self();  
  
 // Copy protected variable
 IArg key = GateMutexPri_enter(someGateMutex);
 {
   currentOwner = mCurrentOwner;
 }
 GateMutexPri_leave(someGateMutex, key);
   
 // Check who is the owner
 if (currentOwner != selfHandle)
 {
   // Task is not current owner. Wait on semaphore
   if (Semaphore_pend(ownerSemaphore, timeoutTicks))
   {

     //
     // Access the protected resource here
     //

     // Semaphore was taken so we need to post back to it
     Semaphore_post(ownerSemaphore);
   }
   return;
 }
 else
 {
   // Current task is the owner. We write directly to resource (pending on semaphore would result in deadlock)

   //
   // Access the protected resource here
   //

}

Hope this helps others

If there is a Module that can already do that, it would be great.

Michel