; KolibriOS bootloader
; this code has been written by diamond in 2005,2006 specially for KolibriOS
format binary
use16
org 0xD000
; may be changed from ldklbr.vxd
partition_start dd -1
boot_drive db 80h
imgnameofs dw menuet_img_name - 0xD000
macro out_delay port
{
out port, al
jcxz $+2
}
cli
; reprogram IRQs
mov al, 11h
out_delay 20h
out_delay 0A0h
mov al, 8
out_delay 21h
mov al, 70h
out_delay 0A1h
mov al, 4
out_delay 21h
mov al, 2
out_delay 0A1h
mov al, 1
out_delay 21h
out_delay 0A1h
mov al, 0
out_delay 21h
out_delay 0A1h
; set videomode
mov ax, 3
int 10h
; reprogram timer
mov al, 00110100b
out_delay 43h
mov al, 0FFh
out_delay 40h
out_delay 40h
; reset mouse
mov ax, 0C201h
int 15h
jmp start
out_string:
lodsb
test al, al
jz .xxx
mov ah, 0Eh
mov bx, 7
int 10h
jmp out_string
.xxx: ret
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
noindex_string db '$INDEX_ROOT not found',0
invalid_read_request_string db 'cannot read attribute',0
nodata_string db '$DATA '
notfound_string db 'not found',0
directory_string db 'is a directory',0
notdir_string db 'not a directory',0
fragmented_string db 'too fragmented file',0
exmem_string db 'extended memory error',0
bad_cluster_string db 'bad cluster',0
data_error_msg db 'data error',0
start:
xor ax, ax
mov ds, ax
mov es, ax
; our stack is 4Kb-2b!!! (0xFFE)
mov ss, ax
mov esp, 0FFFEh
cld
sti
; calculate drive size
mov dl, [boot_drive]
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
mov eax, [partition_start]
cmp eax, -1
jnz @f
; 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
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
mov [data_start], eax
; parse image name
add [imgnameofs], 0xD000
mov eax, [52Ch] ; root_cluster
mov [cur_obj], root_string
.parsedir:
push ax
mov si, [imgnameofs]
push si
@@:
lodsb
cmp al, '\'
jz @f
cmp al, 0
jnz @b
@@:
xchg ax, [esp+2]
mov byte [si-1], 0
mov [imgnameofs], si
call fat32_parse_dir
pop cx
test cl, cl
jz .end
test byte [di+0Bh], 10h
mov si, notdir_string
jz find_error_si
jmp .parsedir
.end:
test byte [di+0Bh], 10h
mov si, directory_string
jnz find_error_si
; 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
scasd
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
; parse image name
add [imgnameofs], 0xD000
mov eax, 5 ; root cluster
mov [cur_obj], root_string
.parsedir:
push ax
mov si, [imgnameofs]
push si
@@:
lodsb
cmp al, '\'
jz @f
cmp al, 0
jnz @b
@@:
xchg ax, [esp+2]
mov byte [si-1], 0
mov [imgnameofs], si
call ntfs_parse_dir
pop cx
test cl, cl
jnz .parsedir
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
test ah, ah
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 ax, 'KL'
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
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
; uninitialized data follows
drive_size dd ? ; in sectors
heads dw ?
sectors dw ?
cyls dw ?
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 ?
; will be initialized by ldklbr.vxd
menuet_img_name rb 300