kordldr.f1x.asm
kolibrios-nextgen_kolibrios-kernel/kernel/sec_loader/trunk/boot/fat1x/kordldr.f1x.asm
; Copyright (c) 2008-2009, diamond
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;       * Redistributions of source code must retain the above copyright
;       notice, this list of conditions and the following disclaimer.
;       * Redistributions in binary form must reproduce the above copyright
;       notice, this list of conditions and the following disclaimer in the
;       documentation and/or other materials provided with the distribution.
;       * Neither the name of the <organization> nor the
;       names of its contributors may be used to endorse or promote products
;       derived from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY Alexey Teplov aka <Lrz> ''AS IS'' AND ANY
; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
; DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;*****************************************************************************

        org     0x7E00
; the KordOS FAT12/FAT16 bootsector loads first cluster of this file to 0:7E00 and transfers control to here
; ss:bp = 0:7C00
virtual at bp
                rb      3               ; BS_jmpBoot
                rb      8               ; BS_OEMName, ignored
                dw      ?               ; BPB_BytsPerSec
BPB_SecsPerClus db      ?
BPB_RsvdSecCnt  dw      ?
BPB_NumFATs     db      ?
BPB_RootEntCnt  dw      ?
BPB_TotSec16    dw      ?
                db      ?               ; BPB_Media
BPB_FATSz16     dw      ?
BPB_SecPerTrk   dw      ?
BPB_NumHeads    dw      ?
BPB_HiddSec     dd      ?
BPB_TotSec32    dd      ?
BS_DrvNum       db      ?
fat_type        db      ?               ; this is BS_Reserved1,
                                ; we use it to save FS type: 0=FAT12, 1=FAT16
                db      ?               ; BS_BootSig
num_sectors     dd      ?               ; BS_VolID
;               rb      11              ; BS_VolLab
;               rb      3               ; BS_FilSysType, first 3 bytes
read_sectors    dw      ?
read_sectors2   dw      ?
lookup_in_root_dir dw   ?
scan_for_filename dw    ?
err_             dw      ?
noloader        dw      ?
cachelimit      dw      ?
filesize:       ; will be used to save file size
                rb      5               ; BS_FilSysType, last 5 bytes
; following variables are located in the place of starting code;
; starting code is no more used at this point
sect_per_clus   dw      ?
cur_cluster     dw      ?
next_cluster    dw      ?
flags           dw      ?
cur_delta       dd      ?
end virtual

; procedures from boot sector
; LBA version
lba_read_sectors = 7CE2h
lba_read_sectors2 = 7CDCh
lba_lookup_in_root_dir = 7D4Fh
lba_scan_for_filename = 7D2Dh
lba_err = 7CB5h
lba_noloader = 7CB2h
; CHS version
chs_read_sectors = 7CDEh
chs_read_sectors2 = 7CD8h
chs_lookup_in_root_dir = 7D70h
chs_scan_for_filename = 7D4Eh
chs_err = 7CB1h
chs_noloader = 7CAEh

        push    ax cx           ; save our position on disk
        push    ss
        pop     es
; determine version of bootsector (LBA vs CHS)
;       mov     [read_sectors], chs_read_sectors
;       mov     [read_sectors2], chs_read_sectors2
;       mov     [lookup_in_root_dir], chs_lookup_in_root_dir
;       mov     [scan_for_filename], chs_scan_for_filename
;       mov     [err], chs_err
;       mov     [noloader], chs_noloader
        lea     di, [read_sectors]
        mov     si, chs_proc_addresses
        mov     cx, 6*2
        cmp     word [chs_scan_for_filename], 0xFF31    ; 'xor di,di'
        jz      @f
        add     si, cx
;       mov     [read_sectors], lba_read_sectors
;       mov     [read_sectors2], lba_read_sectors2
;       mov     [lookup_in_root_dir], lba_lookup_in_root_dir
;       mov     [scan_for_filename], lba_scan_for_filename
;       mov     [err], lba_err
;       mov     [noloader], lba_noloader
@@:
        rep movsb
        mov     cl, [BPB_SecsPerClus]
        mov     [sect_per_clus], cx
        xor     bx, bx
