reactos/hal/halppc/generic/spinlock.c

   1 /*
   2  * PROJECT:         ReactOS HAL
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            hal/halppc/generic/spinlock.c
   5  * PURPOSE:         Spinlock and Queued Spinlock Support
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <hal.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 #undef KeAcquireSpinLock
  16 #undef KeReleaseSpinLock
  17 #undef KeLowerIrql
  18 #undef KeRaiseIrql
  19
  20
  21 KIRQL FASTCALL
  22 KfRaiseIrql (KIRQL      NewIrql);
  23
  24 VOID FASTCALL
  25 KfLowerIrql (KIRQL      NewIrql);
  26
  27 /* FUNCTIONS *****************************************************************/
  28
  29 /*
  30  * @implemented
  31  */
  32 VOID
  33 NTAPI
  34 KeLowerIrql(KIRQL NewIrql)
  35 {
  36     /* Call the fastcall function */
  37     KfLowerIrql(NewIrql);
  38 }
  39
  40 /*
  41  * @implemented
  42  */
  43 NTKERNELAPI
  44 KIRQL
  45 NTAPI
  46 KeRaiseIrql(KIRQL NewIrql,
  47             PKIRQL OldIrql)
  48 {
  49     /* Call the fastcall function */
  50     return *OldIrql = KfRaiseIrql(NewIrql);
  51 }
  52
  53 /*
  54  * @implemented
  55  */
  56 VOID
  57 NTAPI
  58 KeAcquireSpinLock(PKSPIN_LOCK SpinLock,
  59                   PKIRQL OldIrql)
  60 {
  61     /* Call the fastcall function */
  62     *OldIrql = KfAcquireSpinLock(SpinLock);
  63 }
  64
  65 /*
  66  * @implemented
  67  */
  68 KIRQL
  69 FASTCALL
  70 KeAcquireSpinLockRaiseToSynch(PKSPIN_LOCK SpinLock)
  71 {
  72     /* Simply raise to dispatch */
  73     return KfRaiseIrql(DISPATCH_LEVEL);
  74 }
  75
  76 /*
  77  * @implemented
  78  */
  79 VOID
  80 NTAPI
  81 KeReleaseSpinLock(PKSPIN_LOCK SpinLock,
  82                   KIRQL NewIrql)
  83 {
  84     /* Call the fastcall function */
  85     KfReleaseSpinLock(SpinLock, NewIrql);
  86 }
  87
  88 /*
  89  * @implemented
  90  */
  91 KIRQL
  92 FASTCALL
  93 KfAcquireSpinLock(PKSPIN_LOCK SpinLock)
  94 {
  95     /* Simply raise to dispatch */
  96     return KfRaiseIrql(DISPATCH_LEVEL);
  97 }
  98
  99 /*
 100  * @implemented
 101  */
 102 VOID
 103 FASTCALL
 104 KfReleaseSpinLock(PKSPIN_LOCK SpinLock,
 105                   KIRQL OldIrql)
 106 {
 107     /* Simply lower IRQL back */
 108     KfLowerIrql(OldIrql);
 109 }
 110
 111 /*
 112  * @implemented
 113  */
 114 KIRQL
 115 FASTCALL
 116 KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
 117 {
 118     /* Simply raise to dispatch */
 119     return KfRaiseIrql(DISPATCH_LEVEL);
 120 }
 121
 122 /*
 123  * @implemented
 124  */
 125 KIRQL
 126 FASTCALL
 127 KeAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
 128 {
 129     /* Simply raise to dispatch */
 130     return KfRaiseIrql(DISPATCH_LEVEL);
 131 }
 132
 133 /*
 134  * @implemented
 135  */
 136 VOID
 137 FASTCALL
 138 KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock,
 139                                IN PKLOCK_QUEUE_HANDLE LockHandle)
 140 {
 141     /* Simply raise to dispatch */
 142     LockHandle->OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 143 }
 144
 145 /*
 146  * @implemented
 147  */
 148 VOID
 149 FASTCALL
 150 KeAcquireInStackQueuedSpinLockRaiseToSynch(IN PKSPIN_LOCK SpinLock,
 151                                            IN PKLOCK_QUEUE_HANDLE LockHandle)
 152 {
 153     /* Simply raise to synch */
 154     LockHandle->OldIrql = KfRaiseIrql(SYNCH_LEVEL);
 155 }
 156
 157 /*
 158  * @implemented
 159  */
 160 VOID
 161 FASTCALL
 162 KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 163                         IN KIRQL OldIrql)
 164 {
 165     /* Simply lower IRQL back */
 166     KfLowerIrql(OldIrql);
 167 }
 168
 169 /*
 170  * @implemented
 171  */
 172 VOID
 173 FASTCALL
 174 KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
 175 {
 176     /* Simply lower IRQL back */
 177     KfLowerIrql(LockHandle->OldIrql);
 178 }
 179
 180 /*
 181  * @implemented
 182  */
 183 BOOLEAN
 184 FASTCALL
 185 KeTryToAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 186                                          IN PKIRQL OldIrql)
 187 {
 188     /* Simply raise to dispatch */
 189     *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 190
 191     /* Always return true on UP Machines */
 192     return TRUE;
 193 }
 194
 195 /*
 196  * @implemented
 197  */
 198 LOGICAL
 199 FASTCALL
 200 KeTryToAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 201                              OUT PKIRQL OldIrql)
 202 {
 203     /* Simply raise to dispatch */
 204     *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 205
 206     /* Always return true on UP Machines */
 207     return TRUE;
 208 }
 209
 210 /* EOF */