reactos/hal/halx86/mp/spinlock.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            hal/halx86/mp/spinlock.c
   5  * PURPOSE:         Implements spinlocks
   6  * PROGRAMMER:      David Welch (welch@cwcom.net)
   7  *                  Eric Kohl
   8  * UPDATE HISTORY:
   9  *                  09/06/2000 Created
  10  */
  11
  12 /*
  13  * NOTE: On a uniprocessor machine spinlocks are implemented by raising
  14  * the irq level
  15  */
  16
  17 /* INCLUDES ****************************************************************/
  18
  19 #include <hal.h>
  20 #define NDEBUG
  21 #include <debug.h>
  22
  23 /* Hmm, needed for KDBG := 1. Why? */
  24 #undef KeGetCurrentIrql
  25
  26 /* FUNCTIONS ***************************************************************/
  27
  28 #undef KeAcquireSpinLock
  29 VOID NTAPI
  30 KeAcquireSpinLock (
  31         PKSPIN_LOCK     SpinLock,
  32         PKIRQL          OldIrql
  33         )
  34 /*
  35  * FUNCTION: Acquires a spinlock
  36  * ARGUMENTS:
  37  *         SpinLock = Spinlock to acquire
  38  *         OldIrql (OUT) = Caller supplied storage for the previous irql
  39  */
  40 {
  41   *OldIrql = KfAcquireSpinLock(SpinLock);
  42 }
  43
  44 KIRQL FASTCALL
  45 KeAcquireSpinLockRaiseToSynch (
  46         PKSPIN_LOCK     SpinLock
  47         )
  48 {
  49   KIRQL OldIrql;
  50
  51   OldIrql = KfRaiseIrql(CLOCK2_LEVEL);
  52   KiAcquireSpinLock(SpinLock);
  53
  54   return OldIrql;
  55 }
  56
  57 #undef KeReleaseSpinLock
  58 VOID NTAPI
  59 KeReleaseSpinLock (
  60         PKSPIN_LOCK     SpinLock,
  61         KIRQL           NewIrql
  62         )
  63 /*
  64  * FUNCTION: Releases a spinlock
  65  * ARGUMENTS:
  66  *        SpinLock = Spinlock to release
  67  *        NewIrql = Irql level before acquiring the spinlock
  68  */
  69 {
  70    KfReleaseSpinLock(SpinLock, NewIrql);
  71 }
  72
  73 LOGICAL
  74 FASTCALL
  75 KeTryToAcquireQueuedSpinLock(
  76   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
  77   PKIRQL OldIrql)
  78 {
  79   UNIMPLEMENTED;
  80
  81   return FALSE;
  82 }
  83
  84
  85 BOOLEAN
  86 FASTCALL
  87 KeTryToAcquireQueuedSpinLockRaiseToSynch(
  88   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
  89   PKIRQL OldIrql)
  90 {
  91   UNIMPLEMENTED;
  92
  93   return FALSE;
  94 }
  95
  96 KIRQL FASTCALL
  97 KfAcquireSpinLock (
  98         PKSPIN_LOCK     SpinLock
  99         )
 100 {
 101    KIRQL OldIrql;
 102
 103    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 104
 105    OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 106    KiAcquireSpinLock(SpinLock);
 107
 108    return OldIrql;
 109 }
 110
 111 VOID FASTCALL
 112 KfReleaseSpinLock (
 113         PKSPIN_LOCK     SpinLock,
 114         KIRQL           NewIrql
 115         )
 116 /*
 117  * FUNCTION: Releases a spinlock
 118  * ARGUMENTS:
 119  *        SpinLock = Spinlock to release
 120  *        NewIrql = Irql level before acquiring the spinlock
 121  */
 122 {
 123    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL || KeGetCurrentIrql() == SYNCH_LEVEL);
 124    KiReleaseSpinLock(SpinLock);
 125    KfLowerIrql(NewIrql);
 126 }
 127
 128
 129 /*
 130  * @unimplemented
 131  */
 132 VOID
 133 FASTCALL
 134 KeAcquireInStackQueuedSpinLock(
 135     IN PKSPIN_LOCK SpinLock,
 136     IN PKLOCK_QUEUE_HANDLE LockHandle
 137     )
 138 {
 139    UNIMPLEMENTED;
 140 }
 141
 142 /*
 143  * @unimplemented
 144  */
 145 VOID
 146 FASTCALL
 147 KeAcquireInStackQueuedSpinLockRaiseToSynch(
 148     IN PKSPIN_LOCK SpinLock,
 149     IN PKLOCK_QUEUE_HANDLE LockHandle
 150     )
 151 {
 152    UNIMPLEMENTED;
 153 }
 154
 155
 156 /*
 157  * @unimplemented
 158  */
 159 VOID
 160 FASTCALL
 161 KeReleaseInStackQueuedSpinLock(
 162     IN PKLOCK_QUEUE_HANDLE LockHandle
 163     )
 164 {
 165    UNIMPLEMENTED;
 166 }
 167
 168 /*
 169  * @unimplemented
 170  */
 171 KIRQL
 172 FASTCALL
 173 KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER Number)
 174 {
 175    UNIMPLEMENTED;
 176    return 0;
 177 }
 178
 179 /*
 180  * @unimplemented
 181  */
 182 KIRQL
 183 FASTCALL
 184 KeAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
 185 {
 186     UNIMPLEMENTED;
 187     return 0;
 188 }
 189
 190 /*
 191  * @unimplemented
 192  */
 193 VOID
 194 FASTCALL
 195 KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER Number,
 196                         IN KIRQL OldIrql)
 197 {
 198    UNIMPLEMENTED;
 199 }
 200
 201 /* EOF */