WebSVN – Kolibri OS – Diff – /kernel/trunk/bootloader/extended_primary_loader/cdfs/bootsect.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  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  ''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  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.
;*****************************************************************************
 
        jmp     far 0:real_start
; special text
org $+0x7C00
real_start:
; initialize
        xor     ax, ax
        mov     ss, ax
        mov     sp, 0x7C00
        mov     ds, ax
        mov     es, ax
        cld
        sti
        mov     [bootdrive], dl
; check LBA support
        mov     ah, 41h
        mov     bx, 55AAh
        int     13h
        mov     si, aNoLBA
        jc      err_
        cmp     bx, 0AA55h
        jnz     err_
        test    cl, 1
        jz      err_
; get file system information
; scan for Primary Volume Descriptor
        db      66h
        movi    eax, 10h-1
 
pvd_scan_loop:
        mov     cx, 1
        inc     eax
        mov     bx, 0x1000
        call    read_sectors
        jnc     @f
fatal_read_err:
        mov     si, aReadError
err_:
        call    out_string
        mov     si, aPressAnyKey
        call    out_string
        xor     ax, ax
        int     16h
        int     18h
        jmp     $
@@:
        push    ds
        pop     es
        cmp     word [bx+1], 'CD'
        jnz     pvd_scan_loop
        cmp     word [bx+3], '00'
        jnz     pvd_scan_loop
        cmp     byte [bx+5], '1'
        jnz     pvd_scan_loop
; we have found ISO9660 descriptor, look for type
        cmp     byte [bx], 1    ; Primary Volume Descriptor?
        jz      pvd_found
        cmp     byte [bx], 0xFF ; Volume Descriptor Set Terminator?
        jnz     pvd_scan_loop
; Volume Descriptor Set Terminator reached, no PVD found - fatal error
        mov     si, no_pvd
        jmp     err_
pvd_found:
        add     bx, 80h
        mov     ax, [bx]
        mov     [lb_size], ax
; calculate number of logical blocks in one sector
        mov     ax, 800h
        cwd
        div     word [bx]
        mov     [lb_per_sec], ax
; get location of root directory
        mov     di, root_location
        movzx   eax, byte [bx+1Dh]
        add     eax, [bx+1Eh]
        stosd
; get memory size
        int     12h
        mov     si, nomem_str
        cmp     ax, 71000h / 400h
        jb      err_
        shr     ax, 1
        sub     ax, 60000h / 800h
        mov     [size_rest], ax
        mov     [free_ptr], 60000h / 800h
; load path table
; if size > 62K => it's very strange, avoid using it
; if size > (size of cache)/2 => avoid using it too
        mov     ecx, [bx+4]
        cmp     ecx, 0x10000 - 0x800
        ja      nopathtable
        shr     ax, 1
        cmp     ax, 0x20
        jae     @f
        shl     ax, 11
        cmp     cx, ax
        ja      nopathtable
@@:
; size is ok, try to load it
        mov     [pathtable_size], cx
        mov     eax, [bx+12]
        xor     edx, edx
        div     dword [lb_per_sec]
        imul    dx, [bx]
        mov     [pathtable_start], dx
        add     cx, dx
        call    cx_to_sectors
        xor     bx, bx
        push    6000h
        pop     es
        call    read_sectors
        jc      nopathtable
; path table has been loaded
        inc     [use_path_table]
        sub     [size_rest], cx
        add     [free_ptr], cx
nopathtable:
; init cache
        mov     ax, [size_rest]
        mov     [cache_size], ax
        mov     ax, [free_ptr]
        mov     [cache_start], ax
; load secondary loader
        mov     di, secondary_loader_info
        call    load_file
        test    bx, bx
        jnz     noloader
; set registers for secondary loader
        mov     ah, [bootdrive]
        mov     al, 'c'
        mov     bx, 'is'
        mov     si, callback
        jmp     far [si-callback+secondary_loader_info] ; jump to 1000:0000
 
noloader:
        mov     si, aKernelNotFound
        jmp     err_
 
read_sectors:
; es:bx = pointer to data
; eax = first sector
; cx = number of sectors
        pushad
        push    ds
do_read_sectors:
        push    ax
        push    cx
        cmp     cx, 0x7F
        jbe     @f
        mov     cx, 0x7F
@@:
; create disk address packet on the stack
; dq starting LBA
        db      66h
        push    0
        push    eax
; dd buffer
        push    es
        push    bx
; dw number of blocks to transfer (no more than 0x7F)
        push    cx
; dw packet size in bytes
        push    10h
; issue BIOS call
        push    ss
        pop     ds
        mov     si, sp
        mov     dl, [cs:bootdrive]
        mov     ah, 42h
        int     13h
        jc      diskreaderr
; restore stack
        add     sp, 10h
; increase current sector & buffer; decrease number of sectors
        movzx   esi, cx
        mov     ax, es
        shl     cx, 7
        add     ax, cx
        mov     es, ax
        pop     cx
        pop     ax
        add     eax, esi
        sub     cx, si
        jnz     do_read_sectors
        pop     ds
        popad
        ret
diskreaderr:
        add     sp, 10h + 2*2
        pop     ds
        popad
        stc
out_string.ret:
        ret
 
out_string:
; in: ds:si -> ASCIIZ string
        lodsb
        test    al, al
        jz      .ret
        mov     ah, 0Eh
        mov     bx, 7
        int     10h
        jmp     out_string
 
aNoLBA          db      'The drive does not support LBA!',0
aReadError      db      'Read error',0
no_pvd          db      'Primary Volume Descriptor not found!',0
nomem_str       db      'No memory',0
aPressAnyKey    db      13,10,'Press any key...',13,10,0
 
load_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 = 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)
; parse path to the file
        lea     si, [di+6]
        mov     eax, [cs:root_location]
        cmp     [cs:use_path_table], 0
        jz      parse_dir
; scan for path in path table
        push    di
        push    6000h
        pop     es
        mov     di, [cs:pathtable_start]        ; es:di = pointer to current entry in path table
        mov     dx, 1   ; dx = number of current entry in path table, start from 1
        mov     cx, [cs:pathtable_size]
pathtable_newparent:
        mov     bx, dx  ; bx = number of current parent in path table: root = 1
scan_path_table_e:
        call    is_last_component
        jnc     path_table_scanned
scan_path_table_i:
        cmp     word [es:di+6], bx
        jb      .next
        ja      path_table_notfound
        call    test_filename1
        jc      .next
@@:
        lodsb
        cmp     al, '/'
        jnz     @b
        jmp     pathtable_newparent
.next:
; go to next entry
        inc     dx
        movzx   ax, byte [es:di]
        add     ax, 8+1
        and     al, not 1
        add     di, ax
        sub     cx, ax
        ja      scan_path_table_i
path_table_notfound:
        pop     di
        mov     ax, -1
        mov     dx, ax
        mov     bx, 2   ; file not found
        ret
