You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
584 lines
15 KiB
584 lines
15 KiB
|
|
include kernel.inc
|
|
include protect.inc
|
|
.list
|
|
|
|
.386p
|
|
|
|
DataBegin
|
|
|
|
externB WinFlags
|
|
externW hGlobalHeap
|
|
externW pGlobalHeap
|
|
externW ArenaSel
|
|
externD hBmDPMI
|
|
externD FreeArenaList
|
|
externD FreeArenaCount
|
|
externD SelTableStart
|
|
externW SelTableLen
|
|
externW InitialPages
|
|
|
|
DataEnd
|
|
|
|
|
|
sBegin INITCODE
|
|
assumes CS,CODE
|
|
|
|
externNP get_physical_address
|
|
externNP set_physical_address
|
|
externNP set_selector_address32
|
|
externNP set_selector_limit32
|
|
externNP alloc_arena_header
|
|
externNP AssociateSelector32
|
|
externNP alloc_data_sel
|
|
externNP alloc_data_sel32
|
|
externNP GrowHeap
|
|
externNP DPMIProc
|
|
externFP greserve
|
|
|
|
GA_ALIGN_BYTES = (((GA_ALIGN+1) SHL 4) - 1)
|
|
GA_MASK_BYTES = NOT GA_ALIGN_BYTES
|
|
|
|
;-----------------------------------------------------------------------;
|
|
; get_selector_address32 ;
|
|
; ;
|
|
; Function to translate return of get_physical_address (DX:AX) into EAX ;
|
|
; ;
|
|
;-----------------------------------------------------------------------;
|
|
cProc get_selector_address32,<PUBLIC,NEAR>
|
|
parmW selector
|
|
cBegin
|
|
push dx
|
|
cCall get_physical_address,<selector>
|
|
shl eax, 16
|
|
mov ax, dx
|
|
ror eax, 16
|
|
pop dx
|
|
cEnd
|
|
|
|
;-----------------------------------------------------------------------;
|
|
; GlobalInit ;
|
|
; ;
|
|
; Procedure to initialize the global heap. Called with the starting ;
|
|
; and ending paragraph addresses. ;
|
|
; ;
|
|
; Arguments: ;
|
|
; parmW hdelta = size (.25k) of master object ;
|
|
; parmW palloc = block to mark allocated ;
|
|
; parmW pstart = first available address ;
|
|
; parmW pend = last available address ;
|
|
; ;
|
|
; Returns: ;
|
|
; AX = handle for allocated block ;
|
|
; ;
|
|
; Error Returns: ;
|
|
; ;
|
|
; Alters: ;
|
|
; ES ;
|
|
; Calls: ;
|
|
; ginit ;
|
|
; hthread ;
|
|
; ghalloc ;
|
|
; History: ;
|
|
; ;
|
|
; Sat Jun 20, 1987 05:55:35p -by- David N. Weise [davidw] ;
|
|
; Making real EMS work with the fast boot version. ;
|
|
; ;
|
|
; Sun Mar 15, 1987 06:38:04p -by- David N. Weise [davidw] ;
|
|
; Added support for the linked free list long ago. ;
|
|
; ;
|
|
; Wed Feb 18, 1987 08:09:18p -by- David N. Weise [davidw] ;
|
|
; Added the initialization of the gi_alt entries. ;
|
|
; ;
|
|
; Mon Sep 08, 1986 07:53:41p -by- David N. Weise [davidw ;
|
|
; Changed the return values so that this can be called from other than ;
|
|
; initialization code. ;
|
|
;-----------------------------------------------------------------------;
|
|
|
|
cProc GlobalInit,<PUBLIC,NEAR>,<ds,si,di>
|
|
parmW hdelta
|
|
parmW palloc
|
|
parmW pstart
|
|
parmW pend
|
|
localW emspalloc
|
|
localW hInitMem
|
|
localD allocated_arena
|
|
localW next_block
|
|
localW free_hi
|
|
localW free_lo
|
|
|
|
cBegin
|
|
mov ax,palloc ; AX = block to mark allocated
|
|
mov bx,pstart ; BX = first available address
|
|
mov cx,hdelta ; CX = size (.25k) of master object
|
|
mov dx,pend ; DX = last available address
|
|
call ginit
|
|
jc FailGlobalInit
|
|
|
|
SetKernelDS es
|
|
mov allocated_arena,eax
|
|
xor edi,edi ; Initialize master object
|
|
mov [di].phi_first,ebx ; Fill in pointers to first and
|
|
mov [di].phi_last,edx ; last blocks
|
|
mov [di].hi_count,4 ; 4 arena entries
|
|
or eax,eax
|
|
jnz short allocated_block
|
|
mov [di].hi_count,3 ; 3 arena entries
|
|
allocated_block:
|
|
mov [di].gi_lruchain,edi ; Nothing in LRU list so far
|
|
mov [di].gi_lrucount,di
|
|
mov [di].gi_lrulock,di ; ...and not locked
|
|
mov [di].gi_reserve,edi ; No discardable code reserve area yet
|
|
push eax
|
|
mov eax, ds:[edx.pga_address]
|
|
mov word ptr [di].gi_disfence,ax ; gi_disfence = hi_last
|
|
shr eax, 16
|
|
mov word ptr [di].gi_disfence_hi,ax
|
|
pop eax
|
|
|
|
mov [di].gi_alt_first,-1 ; Fill in pointers to first and
|
|
mov [di].gi_alt_last,-1 ; last blocks, the -1 is necessary!!
|
|
mov [di].gi_alt_count,di ; # of arena entries
|
|
mov [di].gi_alt_lruchain,di
|
|
mov [di].gi_alt_lrucount,di ; MUST be 0!
|
|
mov [di].gi_alt_free_count,di
|
|
mov [di].gi_alt_reserve,di
|
|
mov [di].gi_alt_disfence,di
|
|
mov [di].gi_alt_pPhantom,-1 ; MUST be -1!
|
|
|
|
mov ax, ds:[esi.pga_handle] ; Pick up master objects selector
|
|
mov hGlobalHeap,ax
|
|
mov ds:[esi].pga_count,0
|
|
mov ds:[esi].pga_selcount,1
|
|
|
|
mov esi,ds:[edx].pga_prev ; Point to allocated object before
|
|
mov bx,ds:[esi.pga_handle]
|
|
StoH bx ; It is moveable
|
|
mov ds:[esi].pga_handle,bx
|
|
mov hInitMem,bx
|
|
mov ds:[esi].pga_count,0
|
|
no_allocated_object:
|
|
|
|
; initialize free list
|
|
|
|
mov [di].gi_free_count,1
|
|
mov eax,[di].phi_first
|
|
mov ecx,[di].phi_last
|
|
|
|
mov ebx,ds:[eax].pga_next
|
|
mov ds:[eax].pga_freeprev,-1 ; Fill in first sentinal
|
|
mov ds:[eax].pga_freenext,ebx
|
|
|
|
mov ds:[ecx].pga_freeprev,ebx ; Fill in last sentinal
|
|
mov ds:[ecx].pga_freenext,-1
|
|
|
|
mov ds:[ebx].pga_freeprev,eax ; Link in free block
|
|
mov ds:[ebx].pga_freenext,ecx
|
|
pushad
|
|
SetKernelDS fs
|
|
mov edx, 030000h ; Insist on enough for fence
|
|
call GrowHeap
|
|
jc short Failed_GrowHeap ;garage sale machine,tough luck!
|
|
|
|
; 192k (3 segs) fixed greserve
|
|
mov ax, 1000h ; fence it all off. (in paras)
|
|
push fs
|
|
call greserve ; greserve will triple the no.
|
|
pop fs
|
|
or ax, ax
|
|
stc ; assume failure
|
|
jz short Failed_GrowHeap
|
|
|
|
ifdef WOW
|
|
clc
|
|
; WOW isn't greedy and doesn't have gcommit_block
|
|
else
|
|
mov esi, ds:[edi].phi_last ; sentinel
|
|
mov esi, ds:[esi].pga_prev ; not_there
|
|
mov esi, ds:[esi].pga_prev ; free blk
|
|
call gcommit_block ; commit it all
|
|
jc short Failed_GrowHeap ; to guarantee stable system
|
|
|
|
; Let's start with 20MB reserve and allocate more as reqd.
|
|
mov edx, 20*1024*1024 ; Let's get greedy
|
|
call GrowHeap
|
|
clc ; we don't care about this fail
|
|
endif
|
|
Failed_GrowHeap:
|
|
UnSetKernelDS fs
|
|
popad
|
|
jc short FailGlobalInit
|
|
mov ax,hInitMem
|
|
clc
|
|
|
|
FailGlobalInit:
|
|
cEnd
|
|
|
|
|
|
;-----------------------------------------------------------------------;
|
|
; ginit ;
|
|
; ;
|
|
; Procedure to initialize the global heap. ;
|
|
; ;
|
|
; The global heap looks as follows after this procedure returns: ;
|
|
; ;
|
|
; BX - first object in arena, alway busy, zero length. ;
|
|
; - free object ;
|
|
; AX - allocated object ;
|
|
; DS - master object ;
|
|
; DX - last object in arena, alway busy, zero length. ;
|
|
; ;
|
|
; ;
|
|
; Arguments: ;
|
|
; AX = address of block to mark allocated. May be zero. ;
|
|
; BX = address of first paragraph in arena ;
|
|
; DX = address of last paragraph in arena ;
|
|
; CX = initial size of master object, in bytes ;
|
|
; ;
|
|
; Returns: ;
|
|
; AX = aligned address of block marked allocated. ;
|
|
; BX = aligned address of first object in arena ;
|
|
; CX = size of master object, in bytes ;
|
|
; DX = aligned address of last object in arena ;
|
|
; DS = aligned address of master object ;
|
|
; ;
|
|
; Registers Preserved: ;
|
|
; ;
|
|
; Registers Destroyed: ;
|
|
; DI,SI,ES ;
|
|
; Calls: ;
|
|
; nothing ;
|
|
; History: ;
|
|
; ;
|
|
; Thu Sep 11, 1986 04:22:02p -by- David N. Weise [davidw] ;
|
|
; Commented it, made it handle the case of no allocated block correctly.;
|
|
;-----------------------------------------------------------------------;
|
|
|
|
assumes ds, nothing
|
|
assumes es, nothing
|
|
|
|
cProc ginit,<PUBLIC,NEAR>
|
|
|
|
localD size_free
|
|
localD size_allocated
|
|
localD size_master
|
|
localD allocated_arena
|
|
localW allocated_sel
|
|
localD BurgerMaster_arena
|
|
localW BurgerMaster_sel
|
|
localD new_last_arena
|
|
|
|
cBegin
|
|
|
|
; ESI = the first block address (sentinel, always busy)
|
|
|
|
SetKernelDS es
|
|
push ax
|
|
|
|
cCall get_selector_address32,<bx> ; Start of our memory
|
|
add eax, GA_ALIGN_BYTES ; Align our start
|
|
and al, GA_MASK_BYTES
|
|
push eax ; Save the start address
|
|
cCall set_selector_address32,<bx,eax> ; This will be our arena list
|
|
mov ArenaSel, bx
|
|
mov BurgerMaster_sel, bx
|
|
mov si, bx
|
|
|
|
push bx
|
|
push di
|
|
xor bx, bx ; # physical pages available
|
|
sub sp, 30h
|
|
mov di, sp
|
|
push es
|
|
smov es, ss
|
|
DPMICALL 0500h
|
|
pop es
|
|
mov eax, 16*1024 ; Size of selector table
|
|
jc short default_sel_table
|
|
mov bx, word ptr ss:[di][10h]
|
|
cmp bx, 256
|
|
jb short default_sel_table
|
|
;;;mov eax, 31*1024
|
|
mov eax, 32*1024
|
|
default_sel_table:
|
|
mov [InitialPages], bx
|
|
; For WOW we assume 386 Kernel is running on paging System
|
|
; So always set WF1_PAGING
|
|
ifndef WOW
|
|
mov ecx, ss:[di][20h] ; Paging file size
|
|
inc ecx
|
|
cmp ecx, 1 ; 0 or -1?
|
|
jbe short @F
|
|
endif
|
|
or byte ptr WinFlags[1], WF1_PAGING
|
|
@@:
|
|
mov ecx, ss:[di][0]
|
|
shr ecx, 7 ; Bytes reserved for arenas
|
|
add sp, 30h
|
|
pop di
|
|
pop bx
|
|
|
|
add ecx, GA_ALIGN_BYTES ; Align length of arena table
|
|
and cl, GA_MASK_BYTES
|
|
add eax, GA_ALIGN_BYTES ; Align length of selector table
|
|
and al, GA_MASK_BYTES
|
|
mov SelTableLen, ax
|
|
cmp ecx, DEFAULT_ARENA_SIZE ; Number of bytes of arenas
|
|
jae short @F
|
|
mov ecx, DEFAULT_ARENA_SIZE
|
|
@@:
|
|
mov ebx, Size GlobalInfo+GA_ALIGN_BYTES
|
|
and bl, GA_MASK_BYTES ; EBX start of arenas
|
|
mov size_master, ebx
|
|
add ecx, ebx
|
|
mov SelTableStart, ecx
|
|
add eax, ecx ; EAX total length of segment
|
|
|
|
push ecx
|
|
push ebx
|
|
push eax
|
|
push si
|
|
mov cx, ax ; Make BX:CX required
|
|
mov ebx, eax ; length of Burgermaster
|
|
shr ebx, 16
|
|
push bx ; Save length
|
|
push cx
|
|
DPMICALL 0501h
|
|
mov hBmDPMI[0], di ; Save DPMI handle
|
|
mov hBmDPMI[2], si
|
|
pop di ; SI:DI now length
|
|
pop si
|
|
jc Failginit
|
|
if 0
|
|
mov di, 4096 ; Lock first page
|
|
xor si, si
|
|
DPMICALL 0600h ; Now page lock it
|
|
push bx
|
|
push cx
|
|
add cx, word ptr SelTableStart
|
|
adc bx, 0
|
|
and cx, not 4095
|
|
DPMICALL 0600h
|
|
pop cx
|
|
pop bx
|
|
endif
|
|
|
|
shl ebx, 16
|
|
mov bx, cx ; Address in EBX
|
|
pop si
|
|
pop eax
|
|
cCall set_selector_address32,<si,ebx>
|
|
mov edi, ebx
|
|
;;; cCall set_selector_limit32, <si,eax>
|
|
push eax
|
|
push dx
|
|
dec eax
|
|
mov ecx, eax ; Limit in CX:DX
|
|
shr ecx, 16
|
|
mov dx, ax
|
|
test cx,0fff0h ; bits 20-31 set?
|
|
jz @F ; No.
|
|
or dx,0fffh ; Yes, page align limit.
|
|
@@:
|
|
mov bx, si ; Selector in BX
|
|
DPMICALL 8
|
|
pop dx
|
|
pop eax
|
|
pop ebx
|
|
pop ecx
|
|
jc Failginit
|
|
|
|
mov ds, si
|
|
sub ecx, ebx ; Subtract out BurgerMaster
|
|
cCall InitialiseArenas,<ebx,ecx>
|
|
mov ecx, eax
|
|
pop esi ; Sentinel address
|
|
cCall alloc_arena_header,<esi> ; Sentinel
|
|
mov esi, eax
|
|
cCall alloc_arena_header,<edi> ; BurgerMaster
|
|
mov BurgerMaster_arena, eax
|
|
mov ds:[eax].pga_handle, ds ; Save selector in handle field
|
|
mov ds:[eax].pga_size, ecx
|
|
|
|
push edi
|
|
push ecx
|
|
movzx ecx, SelTableLen
|
|
mov edi, SelTableStart
|
|
push es
|
|
smov es, ds ; Zero this area
|
|
UnSetKernelDS es
|
|
shr ecx, 2
|
|
xor eax, eax
|
|
rep stos dword ptr es:[edi]
|
|
pop es
|
|
ReSetKernelDS es
|
|
pop ecx
|
|
pop edi
|
|
cCall AssociateSelector32,<ds,BurgerMaster_Arena> ; Set back link
|
|
|
|
; EDI = the Free block address (initial free block)
|
|
|
|
mov eax, ds:[esi].pga_address
|
|
;;; add eax, ecx
|
|
cCall alloc_arena_header,<eax>
|
|
mov edi, eax ; Free block arena in EDI
|
|
|
|
movzx eax, dx ; Get linear address
|
|
shl eax, 4
|
|
|
|
; EDX = the last block address (sentinel, always busy)
|
|
|
|
and al, GA_MASK_BYTES
|
|
push eax
|
|
cCall alloc_arena_header,<eax>
|
|
mov new_last_arena, eax ; Save it away
|
|
pop ebx
|
|
|
|
pop ax ; Allocated Block
|
|
cCall get_selector_address32, <ax>
|
|
and al, GA_MASK_BYTES ; "Align" it
|
|
|
|
sub ebx, eax ; Length in bytes
|
|
|
|
push eax
|
|
push eax
|
|
cCall alloc_arena_header, <eax>
|
|
mov ds:[eax].pga_size, ebx ; Record size
|
|
mov allocated_arena, eax
|
|
mov ebx, eax
|
|
pop eax
|
|
cCall alloc_data_sel32, <eax, ds:[ebx].pga_size>
|
|
mov allocated_sel, ax
|
|
mov ds:[ebx.pga_handle], ax ; Save selector
|
|
cCall AssociateSelector32,<ax,ebx> ; Set back link
|
|
|
|
pop ebx
|
|
sub ebx, ds:[edi].pga_address ; Length in bytes
|
|
mov ds:[edi].pga_size, ebx
|
|
|
|
mov eax, allocated_arena
|
|
mov ecx, BurgerMaster_arena
|
|
mov edx, new_last_arena
|
|
|
|
; Fill in first block
|
|
|
|
xor ebx, ebx
|
|
mov ds:[esi].pga_sig,GA_SIGNATURE
|
|
mov ds:[esi].pga_size,ebx
|
|
mov ds:[esi].pga_owner,-1
|
|
mov ds:[esi].pga_flags,bx
|
|
mov ds:[esi].pga_prev,esi ; first.prev = self
|
|
mov ds:[esi].pga_next,edi ; first.next = free
|
|
mov ds:[esi].pga_handle,bx
|
|
mov ds:[esi].pga_lrunext,ebx
|
|
mov ds:[esi].pga_lruprev,ebx
|
|
|
|
; Fill in the last block (sentinel block)
|
|
|
|
mov ds:[edx].pga_sig,GA_ENDSIG
|
|
mov ds:[edx].pga_size,ebx
|
|
mov ds:[edx].pga_owner,-1 ; Always allocated
|
|
mov ds:[edx].pga_next,edx ; last.next = self
|
|
mov ds:[edx].pga_prev,eax ; last.prev = alloced
|
|
mov ds:[edx].pga_flags,bx
|
|
mov ds:[edx].pga_handle, bx
|
|
mov ds:[edx].pga_lrunext,ebx
|
|
mov ds:[edx].pga_lruprev,ebx
|
|
|
|
; Fill in the master object
|
|
|
|
mov ds:[ecx].pga_next,ecx
|
|
mov ds:[ecx].pga_prev,ecx
|
|
mov ds:[ecx].pga_sig,GA_SIGNATURE
|
|
mov ds:[ecx].pga_owner,-3
|
|
mov ds:[ecx].pga_flags,bx
|
|
mov ds:[ecx].pga_lruprev,ebx
|
|
mov ds:[ecx].pga_lrunext,ebx
|
|
|
|
; Fill in the allocated block
|
|
|
|
mov ds:[eax].pga_next,edx ; next object is Sentinel
|
|
mov ds:[eax].pga_prev,edi ; Previous object is second block
|
|
mov ds:[eax].pga_sig,GA_SIGNATURE
|
|
mov ds:[eax].pga_owner,-1
|
|
mov ds:[eax].pga_flags,bx
|
|
mov ds:[eax].pga_lruprev,ebx
|
|
mov ds:[eax].pga_lrunext,ebx
|
|
|
|
; Fill in free block
|
|
|
|
mov ds:[edi].pga_sig,GA_SIGNATURE
|
|
mov ds:[edi].pga_owner,bx ; This is a free block
|
|
mov ds:[edi].pga_flags,bx
|
|
mov ds:[edi].pga_next,eax ; Next obj allocated block
|
|
mov ds:[edi].pga_prev,esi
|
|
mov ds:[edi].pga_handle,bx
|
|
mov ds:[edi].pga_lruprev,ebx
|
|
mov ds:[edi].pga_lrunext,ebx
|
|
|
|
; Initialize master object
|
|
|
|
|
|
mov ecx, size_master
|
|
mov dx,BurgerMaster_sel
|
|
shr ecx, 1
|
|
|
|
push ecx ; save size in words
|
|
|
|
mov pGlobalHeap,dx
|
|
mov es,dx
|
|
UnSetKernelDS es
|
|
xor eax,eax
|
|
xor di,di ; Init master object to zero
|
|
shr ecx, 1
|
|
rep stosd
|
|
|
|
mov ds,dx ; Switch to master object as our DS
|
|
|
|
pop ecx
|
|
shl ecx,1 ; ECX = size of master object in bytes
|
|
|
|
mov eax, allocated_arena ; EAX = address of allocated block
|
|
mov edx, new_last_arena ; EDX = address of last block
|
|
mov ebx, esi ; EBX = address of first block
|
|
mov esi, BurgerMaster_arena ; ESI = arena of BurgerMaster
|
|
clc
|
|
Failginit:
|
|
cEnd
|
|
|
|
assumes ds, nothing
|
|
assumes es, nothing
|
|
|
|
cProc InitialiseArenas,<PUBLIC,NEAR>
|
|
parmD StartOffset
|
|
parmD BytesAllocated
|
|
cBegin
|
|
push ecx
|
|
push esi
|
|
push edi
|
|
CheckKernelDS es
|
|
ReSetKernelDS es
|
|
mov esi, StartOffset
|
|
mov ecx, BytesAllocated
|
|
add ecx, esi
|
|
mov FreeArenaList, esi ; Point to list
|
|
lea edi, [esi+size GlobalArena32]
|
|
IA_loop:
|
|
cmp edi, ecx
|
|
jae short IA_done
|
|
mov [esi.pga_next], edi
|
|
add esi, size GlobalArena32
|
|
add edi, size GlobalArena32
|
|
inc FreeArenaCount
|
|
jmps IA_loop
|
|
IA_done:
|
|
mov ds:[esi.pga_next], -1 ; Terminate list
|
|
UnSetKernelDS es
|
|
pop edi
|
|
pop esi
|
|
pop ecx
|
|
cEnd
|
|
|
|
sEnd INITCODE
|
|
|
|
end
|