OSDev.org

Code: Select all

; KolibriOS bootloader
; this code has been written by diamond in 2005 specially for KolibriOS

; this code is loaded by ntldr to 0D00:0000
; and by io.sys from config.sys to xxxx:0100
	format	binary
	use16

	org	0xD000
; entry point for 9x booting
	jmp	@f
	db	'd' xor 'i' xor 'a' xor 'm' xor 'o' xor 'n' xor 'd'
	db	'NTFS'
@@:
	mov	si, load_question + 100h - 0D000h
	call	out_string
;	mov	si, answer + 100h - 0D000h	; already is
xxy:	mov	ah, 0
	int	16h
	or	al, 20h
	mov	[si], al
	cmp	al, 'y'
	jz	xxz
	cmp	al, 'n'
	jnz	xxy
; continue load Windows
;       call    out_string
;       ret
out_string:
	lodsb
	test	al, al
	jz	.xxx
	mov	ah, 0Eh
	mov	bx, 7
	int	10h
	jmp	out_string
.xxx:	ret
xxz:
; boot KolibriOS
	call	out_string
	push	0
	pop	ds
	mov	word [4], new01handler + 100h - 0D000h
	mov	[6], cs
	pushf
	pop	ax
	or	ah, 1
	push	ax
	popf
;	int	19h
;	pushf		; there will be no iret
	call	far [19h*4]
xxt:
; TF has been cleared when entered new01handler
;	pushf
;	pop	ax
;	and	ah, not 1
;	push	ax
;	popf
	xor	di, di
	mov	ds, di
	cmp	word [8*4+2], 0F000h
	jz	@f
	les	bx, [8*4]
	mov	eax, [es:bx+1]
	mov	[8*4], eax
@@:
	mov	eax, [8*4]
	mov	[20h*4], eax
	mov	si, 100h
	push	cs
	pop	ds
	push	0D00h
	pop	es
	mov	cx, 2000h/2
	rep	movsw
	jmp	0D00h:0256h
load_question	db	'Load KolibriOS? [y/n]: ',0
answer	db	?
	db	13,10,0

new01handler:
; [sp]=ip, [sp+2]=cs, [sp+4]=flags
	push	bp
	mov	bp, sp
	push	bx
	push	ds
	lds	bx, [bp+2]
	cmp	word [bx], 19cdh
	jz	xxt
	pop	ds
	pop	bx
	pop	bp
	iret

relative_read:
	add	eax, [partition_start]

; read from hard disk
; drive_size must be already initialized
; in: eax = absolute sector
;     cx = number of sectors
;     es:bx -> buffer
read:
	pushad
	cmp	eax, [drive_size]
	jb	.old_style
; new style - LBA, function 42
	cmp	[has_lba], 0
	jz	disk_error
; allocate disk address packet on the stack
; qword +8: absolute block number
	push	dword 0 	; dword +C is high dword
	push	eax		; dword +8 is low dword
; dword +4: buffer address
	push	es		; word +6 is segment
	push	bx		; word +4 is offset
; word +2: number of blocks = 1
; word +0: size of packet = 10h
	push	dword 10010h
; now pair ss:sp contain address of disk address packet
.patch1:
	mov	ax, 4200h
	mov	dl, [boot_drive]
	mov	si, sp
	push	ds
	push	ss
	pop	ds
	int	13h
	pop	ds
	add	sp, 10h
.end:
	popad
	jc	disk_error
	add	bx, 200h
	inc	eax
	dec	cx
	jnz	read
	ret
.old_style:
; old style - CHS, function 2
; convert absolute sector in eax to cylinder-head-sector coordinates
; calculate sector
	xor	edx, edx
	movzx	ecx, [sectors]
	div	ecx
; sectors are counted from 1
	inc	dl
	mov	cl, dl		; low 6 bits of cl = sector number
; calculate head number
	shld	edx, eax, 10h	; convert eax to dx:ax
	div	[heads]
	mov	dh, dl		; dh = head
	mov	ch, al		; ch = low 8 bits of cylinder
	shl	ah, 6
	or	cl, ah		; high 2 bits of cl = high 2 bits of cylinder
.patch2:
	mov	ax, 201h	; function 2, al=1 - number of sectors
	mov	dl, [boot_drive]
	int	13h
	jmp	.end

disk_error:
	mov	si, disk_error_msg
	call	out_string
	jmp	$

has_lba db	0

