kolibrios/kernel/trunk/bootloader/extended_primary_loader/after_win/fat.inc

; 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.
;*****************************************************************************

; in: ss:bp = 0:dat
; in: es:bx = address to load file
; in: ds:si -> ASCIIZ name
; in: cx = limit in sectors
; out: bx = status: bx=0 - ok, bx=1 - file is too big, only part of file has been loaded, bx=2 - file not found
; out: dx:ax = file size (0xFFFFFFFF if file not found)
load_file_fat:
        mov     eax, [bp + root_clus - dat]
        mov     [bp + cur_obj - dat], root_string
        push    es
        push    bx
        push    cx
.parse_dir_loop:
; convert name to FAT name
        push    [bp + cur_obj - dat]
        push    ax
        mov     [bp + cur_obj - dat], si
        push    ss
        pop     es
; convert ASCIIZ filename to FAT name
        mov     di, fat_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:
        mov     si, badname_msg
        jmp     find_error_si
.namedone:
; scan directory
        pop     ax      ; eax = cluster of directory
                        ; high word of eax is preserved by operations above
        push    ds
        push    si
; read a folder sector-by-sector and scan
; first, try to use the cache
        push    ss
        pop     ds
        mov     bx, -2
        mov     cx, [bp + rootcache_size - dat]
        cmp     [bp + root_clus - dat], eax
        jz      .lookcache_root
        mov     di, foldcache_mark
        xor     bx, bx
        mov     cx, [bp + cachelimit - dat]
@@:
        lea     si, [di+bx]
        mov     edx, dword [foldcache_clus+si-foldcache_mark+bx]
        cmp     edx, eax
        jz      .cacheok
        test    edx, edx
        jz      .cacheadd       ; the cache has place for new entry
        inc     bx
        inc     bx
        dec     cx
        js      @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     bx, -2
        mov     dx, [bp + cachelimit - dat]
@@:
        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
        and     [foldcache_size+di-foldcache_mark+bx], 0        ; no folder items yet
        lea     si, [di+bx]
        mov     dword [foldcache_clus+si-foldcache_mark+bx], eax
.cacheok:
; update cache marks
        mov     dx, [di+bx]
        mov     cx, [foldcache_size+di-foldcache_mark+bx]
        mov     di, [bp + cachelimit - dat]
        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
.lookcache_root:
; bx = (position in cache)*2 for non-root folders; bx = -2 for root folder
        ;mov    dx, bx
        ;shl    dx, 8
        ;add    dx, 0x9200
        lea     dx, [bx + 0x92]
        xchg    dl, dh
        mov     ds, dx
        mov     si, fat_filename        ; ss:si -> filename in FAT style
        call    fat_scan_for_filename
        jz      .lookup_done
; cache miss, read folder data from disk
; we are reading parent directory, it can result in disk read errors; restore [cur_obj]
        mov     di, sp
        mov     bx, [bp + cur_obj - dat]
        xchg    bx, [ss:di+4]
        mov     [bp + cur_obj - dat], bx
        mov     bx, cx
        add     bx, 0xF
        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
        movzx   ecx, byte [ss:0x320D]   ; BPB_SecPerClus
        push    eax
; FAT12/16 root - special handling
        test    eax, eax
        jnz     .folder_notroot
        mov     cx, [ss:0x3211]         ; BPB_RootEntCnt
        mov     dx, cx
        add     cx, 0xF
        rcr     cx, 1
        shr     cx, 3
        mov     eax, [bp + root_start - dat]
        jmp     .folder_next_sector
.folder_notroot:
        mul     ecx
        add     eax, [bp + data_start - dat]
.folder_next_sector:
        sub     dx, 0x10
; 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
        jc      ..found_disk_error
; copy data to the cache...
        pop     ds
        pop     di es
        cmp     di, 0x2000      ; ...if there is free space, of course
        jae     @f
        pusha
        mov     cx, 0x100
        xor     si, si
        rep movsw
        mov     di, es
        shr     di, 8
        cmp     di, 0x90
        jz      .update_rootcache_size
        add     [ss:foldcache_size+di-0x92], 0x10       ; 0x10 new entries in the cache
        jmp     .updated_cachesize
