| 0,0 → 1,852 |
|---|
| ; KolibriOS bootloader |
| ; this code has been written by diamond in 2005,2006,2008 specially for KolibriOS |
| |
| ; this code is loaded by ntldr to 0D00:0000 |
| ; and by io.sys from config.sys to xxxx:0100 |
| ; and by bootmgr in vista to 0000:7C00 |
| format binary |
| use16 |
| |
| org 0xD000 |
| ; entry point for 9x and Vista booting |
| call @f |
| ; db 'd' xor 'i' xor 'a' xor 'm' xor 'o' xor 'n' xor 'd' |
| db 'NTFS' |
| @@: |
| pop si |
| sub si, 3 |
| cmp si, 7C00h |
| jz boot_vista |
| 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 si, 100h |
| boot_vista: |
| 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 dx |
| 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',13,10,0 |
| part_msg db 'looking at partition ' |
| part_char db '0' ; will be incremented before writing message |
| db ' ... ',0 |
| errfs_msg db 'unknown filesystem',13,10,0 |
| fat16_msg db 'FAT12/FAT16 - unsupported',13,10,0 |
| fat32_msg db 'FAT32' |
| newline db 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 |
| |
| ; 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-512b-2b!!! (0xDFE) |
| mov ss, ax |
| mov esp, 0FFFEh |
| |
| ; we are booting from hard disk identified by [boot_drive] |
| mov dl, [boot_drive] |
| 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 |
| new_partition_ex: |
| mov cx, 1 |
| mov bx, 0F000h |
| call read |
| new_partition: |
| mov bx, [cur_partition_ofs] |
| mov al, [bx+4] ; partition type |
| test al, al |
| jz next_partition |
| cmp al, 5 |
| jz @f |
| cmp al, 0xF |
| jnz not_extended |
| @@: |
| ; extended partition |
| mov eax, [bx+8] ; partition start |
| add eax, [extended_part_start] |
| mov [extended_part_cur], eax |
| next_partition: |
| add [cur_partition_ofs], 10h |
| cmp [cur_partition_ofs], 0xF1FE |
| jb new_partition |
| mov eax, [extended_part_cur] |
| test eax, eax |
| jz partitions_done |
| cmp [extended_part_start], 0 |
| jnz @f |
| mov [extended_part_start], eax |
| @@: |
| mov [extended_parent], eax |
| and [extended_part_cur], 0 |
| mov [cur_partition_ofs], 0xF1BE |
| jmp new_partition_ex |
| partitions_done: |
| mov si, total_kaput |
| call out_string |
| jmp $ |
| not_extended: |
| mov eax, [bx+8] |
| add eax, [extended_parent] |
| mov [partition_start], eax |
| push ax |
| mov si, part_msg |
| inc [si+part_char-part_msg] |
| call out_string |
| pop ax |
| 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 |
| call out_string |
| jmp next_partition |
| fat1x: |
| mov si, fat16_msg |
| call out_string |
| jmp next_partition |
| 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 |
| mov eax, [52Ch] ; root_cluster |
| mov [cur_obj], root_string |
| .parsedir: |
| push ax |
| mov si, [imgnameofs] |
| push si |
| @@: |
| lodsb |
| cmp al, 0 |
| jz @f |
| cmp al, '\' |
| jnz @b |
| dec si |
| mov [missing_slash], si |
| inc si |
| @@: |
| xchg ax, [esp+2] |
| mov byte [si-1], 0 |
| mov [imgnameofs], si |
| call fat32_parse_dir |
| call restore_slash |
| 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 kolibri.img |
| ; parse image name |
| mov eax, 5 ; root cluster |
| mov [cur_obj], root_string |
| .parsedir: |
| push ax |
| mov si, [imgnameofs] |
| push si |
| @@: |
| lodsb |
| cmp al, 0 |
| jz @f |
| cmp al, '\' |
| jnz @b |
| dec si |
| mov [missing_slash], si |
| inc si |
| @@: |
| xchg ax, [esp+2] |
| mov byte [si-1], 0 |
| mov [imgnameofs], si |
| call ntfs_parse_dir |
| call restore_slash |
| 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: |
| ; kolibri.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 kolibri.img |
| push ax |
| dec ax |
| dec ax |
| movzx cx, byte [50Dh] |
| mul cx |
| add ax, [img_data_start] |
| ; now ax is sector in kolibri.img |
| mov [kernel_mnt_in_img], ax |
| div [sect_per_clust] |
| ; now ax is cluster in kolibri.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 |
| mov si, newline |
| call out_string |
| or [fat_cur_sector], -1 |
| mov [imgnameofs], kolibri_img_name |
| call restore_slash |
| mov sp, 0xFFFE |
| jmp next_partition |
| |
| file_not_found: |
| mov si, [esp+2] |
| mov [cur_obj], si |
| push notfound_string |
| jmp find_error_sp |
| |
| restore_slash: |
| mov si, [missing_slash] |
| test si, si |
| jz @f |
| and [missing_slash], 0 |
| mov byte [si], '\' |
| @@: ret |
| |
| 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 |
| imgnameofs dw kolibri_img_name |
| |
| ; ----------------------------------------------- |
| ; ------------------ Settings ------------------- |
| ; ----------------------------------------------- |
| |
| ; must be in lowercase, see ntfs_parse_dir.scan, fat32_parse_dir.scan |
| kernel_mnt_name db 'kernel.mnt',0 |
| kolibri_img_name db 'kolibri.img',0 |
| |
| ; change next variable if you want to boot from other physical drive |
| boot_drive db 80h |
| |
| total_kaput db 13,10,'Fatal: image is not found.',13,10,0 |
| missing_slash dw 0 |
| align 2 |
| |
| cur_partition_ofs dw 0xF1BE |
| extended_part_start dd 0 |
| extended_part_cur dd 0 |
| extended_parent dd 0 |
| |
| ; uninitialized data follows |
| drive_size dd ? ; in sectors |
| 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 |