; determine size of cache for folders
        int     12h             ; ax = size of available base memory in Kb
        sub     ax, 94000h / 1024
        jae     @f
nomem:
        mov     si, nomem_str
        jmp     [err_]
@@:
        shr     ax, 3
        mov     [cachelimit], ax        ; size of cache - 1
; get type of file system - FAT12 or FAT16?
; calculate number of clusters
        mov     ax, [BPB_TotSec16]
        xor     dx, dx
        test    ax, ax
        jnz     @f
        mov     ax, word [BPB_TotSec32]
        mov     dx, word [BPB_TotSec32+2]
@@:
        sub     ax, [bp-8]      ; dword [bp-8] = first data sector
        sbb     dx, [bp-6]
        jb      j_noloader
        div     [sect_per_clus]
; ax = number of clusters
; note: this is loader for FAT12/FAT16, so 'div' does not overflow on correct volumes
        mov     [fat_type], ch
        cmp     ax, 0xFF5
        jb      init_fat12
        inc     [fat_type]
init_fat16:
; no sectors loaded
        mov     di, 0x8200
        xor     ax, ax
        mov     cx, 0x100/2
        rep stosw
        jmp     init_fat_done
init_fat12:
; read FAT
        push    0x6000
        pop     es
        mov     ax, [BPB_RsvdSecCnt]
        mov     cx, [BPB_FATSz16]
        cmp     cx, 12
        jb      @f
        mov     cx, 12
@@:
        xor     dx, dx
        call    [read_sectors]
init_fat_done:
; if cluster = sector, we need to read second part of our file
; (bootsector loads only first cluster of kordldr.f1x)
        pop     cx ax           ; restore our position on disk
        cmp     cx, 1
        ja      kordldr_full
        sub     ax, [bp-8]
        inc     ax
        inc     ax              ; ax = first cluster of kordldr.f12
        call    get_next_cluster
        jc      @f
j_noloader:
        jmp     [noloader]
@@:
        dec     ax
        dec     ax
        push    0x800
        pop     es
        call    [read_sectors2]
kordldr_full:
; ...continue loading...
        mov     di, secondary_loader_info
        call    load_file
        test    bx, bx
        mov     bx, [err_]
        jz      @f
        mov     si, aKernelNotFound
        jmp     bx
@@:
; for subsequent calls to callback function, hook error handler
;       mov     byte [bx], 0xE9         ; 'jmp' opcode
;       mov     ax, hooked_err - 3
;       sub     ax, bx
;       mov     word [bx+1], ax
; push hooked_err / ret
        mov     word [bx], 0x68 + ((hooked_err and 0xFF) shl 8)
        mov     word [bx+2], (hooked_err shr 8) + (0xC3 shl 8)
; set registers for secondary loader
        mov     ah, [BS_DrvNum]
        mov     al, 'f'
        test    ah, ah
        jns     @f
        sub     ah, 80h
        mov     al, 'h'
@@:
        mov     bx, '12'
        cmp     [fat_type], 0
        jz      @f
        mov     bh, '6'
@@:
        mov     si, callback    ; ds:si = far pointer to callback procedure
        jmp     far [si-callback+secondary_loader_info] ; jump to 1000:0000

nomem_str       db      'No memory',0

chs_proc_addresses:
        dw      chs_read_sectors
        dw      chs_read_sectors2
        dw      chs_lookup_in_root_dir
        dw      chs_scan_for_filename
        dw      chs_err
        dw      chs_noloader
lba_proc_addresses:
        dw      lba_read_sectors
        dw      lba_read_sectors2
        dw      lba_lookup_in_root_dir
        dw      lba_scan_for_filename
        dw      lba_err
        dw      lba_noloader

get_next_cluster:
; in: ax = cluster
; out: if there is next cluster: CF=1, ax = next cluster
; out: if there is no next cluster: CF=0
        push    si
        cmp     [fat_type], 0
        jnz     gnc16
; for FAT12
        push    ds
        push    0x6000
        pop     ds
        mov     si, ax
        shr     si, 1
        add     si, ax
        test    al, 1
        lodsw
        jz      @f
        shr     ax, 4
@@:
        and     ax, 0xFFF
        cmp     ax, 0xFF7
        pop     ds si
        ret