path_table_scanned:
        movzx   eax, byte [es:di+1]
        add     eax, [es:di+2]
        pop     di
parse_dir:
; eax = logical block, ds:di -> information structure, ds:si -> file name
; was the folder already read?
        push    di ds
        push    cs
        pop     ds
        mov     [cur_desc_end], 2000h
        mov     bx, cachelist
.scan1:
        mov     bx, [bx+2]
        cmp     bx, cachelist
        jz      .notfound
        cmp     [bx+4], eax
        jnz     .scan1
.found:
; yes; delete this item from the list (the following code will append this item to the tail)
        mov     di, [bx]
        push    word [bx+2]
        pop     word [di+2]
        mov     di, [bx+2]
        push    word [bx]
        pop     word [di]
        mov     di, bx
        jmp     .scan
.notfound:
; no; load first sector of the folder to get its size
        push    eax
        push    si
        mov     si, 1
        call    load_phys_sector_for_lb_force
        mov     bx, si
        pop     si
        pop     eax
        jnc     @f
; read error - return
.readerr:
        pop     ds
.readerr2:
        pop     di
        mov     ax, -1
        mov     dx, ax
        mov     bx, 3
        ret
@@:
; first item of the folder describes the folder itself
; do not cache too big folders: size < 64K and size <= (total cache size)/2
        cmp     word [bx+12], 0
        jnz     .nocache
        mov     cx, [cache_size]        ; cx = cache size in sectors
        shr     cx, 1                   ; cx = (cache size)/2
        cmp     cx, 0x20
        jae     @f
        shl     cx, 11
        cmp     [bx+10], cx
        ja      .nocache
@@:
; we want to cache this folder; get space for it
        mov     cx, [bx+10]
        call    cx_to_sectors
        jnz     .yescache
.nocache:
        push    dword [bx+10]
        pop     dword [cur_nocache_len]
        call    lb_to_sector
        push    ds
        pop     es
        pop     ds
.nocache_loop:
        push    eax
        mov     dx, 1800h
        call    scan_for_filename_in_sector
        mov     cx, dx
        pop     eax
        jnc     .j_scandone
        sub     cx, bx
        sub     word [es:cur_nocache_len], cx
        sbb     word [es:cur_nocache_len+2], 0
        jb      .j_scandone
        ja      @f
        cmp     word [es:cur_nocache_len], 0
        jz      .j_scandone
@@:
        mov     cx, 1
        inc     eax
        push    es
        mov     bx, 1000h
        call    read_sectors
        pop     es
        jc      .readerr2
        jmp     .nocache_loop
.j_scandone:
        jmp     .scandone
.yescache:
        push    bx
        mov     bx, [cachelist.head]
.freeloop:
        cmp     cx, [size_rest]
        jbe     .sizeok
@@:
; if we are here: there is not enough free space, so we must delete old folders' data
; N.B. We know that after deleting some folders the space will be available (size <= (total cache size)/2).
; one loop iteration: delete data of one folder
        pusha
        mov     dx, [bx+10]
        mov     es, dx          ; es = segment of folder data to be deleted
        xor     di, di
        mov     ax, [bx+8]
        add     ax, 0x7FF
        rcr     ax, 1
        shr     ax, 10
        push    ax
        shl     ax, 11-4        ; get number of paragraphs in folder data to be deleted
        mov     cx, [cache_size]
        add     cx, [cache_start]
        push    ds
        push    ax
        add     ax, dx
        mov     ds, ax
        pop     ax
        shl     cx, 11-4
        sub     cx, dx          ; cx = number of paragraphs to be moved
        push    si
        xor     si, si
; move cx paragraphs from ds:si to es:di to get free space in the end of cache
@@:
        sub     cx, 1000h
        jbe     @f
        push    cx
        mov     cx, 8000h
        rep movsw
        mov     cx, ds
        add     cx, 1000h
        mov     ds, cx
        mov     cx, es
        add     cx, 1000h
        mov     es, cx
        pop     cx
        jmp     @b
@@:
        add     cx, 1000h
        shl     cx, 3
        rep movsw
        pop     si
        pop     ds
; correct positions in cache for existing items
        mov     cx, 80h
        mov     di, 8400h
.correct:
        cmp     [di+10], dx
        jbe     @f
        sub     [di+10], ax
@@:
        add     di, 12
        loop    .correct
; some additional space is free now
        pop     ax
        add     [size_rest], ax
        sub     [free_ptr], ax
; add cache item to the list of free items
        mov     dx, [bx]
        mov     ax, [free_cache_item]
        mov     [bx], ax
        mov     [free_cache_item], bx
        mov     bx, dx
; current iteration done
        popa
        jmp     .freeloop
.sizeok:
        mov     [cachelist.head], bx
        mov     word [bx+2], cachelist
; allocate new item in cache
        mov     di, [free_cache_item]
        test    di, di
        jz      .nofree
        push    word [di]
        pop     [free_cache_item]
        jmp     @f
.nofree:
        mov     di, [last_cache_item]
        add     [last_cache_item], 12
@@:
        pop     bx
        push    si di
;       mov     [di+4], eax     ; start of folder
        scasd
        stosd
        push    ax
        mov     ax, [free_ptr]
        shl     ax, 11-4
        mov     [di+10-8], ax
        mov     es, ax
        pop     ax
        add     [free_ptr], cx
        sub     [size_rest], cx
; read folder data
; first sector is already in memory, 0000:bx
        pusha
        mov     cx, [bx+10]
        mov     [di+8-8], cx    ; folder size in bytes
        mov     si, bx
        xor     di, di
        mov     cx, 0x1800
        sub     cx, si
        rep movsb
        pop     ax
        push    di
        popa
; read rest of folder
        mov     esi, dword [lb_per_sec]
        add     eax, esi
        dec     si
        not     si
        and     ax, si
        mov     si, word [bx+10]
        mov     bx, di
        pop     di
        sub     si, bx
        jbe     @f
        mov     [cur_limit], esi
        call    read_many_bytes
        pop     si
        jnc     .scan
        jmp     .readerr
@@:
        pop     si
.scan:
; now we have required cache item; append it to the end of list
        mov     bx, [cachelist.tail]
        mov     [cachelist.tail], di
        mov     [di+2], bx
        mov     word [di], cachelist
        mov     [bx], di
; scan for given filename
        mov     es, [di+10]
        mov     dx, [di+8]
        pop     ds
        xor     bx, bx
        call    scan_for_filename_in_sector
.scandone:
        push    cs
        pop     es
        mov     bx, 2000h
        cmp     bx, [es:cur_desc_end]
        jnz     filefound
j_notfound:
        jmp     path_table_notfound
filefound:
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
@@:
        mov     cl, [es:bx+8]
        test    al, al
        jz      @f
