SynchronizationGcc.c

Go to the documentation of this file.

 
#include "BaseSynchronizationLibInternals.h"
 
//
// GCC inline assembly for Read Write Barrier
//
#define _ReadWriteBarrier()  do { __asm__ __volatile__ ("": : : "memory"); } while(0)
 
#define SPIN_LOCK_RELEASED  ((UINTN) 1)
#define SPIN_LOCK_ACQUIRED  ((UINTN) 2)
 
UINTN
EFIAPI
GetSpinLockProperties (
  VOID
  )
{
  return InternalGetSpinLockProperties ();
}
 
SPIN_LOCK *
EFIAPI
InitializeSpinLock (
  OUT      SPIN_LOCK  *SpinLock
  )
{
  ASSERT (SpinLock != NULL);
 
  _ReadWriteBarrier ();
  *SpinLock = SPIN_LOCK_RELEASED;
  _ReadWriteBarrier ();
 
  return SpinLock;
}
 
SPIN_LOCK *
EFIAPI
AcquireSpinLock (
  IN OUT  SPIN_LOCK  *SpinLock
  )
{
  UINT64  Current;
  UINT64  Previous;
  UINT64  Total;
  UINT64  Start;
  UINT64  End;
  UINT64  Timeout;
  INT64   Cycle;
  INT64   Delta;
 
  if (PcdGet32 (PcdSpinLockTimeout) == 0) {
    while (!AcquireSpinLockOrFail (SpinLock)) {
      CpuPause ();
    }
  } else if (!AcquireSpinLockOrFail (SpinLock)) {
    //
    // Get the current timer value
    //
    Current = GetPerformanceCounter ();
 
    //
    // Initialize local variables
    //
    Start = 0;
    End   = 0;
    Total = 0;
 
    //
    // Retrieve the performance counter properties and compute the number of performance
    // counter ticks required to reach the timeout
    //
    Timeout = DivU64x32 (
                MultU64x32 (
                  GetPerformanceCounterProperties (&Start, &End),
                  PcdGet32 (PcdSpinLockTimeout)
                  ),
                1000000
                );
    Cycle = End - Start;
    if (Cycle < 0) {
      Cycle = -Cycle;
    }
 
    Cycle++;
 
    while (!AcquireSpinLockOrFail (SpinLock)) {
      CpuPause ();
      Previous = Current;
      Current  = GetPerformanceCounter ();
      Delta    = (INT64)(Current - Previous);
      if (Start > End) {
        Delta = -Delta;
      }
 
      if (Delta < 0) {
        Delta += Cycle;
      }
 
      Total += Delta;
      ASSERT (Total < Timeout);
    }
  }
 
  return SpinLock;
}
 
BOOLEAN
EFIAPI
AcquireSpinLockOrFail (
  IN OUT  SPIN_LOCK  *SpinLock
  )
{
  SPIN_LOCK  LockValue;
  VOID       *Result;
 
  ASSERT (SpinLock != NULL);
 
  LockValue = *SpinLock;
  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
 
  _ReadWriteBarrier ();
  Result = InterlockedCompareExchangePointer (
             (VOID **)SpinLock,
             (VOID *)SPIN_LOCK_RELEASED,
             (VOID *)SPIN_LOCK_ACQUIRED
             );
 
  _ReadWriteBarrier ();
  return (BOOLEAN)(Result == (VOID *)SPIN_LOCK_RELEASED);
}
 
SPIN_LOCK *
EFIAPI
ReleaseSpinLock (
  IN OUT  SPIN_LOCK  *SpinLock
  )
{
  SPIN_LOCK  LockValue;
 
  ASSERT (SpinLock != NULL);
 
  LockValue = *SpinLock;
  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
 
  _ReadWriteBarrier ();
  *SpinLock = SPIN_LOCK_RELEASED;
  _ReadWriteBarrier ();
 
  return SpinLock;
}
 
UINT32
EFIAPI
InterlockedIncrement (
  IN      volatile UINT32  *Value
  )
{
  ASSERT (Value != NULL);
  return InternalSyncIncrement (Value);
}
 
UINT32
EFIAPI
InterlockedDecrement (
  IN      volatile UINT32  *Value
  )
{
  ASSERT (Value != NULL);
  return InternalSyncDecrement (Value);
}
 
UINT16
EFIAPI
InterlockedCompareExchange16 (
  IN OUT  volatile UINT16  *Value,
  IN      UINT16           CompareValue,
  IN      UINT16           ExchangeValue
  )
{
  ASSERT (Value != NULL);
  return InternalSyncCompareExchange16 (Value, CompareValue, ExchangeValue);
}
 
UINT32
EFIAPI
InterlockedCompareExchange32 (
  IN OUT  volatile UINT32  *Value,
  IN      UINT32           CompareValue,
  IN      UINT32           ExchangeValue
  )
{
  ASSERT (Value != NULL);
  return InternalSyncCompareExchange32 (Value, CompareValue, ExchangeValue);
}
 
UINT64
EFIAPI
InterlockedCompareExchange64 (
  IN OUT  volatile UINT64  *Value,
  IN      UINT64           CompareValue,
  IN      UINT64           ExchangeValue
  )
{
  ASSERT (Value != NULL);
  return InternalSyncCompareExchange64 (Value, CompareValue, ExchangeValue);
}
 
VOID *
EFIAPI
InterlockedCompareExchangePointer (
  IN OUT  VOID                      *volatile  *Value,
  IN      VOID                                 *CompareValue,
  IN      VOID                                 *ExchangeValue
  )
{
  UINT8  SizeOfValue;
 
  SizeOfValue = sizeof (*Value);
 
  switch (SizeOfValue) {
    case sizeof (UINT32):
      return (VOID *)(UINTN)InterlockedCompareExchange32 (
                              (volatile UINT32 *)Value,
                              (UINT32)(UINTN)CompareValue,
                              (UINT32)(UINTN)ExchangeValue
                              );
    case sizeof (UINT64):
      return (VOID *)(UINTN)InterlockedCompareExchange64 (
                              (volatile UINT64 *)Value,
                              (UINT64)(UINTN)CompareValue,
                              (UINT64)(UINTN)ExchangeValue
                              );
    default:
      ASSERT (FALSE);
      return NULL;
  }
}