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