disk_error_msg	db	'Disk read error!',0
start_msg	db	2,' KolibriOS bootloader, running on ',0
errfs_msg	db	'unknown filesystem, cannot continue',0
fat16_msg	db	'FAT12/FAT16 - unsupported',13,10,0
fat32_msg	db	'FAT32',13,10,0
ntfs_msg	db	'NTFS',13,10,0
error_msg	db	'Error'
colon		db	': ',0
mft_string	db	'MFT',0
root_string	db	'\',0
nodata_string	db	'$DATA not found',0
noindex_string	db	'$INDEX_ROOT not found',0
invalid_read_request_string db 'cannot read attribute',0
notfound_string db	'not found',0
directory_string db	'is a directory',0
fragmented_string db	'too fragmented file',0
exmem_string	db	'extended memory error',0
bad_cluster_string db	'bad cluster',0

; init procedure - ntldr jmps here
	repeat	0D256h - $
		db	1
	end	repeat
start:
; cs=es=0D00, ds=07C0, ss=0
; esi=edi=ebp=0, esp=7C00
	xor	ax, ax
	mov	ds, ax
	mov	es, ax
; our stack is 4Kb-2b!!! (0xFFE)
	mov	ss, ax
	mov	esp, 0FFFEh

; we are booting from first hard disk
	mov	dl, 80h
	mov	[boot_drive], dl
	cld
	sti
; calculate drive size
	mov	ah, 8	; 8 = get drive parameters
	int	13h
; now: CF is set on error;
; ch = low 8 bits of maximum cylinder number
; cl : low 6 bits makes maximum sector number, high 2 bits are high 2 bits of maximum cylinder number
; dh = maximum head number
	jnc	@f
	mov	cx, -1
	mov	dh, cl
@@:
	movzx	ax, dh
	inc	ax
; ax = number of heads
	mov	[heads], ax
	mov	dl, cl
	and	dx, 3Fh
; dx = number of sectors
; (note that sectors are counted from 1, and maximum sector number = number of sectors)
	mov	[sectors], dx
	mul	dx
	xchg	cl, ch
	shr	ch, 6
	inc	cx
; cx = number of cylinders
	mov	[cyls], cx
	mul	cx
	mov	word [drive_size], ax
	mov	word [drive_size+2], dx
; this drive supports LBA?
	mov	dl, [boot_drive]
	mov	ah, 41h
	mov	bx, 55AAh
	int	13h
	jc	.no_lba
	cmp	bx, 0AA55h
	jnz	.no_lba
	test	cl, 1
	jz	.no_lba
	inc	[has_lba]
.no_lba:
; say hi to user
	mov	si, start_msg
	call	out_string
; now read first sector to determine file system type
; first sector of disk is MBR sector
	xor	eax, eax
	mov	cx, 1
	mov	bx, 500h
	call	read
	mov	eax, [6C6h]	; first disk
	mov	[partition_start], eax
	mov	cx, 1
	mov	bx, 500h
	call	read
	movzx	ax, byte [50Dh]
	mov	[sect_per_clust], ax
; determine file system
	cmp	dword [536h], 'FAT1'
	jz	fat1x
	cmp	dword [552h], 'FAT3'
	jz	fat32
	cmp	dword [503h], 'NTFS'
	jz	ntfs
;       mov     si, errfs_msg           ; already is
	call	out_string
	jmp	$
fat1x:
	mov	si, fat16_msg
	call	out_string
	jmp	$
fat32:
	mov	si, fat32_msg
	call	out_string
	movzx	eax, word [50Bh]	; bytes_per_sect
	movzx	ebx, byte [50Dh]	; sects_per_clust
	mul	ebx
	mov	[cluster_size], eax
	movzx	ebx, word [50Eh]	; reserved_sect
	add	ebx, [51Ch]		; hidden
	mov	[fat_start], ebx
	movzx	eax, byte [510h]	; num_fats
	mul	dword [524h]		; sect_fat
	add	eax, ebx
; cluster 2 begins from sector eax
	movzx	ebx, byte [50Dh]	; sects_per_clust
	sub	eax, ebx
	sub	eax, ebx
	sub	eax, [51Ch]	; we will use relative_read
	mov	[data_start], eax
	mov	eax, [52Ch]		; root_cluster
	push	menuet_img_name
	mov	[cur_obj], root_string
	call	fat32_parse_dir