; for FAT16
gnc16:
; each sector contains 200h bytes = 100h FAT entries
; so ah = # of sector, al = offset in sector
        mov     si, ax
        mov     ah, 0
        shr     si, 8
; calculate segment for this sector of FAT table
; base for FAT table is 6000:0000, so the sector #si has to be loaded to (60000 + 200*si)
; segment = 6000 + 20*si, offset = 0
        push    es
        push    si
        shl     si, 5
        add     si, 0x6000
        mov     es, si
        pop     si
        cmp     byte [ss:0x8200+si], ah ; sector already loaded?
        jnz     @f
; load corresponding sector
        pusha
        push    es
        xor     bx, bx
        mov     ax, [BPB_RsvdSecCnt]
        xor     dx, dx
        add     ax, si
        adc     dx, bx
        mov     cx, 1   ; read 1 sector
        call    [read_sectors]
        pop     es
        popa
@@:
        mov     si, ax
        add     si, si
;       mov     ax, [es:si]
        lods    word [es:si]
        pop     es
        cmp     ax, 0xFFF7
        pop     si
        ret

if $ > 0x8000
error 'get_next_cluster must fit in first sector of kordldr.f1x!'
end if

load_file:
; in: ss:bp = 0:7C00
; in: ds:di -> information structure
;       dw:dw   address
;       dw      limit in 4Kb blocks (0x1000 bytes) (must be non-zero and not greater than 0x100)
;       ASCIIZ  name
; out: bx = status: bx=0 - ok, bx=1 - file is too big, only part of file was loaded, bx=2 - file not found
; out: dx:ax = file size (0xFFFFFFFF if file not found)
        xor     ax, ax  ; start from root directory
        mov     dx, -1
        mov     word [filesize], dx
        mov     word [filesize+2], dx   ; initialize file size with invalid value
        lea     si, [di+6]
parse_dir_loop:
; convert name to FAT name
        push    di
        push    ax
        push    ss
        pop     es
; convert ASCIIZ filename to FAT name
        mov     di, filename
        push    di
        mov     cx, 8+3
        mov     al, ' '
        rep stosb
        pop     di
        mov     cl, 8   ; 8 symbols per name
        mov     bl, 1
nameloop:
        lodsb
        test    al, al
        jz      namedone
        cmp     al, '/'
        jz      namedone
        cmp     al, '.'
        jz      namedot
        dec     cx
        js      badname
        cmp     al, 'a'
        jb      @f
        cmp     al, 'z'
        ja      @f
        sub     al, 'a'-'A'
@@:
        stosb
        jmp     nameloop
namedot:
        inc     bx
        jp      badname
        add     di, cx
        mov     cl, 3
        jmp     nameloop
badname:        ; do not make direct js/jp to notfound_pop:
                ; this generates long forms of conditional jumps and results in longer code
        jmp     notfound_pop
namedone:
; scan directory
        pop     ax      ; ax = cluster of directory or 0 for root
        push    ds
        push    si
        push    es
        pop     ds
        mov     si, filename    ; ds:si -> filename in FAT style
        test    ax, ax
        jnz     lookup_in_notroot_dir
; for root directory, use the subroutine from bootsector
        call    [lookup_in_root_dir]
        jmp     lookup_done
lookup_in_notroot_dir:
; for other directories, read a folder sector-by-sector and scan
; first, try to use the cache
        push    ds
        push    cs
        pop     ds
        mov     bx, [cachelimit]
        add     bx, bx
        mov     di, foldcache_mark
@@:
        mov     dx, [foldcache_clus+di-foldcache_mark+bx]
        cmp     dx, ax
        jz      cacheok
        test    dx, dx
        jz      cacheadd        ; the cache has place for new entry
        dec     bx
        dec     bx
        jns     @b
; the folder is not present in the cache, so add it
; the cache is full; find the oldest entry and replace it with the new one
        mov     dx, [cachelimit]
@@:
        inc     bx
        inc     bx
        cmp     word [di+bx], dx        ; marks have values 0 through [cachelimit]
        jnz     @b
cacheadd:
        or      word [di+bx], 0xFFFF    ; very big value, it will be changed soon
        mov     [foldcache_clus+di-foldcache_mark+bx], ax
        and     [foldcache_size+di-foldcache_mark+bx], 0        ; no folder items yet
