|
|
TITLE GMEM - Register interface to global memory allocator
.xlistinclude kernel.incinclude tdb.incinclude protect.inc.list
externFP SetSelectorLimit
DataBegin
externB fBooting;externW curTDB;externW pGlobalHeapexternW SelTableStartexternW SelTableLen
ifdef WOWglobalB fInAlloc, 0globalW UserSelArray, 0globalW SelectorFreeBlock, 0endif
DataEnd
sBegin CODEassumes CS,CODE
externNP DPMIProcDPMICALL MACRO callno mov ax, callno call DPMIProc ENDM
;externW gdtdsc
externNP gspliceexternNP gjoinexternNP gzeroexternNP gsearchexternNP gmarkfree;externNP gcheckfreeexternNP gmovebusyexternNP gcompactexternNP glruaddexternNP glrudelexternNP glrutopexternNP gnotifyexternNP henumexternNP is_there_theoretically_enough_spaceexternNP can_we_clear_this_space
externNP get_physical_addressexternNP set_physical_addressexternNP alloc_selexternNP alloc_data_sel_aboveexternNP pdrefexternNP set_sel_limitexternNP mark_sel_PRESENTexternNP mark_sel_NPexternNP free_selexternNP FreeSelArrayexternNP GrowSelArrayexternNP get_arena_pointerexternNP get_temp_selexternNP get_blotto;externNP get_selexternNP PreallocSelexternNP AssociateSelectorexternNP GetAccessWordexternNP SetAccessWordexternFP set_discarded_sel_owner
if ROMexternNP IsROMObjectendif
if KDEBUGexternNP CheckGAllocBreakendif
;-----------------------------------------------------------------------;; galign ;; ;; Aligns the size request for a global item to a valid para boundary. ;; ;; Arguments: ;; BX = #paras ;; CF = 1 if #paras overflowed. ;; ;; Returns: ;; DX = #paras aligned, to next higher multiple of 2 ;; ;; Error Returns: ;; DX = FFFFh ;; ;; Registers Preserved: ;; all ;; Registers Destroyed: ;; none ;; Calls: ;; nothing ;; History: ;; ;; Mon Sep 22, 1986 03:14:56p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc galign,<PUBLIC,NEAR>cBegin nogen
jc align_error ; Overflow occur? lea dx,[bx+GA_ALIGN] ; No, add alignment amount and dl,GA_MASK ; ...modulo alignment boundary cmp dx,bx ; Test for overflow jnb align_exit ; Yes, continuealign_error: mov dx,0FFFFh ; Return impossible sizealign_exit: retcEnd nogen
;-----------------------------------------------------------------------;; galloc ;; ;; Allocates global memory. ;; ;; Arguments: ;; AX = allocation flags ;; BX = #paragraphs ;; CX = owner field ;; DS:DI = address of global heap info ;; ;; Returns: ;; AX = handle to object or zero ;; BX = size of largest free block if AX = 0 ;; CX = AX ;; ;; Error Returns: ;; DX = 0 ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ;; Calls: ;; gsearch ;; ghalloc ;; glruadd ;; gmarkfree ;; History: ;; ;; Wed Jun 24, 1987 03:04:32a -by- David N. Weise [davidw] ;; Added support for Global Notify. ;; ;; Mon Sep 22, 1986 02:38:19p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
AccessWord dw DSC_DATA+DSC_PRESENT dw (DSC_DISCARDABLE SHL 8) + DSC_DATA+DSC_PRESENT dw DSC_CODE+DSC_PRESENT dw (DSC_DISCARDABLE SHL 8) + DSC_CODE+DSC_PRESENT dw DSC_DATA+DSC_PRESENT dw (DSC_DISCARDABLE SHL 8) + DSC_DATA+DSC_PRESENT dw DSC_DATA+DSC_PRESENT dw (DSC_DISCARDABLE SHL 8) + DSC_DATA+DSC_PRESENT
cProc galloc,<PUBLIC,NEAR>cBegin nogen
if ROM and KDEBUG if 1 %out Remove me someday
endif or cx,cx ; had trouble with owner == 0 jnz @f ; too many times! Debug_Out "ROMKRNL: galloc with owner = 0!"@@:endif
if KDEBUG test al,GA_DISCCODE ; If discardable code, allow alloc jnz @F call CheckGAllocBreak jnc @F jmp gaerr@@:endif
or bx,bx ; Allocating zero size? jnz @F jmp allocate_zero_size@@:
ifdef WOW push ds SetKernelDS mov fInAlloc, 1 mov SelectorFreeBlock, 0 mov UserSelArray, 0 UnSetKernelDS pop dsendif call gsearch ; Search for block big enough jnz bleech mov cx, ax
ifdef WOW push ds SetKernelDS mov fInAlloc, 0 mov SelectorFreeBlock, 0 mov UserSelArray, 0 UnSetKernelDS pop dsendif
ret ; Done, if couldn't get enoughbleech: mov es,ax push dx
ifdef WOW
push ds SetKernelDS mov fInAlloc, 0 mov SelectorFreeBlock, 0 mov ax, UserSelArray UnSetKernelDS pop ds or ax, ax jnz got_Sel mov ax, es
old_path:
endif mov bx,dx cCall get_physical_address,<ax> add ax,10h ; Calculate address of object adc dx,0 mov cx, ax ; in DX:CX
and bx, ((GA_CODE_DATA+GA_DISCARDABLE) shl 8) + GA_DGROUP or bl, bh xor bh, bh shl bx, 1 mov ax, cs:AccessWord[bx] ; Pick up access rights for selector cCall alloc_sel,<dx,cx,es:[di].ga_size>
got_sel: pop dx or ax, ax jz short gaerr1 cCall AssociateSelector,<ax,es> test dl,GA_MOVEABLE ; Is this a moveable object? jnz moveable test dh, GA_DISCARDABLE ; We have a fixed block jnz not_moveable ; Not interested in discardable blocks mov bx, ax%out THIS IS WRONG!!!
ifdef WOW ; the following dpmicall is basically a NOP. so just ; avoid the call altogether. ; - Nanduri Ramakrishnaelse mov ax, 4 ; Lock the WIN386 pages ;bugbugbugbug DPMICALL ax ; int 31h mov ax, bxendif jmps not_moveablemoveable: mov es:[di].ga_count,0 ; Initialize lock count to 0 StoH al ; Mark as moveable blocknot_moveable: mov es:[di].ga_handle,ax ; Set handle in arena mov bx, ax ; AX and BX handle
call glruadd ; Yes, Add to LRU chain mov cx, ax ret
allocate_zero_size: test al,GA_MOVEABLE ; Yes, moveable? jz gaerr ; No, return error (AX = 0)
mov bx, ax and bx, ((GA_CODE_DATA+GA_DISCARDABLE) shl 8) + GA_DGROUP or bl, bh ; Above bits are exclusive xor bh, bh shl bx, 1 mov ax, cs:AccessWord[bx] ; Pick up access rights for selector and al, NOT DSC_PRESENT ; These are NOT present xor dx, dx ; Base of zero for now cCall alloc_sel,<dx,dx,cx> or ax, ax jz gaerr
cCall AssociateSelector,<ax,cx> StoH al ; Handles are RING 2 mov bx,axga_exit: mov cx, ax ret
gaerr1: xor si,si call gmarkfreegaerr: KernelLogError DBF_WARNING,ERR_GALLOC,"GlobalAlloc failed" xor dx,dx ; DX = 0 means NOT out of memory xor ax,ax ; Return AX = 0 to indicate error jmps ga_exitcEnd nogen
;-----------------------------------------------------------------------;; grealloc ;; ;; Reallocates the given global memory object. ;; ;; Arguments: ;; AX = allocation flags ;; BX = #paragraphs for new size ;; CX = new owner field value ;; DX = existing handle ;; DS:DI = address of global heap info ;; ;; Returns: ;; AX = handle to object or zero ;; DX = size of largest free block if AX = 0 ;; CX = AX ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; SI ;; ;; Calls: ;; ;; History: ;; ;; Mon 05-Feb-1990 21:07:33 -by- David N. Weise [davidw] ;; Got rid of the spagetti code. ;; ;; Mon Sep 22, 1986 10:11:48a -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc grealloc,<PUBLIC,NEAR>,<si>
localW rflags localW hMem localW oldhMem localW owner localW rsize localW canmove localB locked localB mflags localW numselscBegin mov rflags,ax mov hMem,dx mov oldhMem,dx mov owner,cx mov rsize,bx call pdref mov dx,bx ; save owner if discarded mov word ptr mflags,cx mov bx,rsize jnz handle_ok jmp racreate ; Do nothing with 0, free or discarded handleshandle_ok: test byte ptr rflags,GA_MODIFY ; Want to modify table flags? jnz ramodify ; Yes go do it or bx,bx ; Are we reallocing to zero length? jz radiscard jmp ra_shrink_grow ; No, continue
;-----------------------------------------------------------------------;; Here to discard object, when reallocating to zero size. This ;; feature is only enabled if the caller passes the moveable flag ;;-----------------------------------------------------------------------;
radiscard: or ch,ch ; Is handle locked? jnz radiscard_fail test byte ptr rflags,GA_MOVEABLE ; Did they want to discard? jz radiscard_fail ; No, then return failure. mov al,GN_DISCARD ; AL = discard message code xor cx,cx ; CX = means realloc mov bx,hMem ; BX = handle push es call gnotify ; See if okay to discard pop es jz radiscard_fail ; No, do nothing call glrudel ; Yes, Delete handle from LRU chain
cCall mark_sel_NP,<si,es:[di].ga_owner>
xor si,si call gmarkfree ; Free client data mov ax,0 ; don't change flags jz @F ; Return NULL if freed a fixed block mov bx, si mov ax,hMem ; Return original handle, except@@: jmp raexit ; GlobalLock will now return null.
radiscard_fail: KernelLogError DBF_WARNING,ERR_GREALLOC,"GlobalReAlloc failed" xor dx,dx xor ax,ax jmp raexit
;-----------------------------------------------------------------------;; There are 2 attributes that can change: ;; 1) Fixed -> moveable - added in 2.x, probably not used by many ;; 2) nondiscardable <-> discardable ;; 3) non-shared -> shared, i.e., the owner changes ;;-----------------------------------------------------------------------;
ramodify:if ROM cCall IsROMObject,<hMem> ; If someone is trying to modify a jc ramod_done ; ROM object, just pretend it workedendif mov ax,rflags ; Get new flags mov dx,owner ; Get new owner field value or si,si ; Moveable object? jnz is_moveable ; yes, change discardability/owner test al,GA_MOVEABLE ; Make fixed into moveable? jz ra_mod_owner ; Fixed, can ONLY change owner
push ax push cx mov ax, es:[di].ga_handle ; Turn selector into handle StoH al mov bx, ax mov es:[di].ga_handle, ax mov es:[di].ga_count, 0 ; 0 lock count for new movable obj pop cx pop ax mov si,bx
; fall through to code that makes [non]discardable and may change owner
is_moveable: call glrudel ; Remove from lru chain, even though push bx mov bx, ax cCall GetAccessWord,<si> and ah, not DSC_DISCARDABLE ; Clear discard bit test bh, GA_DISCARDABLE jz ra_notdiscardable or ah, DSC_DISCARDABLEra_notdiscardable: cCall SetAccessWord,<si,ax> mov ax, bx pop bx test cl,HE_DISCARDED ; Is this a discarded handle? jz ramod1 ; No, continue test ah,GA_SHAREABLE ; Only change owner if making shared jz ramod_done
push bx push es mov bx, si mov es, dx call set_discarded_sel_owner pop es pop bx jmps ramod_done
ramod1: call glruadd ; only adds to list IF object is disc
ra_mod_owner: test ah,GA_SHAREABLE ; Only change owner if making shared jz ramod_done mov es:[di].ga_owner,dx ; Set new owner valueramod_done: mov ax,hMem ; Return the same handle jmp raexit ; All done
;-----------------------------------------------------------------------;; We are here to grow a 0 sized object up big. ;;-----------------------------------------------------------------------;
racreate: test cl,HE_DISCARDED ; Is this a discarded handle? jz racre_fail ; No, return error or bx,bx ; Are we reallocing to zero length? mov ax,hMem jz racre_done ; Yes, return handle as is.if KDEBUG test cl,GA_DISCCODE ; if discardable code, allow realloc jnz @F call CheckGAllocBreak jc racre_fail@@:endif mov ax,GA_MOVEABLE ; Reallocating a moveable object or ax,rflags ; ...plus any flags from the caller
and cl,GA_SEGTYPE or al,cl mov cx,dx ; get owner push ds SetKernelDSife ROM cmp fBooting, 1 ; Allocate high while booting je @Fendif test al,GA_DISCCODE ; Discardable code segment? jz ranotcode@@: or al,GA_ALLOCHIGH ; Yes, allocate highranotcode: pop ds UnSetKernelDS mov [di].gi_cmpflags,al ; Save flags for gcompact and [di].gi_cmpflags,CMP_FLAGS push si ; save handle call gsearch ; Find block big enough pop si ; restore existing handle jz racre_fail1
mov bx,ax ; save new block cCall mark_sel_PRESENT,<ax,si> ; sets a new set of sels if necessary or si,si jz racre_worst_case xchg ax,si ; Return original/new handle ; Set back link to handle in new block cCall AssociateSelector,<ax,si> mov es,si mov es:[di].ga_handle,ax mov es:[di].ga_count,0 call glruadd ; Add to LRU chain jmps racre_done
racre_worst_case: mov es,bx ; Free block if no handles available. xor si,si call gmarkfree
racre_fail: xor dx,dxracre_fail1: push dx KernelLogError DBF_WARNING,ERR_GREALLOC,"GlobalReAlloc failed" pop dx xor ax,ax ; Yes, return failureracre_done: jmp raexit
;-----------------------------------------------------------------------;; This is what most would have thought is the guts of GlobalRealloc. ;;-----------------------------------------------------------------------;
ra_shrink_grow:
if KDEBUG test es:[di].ga_flags,GA_DISCCODE jz ok INT3_WARN ; GlobalRealloc of discardable code!ok:endif cmp bx,es:[di].ga_size jz rasame
add bx,1 ; add room for header, set carry bit jc ra_s_g_fail call galign ; assuming there is room. dec dx ; Exclude header again mov si,dx
; Here if not trying to realloc this block to zero; ES:0 = arena header of current block; AX:0 = client address of current block; CH = lock count of current block; DX = new requested size of block; SI = new requested size of block
mov bx,es:[di].ga_next ; Get address of current next header cmp si,es:[di].ga_size ; Are we growing or shrinking? ja raextend ; We are growing
call rashrinkrasame: mov ax,hMem ; Return the same handle jmp raexit ; All done
raextend: test rflags,GA_DISCCODE ; Not allowed to grow a disccode seg jnz ra_s_g_failif KDEBUG call CheckGAllocBreak jc ra_s_g_failendif push ax call GrowSelArray mov numsels, cx ; Save how many to free just in case mov cx, ax pop ax jcxz ra_s_g_fail ; Didn't get selectors mov hMem, cx ; We have a new handle call ragrow jnc rasame test mflags,GA_DISCARDABLE ; if discardable, just stop now jz ramove ; since it might get discarded!ra_s_g_fail: KernelLogError DBF_WARNING,ERR_GREALLOC,"GlobalReAlloc failed" xor ax,ax ; Yes, return failure xor dx,dx jmp raexit
; Here to try to move the current block; AX = client address of current block; ES:0 = arena header of current block; CH = lock count of current block; SI = new requested size of block
ramove: mov canmove, 1 mov dx,rflags ; get the passed in flags test dx,GA_MOVEABLE ; Did they say OK to move jnz ramove1 ; Yes, try to move even iflocked or fixed cmp locked, 0 ; Locked? jnz racompact ; Continue if this handle not locked ; yes, try to find space to grow in place or dx,GA_MOVEABLE ; If moveable, make sure bit set. test hMem,GA_FIXED ; Is this a moveable handle? jz ramove2 ; Yes, okay to moveracompact: xor dx,dx ; No, get size of largest free block call gcompact jmps racantmove
ramove1: test hMem, GA_FIXED jz ramove2 and dx, NOT GA_MOVEABLEramove2: mov ax,dx ; AX = allocation flags mov bx,si ; BX = size of new block call PreAllocSel ; for gmovebusy later jz racantmove mov cx,bx ; CX = owner (use size for now) call gsearch ; Find block big enough jz racantmove ; Cant find one, grow in place now? mov cx,hMem
push ax cCall get_arena_pointer,<cx>;;; mov es,ax;;; mov es,es:[di].ga_next ; get real arena header;;; mov si,es:[di].ga_prev mov si, ax ; SI = source arena pop es ; ES = destination arena
call gmovebusy ; Call common code to move busy block ; (AX destroyed) push bx push cx mov bx, es:[di].ga_size xor cx,cxREPT 4 shl bx,1 rcl cx,1ENDM cCall set_sel_limit, <es:[di].ga_handle>
pop cx pop bx mov ax,cx ; Return new handleraexit: mov cx,ax jcxz ra_done test hMem,GA_FIXED ; Is this a moveable object? jz ra_done ; no, don't lock mov bx, axifdef WOW ; the following dpmicall is basically a NOP. so just ; avoid the call altogether. ; - Nanduri Ramakrishnaelse mov ax, 4 ; Lock the WIN386 pages ; bugbugbugbug DPMICALL ax ; int 31h mov ax, bxendif jmps ra_done
racantmove: mov dx, hMem call pdref
mov bx,rsize add bx,1 ; add room for header, set carry bit call galign ; assuming there is room. dec dx ; Exclude header again mov si,dx
mov bx,es:[di].ga_next ; Get address of current next header call ragrow jc racmove3 jmp rasame
racmove3: xor dx,dx ; No, get size of largest free block call gcompact mov dx,ax ; DX = size of largest free block
rafailmem: cCall get_arena_pointer,<hMem> mov es,ax mov ax,es:[di].ga_size ; AX = size of current block mov es,es:[di].ga_next ; Check following block cmp es:[di].ga_owner,di ; Is it free? jne rafailmem0 ; No, continue add ax,es:[di].ga_size ; Yes, then include it as well inc axrafailmem0: cmp ax,dx ; Choose the larger of the two jbe rafailmem1 mov dx,axrafailmem1: push dx ; Save DX KernelLogError DBF_WARNING,ERR_GREALLOC,"GlobalReAlloc failed" pop dx ; RestoreDX xor ax,ax jmps raexit
ra_done: ; 3 feb 1990, this push ax ; is a last minute hack push bx push cx push dx mov bx,hMem mov cx,oldhMemife RING-1 inc bx and bl,NOT 1 inc cx and cl,NOT 1else or bl, 1 or cl, 1endif cmp bx,cx ; was a new selector allocated? jz ra_really_done ; or ax,ax ; figure out if we suceeded jz ra_ra cCall FreeSelArray,<cx> ; free the original selector jmps ra_really_done
ra_ra: cCall get_physical_address,<bx> cCall set_physical_address,<oldhMem> cCall get_arena_pointer,<hMem> INT3_ANCIENT cCall AssociateSelector,<cx,es> push ax
mov cx, numsels mov ax, hMemfsloop: cCall free_sel,<ax> add ax, 8 loop fsloop
pop es mov ax,oldhMem mov es:[ga_handle],ax cCall AssociateSelector,<ax,es>
ra_really_done: pop dx pop cx pop bx pop ax
cEnd
;-----------------------------------------------------------------------;; rashrink ;; ;; Shrinks the given block ;; ;; Arguments: ;; Here to shrink a block ;; ES:0 = arena header of current block ;; DX = new requested size of block ;; SI = new requested size of block ;; ;; Returns: ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ALL but DS, DI ;; ;; Calls: ;; gsplice ;; gmarkfree ;; ;; History: ;; ;; Tue 06-Feb-1990 01:03:54 -by- David N. Weise [davidw] ;; I got no clue what the history of this thing is, all I know is ;; that I got to fix it fast to prevent selector leak. ;;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothing
cProc rashrink,<PUBLIC,NEAR>cBegin nogen
mov bx,si xor cx,cx REPT 4 shl bx,1 rcl cx,1 ENDM mov ax,es:[di].ga_handle or ax,ax jz ra_free
; !! the following was added Tue 06-Feb-1990 01:47:12; it doesn't belong here really but it is the only way to; prevent selector leak.
push bx push cx push si
mov si,ax cCall GetAccessWord,<si> mov bl, ah mov ax, si and bl, 0Fh ; Current hlimit inc bl ; number of selectors there now mov cx,dx
add cx, 0FFFh rcr cx, 1 ; 17 bitdom shr cx, 11 sub bl, cl jbe ignore_this_shi
xor bh,bh ; BX = number of selectors to free shl cx,3 .errnz SIZE DscPtr - 8 add cx,si ; CX = selector to start to free xchg bx,cx@@: cCall free_sel,<bx> add bx,SIZE DscPtr loop @B
ignore_this_shi: pop si pop cx pop bx
; end of shi
Handle_To_Sel al cCall set_sel_limit,<ax>ra_free: inc dx ; Test for small shrinkage inc dx .errnz GA_ALIGN - 1
cmp dx,es:[di].ga_size ; Enough room from for free block? ja rashrunk ; No, then no change to make
; !! why isn't the PreAllocSel done before the set_sel_limit?; Because it belongs with the 'gsplice'.
call PreallocSel ; Must be able to get selector jz rashrunk ; Yes, ES:DI = cur block, SI=new block inc si ; Include header in size of block call gsplice ; splice new block into the arena mov es,si ; ES:DI = new free block xor si,si call gmarkfree ; Mark it as freerashrunk: retcEnd nogen
;-----------------------------------------------------------------------;; ragrow ;; ;; Tries to grow the given global memory object in place ;; ;; Arguments: ;; AX:0 = client address of current block ;; ES:0 = arena header of current block ;; BX:0 = arena header of next block ;; DX = SI = new requested size of block ;; ;; Returns: ;; CY = 0 Success ;; ;; CY = 1 Failed ;; ES preserved ;; DX contains free memory required ;; ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ALL but DS, DI ;; ;; Calls: ;; is_there_theoretically_enough_space ;; can_we_clear_this_space ;; gjoin ;; gzero ;; rashrink ;; ;; History: ;; ;; Mon 05-Sep-1988 20:10:15 -by- David N. Weise [davidw] ;; Made ragrow be more intelligent by trying to extend into moveable ;; blocks. ;;-----------------------------------------------------------------------;cProc ragrow,<PUBLIC,NEAR>cBegin nogen
push si push es ; Save current block address sub dx, es:[di].ga_size ; compute amount of free space wanted mov es,bx ; ES = next block address mov cx,[di].hi_count push cx push es call is_there_theoretically_enough_space pop es pop cx cmp ax,dx jb ragx call can_we_clear_this_space jz ragx pop cx ; clear the stack pop si push si call gjoin ; and attach to end of current block pop si ; (will free a selector) test byte ptr rflags,GA_ZEROINIT ; Zero fill extension? jz ranz ; No, continue
mov bx, dx ; number of paragraphs to fill mov dx, si ; New size of block sub dx, bx ; Old size of block inc dx ; Paragraph offset of where to zero cCall alloc_data_sel_above,<es,dx> push bx push ax ; set the limit really big push es cCall SetSelectorLimit,<ax,0Fh,0FFFFh> pop es pop ax pop cx ; Number of paragraphs to zero mov bx, ax ; Selector to fill call gzero ; zero fill extension cCall free_sel,<bx>ranz: mov dx, si mov bx,es:[di].ga_next ; Pick up new next block address call rashrink ; Now shrink block to correct size clc retragx: pop es ; Recover current block address pop si stc retcEnd nogen
;-----------------------------------------------------------------------;; gfree ;; ;; Frees a global object. ;; ;; Arguments: ;; DX = global memory object handle ;; CX = owner field value to match or zero if dont care ;; DS:DI = address of global heap info ;; ;; Returns: ;; AX = 0 ;; CX = 0 ;; ;; Error Returns: ;; AX = -1 ;; CX = -1 ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ? ;; Calls: ;; gdref ;; free_object ;; hfree ;; ;; History: ;; ;; Sat Sep 20, 1986 11:48:38a -by- David N. Weise [davidw] ;; Added this nifty comment block and restructured. ;;-----------------------------------------------------------------------;
cProc gfree,<PUBLIC,NEAR>cBegin nogen
push cx call pdref
pop dx jz object_discarded call free_object jmps gfree_exitobject_discarded:
cCall AssociateSelector,<si,di> cCall FreeSelArray,<si> xor ax,ax ;!!! just for now force success
gfree_exit: mov cx,ax retcEnd nogen
;-----------------------------------------------------------------------;; free_object ;; ;; Arguments: ;; DX = owner field value to match or zero if dont care ;; DS:DI = address of global heap info ;; ES:DI = address of arena header ;; ;; Returns: ;; AX = 0 ;; ;; Error Returns: ;; AX = -1 ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ;; Calls: ;; glrudel ;; gmarkfree ;; hfree ;; History: ;; ;; Sat Sep 20, 1986 02:59:06p -by- David N. Weise [davidw] ;; Moved it from gfree. ;;-----------------------------------------------------------------------;
cProc free_object,<PUBLIC,NEAR>cBegin nogen or dx,dx jz free_it cmp es:[di].ga_owner,dx je free_it mov ax,-1 jmps free_object_exitfree_it: call glrudel ; delete object from LRU chain xor si,si call gmarkfree ; free the object cCall AssociateSelector,<si,di> cCall FreeSelArray,<si> xor ax,ax ;!!! just for now force successfree_object_exit: retcEnd nogen
;-----------------------------------------------------------------------;; free_handle ;; ;; Frees the given handle. ;; ;; Arguments: ;; DS:SI = handle table entry address ;; ;; Returns: ;; AX = 0 ;; CX = AX ;; ;; Error Returns: ;; AX = -1 ;; ;; Registers Preserved: ;; BX ;; ;; Registers Destroyed: ;; ? ;; Calls: ;; hfree ;; History: ;; ;; Sat Sep 20, 1986 02:30:32p -by- David N. Weise [davidw] ;; Moved it from gfree. ;;-----------------------------------------------------------------------;
;cProc free_handle,<PUBLIC,NEAR>;cBegin nogen; xor ax,ax; or si,si; jz free_handle_exit; push bx; mov bx,si; call hfree; pop bx;free_handle_exit:; ret;cEnd nogen
;-----------------------------------------------------------------------;; gfreeall ;; ;; Frees all global objects that belong to the given owner. It first ;; loops through the global heap freeing objects and then loops through ;; the handle table freeing handles of discarded objects. ;; ;; Arguments: ;; DX = owner field value to match ;; DS:DI = address of global heap info ;; ;; Returns: ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; CX,ES,SI ;; ;; Calls: ;; free_object ;; henum ;; hfree ;; ;; History: ;; ;; Fri Sep 19, 1986 05:46:52p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc gfreeall,<PUBLIC,NEAR>cBegin nogen
mov es,[di].hi_first ; ES:DI points to first arena entry mov cx,[di].hi_count ; CX = #entries in the arenafree_all_objects: push cx call free_object ; Free object if matches owner pop cx mov es,es:[di].ga_next ; Move to next block loop free_all_objects
; may go extra times, as CX does not track coalescing done by gfree,; but no big whoop
push ax push bx push di SetKernelDS es mov si, SelTableStart mov cx, SelTableLen shr cx, 1 mov di, si smov es, ds UnSetKernelDS es
free_all_handles_loop: mov ax, dx repne scas word ptr es:[di] ; Isn't this easy? jne short we_be_done lea bx, [di-2] sub bx, si shl bx, 2 or bl, SEG_RING
if KDEBUG lsl ax, bx cmp ax, dx je @F INT3_ANCIENT@@:endif
cCall GetAccessWord,<bx> test al,DSC_PRESENT ; segment present? jnz short free_all_handles_loop ; yes, not a handle test ah,DSC_DISCARDABLE ; discardable? jz short free_all_handles_loop ; no, nothing to free cCall free_sel,<bx> mov word ptr [di-2], 0 ; Remove owner from table jcxz we_be_done jmps free_all_handles_loopwe_be_done: pop di pop bx pop ax
gfreeall_done: retcEnd nogen
;-----------------------------------------------------------------------;; glock ;; ;; Increment the lock count of an object in handle table entry ;; ;; Arguments: ;; BX = handle to global object ;; CH = handle table flags ;; CL = lock count for moveable objects ;; DX = segment address of object ;; DS:DI = address of master object ;; ES:DI = arena header ;; ;; Returns: ;; CX = updated lock count ;; DX = pointer to client area ;; ;; Error Returns: ;; ZF = 1 if count overflowed. ;; ;; Registers Preserved: ;; AX ;; ;; Registers Destroyed: ;; ;; Calls: ;; nothing ;; History: ;; ;; Fri Sep 19, 1986 05:38:57p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc glock,<PUBLIC,NEAR>cBegin nogen push ax inc ch ; Increment lock count jz overflow ; All done if overflow mov es:[di].ga_count,ch ; Update lock countglockerror:overflow: pop ax retcEnd nogen
;-----------------------------------------------------------------------;; gunlock ;; ;; Decrement the lock count of an object. ;; ;; Arguments: ;; BX = handle to global object ;; CH = handle table flags ;; CL = lock count for moveable objects ;; CX = handle table flags and lock count for moveable objects ;; DS:DI = address of master object ;; ES:DI = arena header ;; ;; Returns: ;; CX = updated lock count, no underflow ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ;; Calls: ;; glrutop ;; History: ;; ;; Fri Sep 19, 1986 04:39:01p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc gunlock,<PUBLIC,NEAR>cBegin nogen push ax mov ax,bx dec ch ; Decrement usage count cmp ch,0FFh-1 ; ff -> fe, 0 -> ff jae count_zero ; Return if pinned, or was already 0 dec es:[di].ga_count ; Non-zero update lock count jnz count_positive ; All done if still non-zero test cl,GA_DISCARDABLE ; Is this a discardable handle? jz count_zero ; No, all done call glrutop ; Yes, bring to top of LRU chaincount_zero: xor cx,cxcount_positive: pop ax retcEnd nogen
sEnd CODE
end
|