; parse FAT chunk
; runlist at 2000:0000
	mov	di, 5
	push	2000h
	pop	es
	mov	byte [es:di-5], 1	; of course, non-resident
	mov	dword [es:di-4], 1
	stosd
.parsefat:
	push	es
	push	ds
	pop	es
	call	next_cluster
	pop	es
	jnc	.done
	mov	ecx, [es:di-8]
	add	ecx, [es:di-4]
	cmp	eax, ecx
	jz	.contc
	mov	dword [es:di], 1
	add	di, 4
	stosd
	jmp	.parsefat
.contc:
	inc	dword [es:di-8]
	jmp	.parsefat
.done:
	xor	eax, eax
	stosd
	jmp	read_img_file

ntfs:
	mov	si, ntfs_msg
	call	out_string
	movzx	eax, word [50Bh]	; bpb_bytes_per_sect
	push	eax
	movzx	ebx, byte [50Dh]	; bpb_sects_per_clust
	mul	ebx
	mov	[cluster_size], eax
	mov	[data_start], 0
	mov	ecx, [540h]		; frs_size
	cmp	cl, 0
	jg	.1
	neg	cl
	xor	eax, eax
	inc	eax
	shl	eax, cl
	jmp	.2
.1:
	mul	ecx
.2:
	mov	[frs_size], eax
	pop	ebx
	xor	edx, edx
	div	ebx
	mov	[frs_sectors], ax
; read first MFT record - description of MFT itself
	mov	[cur_obj], mft_string
	movzx	eax, byte [50Dh]	; bpb_sects_per_clust
	mul	dword [530h]		; mft_cluster
	mov	cx, [frs_sectors]
	mov	bx, 4000h
	mov	di, bx
	push	bx
	call	relative_read
	call	restore_usa
; scan for unnamed $DATA attribute
	pop	di
	mov	ax, 80h		; $DATA
	mov	bx, 700h
	call	load_attr
	mov	si, nodata_string
	jc	find_error_si
	mov	[free], bx
; load menuet.img
; find entry
	mov	eax, 5
	push	menuet_img_name
	mov	[cur_obj], root_string
	call	ntfs_parse_dir
read_img_file:
	xor	si, si
	push	es
	pop	fs
; yes! Now read file to 0x100000
	lods byte [fs:si]
	cmp	al, 0	; assume nonresident attr
	mov	si, invalid_read_request_string
	jz	find_error_si
	mov	si, 1
	xor	edi, edi
; read buffer to 1000:0000 and move it to extended memory
	push	1000h
	pop	es
	xor	bx, bx
.img_read_block:
	lods dword [fs:si]		; eax=length
	xchg	eax, ecx
	jecxz	.img_read_done
	lods dword [fs:si]		; eax=disk cluster
.img_read_cluster:
	pushad
; read part of file
	movzx	ecx, byte [50Dh]
	mul	ecx
	add	eax, [data_start]
	call	relative_read
; move it to extended memory
	mov	ah, 87h
	mov	ecx, [cluster_size]
	push	ecx
	shr	cx, 1
	mov	si, movedesc
	push	es
	push	ds
	pop	es
	int	15h
	pop	es
	cmp	ah, 0
	mov	si, exmem_string
	jnz	find_error_si
	pop	ecx
	add	[dest_addr], ecx
	popad
	inc	eax
	loop	.img_read_cluster
	jmp	.img_read_block
.img_read_done:
; menuet.img loaded; now load kernel.mnt
load_kernel:
	push	ds
	pop	es
	mov	[cur_obj], kernel_mnt_name
; read boot sector
	xor	eax, eax
	mov	bx, 500h
	mov	cx, 1
	call	read_img
; init vars
	mov	ax, [50Eh]	; reserved_sect
	add	ax, [51Ch]	; hidden
	mov	word [fat_start], ax
	xchg	ax, bx
	movzx	ax, byte [510h]		; num_fats
	mul	word [516h]		; fat_length
	add	ax, bx
; read root dir
	mov	bx, 700h
	mov	cx, [511h]	; dir_entries
	add	cx, 0Fh
	shr	cx, 4
	call	read_img
	add	ax, cx
	mov	[img_data_start], ax
	shl	cx, 9
	mov	di, bx
	add	bx, cx
	mov	byte [bx], 0
.scan_loop:
	cmp	byte [di], 0
	mov	si, notfound_string
	jz	find_error_si
	mov	si, kernel_mnt_name
	call	fat_compare_name
	jz	.found
	and	di, not 1Fh
	add	di, 20h
	jmp	.scan_loop