; parse next component of file name
        test    cl, 2   ; directory?
        jz      j_notfound
        mov     eax, [es:bx]
        pop     di
        jmp     parse_dir
@@:
        test    cl, 2   ; directory?
        jnz     j_notfound      ; do not allow read directories as regular files
; ok, now load the file
        pop     di
        les     bx, [di]
        call    normalize
        movzx   esi, word [di+4]        ; esi = limit in 4K blocks
        shl     esi, 12         ; esi = limit in bytes
        push    cs
        pop     ds
        mov     [cur_limit], esi
        mov     di, 2000h
loadloop:
        and     [cur_start], 0
.loadnew:
        mov     esi, [cur_limit]
        mov     eax, [cur_start]
        add     esi, eax
        mov     [overflow], 1
        sub     esi, [di+4]
        jb      @f
        xor     esi, esi
        dec     [overflow]
@@:
        add     esi, [di+4]     ; esi = number of bytes to read
        mov     [cur_start], esi
        sub     esi, eax
        jz      .loadcontinue
        xor     edx, edx
        div     dword [lb_size] ; eax = number of logical blocks to skip,
        mov     [first_byte], dx; [first_byte] = number of bytes to skip in 1st block
        cmp     byte [di+10], 0
        jnz     .interleaved
        add     eax, [di]
; read esi bytes from logical block eax to buffer es:bx
        call    read_many_bytes.with_first
        jc      .readerr3
.loadcontinue:
        mov     [cur_chunk], di
        add     di, 11
        cmp     di, [cur_desc_end]
        jae     @f
        cmp     [cur_limit], 0
        jnz     loadloop
@@:
        mov     bx, [overflow]
.calclen:
; calculate length of file
        xor     ax, ax
        xor     dx, dx
        mov     di, 2000h
@@:
        add     ax, [di+4]
        adc     dx, [di+6]
        add     di, 11
        cmp     di, [cur_desc_end]
        jb      @b
        ret
.interleaved:
        mov     [cur_unit_limit], esi
        push    esi
; skip first blocks
        movzx   ecx, byte [di+9]        ; Unit Size
        movzx   esi, byte [di+10]       ; Interleave Gap
        add     si, cx
        mov     edx, [di]
@@:
        sub     eax, ecx
        jb      @f
        add     edx, esi
        jmp     @b
@@:
        add     ecx, eax        ; ecx = number of logical blocks to skip
        lea     eax, [ecx+edx]  ; eax = first logical block
        pop     esi
.interleaved_loop:
; get number of bytes in current file unit
        push    eax
        movzx   eax, byte [di+9]
        sub     ax, cx
        imul    eax, dword [lb_size]
        cmp     eax, esi
        ja      .i2
.i1:
        xchg    esi, eax
.i2:
        pop     eax
        sub     [cur_unit_limit], esi
        push    eax
; read esi bytes from logical block eax to buffer es:bx
        call    read_many_bytes.with_first
        pop     eax
        jnc     @f
.readerr3:
        mov     bx, 3
        jmp     .calclen
@@:
        mov     esi, [cur_unit_limit]
        test    esi, esi
        jz      .loadcontinue
        movzx   ecx, byte [di+9]        ; add Unit Size
        add     cl, byte [di+10]        ; add Interleave Gap
        adc     ch, 0
        add     eax, ecx
        xor     cx, cx
        mov     [first_byte], cx
        jmp     .interleaved_loop
 
cx_to_sectors:
        add     cx, 7FFh
        rcr     cx, 1
        shr     cx, 10
        ret
 
is_last_component:
; in: ds:si -> name
; out: CF set <=> current component is not last (=> folder)
        push    si
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
        stc
@@:
        pop     si
        ret
 
test_filename1:
; in: ds:si -> filename, es:di -> path table item
; out: CF set <=> no match
        pusha
        mov     cl, [es:di]
        add     di, 8
        jmp     test_filename2.start
test_filename2:
; in: ds:si -> filename, es:bx -> directory item
; out: CF set <=> no match
        pusha
        mov     cl, [es:bx+32]
        lea     di, [bx+33]
.start:
        mov     ch, 0
@@:
        lodsb
        test    al, al
        jz      .test1
        cmp     al, '/'
        jz      .test1
        call    toupper
        mov     ah, al
        mov     al, [es:di]
        call    toupper
        inc     di
        cmp     al, ah
        loopz   @b
        jnz     .next1
; if we have reached this point: current name is done
        lodsb
        test    al, al
        jz      .ret
        cmp     al, '/'
        jz      .ret
; if we have reached this point: current name is done, but input name continues
; so they do not match
        jmp     .next1
.test1:
; if we have reached this point: input name is done, but current name continues
; "filename.ext;version" in ISO-9660 represents file "filename.ext"
; "filename." and "filename.;version" are also possible for "filename"
        cmp     byte [es:di], '.'
        jnz     @f
        inc     di
        dec     cx
        jz      .ret
@@:
        cmp     byte [es:di], ';'
        jnz     .next1
        jmp     .ret
.next1:
        stc
.ret:
        popa
        ret
 
toupper:
; in: al=symbol
; out: al=symbol in uppercase
        cmp     al, 'a'
        jb      .ret
        cmp     al, 'z'
        ja      .ret
        sub     al, 'a'-'A'
.ret:
        ret
 
scan_for_filename_in_sector:
; in: ds:si->filename, es:bx->folder data, dx=limit
; out: CF=0 if found
        push    bx
.loope:
        push    bx
.loop:
        cmp     bx, dx
        jae     .notfound
        cmp     byte [es:bx], 0
        jz      .loopd
        test    byte [es:bx+25], 4      ; ignore files with Associated bit
        jnz     .next
        call    test_filename2
        jc      .next
        push    ds es di
        push    es
        pop     ds
        push    cs
        pop     es
        mov     di, [es:cur_desc_end]
        movzx   eax, byte [bx+1]
        add     eax, [bx+2]
        stosd   ; first logical block
        mov     eax, [bx+10]
        stosd   ; length
        mov     al, [bx+25]
        stosb   ; flags
        mov     ax, [bx+26]
        stosw   ; File Unit size, Interleave Gap size
        mov     [es:cur_desc_end], di
        cmp     di, 3000h
        pop     di es ds
        jae     .done
        test    byte [es:bx+25], 80h
        jz      .done
.next:
        add     bl, [es:bx]
        adc     bh, 0
        jmp     .loop
.loopd:
        mov     ax, bx
        pop     bx
@@:
        add     bx, [cs:lb_size]
        jz      .done2
        cmp     bx, ax
        jb      @b
        jmp     .loope
.notfound:
        stc
.done:
        pop     bx
.done2:
        pop     bx
        ret
 
lb_to_sector:
        xor     edx, edx
        div     dword [lb_per_sec]
        ret
 
