ReactOS Development > Doxygen

00001 /*
00002  * PROJECT:         ReactOS HAL
00003  * LICENSE:         GPL - See COPYING in the top level directory
00004  * FILE:            hal/halx86/up/spinlock.c
00005  * PURPOSE:         Spinlock and Queued Spinlock Support
00006  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
00007  */
00008 
00009 /* INCLUDES ******************************************************************/
00010 
00011 #include <hal.h>
00012 #define NDEBUG
00013 #include <debug.h>
00014 
00015 #undef KeAcquireSpinLock
00016 #undef KeReleaseSpinLock
00017 #undef KeLowerIrql
00018 #undef KeRaiseIrql
00019 
00020 
00021 KIRQL FASTCALL
00022 KfRaiseIrql (KIRQL  NewIrql);
00023 
00024 VOID FASTCALL
00025 KfLowerIrql (KIRQL  NewIrql);
00026 
00027 /* FUNCTIONS *****************************************************************/
00028 
00029 /*
00030  * @implemented
00031  */
00032 VOID
00033 NTAPI
00034 KeLowerIrql(KIRQL NewIrql)
00035 {
00036     /* Call the fastcall function */
00037     KfLowerIrql(NewIrql);
00038 }
00039 
00040 /*
00041  * @implemented
00042  */
00043 NTKERNELAPI
00044 KIRQL
00045 NTAPI
00046 KeRaiseIrql(KIRQL NewIrql,
00047             PKIRQL OldIrql)
00048 {
00049     /* Call the fastcall function */
00050     return *OldIrql = KfRaiseIrql(NewIrql);
00051 }
00052 
00053 /*
00054  * @implemented
00055  */
00056 VOID
00057 NTAPI
00058 KeAcquireSpinLock(PKSPIN_LOCK SpinLock,
00059                   PKIRQL OldIrql)
00060 {
00061     /* Call the fastcall function */
00062     *OldIrql = KfAcquireSpinLock(SpinLock);
00063 }
00064 
00065 /*
00066  * @implemented
00067  */
00068 KIRQL
00069 FASTCALL
00070 KeAcquireSpinLockRaiseToSynch(PKSPIN_LOCK SpinLock)
00071 {
00072     /* Simply raise to dispatch */
00073     return KfRaiseIrql(DISPATCH_LEVEL);
00074 }
00075 
00076 /*
00077  * @implemented
00078  */
00079 VOID
00080 NTAPI
00081 KeReleaseSpinLock(PKSPIN_LOCK SpinLock,
00082                   KIRQL NewIrql)
00083 {
00084     /* Call the fastcall function */
00085     KfReleaseSpinLock(SpinLock, NewIrql);
00086 }
00087 
00088 /*
00089  * @implemented
00090  */
00091 KIRQL
00092 FASTCALL
00093 KfAcquireSpinLock(PKSPIN_LOCK SpinLock)
00094 {
00095     /* Simply raise to dispatch */
00096     return KfRaiseIrql(DISPATCH_LEVEL);
00097 }
00098 
00099 /*
00100  * @implemented
00101  */
00102 VOID
00103 FASTCALL
00104 KfReleaseSpinLock(PKSPIN_LOCK SpinLock,
00105                   KIRQL OldIrql)
00106 {
00107     /* Simply lower IRQL back */
00108     KfLowerIrql(OldIrql);
00109 }
00110 
00111 /*
00112  * @implemented
00113  */
00114 KIRQL
00115 FASTCALL
00116 KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
00117 {
00118     /* Simply raise to dispatch */
00119     return KfRaiseIrql(DISPATCH_LEVEL);
00120 }
00121 
00122 /*
00123  * @implemented
00124  */
00125 KIRQL
00126 FASTCALL
00127 KeAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
00128 {
00129     /* Simply raise to dispatch */
00130     return KfRaiseIrql(DISPATCH_LEVEL);
00131 }
00132 
00133 /*
00134  * @implemented
00135  */
00136 VOID
00137 FASTCALL
00138 KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock,
00139                                IN PKLOCK_QUEUE_HANDLE LockHandle)
00140 {
00141     /* Simply raise to dispatch */
00142     LockHandle->OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
00143 }
00144 
00145 /*
00146  * @implemented
00147  */
00148 VOID
00149 FASTCALL
00150 KeAcquireInStackQueuedSpinLockRaiseToSynch(IN PKSPIN_LOCK SpinLock,
00151                                            IN PKLOCK_QUEUE_HANDLE LockHandle)
00152 {
00153     /* Simply raise to synch */
00154     LockHandle->OldIrql = KfRaiseIrql(SYNCH_LEVEL);
00155 }
00156 
00157 /*
00158  * @implemented
00159  */
00160 VOID
00161 FASTCALL
00162 KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
00163                         IN KIRQL OldIrql)
00164 {
00165     /* Simply lower IRQL back */
00166     KfLowerIrql(OldIrql);
00167 }
00168 
00169 /*
00170  * @implemented
00171  */
00172 VOID
00173 FASTCALL
00174 KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
00175 {
00176     /* Simply lower IRQL back */
00177     KfLowerIrql(LockHandle->OldIrql);
00178 }
00179 
00180 /*
00181  * @implemented
00182  */
00183 BOOLEAN
00184 FASTCALL
00185 KeTryToAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
00186                                          IN PKIRQL OldIrql)
00187 {
00188     /* Simply raise to dispatch */
00189     *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
00190 
00191     /* Always return true on UP Machines */
00192     return TRUE;
00193 }
00194 
00195 /*
00196  * @implemented
00197  */
00198 LOGICAL
00199 FASTCALL
00200 KeTryToAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber,
00201                              OUT PKIRQL OldIrql)
00202 {
00203     /* Simply raise to dispatch */
00204     *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
00205 
00206     /* Always return true on UP Machines */
00207     return TRUE;
00208 }
00209 
00210 /* EOF */
Generated on Sat May 26 2012 04:27:16 for ReactOS by
1.7.6.1