.found:
	and	di, not 1Fh
	mov	si, directory_string
	test	byte [di+0Bh], 10h
	jnz	find_error_si
; found, now load it to 1000h:0000h
	mov	ax, [di+1Ah]
; first cluster of kernel.mnt in ax
; translate it to sector on disk in menuet.img
	push	ax
	dec	ax
	dec	ax
	movzx	cx, byte [50Dh]
	mul	cx
	add	ax, [img_data_start]
; now ax is sector in menuet.img
	mov	[kernel_mnt_in_img], ax
	div	[sect_per_clust]
; now ax is cluster in menuet.img and
; dx is offset from the beginning of cluster
	movzx	eax, ax
	push	2000h
	pop	ds
	mov	si, 1
.scani:
	sub	eax, [si]
	jb	.scanidone
; sanity check
	cmp	dword [si], 0
	push	invalid_read_request_string
	jz	find_error_sp
	pop	cx
; next chunk
	add	si, 8
	jmp	.scani
.scanidone:
	add	eax, [si]	; undo last subtract
	add	eax, [si+4]	; get cluster
	push	0
	pop	ds
	movzx	ecx, [sect_per_clust]
	push	dx
	mul	ecx		; get sector
	pop	dx
	movzx	edx, dx
	add	eax, edx
	add	eax, [data_start]
	mov	[kernel_mnt_1st], eax
	pop	ax
	push	1000h
	pop	es
.read_loop:
	push	ax
	xor	bx, bx
	call	img_read_cluster
	shl	cx, 9-4
	mov	ax, es
	add	ax, cx
	mov	es, ax
	pop	ax
	call	img_next_cluster
	jc	.read_loop
	mov	eax, 'KLBR'
	mov	si, loader_block
	jmp	1000h:0000h

img_next_cluster:
	mov	bx, 700h
	push	ax
	shr	ax, 1
	add	ax, [esp]
	mov	dx, ax
	shr	ax, 9
	add	ax, word [fat_start]
	mov	cx, 2
	push	es
	push	ds
	pop	es
	call	read_img
	pop	es
	and	dx, 1FFh
	add	bx, dx
	mov	ax, [bx]
	pop	cx
	test	cx, 1
	jz	.1
	shr	ax, 4
.1:
	and	ax, 0FFFh
	mov	si, bad_cluster_string
	cmp	ax, 0FF7h
	jz	find_error_si
	ret
img_read_cluster:
	dec	ax
	dec	ax
	movzx	cx, byte [50Dh]	; sects_per_clust
	mul	cx
	add	ax, [img_data_start]
	movzx	eax, ax
;	call	read_img
;	ret
read_img:
; in: ax = sector, es:bx->buffer, cx=length in sectors
	pushad
	movzx	ebx, bx
	mov	si, movedesc
	shl	eax, 9
	add	eax, 93100000h
	mov	dword [si+sou_addr-movedesc], eax
	mov	eax, 9300000h
	mov	ax, es
	shl	eax, 4
	add	eax, ebx
	mov	[si+dest_addr-movedesc], eax
	mov	ah, 87h
	shl	cx, 8	; mul 200h/2
	push	es
	push	0
	pop	es
	int	15h
	pop	es
	cmp	ah, 0
	mov	si, exmem_string
	jnz	find_error_si
	popad
	ret

movedesc:
	times 16 db 0
; source
	dw	0xFFFF		; segment length
sou_addr dw	0000h		; linear address
	db	1		; linear address
	db	93h		; access rights
	dw	0
; destination
	dw	0xFFFF		; segment length
dest_addr dd	93100000h	; high byte contains access rights
				; three low bytes contains linear address (updated when reading)
	dw	0
	times 32 db 0

find_error_si:
	push	si
find_error_sp:
	mov	si, error_msg
	call	out_string
	mov	si, [cur_obj]
	call	out_string
	mov	si, colon
	call	out_string
	pop	si
	call	out_string
	jmp	$

file_not_found:
	mov	si, [esp+2]
	mov	[cur_obj], si
	push	notfound_string
	jmp	find_error_sp

	include 'fat32.inc'
	include	'ntfs.inc'

write1st:
; callback from kernel.mnt
; write first sector of kernel.mnt from 1000:0000 back to disk
	push	cs
	pop	ds
	push	cs
	pop	es