load_phys_sector_for_lb_force:
; in: eax = logical block, ds=0
; in: si=0 - accept 0 logical blocks, otherwise force read at least 1
; out: 0000:1000 = physical sector data; si -> logical block
; out: eax = next physical sector
; out: CF=1 if read error
; destroys cx
; this procedure reads 0-3 or 1-4 logical blocks, up to the end of physical sector
        call    lb_to_sector
        or      si, dx
        jnz     @f
        mov     si, 1800h
        jmp     .done
@@:
        mov     si, 1000h
        imul    dx, [lb_size]
        add     si, dx
        mov     cx, 1
        push    es bx
        push    ds
        pop     es
        mov     bx, 1000h
        call    read_sectors
        pop     bx es
        inc     eax
.done:
        ret
 
normalize:
; in: es:bx = far pointer
; out: es:bx = normalized pointer (i.e. 0 <= bx < 0x10)
        push    ax bx
        mov     ax, es
        shr     bx, 4
        add     ax, bx
        mov     es, ax
        pop     bx ax
        and     bx, 0x0F
        ret
 
read_many_bytes:
        and     [first_byte], 0
read_many_bytes.with_first:
; read esi bytes from logical block dx:ax to buffer es:bx
; out: CF=1 <=> disk error
        push    di
; load first physical sector
        push    bx si
        mov     si, [first_byte]
        call    load_phys_sector_for_lb_force
        jnc     @f
        pop     si bx
.ret:
        pop     di
        ret
@@:
        add     si, [first_byte]
        mov     ecx, 1800h
        sub     cx, si
        mov     ebx, esi
        pop     bx
        sub     ebx, ecx
        jnc     @f
        add     cx, bx
        xor     ebx, ebx
@@:
        pop     di
        sub     [cur_limit], ecx
        rep movsb
        mov     esi, ebx
        mov     bx, di
        call    normalize
; load other physical sectors
; read esi bytes from physical sector eax to buffer es:bx
        test    esi, esi
        jz      .ret
        push    esi
        add     esi, 0x7FF
        and     si, not 0x7FF
        cmp     esi, [cur_limit]
        jbe     .okplace
.noplace:
        sub     esi, 800h
.okplace:
        shr     esi, 11 ; si = number of sectors
        mov     cx, si
        jz      @f
        call    read_sectors
@@:
        pop     esi
        jc      .ret
        movzx   ecx, cx
        add     eax, ecx
        shl     ecx, 11
        sub     [cur_limit], ecx
        sub     esi, ecx
        jc      .big
        jz      .nopost
        push    bx es
        push    ds
        pop     es
        mov     bx, 1000h
        mov     cx, 1
        call    read_sectors
        pop     es di
        jc      .ret2
        mov     cx, si
        mov     si, 1000h
        sub     word [cur_limit], cx
        sbb     word [cur_limit+2], 0
        rep movsb
        mov     bx, di
        call    normalize
.nopost:
        clc
.ret2:
        pop     di
        ret
.big:
        mov     ax, es
        sub     ax, 80h
        mov     es, ax
        add     bx, 800h
        add     bx, si
        call    normalize
        sub     [cur_limit], esi
        jmp     .nopost
 
; Callback function for secondary loader
callback:
; in: ax = function number; only function 1 is defined for now
        dec     ax
        jz      callback_readfile
        dec     ax
        jz      callback_continueread
        stc     ; unsupported function
        retf
 
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
        clc     ; function is supported
        retf
 
callback_continueread:
; function 2: continue to 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)
; out: bx=0 - ok, bx=1 - file is too big, only part of file was loaded, bx=3 - read error
; out: dx:ax = file size
        les     bx, [di]
        call    normalize
        movzx   esi, word [di+4]        ; si = limit in 4K blocks
        shl     esi, 12                 ; bp:si = limit in bytes
        push    cs
        pop     ds
        mov     [cur_limit], esi
        mov     di, [cur_chunk]
        call    loadloop.loadnew
        clc     ; function is supported
        retf
 
secondary_loader_info:
        dw      0, 0x1000
        dw      0x30000 / 0x1000
        db      'kernel.mnt',0
aKernelNotFound db      'Fatal error: cannot load the kernel',0
 
align 2
cachelist:
.head           dw      cachelist
.tail           dw      cachelist
free_cache_item dw      0
last_cache_item dw      0x8400
 
use_path_table  db      0
bootdrive       db      ?
align 2
lb_size         dw      ?       ; Logical Block size in bytes
                dw      0       ; to allow access dword [lb_size]
lb_per_sec      dw      ?       ; Logical Blocks per physical sector
                dw      0       ; to allow access dword [lb_per_sec]
free_ptr        dw      ?       ; first free block in cache (cache block = sector = 0x800 bytes)
size_rest       dw      ?       ; free space in cache (in blocks)
cache_size      dw      ?
cache_start     dw      ?
pathtable_size  dw      ?
pathtable_start dw      ?
root_location   dd      ?
cur_desc_end    dw      ?
cur_nocache_len dd      ?
cur_limit       dd      ?
cur_unit_limit  dd      ?
overflow        dw      ?
cur_chunk       dw      ?
first_byte      dw      ?
cur_start       dd      ?
 
times 83FCh-$  db      0
        db      43h
; just to make file 2048 bytes long :)
        db      'd' xor 'i' xor 'a' xor 'm' xor 'o' xor 'n' xor 'd'
 
        dw      0xAA55          ; this is not required for CD, but to be consistent...

