|
|
DOSSEG .MODEL LARGE
include disk.incinclude partit.inc
.DATA extrn _x86BootCode:far
.DATA? extrn PartitionList:dword extrn PartitionListCount:word
.CODE ASSUME ds:NOTHING
extrn _malloc:far extrn _free:far extrn _qsort:far extrn _ReadDisk:far extrn _WriteDisk:far extrn _GetDiskInfoByHandle:far
.386
;++;; INT; _far; MakePartitionAtStartOfDisk(; IN HDISK DiskHandle,; OUT FPVOID SectorBuffer,; IN ULONG MinimumSectorCount,; IN UINT PartitionClass,; IN BYTE SystemId OPTIONAL; );;; Routine Description:;; This routine makes a new primary partition of at least; a given number of sectors. The partition may be larger; to keep it aligned on the proper cyl/track boundary.;; Only int13 disk units are supported.;; Arguments:;; DiskHandle - supplies a disk handle as returned by OpenDisk().;; SectorBuffer - supplies a pointer to a buffer suitable for use; for i/o of a single sector. This buffer must not; cross a DMA boundary, but the caller is responsible; for ensuring this.;; MinimumSectorCount - supplies the minimum number of sectors; that the partition should contain.;; PartitionClass - supplies a value indicating what class of system id; should be used for the partition.;; PARTCLASS_FAT - creates a type 1, 4, or 6, or e partition; depending on size and availability of xint13; services for the drive.;; PARTCLASS_FAT32 - creates a type b or c partition depending; on availability of xint13 services for the drive.;; PARTCLASS_NTFS - creates a type 7 partition.;; PARTCLASS_OTHER - create a partition whose type is given by; the SystemId parameter.;; SystemId - if PartitionClass is PARTCLASS_OTHER, supplies the; system id for the partition. Ignored otherwise.;; Return Value:;; Partition id of newly created partition, or -1 if failure.;;--
DiskHandle equ dword ptr [bp+6]DiskHandlel equ word ptr [bp+6]DiskHandleh equ word ptr [bp+8]SectorBuffer equ dword ptr [bp+10]SectorBufferl equ word ptr [bp+10]SectorBufferh equ word ptr [bp+12]MinimumSectorCount equ dword ptr [bp+14]MinimumSectorCountl equ word ptr [bp+14]MinimumSectorCounth equ word ptr [bp+16]PartitionClass equ word ptr [bp+18]SystemId equ byte ptr [bp+20]
ExtSecCnth equ word ptr [bp-2]ExtSecCntl equ word ptr [bp-4]ExtSecCnt equ dword ptr [bp-4]Cylinders equ word ptr [bp-6]Heads equ word ptr [bp-8]SectorsPerTrack equ byte ptr [bp-9]Int13UnitNumber equ byte ptr [bp-10]SectorsPerCylinder equ word ptr [bp-12]DiskSizeh equ word ptr [bp-14]DiskSizel equ word ptr [bp-16]DiskSize equ dword ptr [bp-16]DiskId equ word ptr [bp-18]Tableh equ word ptr [bp-20]Tablel equ word ptr [bp-22]Table equ dword ptr [bp-22]FreeStarth equ word ptr [bp-24]FreeStartl equ word ptr [bp-26]FreeStart equ dword ptr [bp-26]
START_AND_SIZE STRUC PartStartl dw ? PartStarth dw ? PartSizel dw ? PartSizeh dw ?START_AND_SIZE ENDS
public _MakePartitionAtStartOfDisk_MakePartitionAtStartOfDisk proc far
push bp mov bp,sp sub sp,26
push ds push es push bx push si push di
; ; Get disk info. This also makes sure the handle is open, ; calculates the number of sectors we can address on the disk, ; and the number of sectors in a cylinder. ; call near ptr pGetDiskValues jnc @f mov ax,0ffffh jc done2
; ; Allocate a buffer for our table. ; Make sure ds addresses DGROUP for crt ;@@: push ds push DGROUP pop ds push 5 * SIZE START_AND_SIZE call _malloc add sp,2 pop ds mov cx,ax or cx,dx jnz @f dec ax ; ax = -1 for error return jmp done2@@: mov Tableh,dx mov Tablel,ax
; ; Read sector 0 of the disk. ; push SectorBuffer push 1 push 0 push 0 push DiskHandle call _ReadDisk add sp,14 cmp ax,0 jne @f dec ax jmp done1 ; ax = -1 for error exit
; ; Make sure the MBR is valid. ;@@: lds si,SectorBuffer cmp word ptr [si+510],0aa55h je @f mov ax,0ffffh jmp done1
; ; Zero out the start/offset table. ;@@: les di,Table ; es:di -> local start/size table mov ax,0 mov cx,4*(SIZE START_AND_SIZE) cld rep stosb
; ; Build the start/offset table. ; mov cx,4 ; cx = loop count add si,1beh ; ds:si -> start of partition table mov di,Tablel ; es:di -> local start/size tablenextent: cmp byte ptr [si+4],0 jnz @f add si,16 loop nextent jmp short chkfull@@: add si,8 ; ds:si -> relative sector field movsw ; start low movsw ; start high movsw ; count low movsw ; count high inc al ; remember number of used entries loop nextent
; ; See if the partition table is full. ;chkfull: cmp al,4 jne @f mov ax,0ffffh je done1
; ; Sort the local start/size table. Before calling crt ; make sure ds addresses DGROUP. ;@@: push ds push DGROUP pop ds push ax ; save table length push SEG CompareStartSize push OFFSET CompareStartSize ; compare routine pointer push SIZE START_AND_SIZE ; size of each element push ax ; number of elements to sort push Table ; array of elements to sort call _qsort add sp,12 pop bx ; restore table length pop ds
; ; Put a "fence" entry at the end of the table ; for space at the end of the disk. ; mov al,SIZE START_AND_SIZE mul bl ; ax = byte offset to fence entry inc bl ; account for fence entry les di,Table add di,ax ; es:di -> fence entry mov ax,DiskSizel mov es:[di].PartStartl,ax mov ax,DiskSizeh mov es:[di].PartStarth,ax mov es:[di].PartSizel,1 mov es:[di].PartSizeh,0
; ; Initialize for loop. The first space starts on the first sector ; of the second head. ; mov al,SectorsPerTrack cbw mov FreeStartl,ax mov FreeStarth,0
mov cl,bl xor ch,ch ; cx = # entries in table les di,Table ; es:di -> start/offset table jmp short aligned1
; ; Get the start of the partition and align to cylinder boundary ;nextspace: mov dx,FreeStarth mov ax,FreeStartl ; dx:ax = start of free space div SectorsPerCylinder ; dx = sector within cylinder cmp dx,0 ; already aligned? jz aligned1 ; yes mov bx,SectorsPerCylinder sub bx,dx ; bx = adjustment to next boundary add FreeStartl,bx adc FreeStarth,0 ; FreeStart now aligned
aligned1: mov dx,es:[di].PartStarth mov ax,es:[di].PartStartl ; dx:ax = start of partition sub ax,FreeStartl sbb dx,FreeStarth ; dx:ax = size of free space push ax push dx
; ; Now make sure the end of the free space is aligned. ; add ax,FreeStartl adc dx,FreeStarth ; dx:ax = first sector past free space div SectorsPerCylinder ; dx = sector within cylinder (may be 0) mov bx,dx pop dx pop ax ; dx:ax = size of free space sub ax,bx sbb dx,0 ; dx:ax = size of aligned free space js nextspace1 ; just in case
; ; Check the free space to see if it's large enough. ; cmp dx,MinimumSectorCounth ja makepart ; it's large enough jb nextspace1 cmp ax,MinimumSectorCountl jae makepartnextspace1: mov ax,es:[di].PartStartl add ax,es:[di].PartSizel mov FreeStartl,ax mov ax,es:[di].PartStarth adc ax,es:[di].PartSizeh mov FreeStarth,ax ; next space is after this partition add di,SIZE START_AND_SIZE ; point at next table entry loop nextspace mov ax,cx ; no room, set ax for error return dec ax jmp done1
; ; If we get here, we've found a free space that will work ; for our partition. ; ; FreeStart has the start of the free space. ;makepart: mov ax,FreeStartl add ax,MinimumSectorCountl mov dx,FreeStarth adc dx,MinimumSectorCounth
div SectorsPerCylinder ; dx = sector within cylinder cmp dx,0 ; aligned already? jz @f ; yes mov bx,SectorsPerCylinder sub bx,dx ; bx = adjustment to next cyl boundary add MinimumSectorCountl,bx adc MinimumSectorCounth,0
; ; Now MinimumSectorCount has the actual sector count. ; Find a free table entry. We know there is one or else ; we'd have errored out a while ago. ;@@: lds si,SectorBuffer add si,1beh ; ds:si -> partition table@@: cmp byte ptr [si+4],0 jz makepart1 add si,16 jmp short @b
makepart1: mov ax,FreeStartl mov dx,FreeStarth mov [si+8],ax mov [si+10],dx add si,1 call pMakeCHS mov ax,MinimumSectorCountl mov dx,MinimumSectorCounth mov [si+11],ax mov [si+13],dx add ax,FreeStartl adc dx,FreeStarth sub ax,1 sbb dx,0 add si,4 call pMakeCHS ; al = xint13 required flag sub si,1 ; ds:si -> system id byte
; ; Figure out the partition id. ; al is xint13 required flag ; mov dx,PartitionClass mov ah,SystemId call pDetermineSystemId mov [si],al ; store away system id
sub si,4 ; ds:si -> partition table entry call pNewPartitionRecord cmp ax,0ffffh je done1 ; error, bail now
; ; Phew. Write out the master boot sector. ; push ax ; save partition id push SectorBuffer push 1 push 0 push 0 push DiskHandle call _WriteDisk add sp,14 ; ax set for return pop dx ; dx = partition id cmp ax,0 ; error? jne @f ; no dec ax ; ax = -1 for error return jmp short done1@@: mov ax,dx ; ax = partition id for return
done1: push ax push Table push DGROUP pop ds ; address DGROUP for crt call _free add sp,4 pop ax
done2: pop di pop si pop bx pop es pop ds
leave retf
_MakePartitionAtStartOfDisk endp
Comparand1 equ dword ptr [bp+6]Comparand2 equ dword ptr [bp+10]
CompareStartSize proc far
push bp mov bp,sp
push ds push es push di push si
lds si,Comparand1 les di,Comparand2
mov dx,es:[di].PartStarth mov ax,es:[di].PartStartl
cmp [si].PartStarth,dx jb less1 ja greater1
cmp [si].PartStartl,ax jb less1 ja greater1
xor ax,ax jmp short compdone
less1: mov ax,0ffffh jmp short compdone
greater1: mov ax,1
compdone: pop si pop di pop es pop ds
leave retf
CompareStartSize endp
;++;; INT; _far; MakePartitionAtEndOfEmptyDisk(; IN HDISK DiskHandle,; OUT FPVOID SectorBuffer,; IN ULONG MinimumSectorCount,; IN BOOL NewMasterBootCode; );;; Routine Description:;; This routine creates an partition at the very end of a disk.; The disk MUST be completely empty. If no valid MBR exists,; one will be created.;; The partition will be made active.;; Arguments:;; DiskHandle - supplies handle to open disk, from OpenDisk().;; SectorBuffer - supplies a pointer to a buffer suitable for use; for i/o of a single sector. This buffer must not; cross a DMA boundary, but the caller is responsible; for ensuring this.;; MinimumSectorCount - supplies minimum number of sectors; for the partition. The actual size may be larger; to account for rounding, etc.;; This routine does NOT properly deal with partitions; that start on cylinder 0 or are larger than the size; of the disk! The caller must ensure that these cases; do not occur.;; NewMasterBootCode - if non-0, then new master boot code will; be written regardless of the current state of the MBR.;; Return Value:;; Partition id of newly created partition.; -1 means failure;;--
DiskHandle equ dword ptr [bp+6]DiskHandlel equ word ptr [bp+6]DiskHandleh equ word ptr [bp+8]SectorBuffer equ dword ptr [bp+10]SectorBufferl equ word ptr [bp+10]SectorBufferh equ word ptr [bp+12]MinimumSectorCount equ dword ptr [bp+14]MinimumSectorCountl equ word ptr [bp+14]MinimumSectorCounth equ word ptr [bp+16]NewMasterBootCode equ word ptr [bp+18]
ExtSecCnth equ word ptr [bp-2]ExtSecCntl equ word ptr [bp-4]ExtSecCnt equ dword ptr [bp-4]Cylinders equ word ptr [bp-6]Heads equ word ptr [bp-8]SectorsPerTrack equ byte ptr [bp-9]Int13UnitNumber equ byte ptr [bp-10]SectorsPerCylinder equ word ptr [bp-12]DiskSizeh equ word ptr [bp-14]DiskSizel equ word ptr [bp-16]DiskSize equ dword ptr [bp-16]DiskId equ word ptr [bp-18]
public _MakePartitionAtEndOfEmptyDisk_MakePartitionAtEndOfEmptyDisk proc far
push bp mov bp,sp sub sp,18
push ds push es push bx push si push di
; ; Get disk info. This also makes sure the handle is open, ; calculates the number of sectors we can address on the disk, ; and the number of sectors in a cylinder. ; call near ptr pGetDiskValues jnc @f mov ax,0ffffh jc mpaod_4
@@: ; ; Read the mbr. ; push SectorBuffer push 1 push 0 push 0 push DiskHandle call _ReadDisk add sp,14 cmp ax,0 jne @f dec ax ; ax = -1 for error return jmp mpaod_4
; ; Check the mbr. If not valid, make it valid. ;@@: les di,SectorBuffer cmp NewMasterBootCode,0 jnz makembr ; caller wants new master boot code cmp byte ptr es:[di+510],055h jne makembr cmp byte ptr es:[di+511],0aah je mbrokmakembr: mov byte ptr es:[di+510],055h mov byte ptr es:[di+511],0aah mov si,offset DGROUP:_x86BootCode mov cx,1b8h/2 ; don't overwrite NTFT sig or table rep movsw
mbrok: ; ; Make sure all entries are empty. ; lds si,SectorBuffer add si,1beh mov cx,0 mov ax,cx dec ax ; ax = -1 cmp [si+04h],cl jnz mpaod_4 cmp [si+14h],cl jnz mpaod_4 cmp [si+24h],cl jnz mpaod_4 cmp [si+34h],cl jnz mpaod_4
; ; Calculate the starting sector. We don't worry about aligning ; the end sector because in the conventional int13 case we ; calculated the disk size based on cylinder count, which means ; it is guaranteed to be aligned; in the xint13 case CHS isn't ; even relevent and in any case there won't be any partitions ; on the disk after this one. ; mov ax,DiskSizel sub ax,MinimumSectorCountl mov dx,DiskSizeh sbb dx,MinimumSectorCounth ; dx:ax = start sector of partition mov [si+8],ax mov [si+10],dx ; save in partition table div SectorsPerCylinder ; ax = cyl, dx = sector within cyl sub [si+8],dx ; note: dx is zero if already aligned sbb [si+10],cx ; partition table has aligned start mov ax,MinimumSectorCountl add ax,dx ; grow to account for alignment mov [si+12],ax mov ax,MinimumSectorCounth adc ax,cx mov [si+14],ax ; put adjusted size in partition table
; ; Make the partition active. ; mov byte ptr [si],80h
; ; Fill in CHS values for the partition ; mov ax,[si+8] mov dx,[si+10] ; dx:ax = start sector inc si ; ds:si -> start CHS in part table call pMakeCHS mov ax,[si+7] add ax,[si+11] mov dx,[si+9] adc dx,[si+13] sub ax,1 sbb dx,0 ; dx:ax = last sector add si,4 ; ds:si -> end CHS in part table call pMakeCHS ; al = overflow flag
; ; Figure out the system id. ; al is xint13 required flag ; mov dx,PARTCLASS_FAT call pDetermineSystemId mov [si-1],al ; store away system id
; ; Build a partition record for this guy and add to list. ; sub si,5 ; ds:si -> partition table entry call pNewPartitionRecord cmp ax,0ffffh je mpaod_4 ; error, ax set for return
; ; The mbr is ready, write it out. ; push ax push SectorBuffer push 1 push 0 push 0 push DiskHandle call _WriteDisk add sp,14 mov dx,ax pop ax ; ax = partition id cmp dx,0 ; write error? jnz mpaod_4 ; no, ax = partition id for exit mov ax,0ffffh ; set ax for error return
mpaod_4: pop di pop si pop bx pop es pop ds
leave retf
_MakePartitionAtEndOfEmptyDisk endp
;++;; INT; _far; ReinitializePartitionTable(; IN HDISK DiskHandle,; OUT FPVOID SectorBuffer; );;; Routine Description:;; This routine wipes a disk completely clean by clearning; the partition table and writing new boot code.;; NOTE: after this routine, partition ids may change!;; Arguments:;; DiskHandle - supplies handle to open disk, from OpenDisk().;; SectorBuffer - supplies a pointer to a buffer suitable for use; for i/o of a single sector. This buffer must not; cross a DMA boundary, but the caller is responsible; for ensuring this.;; Return Value:;; The new number of total partitions, -1 if error;;--
DiskHandle equ dword ptr [bp+6]SectorBuffer equ dword ptr [bp+10]
public _ReinitializePartitionTable_ReinitializePartitionTable proc far
push bp mov bp,sp
push ds push es push si push di pushf
; ; This is very simple. Move template boot code ; into the sector buffer and write it out. ; les di,SectorBuffer push DGROUP pop ds mov si,OFFSET DGROUP:_x86BootCode mov cx,512/2
cld rep movsw
push SectorBuffer push 1 push 0 push 0 push DiskHandle call _WriteDisk add sp,14 cmp ax,0 jnz rpt2 dec ax ; ax = -1 for return jmp short rpt8
; ; Now go through the partition list, removing all entries that were ; on this disk. ;rpt2: les di,DiskHandle mov bx,es:[di].DiskInfoDiskId ; bx = id of disk we're wiping mov dx,[PartitionListCount] mov si,OFFSET DGROUP:PartitionList ; ds:si = &PartitionList .errnz PartInfoNext
rpt3: mov cx,[si].PartInfoNextl or cx,[si].PartInfoNexth jz rpt5 ; done les di,[si].PartInfoNext ; es:di -> current, ds:si -> prev cmp es:[di].PartInfoDiskId,bx ; partition on disk we wiped? jne rpt4 ; no
dec dx ; one fewer total partitions
mov ax,es:[di].PartInfoNextl mov [si].PartInfoNextl,ax mov ax,es:[di].PartInfoNexth mov [si].PartInfoNexth,ax ; prev->next = current->next
push bx push ds push DGROUP pop ds ; make sure we're addressing DGROUP push es push di call _free ; free(current) add sp,4 pop ds pop bx ; restore disk id
jmp short rpt3
rpt4: mov ax,es mov ds,ax mov si,di ; prev = current jmp short rpt3
rpt5: push DGROUP pop ds mov [PartitionListCount],dx ; save new count mov ax,dx ; ax = return value
; ; Now reassign partition ids so they are contiguous. ; mov si,OFFSET DGROUP:PartitionListrpt6: mov cx,[si].PartInfoNextl or cx,[si].PartInfoNexth jz rpt8 dec dx lds si,[si].PartInfoNext mov [si].PartInfoDiskId,dx jmp short rpt6
rpt8: popf pop di pop si pop es pop ds
leave retf
_ReinitializePartitionTable endp
;; dx:ax = sector to translate; ds:si -> CHS bytes;pMakeCHS proc near
div SectorsPerCylinder ; ax = cylinder, dx = sector in cyl
cmp ax,Cylinders ; overflow? jb chsok ; no, continue
push 1 ; overflow flag mov ax,Cylinders dec ax ; store max cylinder in table jmp short chs1
chsok: push 0 ; no overflow flagchs1: mov cx,ax xchg cl,ch shl cl,6
; ; small divide is acceptable here since head is 1-255, sector is ; 1-63 (and thus max sector within cyl is (63*256)-1). ; mov ax,dx div SectorsPerTrack ; al = head, ah = sector inc ah ; sector is 1-based or cl,ah ; cx has cyl/sector in int13 format
storechs: mov [si+1],cx ; store in partition table entry mov [si],al ; store head in partition table entry
pop ax ; return overflow flag ret
pMakeCHS endp
;; ds:si -> partition table entry with lba and sysid fields filled in; preserves none; returns new part ordinal or -1;pNewPartitionRecord proc near
; ; Allocate a new partition record ; push ds push si push DGROUP pop ds mov si,OFFSET DGROUP:PartitionListCount push [si] ; save count for later inc word ptr [si] push SIZE PART_INFO call _malloc add sp,2 pop bx ; restore partition count pop si pop ds ; ds:si -> partition table entry mov cx,ax or cx,dx jnz @f ; malloc ok mov ax,0ffffh jz npr_done ; return failure
@@: push bx mov cx,DGROUP mov es,cx mov di,OFFSET DGROUP:PartitionList ; es:di = &PartitionList
.errnz PartInfoNext mov cx,es:[di] ; get current head of list in bx:cx mov bx,es:[di+2]
mov es:[di],ax mov es:[di+2],dx ; insert new record at head of list
mov es,dx mov di,ax ; es:di -> new record mov es:[di].PartInfoNextl,cx mov es:[di].PartInfoNexth,bx
mov ax,DiskId mov es:[di].PartInfoDiskId,ax pop ax ; partition ordinal, also return val mov es:[di].PartInfoOrdinal,ax mov cx,[si+8] mov es:[di].PartInfoStartSectorl,cx mov cx,[si+10] mov es:[di].PartInfoStartSectorh,cx mov cx,[si+12] mov es:[di].PartInfoSectorCountl,cx mov cx,[si+14] mov es:[di].PartInfoSectorCounth,cx mov cl,[si+4] mov es:[di].PartInfoSystemId,cl
; ; Indicate partition not open ; mov es:[di].PartInfoPartOpen,0 mov es:[di].PartInfoDiskHandlel,0 mov es:[di].PartInfoDiskHandleh,0
npr_done: ret
pNewPartitionRecord endp
;; No params, nested in top-level routines above;pGetDiskValues proc near
; ; Get disk info. This also makes sure the handle is open. ; push ss lea bx,DiskId push bx push ss lea bx,ExtSecCnt push bx push ss lea bx,Cylinders push bx push ss lea bx,Heads push bx push ss lea bx,SectorsPerTrack push bx push ss lea bx,Int13UnitNumber push bx push DiskHandle call _GetDiskInfoByHandle add sp,28 cmp ax,0 jnz @f stc ret
; ; Calculate the number of sectors we can address on the disk. ; Also precalculate the number of sectors in a cylinder. ;@@: mov al,SectorsPerTrack cbw mul Heads ; ax = sectors per cylinder, dx = 0 mov SectorsPerCylinder,ax cmp ExtSecCntl,dx jnz usexcnt cmp ExtSecCnth,dx jnz usexcnt mul Cylinders ; dx:ax = sectors on disk jmp short storsizeusexcnt: mov dx,ExtSecCnth mov ax,ExtSecCntlstorsize: mov DiskSizeh,dx mov DiskSizel,ax clcgv3: ret
pGetDiskValues endp
;; No params, nested in top-level routines above; al = xint13 required flag; dx = partition class; ah = sysid if unknown class;; returns system id in al;pDetermineSystemId proc near
cmp dx,PARTCLASS_FAT jne tryfat32 cmp al,0 je @f mov al,0eh ; type e = fat xint13 jmp short gotsysid@@: cmp MinimumSectorCounth,0 jne bigfat cmp MinimumSectorCountl,32680 jb fat12 mov al,4 ; type 4 = fat16 jmp short gotsysidfat12: mov al,1 ; type 1 = fat12 jmp short gotsysidbigfat: mov al,6 ; type 6 = huge fat jmp short gotsysid
tryfat32: cmp dx,PARTCLASS_FAT32 jne tryntfs cmp al,0 jne @f mov al,0bh ; type b = fat32 non-xint13 jmp short gotsysid@@: mov al,0ch ; type c = fat32 xint13 jmp short gotsysid
tryntfs: cmp dx,PARTCLASS_NTFS jne othersys mov al,7 ; type 7 = ntfs jmp short gotsysid
othersys: mov al,ah
gotsysid: ret
pDetermineSystemId endp
end
|
