|
|
TITLE LDSEG - SegAlloc procedure
.xlistinclude kernel.incinclude newexe.incinclude tdb.incinclude protect.inc ; Handle_To_Sel.list
NSHUGESEG = NSKCACHED ; not first seg of huge segment; A huge segment (data object larger than 64K) requires more than one; selector, but is part of a single memory allocation block. The first; selector is a handle, like any other segment. Subsequent selectors of; the huge memory block are _not_ handles, so we can't call MyLock() on; them, as the consistency check will fail. We mark these selectors with; the NSHUGESEG bit in the flags word. TonyG suggested this.; Note that data segments are already loaded, locked, etc, so the call to; MyLock is redundant anyway.; Thu Feb 28, 1991 01:39:00p -by- Don A. Corbitt [donc] ;
externFP IGlobalFreeexternFP IGlobalAllocexternFP IGlobalReAllocexternFP IGlobalLockexternFP MyOpenFileexternFP FlushCachedFileHandleexternFP Int21HandlerexternFP set_discarded_sel_ownerexternFP GetPatchAppRegKeyexternFP PatchAppSeg
if KDEBUGexternFP OutputDebugStringendif
DataBegin
externB Kernel_flags;externB fBootingexternB fPadCode;externW pGlobalHeap;externW MyCSDSexternW Win_PDB
if KDEBUGexternB fLoadTraceexternB fPreloadSegendif
externD FreeArenaCountextrn CountFreeSel:WORD
DataEnd
sBegin CODEassumes CS,CODEassumes DS,NOTHINGassumes ES,NOTHING
;externNP MyFreeexternNP SegRelocexternNP MyAllocexternNP MyAllocLinear ; MyAlloc with useful parametersexternNP MyLockexternNP GetCachedFileHandleexternNP CloseCachedFileHandleexternNP GetOwnerexternNP SetOwnerexternNP get_selector_length16
externNP get_rover_2externNP DiscardTheWorld
IFNDEF NO_APPLOADERexternNP LoadApplSegmentendif ;!NO_APPLOADER
if LDCHKSUM;externNP GetChksumAddrexternNP CheckSegChksumexternNP ZeroSegmentChksumendif
if SDEBUGexternNP DebugDefineSegmentendif
ifdef WOW_x86externNP get_physical_addressendif
;-----------------------------------------------------------------------;; AllocSeg ;; ;; Allocates memory for a segment. Does not load the segment. Puts ;; the handle of the segment into the segment descriptor structure ;; in the module database, and updates the flags there to mark the ;; segment as allocated but not loaded. Put the segment number into ;; the BurgerMaster handle entry. It also changes the .ga_owner to be ;; the module database. ;; ;; Arguments: ;; parmD pSegInfo ;; ;; Returns: ;; AX = handle for segment ;; ;; Error Returns: ;; AX = 0 ;; ZF = 1 ;; ;; Registers Preserved: ;; SI,DS,ES ;; ;; Registers Destroyed: ;; BX,CX,DX ;; ;; Calls: ;; MyAlloc ;; ;; History: ;; Thu Feb 28, 1991 01:39:00p -by- Don A. Corbitt [donc] ;; Handle 64K (big/huge) data segments ;; ; ;; Mon Feb 09, 1987 10:29:16p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothing
cProc AllocSeg,<PUBLIC,NEAR>,<si,es> parmD pSegInfocBegin SetKernelDS les si,pSegInfo
; Get size into AX (max of file size and minimum allocation).
mov bx,es:[si].ns_flags
test bl,NSALLOCED ; Already allocated? jz as0 ; No, allocate it jmp SHORT as3as0: mov ax,es:[si].ns_minalloc xor dx, dx ; if AX == 0 cmp ax, 1 ; then it is really 64K adc dx, dx add ax, 2 ; We may have a 1 byte entry point at the adc dx, 0 ; very end of a segment. PatchCodeHandle ; will GP trying to decipher the prolog. ; Also allow space for reading relocation word
cmp si,es:[ne_pautodata] jne as1 add ax,es:[ne_stack] ; Include stack and heap for data. jc asfail ; Don't need to handle big auto segs add ax,es:[ne_heap] jnc as1asfail: krDebugOut DEB_ERROR, "%es2 Automatic Data Segment larger than 64K." xor ax,axasxj: jmp SHORT asxas1:
; Allocate space for segment push bx push es cCall MyAllocLinear,<bx,dxax> pop es pop bx or ax,ax jz asxj
as2: mov es:[si].ns_handle,dx ; Handle into seg table and byte ptr es:[si].ns_flags,not NSLOADED or byte ptr es:[si].ns_flags,NSALLOCED
mov bx,dx cCall SetOwner,<ax,es>
as3: mov ax,es:[si].ns_handleasx: or ax,ax
cEnd
;-----------------------------------------------------------------------;; LoadSegment ;; ;; Loads a segment and performs any necessary relocations. ;; ;; Arguments: ;; parmW hExe ;; parmW segno ;; parmW fh ;; parmW isfh ;; ;; Returns: ;; AX = handle of segment ;; CX = handle of segment ;; DX = handle of segment ;; ;; Error Returns: ;; AX = 0 ;; CX = 0 ;; ;; Registers Preserved: ;; DI,SI,DS ;; ;; Registers Destroyed: ;; BX,ES ;; ;; Calls: ;; LoadSegment ;; AllocSeg ;; LoadApplSegment ;; MyOpenFile ;; SegLoad ;; GlobalAlloc ;; MyLock ;; SegReloc ;; GlobalFree ;; ZeroSegmentChksum ;; CheckSegChksum ;; ;; History: ;; Thu Feb 28, 1991 01:39:00p -by- Don A. Corbitt [donc] ;; ;; Tue Oct 27, 1987 06:10:31p -by- David N. Weise [davidw] ;; Wrote it. ;;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothing
cProc LoadSegment,<PUBLIC,NEAR>,<si,di> parmW hExe parmW segno parmW fh parmW isfh localW myfh localW hrleseg localD pseginfo localW creloc localW hseg localW fdataseg localW retries localW SavePDB localB fReload localW pleaseNoLock ; 1 if shouldn't lock segcBegin mov retries, 2 xor ax,ax mov hrleseg,ax mov hseg,ax mov SavePDB, ax mov pleaseNoLock, ax mov fReload, al not ax mov myfh,ax mov es,hexe mov si,segno dec si cmp es:[ne_cseg],si jg ls_not_done ; wish we had auto jump sizing... jmp lsdonels_not_done: shl si,1 mov bx,si shl si,1 shl si,1 add si,bx .errnz 10 - SIZE NEW_SEG1 add si,es:[ne_segtab] mov SEG_pseginfo, es ; Save segment info pointer mov OFF_pseginfo, si
IFNDEF NO_APPLOADER test es:[ne_flags],NEAPPLOADER jnz ls_special_loadls_not_special_load:ENDIF ;!NO_APPLOADER
mov bx,es:[si].ns_flags mov ax, bx and ax, NSHUGESEG mov pleaseNoLock, ax
test bl,NSALLOCED jnz ls1 push bx cCall AllocSeg,<essi> ; No, so try allocating the segment pop bx or ax,ax jnz ls1bls1: mov ax,es:[si].ns_handle mov hseg,ax test bl,NSLOADED jz ls1b mov fReload,1 jmp lsexit ; so MyLock at lsexit can swap them in
IFNDEF NO_APPLOADERls_special_load: mov ax,segno cmp ax,1 je ls_not_special_load ;* first segment normal load test es:[si].ns_flags,NSLOADED jnz ls_already_loaded cCall LoadApplSegment, <hExe, fh, ax> jmp lsx
ls_already_loaded: mov ax,es:[si].ns_handle mov hseg,ax mov fReload,1 jmp lsexitendif ;!NO_APPLOADER
ls1b: mov ax,fh inc ax ; Already have file handle? jz ls2 ; No, then get one and load segment dec ax cmp isfh,ax ; Yes, loading from memory? jne lsdoit ; Yes, load it now jmps ls2b ; No, load it nowls2: SetKernelDS mov ax, Win_PDB ; Save what PDB is supposed to be mov SavePDB, ax ; since we will set it to kernel's PDB mov ax,-1 cCall GetCachedFileHandle,<hExe,ax,ax> ; Get file handle from cachels2b: mov myfh,ax mov isfh,ax inc ax jnz lsdoit0 cmp SavePDB, ax ; If we saved the PDB, (ax=0) je @F push SavePDB ; better restore it! pop Win_PDB@@: jmp lsdonelsdoit0: dec axlsdoit: push es cCall SegLoad,<essi,segno,ax,isfh> pop es mov hseg,0 or ax,ax jz lsexit1
inc ax ; Did we get a file error? jnz lsloaded mov bx, myfh inc bx ; Reading from memory? jz lsexit1 ; no, fail dec bx cmp bx, fh ; We opened the file? je lsexit1 ; no, fail;;; cCall CloseCachedFileHandle,<bx> mov bx, SavePDB mov Win_PDB, bx cCall FlushCachedFileHandle,<hExe> ; Close it dec retries jz lsbadfile jmps ls2 ; and try to re-open it. UnSetKernelDSlsbadfile: krDebugOut DEB_ERROR, "%ES2 I/O error reading segment"lsexit1: jmp lsexit
lsloaded: mov hseg,bx mov bx,es:[si].ns_flags test bx,NSRELOC jnz lm1x jmp lschksumlm1x: and bx,NSDATA mov fdataseg,bx mov bx,myfh ; Loading from memory? inc bx jnz lm1 ; No, continue mov es,dx ; Yes, point to relocation info mov si,cx cld lods word ptr es:[si] mov creloc,ax jmps lm2lm1: dec bx mov creloc,cx shl cx,1 shl cx,1 shl cx,1 .errnz 8 - SIZE new_rlc push bx push cx mov ax,GA_MOVEABLE+GA_NODISCARD ; DO NOT WANT FIXED!! xor bx,bx regptr xsize,bx,cx.386; We don't really want to cause an attempt to grow the global arena; table or the LDT here! push ds SetKernelDS cmp FreeArenaCount,0 ; free arena? jz NoFreeArenas ; No cmp CountFreeSel,0 ; free selector?NoFreeArenas: pop ds UnsetKernelDS jz lm1a ; No, then read one at a time.286 cCall IGlobalAlloc,<ax,xsize> mov hrleseg,ax ; Save handle or ax,ax ; Did we get the memory jz lm1a ; No, then read one at a time
cCall IGlobalLock,<ax> ; Get the address of the relocation info mov si, ax mov es, dx pop cx ; Restore byte count pop bx ; Restore file handle push ds mov ds,dx assumes ds,nothing xor dx,dx mov ah,3Fh ; Read in relocation information DOSCALL pop ds assumes ds,nothing jc lserr2 cmp ax,cx jne lserr2 jmps lm2
lm1a: pop cx ; Restore byte count pop bx ; Restore file handle xor si,si mov es,si ; Signal no records readlm2: ; Pass pseginfo, not hseg cCall SegReloc,<hexe,essi,creloc,pseginfo,fdataseg,myfh>lm2a: mov cx,hrleseg jcxz no_hrleseg push ax cCall IGlobalFree,<hrleseg> pop axno_hrleseg: les si,pseginfo or ax,ax jnz lschksumlsdone2: jmps lsdone
lserr2: krDebugOut DEB_ERROR, "Error reading relocation records from %es2" xor ax,ax jmp lm2a
lschksum: mov ax, hseg ; in case we aren't locking Handle_To_Sel al cmp pleaseNoLock, 0 jnz lschksum1 cCall MyLock,<hseg>lschksum1:
if LDCHKSUM push ax push si mov si,ax cCall ZeroSegmentChksum pop si cCall CheckSegChksum ; destroys ax, bx, cx, dx, es pop axendif
les si, pseginfo
if SDEBUG ; Tell debugger about new segment cmp pleaseNoLock, 0 jnz keep_secrets mov bx,es:[ne_restab] inc bx mov dx,es:[si].ns_flags mov si, ax xor ax, ax test dx,NSDATA ; test to pass NSKCACHED too jz sa8 test byte ptr es:[ne_flags],NEINST jz sa8 mov ax,es:[ne_usage] dec axsa8: mov cx,segno dec cx
cCall DebugDefineSegment,<esbx,cx,si,ax,dx>keep_secrets:endif
lsexit: mov cx,hseg jcxz lsdone mov ax, cx ; in case we don't lock mov dx, ax Handle_To_Sel al cmp pleaseNoLock, 0 jnz lsdone cCall MyLock,<cx>lsdone: mov cx,myfh inc cx jz lsx dec cx cmp fh,cx je lsx push ax SetKernelDS;;; cCall CloseCachedFileHandle,<cx> mov ax, SavePDBif KDEBUG or ax, ax jnz @F int 3@@:endif mov Win_PDB, ax UnSetKernelDS pop axpublic lsxlsx: mov es, hExe test es:[ne_flagsothers], NEHASPATCH jz ls_exeunt cmp fReload, 0 jne ls_exeunt
push dx push ax
cCall GetPatchAppRegKey,<hExe> mov cx, dx or cx, ax jnz @F
; MCF_MODPATCH is set, but there are no patches ; in the registry for this module. Turn off the patch flag. and es:[ne_flagsothers], not NEHASPATCH jmp short ls_after_patch@@: ; reg key in dx:ax cCall PatchAppSeg,<dx,ax,segno,hseg> test ax, ax jz ls_after_patch
; One or more patches applied, so mark the segment not discardable. ; PatchAppSeg already cleared GA_DISCARDABLE or GA_DISCCODE in the ; global arena record. mov si, pseginfo.off and es:[si].ns_flags, not NSDISCARD ; mark not discardablels_after_patch: pop ax pop dxls_exeunt: mov cx,axcEnd
GETSEGLEN macro segval local not_huge_386.386p xor eax, eax ; since we now have huge segments, mov ax, segval ; we need to be able to handle limit lsl eax, eax ; values > 64K. On a 386 we just inc eax ; execute the lsl instruction. test eax, 0ffff0000h.286 jz not_huge_386 mov ax, 0 ; 0 == 64Knot_huge_386:endm
;-----------------------------------------------------------------------;; SegLoad ;; ;; Reads in the data portion of a code or data segment. ;; ;; It can be confusing decoding how various values of ns_cbseg, ;; ns_minalloc, and ns_sector define the size of disk files. I hope ;; this table is accurate for all combinations.... ;; ;; sector cbseg minalloc- Sector in memory is ... ;; 0 0 0 - 64K segment, all 0's ;; 0 0 m - 'm' bytes, all 0's ;; 0 c 0 - illegal (sector = 0 when cbseg != 0) ;; 0 c m - illegal (sector = 0 when cbseg != 0) ;; s 0 0 - 64K segment on disk at given sector ;; s 0 m - illegal (cbseg > minalloc) ;; s c 0 - 64K, 'c' from file, 64K-'c' 0's ;; s c m - 'm' bytes, 'c' from file, 'm-c' 0's ;; ;; In other words, cbseg == 0 means 64K when a sector value is given, ;; else it means 0 bytes from the file ;; ;; Arguments: ;; parmD pseginfo ;; parmW segno ;; parmW psegsrc ;; parmW isfh ;; ;; Returns: ;; ;; Error Returns: ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ;; Calls: ;; ;; History: ;; Thu Feb 28, 1991 01:39:00p -by- Don A. Corbitt [donc] ;; Add support for big/huge segments ;; ;; Tue Oct 27, 1987 06:17:07p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothing
cProc SegLoad,<NEAR,PUBLIC>,<si,di> parmD pseginfo parmW segno parmW psegsrc parmW isfh localW hseg localW pseg localW psegdest localD prleinfo localW retry localW segoffset localW pleaseNoLock ;1 if segment is 64K localW allocTwice ;if first alloc fails, FreeTheWorldifdef WOW_x86 localD rover_2endifcBegin mov retry,1 mov segoffset, 0 mov allocTwice, 1 les si,pseginfo mov ax,es:[si].ns_handle mov hseg,ax Handle_To_Sel al ; in case we don't lock mov pleaseNoLock, 1 test es:[si].ns_flags, NSHUGESEG jnz dont_touch ;big segs are always locked and present mov pleaseNoLock, 0 push es cCall MyLock,<ax> pop es or ax,ax jz try_alloc ; wish I could "jnz saalloced"dont_touch: jmps saalloced
try_alloc: push es xor ax,ax mov bx, es:[si].ns_minalloc xor dx, dx cmp bx, 1 adc dx, dx add bx, 2 ; We may have a 1 byte entry point at the adc dx, 0 ; very end of a segment. PatchCodeHandle ; will GP trying to decipher the prolog. ; Allow room to read relocation word cCall IGlobalReAlloc,<hseg,dx,bx,ax> pop es cmp hseg,ax jz sareallocedsaerr2: test es:[si].ns_flags,NSDISCARD jz dont_scream push es cCall DiscardTheWorld ; Maybe if we try again pop es dec allocTwice jz try_alloc krDebugOut DEB_ERROR, "Out of mem loading seg %es2"dont_scream: jmp saerr1
sarealloced: ; ax == handle Handle_To_Sel al cmp pleaseNoLock, 0 jnz saalloced push es cCall MyLock,<hseg> pop es or ax,ax jz saerr2
saalloced: mov pseg,ax mov psegdest,ax
sareread: push es push si push ds ; We are going to trash this
cld cmp es:[si].ns_sector,0 ; if sector == 0, then just init jnz sa_read_from_disk ; segment to all 0's; mov cx, es:[si].ns_minalloc ; convert minalloc == 0 to 64K GETSEGLEN pseg mov cx, axifdef WOW_x86 ;.386;; WOW we can use the magic flat selector 23h to write to any segment;; This saves us calling get_rover_2 which makes an NT system call to set;; a temp selector cCall get_physical_address,<pseg> shl edx,16 mov dx,ax mov ax,FLAT_SEL mov es,ax
xor eax, eax mov edi,edx ; es:edi -> pseg:0
cmp cx, 1 ; Need to handle case where CX == 0 mov dx, cx rcr cx, 1 shr cx, 1 movzx ecx,cx rep stos dword ptr [edi] mov cx, dx and cx, 3 rep stos byte ptr [edi] jmp sa_after_read
else ; 286 cmp cx, 1 ; set CF if 0000 rcr cx, 1 ; this sets CF for odd byte of size xor ax, ax xor di, di mov es, pseg ; start at pseg:0000 call get_rover_2 rep stosw adc cx, cx rep stosb ; this case now handled jmp sa_after_readendif;
sa_read_from_disk: mov di,es:[si].ns_cbseg ; #bytes in segment to read
; If source segment address given then copy segment contents
mov bx,psegsrc ; Get source handle cmp isfh,bx ; Is source a file handle? je sa_read_file ; Yes, go read segment from file
; We are reading from preload buffer, bx == src seg address, di == len push di ; No, set up for fast copy mov OFF_prleinfo,di mov SEG_prleinfo,bx pop cx
mov ds,bxifdef WOW_x86 ;.386;; For WOW on NT we don't want to set the selector unesssarily cCall get_physical_address,<pseg> shl edx,16 mov dx,ax mov rover_2,edx
mov ax,FLAT_SEL mov es,ax
mov edi,edx ; es:edi -> pseg:0 xor esi,esi
cmp cx, 1 ; set carry if 0 for big/huge segs mov ax, cx rcr cx, 1 shr cx, 1 movzx ecx,cx rep movs dword ptr [edi], dword ptr [esi] mov cx, ax and cx, 3 rep movs byte ptr [edi], dword ptr [esi]
sub edi,edx ; make di correct for rest of codeelse mov es,pseg ; Writing to pseg call get_rover_2 xor si,si xor di,di
; need to handle case where seg size is 64K (cx == 0) cmp cx, 1 ; set carry if 0 for big/huge segs.386 mov ax, cx rcr cx, 1 shr cx, 1 rep movsd mov cx, ax and cx, 3 rep movsb.286endif; WOW_x86
; we have now read 'cbseg' bytes from preload buffer, di == cbseg jmp sa_zero_fill_rest saerr1: xor ax,ax jmp sax
sa_read_file: ; read segment contents from disk file, bx == file handle ; ax = disk file sector
if 0 ;KDEBUG push ax push ds SetKernelDS
cmp fPreloadSeg, 0 jne SHORT SkipDebugTrace
mov ax, segno krDebugOut <DEB_TRACE or DEB_krLoadSeg>, "%ES0: reading segment #ax"SkipDebugTrace: pop ds UnSetKernelDS pop axendif
; Get offset to data portion of segment in DX:AX mov ax, es:[si].ns_sector xor dx,dx mov cx,es:[ne_align]sa4a: shl ax,1 adc dx, dx loop sa4a ; DX:AX = file offset to segment
mov cx,dx ; Seek to beginning of segment data mov dx,ax mov ax,4200h ; lseek(bx, sector << align, SEEK_SET) DOSCALL jc saerr mov cx,di ; Get #bytes to read test es:[si].ns_flags,NSRELOC jz no_read_extra_word add cx, 2 ; Relocation wordno_read_extra_word: mov ds,pseg ; Read segment from file xor dx,dx mov ah,3Fh test es:[si].ns_flags,NSITER jz @F call iterated_data_seg jmps sa_iter_done@@: or cx, cx ; if cx == 0 at this point, it is 64K jnz not_huge_read
cmp es:[si].ns_minalloc,0 ; If minalloc isn't zero too, then the jnz not_huge_read ; segment is too small. Case should't ; happen but does for dbwindow, mimic Win 3.0.
mov cx, 8000h DOSCALL ; read first 32K from disk jc saerr add dx, cx ; update destination address mov ah, 3fh ; restore AX (doscall trashes it) DOSCALL ; read second 32K jc saerr cmp ax, cx jnz saerr jmp short sa_zero_fill_rest
not_huge_read: DOSCALLsa_iter_done: jc saerr ; Continue if no errors cmp ax,cx ; Read ok, did we get what we asked for? jne saerr ; No, fail test es:[si].ns_flags,NSRELOC ; Relocation records? jz sa_zero_fill_rest ; No, continue mov ax, ds:[di] ; Extra word was read here mov OFF_prleinfo, ax jmps sa_zero_fill_restsaerr: pop ds pop si pop es mov ax, -1 ; File error jmp sax
sa_zero_fill_rest: ; di == bytes written so far GETSEGLEN pseg ; seg len to ax, 0 == 64K
sub ax,di ; Any uninitialized portion? jz sa_after_read ; No, continueifdef WOW_x86;.386;; WOW we don't want to call NT to set the selector push ax cCall get_physical_address,<psegdest> shl edx,16 mov dx,ax mov ax,FLAT_SEL mov es,ax
and edi,0000ffffh add edi,edx ; es:edi -> pseg:0 pop cx
push edx
xor eax,eax cld mov dx,cx shr cx, 2 movzx ecx,cx rep stos dword ptr [edi] mov cx, dx and cx, 3 rep stos byte ptr [edi]
pop edx sub edi,edx
else mov es,psegdest ; Yes, set it to zero call get_rover_2 mov cx,ax xor ax,ax cld shr cx, 1 rep stosw adc cx, cx rep stosbendif
sa_after_read: les si, pseginfo
if LDCHKSUM mov ds,psegdest xor si,si mov cx,di shr cx,1 xor dx,dx cldsa5b: lodsw xor dx,ax loop sa5bendif cmp pleaseNoLock, 0 jnz dont_patch push dx cCall <far ptr PatchCodeHandle>,<hseg> pop dxdont_patch: pop ds ; Restore DS pop si ; segment info pointer pop es mov ax,es:[si].ns_flags ; Are we loading a code segment? and ax,NSDATA .errnz NSCODE jnz sa9
; Here when loading a code segment
if LDCHKSUM mov cx,segno dec cx shl cx,1 shl cx,1 mov di,es:[ne_psegcsum] add di,cx mov cx,dx xchg es:[di],cx jcxz sa6a0 cmp cx,dx je sa6a0 dec retry jl sa6a1 public badsegreadbadsegread: mov ah,0Dh ; Disk Reset DOSCALL jmp sarereadsa6a1: krDebugOut DEB_ERROR, "Segment contents invalid %es2" xor ax,ax jmps saxsa6a0: mov word ptr es:[di+2],0endif
sa9: mov dx,SEG_prleinfo mov cx,OFF_prleinfo mov bx,hseg mov ax,psegsax: or ax,axcEnd
.286
;-----------------------------------------------------------------------;; iterated_data_seg;; This expands out iterated data segments (specifically for the; OS/2 m.exe). Due to the late date this is being sleazed in; instead of being done right. To be done right, the read would; go into the last part of the present block, and expanded in place,; the stack used for the next record count because the last record; never fits.;; Entry:; CX = number of bytes to read; DS:DX = place to put them; DS:DI = place where #relocs will magically appear; ES:SI = module exe header:seg info;; Returns:; CF = 1; DS:DI = updated magic place where #relocs will magically appear;; Error Return:; CX = 0;; Registers Destroyed:;; History:; Sun 28-Jan-1990 12:25:02 -by- David N. Weise [davidw]; Wrote it!;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothing
cProc iterated_data_seg,<PUBLIC,NEAR>,<bx,dx,si,ds,es>
localW temp_buf localW freloccBegin
; deal with that extra relocation word!
xor ax,ax test es:[si].ns_flags,NSRELOC ; Relocation records? jz @F inc ax@@: mov freloc,ax
; first get a temp buffer
push bx push cx cCall IGlobalAlloc,<0,0,cx> mov temp_buf,ax pop cx pop bx or ax,ax stc ; assume failure jz ids_exit push dx push ds
; read into the temp buffer
mov ds,ax xor dx,dx mov ah,3Fh DOSCALL pop ds pop dx jc ids_exit1 cmp ax,cx jnz ids_exit1
; expand the buffer, yes we should special case strings of length 1
cmp freloc,0 ; was an extra word read? jz @F sub cx,2@@: mov dx,cx smov es,ds xor di,di mov ds,temp_buf xor si,si cldids_next_group: lodsw ; get the # interations mov cx,ax lodsw ; get the # bytes@@: push cx push si mov cx,ax rep movsb pop si pop cx loop @B add si,ax ; get past group cmp si,dx jb ids_next_group
; data segment now processed, deal with reloc word
cmp freloc,0 ; was an extra word read? jz @F movsw sub di,2 add dx,2@@: mov ax,dx mov cx,dx clc
ids_exit1: pushf ; preserve the carry flag push ax push cx smov ds,0 cCall IGlobalFree,<temp_buf> pop cx pop ax popf
ids_exit:
cEnd
;-----------------------------------------------------------------------;; PatchCodeHandle ;; ;; Patches the prologs of the procedures in the given code segment. ;; ;; Arguments: ;; parmW hseg ;; ;; Returns: ;; AX = hseg ;; DX = pseg ;; ;; Error Returns: ;; ;; Registers Preserved: ;; DI,SI,DS ;; ;; Registers Destroyed: ;; BX,CX,ES ;; ;; Calls: ;; MyLock ;; ;; History: ;; ;; Sun 17-Sep-1989 10:45:24 -by- David N. Weise [davidw] ;; Added support for symdeb to understand segments in himem. ;; ;; Tue Oct 27, 1987 06:19:12p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
assumes ds,nothing assumes es,nothingcProc PatchCodeHandle,<PUBLIC,FAR>,<si,di> parmW hseg localW pseg localW hexe localW segno localW segoffsetifdef WOW_x86.386 localD rover_2endifcBegin SetKernelDS cCall MyLock,<hseg> mov pseg,ax ; Save physical addresss or ax,ax ; All done if discarded jz pcsDone1
xor si,si mov segoffset, si
push ax cCall GetOwner,<pseg> mov es, ax pop ax
cmp es:[si].ne_magic,NEMAGICif KDEBUG jz good_boybad_boy: krDebugOut DEB_ERROR "PatchCodeHandle, owner not NewExe %es2" jmps pcsDone1good_boy:endif jne pcsDone1 mov hexe,es mov cx,es:[si].ne_cseg ; We need si to point to entry mov si,es:[si].ne_segtab ; anyway so do it the slow waypcsLoop: cmp es:[si].ns_handle,dx ; Scan table for handle je pcsFound add si,SIZE NEW_SEG1 loop pcsLooppcsDone1: jmp pcsDonepcsExit1: jmp pcsExitpcsFound: sub cx,es:[ne_cseg] ; Compute segment# from remainder neg cx ; of loop count inc cx ; 1-based segment# mov segno,cx
test es:[si].ns_flags,NSDATA jnz pcsExit1 .errnz NSCODE
push si mov di,es:[ne_pautodata] or di,di jz sa6a cCall MyLock,<es:[di].ns_handle> mov di,axsa6a: ; DI:0 points to data segment (or 0)ifdef WOW_x86;; For WOW we use the NT Magic data selector, since all 16 bit code is DATA cCall get_physical_address,<pseg> assumes es,nothing shl edx,16 mov dx,ax ; ES:EDX -> pseg:0 mov rover_2,edx
mov ax,FLAT_SEL mov es,axelse mov es,pseg ; ES:0 points to code segment call get_rover_2endif mov ds,hexe ; DS:SI points to entry table assumes ds,nothing mov si,ds:[ne_enttab] cld
or di, di ; Anything to do? jz sa6xsa6b: lods word ptr ds:[si] mov dx, ax lods word ptr ds:[si] sub ax, dx ; Get # entries in this block or ax,ax jz sa6x ; Done if zero push word ptr ds:[si] ; Next block add si, 2 ; Skip Next mov cx,ax
sa6c: mov al,ds:[si].pentsegno ; Get segment# from int instruction cmp byte ptr segno,al ; Does this moveable segment match ES? jne sa6e ; No, advance to next entry
ifdef WOW_x86
movzx ebx, word ptr ds:[si].pentoffset ; Get entry point offset add ebx,rover_2 mov al, ds:[si].pentflags ; Get entry point flags
cmp byte ptr es:[ebx+2],90h ; Yes, followed by nop? jne sa6e ; No, can;t patch prolog then cmp word ptr es:[ebx],0581Eh ; Is it a push ds, pop ax? jne @F ; Yes, take care of prolog
mov word ptr es:[ebx],0D88Ch jmps sa6d1@@: cmp word ptr es:[ebx],0D88Ch ; Is it a mov ax,ds? jne sa6e ; No, can't patch prolog thensa6d1: test al,ENT_DATA ; Valid prolog. shared data? jnz sa6d2 ; Yes, patch mov ax,DGROUP into prolog test byte ptr ds:[ne_flags],NEINST ; No, multiple instances? jz sa6e ; No, do nothing test al,ENT_PUBLIC ; Public entry point? jz sa6e ; No, do nothing mov word ptr es:[ebx],09090h ; Yes, set nop, nop in prolog jmps sa6esa6d2: mov byte ptr es:[ebx],0B8h ; Set mov ax, mov es:[ebx+1],di ; DGROUP
else ; NOT WOW_x86
mov bx, ds:[si].pentoffset ; Get entry point offset mov al, ds:[si].pentflags ; Get entry point flags
cmp byte ptr es:[bx+2],90h ; Yes, followed by nop? jne sa6e ; No, can;t patch prolog then cmp word ptr es:[bx],0581Eh ; Is it a push ds, pop ax? jne @F ; Yes, take care of prolog
mov word ptr es:[bx],0D88Ch jmps sa6d1@@: cmp word ptr es:[bx],0D88Ch ; Is it a mov ax,ds? jne sa6e ; No, can't patch prolog thensa6d1: test al,ENT_DATA ; Valid prolog. shared data? jnz sa6d2 ; Yes, patch mov ax,DGROUP into prolog test byte ptr ds:[ne_flags],NEINST ; No, multiple instances? jz sa6e ; No, do nothing test al,ENT_PUBLIC ; Public entry point? jz sa6e ; No, do nothing mov word ptr es:[bx],09090h ; Yes, set nop, nop in prolog jmps sa6esa6d2: mov byte ptr es:[bx],0B8h ; Set mov ax, mov es:[bx+1],di ; DGROUPendif; WOW_x86sa6e: add si,SIZE PENT ; Advance to next entry in loop sa6c ; this block pop si or si, si jnz sa6bsa6x: mov es,hexe pop sipcsExit: or byte ptr es:[si].ns_flags,NSLOADED ; Mark segment as loaded
;;;if SDEBUG ; Tell debugger about new segment;;; mov bx,es:[ne_restab];;; inc bx;;; mov dx,es:[si].ns_flags;;; mov ax,segoffset ; tell symdeb how to fixup symbols;;; test dx,NSDATA ; test to pass NSKCACHED too;;; jz sa8;;; test byte ptr es:[ne_flags],NEINST;;; jz sa8;;; mov ax,es:[ne_usage];;; dec ax;;;sa8:;;; mov cx,segno;;; dec cx;;; cCall DebugDefineSegment,<esbx,cx,pseg,ax,dx>;;;endifpcsDone: mov ax,hseg mov dx,psegcEnd
sEnd CODE
externFP FarAllocSegexternFP FarMyAllocexternFP FarMyAllocLinearexternFP FarMyFreeexternFP FarSetOwner
sBegin NRESCODEassumes CS,NRESCODEassumes DS,NOTHINGassumes ES,NOTHING
externNP MapDStoDATA
externA __AHINCR
;-----------------------------------------------------------------------;; AllocAllSegs ;; ;; "Allocates" for all segments of the module being loaded and stores ;; the addresses in the segment table. By allocate we mean: ;; ;; AUTOMATIC DATA gets space, but not yet loaded, ;; PRELOAD FIXED get global mem allocated , but not yet loaded, ;; MOVEABLE get a handle for later use, ;; FIXED get nothing. ;; ;; If this is not the first instance, then just allocate space for ;; the new instance of the automatic data segment. ;; ;; Arguments: ;; parmW hexe ;; ;; Returns: ;; ;; Error Returns: ;; AX =-1 not enough memory ;; ;; Registers Preserved: ;; ;; Registers Destroyed: ;; ;; Calls: ;; FarAllocSeg ;; FarMyAlloc ;; FarMyFree ;; ;; History: ;; ;; Tue Feb 24, 1987 01:04:12p -by- David N. Weise [davidw] ;; Added this nifty comment block. ;;-----------------------------------------------------------------------;
cProc AllocAllSegs,<NEAR,PUBLIC>,<si,di,ds> parmW hexe localW cSegs localD hugeLen ; cum length of huge segment localW hugeIndex ; index of first segment of huge localW hugeOffs ; offset of first segment desc of huge localW hugeCnt ; segments making up huge seg localW hugeFlags ; flags of huge segment (needed?)
cBegin call MapDStoDATA ReSetKernelDS mov es,hexe mov si,es:[ne_segtab] xor di,di mov cSegs,di inc di cmp es:[ne_usage],di je paloop mov si,es:[ne_pautodata] and byte ptr es:[si].ns_flags,not NSALLOCED+NSLOADED mov di,es:[si].ns_handle cCall FarAllocSeg,<essi> or ax,ax jz aa_nomem inc cSegsoutahere: jmp pagood
aa_nomem: mov es,hexe or byte ptr es:[si].ns_flags,NSALLOCED+NSLOADED mov es:[si].ns_handle,di jmp pafail3
paloop: cmp di,es:[ne_cseg] jbe more_to_go jmp pagood
more_to_go:
mov bx,es:[si].ns_flags test bl,NSPRELOAD ; Are we preloading? jz not_preload test bl,NSDATA ; Preload data although moveable jnz paalloc test bl,NSMOVE ; Fixed segment? jz paalloc ; Yes, allocate segmentnot_preload:
test bl,NSALLOCED ; Already allocated? jnz panext ; Yes, then nothing to do test bl,NSMOVE ; Fixed segment? jz panext ; Yes, then nothing to do
xor cx,cx ; No, allocate zero length push es ; object so that we guarantee cCall FarMyAlloc,<bx,cx,cx> ; we will have a handle. pop es or dx,dx ; Fail if we cant get a handle jz pafail mov es:[si].ns_handle,dx ; Handle into seg table and byte ptr es:[si].ns_flags,not NSLOADED or byte ptr es:[si].ns_flags,NSALLOCED
mov bx,dx ; put handle into base register call set_discarded_sel_owner jmps panext
paalloc:
cmp es:[si].ns_minalloc, 0 jnz paalloc_fer_shure jmps PAHugeAlloc
paalloc_fer_shure: cCall FarAllocSeg,<essi> or ax,ax jz pafail inc cSegspanext: add si,size NEW_SEG1 inc di jmp paloop
; only gets here if not enough memory, free up all previous segments
pafail: mov si,es:[ne_segtab] mov cx,es:[ne_cseg]pafail1: push cx mov cx,es:[si].ns_handle jcxz pafail2 push es ;Need to handle freeing huge segments!!! cCall FarMyFree,<cx> pop es mov es:[si].ns_handle, 0 ; Necessary for EntProcAddresspafail2: and byte ptr es:[si].ns_flags,not (NSALLOCED+NSLOADED) add si,size NEW_SEG1 pop cx loop pafail1pafail3: mov cSegs,-1 jmp pagood
PAHugeAlloc: ; at this point, es:si -> current seg record ; di is segment index (range from 1 to es:[ne_cseg]) mov off_hugeLen, 0 mov seg_hugeLen, 0 ; init length to 0K
mov hugeOffs, si mov hugeCnt, 1 mov ax, es:[si].ns_flags or ax, NSHUGESEG mov hugeFlags, axPAHugeLoop: mov ax, es:[si].ns_minalloc ; add current segment to group cmp ax, 1 sbb dx, dx neg dx add off_hugeLen, ax adc seg_hugeLen, dx or es:[si].ns_flags, NSHUGESEG
cmp es:[si].ns_minalloc, 0 ; jnz PAHugeEndLoop
cmp di, es:[ne_cseg] jae PAHugeEndLoop
mov ax, si add ax, size NEW_SEG1 cmp ax, es:[ne_pautodata] jz PAHugeEndLoop
mov ax, hugeFlags ; do flags have to be identical? cmp ax, es:[si].ns_flags jnz PAHugeEndLoop
inc hugeCnt inc di add si, size NEW_SEG1 jmp PAHugeLoop
PAHugeEndLoop: inc di push es or hugeFlags, NSMOVE cCall FarMyAllocLinear, <hugeFlags, hugeLen> pop es or ax, ax ; check for error jnz Not_pafail jmp pafailNot_pafail:
mov si, hugeOffs ; fix up segment(s) and es:[si].ns_flags, NOT NSHUGESEGPAHugeSegLoop: mov es:[si].ns_handle, dx and byte ptr es:[si].ns_flags, not NSLOADED or byte ptr es:[si].ns_flags, NSALLOCED cCall FarSetOwner, <ax, es> add si, size NEW_SEG1 add dx, __AHINCR dec hugeCnt jnz PAHugeSegLoop
; continue with rest of allocations
jmp paloop
pagood: mov ax,cSegscEnd
sEnd NRESCODE
end
|