Rev 2288	Rev 3598
1	; Copyright (c) 2008-2009, diamond	1	; Copyright (c) 2008-2009, diamond
2	; All rights reserved.	2	; All rights reserved.
3	;	3	;
4	; Redistribution and use in source and binary forms, with or without	4	; Redistribution and use in source and binary forms, with or without
5	; modification, are permitted provided that the following conditions are met:	5	; modification, are permitted provided that the following conditions are met:
6	; * Redistributions of source code must retain the above copyright	6	; * Redistributions of source code must retain the above copyright
7	; notice, this list of conditions and the following disclaimer.	7	; notice, this list of conditions and the following disclaimer.
8	; * Redistributions in binary form must reproduce the above copyright	8	; * Redistributions in binary form must reproduce the above copyright
9	; notice, this list of conditions and the following disclaimer in the	9	; notice, this list of conditions and the following disclaimer in the
10	; documentation and/or other materials provided with the distribution.	10	; documentation and/or other materials provided with the distribution.
11	; * Neither the name of the nor the	11	; * Neither the name of the nor the
12	; names of its contributors may be used to endorse or promote products	12	; names of its contributors may be used to endorse or promote products
13	; derived from this software without specific prior written permission.	13	; derived from this software without specific prior written permission.
14	;	14	;
15	; THIS SOFTWARE IS PROVIDED BY Alexey Teplov aka ''AS IS'' AND ANY	15	; THIS SOFTWARE IS PROVIDED BY Alexey Teplov aka ''AS IS'' AND ANY
16	; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED	16	; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17	; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE	17	; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18	; DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY	18	; DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
19	; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES	19	; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20	; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;	20	; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21	; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND	21	; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22	; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	22	; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23	; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS	23	; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24	; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	24	; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25	;*****************************************************************************	25	;*****************************************************************************
26		26
27	jmp far 0:real_start	27	jmp far 0:real_start
28	; special text	28	; special text
29	org $+0x7C00	29	org $+0x7C00
30	real_start:	30	real_start:
31	; initialize	31	; initialize
32	xor ax, ax	32	xor ax, ax
33	mov ss, ax	33	mov ss, ax
34	mov sp, 0x7C00	34	mov sp, 0x7C00
35	mov ds, ax	35	mov ds, ax
36	mov es, ax	36	mov es, ax
37	cld	37	cld
38	sti	38	sti
39	mov [bootdrive], dl	39	mov [bootdrive], dl
40	; check LBA support	40	; check LBA support
41	mov ah, 41h	41	mov ah, 41h
42	mov bx, 55AAh	42	mov bx, 55AAh
43	int 13h	43	int 13h
44	mov si, aNoLBA	44	mov si, aNoLBA
45	jc err_	45	jc err_
46	cmp bx, 0AA55h	46	cmp bx, 0AA55h
47	jnz err_	47	jnz err_
48	test cl, 1	48	test cl, 1
49	jz err_	49	jz err_
50	; get file system information	50	; get file system information
51	; scan for Primary Volume Descriptor	51	; scan for Primary Volume Descriptor
52	db 66h	52	db 66h
53	push 10h-1	53	movi eax, 10h-1
54	pop eax	-
55	pvd_scan_loop:	54	pvd_scan_loop:
56	mov cx, 1	55	mov cx, 1
57	inc eax	56	inc eax
58	mov bx, 0x1000	57	mov bx, 0x1000
59	call read_sectors	58	call read_sectors
60	jnc @f	59	jnc @f
61	fatal_read_err:	60	fatal_read_err:
62	mov si, aReadError	61	mov si, aReadError
63	err_:	62	err_:
64	call out_string	63	call out_string
65	mov si, aPressAnyKey	64	mov si, aPressAnyKey
66	call out_string	65	call out_string
67	xor ax, ax	66	xor ax, ax
68	int 16h	67	int 16h
69	int 18h	68	int 18h
70	jmp $	69	jmp $
71	@@:	70	@@:
72	push ds	71	push ds
73	pop es	72	pop es
74	cmp word [bx+1], 'CD'	73	cmp word [bx+1], 'CD'
75	jnz pvd_scan_loop	74	jnz pvd_scan_loop
76	cmp word [bx+3], '00'	75	cmp word [bx+3], '00'
77	jnz pvd_scan_loop	76	jnz pvd_scan_loop
78	cmp byte [bx+5], '1'	77	cmp byte [bx+5], '1'
79	jnz pvd_scan_loop	78	jnz pvd_scan_loop
80	; we have found ISO9660 descriptor, look for type	79	; we have found ISO9660 descriptor, look for type
81	cmp byte [bx], 1 ; Primary Volume Descriptor?	80	cmp byte [bx], 1 ; Primary Volume Descriptor?
82	jz pvd_found	81	jz pvd_found
83	cmp byte [bx], 0xFF ; Volume Descriptor Set Terminator?	82	cmp byte [bx], 0xFF ; Volume Descriptor Set Terminator?
84	jnz pvd_scan_loop	83	jnz pvd_scan_loop
85	; Volume Descriptor Set Terminator reached, no PVD found - fatal error	84	; Volume Descriptor Set Terminator reached, no PVD found - fatal error
86	mov si, no_pvd	85	mov si, no_pvd
87	jmp err_	86	jmp err_
88	pvd_found:	87	pvd_found:
89	add bx, 80h	88	add bx, 80h
90	mov ax, [bx]	89	mov ax, [bx]
91	mov [lb_size], ax	90	mov [lb_size], ax
92	; calculate number of logical blocks in one sector	91	; calculate number of logical blocks in one sector
93	mov ax, 800h	92	mov ax, 800h
94	cwd	93	cwd
95	div word [bx]	94	div word [bx]
96	mov [lb_per_sec], ax	95	mov [lb_per_sec], ax
97	; get location of root directory	96	; get location of root directory
98	mov di, root_location	97	mov di, root_location
99	movzx eax, byte [bx+1Dh]	98	movzx eax, byte [bx+1Dh]
100	add eax, [bx+1Eh]	99	add eax, [bx+1Eh]
101	stosd	100	stosd
102	; get memory size	101	; get memory size
103	int 12h	102	int 12h
104	mov si, nomem_str	103	mov si, nomem_str
105	cmp ax, 71000h / 400h	104	cmp ax, 71000h / 400h
106	jb err_	105	jb err_
107	shr ax, 1	106	shr ax, 1
108	sub ax, 60000h / 800h	107	sub ax, 60000h / 800h
109	mov [size_rest], ax	108	mov [size_rest], ax
110	mov [free_ptr], 60000h / 800h	109	mov [free_ptr], 60000h / 800h
111	; load path table	110	; load path table
112	; if size > 62K => it's very strange, avoid using it	111	; if size > 62K => it's very strange, avoid using it
113	; if size > (size of cache)/2 => avoid using it too	112	; if size > (size of cache)/2 => avoid using it too
114	mov ecx, [bx+4]	113	mov ecx, [bx+4]
115	cmp ecx, 0x10000 - 0x800	114	cmp ecx, 0x10000 - 0x800
116	ja nopathtable	115	ja nopathtable
117	shr ax, 1	116	shr ax, 1
118	cmp ax, 0x20	117	cmp ax, 0x20
119	jae @f	118	jae @f
120	shl ax, 11	119	shl ax, 11
121	cmp cx, ax	120	cmp cx, ax
122	ja nopathtable	121	ja nopathtable
123	@@:	122	@@:
124	; size is ok, try to load it	123	; size is ok, try to load it
125	mov [pathtable_size], cx	124	mov [pathtable_size], cx
126	mov eax, [bx+12]	125	mov eax, [bx+12]
127	xor edx, edx	126	xor edx, edx
128	div dword [lb_per_sec]	127	div dword [lb_per_sec]
129	imul dx, [bx]	128	imul dx, [bx]
130	mov [pathtable_start], dx	129	mov [pathtable_start], dx
131	add cx, dx	130	add cx, dx
132	call cx_to_sectors	131	call cx_to_sectors
133	xor bx, bx	132	xor bx, bx
134	push 6000h	133	push 6000h
135	pop es	134	pop es
136	call read_sectors	135	call read_sectors
137	jc nopathtable	136	jc nopathtable
138	; path table has been loaded	137	; path table has been loaded
139	inc [use_path_table]	138	inc [use_path_table]
140	sub [size_rest], cx	139	sub [size_rest], cx
141	add [free_ptr], cx	140	add [free_ptr], cx
142	nopathtable:	141	nopathtable:
143	; init cache	142	; init cache
144	mov ax, [size_rest]	143	mov ax, [size_rest]
145	mov [cache_size], ax	144	mov [cache_size], ax
146	mov ax, [free_ptr]	145	mov ax, [free_ptr]
147	mov [cache_start], ax	146	mov [cache_start], ax
148	; load secondary loader	147	; load secondary loader
149	mov di, secondary_loader_info	148	mov di, secondary_loader_info
150	call load_file	149	call load_file
151	test bx, bx	150	test bx, bx
152	jnz noloader	151	jnz noloader
153	; set registers for secondary loader	152	; set registers for secondary loader
154	mov ah, [bootdrive]	153	mov ah, [bootdrive]
155	mov al, 'c'	154	mov al, 'c'
156	mov bx, 'is'	155	mov bx, 'is'
157	mov si, callback	156	mov si, callback
158	jmp far [si-callback+secondary_loader_info] ; jump to 1000:0000	157	jmp far [si-callback+secondary_loader_info] ; jump to 1000:0000
159		158
160	noloader:	159	noloader:
161	mov si, aKernelNotFound	160	mov si, aKernelNotFound
162	jmp err_	161	jmp err_
163		162
164	read_sectors:	163	read_sectors:
165	; es:bx = pointer to data	164	; es:bx = pointer to data
166	; eax = first sector	165	; eax = first sector
167	; cx = number of sectors	166	; cx = number of sectors
168	pushad	167	pushad
169	push ds	168	push ds
170	do_read_sectors:	169	do_read_sectors:
171	push ax	170	push ax
172	push cx	171	push cx
173	cmp cx, 0x7F	172	cmp cx, 0x7F
174	jbe @f	173	jbe @f
175	mov cx, 0x7F	174	mov cx, 0x7F
176	@@:	175	@@:
177	; create disk address packet on the stack	176	; create disk address packet on the stack
178	; dq starting LBA	177	; dq starting LBA
179	db 66h	178	db 66h
180	push 0	179	push 0
181	push eax	180	push eax
182	; dd buffer	181	; dd buffer
183	push es	182	push es
184	push bx	183	push bx
185	; dw number of blocks to transfer (no more than 0x7F)	184	; dw number of blocks to transfer (no more than 0x7F)
186	push cx	185	push cx
187	; dw packet size in bytes	186	; dw packet size in bytes
188	push 10h	187	push 10h
189	; issue BIOS call	188	; issue BIOS call
190	push ss	189	push ss
191	pop ds	190	pop ds
192	mov si, sp	191	mov si, sp
193	mov dl, [cs:bootdrive]	192	mov dl, [cs:bootdrive]
194	mov ah, 42h	193	mov ah, 42h
195	int 13h	194	int 13h
196	jc diskreaderr	195	jc diskreaderr
197	; restore stack	196	; restore stack
198	add sp, 10h	197	add sp, 10h
199	; increase current sector & buffer; decrease number of sectors	198	; increase current sector & buffer; decrease number of sectors
200	movzx esi, cx	199	movzx esi, cx
201	mov ax, es	200	mov ax, es
202	shl cx, 7	201	shl cx, 7
203	add ax, cx	202	add ax, cx
204	mov es, ax	203	mov es, ax
205	pop cx	204	pop cx
206	pop ax	205	pop ax
207	add eax, esi	206	add eax, esi
208	sub cx, si	207	sub cx, si
209	jnz do_read_sectors	208	jnz do_read_sectors
210	pop ds	209	pop ds
211	popad	210	popad
212	ret	211	ret
213	diskreaderr:	212	diskreaderr:
214	add sp, 10h + 2*2	213	add sp, 10h + 2*2
215	pop ds	214	pop ds
216	popad	215	popad
217	stc	216	stc
218	out_string.ret:	217	out_string.ret:
219	ret	218	ret
220		219
221	out_string:	220	out_string:
222	; in: ds:si -> ASCIIZ string	221	; in: ds:si -> ASCIIZ string
223	lodsb	222	lodsb
224	test al, al	223	test al, al
225	jz .ret	224	jz .ret
226	mov ah, 0Eh	225	mov ah, 0Eh
227	mov bx, 7	226	mov bx, 7
228	int 10h	227	int 10h
229	jmp out_string	228	jmp out_string
230		229
231	aNoLBA db 'The drive does not support LBA!',0	230	aNoLBA db 'The drive does not support LBA!',0
232	aReadError db 'Read error',0	231	aReadError db 'Read error',0
233	no_pvd db 'Primary Volume Descriptor not found!',0	232	no_pvd db 'Primary Volume Descriptor not found!',0
234	nomem_str db 'No memory',0	233	nomem_str db 'No memory',0
235	aPressAnyKey db 13,10,'Press any key...',13,10,0	234	aPressAnyKey db 13,10,'Press any key...',13,10,0
236		235
237	load_file:	236	load_file:
238	; in: ds:di -> information structure	237	; in: ds:di -> information structure
239	; dw:dw address	238	; dw:dw address
240	; dw limit in 4Kb blocks (0x1000 bytes) (must be non-zero and not greater than 0x100)	239	; dw limit in 4Kb blocks (0x1000 bytes) (must be non-zero and not greater than 0x100)
241	; ASCIIZ name	240	; ASCIIZ name
242	; out: bx = status: bx=0 - ok, bx=1 - file is too big, only part of file was loaded, bx=2 - file not found	241	; out: bx = status: bx=0 - ok, bx=1 - file is too big, only part of file was loaded, bx=2 - file not found
243	; out: dx:ax = file size (0xFFFFFFFF if file not found)	242	; out: dx:ax = file size (0xFFFFFFFF if file not found)
244	; parse path to the file	243	; parse path to the file
245	lea si, [di+6]	244	lea si, [di+6]
246	mov eax, [cs:root_location]	245	mov eax, [cs:root_location]
247	cmp [cs:use_path_table], 0	246	cmp [cs:use_path_table], 0
248	jz parse_dir	247	jz parse_dir
249	; scan for path in path table	248	; scan for path in path table
250	push di	249	push di
251	push 6000h	250	push 6000h
252	pop es	251	pop es
253	mov di, [cs:pathtable_start] ; es:di = pointer to current entry in path table	252	mov di, [cs:pathtable_start] ; es:di = pointer to current entry in path table
254	mov dx, 1 ; dx = number of current entry in path table, start from 1	253	mov dx, 1 ; dx = number of current entry in path table, start from 1
255	mov cx, [cs:pathtable_size]	254	mov cx, [cs:pathtable_size]
256	pathtable_newparent:	255	pathtable_newparent:
257	mov bx, dx ; bx = number of current parent in path table: root = 1	256	mov bx, dx ; bx = number of current parent in path table: root = 1
258	scan_path_table_e:	257	scan_path_table_e:
259	call is_last_component	258	call is_last_component
260	jnc path_table_scanned	259	jnc path_table_scanned
261	scan_path_table_i:	260	scan_path_table_i:
262	cmp word [es:di+6], bx	261	cmp word [es:di+6], bx
263	jb .next	262	jb .next
264	ja path_table_notfound	263	ja path_table_notfound
265	call test_filename1	264	call test_filename1
266	jc .next	265	jc .next
267	@@:	266	@@:
268	lodsb	267	lodsb
269	cmp al, '/'	268	cmp al, '/'
270	jnz @b	269	jnz @b
271	jmp pathtable_newparent	270	jmp pathtable_newparent
272	.next:	271	.next:
273	; go to next entry	272	; go to next entry
274	inc dx	273	inc dx
275	movzx ax, byte [es:di]	274	movzx ax, byte [es:di]
276	add ax, 8+1	275	add ax, 8+1
277	and al, not 1	276	and al, not 1
278	add di, ax	277	add di, ax
279	sub cx, ax	278	sub cx, ax
280	ja scan_path_table_i	279	ja scan_path_table_i
281	path_table_notfound:	280	path_table_notfound:
282	pop di	281	pop di
283	mov ax, -1	282	mov ax, -1
284	mov dx, ax	283	mov dx, ax
285	mov bx, 2 ; file not found	284	mov bx, 2 ; file not found
286	ret	285	ret
287	path_table_scanned:	286	path_table_scanned:
288	movzx eax, byte [es:di+1]	287	movzx eax, byte [es:di+1]
289	add eax, [es:di+2]	288	add eax, [es:di+2]
290	pop di	289	pop di
291	parse_dir:	290	parse_dir:
292	; eax = logical block, ds:di -> information structure, ds:si -> file name	291	; eax = logical block, ds:di -> information structure, ds:si -> file name
293	; was the folder already read?	292	; was the folder already read?
294	push di ds	293	push di ds
295	push cs	294	push cs
296	pop ds	295	pop ds
297	mov [cur_desc_end], 2000h	296	mov [cur_desc_end], 2000h
298	mov bx, cachelist	297	mov bx, cachelist
299	.scan1:	298	.scan1:
300	mov bx, [bx+2]	299	mov bx, [bx+2]
301	cmp bx, cachelist	300	cmp bx, cachelist
302	jz .notfound	301	jz .notfound
303	cmp [bx+4], eax	302	cmp [bx+4], eax
304	jnz .scan1	303	jnz .scan1
305	.found:	304	.found:
306	; yes; delete this item from the list (the following code will append this item to the tail)	305	; yes; delete this item from the list (the following code will append this item to the tail)
307	mov di, [bx]	306	mov di, [bx]
308	push word [bx+2]	307	push word [bx+2]
309	pop word [di+2]	308	pop word [di+2]
310	mov di, [bx+2]	309	mov di, [bx+2]
311	push word [bx]	310	push word [bx]
312	pop word [di]	311	pop word [di]
313	mov di, bx	312	mov di, bx
314	jmp .scan	313	jmp .scan
315	.notfound:	314	.notfound:
316	; no; load first sector of the folder to get its size	315	; no; load first sector of the folder to get its size
317	push eax	316	push eax
318	push si	317	push si
319	mov si, 1	318	mov si, 1
320	call load_phys_sector_for_lb_force	319	call load_phys_sector_for_lb_force
321	mov bx, si	320	mov bx, si
322	pop si	321	pop si
323	pop eax	322	pop eax
324	jnc @f	323	jnc @f
325	; read error - return	324	; read error - return
326	.readerr:	325	.readerr:
327	pop ds	326	pop ds
328	.readerr2:	327	.readerr2:
329	pop di	328	pop di
330	mov ax, -1	329	mov ax, -1
331	mov dx, ax	330	mov dx, ax
332	mov bx, 3	331	mov bx, 3
333	ret	332	ret
334	@@:	333	@@:
335	; first item of the folder describes the folder itself	334	; first item of the folder describes the folder itself
336	; do not cache too big folders: size < 64K and size <= (total cache size)/2	335	; do not cache too big folders: size < 64K and size <= (total cache size)/2
337	cmp word [bx+12], 0	336	cmp word [bx+12], 0
338	jnz .nocache	337	jnz .nocache
339	mov cx, [cache_size] ; cx = cache size in sectors	338	mov cx, [cache_size] ; cx = cache size in sectors
340	shr cx, 1 ; cx = (cache size)/2	339	shr cx, 1 ; cx = (cache size)/2
341	cmp cx, 0x20	340	cmp cx, 0x20
342	jae @f	341	jae @f
343	shl cx, 11	342	shl cx, 11
344	cmp [bx+10], cx	343	cmp [bx+10], cx
345	ja .nocache	344	ja .nocache
346	@@:	345	@@:
347	; we want to cache this folder; get space for it	346	; we want to cache this folder; get space for it
348	mov cx, [bx+10]	347	mov cx, [bx+10]
349	call cx_to_sectors	348	call cx_to_sectors
350	jnz .yescache	349	jnz .yescache
351	.nocache:	350	.nocache:
352	push dword [bx+10]	351	push dword [bx+10]
353	pop dword [cur_nocache_len]	352	pop dword [cur_nocache_len]
354	call lb_to_sector	353	call lb_to_sector
355	push ds	354	push ds
356	pop es	355	pop es
357	pop ds	356	pop ds
358	.nocache_loop:	357	.nocache_loop:
359	push eax	358	push eax
360	mov dx, 1800h	359	mov dx, 1800h
361	call scan_for_filename_in_sector	360	call scan_for_filename_in_sector
362	mov cx, dx	361	mov cx, dx
363	pop eax	362	pop eax
364	jnc .j_scandone	363	jnc .j_scandone
365	sub cx, bx	364	sub cx, bx
366	sub word [es:cur_nocache_len], cx	365	sub word [es:cur_nocache_len], cx
367	sbb word [es:cur_nocache_len+2], 0	366	sbb word [es:cur_nocache_len+2], 0
368	jb .j_scandone	367	jb .j_scandone
369	ja @f	368	ja @f
370	cmp word [es:cur_nocache_len], 0	369	cmp word [es:cur_nocache_len], 0
371	jz .j_scandone	370	jz .j_scandone
372	@@:	371	@@:
373	mov cx, 1	372	mov cx, 1
374	inc eax	373	inc eax
375	push es	374	push es
376	mov bx, 1000h	375	mov bx, 1000h
377	call read_sectors	376	call read_sectors
378	pop es	377	pop es
379	jc .readerr2	378	jc .readerr2
380	jmp .nocache_loop	379	jmp .nocache_loop
381	.j_scandone:	380	.j_scandone:
382	jmp .scandone	381	jmp .scandone
383	.yescache:	382	.yescache:
384	push bx	383	push bx
385	mov bx, [cachelist.head]	384	mov bx, [cachelist.head]
386	.freeloop:	385	.freeloop:
387	cmp cx, [size_rest]	386	cmp cx, [size_rest]
388	jbe .sizeok	387	jbe .sizeok
389	@@:	388	@@:
390	; if we are here: there is not enough free space, so we must delete old folders' data	389	; if we are here: there is not enough free space, so we must delete old folders' data
391	; N.B. We know that after deleting some folders the space will be available (size <= (total cache size)/2).	390	; N.B. We know that after deleting some folders the space will be available (size <= (total cache size)/2).
392	; one loop iteration: delete data of one folder	391	; one loop iteration: delete data of one folder
393	pusha	392	pusha
394	mov dx, [bx+10]	393	mov dx, [bx+10]
395	mov es, dx ; es = segment of folder data to be deleted	394	mov es, dx ; es = segment of folder data to be deleted
396	xor di, di	395	xor di, di
397	mov ax, [bx+8]	396	mov ax, [bx+8]
398	add ax, 0x7FF	397	add ax, 0x7FF
399	rcr ax, 1	398	rcr ax, 1
400	shr ax, 10	399	shr ax, 10
401	push ax	400	push ax
402	shl ax, 11-4 ; get number of paragraphs in folder data to be deleted	401	shl ax, 11-4 ; get number of paragraphs in folder data to be deleted
403	mov cx, [cache_size]	402	mov cx, [cache_size]
404	add cx, [cache_start]	403	add cx, [cache_start]
405	push ds	404	push ds
406	push ax	405	push ax
407	add ax, dx	406	add ax, dx
408	mov ds, ax	407	mov ds, ax
409	pop ax	408	pop ax
410	shl cx, 11-4	409	shl cx, 11-4
411	sub cx, dx ; cx = number of paragraphs to be moved	410	sub cx, dx ; cx = number of paragraphs to be moved
412	push si	411	push si
413	xor si, si	412	xor si, si
414	; move cx paragraphs from ds:si to es:di to get free space in the end of cache	413	; move cx paragraphs from ds:si to es:di to get free space in the end of cache
415	@@:	414	@@:
416	sub cx, 1000h	415	sub cx, 1000h
417	jbe @f	416	jbe @f
418	push cx	417	push cx
419	mov cx, 8000h	418	mov cx, 8000h
420	rep movsw	419	rep movsw
421	mov cx, ds	420	mov cx, ds
422	add cx, 1000h	421	add cx, 1000h
423	mov ds, cx	422	mov ds, cx
424	mov cx, es	423	mov cx, es
425	add cx, 1000h	424	add cx, 1000h
426	mov es, cx	425	mov es, cx
427	pop cx	426	pop cx
428	jmp @b	427	jmp @b
429	@@:	428	@@:
430	add cx, 1000h	429	add cx, 1000h
431	shl cx, 3	430	shl cx, 3
432	rep movsw	431	rep movsw
433	pop si	432	pop si
434	pop ds	433	pop ds
435	; correct positions in cache for existing items	434	; correct positions in cache for existing items
436	mov cx, 80h	435	mov cx, 80h
437	mov di, 8400h	436	mov di, 8400h
438	.correct:	437	.correct:
439	cmp [di+10], dx	438	cmp [di+10], dx
440	jbe @f	439	jbe @f
441	sub [di+10], ax	440	sub [di+10], ax
442	@@:	441	@@:
443	add di, 12	442	add di, 12
444	loop .correct	443	loop .correct
445	; some additional space is free now	444	; some additional space is free now
446	pop ax	445	pop ax
447	add [size_rest], ax	446	add [size_rest], ax
448	sub [free_ptr], ax	447	sub [free_ptr], ax
449	; add cache item to the list of free items	448	; add cache item to the list of free items
450	mov dx, [bx]	449	mov dx, [bx]
451	mov ax, [free_cache_item]	450	mov ax, [free_cache_item]
452	mov [bx], ax	451	mov [bx], ax
453	mov [free_cache_item], bx	452	mov [free_cache_item], bx
454	mov bx, dx	453	mov bx, dx
455	; current iteration done	454	; current iteration done
456	popa	455	popa
457	jmp .freeloop	456	jmp .freeloop
458	.sizeok:	457	.sizeok:
459	mov [cachelist.head], bx	458	mov [cachelist.head], bx
460	mov word [bx+2], cachelist	459	mov word [bx+2], cachelist
461	; allocate new item in cache	460	; allocate new item in cache
462	mov di, [free_cache_item]	461	mov di, [free_cache_item]
463	test di, di	462	test di, di
464	jz .nofree	463	jz .nofree
465	push word [di]	464	push word [di]
466	pop [free_cache_item]	465	pop [free_cache_item]
467	jmp @f	466	jmp @f
468	.nofree:	467	.nofree:
469	mov di, [last_cache_item]	468	mov di, [last_cache_item]
470	add [last_cache_item], 12	469	add [last_cache_item], 12
471	@@:	470	@@:
472	pop bx	471	pop bx
473	push si di	472	push si di
474	; mov [di+4], eax ; start of folder	473	; mov [di+4], eax ; start of folder
475	scasd	474	scasd
476	stosd	475	stosd
477	push ax	476	push ax
478	mov ax, [free_ptr]	477	mov ax, [free_ptr]
479	shl ax, 11-4	478	shl ax, 11-4
480	mov [di+10-8], ax	479	mov [di+10-8], ax
481	mov es, ax	480	mov es, ax
482	pop ax	481	pop ax
483	add [free_ptr], cx	482	add [free_ptr], cx
484	sub [size_rest], cx	483	sub [size_rest], cx
485	; read folder data	484	; read folder data
486	; first sector is already in memory, 0000:bx	485	; first sector is already in memory, 0000:bx
487	pusha	486	pusha
488	mov cx, [bx+10]	487	mov cx, [bx+10]
489	mov [di+8-8], cx ; folder size in bytes	488	mov [di+8-8], cx ; folder size in bytes
490	mov si, bx	489	mov si, bx
491	xor di, di	490	xor di, di
492	mov cx, 0x1800	491	mov cx, 0x1800
493	sub cx, si	492	sub cx, si
494	rep movsb	493	rep movsb
495	pop ax	494	pop ax
496	push di	495	push di
497	popa	496	popa
498	; read rest of folder	497	; read rest of folder
499	mov esi, dword [lb_per_sec]	498	mov esi, dword [lb_per_sec]
500	add eax, esi	499	add eax, esi

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bootloader/extended_primary_loader/cdfs/bootsect.asm – Rev 2288 → 3598