cacheok:
; update cache marks
        mov     dx, [di+bx]
        mov     cx, [foldcache_size+di-foldcache_mark+bx]
        mov     di, [cachelimit]
        add     di, di
cacheupdate:
        cmp     [foldcache_mark+di], dx
        adc     [foldcache_mark+di], 0
        dec     di
        dec     di
        jns     cacheupdate
        and     [foldcache_mark+bx], 0
; done, bx contains (position in cache)*2
        pop     ds
;       mov     dx, bx
;       shl     dx, 8           ; dx = (position in cache)*0x2000/0x10
;       add     dx, 0x9200
        lea     dx, [bx+0x92]
        xchg    dl, dh
        mov     es, dx
        jcxz    not_in_cache
        call    [scan_for_filename]
        jz      lookup_done
not_in_cache:
; cache miss, read folder data from disk
        mov     bx, cx
        shr     bx, 4
        shl     cx, 5
        mov     di, cx          ; es:di -> free space in cache entry
; external loop: scan clusters
folder_next_cluster:
; internal loop: scan sectors in cluster
        mov     cx, [sect_per_clus]
        push    ax
        dec     ax
        dec     ax
        mul     cx
        add     ax, [bp-8]
        adc     dx, [bp-6]      ; dx:ax = absolute sector
folder_next_sector:
; skip first bx sectors
        dec     bx
        jns     folder_skip_sector
        push    cx
        push    es di
        push    0x8000
        pop     es
        xor     bx, bx
        mov     cx, 1
        push    es
        call    [read_sectors]
; copy data to the cache...
        pop     ds
        pop     di es
        cmp     di, 0x2000      ; ...if there is free space, of course
        jae     @f
        push    si di
        mov     cx, 0x100
        xor     si, si
        rep movsw
        mov     di, es
        shr     di, 8
        add     [ss:foldcache_size+di-0x92], 0x10       ; 0x10 new entries in the cache
        pop     di si
@@:
        push    es
        push    0x8000
        pop     es
        push    cs
        pop     ds
        mov     cx, 0x10
        call    [scan_for_filename]
        pop     es
        pop     cx
        jz      lookup_done_pop
folder_skip_sector:
        inc     ax
        jnz     @f
        inc     dx
@@:
        loop    folder_next_sector
        pop     ax      ; ax = current cluster
        call    get_next_cluster
        jc      folder_next_cluster
        stc
        push    ax
lookup_done_pop:
        pop     ax
lookup_done:
        pop     si
        pop     ds
; CF=1 <=> failed
        jnc     found
notfound:
        pop     di
        mov     bx, 2   ; file not found
        mov     ax, 0xFFFF
        mov     dx, ax  ; invalid file size
        ret
notfound_pop:
        pop     ax
        jmp     notfound
found:
        mov     ax, [es:di+26]  ; get cluster
        test    byte [es:di+11], 10h    ; directory?
        jz      regular_file
        cmp     byte [si-1], 0
        jz      notfound        ; don't read directories as a regular files
; ok, we have found a directory and the caller requested a file into it
        pop     di
        jmp     parse_dir_loop  ; restart with new cluster in ax
regular_file:
        cmp     byte [si-1], 0
        jnz     notfound        ; file does not contain another files
; ok, we have found a regular file and the caller requested it
; save file size
        mov     dx, [es:di+28]
        mov     [filesize], dx
        mov     dx, [es:di+30]
        mov     [filesize+2], dx
        pop     di
        mov     si, [di+4]
        shl     si, 3
        push    si              ; [ds:di+4] = limit in 4K blocks
        les     bx, [di]        ; es:bx -> buffer
clusloop:
; ax = first cluster, top of stack contains limit in sectors
        mov     si, ax  ; remember current cluster
        xor     cx, cx  ; cx will contain number of consecutive clusters
        mov     word [cur_delta], cx
        mov     word [cur_delta+2], cx
        mov     di, ax
clusfind:
        inc     di
        inc     cx
        call    get_next_cluster
        jnc     clusread
        cmp     ax, di
        jz      clusfind
        stc