.update_rootcache_size:
        mov     cl, 0x10
        cmp     cx, dx
        jb      @f
        mov     cx, dx
@@:
        add     [bp + rootcache_size - dat], cx
.updated_cachesize:
        popa
@@:
        push    es
        mov     cl, 0x10        ; ch=0 at this point
        cmp     cx, dx
        jb      @f
        mov     cx, dx
@@:
        call    fat_scan_for_filename
        pop     es
        pop     cx
        jz      .lookup_done_pop
.folder_skip_sector:
        inc     eax
        loop    .folder_next_sector
        pop     eax     ; eax = current cluster
        test    eax, eax
        jz      @f
        call    [bp + get_next_cluster_ptr - dat]
        jc      .folder_next_cluster
@@:
        stc
        push    eax
.lookup_done_pop:
        pop     eax
.lookup_done:
        pop     si
; CF=1 <=> failed
        jnc     .found
        pop     ds
        pop     [bp + cur_obj - dat]
        mov     si, error_not_found
        jmp     find_error_si
.found:
        mov     eax, [di+20-2]
        mov     edx, [di+28]
        mov     ax, [di+26]     ; get cluster
        test    byte [di+11], 10h       ; directory?
        pop     ds
        pop     [bp + cur_obj - dat]    ; forget old [cur_obj]
        jz      .regular_file
        cmp     byte [si-1], 0
        jnz     .parse_dir_loop
..directory_error:
        mov     si, directory_string
        jmp     find_error_si
.regular_file:
        cmp     byte [si-1], 0
        jz      @f
..notdir_error:
        mov     si, notdir_string
        jmp     find_error_si
@@:
; ok, we have found a regular file and the caller requested it
; parse FAT chunk
        push    ss
        pop     es
        push    ss
        pop     ds
        mov     di, 0x4005
        mov     byte [di-5], 1  ; non-resident attribute
        mov     dword [di-4], 1
        stosd
        pop     cx
        push    cx
.parsefat:
        call    [bp + get_next_cluster_ptr - dat]
        jnc     .done
        mov     esi, [di-8]
        add     esi, [di-4]
        cmp     eax, esi
        jz      .contc
        mov     dword [di], 1
        scasd
        stosd
        jmp     @f
.contc:
        inc     dword [di-8]
@@:
        sub     cl, [0x320D]
        sbb     ch, 0
        ja      .parsefat
.done:
        xor     eax, eax
        stosd
        mov     si, 0x4000
load_file_common_end:
        xor     ecx, ecx
        pop     cx
        pop     bx
        pop     es
        mov     [bp + filesize - dat], edx
        mov     [bp + sectors_read - dat], ecx
        add     edx, 0x1FF
        shr     edx, 9
        mov     [bp + filesize_sectors - dat], edx
        cmp     edx, ecx
        seta    al
        mov     ah, 0
        push    ax
        call    read_file_chunk
continue_load_common_end:
        mov     [bp + cur_chunk_ptr - dat], si
        pop     bx
        mov     ax, word [bp + filesize - dat]
        mov     dx, word [bp + filesize+2 - dat]
        jnc     @f
        mov     bl, 3   ; read error
@@:
        ret

continue_load_file:
; es:bx -> buffer for output, ecx = cx = number of sectors
        mov     si, [bp + cur_chunk_ptr - dat]
        push    ecx
        add     ecx, [bp + sectors_read - dat]
        mov     [bp + sectors_read - dat], ecx
        cmp     [bp + filesize_sectors - dat], ecx
        pop     ecx
        seta    al
        mov     ah, 0
        push    ax
        push    continue_load_common_end
        push    ss
        pop     ds
        cmp     [bp + cur_chunk_resident - dat], ah
        jnz     .nonresident
.resident:
        mov     ax, word [bp + num_sectors - dat]
        jmp     read_file_chunk.resident.continue
