Sync to trunk head (r42241)

[reactos.git] / reactos / ntoskrnl / ke / spinlock.c

diff --git a/reactos/ntoskrnl/ke/spinlock.c b/reactos/ntoskrnl/ke/spinlock.c
index a97158b..a1ed59b 100644 (file)
--- a/reactos/ntoskrnl/ke/spinlock.c
+++ b/reactos/ntoskrnl/ke/spinlock.c
@@ -10,7 +10,7 @@
 
 #include <ntoskrnl.h>
 #define NDEBUG
-#include <internal/debug.h>
+#include <debug.h>
 
 #define LQ_WAIT     1
 #define LQ_OWN      2
@@ -26,24 +26,24 @@ KeAcquireQueuedSpinLockAtDpcLevel(IN PKSPIN_LOCK_QUEUE LockHandle)
 
     /* Set the new lock */
     Prev = (PKSPIN_LOCK_QUEUE)
-           InterlockedExchange((PLONG)LockHandle->LockQueue.Lock,
+           InterlockedExchange((PLONG)LockHandle->Next,
                                (LONG)LockHandle);
     if (!Prev)
     {
         /* There was nothing there before. We now own it */
-         *(ULONG_PTR*)&LockHandle->LockQueue.Lock |= LQ_OWN;
+         *LockHandle->Lock |= LQ_OWN;
         return;
     }
 
     /* Set the wait flag */
-     *(ULONG_PTR*)&LockHandle->LockQueue.Lock |= LQ_WAIT;
+     *LockHandle->Lock |= LQ_WAIT;
 
     /* Link us */
     Prev->Next = (PKSPIN_LOCK_QUEUE)LockHandle;
 
     /* Loop and wait */
-    while ( *(ULONG_PTR*)&LockHandle->LockQueue.Lock & LQ_WAIT) YieldProcessor();
-    return;
+    while (*LockHandle->Lock & LQ_WAIT)
+        YieldProcessor();
 #endif
 }
 
@@ -56,46 +56,80 @@ KeReleaseQueuedSpinLockFromDpcLevel(IN PKSPIN_LOCK_QUEUE LockHandle)
     PKSPIN_LOCK_QUEUE Waiter;
 
     /* Remove own and wait flags */
-     *(ULONG_PTR*)&LockHandle->LockQueue.Lock &= ~(LQ_OWN | LQ_WAIT);
-    LockVal = *LockHandle->LockQueue.Lock;
+    *LockHandle->Lock &= ~(LQ_OWN | LQ_WAIT);
+    LockVal = *LockHandle->Lock;
 
     /* Check if we already own it */
     if (LockVal == (KSPIN_LOCK)LockHandle)
     {
         /* Disown it */
         LockVal = (KSPIN_LOCK)
-                  InterlockedCompareExchangePointer(LockHandle->LockQueue.Lock,
+                  InterlockedCompareExchangePointer(LockHandle->Lock,
                                                     NULL,
                                                     LockHandle);
     }
     if (LockVal == (KSPIN_LOCK)LockHandle) return;
 
     /* Need to wait for it */
-    Waiter = LockHandle->LockQueue.Next;
+    Waiter = LockHandle->Next;
     while (!Waiter)
     {
         YieldProcessor();
-        Waiter = LockHandle->LockQueue.Next;
+        Waiter = LockHandle->Next;
     }
 
     /* It's gone */
     *(ULONG_PTR*)&Waiter->Lock ^= (LQ_OWN | LQ_WAIT);
-    LockHandle->LockQueue.Next = NULL;
+    LockHandle->Next = NULL;
 #endif
 }
 
 /* PUBLIC FUNCTIONS **********************************************************/
 
+#ifdef _X86_
+/*
+ * @implemented
+ */
+KIRQL
+NTAPI
+KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt)
+{
+    KIRQL OldIrql;
+
+    /* Raise IRQL */
+    KeRaiseIrql(Interrupt->SynchronizeIrql, &OldIrql);
+
+    /* Acquire spinlock on MP */
+    KeAcquireSpinLockAtDpcLevel(Interrupt->ActualLock);
+    return OldIrql;
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt,
+                           IN KIRQL OldIrql)
+{
+    /* Release lock on MP */
+    KeReleaseSpinLockFromDpcLevel(Interrupt->ActualLock);
+
+    /* Lower IRQL */
+    KeLowerIrql(OldIrql);
+}
+
 /*
  * @implemented
  */
 VOID
 NTAPI