; sanity check
	mov	bx, 500h
	mov	si, bx
	mov	cx, 1
	push	cx
	mov	eax, [kernel_mnt_1st]
	push	eax
	call	relative_read
	push	1000h
	pop	es
	xor	di, di
	mov	cx, 8
	repz	cmpsw
	mov	si, data_error_msg
	jnz	find_error_si
; ok, now write back to disk
	or	byte [read.patch1+2], 1
	or	byte [read.patch2+2], 1
	xor	bx, bx
	pop	eax
	pop	cx
	call	relative_read
	and	byte [read.patch1+1], not 1
	and	byte [read.patch2+2], not 2
; and to image in memory (probably this may be done by kernel.mnt itself?)
	mov	dword [sou_addr], 93010000h
	movzx	eax, [kernel_mnt_in_img]
	shl	eax, 9
	add	eax, 93100000h
	mov	dword [dest_addr], eax
	mov	si, movedesc
	push	ds
	pop	es
	mov	ah, 87h
	mov	cx, 100h
	int	15h
	cmp	ah, 0
	mov	si, exmem_string
	jnz	find_error_si
	retf
data_error_msg db 'data error',0

loader_block:
	db	1	; version
	dw	1	; flags - image is loaded
	dw	write1st	; offset
	dw	0		; segment

fat_cur_sector dd -1

; -----------------------------------------------
; ------------------ Settings -------------------
; -----------------------------------------------

; must be in lowercase, see ntfs_parse_dir.scan, fat32_parse_dir.scan
kernel_mnt_name 	db	'kernel.mnt',0
menuet_img_name 	db	'menuet.img',0

; uninitialized data follows
drive_size		dd	?	; in sectors
boot_drive		db	?
heads			dw	?
sectors 		dw	?
cyls			dw	?
partition_start 	dd	?
free			dw	?
cur_obj 		dw	?
data_start		dd	?
img_data_start		dw	?
sect_per_clust		dw	?
kernel_mnt_in_img	dw	?
kernel_mnt_1st		dd	?
; NTFS data
cluster_size		dd	?	; in bytes
frs_size		dd	?	; in bytes
frs_sectors		dw	?	; in sectors
mft_data_attr		dw	?
index_root		dw	?
index_alloc		dw	?
ofs			dw	?
dir			dw	?
; FAT32 data
fat_start		dd	?
cur_cluster		dd	?
; file must be 16 sectors long

	repeat	0F000h - $
		db	2
	end	repeat

Code: Select all

restore_usa:
; Update Sequence Array restore
	mov	bx, [di+4]
	mov	cx, [di+6]
	inc	bx
	add	bx, di
	inc	bx
	add	di, 1feh
	dec	cx
@@:
	mov	ax, [bx]
	stosw
	inc	bx
	inc	bx
	add	di, 1feh
	loop	@b
	ret

find_attr:
; in: di->file record, ax=attribute
; out: di->attribute or di=0 if not found
	add	di, [di+14h]
.1:
; attributes codes are formally dwords, but all they fit in word
	cmp	word [di], -1
	jz	.notfound
	cmp	word [di], ax
	jnz	.continue
; for $DATA attribute, scan only unnamed
	cmp	ax, 80h
	jnz	.found
	cmp	byte [di+9], 0
	jz	.found
.continue:
	add	di, [di+4]
	jmp	.1
.notfound:
	xor	di, di
.found:
	ret

process_mcb_nonres:
; in: si->attribute, es:di->buffer
; out: di->buffer end
	add	si, [si+20h]
	xor	ebx, ebx
.loop:
	lodsb
	test	al, al
	jz	.done
	push	invalid_read_request_string
	movzx	cx, al
	shr	cx, 4
	jz	find_error_sp
	xchg	ax, dx
	and	dx, 0Fh
	jz	find_error_sp
	add	si, cx
	add	si, dx
	pop	ax
	push	si
	dec	si
	movsx	eax, byte [si]
	dec	cx
	jz	.l1e
.l1:
	dec	si
	shl	eax, 8
	mov	al, [si]
	loop	.l1
.l1e:
	xchg	ebp, eax
	dec	si
	movsx	eax, byte [si]
	mov	cx, dx
	dec	cx
	jz	.l2e
.l2:
	dec	si
	shl	eax, 8
	mov	al, byte [si]
	loop	.l2
.l2e:
	pop	si
	add	ebx, ebp
; eax=length, ebx=disk block
	stosd
	mov	eax, ebx
	stosd
	jmp	.loop
