mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-24 08:54:17 +00:00
282 lines
7.5 KiB
Plaintext
282 lines
7.5 KiB
Plaintext
|
||
;*****************************************************
|
||
;*
|
||
;* MEM Entry Points
|
||
;*
|
||
;* Each process descriptor points to a linked
|
||
;* list of MDs that describe memory segments that
|
||
;* it owns. The MDs note the starting paragraph
|
||
;* and a MAU that the Memory Segment is in.
|
||
;*
|
||
;* Format of MDs on p_mem lists:
|
||
;*
|
||
;* +----+----+----+----+----+----+----+----+
|
||
;* | link | start | flags | mau |
|
||
;* +----+----+----+----+----+----+----+----+
|
||
;*
|
||
;* link link field for p_mem list
|
||
;* start starting paragraph of memory segment
|
||
;* flags load,code,and share as in MPB
|
||
;* mau offset of MAU in SYSDAT that segment is
|
||
;* allocated from
|
||
;*
|
||
;*****************************************************
|
||
|
||
;============
|
||
malloc_entry:
|
||
;============
|
||
; Allocate Memory - memory is allocated from MAUs.
|
||
; First we try to allocate memory from MAUs that has
|
||
; memory segments already allocated by this process.
|
||
; If that fails, we try to create a new MAU from the
|
||
; Memory Free List (MFL). If both fails, an error is
|
||
; is returned to the user.
|
||
;
|
||
; (Future - if MPB flags indicate load shared code,
|
||
; we try to allocate from MAU's used by another process
|
||
; of the same name and from the same load file.)
|
||
;
|
||
; input: DX = MPB in u_wrkseg
|
||
; output: BX = 0 if successful (unused memory)
|
||
; = 1 if successful (shared code)
|
||
; = 0ffffh if failure
|
||
; CX = error code
|
||
;
|
||
; Format of MPB:
|
||
;
|
||
; +----+----+----+----+----+----+----+----+----+----+
|
||
; | start | min | max | pdadr | flags |
|
||
; +----+----+----+----+----+----+----+----+----+----+
|
||
;
|
||
; start - if non-zero, an absolute request
|
||
; min - minimum length that will satisfy the request
|
||
; max - maximum length wanted
|
||
; We will try to allocate the maximum
|
||
; but will be satisfied with as little as the
|
||
; minimum.
|
||
; pdadr - Process Descriptor to allocate memory to.
|
||
; Note - PD can not be a current process unless
|
||
; it is the calling process.
|
||
; The Calling process must explicitly release
|
||
; the memory if the PD never becomes a process.
|
||
; Otherwise, memory is released upon termination.
|
||
; If pdadr is 0, then calling process allocates
|
||
; the memory.
|
||
; flags - 00001h Load This segment initialized from
|
||
; a disk file
|
||
; 00002h Shared This is a sharable segment
|
||
; 00004h Code This is a Code segment
|
||
|
||
; Get a MD for use in the p_mem list
|
||
|
||
; DX -> MPB (u_wrkseg)
|
||
push dx ! call getmd ! pop dx ; BX -> MD
|
||
jcxz mall_gmd
|
||
mov bx,0ffffh ! ret
|
||
mall_gmd:
|
||
; fill PDADR field in case its zero
|
||
|
||
push es ! mov es,u_wrkseg
|
||
mov di,dx ! mov ax,es:mpb_pdadr[di]
|
||
cmp ax,0 ! jne mall_gpd
|
||
mov ax,rlr
|
||
mov es:mpb_pdadr[di],ax
|
||
mall_gpd:
|
||
pop es
|
||
cmp ax,rlr ! je mall_pdver
|
||
mov si,(offset thrdrt)-p_thread
|
||
mall_pdnxt: mov si,p_thread[si]
|
||
cmp si,0 ! je mall_pdver
|
||
cmp si,ax ! jne mall_pdnxt
|
||
cmp si,rlr ! je mall_pdver
|
||
mov bx,0ffffh
|
||
mov cx,e_active_pd
|
||
ret
|
||
mall_pdver:
|
||
; try to allocate memory
|
||
|
||
mov si,ax ! add si,(p_mem - ms_link)
|
||
mov cx,0 ;CX=last MAU we've tried
|
||
mall_next:
|
||
mov si,ms_link[si]
|
||
cmp si,0 ! je mall_ml
|
||
cmp cx,ms_mau[si] ! je mall_next
|
||
; here's a MAU we haven't tried...
|
||
; CX=last MAU tried
|
||
; DX=MPB adr in u_wrkseg
|
||
; BX=New MD
|
||
; SI=current MD
|
||
push cx ! push dx ! push bx ! push si
|
||
mov bx,ms_mau[si]
|
||
push bx ! call mall_try_mau ! pop di
|
||
pop si ! pop bx ! pop dx
|
||
; Plus DI=MAU address
|
||
cmp cx,0 ! pop cx ! jne mall_next
|
||
; succesful allocation
|
||
jmp mall_linkit
|
||
mall_ml: ; We must create a new MAU from MFL
|
||
push bx ! push dx
|
||
mov ds,u_wrkseg
|
||
mov bx,offset mfl ! mov cx,f_mlalloc
|
||
call mpmif
|
||
mov ds,sysdat
|
||
;BX=MAU, (New MD,MPB on stack)
|
||
jcxz mall_ml0
|
||
pop dx ! pop bx ! jmp mall_err
|
||
mall_ml0: ; We have a new MAU
|
||
;place MAU on MAL
|
||
mov si,mal
|
||
mov m_link[bx],si
|
||
mov mal,bx
|
||
;allocate memory
|
||
pop dx ! push dx
|
||
push bx ! call mall_try_mau ! pop di
|
||
pop dx ! pop bx
|
||
;DI=MAU, BX=New MD, DX=MPB in u_wrkseg
|
||
cmp cx,0 ! jne mall_err
|
||
; Successful allocation
|
||
mov si,0
|
||
jmps mall_linkit
|
||
mall_err: ; No memory available
|
||
call freemd ; Free the Memory Descriptor
|
||
mov bx,0ffffh ! ret ; CX=Error Code set previously
|
||
mall_linkit:
|
||
;SI = MD addr which MAU came from
|
||
; if zero, from new MAU
|
||
;BX -> MD
|
||
;DX -> MPB in u_wrkseg
|
||
;DI -> MAU
|
||
push es ! mov es,u_wrkseg
|
||
push di ! mov di,dx
|
||
mov ax,es:mpb_start[di]
|
||
mov ms_start[bx],ax
|
||
mov ax,es:mpb_min[di]
|
||
mov ms_length[bx],ax
|
||
mov ax,es:mpb_flags[di]
|
||
mov ms_flags[bx],ax
|
||
cmp si,0 ! jne mall_l0
|
||
mov si,es:mpb_pdadr[di]
|
||
add si,(p_mem-ms_link)
|
||
mall_l0:mov ax,ms_link[si] ! mov ms_link[bx],ax
|
||
mov ms_link[si],bx
|
||
pop di ! mov ms_mau[bx],di
|
||
pop es ! sub cx,cx ! mov bx,cx ! ret
|
||
|
||
mall_try_mau:
|
||
;------------
|
||
; input: BX -> MAU
|
||
; DX -> MPB in u_wrkseg
|
||
; output: CX = Error Code
|
||
|
||
mov ds,u_wrkseg
|
||
mov cx,f_maualloc ! call mpmif
|
||
mov ds,sysdat ! ret
|
||
|
||
;===========
|
||
mfree_entry: ; 130 - Memory Free
|
||
;===========
|
||
; Free the memory segment with the given segment addr.
|
||
; input: DX = MFPB in u_wrkseg
|
||
; output: BX = 0 if successful
|
||
; = 0ffffh on failure
|
||
; CX = error code
|
||
;
|
||
; Memory Free Parameter Block (MFPB)
|
||
;
|
||
; +----+----+----+----+
|
||
; | start | pdadr |
|
||
; +----+----+----+----+
|
||
;
|
||
; start - starting paragraph of area to be freed.
|
||
; pdadr - PD to free memory from. If 0, then calling
|
||
; process. If non-zero, the PD must not be
|
||
; a current process.
|
||
|
||
push es ! mov es,u_wrkseg
|
||
mov si,dx
|
||
mov bx,es:mfpb_pd[si]
|
||
mov dx,es:mfpb_start[si]
|
||
pop es
|
||
; BX = pdadr
|
||
; DX = start paragraph
|
||
cmp bx,0 ! jne mfree_chkpd
|
||
mov bx,rlr
|
||
jmps mfree_gotpd
|
||
mfree_chkpd:
|
||
mov si,(offset thrdrt)-p_thread
|
||
mfree_nxtpd:
|
||
mov si,p_link[si]
|
||
cmp si,0 ! je mfree_gotpd
|
||
cmp si,bx ! jne mfree_nxtpd
|
||
cmp si,rlr ! je mfree_gotpd
|
||
mov bx,0ffffh
|
||
mov cx,e_active_pd
|
||
ret
|
||
mfree_gotpd:
|
||
lea si,p_mem[bx]
|
||
mfree_next:
|
||
mov bx,si ! mov si,ms_link[bx]
|
||
cmp si,0 ! je mfree_err
|
||
cmp ms_start[si],dx ! je mfree_it
|
||
ja mfree_next
|
||
mov ax,ms_start[si]
|
||
add ax,ms_length[si]
|
||
cmp ax,dx ! jbe mfree_next
|
||
push dx ! push si
|
||
call mfree_it
|
||
pop si ! pop dx
|
||
cmp cx,0 ! jne mfree_next
|
||
mfree_exit:
|
||
sub bx,bx ! mov cx,bx ! ret
|
||
mfree_err:
|
||
mov bx,0ffffh ! mov cx,e_no_memory
|
||
ret
|
||
|
||
mfree_it:
|
||
;--------
|
||
; input: BX = root
|
||
; SI = MD ([bx])
|
||
; DX = segment to free
|
||
; output: BX = 0,0ffffh (success,failure)
|
||
; CX = Error Code
|
||
|
||
push bx ! push si ! push dx
|
||
;push MAF structure
|
||
push dx ! push ms_start[si]
|
||
push ms_mau[si]
|
||
mov dx,sp ! push ss ! pop ds
|
||
mov cx,f_maufree ! call mpmif
|
||
mov bp,bx ;if bp=0,MAU not empty
|
||
mov ds,sysdat
|
||
;pop MAF structure
|
||
pop ax ! pop ax ! pop ax
|
||
pop dx ! pop si ! pop bx
|
||
;DX=segment to free
|
||
;BX=root
|
||
;SI=MD ( [BX] )
|
||
cmp cx,0 ! jne mfree_r
|
||
cmp dx,ms_start[si] ! je mfree_off
|
||
;decrease length
|
||
sub dx,ms_start[si]
|
||
mov ms_length[si],dx
|
||
mfree_r: ret
|
||
;take off p_mem list
|
||
mfree_off: mov ax,ms_link[si] ! mov ms_link[bx],ax
|
||
;free MD
|
||
push ms_mau[si] ! push bp
|
||
mov bx,si ! call freemd
|
||
pop bp ! pop dx
|
||
;free MAU if empty
|
||
cmp bp,0 ! je mfree_exit
|
||
;find it on MAL
|
||
mov di,(offset mal)-m_link
|
||
mfree_nmal: mov si,di ! mov di,m_link[si]
|
||
cmp di,0 ! je mfree_r
|
||
cmp di,dx ! jne mfree_nmal
|
||
;release from MAL
|
||
mov ax,m_link[di] ! mov m_link[si],ax
|
||
mov m_link[di],0
|
||
;release to MFL
|
||
mov bx,offset mfl ! mov cx,f_mlfree
|
||
jmp mpmif
|
||
|