-KeInitializeSpinLock(IN PKSPIN_LOCK SpinLock)
+_KeInitializeSpinLock(IN PKSPIN_LOCK SpinLock)
 {
     /* Clear it */
     *SpinLock = 0;
 }
+#endif
 
 /*
  * @implemented
@@ -189,7 +223,7 @@ KeTryToAcquireSpinLockAtDpcLevel(IN OUT PKSPIN_LOCK SpinLock)
         return FALSE;
     }
 
-#ifdef DBG
+#if DBG
     /* On debug builds, we OR in the KTHREAD */
     *SpinLock = (ULONG_PTR)KeGetCurrentThread() | 1;
 #endif
@@ -211,8 +245,7 @@ KeAcquireInStackQueuedSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock,
     /* Set it up properly */
     LockHandle->LockQueue.Next = NULL;
     LockHandle->LockQueue.Lock = SpinLock;
-    KeAcquireQueuedSpinLockAtDpcLevel((PKLOCK_QUEUE_HANDLE)
-                                      &LockHandle->LockQueue.Next);
+    KeAcquireQueuedSpinLockAtDpcLevel(LockHandle->LockQueue.Next);
 #endif
 }
 
@@ -225,41 +258,73 @@ KeReleaseInStackQueuedSpinLockFromDpcLevel(IN PKLOCK_QUEUE_HANDLE LockHandle)
 {
 #ifdef CONFIG_SMP
     /* Call the internal function */
-    KeReleaseQueuedSpinLockFromDpcLevel((PKLOCK_QUEUE_HANDLE)
-                                        &LockHandle->LockQueue.Next);
+    KeReleaseQueuedSpinLockFromDpcLevel(LockHandle->LockQueue.Next);
 #endif
 }
 
 /*
- * @implemented
+ * @unimplemented
  */
 KIRQL
-NTAPI
-KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt)
+FASTCALL
+KeAcquireSpinLockForDpc(IN PKSPIN_LOCK SpinLock)
 {
-    KIRQL OldIrql;
+    UNIMPLEMENTED;
+    return 0;
+}
 
-    /* Raise IRQL */
-    KeRaiseIrql(Interrupt->SynchronizeIrql, &OldIrql);
+/*
+ * @unimplemented
+ */
+VOID
+FASTCALL
+KeReleaseSpinLockForDpc(IN PKSPIN_LOCK SpinLock,
+                        IN KIRQL OldIrql)
+{
+    UNIMPLEMENTED;
+}
 
-    /* Acquire spinlock on MP */
-    KefAcquireSpinLockAtDpcLevel(Interrupt->ActualLock);
-    return OldIrql;
+/*
+ * @unimplemented
+ */
+KIRQL
+FASTCALL
+KeAcquireInStackQueuedSpinLockForDpc(IN PKSPIN_LOCK SpinLock,
+                                     IN PKLOCK_QUEUE_HANDLE LockHandle)
+{
+    UNIMPLEMENTED;
+    return 0;
 }
 
 /*
- * @implemented
+ * @unimplemented
  */
 VOID
-NTAPI
-KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt,
-                           IN KIRQL OldIrql)
+FASTCALL
+KeReleaseInStackQueuedSpinLockForDpc(IN PKLOCK_QUEUE_HANDLE LockHandle)
 {
-    /* Release lock on MP */
-    KefReleaseSpinLockFromDpcLevel(Interrupt->ActualLock);
+    UNIMPLEMENTED;
+}
 
-    /* Lower IRQL */
-    KeLowerIrql(OldIrql);
+/*
+ * @implemented
+ */
+BOOLEAN
+FASTCALL
+KeTestSpinLock(IN PKSPIN_LOCK SpinLock)
+{
+    /* Test this spinlock */
+    if (*SpinLock)
+    {
+        /* Spinlock is busy, yield execution */
+        YieldProcessor();
+
+        /* Return busy flag */
+        return FALSE;
+    }
+
+    /* Spinlock appears to be free */
+    return TRUE;
 }
 
 /* EOF */