.done:
	xor	eax, eax
	stosd
	ret

load_attr:
; in: ax=attribute, es:bx->buffer, di->base record
; out: bx->buffer end; CF set if not found
	push	di
	push	ax
	mov	byte [es:bx], 1
	inc	bx
	push	bx
	mov	[ofs], bx
; scan for attrubute
	add	di, [di+14h]
@@:
	call	find_attr.1
	test	di, di
	jz	.notfound1
	cmp	byte [di+8], 0
	jnz	.nonresident
; resident attribute
	mov	si, di
	pop	di
	dec	di
	mov	al, 0
	stosb
	mov	ax, [si+10h]
	stosw
	xchg	ax, cx
	add	si, [si+14h]
	rep	movsb
	mov	bx, di
	pop	ax
	pop	di
	ret
.nonresident:
; nonresident attribute
	cmp	dword [di+10h], 0
	jnz	@b
; read start of data
	mov	si, di
	pop	di
	call	process_mcb_nonres
	push	di
.notfound1:
; $ATTRIBUTE_LIST is always in base file record
	cmp	word [esp+2], 20h
	jz	.nofragmented
; scan for $ATTRIBUTE_LIST = 20h
	mov	di, [esp+4]
	mov	ax, 20h
	call	find_attr
	test	di, di
	jz	.nofragmented
; load $ATTRIBUTE_LIST itself
	push	es
	mov	bx, 0C000h
	mov	di, [esp+4]
	push	bx
	push	[ofs]
	push	ds
	pop	es
	call	load_attr
	pop	[ofs]
	pop	si
	mov	bx, 8000h
	push	bx
	push	si
	call	read_attr_full
	pop	si
	pop	bx
	add	dx, bx
	mov	ax, [esp+2]
	pop	es
.1:
	cmp	[bx], ax
	jnz	.continue1
; only unnamed $DATA attributes!
	cmp	ax, 80h
	jnz	@f
	cmp	byte [bx+6], 0
	jnz	.continue1
@@:
	cmp	dword [bx+10h], 0
	jz	.continue1
	cmp	dword [bx+8], 0
	jnz	@f
	push	ax
	mov	ax, [esp+2]
	cmp	ax, [ofs]
	pop	ax
	jnz	.continue1
@@:
	pushad
	mov	eax, [bx+10h]
	mov	bx, dx
	push	[ofs]
	push	es
	push	ds
	pop	es
	call	read_file_record
	pop	es
	pop	[ofs]
	popad
	pushad
	mov	di, dx
	add	di, [di+14h]
.2:
	call	find_attr.1
	mov	eax, [bx+8]
	cmp	eax, [di+10h]
	jnz	.2
	mov	si, di
	mov	di, [esp+20h]
	sub	di, 4
	call	process_mcb_nonres
	mov	[esp+20h], di
	popad
.continue1:
	add	bx, [bx+4]
	cmp	bx, dx
	jb	.1
.nofragmented:
	pop	bx
	pop	ax
	pop	di
	cmp	bx, [ofs]
	jnz	@f
	dec	bx
	stc
@@:
	ret

read_attr_full:
; in: si->decoded attribute data, bx->buffer
; out: edx=length in bytes
	lodsb
	cmp	al, 0
	jnz	.nonresident
; resident
	lodsw
	movzx	edx, ax
	xchg	ax, cx
	mov	di, bx
	rep	movsb
	ret
.nonresident:
; nonresident :-)
	xor	edx, edx
.loop:
	lodsd
	xchg	ecx, eax
	jecxz	.loopend
	lodsd
	xchg	edi, eax
; read ecx clusters from cluster edi to es:bx
.intloop:
	push	ecx
; read 1 cluster from physical cluster edi to es:bx
	mov	ecx, [cluster_size]
	mov	eax, edi
	mul	ecx
	push	bx
	call	relative_read
	pop	bx
	pop	ecx
	inc	edi
	mov	eax, [cluster_size]
	add	edx, eax
	shr	eax, 4
	mov	bp, es
	add	bp, ax
	mov	es, bp
	loop	.intloop
	jmp	.loop
.loopend:
	mov	es, cx
	ret

read_file_record:
; in: eax=index of record, bx=buffer
	mov	si, 700h
	mov	ecx, [frs_size]
	mul	ecx
	push	bx
	push	[cur_obj]
	mov	[cur_obj], mft_string
	call	read_attr
	pop	[cur_obj]
	pop	di
	call	restore_usa
	ret