.nonresident:
        mov     eax, [bp + cur_cluster - dat]
        mov     edx, [bp + num_sectors - dat]
        add     eax, [bp + cur_delta - dat]
        jmp     read_file_chunk.nonresident.continue

fat_scan_for_filename:
; in: ss:si -> 11-bytes FAT name
; in: ds:0 -> part of directory data
; in: cx = number of entries
; out: if found: CF=0, ZF=1, es:di -> directory entry
; out: if not found, but continue required: CF=1 and ZF=0
; out: if not found and zero item reached: CF=1 and ZF=1
        push    ds
        pop     es
        xor     di, di
        push    cx
        jcxz    .noent
.loop:
        cmp     byte [di], 0
        jz      .notfound
        test    byte [di+11], 8         ; volume label?
        jnz     .cont                   ; ignore volume labels
        pusha
        mov     cx, 11
        repz cmps byte [ss:si], byte [es:di]
        popa
        jz      .done
.cont:
        add     di, 0x20
        loop    .loop
.noent:
        inc     cx      ; clear ZF flag
.notfound:
        stc
.done:
        pop     cx
        ret

fat12_get_next_cluster:
; in: ax = cluster (high word of eax is zero)
; out: if there is next cluster: CF=1, ax = next cluster
; out: if there is no next cluster: CF=0
        push    si
        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

fat16_get_next_cluster:
; in: ax = cluster (high word of eax is zero)
; out: if there is next cluster: CF=1, ax = next cluster
; out: if there is no next cluster: CF=0
; each sector contains 200h bytes = 100h FAT entries
; so ah = # of sector, al = offset in sector
        push    si
        mov     si, ax
        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:0x3400+si], 0  ; sector already loaded?
        jnz     .noread
; load corresponding sector, try all FATs if disk read error detected
        pusha
        movzx   di, byte [ss:0x3210]    ; BPB_NumFATs
        xor     bx, bx
        mov     ax, [ss:0x320E]         ; BPB_RsvdSecCnt
        xor     dx, dx
        add     ax, si
        adc     dx, bx
@@:
        push    es
        push    dx ax
        pop     eax
        mov     cx, 1   ; read 1 sector
        call    read
        pop     es
        jnc     @f
        add     ax, [ss:0x3216]         ; BPB_FATSz16
        adc     dx, bx
        dec     di
        jnz     @b
..found_disk_error:
        mov     si, disk_error_msg
        jmp     find_error_si
@@:
        popa
.noread:
        mov     si, ax
        and     si, 0xFF
        add     si, si
        mov     ax, [es:si]
        pop     es
        cmp     ax, 0xFFF7
        pop     si
        ret

fat32_get_next_cluster:
; in: eax = cluster
; out: if there is next cluster: CF=1, eax = next cluster
; out: if there is no next cluster: CF=0
        push    di
        push    ax
        shr     eax, 7
; eax = FAT sector number; look in cache
        push    si
        mov     si, cache1head
        call    cache_lookup
        pop     si
        jnc     .noread
; read FAT, try all FATs if disk read error detected
        push    es
        pushad
        movzx   edx, word [ss:0x320E]   ; BPB_RsvdSecCnt
        add     eax, edx
        movzx   si, byte [ss:0x3210]    ; BPB_NumFATs
@@:
        lea     cx, [di - 0x3400 + (0x6000 shr (9-3))]
        shl     cx, 9-3
        mov     es, cx
        xor     bx, bx
        mov     cx, 1
        call    read
        jnc     @f
        add     eax, [ss:0x3224]        ; BPB_FATSz32
        dec     si
        jnz     @b
        jmp     ..found_disk_error
@@:
        popad
        pop     es
.noread:
; get requested item
        lea     ax, [di - 0x3400 + (0x6000 shr (9-3))]
        pop     di
        and     di, 0x7F
        shl     di, 2
        shl     ax, 9-3
        push    ds
        mov     ds, ax
        and     byte [di+3], 0x0F
        mov     eax, [di]
        pop     ds
        pop     di
        ;and    eax, 0x0FFFFFFF
        cmp     eax, 0x0FFFFFF7
        ret