title "Critical Section Support" ; Copyright (c) 1991 Microsoft Corporation ; Module Name: ; critsect.asm ; Abstract: ; This module implements functions to support user mode critical sections. ; Author: ; Bryan M. Willman (bryanwi) 2-Oct-91 ; Environment: ; Any mode. ; Revision History: .486p .xlist include ks386.inc include callconv.inc ; calling convention macros include mac386.inc .list _DATA SEGMENT DWORD PUBLIC 'DATA' public _LdrpLockPrefixTable _LdrpLockPrefixTable label dword dd offset FLAT:Lock1 dd offset FLAT:Lock2 dd offset FLAT:Lock3 dd offset FLAT:Lock4 dd offset FLAT:Lock5 dd offset FLAT:Lock6 dd offset FLAT:Lock7 dd 0 _DATA ENDS _TEXT SEGMENT PARA PUBLIC 'CODE' ASSUME DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING EXTRNP _RtlpWaitForCriticalSection,1 EXTRNP _RtlpUnWaitCriticalSection,1 if DEVL EXTRNP _RtlpNotOwnerCriticalSection,1 endif if DBG EXTRNP _RtlpCriticalSectionIsOwned,1 endif CriticalSection equ [esp + 4] page , 132 subttl "RtlEnterCriticalSection" ; NTSTATUS RtlEnterCriticalSection(IN PRTL_CRITICAL_SECTION CriticalSection) ; Routine Description: ; This function enters a critical section. ; Arguments: ; CriticalSection - supplies a pointer to a critical section. ; Return Value: ; STATUS_SUCCESS or raises an exception if an error occured. align 16 cPublicProc _RtlEnterCriticalSection,1 cPublicFpo 1,0 mov ecx,fs:PcTeb ; get current TEB address mov edx,CriticalSection ; get address of critical section cmp CsSpinCount[edx],0 ; check if spin count is zero jne short Ent40 ; if ne, spin count specified ; Attempt to acquire critical section. Lock1: ; lock inc dword ptr CsLockCount[edx] ; increment lock count jnz short Ent20 ; if nz, already owned ; Set critical section owner and initialize recursion count. Ent10: if DBG cmp CsOwningThread[edx],0 je @F stdCall _RtlpCriticalSectionIsOwned, mov ecx,fs:PcTeb ; get current TEB address mov edx,CriticalSection ; get address of critical section @@: endif ; DBG mov eax,TbClientId + 4[ecx] ; get current client ID mov CsOwningThread[edx],eax ; set critical section owner mov dword ptr CsRecursionCount[edx],1 ; set recursion count if DBG inc dword ptr TbCountOfOwnedCriticalSections[ecx] ; increment owned count mov eax,CsDebugInfo[edx] ; get debug information address inc dword ptr CsEntryCount[eax] ; increment entry count endif ; DBG xor eax,eax ; set success status stdRET _RtlEnterCriticalSection ; The critical section is already owned, but may be owned by the current thread. align 16 Ent20: mov eax,TbClientId + 4[ecx] ; get current client ID cmp CsOwningThread[edx],eax ; check if current thread is owner jne short Ent30 ; if ne, current thread not owner inc dword ptr CsRecursionCount[edx] ; increment recursion count if DBG mov eax,CsDebugInfo[edx] ; get debug information address inc dword ptr CsEntryCount[eax] ; increment entry count endif ; DBG xor eax,eax ; set success status stdRET _RtlEnterCriticalSection ; The critcal section is owned by another thread and the current thread must ; wait for ownership. Ent30: stdCall _RtlpWaitForCriticalSection, ; wait for ownership mov ecx,fs:PcTeb ; get current TEB address mov edx,CriticalSection ; get address of critical section jmp Ent10 ; set owner and recursion count ; A nonzero spin count is specified. align 16 Ent40: mov eax,TbClientId + 4[ecx] ; get current client ID cmp CsOwningThread[edx],eax ; check if current thread is owner jne short Ent50 ; if ne, current thread not owner ; The critical section is owned by the current thread. Increment the lock ; count and the recursion count. Lock6: ; lock inc dword ptr CsLockCount[edx] ; increment lock count inc dword ptr CsRecursionCount[edx] ; increment recursion count if DBG mov eax,CsDebugInfo[edx] ; get debug information address inc dword ptr CsEntryCount[eax] ; increment entry count endif ; DBG xor eax,eax ; set success status stdRET _RtlEnterCriticalSection ; A nonzero spin count is specified and the current thread is not the owner. align 16 Ent50: push CsSpinCount[edx] ; get spin count value Ent60: mov eax,-1 ; set comparand value mov ecx,0 ; set exchange value Lock7: lock cmpxchg dword ptr CsLockCount[edx],ecx ; attempt to acquire critical section jnz short Ent70 ; if nz, critical section not acquired ; The critical section has been acquired. Set the owning thread and the initial ; recursion count. add esp,4 ; remove spin count from stack mov ecx,fs:PcTeb ; get current TEB address mov eax,TbClientId + 4[ecx] ; get current client ID mov CsOwningThread[edx],eax ; set critical section owner mov dword ptr CsRecursionCount[edx],1 ; set recursion count if DBG inc dword ptr TbCountOfOwnedCriticalSections[ecx] ; increment owned count mov eax,CsDebugInfo[edx] ; get debug information address inc dword ptr CsEntryCount[eax] ; increment entry count endif ; DBG xor eax,eax ; set success status stdRET _RtlEnterCriticalSection ; The critical section is currently owned. Spin until it is either unowned ; or the spin count has reached zero. ; If waiters are present, don't spin on the lock since we will never see it go free Ent70: cmp CsLockCount[edx],1 ; check if waiters are present, jge short Ent76 ; if ge 1, then do not spin Ent75: YIELD cmp CsLockCount[edx],-1 ; check if lock is owned je short Ent60 ; if e, lock is not owned dec dword ptr [esp] ; decrement spin count jnz short Ent75 ; if nz, continue spinning Ent76: add esp,4 ; remove spin count from stack mov ecx,fs:PcTeb ; get current TEB address jmp Lock1 ; stdENDP _RtlEnterCriticalSection page , 132 subttl "RtlLeaveCriticalSection" ; NTSTATUS ; RtlLeaveCriticalSection( ; IN PRTL_CRITICAL_SECTION CriticalSection ; ) ; Routine Description: ; This function leaves a critical section. ; Arguments: ; CriticalSection - supplies a pointer to a critical section. ; Return Value: ; STATUS_SUCCESS or raises an exception if an error occured. align 16 cPublicProc _RtlLeaveCriticalSection,1 cPublicFpo 1,0 mov edx,CriticalSection if DBG mov ecx,fs:PcTeb ; (ecx) == NtCurrentTeb() mov eax,TbClientId+4[ecx] ; (eax) == NtCurrentTeb()->ClientId.UniqueThread cmp eax,CsOwningThread[edx] je @F stdCall _RtlpNotOwnerCriticalSection, mov eax,STATUS_INVALID_OWNER stdRET _RtlLeaveCriticalSection @@: endif ; DBG xor eax,eax ; Assume STATUS_SUCCESS dec dword ptr CsRecursionCount[edx] jnz leave_recurs ; skip if only leaving recursion mov CsOwningThread[edx],eax ; clear owning thread id if DBG mov ecx,fs:PcTeb ; (ecx) == NtCurrentTeb() dec dword ptr TbCountOfOwnedCriticalSections[ecx] endif ; DBG Lock2: lock dec dword ptr CsLockCount[edx] ; interlocked dec of ; ... CriticalSection->LockCount jge @F stdRET _RtlLeaveCriticalSection @@: stdCall _RtlpUnWaitCriticalSection, xor eax,eax ; return STATUS_SUCCESS stdRET _RtlLeaveCriticalSection align 16 leave_recurs: Lock3: lock dec dword ptr CsLockCount[edx] ; interlocked dec of ; ... CriticalSection->LockCount stdRET _RtlLeaveCriticalSection _RtlLeaveCriticalSection endp page ,132 subttl "RtlTryEnterCriticalSection" ; BOOL RtlTryEnterCriticalSection(IN PRTL_CRITICAL_SECTION CriticalSection) ; Routine Description: ; This function attempts to enter a critical section without blocking. ; Arguments: ; CriticalSection (a0) - Supplies a pointer to a critical section. ; Return Value: ; If the critical section was successfully entered, then a value of TRUE ; is returned as the function value. Otherwise, a value of FALSE is returned. CriticalSection equ [esp + 4] cPublicProc _RtlTryEnterCriticalSection,1 cPublicFpo 1,0 mov ecx,CriticalSection ; interlocked inc of mov eax, -1 ; set value to compare against mov edx, 0 ; set value to set Lock4: lock cmpxchg dword ptr CsLockCount[ecx],edx ; Attempt to acquire critsect jnz short tec10 ; if nz, critsect already owned mov eax,fs:TbClientId+4 ; (eax) == NtCurrentTeb()->ClientId.UniqueThread mov CsOwningThread[ecx],eax mov dword ptr CsRecursionCount[ecx],1 if DBG mov eax,fs:PcTeb ; (ecx) == NtCurrentTeb() inc dword ptr TbCountOfOwnedCriticalSections[eax] endif ; DBG mov eax, 1 ; set successful status stdRET _RtlTryEnterCriticalSection tec10: ; The critical section is already owned. If it is owned by another thread, ; return FALSE immediately. If it is owned by this thread, we must increment the lock count here. mov eax, fs:TbClientId+4 ; (eax) == NtCurrentTeb()->ClientId.UniqueThread cmp CsOwningThread[ecx], eax jz tec20 ; if eq, this thread is already the owner xor eax, eax ; set failure status YIELD stdRET _RtlTryEnterCriticalSection tec20: ; This thread is already the owner of the critical section. Perform an atomic ; increment of the LockCount and a normal increment of the RecursionCount and return success. Lock5: lock inc dword ptr CsLockCount[ecx] inc dword ptr CsRecursionCount[ecx] mov eax, 1 stdRET _RtlTryEnterCriticalSection stdENDP _RtlTryEnterCriticalSection _TEXT ends end