read_attr:
; in: edx:eax=offset in bytes, ecx=size in bytes, bx=buffer, si=attribute
	push	invalid_read_request_string
	cmp	byte [si], 0
	jnz	.nonresident
	test	edx, edx
	jnz	find_error_sp
	cmp	eax, 10000h
	jae	find_error_sp
	cmp	ecx, 10000h
	jae	find_error_sp
	cmp	ax, [si+2]
	jae	find_error_sp
	cmp	cx, [si+2]
	ja	find_error_sp
	add	si, 3
	add	si, ax
	mov	di, bx
	rep	movsb
	pop	ax
	ret
.nonresident:
	mov	edi, [cluster_size]
	div	edi
	mov	[ofs], dx
	add	cx, dx
	push	eax
	xchg	eax, ecx
	xor	edx, edx
	dec	eax
	div	edi
	inc	eax
	xchg	eax, ecx
	pop	eax
	add	si, 1
	xor	edx, edx
	push	bx
; eax=offset in clusters, ecx=size in clusters
.scan:
	mov	ebx, [si]
	test	ebx, ebx
	jz	.notfound
	add	edx, ebx
	add	si, 8
	cmp	eax, edx
	jae	.scan
	mov	edi, [si-4]
; now edx=end of block, ebx=length of block, edi=start of block on disk
; eax=required offset, ecx=required length
	push	edx
	push	edi
	sub	edx, eax
	add	edi, ebx
	sub	edi, edx
	cmp	edx, ecx
	jb	@f
	mov	edx, ecx
@@:
; read (edx) clusters from (edi=disk offset in clusters) to ([esp+8])
	cmp	[ofs], 0
	jnz	.ofs_read
.cont:
	pushad
	movzx	ebx, byte [50Dh]
;       xchg    eax, edx
;       mul     ebx
	xchg	ax, dx
	mul	bx
	xchg	cx, ax
	xchg	eax, edi
	mul	ebx
	mov	bx, [esp+8+20h]
	call	relative_read
	mov	[esp+8+20h], bx
	popad
.cont2:
	add	eax, edx
	sub	ecx, edx
.cont3:
	pop	edi
	pop	edx
	jnz	.scan
	pop	bx
	pop	ax
	ret
.ofs_read:
	push	ecx
	movzx	ecx, byte [50Dh]	; bpb_sects_per_clust
	mov	eax, edi
	push	edx
	mul	ecx
	push	1000h
	pop	es
	xor	bx, bx
	call	relative_read
	mov	cx, bx
	push	si
	push	di
	mov	si, [ofs]
	mov	di, [esp+8+12]
	sub	cx, si
	push	ds
	push	es
	pop	ds
	pop	es
	rep	movsb
	mov	[esp+8+12], di
	push	es
	pop	ds
	pop	di
	pop	si
	pop	edx
	pop	ecx
	inc	edi
	mov	[ofs], 0
	inc	eax
	dec	ecx
	jz	.cont3
	dec	edx
	jnz	.cont
	jmp	.cont2
.notfound:
	mov	si, invalid_read_request_string
	jmp	find_error_si

ntfs_parse_dir:
; in: eax=directory iRecord, [word sp+2]=filename
; out: si=$DATA attribute of file
	mov	bx, [free]
	mov	[dir], bx
	push	bx
	call	read_file_record
	mov	ax, word [frs_size]
	add	[free], ax
	pop	di
; find attributes $INDEX_ROOT, $INDEX_ALLOCATION, $BITMAP
	mov	ax, 90h 	; $INDEX_ROOT
	push	di
	mov	bx, [free]
	mov	[index_root], bx
	call	load_attr
	mov	si, noindex_string
	jc	find_error_si
	mov	[free], bx
	pop	di
	mov	ax, 0A0h	; $INDEX_ALLOCATION
	mov	bx, [free]
	mov	[index_alloc], bx
	call	load_attr
	jnc	@f
	mov	[index_alloc], 0
@@:
	mov	[free], bx
; search for entry
	mov	si, [index_root]
	mov	bx, [free]
	call	read_attr_full
	mov	ebp, [bx+8]	; subnode_size
	add	bx, 10h
.scan_record:
	add	bx, [bx]
.scan:
	test	byte [bx+0Ch], 2
	jnz	.not_found
	mov	si, [esp+2]
	movzx	cx, byte [bx+50h]	; namelen
	lea	di, [bx+52h]		; name
	xor	ax, ax
