|
|
;**************************************************************************;* walk286.ASM;*;* Assembly support code for the KRNL286 global heap routines;* for TOOLHELP.DLL;*;**************************************************************************
INCLUDE TOOLPRIV.INC
PMODE32 = 0PMODE = 1SWAPPRO = 0 INCLUDE WINKERN.INC
;** External functionsexternNP HelperVerifySegexternNP HelperHandleToSelexternNP HelperPDBtoTDBexternNP HelperSegLen
;** Functions
sBegin CODE assumes CS,CODE
; Walk286Count;; Returns the number of blocks in the given list
cProc Walk286Count, <PUBLIC,NEAR>, <di> parmW wFlagscBegin mov es,hMaster ;Segment of master block mov ax,wFlags ;Get the flag value shr ax,1 ;Check for GLOBAL_LRU jc W2C_LRU ;Bit set, must be LRU shr ax,1 ;Check for GLOBAL_FREE jc W2C_Free ;Must be free ;Must be GLOBAL_ALL
;** Get total object count mov ax,es:[hi_count] ;Get heap count inc ax ;Bump to include first sentinel jmp SHORT W2C_End ;Get out
;** Get LRU object countW2C_LRU: mov ax,es:[gi_lrucount] ;Get the LRU count jmp SHORT W2C_End ;Get out
;** Get Free list object countW2C_Free: mov ax,es:[gi_free_count] ;Get free count jmp SHORT W2C_End ;Get out
;** Return the result in AXW2C_End: cEnd
; Walk286First;; Returns a handle to the first block in the 286 global heap.
cProc Walk286First, <PUBLIC,NEAR>, <di> parmW wFlagscBegin mov es,hMaster ;Segment of master block mov ax,wFlags ;Get the flag value shr ax,1 ;Check for GLOBAL_LRU jc W2F_LRU ;Bit set, must be LRU shr ax,1 ;Check for GLOBAL_FREE jc W2F_Free ;Must be free ;Must be GLOBAL_ALL
;** Get first object in complete heap (wFlags == GLOBAL_ALL) mov ax,es:[hi_first] ;Get handle of first arena header jmp SHORT W2F_End ;Get out
;** Get first object in LRU listW2F_LRU: mov ax,es:[gi_lrucount] ;Get the number of objects or ax,ax ;Are there any objects? je W2F_End ;No, return NULL inc es:[gi_lrulock] ;No LRU sweeping for awhile inc wLRUCount ;Keep a count of this mov ax,es:[gi_lruchain] ;Get a pointer to the first item jmp SHORT W2F_End ;Done
;** Get first object in Free listW2F_Free: mov ax,es:[gi_free_count] ;Get the number of objects or ax,ax ;Are there any objects? jz W2F_End ;No, return NULL mov es,es:[hi_first] ;Get the first object mov ax,es:[ga_freenext] ;Skip to the first free block ;Fall through to the return
;** Return the result in AX (return DX = NULL)W2F_End: xor dx,dx ;Clear high wordcEnd
; Walk286;; Takes a pointer to a block and returns a GLOBALENTRY structure; full of information about the block. If the block pointer is; NULL, looks at the first block. The last field in the GLOBALENTRY; structure is used to chain to the next block and is thus used to walk; the heap.
cProc Walk286, <PUBLIC,NEAR>, <di,si,ds> parmD dwBlock parmD lpGlobal parmW wFlagscBegin ;** Set up to build public structure mov es,WORD PTR dwBlock ;Point to this block lds si,lpGlobal ;Point to the GLOBALENTRY structure
;** Fill public structure mov ax,es:[ga_handle] ;Get the handle of the block mov [si].ge_hBlock,ax ;Put in public structure mov ax,es:[ga_size] ;Get the size of the block (LOWORD) mov dx,ax ;Clear high word shl ax,4 ;Left shift DX:AX by 4 shr dx,16-4 mov WORD PTR [si].ge_dwBlockSize,ax ;Put in public structure mov WORD PTR [si].ge_dwBlockSize + 2,dx ;Put in public structure mov ax,es:[ga_owner] ;Owning task of block mov [si].ge_hOwner,ax ;Put in public structure xor ah,ah ;No upper BYTE mov al,es:[ga_count] ;Lock count (moveable segments) mov [si].ge_wcLock,ax ;Put in public structure mov WORD PTR [si].ge_wcPageLock,0 ;Zero the page lock count mov al,es:[ga_flags] ;BYTE of flags xor ah,ah ;No upper BYTE mov [si].ge_wFlags,ax ;Put in public structure mov ax,es:[ga_next] ;Put next pointer in structure mov WORD PTR [si].ge_dwNext,ax mov WORD PTR [si].ge_dwNext + 2,0
;** Use DPMI to compute linear address of selector mov ax,6 ;Get Segment Base Address mov bx,es ;Get the segment value int 31h ;Call DPMI mov WORD PTR [si].ge_dwAddress,dx ;Save linear address mov WORD PTR [si].ge_dwAddress + 2,cx
;** If this is a data segment, get local heap information mov ax,[si].ge_hBlock ;Get the handle cCall Walk286VerifyLocHeap mov [si].ge_wHeapPresent,TRUE ;Flag that there's a heap jnc W2_10 ;There really is no heap mov [si].ge_wHeapPresent,FALSE ;Flag that there's no heapW2_10:
;** If the owner is a PDB, translate this to the TDB mov bx,[si].ge_hOwner ;Get the owner cCall HelperHandleToSel, <bx> ;Translate to selector mov bx,ax ;Get the selector in BX cCall HelperVerifySeg, <ax,2> ;Must be two bytes long or ax,ax ;Is it? jz W2_15 ;No. push es ;Save ES for later mov es,bx ;Point to possible PDB block cmp es:[0],20CDh ;Int 20h is first word of PDB jnz W2_12 ;Nope, don't mess with this mov ax,bx ;Pass parameter in AX cCall HelperPDBtoTDB ;Get the corresponding TDB or ax,ax ;Was one found? jz W2_11 ;No. mov [si].ge_hOwner,ax ;Make the owner the TDB insteadW2_11: or [si].ge_wFlags,GF_PDB_OWNER ;Flag that a PDB owned blockW2_12: pop es ;Restore ESW2_15:
;** Check for this being the last item in both lists mov ax,es ;Get the current pointer cmp ax,es:[ga_next] ;See if we're at the end jne W2_20 ;No mov WORD PTR [si].ge_dwNext,0 ;NULL the next pointer mov WORD PTR [si].ge_dwNext + 2,0W2_20: mov ax,es ;Get current pointer mov cx,wFlags ;Get the flags back cCall NextLRU286 ;Get next LRU list pointer or 0 mov WORD PTR [si].ge_dwNextAlt,ax mov WORD PTR [si].ge_dwNextAlt + 2,0
W2_End:cEnd
; Walk286Handle;; Finds an arena pointer given a block handle
cProc Walk286Handle, <PUBLIC,NEAR>, <di,si,ds> parmW hBlockcBegin mov ax,hBlock ;Get the block handle cCall HelperHandleToSel, <ax> ;Convert to selector cCall SelToArena286 ;Get the arena pointer jnc W2H_10 ;Must be OK xor ax,ax ;Return a 0L xor dx,dx jmp SHORT W2H_End ;Error in conversion, get outW2H_10: mov ax,bx ;Get the low word xor dx,dx ;No high wordW2H_End:cEnd
; WalkLoc286Count;; Returns the number of blocks in the given local heap
cProc WalkLoc286Count, <PUBLIC,NEAR>, <di> parmW hHeapcBegin ;** Verify that it has a local heap mov ax, hHeap ;Get the block cCall Walk286VerifyLocHeap ;Verify it jnc LC_10 ;It's OK xor ax,ax ;No heap jmp SHORT LC_End ;Get outLC_10:
;** Point to the block mov ax,hHeap ;Get the heap block cCall HelperHandleToSel, <ax> ;Convert it to a selector mov es,ax ;Use ES to point to it mov bx,es:[6] ;Get a pointer to the HeapInfo struct
;** Get the number of blocks mov ax,es:[bx].hi_count ;Get the countLC_End:cEnd
; WalkLoc286First;; Returns a handle to the first block in the 286 global heap.
cProc WalkLoc286First, <PUBLIC,NEAR>, <di> parmW hHeapcBegin ;** Verify that the given global block has a local heap mov ax, hHeap ;Get the block cCall Walk286VerifyLocHeap ;Verify it jnc LF_10 ;It's OK xor ax,ax ;No heap jmp SHORT LF_End ;Get outLF_10:
;** Point to the global block mov ax,hHeap ;Get the heap block cCall HelperHandleToSel, <ax> ;Convert it to a selector mov es,ax ;Use ES to point to it mov bx,es:[6] ;Get a pointer to the HeapInfo struct
;** Get the first block and return it mov ax,WORD PTR es:[bx].hi_first ;Get the first blockLF_End:cEnd
; WalkLoc286;; Takes a pointer to a block and returns a GLOBALENTRY structure; full of information about the block. If the block pointer is; NULL, looks at the first block. The last field in the GLOBALENTRY; structure is used to chain to the next block and is thus used to walk; the heap.
cProc WalkLoc286, <PUBLIC,NEAR>, <di,si,ds> parmW wBlock parmD lpLocal parmW hHeapcBegin ;** Verify that it has a local heap mov ax, hHeap ;Get the block cCall Walk286VerifyLocHeap ;Verify it jnc LW_10 ;It's OK jmp LW_End ;Get outLW_10:
;** Get variables from the TOOLHELP DGROUP mov ax,_DATA ;Get the variables first mov ds,ax ;Point to our DS mov bx,hUserHeap ;BX=User's heap block mov cx,hGDIHeap ;CX=GDI's heap block
;** Point to the heap mov ax,hHeap ;Get the heap block cCall HelperHandleToSel, <ax> ;Convert it to a selector mov es,ax ;Use ES to point to it lds di,lpLocal ;Point to the LOCALENTRY structure mov [di].le_wHeapType,NORMAL_HEAP ;In case we don't match below... cmp bx,hHeap ;User's heap? jnz LW_3 ;No mov [di].le_wHeapType,USER_HEAP ;Yes jmp SHORT LW_5 ;Skip onLW_3: cmp cx,hHeap ;GDI's heap? jnz LW_5 ;No mov [di].le_wHeapType,GDI_HEAP ;YesLW_5: mov si,wBlock ;Get the address of the block
;** Get information about the given block mov bx,es:[si].la_handle ;Get the handle mov [di].le_hHandle,bx ;Save in the public structure mov ax,si ;Get block address add ax,la_fixedsize ;Skip fixed size local arena mov [di].le_wAddress,ax ;Save the block address mov ax,es:[si].la_next ;Get the address of the next block mov [di].le_wNext,ax ;Save the next pointer sub ax,si ;Compute the size sub ax,SIZE LocalArena ;Don't count arena size mov [di].le_wSize,ax ;Save in public structure mov ax,es:[si].la_prev ;Get the flags and ax,3 ;Mask out all but flags mov [di].le_wFlags,ax ;Save in structure
;** Moveable arenas are bigger and have a lock count to get test al,LA_MOVEABLE ;Block has a handle iff it's moveable jz SHORT LW_NoHandle ;No handle info sub [di].le_wSize, (SIZE LocalArena) - la_fixedsize add [di].le_wAddress, (SIZE LocalArena) - la_fixedsize xor ah,ah ;Clear upper word mov al,es:[bx].lhe_count ;Get lock count mov [di].le_wcLock,ax ;Save it jmp SHORT LW_20 ;Skip no handle infoLW_NoHandle: mov ax, [di].le_wAddress ;Handle of fixed block is real offset mov [di].le_hHandle, ax mov [di].le_wcLock,0LW_20: ;** See if it's the end cmp [di].le_wNext,si ;Loop pointer? jnz LW_End ;Nope mov [di].le_wNext,0 ;Set a zero pointerLW_End:cEnd
; Walk286VerifyLocHeap;; Verifies that the given global block points to a data segment; with a local heap.;; Call:; AX = Block handle or selector; Return:; Carry flag set iff NOT a local heap segment;; Destroys all registers except AX, ESI, EDI, DS, and ES
cProc Walk286VerifyLocHeap, <PUBLIC,NEAR>, <es,si,di>cBegin ;** Convert to a handle cCall HelperHandleToSel, <ax>
;** Verify the selector push ax ;Save the parameter mov bx,SIZE LocalInfo ;Get the size cCall HelperVerifySeg, <ax,bx> ;Check the selector or ax,ax ;Is it valid? pop ax ;Restore parameter jnz VLH_SelOK ;Yes. stc ;Set error flag jmp SHORT VLH_End ;Get outVLH_SelOK:
;** Check data segment to see if it has a local heap mov es,ax ;Point to the local block with ES cCall HelperSegLen, <ax> ;Get the length of the heap or ax,ax ;Check for error jz VLH_NoHeap ;Get out on error mov cx,ax ;Use CX for comparisons cmp cx,8 ;At least 8 bytes long? ja VLH_10 ;Yes stc ;No -- set error flag and get out jmp SHORT VLH_EndVLH_10: mov bx,es:[6] ;Get offset to HeapInfo struct or bx,bx ;If NULL, no local heap jz VLH_NoHeap ;Get out sub cx,bx ;See if HeapInfo is beyond segment jbe VLH_NoHeap sub cx,li_sig + 2 ;Compare against last structure mem jbe VLH_NoHeap cmp es:[bx].li_sig,LOCALHEAP_SIG ;Make sure the signature matches jne VLH_NoHeap ;Doesn't match clc ;Must be a heap! jmp SHORT VLH_End
VLH_NoHeap: stc ;Set error flag
VLH_End:cEnd
;** Private helper functions
; SelToArena286;; Finds the arena entry for the given selector or handle.; The arena entry is stored 16 bytes before the block in linear; address space.;; Caller: AX = Selector; Returns: BX = Arena entry; Trashes everything except segment registers and AX; Carry set on error
cProc SelToArena286, <NEAR>, <es,ds,ax>cBegin ;** Convert to a handle cCall HelperHandleToSel, <ax>
;** Verify selector push ax ;Save the parameter cCall HelperVerifySeg, <ax,1> ;Check the selector or ax,ax ;Is it valid? pop ax ;Restore parameter jnz STA_SelOK ;Must be stc ;Nope. Set error flag and exit jmp SHORT STA_EndSTA_SelOK: ;** If this is Win30StdMode, we're in the old KRNL286 which used ;* an arcane method of finding the arena. If that's the case ;** here, handle it seperately. mov bx,_DATA ;Get the static data segment mov ds,bx test wTHFlags,TH_WIN30STDMODE ;3.0 Std Mode? jnz STA_OldKRNL286 ;Yes mov bx,segKernel ;Get the KERNEL variable segment mov es,bx mov bx,npwSelTableLen ;Get the pointer mov dx,es:[bx] ;Get the selector table length mov bx,npdwSelTableStart ;Get the start of the sel table mov bx,es:[bx] ;Get the linear offset (32 bits) mov es,hMaster ;Point to the arena table and al,not 7 ;Clear the RPL bits for table lookup shr ax,2 ;Convert to WORD offset cmp ax,dx ;Check to see if off the end of table jb STA_InTable ;It's in the table stc ;Set error flag--not in table jmp SHORT STA_End ;Get outSTA_InTable: add bx,ax ;Add the selector offset mov bx,es:[bx] ;Do the sel table indirection clc ;BX now points to arena segment jmp SHORT STA_End ;Skip the old stuff
STA_OldKRNL286: mov bx,ax ;Selector in BX mov ax,6 ;DPMI function 6, Get Seg Base Addr int 31h ;Call DPMI sub dx,10h ;Move back 16 bytes sbb cx,0 ; (this is a linear address) mov ax,7 ;DPMI function 7, Set Seg Base Addr mov bx,wSel ;Use our roving selector int 31h ;Call DPMI mov ax,8 ;DPMI function 8, Set Seg Limit xor cx,cx ;No upper byte mov dx,16 ;Just 16 bytes int 31h ;Call DPMI mov ax,9 ;DPMI function 9, Set Access Rights mov cl,0b2h ;Desired rights byte int 31h ;Call DPMI ;Return arena segment pointer in BXSTA_End:cEnd
; NextLRU286;; Checks the given arena table pointer to see if it is the last; arena entry on the list.; Uses a grungy method that is necessitated because of the; unterminated linked lists we're dealing with here. The count; stored is the only reliable method for finding the end. So, to; provide random access to blocks in the heap, the heap is searched; from top to bottom to find the block and see if it is the last; one. If it is or if it is not on the given list, returns a 0; pointer to the next item.;; If this search is for the entire global heap, we do not get the; LRU link, but return NULL in AX. This speeds this up alot!;; Caller: AX = Arena table pointer; CX = GLOBAL_ALL, GLOBAL_FREE, or GLOBAL_LRU; Return: AX = Next arena table pointer or 0 if no more; Trashes all registers except segment registers and SI,DI
cProc NextLRU286, <NEAR,PUBLIC>, <es,ds,si,di>cBegin ;** Decode the flags mov bx,_DATA ;Get the static data segment mov ds,bx ;Point with DS mov es,hMaster ;Segment of master block cmp cx,GLOBAL_ALL ;Don't do this on full heap search jne @F jmp SHORT NL_BadList ;Just return NULL for this one@@: cmp cx,GLOBAL_FREE ;Check free list? je NL_Free ;Yes
;** Loop through LRU list until we find this itemNL_LRU: mov si,ax ;Save the selector in AX mov cx,es:[gi_lrucount] ;Get the number of objects jcxz NL_Bad ;No object so return end dec cx ;We don't want to find the last one jcxz NL_Bad ;1 object so return end mov ds,es:[gi_lruchain] ;Get a pointer to the first itemNL_LRULoop: mov ax,ds ;Get in AX so we can compare cmp si,ax ;Match yet? je NL_ReturnNext ;Found it, return next item mov ds,ds:[ga_lrunext] ;Not found yet, get the next one loop NL_LRULoop ;Loop through all items
;** Unlock the LRU sweepingNL_Bad: dec es:[gi_lrulock] ;OK to LRU sweep now mov ax, _DATA ;Point to TH Data seg mov ds, ax dec wLRUCount ;Keep a count of this jmp SHORT NL_BadList ;Not here either. Get out
;** Loop through free list until we find this itemNL_Free: mov si,ax ;Save the selector in SI mov cx,es:[gi_free_count] ;Get the number of objects jcxz NL_BadList ;0 objects so return end dec cx ;We don't want to find the last one jcxz NL_BadList ;1 object so return end mov ds,es:[hi_first] ;Get a pointer to the first itemNL_FreeLoop: mov ds,ds:[ga_lrunext] ;Not found yet, get the next one mov ax,ds ;Get the pointer so we can compare it cmp ax,si ;Is this the one? je NL_ReturnNext ;Yes, return it loop NL_FreeLoop ;Loop through all items jmp SHORT NL_BadList ;Not here either. Get out
NL_ReturnNext: mov ax,ds:[ga_lrunext] ;Return the next one jmp SHORT NL_End ;Get out
NL_BadList: xor ax,ax ;Return zero for error
NL_End:cEnd
sEnd END
|
