critical.c

 
#include <winpr/config.h>
 
#include <winpr/assert.h>
#include <winpr/tchar.h>
#include <winpr/synch.h>
#include <winpr/sysinfo.h>
#include <winpr/interlocked.h>
#include <winpr/thread.h>
 
#include "synch.h"
 
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#if defined(__APPLE__)
#include <mach/task.h>
#include <mach/mach.h>
#include <mach/semaphore.h>
#endif
 
#ifndef _WIN32
 
#include "../log.h"
#define TAG WINPR_TAG("synch.critical")
 
VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  if (!InitializeCriticalSectionEx(lpCriticalSection, 0, 0))
    WLog_ERR(TAG, "InitializeCriticalSectionEx failed");
}
 
BOOL InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount,
                                 DWORD Flags)
{
  WINPR_ASSERT(lpCriticalSection);
  if (Flags != 0)
  {
    WLog_WARN(TAG, "Flags unimplemented");
  }
 
  lpCriticalSection->DebugInfo = nullptr;
  lpCriticalSection->LockCount = -1;
  lpCriticalSection->SpinCount = 0;
  lpCriticalSection->RecursionCount = 0;
  lpCriticalSection->OwningThread = nullptr;
  lpCriticalSection->LockSemaphore = (winpr_sem_t*)malloc(sizeof(winpr_sem_t));
 
  if (!lpCriticalSection->LockSemaphore)
    return FALSE;
 
#if defined(__APPLE__)
 
  if (semaphore_create(mach_task_self(), lpCriticalSection->LockSemaphore, SYNC_POLICY_FIFO, 0) !=
      KERN_SUCCESS)
    goto out_fail;
 
#else
 
  if (sem_init(lpCriticalSection->LockSemaphore, 0, 0) != 0)
    goto out_fail;
 
#endif
  SetCriticalSectionSpinCount(lpCriticalSection, dwSpinCount);
  return TRUE;
out_fail:
  free(lpCriticalSection->LockSemaphore);
  return FALSE;
}
 
BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount)
{
  return InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, 0);
}
 
DWORD SetCriticalSectionSpinCount(WINPR_ATTR_UNUSED LPCRITICAL_SECTION lpCriticalSection,
                                  WINPR_ATTR_UNUSED DWORD dwSpinCount)
{
  WINPR_ASSERT(lpCriticalSection);
#if !defined(WINPR_CRITICAL_SECTION_DISABLE_SPINCOUNT)
  SYSTEM_INFO sysinfo;
  DWORD dwPreviousSpinCount = lpCriticalSection->SpinCount;
 
  if (dwSpinCount)
  {
    /* Don't spin on uniprocessor systems! */
    GetNativeSystemInfo(&sysinfo);
 
    if (sysinfo.dwNumberOfProcessors < 2)
      dwSpinCount = 0;
  }
 
  lpCriticalSection->SpinCount = dwSpinCount;
  return dwPreviousSpinCount;
#else
  // WLog_ERR("TODO", "TODO: implement");
  return 0;
#endif
}
 
static VOID WaitForCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  WINPR_ASSERT(lpCriticalSection);
  WINPR_ASSERT(lpCriticalSection->LockSemaphore);
 
#if defined(__APPLE__)
  semaphore_wait(*((winpr_sem_t*)lpCriticalSection->LockSemaphore));
#else
  sem_wait((winpr_sem_t*)lpCriticalSection->LockSemaphore);
#endif
}
 
static VOID UnWaitCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  WINPR_ASSERT(lpCriticalSection);
  WINPR_ASSERT(lpCriticalSection->LockSemaphore);
#if defined __APPLE__
  semaphore_signal(*((winpr_sem_t*)lpCriticalSection->LockSemaphore));
#else
  sem_post((winpr_sem_t*)lpCriticalSection->LockSemaphore);
#endif
}
 
VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  WINPR_ASSERT(lpCriticalSection);
#if !defined(WINPR_CRITICAL_SECTION_DISABLE_SPINCOUNT)
  ULONG SpinCount = lpCriticalSection->SpinCount;
 
  /* If we're lucky or if the current thread is already owner we can return early */
  if (SpinCount && TryEnterCriticalSection(lpCriticalSection))
    return;
 
  /* Spin requested times but don't compete with another waiting thread */
  while (SpinCount-- && lpCriticalSection->LockCount < 1)
  {
    /* Atomically try to acquire and check the if the section is free. */
    if (InterlockedCompareExchange(&lpCriticalSection->LockCount, 0, -1) == -1)
    {
      lpCriticalSection->RecursionCount = 1;
      lpCriticalSection->OwningThread = (HANDLE)(ULONG_PTR)GetCurrentThreadId();
      return;
    }
 
    /* Failed to get the lock. Let the scheduler know that we're spinning. */
    if (sched_yield() != 0)
    {
      usleep(1);
    }
  }
 
#endif
 
  /* First try the fastest possible path to get the lock. */
  if (InterlockedIncrement(&lpCriticalSection->LockCount))
  {
    /* Section is already locked. Check if it is owned by the current thread. */
    if (lpCriticalSection->OwningThread == (HANDLE)(ULONG_PTR)GetCurrentThreadId())
    {
      /* Recursion. No need to wait. */
      lpCriticalSection->RecursionCount++;
      return;
    }
 
    /* Section is locked by another thread. We have to wait. */
    WaitForCriticalSection(lpCriticalSection);
  }
 
  /* We got the lock. Own it ... */
  lpCriticalSection->RecursionCount = 1;
  lpCriticalSection->OwningThread = (HANDLE)(ULONG_PTR)GetCurrentThreadId();
}
 
BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  HANDLE current_thread = (HANDLE)(ULONG_PTR)GetCurrentThreadId();
 
  WINPR_ASSERT(lpCriticalSection);
 
  /* Atomically acquire the the lock if the section is free. */
  if (InterlockedCompareExchange(&lpCriticalSection->LockCount, 0, -1) == -1)
  {
    lpCriticalSection->RecursionCount = 1;
    lpCriticalSection->OwningThread = current_thread;
    return TRUE;
  }
 
  /* Section is already locked. Check if it is owned by the current thread. */
  if (lpCriticalSection->OwningThread == current_thread)
  {
    /* Recursion, return success */
    lpCriticalSection->RecursionCount++;
    InterlockedIncrement(&lpCriticalSection->LockCount);
    return TRUE;
  }
 
  return FALSE;
}
 
VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  WINPR_ASSERT(lpCriticalSection);
 
  /* Decrement RecursionCount and check if this is the last LeaveCriticalSection call ...*/
  if (--lpCriticalSection->RecursionCount < 1)
  {
    /* Last recursion, clear owner, unlock and if there are other waiting threads ... */
    lpCriticalSection->OwningThread = nullptr;
 
    if (InterlockedDecrement(&lpCriticalSection->LockCount) >= 0)
    {
      /* ...signal the semaphore to unblock the next waiting thread */
      UnWaitCriticalSection(lpCriticalSection);
    }
  }
  else
  {
    (void)InterlockedDecrement(&lpCriticalSection->LockCount);
  }
}
 
VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
  WINPR_ASSERT(lpCriticalSection);
 
  lpCriticalSection->LockCount = -1;
  lpCriticalSection->SpinCount = 0;
  lpCriticalSection->RecursionCount = 0;
  lpCriticalSection->OwningThread = nullptr;
 
  if (lpCriticalSection->LockSemaphore != nullptr)
  {
#if defined __APPLE__
    semaphore_destroy(mach_task_self(), *((winpr_sem_t*)lpCriticalSection->LockSemaphore));
#else
    sem_destroy((winpr_sem_t*)lpCriticalSection->LockSemaphore);
#endif
    free(lpCriticalSection->LockSemaphore);
    lpCriticalSection->LockSemaphore = nullptr;
  }
}
 
#endif