@@:
	lodsb
	cmp	al, 'a'
	jb	.notletter
	cmp	al, 'z'
	ja	.notletter
	or	byte [di], 20h
.notletter:
	scasw
	loopz	@b
	jz	.file_found
	jb	.not_found
	add	bx, [bx+8]
	jmp	.scan
.not_found:
	test	byte [bx+0Ch], 1
	jz	file_not_found
	cmp	[index_alloc], 0
	jz	file_not_found
	add	bx, [bx+8]
	mov	eax, [bx-8]
	mul	[cluster_size]
	mov	si, [index_alloc]
	mov	ecx, ebp
	mov	bx, [free]
	call	read_attr
	mov	di, [free]
	call	restore_usa
	mov	bx, [free]
	add	bx, 18h
	jmp	.scan_record
.file_found:
	mov	si, [esp+2]
	mov	[cur_obj], si
	mov	si, directory_string
	test	byte [bx+48h+3], 10h	; directory?
	jnz	find_error_si
; read entry
	mov	eax, [bx]
	mov	bx, [dir]
	mov	[free], bx
	mov	bx, 4000h
	push	bx
	call	read_file_record
	pop	di
	mov	ax, 80h
	push	2000h
	pop	es
	xor	bx, bx
	call	load_attr
	mov	si, nodata_string
	jz	find_error_si
	mov	[free], bx
	ret	2

Code: Select all

fat32_parse_dir:
; in: eax=directory cluster
; out: eax=entry cluster
	mov	bx, 900h
	mov	di, bx
	push	eax
	call	read_cluster
	mov	cx, word [cluster_size]
	shr	cx, 5		; div 20h
.scan_cluster:
	pop	eax
	cmp	byte [di], 0
	jz	file_not_found
	mov	si, [esp+2]
	push	eax
	call	fat_compare_name
	jz	.file_found
	and	di, not 1Fh
	add	di, 20h
	loop	.scan_cluster
	pop	eax
	call	next_cluster
	jnc	file_not_found
	jc	fat32_parse_dir
.file_found:
	pop	eax
	mov	si, [esp+2]
	mov	[cur_obj], si
	and	di, not 1Fh
	mov	si, directory_string
	test	byte [di+0Bh], 10h
	jnz	find_error_si
	mov	ax, [di+14h]
	shl	eax, 10h
	mov	ax, [di+1Ah]
	test	eax, eax
	mov	si, nodata_string
	jz	find_error_si
	ret	2

fat_compare_name:
	push	cx
	mov	cx, 9
.scan:
	lodsb
	cmp	al, '.'
	jz	.ext
	cmp	al, 0
	jz	.nameend
	cmp	al, 'a'
	jb	.notletter
	cmp	al, 'z'
	ja	.notletter
	or	byte [di], 20h
.notletter:
	scasb
	loopz	.scan
.notfound:
	inc	cx	; to clear ZF flag
	pop	cx
	ret
.ext:
	mov	al, ' '
	dec	cx
	repz	scasb
	jnz	.notfound
	test	di, 1
	jnz	.notfound
	mov	cx, 4
	jmp	.scan
.nameend:
	mov	al, ' '
	dec	cx
	repz	scasb
	jnz	.notfound
	test	di, 1
	jnz	.file_found
	mov	cx, 3
	repz	scasb
	jnz	.notfound
.file_found:
	xor	cx, cx	; to set ZF flag
	pop	cx
	ret

read_cluster:
; in: eax=cluster,bx->buffer
	and	eax, 0FFFFFFFh
	movzx	ecx, byte [50Dh]	; sects_per_clust
	mul	ecx
	add	eax, [data_start]
;	call	read
;	ret
	jmp	relative_read
next_cluster:
	mov	bx, 700h
; sector is 200h bytes long, one entry in FAT occupies 4 bytes => 80h entries in sector
	push	eax
	shr	eax, 7		; div 80h
	cmp	eax, [fat_cur_sector]
	jz	@f
	mov	[fat_cur_sector], eax
	add	eax, [fat_start]
	mov	cx, 1
	call	read
@@:
	pop	eax
	and	eax, 7Fh
	mov	eax, [700h+eax*4]
	and	eax, 0FFFFFFFh
	cmp	eax, 0FFFFFF7h
	mov	si, bad_cluster_string
	jz	find_error_si
	ret