clusread:
        pop     di      ; limit in sectors
        push    ax      ; save next cluster
        pushf           ; save flags
; read cx clusters, starting from si
; calculate number of sectors
        xchg    ax, cx
        mul     [sect_per_clus]
; dx:ax = number of sectors; compare with limit
        mov     word [num_sectors], ax
        mov     word [num_sectors+2], dx
        jmp     @f
continue_load_file:
        les     bx, [di]        ; es:bx -> buffer
        mov     di, [di+4]      ; ds:di = limit in 4K blocks
        shl     di, 3   ; now di = limit in sectors
        mov     ax, word [num_sectors]
        mov     dx, word [num_sectors+2]
        mov     si, [cur_cluster]
        push    [next_cluster]
        push    [flags]
        or      ax, dx
        jz      nextclus
@@:
        test    dx, dx
        jnz     clusdecrease
        push    dx      ; limit was not exceeded
        cmp     ax, di
        jbe     @f
        pop     ax
clusdecrease:
        push    1       ; limit was exceeded
        mov     ax, di
@@:
        sub     di, ax  ; calculate new limit
        sub     word [num_sectors], ax
        sbb     word [num_sectors+2], 0
; calculate starting sector
        xchg    ax, cx
        lea     ax, [si-2]
        mul     [sect_per_clus]
        add     ax, word [cur_delta]
        adc     dx, word [cur_delta+2]
        add     word [cur_delta], cx
        adc     word [cur_delta+2], 0
; read
        call    [read_sectors2]
        pop     dx
; next cluster?
nextclus:
        popf
        pop     ax
        mov     [cur_cluster], si
        mov     [next_cluster], ax
        pushf
        pop     [flags]
        jnc     @f      ; no next cluster => return
        mov     dl, 1   ; dh=0 in any case
        test    di, di
        jz      @f      ; if there is next cluster but current limit is 0 => return: limit exceeded
        push    di
        jmp     clusloop        ; all is ok, continue
hooked_err:
        mov     sp, 7C00h-12-2  ; restore stack
        mov     dx, 3           ; return: read error
@@:
        mov     bx, dx
        mov     ax, [filesize]
        mov     dx, [filesize+2]
        ret

; Callback function for secondary loader
callback:
; in: ax = function number; only functions 1 and 2 are defined for now
; save caller's stack
        mov     dx, ss
        mov     cx, sp
; set our stack (required because we need ss=0)
        xor     si, si
        mov     ss, si
        mov     sp, 7C00h-8
        mov     bp, 7C00h
        push    dx
        push    cx
; call our function
        stc     ; unsupported function
        dec     ax
        jz      callback_readfile
        dec     ax
        jnz     callback_ret
; function 2: continue loading file
; can be called only after function 1 returned value bx=1 (only part of file was loaded)
; in: ds:di -> information structure
;       dw:dw   address
;       dw      limit in 4Kb blocks (0x1000 bytes) (must be non-zero and not greater than 0x100)
; out: bx=0 - ok, bx=1 - still only part of file was loaded, bx=3 - read error
; out: dx:ax = file size
        call    continue_load_file
        jmp     callback_ret_succ
callback_readfile:
; function 1: read file
; in: ds:di -> information structure
;       dw:dw   address
;       dw      limit in 4Kb blocks (0x1000 bytes) (must be non-zero and not greater than 0x100)
;       ASCIIZ  name
; out: bx=0 - ok, bx=1 - file is too big, only part of file was loaded, bx=2 - file not found, bx=3 - read error
; out: dx:ax = file size (0xFFFFFFFF if file was not found)
        call    load_file
callback_ret_succ:
        clc     ; function is supported
callback_ret:
; restore caller's stack
        pop     cx
        pop     ss
        mov     sp, cx
; return to caller
        retf

secondary_loader_info:
        dw      0, 0x1000
        dw      0x30000 / 0x1000
        db      'kord/loader',0
aKernelNotFound db      'Fatal error: cannot load the secondary loader',0

foldcache_clus  dw      0,0,0,0,0,0,0   ; start with no folders in cache
foldcache_mark  rw      7
foldcache_size  rw      7
filename        rb      11
if $ > 0x8200
error:
       table overwritten
end if
