WebSVN – Kolibri OS – Diff – /kernel/trunk/fs/xfs.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5089 $
 
 
include 'xfs.inc'
 
;
; This file contains XFS related code.
; For more information on XFS check sources below.
;
; 1. XFS Filesystem Structure, 2nd Edition, Revision 1. Silicon Graphics Inc. 2006
; 2. Linux source http://kernel.org
;
 
 
; test partition type (valid XFS one?)
; alloc and fill XFS (see xfs.inc) structure
; this function is called for each partition
; returns 0 (not XFS or invalid) / pointer to partition structure
xfs_create_partition:
        push    ebx ecx edx esi edi
        cmp     dword [esi+DISK.MediaInfo.SectorSize], 512
        jnz     .error
        cmp     dword[ebx + xfs_sb.sb_magicnum], XFS_SB_MAGIC   ; signature
        jne     .error
 
        ; TODO: check XFS.versionnum and XFS.features2
        ;       print superblock params for debugging (waiting for bug reports)
 
        movi    eax, sizeof.XFS
        call    malloc
        test    eax, eax
        jz      .error
 
        ; standard partition initialization, common for all file systems
 
        mov     edi, eax
        mov     eax, dword[ebp + PARTITION.FirstSector]
        mov     dword[edi + XFS.FirstSector], eax
        mov     eax, dword[ebp + PARTITION.FirstSector + 4]
        mov     dword[edi + XFS.FirstSector + 4], eax
        mov     eax, dword[ebp + PARTITION.Length]
        mov     dword[edi + XFS.Length], eax
        mov     eax, dword[ebp + PARTITION.Length + 4]
        mov     dword[edi + XFS.Length + 4], eax
        mov     eax, [ebp + PARTITION.Disk]
        mov     [edi + XFS.Disk], eax
        mov     [edi + XFS.FSUserFunctions], xfs_user_functions
 
        ; here we initialize only one mutex so far (for the entire partition)
        ; XFS potentially allows parallel r/w access to several AGs, keep it in mind for SMP times
 
        lea     ecx, [edi + XFS.Lock]
        call    mutex_init
 
        ; read superblock and fill just allocated XFS partition structure
 
        mov     eax, [ebx + xfs_sb.sb_blocksize]
        bswap   eax                                     ; XFS is big endian
        mov     [edi + XFS.blocksize], eax
        movzx   eax, word[ebx + xfs_sb.sb_sectsize]
        xchg    al, ah
        mov     [edi + XFS.sectsize], eax
        movzx   eax, word[ebx + xfs_sb.sb_versionnum]
        xchg    al, ah
        mov     [edi + XFS.versionnum], eax
        mov     eax, [ebx + xfs_sb.sb_features2]
        bswap   eax
        mov     [edi + XFS.features2], eax
        movzx   eax, word[ebx + xfs_sb.sb_inodesize]
        xchg    al, ah
        mov     [edi + XFS.inodesize], eax
        movzx   eax, word[ebx + xfs_sb.sb_inopblock]    ; inodes per block
        xchg    al, ah
        mov     [edi + XFS.inopblock], eax
        movzx   eax, byte[ebx + xfs_sb.sb_blocklog]     ; log2 of block size, in bytes
        mov     [edi + XFS.blocklog], eax
        movzx   eax, byte[ebx + xfs_sb.sb_sectlog]
        mov     [edi + XFS.sectlog], eax
        movzx   eax, byte[ebx + xfs_sb.sb_inodelog]
        mov     [edi + XFS.inodelog], eax
        movzx   eax, byte[ebx + xfs_sb.sb_inopblog]
        mov     [edi + XFS.inopblog], eax
        movzx   eax, byte[ebx + xfs_sb.sb_dirblklog]
        mov     [edi + XFS.dirblklog], eax
        mov     eax, dword[ebx + xfs_sb.sb_rootino + 4] ;
        bswap   eax                                     ; big
        mov     dword[edi + XFS.rootino + 0], eax       ; endian
        mov     eax, dword[ebx + xfs_sb.sb_rootino + 0] ; 64bit
        bswap   eax                                     ; number
        mov     dword[edi + XFS.rootino + 4], eax       ; 
 
        mov     eax, [edi + XFS.blocksize]
        mov     ecx, [edi + XFS.dirblklog]
        shl     eax, cl
        mov     [edi + XFS.dirblocksize], eax           ; blocks for files, dirblocks for directories
 
        ; sector is always smaller than block
        ; so precalculate shift order to allow faster sector_num->block_num conversion
 
        mov     ecx, [edi + XFS.blocklog]
        sub     ecx, [edi + XFS.sectlog]
        mov     [edi + XFS.blockmsectlog], ecx
 
        mov     eax, 1
        shl     eax, cl
        mov     [edi + XFS.sectpblock], eax
 
        ; shift order for inode_num->block_num conversion
 
        mov     eax, [edi + XFS.blocklog]
        sub     eax, [edi + XFS.inodelog]
        mov     [edi + XFS.inodetoblocklog], eax
 
        mov     eax, [ebx + xfs_sb.sb_agblocks]
        bswap   eax
        mov     [edi + XFS.agblocks], eax
        movzx   ecx, byte[ebx + xfs_sb.sb_agblklog]
        mov     [edi + XFS.agblklog], ecx
 
        ; get the mask for block numbers
        ; block numbers are AG relative!
        ; bitfield length may vary between partitions
 
        mov     eax, 1
        shl     eax, cl
        dec     eax
        mov     dword[edi + XFS.agblockmask + 0], eax
        mov     eax, 1
        sub     ecx, 32
        jc      @f
        shl     eax, cl
    @@:
        dec     eax
        mov     dword[edi + XFS.agblockmask + 4], eax
 
        ; calculate magic offsets for directories
 
        mov     ecx, [edi + XFS.blocklog]
        mov     eax, XFS_DIR2_LEAF_OFFSET AND 0xffffffff        ; lo
        mov     edx, XFS_DIR2_LEAF_OFFSET SHR 32                ; hi
        shrd    eax, edx, cl
        mov     [edi + XFS.dir2_leaf_offset_blocks], eax
 
        mov     ecx, [edi + XFS.blocklog]
        mov     eax, XFS_DIR2_FREE_OFFSET AND 0xffffffff        ; lo
        mov     edx, XFS_DIR2_FREE_OFFSET SHR 32                ; hi
        shrd    eax, edx, cl
        mov     [edi + XFS.dir2_free_offset_blocks], eax
 
;        mov     ecx, [edi + XFS.dirblklog]
;        mov     eax, [edi + XFS.blocksize]
;        shl     eax, cl
;        mov     [edi + XFS.dirblocksize], eax
 
        mov     eax, [edi + XFS.blocksize]
        call    malloc
        test    eax, eax
        jz      .error
        mov     [edi + XFS.cur_block], eax
 
        ; we do need XFS.blocksize bytes for single inode
        ; minimal file system structure is block, inodes are packed in blocks
 
        mov     eax, [edi + XFS.blocksize]
        call    malloc
        test    eax, eax
        jz      .error
        mov     [edi + XFS.cur_inode], eax
 
        ; temporary inode
        ; used for browsing directories
 
        mov     eax, [edi + XFS.blocksize]
        call    malloc
        test    eax, eax
        jz      .error
        mov     [edi + XFS.tmp_inode], eax
 
        ; current sector
        ; only for sector size structures like AGI
        ; inodes has usually the same size, but never store them here
 
        mov     eax, [edi + XFS.sectsize]
        call    malloc
        test    eax, eax
        jz      .error
        mov     [edi + XFS.cur_sect], eax
 
        ; current directory block
 
        mov     eax, [edi + XFS.dirblocksize]
        call    malloc
        test    eax, eax
        jz      .error
        mov     [edi + XFS.cur_dirblock], eax
 
  .quit:
        mov     eax, edi                ; return pointer to allocated XFS partition structure
        pop     edi esi edx ecx ebx
        ret
  .error:
        xor     eax, eax
        pop     edi esi edx ecx ebx
        ret
 
 
iglobal
align 4
xfs_user_functions:
        dd      xfs_free
        dd      (xfs_user_functions_end - xfs_user_functions - 4) / 4
        dd      xfs_Read
        dd      xfs_ReadFolder
        dd      0;xfs_Rewrite
        dd      0;xfs_Write
        dd      0;xfs_SetFileEnd
        dd      xfs_GetFileInfo
        dd      0;xfs_SetFileInfo
        dd      0
        dd      0;xfs_Delete
        dd      0;xfs_CreateFolder
xfs_user_functions_end:
endg
 
 
; lock partition access mutex
proc xfs_lock
;DEBUGF 1,"xfs_lock\n"
        lea     ecx, [ebp + XFS.Lock]
        jmp     mutex_lock
endp
 
 
; unlock partition access mutex
proc xfs_unlock
;DEBUGF 1,"xfs_unlock\n"
        lea     ecx, [ebp + XFS.Lock]
        jmp     mutex_unlock
endp
 
 
; free all the allocated memory
; called on partition destroy
proc xfs_free
        push    ebp
        xchg    ebp, eax
        stdcall kernel_free, [ebp + XFS.cur_block]
        stdcall kernel_free, [ebp + XFS.cur_inode]
        stdcall kernel_free, [ebp + XFS.cur_sect]
        stdcall kernel_free, [ebp + XFS.cur_dirblock]
        stdcall kernel_free, [ebp + XFS.tmp_inode]
        xchg    ebp, eax
        call    free
        pop     ebp
        ret
endp
 
 
;---------------------------------------------------------------
; block number (AG relative)
; eax -- inode_lo
; edx -- inode_hi
; ebx -- buffer
;---------------------------------------------------------------
xfs_read_block:
        push    ebx esi
 
        push    edx
        push    eax
 
        ; XFS block numbers are AG relative
        ; they come in bitfield form of concatenated AG and block numbers
        ; to get absolute block number for fs_read32_sys we should
        ; 1. extract AG number (using precalculated mask)
        ; 2. multiply it by the AG size in blocks
        ; 3. add AG relative block number
 
        ; 1.
        mov     ecx, [ebp + XFS.agblklog]
        shrd    eax, edx, cl
        shr     edx, cl
        ; 2.
        mul     dword[ebp + XFS.agblocks]
        pop     ecx
        pop     esi
        and     ecx, dword[ebp + XFS.agblockmask + 0]
        and     esi, dword[ebp + XFS.agblockmask + 4]
        ; 3.
        add     eax, ecx
        adc     edx, esi
 
;DEBUGF 1,"read block: 0x%x%x\n",edx,eax
        ; there is no way to read file system block at once, therefore we
        ; 1. calculate the number of sectors first
        ; 2. and then read them in series
 
        ; 1.
        mov     ecx, [ebp + XFS.blockmsectlog]
        shld    edx, eax, cl
        shl     eax, cl
        mov     esi, [ebp + XFS.sectpblock]
 
        ; 2.
  .next_sector:
        push    eax edx
        call    fs_read32_sys
        mov     ecx, eax
        pop     edx eax
        test    ecx, ecx
        jnz     .error
        add     eax, 1                          ; be ready to fs_read64_sys
        adc     edx, 0
        add     ebx, [ebp + XFS.sectsize]       ; update buffer offset
        dec     esi
        jnz     .next_sector
 
  .quit:
        xor     eax, eax
        pop     esi ebx
        ret
  .error:
        mov     eax, ecx
        pop     esi ebx
        ret
 
 
;---------------------------------------------------------------
; push buffer
; push startblock_hi
; push startblock_lo
; call xfs_read_dirblock
; test eax, eax
;---------------------------------------------------------------
xfs_read_dirblock:
;mov eax, [esp + 4]
;mov edx, [esp + 8]
;DEBUGF 1,"read dirblock at: %d %d\n",edx,eax
;DEBUGF 1,"dirblklog: %d\n",[ebp + XFS.dirblklog]
        push    ebx esi
 
        mov     eax, [esp + 12]         ; startblock_lo
        mov     edx, [esp + 16]         ; startblock_hi
        mov     ebx, [esp + 20]         ; buffer
 
        ; dirblock >= block
        ; read dirblocks by blocks
 
        mov     ecx, [ebp + XFS.dirblklog]
        mov     esi, 1
        shl     esi, cl
  .next_block:
        push    eax edx
        call    xfs_read_block
        mov     ecx, eax
        pop     edx eax
        test    ecx, ecx
        jnz     .error
        add     eax, 1          ; be ready to fs_read64_sys
        adc     edx, 0
        add     ebx, [ebp + XFS.blocksize]
        dec     esi
        jnz     .next_block
 
  .quit:
        xor     eax, eax
        pop     esi ebx
        ret     12
  .error:
        mov     eax, ecx
        pop     esi ebx
        ret     12
 
 
;---------------------------------------------------------------
; push buffer
; push inode_hi
; push inode_lo
; call xfs_read_inode
; test eax, eax
;---------------------------------------------------------------
xfs_read_inode:
;DEBUGF 1,"reading inode: 0x%x%x\n",[esp+8],[esp+4]
        push    ebx
        mov     eax, [esp + 8]  ; inode_lo
        mov     edx, [esp + 12] ; inode_hi
        mov     ebx, [esp + 16] ; buffer
 
        ; inodes are packed into blocks
        ; 1. calculate block number
        ; 2. read the block
        ; 3. add inode offset to block base address
 
        ; 1.
        mov     ecx, [ebp + XFS.inodetoblocklog]
        shrd    eax, edx, cl
        shr     edx, cl
        ; 2.
        call    xfs_read_block
        test    eax, eax
        jnz     .error
 
        ; note that inode numbers should be first extracted from bitfields using mask
 
        mov     eax, [esp + 8]
        mov     edx, 1
        mov     ecx, [ebp + XFS.inopblog]
        shl     edx, cl
        dec     edx             ; get inode number mask
        and     eax, edx        ; apply mask
        mov     ecx, [ebp + XFS.inodelog]
        shl     eax, cl
        add     ebx, eax
 
        cmp     word[ebx], XFS_DINODE_MAGIC     ; test signature
        jne     .error
  .quit:
        xor     eax, eax
        mov     edx, ebx
        pop     ebx
        ret     12
  .error:
        movi    eax, ERROR_FS_FAIL
        mov     edx, ebx
        pop     ebx
        ret     12
 
 
;----------------------------------------------------------------
; push encoding         ; ASCII / UNICODE
; push src              ; inode
; push dst              ; bdfe
; push entries_to_read
; push start_number     ; from 0
;----------------------------------------------------------------
xfs_dir_get_bdfes:
DEBUGF 1,"xfs_dir_get_bdfes: %d entries from %d\n",[esp+8],[esp+4]
        sub     esp, 4     ; local vars
        push    ecx edx esi edi
 
        mov     ebx, [esp + 36]         ; src
        mov     edx, [esp + 32]         ; dst
        mov     ecx, [esp + 24]         ; start_number
 
        ; define directory ondisk format and jump to corresponding label
 
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_LOCAL
        jne     .not_shortdir
        jmp     .shortdir
  .not_shortdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_blockdir
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        cmp     eax, 1
        jne     .not_blockdir
        jmp     .blockdir
  .not_blockdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_leafdir
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        cmp     eax, 4
        ja      .not_leafdir
        jmp     .leafdir
  .not_leafdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_nodedir
        jmp     .nodedir
  .not_nodedir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_BTREE
        jne     .not_btreedir
        jmp     .btreedir
  .not_btreedir:
        movi    eax, ERROR_FS_FAIL
        jmp     .error
 
        ; short form directory (all the data fits into inode)
  .shortdir:
;DEBUGF 1,"shortdir\n",
        movzx   eax, word[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count]
        test    al, al                  ; is count zero?
        jnz     @f                      ; if not, use it (i8count must be zero then)
        shr     eax, 8                  ; use i8count
    @@:
        add     eax, 1                  ; '..' and '.' are implicit
        mov     dword[edx + 0], 1       ; version
        mov     [edx + 8], eax          ; total entries
        sub     eax, [esp + 24]         ; start number
        cmp     eax, [esp + 28]         ; entries to read
        jbe     @f
        mov     eax, [esp + 28]
    @@:
        mov     [esp + 28], eax
        mov     [edx + 4], eax          ; number of actually read entries
        mov     [ebp + XFS.entries_read], eax
 
        ; inode numbers are often saved as 4 bytes (iff they fit)
        ; compute the length of inode numbers
 
        mov     eax, 4          ; 4 by default
        cmp     byte[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.i8count], 0
        je      @f
        add     eax, eax        ; 4+4=8, iff i8count != 0
    @@:
        mov     dword[edx + 12], 0      ; reserved
        mov     dword[edx + 16], 0      ; 
        mov     dword[edx + 20], 0      ; 
        mov     dword[edx + 24], 0      ; 
        mov     dword[edx + 28], 0      ; 
        add     edx, 32
        lea     esi, [ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.parent + eax]
        dec     ecx
        js      .shortdir.fill
 
        ; skip some entries if the first entry to read is not 0
 
  .shortdir.skip:
        test    ecx, ecx
        jz      .shortdir.skipped
        movzx   edi, byte[esi + xfs_dir2_sf_entry.namelen]
        lea     esi, [esi + xfs_dir2_sf_entry.name + edi]
        add     esi, eax
        dec     ecx
        jnz     .shortdir.skip
        mov     ecx, [esp + 28]         ; entries to read
        jmp     .shortdir.skipped
  .shortdir.fill:
        mov     ecx, [esp + 28]         ; total number
        test    ecx, ecx
        jz      .quit
        push    ecx
;DEBUGF 1,"ecx: %d\n",ecx
        lea     edi, [edx + 40]         ; get file name offset
;DEBUGF 1,"filename: ..\n"
        mov     dword[edi], '..'
        mov     edi, edx
        push    eax ebx edx esi
        stdcall xfs_get_inode_number_sf, dword[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count], dword[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.parent + 4], dword[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.parent]
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.tmp_inode]
;        test    eax, eax
;        jnz     .error
        stdcall xfs_get_inode_info, edx, edi
        test    eax, eax
        pop     esi edx ebx eax
        jnz     .error
        mov     ecx, [esp + 44]         ; file name encding
        mov     [edx + 4], ecx
        add     edx, 304                ; ASCII only for now
        pop     ecx
        dec     ecx
        jz      .quit
 
;        push    ecx
;        lea     edi, [edx + 40]
;DEBUGF 1,"filename: .\n"
;        mov     dword[edi], '.'
;        mov     edi, edx
;        push    eax edx
;        stdcall xfs_get_inode_info, [ebp + XFS.cur_inode], edi
;        test    eax, eax
;        pop     edx eax
;        jnz     .error
;        mov     ecx, [esp + 44]
;        mov     [edx + 4], ecx
;        add     edx, 304                ; ASCII only for now
;        pop     ecx
;        dec     ecx
;        jz      .quit
 
        ; we skipped some entries
        ; now we fill min(required, present) number of bdfe's
 
  .shortdir.skipped:
;DEBUGF 1,"ecx: %d\n",ecx
        push    ecx
        movzx   ecx, byte[esi + xfs_dir2_sf_entry.namelen]
        add     esi, xfs_dir2_sf_entry.name
        lea     edi, [edx + 40]         ; bdfe offset of file name
;DEBUGF 1,"filename: |%s|\n",esi
        rep movsb
        mov     word[edi], 0            ; terminator (ASCIIZ)
 
        push    eax ebx ecx edx esi
;        push    edx     ; for xfs_get_inode_info
        mov     edi, edx
        stdcall xfs_get_inode_number_sf, dword[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count], [esi + 4], [esi]
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.tmp_inode]
;        test    eax, eax
;        jnz     .error
        stdcall xfs_get_inode_info, edx, edi
        test    eax, eax
        pop     esi edx ecx ebx eax
        jnz     .error
        mov     ecx, [esp + 44]         ; file name encoding
        mov     [edx + 4], ecx
 
        add     edx, 304                ; ASCII only for now
        add     esi, eax
        pop     ecx
        dec     ecx
        jnz     .shortdir.skipped
        jmp     .quit
 
  .blockdir:
;DEBUGF 1,"blockdir\n"
        push    edx
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        stdcall xfs_extent_unpack, eax
;DEBUGF 1,"extent.br_startoff  : 0x%x%x\n",[ebp+XFS.extent.br_startoff+4],[ebp+XFS.extent.br_startoff+0]
;DEBUGF 1,"extent.br_startblock: 0x%x%x\n",[ebp+XFS.extent.br_startblock+4],[ebp+XFS.extent.br_startblock+0]
;DEBUGF 1,"extent.br_blockcount: %d\n",[ebp+XFS.extent.br_blockcount]
;DEBUGF 1,"extent.br_state     : %d\n",[ebp+XFS.extent.br_state]
        stdcall xfs_read_dirblock, dword[ebp + XFS.extent.br_startblock + 0], dword[ebp + XFS.extent.br_startblock + 4], [ebp + XFS.cur_dirblock]
        test    eax, eax
        pop     edx
        jnz     .error
;DEBUGF 1,"dirblock signature: %s\n",[ebp+XFS.cur_dirblock]
        mov     ebx, [ebp + XFS.cur_dirblock]
        mov     dword[edx + 0], 1       ; version
        mov     eax, [ebp + XFS.dirblocksize]
        mov     ecx, [ebx + eax - sizeof.xfs_dir2_block_tail + xfs_dir2_block_tail.stale]
        mov     eax, [ebx + eax - sizeof.xfs_dir2_block_tail + xfs_dir2_block_tail.count]
        bswap   ecx
        bswap   eax
        sub     eax, ecx                ; actual number of entries = count - stale
        mov     [edx + 8], eax          ; total entries
;DEBUGF 1,"total entries: %d\n",eax
        sub     eax, [esp + 24]         ; start number
        cmp     eax, [esp + 28]         ; entries to read
        jbe     @f
        mov     eax, [esp + 28]
    @@:
        mov     [esp + 28], eax
        mov     [edx + 4], eax          ; number of actually read entries
        mov     [ebp + XFS.entries_read], eax
;DEBUGF 1,"actually read entries: %d\n",eax
        mov     dword[edx + 12], 0      ; reserved
        mov     dword[edx + 16], 0      ; 
        mov     dword[edx + 20], 0      ; 
        mov     dword[edx + 24], 0      ; 
        mov     dword[edx + 28], 0      ; 
        add     ebx, xfs_dir2_block.u
 
        mov     ecx, [esp + 24]         ; start entry number
                                        ; also means how many to skip
        test    ecx, ecx
        jz      .blockdir.skipped
  .blockdir.skip:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_DIR2_DATA_FREE_TAG
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .blockdir.skip
    @@:
        movzx   eax, [ebx + xfs_dir2_data_union.xentry.namelen]
        lea     ebx, [ebx + xfs_dir2_data_union.xentry.name + eax + 2]       ; 2 bytes for 'tag'
        add     ebx, 7                  ; align on 8 bytes
        and     ebx, not 7
        dec     ecx
        jnz     .blockdir.skip
  .blockdir.skipped:
        mov     ecx, [edx + 4]          ; actually read entries
        test    ecx, ecx
        jz      .quit
        add     edx, 32                 ; set edx to the first bdfe
  .blockdir.next_entry:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_NULL
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .blockdir.next_entry
    @@:
        push    ecx
        push    eax ebx ecx edx esi
        mov     edi, edx
        mov     edx, dword[ebx + xfs_dir2_data_union.xentry.inumber + 0]
        mov     eax, dword[ebx + xfs_dir2_data_union.xentry.inumber + 4]
        bswap   edx
        bswap   eax
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.tmp_inode]
        stdcall xfs_get_inode_info, edx, edi
        test    eax, eax
        pop     esi edx ecx ebx eax
        jnz     .error
        mov     ecx, [esp + 44]
        mov     [edx + 4], ecx
        lea     edi, [edx + 40]
        movzx   ecx, byte[ebx + xfs_dir2_data_union.xentry.namelen]
        lea     esi, [ebx + xfs_dir2_data_union.xentry.name]
;DEBUGF 1,"filename: |%s|\n",esi
        rep movsb
;        call    utf8_to_cp866
        mov     word[edi], 0            ; terminator
        lea     ebx, [esi + 2]          ; skip 'tag'
        add     ebx, 7                  ; xfs_dir2_data_entries are aligned to 8 bytes
        and     ebx, not 7
        add     edx, 304
        pop     ecx
        dec     ecx
        jnz     .blockdir.next_entry
        jmp     .quit
 
  .leafdir:
;DEBUGF 1,"readdir: leaf\n"
        mov     [ebp + XFS.cur_inode_save], ebx
        push    ebx ecx edx
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, [ebp + XFS.dir2_leaf_offset_blocks], 0, edx, 0xffffffff, 0xffffffff
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        pop     edx ecx ebx
        jz      .error
 
        mov     eax, [ebp + XFS.cur_dirblock]
        movzx   ecx, word[eax + xfs_dir2_leaf.hdr.stale]
        movzx   eax, word[eax + xfs_dir2_leaf.hdr.count]
        xchg    cl, ch
        xchg    al, ah
        sub     eax, ecx
;DEBUGF 1,"total count: %d\n",eax
 
        mov     dword[edx + 0], 1       ; version
        mov     [edx + 8], eax          ; total entries
        sub     eax, [esp + 24]         ; start number
        cmp     eax, [esp + 28]         ; entries to read
        jbe     @f
        mov     eax, [esp + 28]
    @@:
        mov     [esp + 28], eax
        mov     [edx + 4], eax          ; number of actually read entries
 
        mov     dword[edx + 12], 0      ; reserved
        mov     dword[edx + 16], 0      ; 
        mov     dword[edx + 20], 0      ; 
        mov     dword[edx + 24], 0      ; 
        mov     dword[edx + 28], 0      ; 
 
        mov     eax, [ebp + XFS.cur_dirblock]
        add     eax, [ebp + XFS.dirblocksize]
        mov     [ebp + XFS.max_dirblockaddr], eax
        mov     dword[ebp + XFS.next_block_num + 0], 0
        mov     dword[ebp + XFS.next_block_num + 4], 0
 
        mov     ebx, [ebp + XFS.max_dirblockaddr]       ; to read dirblock immediately
        mov     ecx, [esp + 24]         ; start number
        test    ecx, ecx
        jz      .leafdir.skipped
  .leafdir.skip:
        cmp     ebx, [ebp + XFS.max_dirblockaddr]
        jne     @f
        push    ecx edx
        mov     ebx, [ebp + XFS.cur_inode_save]
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, dword[ebp + XFS.next_block_num + 0], dword[ebp + XFS.next_block_num + 4], edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
        add     eax, 1
        adc     edx, 0
        mov     dword[ebp + XFS.next_block_num + 0], eax
        mov     dword[ebp + XFS.next_block_num + 4], edx
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, sizeof.xfs_dir2_data_hdr
        pop     edx ecx
    @@:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_DIR2_DATA_FREE_TAG
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .leafdir.skip
    @@:
        movzx   eax, [ebx + xfs_dir2_data_union.xentry.namelen]
        lea     ebx, [ebx + xfs_dir2_data_union.xentry.name + eax + 2]       ; 2 for 'tag'
        add     ebx, 7
        and     ebx, not 7
        dec     ecx
        jnz     .leafdir.skip
  .leafdir.skipped:
        mov     [ebp + XFS.entries_read], 0
        mov     ecx, [edx + 4]          ; actually read entries
        test    ecx, ecx
        jz      .quit
        add     edx, 32                 ; first bdfe entry
  .leafdir.next_entry:
;DEBUGF 1,"next_extry\n"
        cmp     ebx, [ebp + XFS.max_dirblockaddr]
        jne     .leafdir.process_current_block
        push    ecx edx
        mov     ebx, [ebp + XFS.cur_inode_save]
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, dword[ebp + XFS.next_block_num + 0], dword[ebp + XFS.next_block_num + 4], edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jnz     @f
        pop     edx ecx
        jmp     .quit
    @@:
        add     eax, 1
        adc     edx, 0
        mov     dword[ebp + XFS.next_block_num + 0], eax
        mov     dword[ebp + XFS.next_block_num + 4], edx
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, sizeof.xfs_dir2_data_hdr
        pop     edx ecx
  .leafdir.process_current_block:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_DIR2_DATA_FREE_TAG
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .leafdir.next_entry
    @@:
        push    eax ebx ecx edx esi
        mov     edi, edx
        mov     edx, dword[ebx + xfs_dir2_data_union.xentry.inumber + 0]
        mov     eax, dword[ebx + xfs_dir2_data_union.xentry.inumber + 4]
        bswap   edx
        bswap   eax
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.tmp_inode]
        stdcall xfs_get_inode_info, edx, edi
        test    eax, eax
        pop     esi edx ecx ebx eax
        jnz     .error
        push    ecx
        mov     ecx, [esp + 44]
        mov     [edx + 4], ecx
        lea     edi, [edx + 40]
        movzx   ecx, byte[ebx + xfs_dir2_data_union.xentry.namelen]
        lea     esi, [ebx + xfs_dir2_data_union.xentry.name]
;DEBUGF 1,"filename: |%s|\n",esi
        rep movsb
        pop     ecx
        mov     word[edi], 0
        lea     ebx, [esi + 2]  ; skip 'tag'
        add     ebx, 7          ; xfs_dir2_data_entries are aligned to 8 bytes
        and     ebx, not 7
        add     edx, 304        ; ASCII only for now
        inc     [ebp + XFS.entries_read]
        dec     ecx
        jnz     .leafdir.next_entry
        jmp     .quit
 
  .nodedir:
;DEBUGF 1,"readdir: node\n"
        push    edx
        mov     [ebp + XFS.cur_inode_save], ebx
        mov     [ebp + XFS.entries_read], 0
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_dir2_node_get_numfiles, eax, edx, [ebp + XFS.dir2_leaf_offset_blocks]
        pop     edx
        test    eax, eax
        jnz     .error
        mov     eax, [ebp + XFS.entries_read]
        mov     [ebp + XFS.entries_read], 0
;DEBUGF 1,"numfiles: %d\n",eax
        mov     dword[edx + 0], 1       ; version
        mov     [edx + 8], eax          ; total entries
        sub     eax, [esp + 24]         ; start number
        cmp     eax, [esp + 28]         ; entries to read
        jbe     @f
        mov     eax, [esp + 28]
    @@:
        mov     [esp + 28], eax
        mov     [edx + 4], eax          ; number of actually read entries
 
        mov     dword[edx + 12], 0      ; reserved
        mov     dword[edx + 16], 0      ; 
        mov     dword[edx + 20], 0      ; 
        mov     dword[edx + 24], 0      ; 
        mov     dword[edx + 28], 0      ; 
 
        mov     eax, [ebp + XFS.cur_dirblock]
        add     eax, [ebp + XFS.dirblocksize]
        mov     [ebp + XFS.max_dirblockaddr], eax
        mov     dword[ebp + XFS.next_block_num + 0], 0
        mov     dword[ebp + XFS.next_block_num + 4], 0
 
        mov     ebx, [ebp + XFS.max_dirblockaddr]       ; to read dirblock immediately
        mov     ecx, [esp + 24]         ; start number
        test    ecx, ecx
        jz      .leafdir.skipped
        jmp     .leafdir.skip
 
  .btreedir:
;DEBUGF 1,"readdir: btree\n"
        mov     [ebp + XFS.cur_inode_save], ebx
        push    ebx edx
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        mov     [ebp + XFS.ro_nextents], eax
        mov     eax, [ebp + XFS.inodesize]
        sub     eax, xfs_inode.di_u
        sub     eax, sizeof.xfs_bmdr_block
        shr     eax, 4
;DEBUGF 1,"maxnumresc: %d\n",eax
        mov     edx, dword[ebx + xfs_inode.di_u + sizeof.xfs_bmdr_block + sizeof.xfs_bmbt_key*eax + 0]
        mov     eax, dword[ebx + xfs_inode.di_u + sizeof.xfs_bmdr_block + sizeof.xfs_bmbt_key*eax + 4]
        bswap   eax
        bswap   edx
        mov     ebx, [ebp + XFS.cur_block]
;DEBUGF 1,"read_block: %x %x ",edx,eax
        stdcall xfs_read_block
        pop     edx ebx
        test    eax, eax
        jnz     .error
;DEBUGF 1,"ok\n"
 
        mov     ebx, [ebp + XFS.cur_block]
        push    edx
        mov     [ebp + XFS.entries_read], 0
        lea     eax, [ebx + sizeof.xfs_bmbt_block]
        mov     edx, [ebp + XFS.ro_nextents]
        stdcall xfs_dir2_node_get_numfiles, eax, edx, [ebp + XFS.dir2_leaf_offset_blocks]
        pop     edx
        test    eax, eax
        jnz     .error
        mov     eax, [ebp + XFS.entries_read]
        mov     [ebp + XFS.entries_read], 0
;DEBUGF 1,"numfiles: %d\n",eax
 
        mov     dword[edx + 0], 1       ; version
        mov     [edx + 8], eax          ; total entries
        sub     eax, [esp + 24]         ; start number
        cmp     eax, [esp + 28]         ; entries to read
        jbe     @f
        mov     eax, [esp + 28]
    @@:
        mov     [esp + 28], eax
        mov     [edx + 4], eax          ; number of actually read entries
 
        mov     dword[edx + 12], 0
        mov     dword[edx + 16], 0
        mov     dword[edx + 20], 0
        mov     dword[edx + 24], 0
        mov     dword[edx + 28], 0
 
        mov     eax, [ebp + XFS.cur_dirblock]   ; fsblock?
        add     eax, [ebp + XFS.dirblocksize]
        mov     [ebp + XFS.max_dirblockaddr], eax
        mov     dword[ebp + XFS.next_block_num + 0], 0
        mov     dword[ebp + XFS.next_block_num + 4], 0
 
        mov     ebx, [ebp + XFS.max_dirblockaddr]       ; to read dirblock immediately
        mov     ecx, [esp + 24]         ; start number
        test    ecx, ecx
        jz      .btreedir.skipped
;        jmp     .btreedir.skip
  .btreedir.skip:
        cmp     ebx, [ebp + XFS.max_dirblockaddr]
        jne     @f
        push    ecx edx
        mov     ebx, [ebp + XFS.cur_block]
        lea     eax, [ebx + sizeof.xfs_bmbt_block]
        mov     edx, [ebp + XFS.ro_nextents]
        stdcall xfs_extent_list_read_dirblock, eax, dword[ebp + XFS.next_block_num + 0], dword[ebp + XFS.next_block_num + 4], edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
        add     eax, 1
        adc     edx, 0
        mov     dword[ebp + XFS.next_block_num + 0], eax
        mov     dword[ebp + XFS.next_block_num + 4], edx
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, sizeof.xfs_dir2_data_hdr
        pop     edx ecx
    @@:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_DIR2_DATA_FREE_TAG
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .btreedir.skip
    @@:
        movzx   eax, [ebx + xfs_dir2_data_union.xentry.namelen]
        lea     ebx, [ebx + xfs_dir2_data_union.xentry.name + eax + 2]       ; 2 for 'tag'
        add     ebx, 7
        and     ebx, not 7
        dec     ecx
        jnz     .btreedir.skip
  .btreedir.skipped:
        mov     [ebp + XFS.entries_read], 0
        mov     ecx, [edx + 4]          ; actually read entries
        test    ecx, ecx
        jz      .quit
        add     edx, 32
  .btreedir.next_entry:
;mov eax, [ebp + XFS.entries_read]
;DEBUGF 1,"next_extry: %d\n",eax
        cmp     ebx, [ebp + XFS.max_dirblockaddr]
        jne     .btreedir.process_current_block
        push    ecx edx
        mov     ebx, [ebp + XFS.cur_block]
        lea     eax, [ebx + sizeof.xfs_bmbt_block]
        mov     edx, [ebp + XFS.ro_nextents]
        stdcall xfs_extent_list_read_dirblock, eax, dword[ebp + XFS.next_block_num + 0], dword[ebp + XFS.next_block_num + 4], edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jnz     @f
        pop     edx ecx
        jmp     .quit
    @@:
        add     eax, 1
        adc     edx, 0
        mov     dword[ebp + XFS.next_block_num + 0], eax
        mov     dword[ebp + XFS.next_block_num + 4], edx
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, sizeof.xfs_dir2_data_hdr
        pop     edx ecx
  .btreedir.process_current_block:
        cmp     word[ebx + xfs_dir2_data_union.unused.freetag], XFS_DIR2_DATA_FREE_TAG
        jne     @f
        movzx   eax, word[ebx + xfs_dir2_data_union.unused.length]
        xchg    al, ah
        add     ebx, eax
        jmp     .btreedir.next_entry
    @@:
        push    eax ebx ecx edx esi
        mov     edi, edx
        mov     edx, dword[ebx + xfs_dir2_data_union.xentry.inumber + 0]
        mov     eax, dword[ebx + xfs_dir2_data_union.xentry.inumber + 4]
        bswap   edx
        bswap   eax
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.tmp_inode]
        stdcall xfs_get_inode_info, edx, edi
        test    eax, eax
        pop     esi edx ecx ebx eax
        jnz     .error
        push    ecx
        mov     ecx, [esp + 44]
        mov     [edx + 4], ecx
        lea     edi, [edx + 40]
        movzx   ecx, byte[ebx + xfs_dir2_data_union.xentry.namelen]
        lea     esi, [ebx + xfs_dir2_data_union.xentry.name]
;DEBUGF 1,"filename: |%s|\n",esi
        rep movsb
        pop     ecx
        mov     word[edi], 0
        lea     ebx, [esi + 2]  ; skip 'tag'
        add     ebx, 7          ; xfs_dir2_data_entries are aligned to 8 bytes
        and     ebx, not 7
        add     edx, 304
        inc     [ebp + XFS.entries_read]
        dec     ecx
        jnz     .btreedir.next_entry
        jmp     .quit
 
 
  .quit:
        pop     edi esi edx ecx
        add     esp, 4  ; pop vars
        xor     eax, eax
;        mov     ebx, [esp + 8]
        mov     ebx, [ebp + XFS.entries_read]
DEBUGF 1,"xfs_dir_get_bdfes done: %d\n",ebx
        ret     20
  .error:
        pop     edi esi edx ecx
        add     esp, 4  ; pop vars
        mov     eax, ERROR_FS_FAIL
        movi    ebx, -1
        ret     20
 
 
;----------------------------------------------------------------
; push inode_hi
; push inode_lo
; push name
;----------------------------------------------------------------
xfs_get_inode_short:
        ; this function searches for the file in _current_ dir
        ; it is called recursively for all the subdirs /path/to/my/file
 
;DEBUGF 1,"xfs_get_inode_short: %s\n",[esp+4]
        mov     esi, [esp + 4]  ; name
        movzx   eax, word[esi]
        cmp     eax, '.'        ; current dir; it is already read, just return
        je      .quit
        cmp     eax, './'       ; same thing
        je      .quit
 
        ; read inode
 
        mov     eax, [esp + 8]  ; inode_lo
        mov     edx, [esp + 12] ; inode_hi
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.cur_inode]
        test    eax, eax
        movi    eax, ERROR_FS_FAIL
        jnz     .error
 
        ; find file name in directory
        ; switch directory ondisk format
 
        mov     ebx, edx
        mov     [ebp + XFS.cur_inode_save], ebx
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_LOCAL
        jne     .not_shortdir
;DEBUGF 1,"dir: shortdir\n"
        jmp     .shortdir
  .not_shortdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_blockdir
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        cmp     eax, 1
        jne     .not_blockdir
        jmp     .blockdir
  .not_blockdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_leafdir
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        cmp     eax, 4
        ja      .not_leafdir
        jmp     .leafdir
  .not_leafdir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_nodedir
        jmp     .nodedir
  .not_nodedir:
        cmp     byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_BTREE
        jne     .not_btreedir
        jmp     .btreedir
  .not_btreedir:
DEBUGF 1,"NOT IMPLEMENTED: DIR FORMAT\n"
        jmp     .error
 
  .shortdir:
  .shortdir.check_parent:
        ; parent inode number in shortform directories is always implicit, check this case
        mov     eax, [esi]
        and     eax, 0x00ffffff
        cmp     eax, '..'
        je      .shortdir.parent2
        cmp     eax, '../'
        je      .shortdir.parent3
        jmp     .shortdir.common
  .shortdir.parent3:
        inc     esi
  .shortdir.parent2:
        add     esi, 2
        add     ebx, xfs_inode.di_u
        stdcall xfs_get_inode_number_sf, dword[ebx + xfs_dir2_sf_hdr.count], dword[ebx + xfs_dir2_sf_hdr.parent + 4], dword[ebx + xfs_dir2_sf_hdr.parent]
;DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
        ; not a parent inode?
        ; search in the list, all the other files are stored uniformly
 
  .shortdir.common:
        mov     eax, 4
        movzx   edx, word[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count] ; read count (byte) and i8count (byte) at once
        test    dl, dl          ; is count zero?
        jnz     @f
        shr     edx, 8          ; use i8count
        add     eax, eax        ; inode_num size
    @@:
        lea     edi, [ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.parent + eax]
 
  .next_name:
        movzx   ecx, byte[edi + xfs_dir2_sf_entry.namelen]
        add     edi, xfs_dir2_sf_entry.name
        mov     esi, [esp + 4]
;DEBUGF 1,"esi: %s\n",esi
;DEBUGF 1,"edi: %s\n",edi
        repe cmpsb
        jne     @f
        cmp     byte[esi], 0            ; HINT: use adc here?
        je      .found
        cmp     byte[esi], '/'
        je      .found_inc
    @@:
        add     edi, ecx
        add     edi, eax
        dec     edx
        jnz     .next_name
        movi    eax, ERROR_FILE_NOT_FOUND
        jmp     .error
  .found_inc:           ; increment esi to skip '/' symbol
                        ; this means esi always points to valid file name or zero terminator byte
        inc     esi
  .found:
        stdcall xfs_get_inode_number_sf, dword[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count], [edi + 4], [edi]
;DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
  .blockdir:
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        stdcall xfs_extent_unpack, eax
        stdcall xfs_read_dirblock, dword[ebp + XFS.extent.br_startblock + 0], dword[ebp + XFS.extent.br_startblock + 4], [ebp + XFS.cur_dirblock]
        test    eax, eax
        jnz     .error
;DEBUGF 1,"dirblock signature: %s\n",[ebp+XFS.cur_dirblock]
        mov     ebx, [ebp + XFS.cur_dirblock]
        mov     eax, [ebp + XFS.dirblocksize]
        mov     eax, [ebx + eax - sizeof.xfs_dir2_block_tail + xfs_dir2_block_tail.count]
        ; note that we don't subtract xfs_dir2_block_tail.stale here,
        ; since we need the number of leaf entries rather than file number
        bswap   eax
        add     ebx, [ebp + XFS.dirblocksize]
;        mov     ecx, sizeof.xfs_dir2_leaf_entry
        imul    ecx, eax, sizeof.xfs_dir2_leaf_entry
        sub     ebx, sizeof.xfs_dir2_block_tail
        sub     ebx, ecx
        shr     ecx, 3
        push    ecx     ; for xfs_get_inode_by_hash
        push    ebx     ; for xfs_get_inode_by_hash
 
        mov     edi, esi
        xor     eax, eax
        mov     ecx, 4096       ; MAX_PATH_LEN
        repne scasb
        movi    eax, ERROR_FS_FAIL
        jne     .error
        neg     ecx
        add     ecx, 4096       ; MAX_PATH_LEN
        dec     ecx
        mov     edx, ecx
;DEBUGF 1,"strlen total  : %d\n",edx
        mov     edi, esi
        mov     eax, '/'
        mov     ecx, edx
        repne scasb
        jne     @f
        inc     ecx
    @@:
        neg     ecx
        add     ecx, edx
;DEBUGF 1,"strlen current: %d\n",ecx
        stdcall xfs_hashname, esi, ecx
        add     esi, ecx
        cmp     byte[esi], '/'
        jne     @f
        inc     esi
    @@:
;DEBUGF 1,"hashed: 0x%x\n",eax
;        bswap   eax
        stdcall xfs_get_addr_by_hash
        bswap   eax
;DEBUGF 1,"got address: 0x%x\n",eax
        cmp     eax, -1
        jne     @f
        movi    eax, ERROR_FILE_NOT_FOUND
        mov     ebx, -1
        jmp     .error
    @@:
        shl     eax, 3
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, eax
        mov     edx, [ebx + 0]
        mov     eax, [ebx + 4]
        bswap   edx
        bswap   eax
;DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
  .leafdir:
;DEBUGF 1,"dirblock signature: %s\n",[ebp+XFS.cur_dirblock]
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, [ebp + XFS.dir2_leaf_offset_blocks], 0, edx, -1, -1
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
 
        mov     ebx, [ebp + XFS.cur_dirblock]
        movzx   eax, [ebx + xfs_dir2_leaf.hdr.count]
        ; note that we don't subtract xfs_dir2_leaf.hdr.stale here,
        ; since we need the number of leaf entries rather than file number
        xchg    al, ah
        add     ebx, xfs_dir2_leaf.ents
;        imul    ecx, eax, sizeof.xfs_dir2_leaf_entry
;        shr     ecx, 3
        push    eax     ; for xfs_get_addr_by_hash: len
        push    ebx     ; for xfs_get_addr_by_hash: base
 
        mov     edi, esi
        xor     eax, eax
        mov     ecx, 4096       ; MAX_PATH_LEN
        repne scasb
        movi    eax, ERROR_FS_FAIL
        jne     .error
        neg     ecx
        add     ecx, 4096
        dec     ecx
        mov     edx, ecx
;DEBUGF 1,"strlen total  : %d\n",edx
        mov     edi, esi
        mov     eax, '/'
        mov     ecx, edx
        repne scasb
        jne     @f
        inc     ecx
    @@:
        neg     ecx
        add     ecx, edx
;DEBUGF 1,"strlen current: %d\n",ecx
        stdcall xfs_hashname, esi, ecx
        add     esi, ecx
        cmp     byte[esi], '/'
        jne     @f
        inc     esi
    @@:
;DEBUGF 1,"hashed: 0x%x\n",eax
        stdcall xfs_get_addr_by_hash
        bswap   eax
;DEBUGF 1,"got address: 0x%x\n",eax
        cmp     eax, -1
        jne     @f
        movi    eax, ERROR_FILE_NOT_FOUND
        mov     ebx, -1
        jmp     .error
    @@:
 
        mov     ebx, [ebp + XFS.cur_inode_save]
        push    esi edi
        xor     edi, edi
        mov     esi, eax
        shld    edi, esi, 3     ; get offset
        shl     esi, 3          ; 2^3 = 8 byte align
        mov     edx, esi
        mov     ecx, [ebp + XFS.dirblklog]
        add     ecx, [ebp + XFS.blocklog]
        mov     eax, 1
        shl     eax, cl
        dec     eax
        and     edx, eax
        push    edx
        shrd    esi, edi, cl
        shr     edi, cl
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, esi, edi, edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        pop     edx
        pop     edi esi
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
 
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, edx
        mov     edx, [ebx + 0]
        mov     eax, [ebx + 4]
        bswap   edx
        bswap   eax
;DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
  .nodedir:
;DEBUGF 1,"lookupdir: node\n"
        mov     [ebp + XFS.cur_inode_save], ebx
 
        mov     edi, esi
        xor     eax, eax
        mov     ecx, 4096       ; MAX_PATH_LEN
        repne scasb
        movi    eax, ERROR_FS_FAIL
        jne     .error
        neg     ecx
        add     ecx, 4096       ; MAX_PATH_LEN
        dec     ecx
        mov     edx, ecx
;DEBUGF 1,"strlen total  : %d\n",edx
        mov     edi, esi
        mov     eax, '/'
        mov     ecx, edx
        repne scasb
        jne     @f
        inc     ecx
    @@:
        neg     ecx
        add     ecx, edx
;DEBUGF 1,"strlen current: %d\n",ecx
        stdcall xfs_hashname, esi, ecx
        add     esi, ecx
        cmp     byte[esi], '/'
        jne     @f
        inc     esi
    @@:
;DEBUGF 1,"hashed: 0x%x\n",eax
        push    edi edx
        mov     edi, eax
        mov     [ebp + XFS.entries_read], 0
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_dir2_lookupdir_node, eax, edx, [ebp + XFS.dir2_leaf_offset_blocks], edi
        pop     edx edi
        test    eax, eax
        jnz     .error
        bswap   ecx
;DEBUGF 1,"got address: 0x%x\n",ecx
 
        mov     ebx, [ebp + XFS.cur_inode_save]
        push    esi edi
        xor     edi, edi
        mov     esi, ecx
        shld    edi, esi, 3     ; get offset
        shl     esi, 3          ; 8 byte align
        mov     edx, esi
        mov     ecx, [ebp + XFS.dirblklog]
        add     ecx, [ebp + XFS.blocklog]
        mov     eax, 1
        shl     eax, cl
        dec     eax
        and     edx, eax
        push    edx
        shrd    esi, edi, cl
        shr     edi, cl
        lea     eax, [ebx + xfs_inode.di_u + xfs_bmbt_rec.l0]
        mov     edx, [ebx + xfs_inode.di_core.di_nextents]
        bswap   edx
        stdcall xfs_extent_list_read_dirblock, eax, esi, edi, edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        pop     edx
        pop     edi esi
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
 
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, edx
        mov     edx, [ebx + 0]
        mov     eax, [ebx + 4]
        bswap   edx
        bswap   eax
;DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
  .btreedir:
DEBUGF 1,"lookupdir: btree\n"
        mov     [ebp + XFS.cur_inode_save], ebx
 
        push    ebx edx
        mov     eax, [ebx + xfs_inode.di_core.di_nextents]
        bswap   eax
        mov     [ebp + XFS.ro_nextents], eax
        mov     eax, [ebp + XFS.inodesize]
        sub     eax, xfs_inode.di_u
        sub     eax, sizeof.xfs_bmdr_block
        shr     eax, 4  ; FIXME forkoff
;DEBUGF 1,"maxnumresc: %d\n",eax
        mov     edx, dword[ebx + xfs_inode.di_u + sizeof.xfs_bmdr_block + sizeof.xfs_bmbt_key*eax + 0]
        mov     eax, dword[ebx + xfs_inode.di_u + sizeof.xfs_bmdr_block + sizeof.xfs_bmbt_key*eax + 4]
        bswap   eax
        bswap   edx
        mov     ebx, [ebp + XFS.cur_block]
;DEBUGF 1,"read_block: %x %x ",edx,eax
        stdcall xfs_read_block
        pop     edx ebx
        test    eax, eax
        jnz     .error
;DEBUGF 1,"ok\n"
        mov     ebx, [ebp + XFS.cur_block]
 
        mov     edi, esi
        xor     eax, eax
        mov     ecx, 4096       ; MAX_PATH_LEN
        repne scasb
        movi    eax, ERROR_FS_FAIL
        jne     .error
        neg     ecx
        add     ecx, 4096
        dec     ecx
        mov     edx, ecx
DEBUGF 1,"strlen total  : %d\n",edx
        mov     edi, esi
        mov     eax, '/'
        mov     ecx, edx
        repne scasb
        jne     @f
        inc     ecx
    @@:
        neg     ecx
        add     ecx, edx
DEBUGF 1,"strlen current: %d\n",ecx
        stdcall xfs_hashname, esi, ecx
        add     esi, ecx
        cmp     byte[esi], '/'
        jne     @f
        inc     esi
    @@:
DEBUGF 1,"hashed: 0x%x\n",eax
        push    edi edx
        mov     edi, eax
        mov     [ebp + XFS.entries_read], 0
        lea     eax, [ebx + sizeof.xfs_bmbt_block]
        mov     edx, [ebp + XFS.ro_nextents]
;push eax
;mov eax, [ebp + XFS.dir2_leaf_offset_blocks]
;DEBUGF 1,": 0x%x %d\n",eax,eax
;pop eax
        stdcall xfs_dir2_lookupdir_node, eax, edx, [ebp + XFS.dir2_leaf_offset_blocks], edi
        pop     edx edi
        test    eax, eax
        jnz     .error
        bswap   ecx
DEBUGF 1,"got address: 0x%x\n",ecx
 
        mov     ebx, [ebp + XFS.cur_block]
        push    esi edi
        xor     edi, edi
        mov     esi, ecx
        shld    edi, esi, 3  ; get offset
        shl     esi, 3
        mov     edx, esi
        mov     ecx, [ebp + XFS.dirblklog]
        add     ecx, [ebp + XFS.blocklog]
        mov     eax, 1
        shl     eax, cl
        dec     eax
        and     edx, eax
        push    edx
        shrd    esi, edi, cl
        shr     edi, cl
        lea     eax, [ebx + sizeof.xfs_bmbt_block]
        mov     edx, [ebp + XFS.ro_nextents]
        stdcall xfs_extent_list_read_dirblock, eax, esi, edi, edx, [ebp + XFS.dir2_leaf_offset_blocks], 0
;DEBUGF 1,"RETVALUE: %d %d\n",edx,eax
        pop     edx
        pop     edi esi
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jz      .error
 
        mov     ebx, [ebp + XFS.cur_dirblock]
        add     ebx, edx
        mov     edx, [ebx + 0]
        mov     eax, [ebx + 4]
        bswap   edx
        bswap   eax
DEBUGF 1,"found inode: 0x%x%x\n",edx,eax
        jmp     .quit
 
  .quit:
        ret     12
  .error:
        xor     eax, eax
        mov     edx, eax
        ret     12
 
 
;----------------------------------------------------------------
; push name
; call xfs_get_inode
; test eax, eax
;----------------------------------------------------------------
xfs_get_inode:
        ; call xfs_get_inode_short until file is found / error returned
 
;DEBUGF 1,"getting inode of: %s\n",[esp+4]
        push    ebx esi edi
 
        ; start from the root inode
 
        mov     edx, dword[ebp + XFS.rootino + 4]       ; hi
        mov     eax, dword[ebp + XFS.rootino + 0]       ; lo
        mov     esi, [esp + 16] ; name
 
  .next_dir:
        cmp     byte[esi], 0
        je      .found
 
;DEBUGF 1,"next_level: |%s|\n",esi
        stdcall xfs_get_inode_short, esi, eax, edx
        test    edx, edx
        jnz     @f
        test    eax, eax
        jz      .error
    @@:
        jmp     .next_dir       ; file name found, go to next directory level
 
  .found:
 
  .quit:
        pop     edi esi ebx
        ret     4
  .error:
        pop     edi esi ebx
        xor     eax, eax
        mov     edx, eax
        ret     4
 
 
;----------------------------------------------------------------
; xfs_ReadFolder - XFS implementation of reading a folder
; in:  ebp = pointer to XFS structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
xfs_ReadFolder:
 
        ; to read folder
        ; 1. lock partition
        ; 2. find inode number
        ; 3. read this inode
        ; 4. get bdfe's
        ; 5. unlock partition
 
        ; 1.
        call    xfs_lock
        push    ecx edx esi edi
 
        ; 2.
        push    ebx esi edi
        add     esi, [esp + 32]         ; directory name
;DEBUGF 1,"xfs_ReadFolder: |%s|\n",esi
        stdcall xfs_get_inode, esi
        pop     edi esi ebx
        mov     ecx, edx
        or      ecx, eax
        jnz     @f
        movi    eax, ERROR_FILE_NOT_FOUND
    @@:
 
        ; 3.
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.cur_inode]
        test    eax, eax
        movi    eax, ERROR_FS_FAIL
        jnz     .error
 
        ; 4.
        mov     eax, [ebx + 8]          ; encoding
        and     eax, 1
        stdcall xfs_dir_get_bdfes, [ebx + 4], [ebx + 12], [ebx + 16], edx, eax
        test    eax, eax
        jnz     .error
 
  .quit:
;DEBUGF 1,"\n\n"
        pop     edi esi edx ecx
        ; 5.
        call    xfs_unlock
        xor     eax, eax
        ret
  .error:
;DEBUGF 1,"\n\n"
        pop     edi esi edx ecx
        push    eax
        call    xfs_unlock
        pop     eax
        ret
 
 
;----------------------------------------------------------------
; push inode_num_hi
; push inode_num_lo
; push [count]
; call xfs_get_inode_number_sf
;----------------------------------------------------------------
xfs_get_inode_number_sf:
 
        ; inode numbers in short form directories may be 4 or 8 bytes long
        ; determine the length in run time and read inode number at given address
 
        cmp     byte[esp + 4 + xfs_dir2_sf_hdr.i8count], 0      ; i8count == 0 means 4 byte per inode number
        je      .i4bytes
  .i8bytes:
        mov     edx, [esp + 12] ; hi
        mov     eax, [esp + 8]  ; lo
        bswap   edx             ; big endian
        bswap   eax
        ret     12
  .i4bytes:
        xor     edx, edx        ; no hi
        mov     eax, [esp + 12] ; hi = lo
        bswap   eax             ; big endian
        ret     12
 
 
;----------------------------------------------------------------
; push dest
; push src
; call xfs_get_inode_info
;----------------------------------------------------------------
xfs_get_inode_info:
 
        ; get access time and other file properties
        ; useful for browsing directories
        ; called for each dir entry
 
;DEBUGF 1,"get_inode_info\n"
        xor     eax, eax
        mov     edx, [esp + 4]
        movzx   ecx, word[edx + xfs_inode.di_core.di_mode]
        xchg    cl, ch
;DEBUGF 1,"di_mode: %x\n",ecx
        test    ecx, S_IFDIR    ; directory?
        jz      @f
        mov     eax, 0x10       ; set directory flag
    @@:
 
        mov     edi, [esp + 8]
        mov     [edi + 0], eax
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 0] ; hi
        bswap   eax
        mov     dword[edi + 36], eax    ; file size hi
;DEBUGF 1,"file_size hi: %d\n",eax
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 4] ; lo
        bswap   eax
        mov     dword[edi + 32], eax    ; file size lo
;DEBUGF 1,"file_size lo: %d\n",eax
 
        add     edi, 8
        mov     eax, [edx + xfs_inode.di_core.di_ctime.t_sec]
        bswap   eax
        push    edx
        xor     edx, edx
        add     eax, 3054539008                                     ;(369 * 365 + 89) * 24 * 3600
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec
        pop     edx
 
        mov     eax, [edx + xfs_inode.di_core.di_atime.t_sec]
        bswap   eax
        push    edx
        xor     edx, edx
        add     eax, 3054539008                                     ;(369 * 365 + 89) * 24 * 3600
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec
        pop     edx
 
        mov     eax, [edx + xfs_inode.di_core.di_mtime.t_sec]
        bswap   eax
        push    edx
        xor     edx, edx
        add     eax, 3054539008                                     ;(369 * 365 + 89) * 24 * 3600
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec
        pop     edx
 
  .quit:
        xor     eax, eax
        ret     8
  .error:
        movi    eax, ERROR_FS_FAIL
        ret     8
 
 
;----------------------------------------------------------------
; push extent_data
; call xfs_extent_unpack
;----------------------------------------------------------------
xfs_extent_unpack:
 
        ; extents come as packet 128bit bitfields
        ; lets unpack them to access internal fields
        ; write result to the XFS.extent structure
 
        push    eax ebx ecx edx
        mov     ebx, [esp + 20]
 
        xor     eax, eax
        mov     edx, [ebx + 0]
        bswap   edx
        test    edx, 0x80000000         ; mask, see documentation
        setnz   al
        mov     [ebp + XFS.extent.br_state], eax
 
        and     edx, 0x7fffffff         ; mask
        mov     eax, [ebx + 4]
        bswap   eax
        shrd    eax, edx, 9
        shr     edx, 9
        mov     dword[ebp + XFS.extent.br_startoff + 0], eax
        mov     dword[ebp + XFS.extent.br_startoff + 4], edx
 
        mov     edx, [ebx + 4]
        mov     eax, [ebx + 8]
        mov     ecx, [ebx + 12]
        bswap   edx
        bswap   eax
        bswap   ecx
        and     edx, 0x000001ff         ; mask
        shrd    ecx, eax, 21
        shrd    eax, edx, 21
        mov     dword[ebp + XFS.extent.br_startblock + 0], ecx
        mov     dword[ebp + XFS.extent.br_startblock + 4], eax
 
        mov     eax, [ebx + 12]
        bswap   eax
        and     eax, 0x001fffff         ; mask
        mov     [ebp + XFS.extent.br_blockcount], eax
 
        pop     edx ecx ebx eax
;DEBUGF 1,"extent.br_startoff  : %d %d\n",[ebp+XFS.extent.br_startoff+4],[ebp+XFS.extent.br_startoff+0]
;DEBUGF 1,"extent.br_startblock: %d %d\n",[ebp+XFS.extent.br_startblock+4],[ebp+XFS.extent.br_startblock+0]
;DEBUGF 1,"extent.br_blockcount: %d\n",[ebp+XFS.extent.br_blockcount]
;DEBUGF 1,"extent.br_state     : %d\n",[ebp+XFS.extent.br_state]
        ret     4
 
 
;----------------------------------------------------------------
; push namelen
; push name
; call xfs_hashname
;----------------------------------------------------------------
xfs_hashname:   ; xfs_da_hashname
 
        ; simple hash function
        ; never fails)
 
        push    ecx esi
        xor     eax, eax
        mov     esi, [esp + 12] ; name
        mov     ecx, [esp + 16] ; namelen
;mov esi, '.'
;mov ecx, 1
;DEBUGF 1,"hashname: %d %s\n",ecx,esi
 
    @@:
        rol     eax, 7
        xor     al, [esi]
        add     esi, 1
        loop    @b
 
        pop     esi ecx
        ret     8
 
 
;----------------------------------------------------------------
; push  len
; push  base
; eax -- hash value
; call xfs_get_addr_by_hash
;----------------------------------------------------------------
xfs_get_addr_by_hash:
 
        ; look for the directory entry offset by its file name hash
        ; allows fast file search for block, leaf and node directories
        ; binary (ternary) search
 
;DEBUGF 1,"get_addr_by_hash\n"
        push    ebx esi
        mov     ebx, [esp + 12] ; left
        mov     edx, [esp + 16] ; len
  .next:
        mov     ecx, edx
;        jecxz   .error
        test    ecx, ecx
        jz      .error
        shr     ecx, 1
        mov     esi, [ebx + ecx*8 + xfs_dir2_leaf_entry.hashval]
        bswap   esi
;DEBUGF 1,"cmp 0x%x",esi
        cmp     eax, esi
        jb      .below
        ja      .above
        mov     eax, [ebx + ecx*8 + xfs_dir2_leaf_entry.address]
        pop     esi ebx
        ret     8
  .below:
;DEBUGF 1,"b\n"
        mov     edx, ecx
        jmp     .next
  .above:
;DEBUGF 1,"a\n"
        lea     ebx, [ebx + ecx*8 + 8]
        sub     edx, ecx
        dec     edx
        jmp     .next
  .error:
        mov     eax, -1
        pop     esi ebx
        ret     8
 
 
;----------------------------------------------------------------
; xfs_GetFileInfo - XFS implementation of getting file info
; in:  ebp = pointer to XFS structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
xfs_GetFileInfo:
 
        ; lock partition
        ; get inode number by file name
        ; read inode
        ; get info
        ; unlock partition
 
        push    ecx edx esi edi
        call    xfs_lock
 
        add     esi, [esp + 20]         ; name
;DEBUGF 1,"xfs_GetFileInfo: |%s|\n",esi
        stdcall xfs_get_inode, esi
        mov     ecx, edx
        or      ecx, eax
        jnz     @f
        movi    eax, ERROR_FILE_NOT_FOUND
        jmp     .error
    @@:
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.cur_inode]
        test    eax, eax
        movi    eax, ERROR_FS_FAIL
        jnz     .error
 
        stdcall xfs_get_inode_info, edx, [ebx + 16]
 
  .quit:
        call    xfs_unlock
        pop     edi esi edx ecx
        xor     eax, eax
;DEBUGF 1,"quit\n\n"
        ret
  .error:
        call    xfs_unlock
        pop     edi esi edx ecx
;DEBUGF 1,"error\n\n"
        ret
 
 
;----------------------------------------------------------------
; xfs_Read - XFS implementation of reading a file
; in:  ebp = pointer to XFS structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
xfs_Read:
        push    ebx ecx edx esi edi
        call    xfs_lock
 
        add     esi, [esp + 24]
;DEBUGF 1,"xfs_Read: %d %d |%s|\n",[ebx+4],[ebx+12],esi
        stdcall xfs_get_inode, esi
        mov     ecx, edx
        or      ecx, eax
        jnz     @f
        movi    eax, ERROR_FILE_NOT_FOUND
        jmp     .error
    @@:
        stdcall xfs_read_inode, eax, edx, [ebp + XFS.cur_inode]
        test    eax, eax
        movi    eax, ERROR_FS_FAIL
        jnz     .error
        mov     [ebp + XFS.cur_inode_save], edx
 
        cmp     byte[edx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
        jne     .not_extent_list
        jmp     .extent_list
  .not_extent_list:
        cmp     byte[edx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_BTREE
        jne     .not_btree
        jmp     .btree
  .not_btree:
DEBUGF 1,"XFS: NOT IMPLEMENTED: FILE FORMAT\n"
        movi    eax, ERROR_FS_FAIL
        jmp     .error
  .extent_list:
        mov     ecx, [ebx + 12]         ; bytes to read
        mov     edi, [ebx + 16]         ; buffer for data
        mov     esi, [ebx + 8]          ; offset_hi
        mov     ebx, [ebx + 4]          ; offset_lo
 
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 4] ; lo
        bswap   eax
        mov     dword[ebp + XFS.bytes_left_in_file + 0], eax    ; lo
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 0] ; hi
        bswap   eax
        mov     dword[ebp + XFS.bytes_left_in_file + 4], eax    ; hi
 
        mov     eax, [edx + xfs_inode.di_core.di_nextents]
        bswap   eax
        mov     [ebp + XFS.left_extents], eax
 
        mov     dword[ebp + XFS.bytes_read], 0          ; actually read bytes
 
        xor     eax, eax                ; extent offset in list
  .extent_list.next_extent:
;DEBUGF 1,"extent_list.next_extent, eax: 0x%x\n",eax
;DEBUGF 1,"bytes_to_read: %d\n",ecx
;DEBUGF 1,"cur file offset: %d %d\n",esi,ebx
;DEBUGF 1,"esp: 0x%x\n",esp
        cmp     [ebp + XFS.left_extents], 0
        jne     @f
        test    ecx, ecx
        jz      .quit
        movi    eax, ERROR_END_OF_FILE
        jmp     .error
    @@:
        push    eax
        lea     eax, [edx + xfs_inode.di_u + eax + xfs_bmbt_rec.l0]
        stdcall xfs_extent_unpack, eax
        pop     eax
        dec     [ebp + XFS.left_extents]
        add     eax, sizeof.xfs_bmbt_rec
        push    eax ebx ecx edx esi
        mov     ecx, [ebp + XFS.blocklog]
        shrd    ebx, esi, cl
        shr     esi, cl
        cmp     esi, dword[ebp + XFS.extent.br_startoff + 4]
        jb      .extent_list.to_hole          ; handle sparse files
        ja      @f
        cmp     ebx, dword[ebp + XFS.extent.br_startoff + 0]
        jb      .extent_list.to_hole          ; handle sparse files
        je      .extent_list.to_extent        ; read from the start of current extent
    @@:
        xor     edx, edx
        mov     eax, [ebp + XFS.extent.br_blockcount]
        add     eax, dword[ebp + XFS.extent.br_startoff + 0]
        adc     edx, dword[ebp + XFS.extent.br_startoff + 4]
;DEBUGF 1,"br_startoff: %d %d\n",edx,eax
        cmp     esi, edx
        ja      .extent_list.skip_extent
        jb      .extent_list.to_extent
        cmp     ebx, eax
        jae     .extent_list.skip_extent
        jmp     .extent_list.to_extent
  .extent_list.to_hole:
;DEBUGF 1,"extent_list.to_hole\n"
        pop     esi edx ecx ebx eax
        jmp     .extent_list.read_hole
  .extent_list.to_extent:
;DEBUGF 1,"extent_list.to_extent\n"
        pop     esi edx ecx ebx eax
        jmp     .extent_list.read_extent
  .extent_list.skip_extent:
;DEBUGF 1,"extent_list.skip_extent\n"
        pop     esi edx ecx ebx eax
        jmp     .extent_list.next_extent
 
  .extent_list.read_hole:
;DEBUGF 1,"hole: offt: 0x%x%x ",esi,ebx
        push    eax edx
        mov     eax, dword[ebp + XFS.extent.br_startoff + 0]
        mov     edx, dword[ebp + XFS.extent.br_startoff + 4]
        push    esi ebx
        mov     ebx, ecx
        sub     eax, ebx        ; get hole_size, it is 64 bit
        sbb     edx, 0          ; now edx:eax contains the size of hole
;DEBUGF 1,"size: 0x%x%x\n",edx,eax
        jnz     @f              ; if hole size >= 2^32, write bytes_to_read zero bytes
        cmp     eax, ecx        ; if hole size >= bytes_to_read, write bytes_to_read zeros
        jae     @f
        mov     ecx, eax        ; if hole is < than bytes_to_read, write hole size zeros
    @@:
        sub     ebx, ecx        ; bytes_to_read - hole_size = left_to_read
        add     dword[esp + 0], ecx     ; update pushed file offset
        adc     dword[esp + 4], 0
        xor     eax, eax        ; hole is made of zeros
        rep stosb
        mov     ecx, ebx
        pop     ebx esi
 
        test    ecx, ecx        ; all requested bytes are read?
        pop     edx eax
        jz      .quit
        jmp     .extent_list.read_extent        ; continue from the start of unpacked extent
 
  .extent_list.read_extent:
;DEBUGF 1,"extent_list.read_extent\n"
        push    eax ebx ecx edx esi
        mov     eax, ebx
        mov     edx, esi
        mov     ecx, [ebp + XFS.blocklog]
        shrd    eax, edx, cl
        shr     edx, cl
        sub     eax, dword[ebp + XFS.extent.br_startoff + 0]    ; skip esi:ebx ?
        sbb     edx, dword[ebp + XFS.extent.br_startoff + 4]
        sub     [ebp + XFS.extent.br_blockcount], eax
        add     dword[ebp + XFS.extent.br_startblock + 0], eax
        adc     dword[ebp + XFS.extent.br_startblock + 4], 0
  .extent_list.read_extent.next_block:
;DEBUGF 1,"extent_list.read_extent.next_block\n"
        cmp     [ebp + XFS.extent.br_blockcount], 0     ; out of blocks in current extent?
        jne     @f
        pop     esi edx ecx ebx eax
        jmp     .extent_list.next_extent                ; go to next extent
    @@:
        mov     eax, dword[ebp + XFS.extent.br_startblock + 0]
        mov     edx, dword[ebp + XFS.extent.br_startblock + 4]
        push    ebx
        mov     ebx, [ebp + XFS.cur_block]
;DEBUGF 1,"read block: 0x%x%x\n",edx,eax
        stdcall xfs_read_block
        test    eax, eax
        pop     ebx
        jz      @f
        pop     esi edx ecx ebx eax
        movi    eax, ERROR_FS_FAIL
        jmp     .error
    @@:
        dec     [ebp + XFS.extent.br_blockcount]
        add     dword[ebp + XFS.extent.br_startblock + 0], 1
        adc     dword[ebp + XFS.extent.br_startblock + 4], 0
        mov     esi, [ebp + XFS.cur_block]
        mov     ecx, [ebp + XFS.blocklog]
        mov     eax, 1
        shl     eax, cl
        dec     eax             ; get blocklog mask
        and     eax, ebx        ; offset in current block
        add     esi, eax
        neg     eax
        add     eax, [ebp + XFS.blocksize]
        mov     ecx, [esp + 8]  ; pushed ecx, bytes_to_read
        cmp     ecx, eax        ; is current block enough?
        jbe     @f              ; if so, read bytes_to_read bytes
        mov     ecx, eax        ; otherwise read the block up to the end
    @@:
        sub     [esp + 8], ecx          ; left_to_read
        add     [esp + 12], ecx         ; update current file offset, pushed ebx
        sub     dword[ebp + XFS.bytes_left_in_file + 0], ecx
        sbb     dword[ebp + XFS.bytes_left_in_file + 4], 0
        jnc     @f
        add     dword[ebp + XFS.bytes_left_in_file + 0], ecx
        mov     ecx, dword[ebp + XFS.bytes_left_in_file + 0]
        mov     dword[ebp + XFS.bytes_left_in_file + 0], 0
        mov     dword[ebp + XFS.bytes_left_in_file + 4], 0
    @@:
        add     [ebp + XFS.bytes_read], ecx
        adc     [esp + 0], dword 0      ; pushed esi
;DEBUGF 1,"read data: %d\n",ecx
        rep movsb
        mov     ecx, [esp + 8]
;DEBUGF 1,"left_to_read: %d\n",ecx
        xor     ebx, ebx
        test    ecx, ecx
        jz      @f
        cmp     dword[ebp + XFS.bytes_left_in_file + 4], 0
        jne     .extent_list.read_extent.next_block
        cmp     dword[ebp + XFS.bytes_left_in_file + 0], 0
        jne     .extent_list.read_extent.next_block
    @@:
        pop     esi edx ecx ebx eax
        jmp     .quit
 
  .btree:
        mov     ecx, [ebx + 12]         ; bytes to read
        mov     [ebp + XFS.bytes_to_read], ecx
        mov     edi, [ebx + 16]         ; buffer for data
        mov     esi, [ebx + 8]          ; offset_hi
        mov     ebx, [ebx + 4]          ; offset_lo
        mov     dword[ebp + XFS.file_offset + 0], ebx
        mov     dword[ebp + XFS.file_offset + 4], esi
        mov     [ebp + XFS.buffer_pos], edi
 
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 4] ; lo
        bswap   eax
        mov     dword[ebp + XFS.bytes_left_in_file + 0], eax    ; lo
        mov     eax, dword[edx + xfs_inode.di_core.di_size + 0] ; hi
        bswap   eax
        mov     dword[ebp + XFS.bytes_left_in_file + 4], eax    ; hi
 
        mov     eax, [edx + xfs_inode.di_core.di_nextents]
        bswap   eax
        mov     [ebp + XFS.left_extents], eax
 
        mov     dword[ebp + XFS.bytes_read], 0          ; actually read bytes
 
        push    ebx ecx edx esi edi
        mov     [ebp + XFS.eof], 0
        mov     eax, dword[ebp + XFS.file_offset + 0]
        mov     edx, dword[ebp + XFS.file_offset + 4]
        add     eax, [ebp + XFS.bytes_to_read]
        adc     edx, 0
        sub     eax, dword[ebp + XFS.bytes_left_in_file + 0]
        sbb     edx, dword[ebp + XFS.bytes_left_in_file + 4]
        jc      @f      ; file_offset + bytes_to_read < file_size
        jz      @f      ; file_offset + bytes_to_read = file_size
        mov     [ebp + XFS.eof], 1
        cmp     edx, 0
        jne     .error.eof
        sub     dword[ebp + XFS.bytes_to_read], eax
        jc      .error.eof
        jz      .error.eof
    @@:
        stdcall xfs_btree_read, 0, 0, 1
        pop     edi esi edx ecx ebx
        test    eax, eax
        jnz     .error
        cmp     [ebp + XFS.eof], 1
        jne     .quit
        jmp     .error.eof
 
 
  .quit:
        call    xfs_unlock
        pop     edi esi edx ecx ebx
        xor     eax, eax
        mov     ebx, [ebp + XFS.bytes_read]
;DEBUGF 1,"quit: %d\n\n",ebx
        ret
  .error.eof:
        movi    eax, ERROR_END_OF_FILE
  .error:
;DEBUGF 1,"error\n\n"
        call    xfs_unlock
        pop     edi esi edx ecx ebx
        mov     ebx, [ebp + XFS.bytes_read]
        ret
 
 
;----------------------------------------------------------------
; push  max_offset_hi
; push  max_offset_lo
; push  nextents
; push  block_number_hi
; push  block_number_lo
; push  extent_list
; -1 / read block number
;----------------------------------------------------------------
xfs_extent_list_read_dirblock:  ; skips holes
;DEBUGF 1,"xfs_extent_list_read_dirblock\n"
        push    ebx esi edi
;mov eax, [esp+28]
;DEBUGF 1,"nextents: %d\n",eax
;mov eax, [esp+20]
;mov edx, [esp+24]
;DEBUGF 1,"block_number: 0x%x%x\n",edx,eax
;mov eax, [esp+32]
;mov edx, [esp+36]
;DEBUGF 1,"max_addr    : 0x%x%x\n",edx,eax
        mov     ebx, [esp + 16]
        mov     esi, [esp + 20]
        mov     edi, [esp + 24]
;        mov     ecx, [esp + 28] ; nextents
  .next_extent:
;DEBUGF 1,"next_extent\n"
        dec     dword[esp + 28]
        js      .error
        stdcall xfs_extent_unpack, ebx
        add     ebx, sizeof.xfs_bmbt_rec        ; next extent
        mov     edx, dword[ebp + XFS.extent.br_startoff + 4]
        mov     eax, dword[ebp + XFS.extent.br_startoff + 0]
        cmp     edx, [esp + 36] ; max_offset_hi
        ja      .error
        jb      @f
        cmp     eax, [esp + 32] ; max_offset_lo
        jae     .error
    @@:
        cmp     edi, edx
        jb      .hole
        ja      .check_count
        cmp     esi, eax
        jb      .hole
        ja      .check_count
        jmp     .read_block
  .hole:
;DEBUGF 1,"hole\n"
        mov     esi, eax
        mov     edi, edx
        jmp     .read_block
  .check_count:
;DEBUGF 1,"check_count\n"
        add     eax, [ebp + XFS.extent.br_blockcount]
        adc     edx, 0
        cmp     edi, edx
        ja      .next_extent
        jb      .read_block
        cmp     esi, eax
        jae     .next_extent
;        jmp     .read_block
  .read_block:
;DEBUGF 1,"read_block\n"
        push    esi edi
        sub     esi, dword[ebp + XFS.extent.br_startoff + 0]
        sbb     edi, dword[ebp + XFS.extent.br_startoff + 4]
        add     esi, dword[ebp + XFS.extent.br_startblock + 0]
        adc     edi, dword[ebp + XFS.extent.br_startblock + 4]
        stdcall xfs_read_dirblock, esi, edi, [ebp + XFS.cur_dirblock]
        pop     edx eax
  .quit:
;DEBUGF 1,"xfs_extent_list_read_dirblock: quit\n"
        pop     edi esi ebx
        ret     24
  .error:
;DEBUGF 1,"xfs_extent_list_read_dirblock: error\n"
        xor     eax, eax
        dec     eax
        mov     edx, eax
        pop     edi esi ebx
        ret     24
 
 
;----------------------------------------------------------------
; push  dirblock_num
; push  nextents
; push  extent_list
;----------------------------------------------------------------
xfs_dir2_node_get_numfiles:
 
        ; unfortunately, we need to set 'total entries' field
        ; this often requires additional effort, since there is no such a number in most directory ondisk formats
 
;DEBUGF 1,"xfs_dir2_node_get_numfiles\n"
        push    ebx ecx edx esi edi
 
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        mov     esi, [esp + 32]
        stdcall xfs_extent_list_read_dirblock, eax, esi, 0, edx, -1, -1
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jnz     @f
        movi    eax, ERROR_FS_FAIL
        jmp     .error
    @@:
        mov     ebx, [ebp + XFS.cur_dirblock]
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DA_NODE_MAGIC
        je      .node
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DIR2_LEAFN_MAGIC
        je      .leaf
        mov     eax, ERROR_FS_FAIL
        jmp     .error
 
  .node:
;DEBUGF 1,".node\n"
        mov     edi, [ebx + xfs_da_intnode.hdr.info.forw]
        bswap   edi
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        mov     esi, [ebx + xfs_da_intnode.btree.before]
        bswap   esi
        stdcall xfs_dir2_node_get_numfiles, eax, edx, esi
        test    eax, eax
        jnz     .error
        jmp     .common
        
  .leaf:
;DEBUGF 1,".leaf\n"
        movzx   ecx, word[ebx + xfs_dir2_leaf.hdr.count]
        xchg    cl, ch
        movzx   eax, word[ebx + xfs_dir2_leaf.hdr.stale]
        xchg    al, ah
        sub     ecx, eax
        add     [ebp + XFS.entries_read], ecx
        mov     edi, [ebx + xfs_dir2_leaf.hdr.info.forw]
        bswap   edi
        jmp     .common
 
  .common:
        test    edi, edi
        jz      .quit
        mov     esi, edi
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        stdcall xfs_dir2_node_get_numfiles, eax, edx, esi
        test    eax, eax
        jnz     .error
        jmp     .quit
 
  .quit:
;DEBUGF 1,".quit\n"
        pop     edi esi edx ecx ebx
        xor     eax, eax
        ret     12
  .error:
;DEBUGF 1,".error\n"
        pop     edi esi edx ecx ebx
        movi    eax, ERROR_FS_FAIL
        ret     12
 
 
;----------------------------------------------------------------
; push  hash
; push  dirblock_num
; push  nextents
; push  extent_list
;----------------------------------------------------------------
xfs_dir2_lookupdir_node:
DEBUGF 1,"xfs_dir2_lookupdir_node\n"
        push    ebx edx esi edi
 
        mov     eax, [esp + 20]
        mov     edx, [esp + 24]
        mov     esi, [esp + 28]
DEBUGF 1,"read dirblock: 0x%x %d\n",esi,esi
        stdcall xfs_extent_list_read_dirblock, eax, esi, 0, edx, -1, -1
DEBUGF 1,"dirblock read: 0x%x%x\n",edx,eax
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jnz     @f
        movi    eax, ERROR_FS_FAIL
        jmp     .error
    @@:
DEBUGF 1,"checkpoint #1\n"
        mov     ebx, [ebp + XFS.cur_dirblock]
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DA_NODE_MAGIC
        je      .node
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DIR2_LEAFN_MAGIC
        je      .leaf
        mov     eax, ERROR_FS_FAIL
DEBUGF 1,"checkpoint #2\n"
        jmp     .error
 
  .node:
DEBUGF 1,".node\n"
        mov     edi, [esp + 32] ; hash
        movzx   ecx, word[ebx + xfs_da_intnode.hdr.count]
        xchg    cl, ch
        mov     [ebp + XFS.left_leaves], ecx
        xor     ecx, ecx
  .node.next_leaf:
        mov     esi, [ebx + xfs_da_intnode.btree + ecx*sizeof.xfs_da_node_entry + xfs_da_node_entry.hashval]
        bswap   esi
        cmp     edi, esi
        jbe     .node.leaf_found
        inc     ecx
        cmp     ecx, [ebp + XFS.left_leaves]
        jne     .node.next_leaf
        mov     eax, ERROR_FILE_NOT_FOUND
        jmp     .error
    @@:
  .node.leaf_found:
        mov     eax, [esp + 20]
        mov     edx, [esp + 24]
        mov     esi, [ebx + xfs_da_intnode.btree + ecx*sizeof.xfs_da_node_entry + xfs_da_node_entry.before]
        bswap   esi
        stdcall xfs_dir2_lookupdir_node, eax, edx, esi, edi
        test    eax, eax
        jz      .quit
        movi    eax, ERROR_FILE_NOT_FOUND
        jmp     .error
 
  .leaf:
DEBUGF 1,".leaf\n"
        movzx   ecx, [ebx + xfs_dir2_leaf.hdr.count]
        xchg    cl, ch
        lea     esi, [ebx + xfs_dir2_leaf.ents]
        mov     eax, [esp + 32]
        stdcall xfs_get_addr_by_hash, esi, ecx
        cmp     eax, -1
        je      .error
        mov     ecx, eax
        jmp     .quit
 
  .quit:
DEBUGF 1,".quit\n"
        pop     edi esi edx ebx
        xor     eax, eax
        ret     16
  .error:
DEBUGF 1,".error\n"
        pop     edi esi edx ebx
        ret     16
 
 
;----------------------------------------------------------------
; push  dirblock_num
; push  nextents
; push  extent_list
;----------------------------------------------------------------
xfs_dir2_btree_get_numfiles:
;DEBUGF 1,"xfs_dir2_node_get_numfiles\n"
        push    ebx ecx edx esi edi
 
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        mov     esi, [esp + 32]
        stdcall xfs_extent_list_read_dirblock, eax, esi, 0, edx, -1, -1
        mov     ecx, eax
        and     ecx, edx
        inc     ecx
        jnz     @f
        movi    eax, ERROR_FS_FAIL
        jmp     .error
    @@:
        mov     ebx, [ebp + XFS.cur_dirblock]
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DA_NODE_MAGIC
        je      .node
        cmp     word[ebx + xfs_da_intnode.hdr.info.magic], XFS_DIR2_LEAFN_MAGIC
        je      .leaf
        mov     eax, ERROR_FS_FAIL
        jmp     .error
 
  .node:
;DEBUGF 1,".node\n"
        mov     edi, [ebx + xfs_da_intnode.hdr.info.forw]
        bswap   edi
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        mov     esi, [ebx + xfs_da_intnode.btree.before]
        bswap   esi
        stdcall xfs_dir2_node_get_numfiles, eax, edx, esi
        test    eax, eax
        jnz     .error
        jmp     .common
        
  .leaf:
;DEBUGF 1,".leaf\n"
        movzx   ecx, word[ebx + xfs_dir2_leaf.hdr.count]
        xchg    cl, ch
        movzx   eax, word[ebx + xfs_dir2_leaf.hdr.stale]
        xchg    al, ah
        sub     ecx, eax
        add     [ebp + XFS.entries_read], ecx
        mov     edi, [ebx + xfs_dir2_leaf.hdr.info.forw]
        bswap   edi
        jmp     .common
 
  .common:
        test    edi, edi
        jz      .quit
        mov     esi, edi
        mov     eax, [esp + 24]
        mov     edx, [esp + 28]
        stdcall xfs_dir2_node_get_numfiles, eax, edx, esi
        test    eax, eax
        jnz     .error
        jmp     .quit
 
  .quit:
;DEBUGF 1,".quit\n"
        pop     edi esi edx ecx ebx
        xor     eax, eax
        ret     12
  .error:
;DEBUGF 1,".error\n"
        pop     edi esi edx ecx ebx
        movi    eax, ERROR_FS_FAIL
        ret     12
 
 
;----------------------------------------------------------------
; push  is_root
; push  block_hi
; push  block_lo
;----------------------------------------------------------------
xfs_btree_read:
        push    ebx ecx edx esi edi
        cmp     dword[esp + 32], 1      ; is root?
        je      .root
        jmp     .not_root
  .root:
DEBUGF 1,".root\n"
        mov     ebx, [ebp + XFS.cur_inode_save]
        add     ebx, xfs_inode.di_u
        movzx   edx, [ebx + xfs_bmdr_block.bb_numrecs]
        xchg    dl, dh
        dec     edx
        add     ebx, sizeof.xfs_bmdr_block
        xor     eax, eax
        dec     eax
 .root.next_key:
DEBUGF 1,".root.next_key\n"
        cmp     [ebp + XFS.bytes_to_read], 0
        je      .quit
        inc     eax
        cmp     eax, edx        ; out of keys?
        ja      .root.key_found ; there is no length field, so try the last key
        lea     edi, [ebx + sizeof.xfs_bmbt_key*eax + 0]
        lea     esi, [ebx + sizeof.xfs_bmbt_key*eax + 4]
        bswap   edi
        bswap   esi
        mov     ecx, [ebp + XFS.blocklog]
        shld    edi, esi, cl
        shl     esi, cl
        cmp     edi, dword[ebp + XFS.file_offset + 4]
        ja      .root.prev_or_hole
        jb      .root.next_key
        cmp     esi, dword[ebp + XFS.file_offset + 0]
        ja      .root.prev_or_hole
        jb      .root.next_key
        jmp     .root.key_found
  .root.prev_or_hole:
DEBUGF 1,".root.prev_or_hole\n"
        test    eax, eax
        jz      .root.hole
        dec     eax
        jmp     .root.key_found
  .root.hole:
DEBUGF 1,".root.hole\n"
        push    eax edx esi edi
        mov     ecx, [ebp + XFS.blocklog]
        shld    edi, esi, cl
        shl     esi, cl
        sub     esi, dword[ebp + XFS.file_offset + 0]
        sbb     edi, dword[ebp + XFS.file_offset + 4]
        mov     ecx, [ebp + XFS.bytes_to_read]
        cmp     edi, 0  ; hole size >= 2^32
        jne     @f
        cmp     ecx, esi
        jbe     @f
        mov     ecx, esi
    @@:
        add     dword[ebp + XFS.file_offset + 0], ecx
        adc     dword[ebp + XFS.file_offset + 4], 0
        sub     [ebp + XFS.bytes_to_read], ecx
        xor     eax, eax
        mov     edi, [ebp + XFS.buffer_pos]
        rep stosb
        mov     [ebp + XFS.buffer_pos], edi
        pop     edi esi edx eax
        jmp     .root.next_key
  .root.key_found:
DEBUGF 1,".root.key_found\n"
        mov     edx, [ebp + XFS.cur_inode_save]
        mov     eax, [ebp + XFS.inodesize]
        sub     eax, xfs_inode.di_u
        cmp     [edx + xfs_inode.di_core.di_forkoff], 0
        je      @f
        movzx   eax, [edx + xfs_inode.di_core.di_forkoff]
        shl     eax, XFS_DIR2_DATA_ALIGN_LOG    ; 3
    @@:
        sub     eax, sizeof.xfs_bmdr_block
        shr     eax, 4  ;log2(sizeof.xfs_bmbt_key + sizeof.xfs_bmdr_ptr)
        mov     edx, [ebx + sizeof.xfs_bmbt_key*eax + 0]        ; hi
        mov     eax, [ebx + sizeof.xfs_bmbt_key*eax + 4]        ; hi
        bswap   edx
        bswap   eax
        stdcall xfs_btree_read, eax, edx, 0
        test    eax, eax
        jnz     .error
        jmp     .root.next_key
 
  .not_root:
DEBUGF 1,".root.not_root\n"
        mov     eax, [esp + 24] ; block_lo
        mov     edx, [esp + 28] ; block_hi
        mov     ebx, [ebp + XFS.cur_block]
        stdcall xfs_read_block
        test    eax, eax
        jnz     .error
        mov     ebx, [ebp + XFS.cur_block]
 
        cmp     [ebx + xfs_bmbt_block.bb_magic], XFS_BMAP_MAGIC
        jne     .error
        cmp     [ebx + xfs_bmbt_block.bb_level], 0      ; leaf?
        je      .leaf
        jmp     .node
 
  .node:
;        mov     eax, [ebp + XFS.blocksize]
;        sub     eax, sizeof.xfs_bmbt_block
;        shr     eax, 4  ; maxnumrecs
        mov     eax, dword[ebp + XFS.file_offset + 0]   ; lo
        mov     edx, dword[ebp + XFS.file_offset + 4]   ; hi
        movzx   edx, [ebx + xfs_bmbt_block.bb_numrecs]
        xchg    dl, dh
        dec     edx
        add     ebx, sizeof.xfs_bmbt_block
        xor     eax, eax
        dec     eax
  .node.next_key:
        push    eax ecx edx esi edi
        mov     eax, [esp + 44] ; block_lo
        mov     edx, [esp + 48] ; block_hi
        mov     ebx, [ebp + XFS.cur_block]
        stdcall xfs_read_block
        test    eax, eax
        jnz     .error
        mov     ebx, [ebp + XFS.cur_block]
        add     ebx, sizeof.xfs_bmbt_block
        pop     edi esi edx ecx eax
        cmp     [ebp + XFS.bytes_to_read], 0
        je      .quit
        inc     eax
        cmp     eax, edx        ; out of keys?
        ja      .node.key_found ; there is no length field, so try the last key
        lea     edi, [ebx + sizeof.xfs_bmbt_key*eax + 0]
        lea     esi, [ebx + sizeof.xfs_bmbt_key*eax + 4]
        bswap   edi
        bswap   esi
        mov     ecx, [ebp + XFS.blocklog]
        shld    edi, esi, cl
        shl     esi, cl
        cmp     edi, dword[ebp + XFS.file_offset + 4]
        ja      .node.prev_or_hole
        jb      .node.next_key
        cmp     esi, dword[ebp + XFS.file_offset + 0]
        ja      .node.prev_or_hole
        jb      .node.next_key
        jmp     .node.key_found
  .node.prev_or_hole:
        test    eax, eax
        jz      .node.hole
        dec     eax
        jmp     .node.key_found
  .node.hole:
        push    eax edx esi edi
        mov     ecx, [ebp + XFS.blocklog]
        shld    edi, esi, cl
        shl     esi, cl
        sub     esi, dword[ebp + XFS.file_offset + 0]
        sbb     edi, dword[ebp + XFS.file_offset + 4]
        mov     ecx, [ebp + XFS.bytes_to_read]
        cmp     edi, 0  ; hole size >= 2^32
        jne     @f
        cmp     ecx, esi
        jbe     @f
        mov     ecx, esi
    @@:
        add     dword[ebp + XFS.file_offset + 0], ecx
        adc     dword[ebp + XFS.file_offset + 4], 0
        sub     [ebp + XFS.bytes_to_read], ecx
        xor     eax, eax
        mov     edi, [ebp + XFS.buffer_pos]
        rep stosb
        mov     [ebp + XFS.buffer_pos], edi
        pop     edi esi edx eax
        jmp     .node.next_key
  .node.key_found:
        mov     edx, [ebp + XFS.cur_inode_save]
        mov     eax, [ebp + XFS.inodesize]
        sub     eax, xfs_inode.di_u
        cmp     [edx + xfs_inode.di_core.di_forkoff], 0
        je      @f
        movzx   eax, [edx + xfs_inode.di_core.di_forkoff]
        shl     eax, XFS_DIR2_DATA_ALIGN_LOG    ; 3
    @@:
        sub     eax, sizeof.xfs_bmdr_block
        shr     eax, 4  ;log2(sizeof.xfs_bmbt_key + sizeof.xfs_bmdr_ptr)
        mov     edx, [ebx + sizeof.xfs_bmbt_key*eax + 0]        ; hi
        mov     eax, [ebx + sizeof.xfs_bmbt_key*eax + 4]        ; hi
        bswap   edx
        bswap   eax
        stdcall xfs_btree_read, eax, edx, 0
        test    eax, eax
        jnz     .error
        jmp     .node.next_key
        jmp     .quit
 
  .leaf:
        
        jmp     .quit
 
  .error:
        pop     edi esi edx ecx ebx
        movi    eax, ERROR_FS_FAIL
        ret     4
  .quit:
        pop     edi esi edx ecx ebx
        xor     eax, eax
        ret     4
 
 
;----------------------------------------------------------------
; push  nextents
; push  extent_list
; push  file_offset_hi
; push  file_offset_lo
;----------------------------------------------------------------
;xfs_extent_list_read:
;        push    ebx 0 edx esi edi       ; zero means actually_read_bytes
;
;  .quit:
;        pop     edi esi edx ecx ebx
;        xor     eax, eax
;        ret     24
;  .error:
;        pop     edi esi edx ecx ebx
;        ret     24

Rev 4850	Rev 5089
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 4850 $	8	$Revision: 5089 $
9		9
10		10
11	include 'xfs.inc'	11	include 'xfs.inc'
12		12
13	;	13	;
14	; This file contains XFS related code.	14	; This file contains XFS related code.
15	; For more information on XFS check sources below.	15	; For more information on XFS check sources below.
16	;	16	;
17	; 1. XFS Filesystem Structure, 2nd Edition, Revision 1. Silicon Graphics Inc. 2006	17	; 1. XFS Filesystem Structure, 2nd Edition, Revision 1. Silicon Graphics Inc. 2006
18	; 2. Linux source http://kernel.org	18	; 2. Linux source http://kernel.org
19	;	19	;
20		20
21		21
22	; test partition type (valid XFS one?)	22	; test partition type (valid XFS one?)
23	; alloc and fill XFS (see xfs.inc) structure	23	; alloc and fill XFS (see xfs.inc) structure
24	; this function is called for each partition	24	; this function is called for each partition
25	; returns 0 (not XFS or invalid) / pointer to partition structure	25	; returns 0 (not XFS or invalid) / pointer to partition structure
26	xfs_create_partition:	26	xfs_create_partition:
27	push ebx ecx edx esi edi	27	push ebx ecx edx esi edi
-		28	cmp dword [esi+DISK.MediaInfo.SectorSize], 512
-		29	jnz .error
28	cmp dword[ebx + xfs_sb.sb_magicnum], XFS_SB_MAGIC ; signature	30	cmp dword[ebx + xfs_sb.sb_magicnum], XFS_SB_MAGIC ; signature
29	jne .error	31	jne .error
30		32
31	; TODO: check XFS.versionnum and XFS.features2	33	; TODO: check XFS.versionnum and XFS.features2
32	; print superblock params for debugging (waiting for bug reports)	34	; print superblock params for debugging (waiting for bug reports)
33		35
34	movi eax, sizeof.XFS	36	movi eax, sizeof.XFS
35	call malloc	37	call malloc
36	test eax, eax	38	test eax, eax
37	jz .error	39	jz .error
38		40
39	; standard partition initialization, common for all file systems	41	; standard partition initialization, common for all file systems
40		42
41	mov edi, eax	43	mov edi, eax
42	mov eax, dword[ebp + PARTITION.FirstSector]	44	mov eax, dword[ebp + PARTITION.FirstSector]
43	mov dword[edi + XFS.FirstSector], eax	45	mov dword[edi + XFS.FirstSector], eax
44	mov eax, dword[ebp + PARTITION.FirstSector + 4]	46	mov eax, dword[ebp + PARTITION.FirstSector + 4]
45	mov dword[edi + XFS.FirstSector + 4], eax	47	mov dword[edi + XFS.FirstSector + 4], eax
46	mov eax, dword[ebp + PARTITION.Length]	48	mov eax, dword[ebp + PARTITION.Length]
47	mov dword[edi + XFS.Length], eax	49	mov dword[edi + XFS.Length], eax
48	mov eax, dword[ebp + PARTITION.Length + 4]	50	mov eax, dword[ebp + PARTITION.Length + 4]
49	mov dword[edi + XFS.Length + 4], eax	51	mov dword[edi + XFS.Length + 4], eax
50	mov eax, [ebp + PARTITION.Disk]	52	mov eax, [ebp + PARTITION.Disk]
51	mov [edi + XFS.Disk], eax	53	mov [edi + XFS.Disk], eax
52	mov [edi + XFS.FSUserFunctions], xfs_user_functions	54	mov [edi + XFS.FSUserFunctions], xfs_user_functions
53		55
54	; here we initialize only one mutex so far (for the entire partition)	56	; here we initialize only one mutex so far (for the entire partition)
55	; XFS potentially allows parallel r/w access to several AGs, keep it in mind for SMP times	57	; XFS potentially allows parallel r/w access to several AGs, keep it in mind for SMP times
56		58
57	lea ecx, [edi + XFS.Lock]	59	lea ecx, [edi + XFS.Lock]
58	call mutex_init	60	call mutex_init
59		61
60	; read superblock and fill just allocated XFS partition structure	62	; read superblock and fill just allocated XFS partition structure
61		63
62	mov eax, [ebx + xfs_sb.sb_blocksize]	64	mov eax, [ebx + xfs_sb.sb_blocksize]
63	bswap eax ; XFS is big endian	65	bswap eax ; XFS is big endian
64	mov [edi + XFS.blocksize], eax	66	mov [edi + XFS.blocksize], eax
65	movzx eax, word[ebx + xfs_sb.sb_sectsize]	67	movzx eax, word[ebx + xfs_sb.sb_sectsize]
66	xchg al, ah	68	xchg al, ah
67	mov [edi + XFS.sectsize], eax	69	mov [edi + XFS.sectsize], eax
68	movzx eax, word[ebx + xfs_sb.sb_versionnum]	70	movzx eax, word[ebx + xfs_sb.sb_versionnum]
69	xchg al, ah	71	xchg al, ah
70	mov [edi + XFS.versionnum], eax	72	mov [edi + XFS.versionnum], eax
71	mov eax, [ebx + xfs_sb.sb_features2]	73	mov eax, [ebx + xfs_sb.sb_features2]
72	bswap eax	74	bswap eax
73	mov [edi + XFS.features2], eax	75	mov [edi + XFS.features2], eax
74	movzx eax, word[ebx + xfs_sb.sb_inodesize]	76	movzx eax, word[ebx + xfs_sb.sb_inodesize]
75	xchg al, ah	77	xchg al, ah
76	mov [edi + XFS.inodesize], eax	78	mov [edi + XFS.inodesize], eax
77	movzx eax, word[ebx + xfs_sb.sb_inopblock] ; inodes per block	79	movzx eax, word[ebx + xfs_sb.sb_inopblock] ; inodes per block
78	xchg al, ah	80	xchg al, ah
79	mov [edi + XFS.inopblock], eax	81	mov [edi + XFS.inopblock], eax
80	movzx eax, byte[ebx + xfs_sb.sb_blocklog] ; log2 of block size, in bytes	82	movzx eax, byte[ebx + xfs_sb.sb_blocklog] ; log2 of block size, in bytes
81	mov [edi + XFS.blocklog], eax	83	mov [edi + XFS.blocklog], eax
82	movzx eax, byte[ebx + xfs_sb.sb_sectlog]	84	movzx eax, byte[ebx + xfs_sb.sb_sectlog]
83	mov [edi + XFS.sectlog], eax	85	mov [edi + XFS.sectlog], eax
84	movzx eax, byte[ebx + xfs_sb.sb_inodelog]	86	movzx eax, byte[ebx + xfs_sb.sb_inodelog]
85	mov [edi + XFS.inodelog], eax	87	mov [edi + XFS.inodelog], eax
86	movzx eax, byte[ebx + xfs_sb.sb_inopblog]	88	movzx eax, byte[ebx + xfs_sb.sb_inopblog]
87	mov [edi + XFS.inopblog], eax	89	mov [edi + XFS.inopblog], eax
88	movzx eax, byte[ebx + xfs_sb.sb_dirblklog]	90	movzx eax, byte[ebx + xfs_sb.sb_dirblklog]
89	mov [edi + XFS.dirblklog], eax	91	mov [edi + XFS.dirblklog], eax
90	mov eax, dword[ebx + xfs_sb.sb_rootino + 4] ;	92	mov eax, dword[ebx + xfs_sb.sb_rootino + 4] ;
91	bswap eax ; big	93	bswap eax ; big
92	mov dword[edi + XFS.rootino + 0], eax ; endian	94	mov dword[edi + XFS.rootino + 0], eax ; endian
93	mov eax, dword[ebx + xfs_sb.sb_rootino + 0] ; 64bit	95	mov eax, dword[ebx + xfs_sb.sb_rootino + 0] ; 64bit
94	bswap eax ; number	96	bswap eax ; number
95	mov dword[edi + XFS.rootino + 4], eax ;	97	mov dword[edi + XFS.rootino + 4], eax ;
96		98
97	mov eax, [edi + XFS.blocksize]	99	mov eax, [edi + XFS.blocksize]
98	mov ecx, [edi + XFS.dirblklog]	100	mov ecx, [edi + XFS.dirblklog]
99	shl eax, cl	101	shl eax, cl
100	mov [edi + XFS.dirblocksize], eax ; blocks for files, dirblocks for directories	102	mov [edi + XFS.dirblocksize], eax ; blocks for files, dirblocks for directories
101		103
102	; sector is always smaller than block	104	; sector is always smaller than block
103	; so precalculate shift order to allow faster sector_num->block_num conversion	105	; so precalculate shift order to allow faster sector_num->block_num conversion
104		106
105	mov ecx, [edi + XFS.blocklog]	107	mov ecx, [edi + XFS.blocklog]
106	sub ecx, [edi + XFS.sectlog]	108	sub ecx, [edi + XFS.sectlog]
107	mov [edi + XFS.blockmsectlog], ecx	109	mov [edi + XFS.blockmsectlog], ecx
108		110
109	mov eax, 1	111	mov eax, 1
110	shl eax, cl	112	shl eax, cl
111	mov [edi + XFS.sectpblock], eax	113	mov [edi + XFS.sectpblock], eax
112		114
113	; shift order for inode_num->block_num conversion	115	; shift order for inode_num->block_num conversion
114		116
115	mov eax, [edi + XFS.blocklog]	117	mov eax, [edi + XFS.blocklog]
116	sub eax, [edi + XFS.inodelog]	118	sub eax, [edi + XFS.inodelog]
117	mov [edi + XFS.inodetoblocklog], eax	119	mov [edi + XFS.inodetoblocklog], eax
118		120
119	mov eax, [ebx + xfs_sb.sb_agblocks]	121	mov eax, [ebx + xfs_sb.sb_agblocks]
120	bswap eax	122	bswap eax
121	mov [edi + XFS.agblocks], eax	123	mov [edi + XFS.agblocks], eax
122	movzx ecx, byte[ebx + xfs_sb.sb_agblklog]	124	movzx ecx, byte[ebx + xfs_sb.sb_agblklog]
123	mov [edi + XFS.agblklog], ecx	125	mov [edi + XFS.agblklog], ecx
124		126
125	; get the mask for block numbers	127	; get the mask for block numbers
126	; block numbers are AG relative!	128	; block numbers are AG relative!
127	; bitfield length may vary between partitions	129	; bitfield length may vary between partitions
128		130
129	mov eax, 1	131	mov eax, 1
130	shl eax, cl	132	shl eax, cl
131	dec eax	133	dec eax
132	mov dword[edi + XFS.agblockmask + 0], eax	134	mov dword[edi + XFS.agblockmask + 0], eax
133	mov eax, 1	135	mov eax, 1
134	sub ecx, 32	136	sub ecx, 32
135	jc @f	137	jc @f
136	shl eax, cl	138	shl eax, cl
137	@@:	139	@@:
138	dec eax	140	dec eax
139	mov dword[edi + XFS.agblockmask + 4], eax	141	mov dword[edi + XFS.agblockmask + 4], eax
140		142
141	; calculate magic offsets for directories	143	; calculate magic offsets for directories
142		144
143	mov ecx, [edi + XFS.blocklog]	145	mov ecx, [edi + XFS.blocklog]
144	mov eax, XFS_DIR2_LEAF_OFFSET AND 0xffffffff ; lo	146	mov eax, XFS_DIR2_LEAF_OFFSET AND 0xffffffff ; lo
145	mov edx, XFS_DIR2_LEAF_OFFSET SHR 32 ; hi	147	mov edx, XFS_DIR2_LEAF_OFFSET SHR 32 ; hi
146	shrd eax, edx, cl	148	shrd eax, edx, cl
147	mov [edi + XFS.dir2_leaf_offset_blocks], eax	149	mov [edi + XFS.dir2_leaf_offset_blocks], eax
148		150
149	mov ecx, [edi + XFS.blocklog]	151	mov ecx, [edi + XFS.blocklog]
150	mov eax, XFS_DIR2_FREE_OFFSET AND 0xffffffff ; lo	152	mov eax, XFS_DIR2_FREE_OFFSET AND 0xffffffff ; lo
151	mov edx, XFS_DIR2_FREE_OFFSET SHR 32 ; hi	153	mov edx, XFS_DIR2_FREE_OFFSET SHR 32 ; hi
152	shrd eax, edx, cl	154	shrd eax, edx, cl
153	mov [edi + XFS.dir2_free_offset_blocks], eax	155	mov [edi + XFS.dir2_free_offset_blocks], eax
154		156
155	; mov ecx, [edi + XFS.dirblklog]	157	; mov ecx, [edi + XFS.dirblklog]
156	; mov eax, [edi + XFS.blocksize]	158	; mov eax, [edi + XFS.blocksize]
157	; shl eax, cl	159	; shl eax, cl
158	; mov [edi + XFS.dirblocksize], eax	160	; mov [edi + XFS.dirblocksize], eax
159		161
160	mov eax, [edi + XFS.blocksize]	162	mov eax, [edi + XFS.blocksize]
161	call malloc	163	call malloc
162	test eax, eax	164	test eax, eax
163	jz .error	165	jz .error
164	mov [edi + XFS.cur_block], eax	166	mov [edi + XFS.cur_block], eax
165		167
166	; we do need XFS.blocksize bytes for single inode	168	; we do need XFS.blocksize bytes for single inode
167	; minimal file system structure is block, inodes are packed in blocks	169	; minimal file system structure is block, inodes are packed in blocks
168		170
169	mov eax, [edi + XFS.blocksize]	171	mov eax, [edi + XFS.blocksize]
170	call malloc	172	call malloc
171	test eax, eax	173	test eax, eax
172	jz .error	174	jz .error
173	mov [edi + XFS.cur_inode], eax	175	mov [edi + XFS.cur_inode], eax
174		176
175	; temporary inode	177	; temporary inode
176	; used for browsing directories	178	; used for browsing directories
177		179
178	mov eax, [edi + XFS.blocksize]	180	mov eax, [edi + XFS.blocksize]
179	call malloc	181	call malloc
180	test eax, eax	182	test eax, eax
181	jz .error	183	jz .error
182	mov [edi + XFS.tmp_inode], eax	184	mov [edi + XFS.tmp_inode], eax
183		185
184	; current sector	186	; current sector
185	; only for sector size structures like AGI	187	; only for sector size structures like AGI
186	; inodes has usually the same size, but never store them here	188	; inodes has usually the same size, but never store them here
187		189
188	mov eax, [edi + XFS.sectsize]	190	mov eax, [edi + XFS.sectsize]
189	call malloc	191	call malloc
190	test eax, eax	192	test eax, eax
191	jz .error	193	jz .error
192	mov [edi + XFS.cur_sect], eax	194	mov [edi + XFS.cur_sect], eax
193		195
194	; current directory block	196	; current directory block
195		197
196	mov eax, [edi + XFS.dirblocksize]	198	mov eax, [edi + XFS.dirblocksize]
197	call malloc	199	call malloc
198	test eax, eax	200	test eax, eax
199	jz .error	201	jz .error
200	mov [edi + XFS.cur_dirblock], eax	202	mov [edi + XFS.cur_dirblock], eax
201		203
202	.quit:	204	.quit:
203	mov eax, edi ; return pointer to allocated XFS partition structure	205	mov eax, edi ; return pointer to allocated XFS partition structure
204	pop edi esi edx ecx ebx	206	pop edi esi edx ecx ebx
205	ret	207	ret
206	.error:	208	.error:
207	xor eax, eax	209	xor eax, eax
208	pop edi esi edx ecx ebx	210	pop edi esi edx ecx ebx
209	ret	211	ret
210		212
211		213
212	iglobal	214	iglobal
213	align 4	215	align 4
214	xfs_user_functions:	216	xfs_user_functions:
215	dd xfs_free	217	dd xfs_free
216	dd (xfs_user_functions_end - xfs_user_functions - 4) / 4	218	dd (xfs_user_functions_end - xfs_user_functions - 4) / 4
217	dd xfs_Read	219	dd xfs_Read
218	dd xfs_ReadFolder	220	dd xfs_ReadFolder
219	dd 0;xfs_Rewrite	221	dd 0;xfs_Rewrite
220	dd 0;xfs_Write	222	dd 0;xfs_Write
221	dd 0;xfs_SetFileEnd	223	dd 0;xfs_SetFileEnd
222	dd xfs_GetFileInfo	224	dd xfs_GetFileInfo
223	dd 0;xfs_SetFileInfo	225	dd 0;xfs_SetFileInfo
224	dd 0	226	dd 0
225	dd 0;xfs_Delete	227	dd 0;xfs_Delete
226	dd 0;xfs_CreateFolder	228	dd 0;xfs_CreateFolder
227	xfs_user_functions_end:	229	xfs_user_functions_end:
228	endg	230	endg
229		231
230		232
231	; lock partition access mutex	233	; lock partition access mutex
232	proc xfs_lock	234	proc xfs_lock
233	;DEBUGF 1,"xfs_lock\n"	235	;DEBUGF 1,"xfs_lock\n"
234	lea ecx, [ebp + XFS.Lock]	236	lea ecx, [ebp + XFS.Lock]
235	jmp mutex_lock	237	jmp mutex_lock
236	endp	238	endp
237		239
238		240
239	; unlock partition access mutex	241	; unlock partition access mutex
240	proc xfs_unlock	242	proc xfs_unlock
241	;DEBUGF 1,"xfs_unlock\n"	243	;DEBUGF 1,"xfs_unlock\n"
242	lea ecx, [ebp + XFS.Lock]	244	lea ecx, [ebp + XFS.Lock]
243	jmp mutex_unlock	245	jmp mutex_unlock
244	endp	246	endp
245		247
246		248
247	; free all the allocated memory	249	; free all the allocated memory
248	; called on partition destroy	250	; called on partition destroy
249	proc xfs_free	251	proc xfs_free
250	push ebp	252	push ebp
251	xchg ebp, eax	253	xchg ebp, eax
252	stdcall kernel_free, [ebp + XFS.cur_block]	254	stdcall kernel_free, [ebp + XFS.cur_block]
253	stdcall kernel_free, [ebp + XFS.cur_inode]	255	stdcall kernel_free, [ebp + XFS.cur_inode]
254	stdcall kernel_free, [ebp + XFS.cur_sect]	256	stdcall kernel_free, [ebp + XFS.cur_sect]
255	stdcall kernel_free, [ebp + XFS.cur_dirblock]	257	stdcall kernel_free, [ebp + XFS.cur_dirblock]
256	stdcall kernel_free, [ebp + XFS.tmp_inode]	258	stdcall kernel_free, [ebp + XFS.tmp_inode]
257	xchg ebp, eax	259	xchg ebp, eax
258	call free	260	call free
259	pop ebp	261	pop ebp
260	ret	262	ret
261	endp	263	endp
262		264
263		265
264	;---------------------------------------------------------------	266	;---------------------------------------------------------------
265	; block number (AG relative)	267	; block number (AG relative)
266	; eax -- inode_lo	268	; eax -- inode_lo
267	; edx -- inode_hi	269	; edx -- inode_hi
268	; ebx -- buffer	270	; ebx -- buffer
269	;---------------------------------------------------------------	271	;---------------------------------------------------------------
270	xfs_read_block:	272	xfs_read_block:
271	push ebx esi	273	push ebx esi
272		274
273	push edx	275	push edx
274	push eax	276	push eax
275		277
276	; XFS block numbers are AG relative	278	; XFS block numbers are AG relative
277	; they come in bitfield form of concatenated AG and block numbers	279	; they come in bitfield form of concatenated AG and block numbers
278	; to get absolute block number for fs_read32_sys we should	280	; to get absolute block number for fs_read32_sys we should
279	; 1. extract AG number (using precalculated mask)	281	; 1. extract AG number (using precalculated mask)
280	; 2. multiply it by the AG size in blocks	282	; 2. multiply it by the AG size in blocks
281	; 3. add AG relative block number	283	; 3. add AG relative block number
282		284
283	; 1.	285	; 1.
284	mov ecx, [ebp + XFS.agblklog]	286	mov ecx, [ebp + XFS.agblklog]
285	shrd eax, edx, cl	287	shrd eax, edx, cl
286	shr edx, cl	288	shr edx, cl
287	; 2.	289	; 2.
288	mul dword[ebp + XFS.agblocks]	290	mul dword[ebp + XFS.agblocks]
289	pop ecx	291	pop ecx
290	pop esi	292	pop esi
291	and ecx, dword[ebp + XFS.agblockmask + 0]	293	and ecx, dword[ebp + XFS.agblockmask + 0]
292	and esi, dword[ebp + XFS.agblockmask + 4]	294	and esi, dword[ebp + XFS.agblockmask + 4]
293	; 3.	295	; 3.
294	add eax, ecx	296	add eax, ecx
295	adc edx, esi	297	adc edx, esi
296		298
297	;DEBUGF 1,"read block: 0x%x%x\n",edx,eax	299	;DEBUGF 1,"read block: 0x%x%x\n",edx,eax
298	; there is no way to read file system block at once, therefore we	300	; there is no way to read file system block at once, therefore we
299	; 1. calculate the number of sectors first	301	; 1. calculate the number of sectors first
300	; 2. and then read them in series	302	; 2. and then read them in series
301		303
302	; 1.	304	; 1.
303	mov ecx, [ebp + XFS.blockmsectlog]	305	mov ecx, [ebp + XFS.blockmsectlog]
304	shld edx, eax, cl	306	shld edx, eax, cl
305	shl eax, cl	307	shl eax, cl
306	mov esi, [ebp + XFS.sectpblock]	308	mov esi, [ebp + XFS.sectpblock]
307		309
308	; 2.	310	; 2.
309	.next_sector:	311	.next_sector:
310	push eax edx	312	push eax edx
311	call fs_read32_sys	313	call fs_read32_sys
312	mov ecx, eax	314	mov ecx, eax
313	pop edx eax	315	pop edx eax
314	test ecx, ecx	316	test ecx, ecx
315	jnz .error	317	jnz .error
316	add eax, 1 ; be ready to fs_read64_sys	318	add eax, 1 ; be ready to fs_read64_sys
317	adc edx, 0	319	adc edx, 0
318	add ebx, [ebp + XFS.sectsize] ; update buffer offset	320	add ebx, [ebp + XFS.sectsize] ; update buffer offset
319	dec esi	321	dec esi
320	jnz .next_sector	322	jnz .next_sector
321		323
322	.quit:	324	.quit:
323	xor eax, eax	325	xor eax, eax
324	pop esi ebx	326	pop esi ebx
325	ret	327	ret
326	.error:	328	.error:
327	mov eax, ecx	329	mov eax, ecx
328	pop esi ebx	330	pop esi ebx
329	ret	331	ret
330		332
331		333
332	;---------------------------------------------------------------	334	;---------------------------------------------------------------
333	; push buffer	335	; push buffer
334	; push startblock_hi	336	; push startblock_hi
335	; push startblock_lo	337	; push startblock_lo
336	; call xfs_read_dirblock	338	; call xfs_read_dirblock
337	; test eax, eax	339	; test eax, eax
338	;---------------------------------------------------------------	340	;---------------------------------------------------------------
339	xfs_read_dirblock:	341	xfs_read_dirblock:
340	;mov eax, [esp + 4]	342	;mov eax, [esp + 4]
341	;mov edx, [esp + 8]	343	;mov edx, [esp + 8]
342	;DEBUGF 1,"read dirblock at: %d %d\n",edx,eax	344	;DEBUGF 1,"read dirblock at: %d %d\n",edx,eax
343	;DEBUGF 1,"dirblklog: %d\n",[ebp + XFS.dirblklog]	345	;DEBUGF 1,"dirblklog: %d\n",[ebp + XFS.dirblklog]
344	push ebx esi	346	push ebx esi
345		347
346	mov eax, [esp + 12] ; startblock_lo	348	mov eax, [esp + 12] ; startblock_lo
347	mov edx, [esp + 16] ; startblock_hi	349	mov edx, [esp + 16] ; startblock_hi
348	mov ebx, [esp + 20] ; buffer	350	mov ebx, [esp + 20] ; buffer
349		351
350	; dirblock >= block	352	; dirblock >= block
351	; read dirblocks by blocks	353	; read dirblocks by blocks
352		354
353	mov ecx, [ebp + XFS.dirblklog]	355	mov ecx, [ebp + XFS.dirblklog]
354	mov esi, 1	356	mov esi, 1
355	shl esi, cl	357	shl esi, cl
356	.next_block:	358	.next_block:
357	push eax edx	359	push eax edx
358	call xfs_read_block	360	call xfs_read_block
359	mov ecx, eax	361	mov ecx, eax
360	pop edx eax	362	pop edx eax
361	test ecx, ecx	363	test ecx, ecx
362	jnz .error	364	jnz .error
363	add eax, 1 ; be ready to fs_read64_sys	365	add eax, 1 ; be ready to fs_read64_sys
364	adc edx, 0	366	adc edx, 0
365	add ebx, [ebp + XFS.blocksize]	367	add ebx, [ebp + XFS.blocksize]
366	dec esi	368	dec esi
367	jnz .next_block	369	jnz .next_block
368		370
369	.quit:	371	.quit:
370	xor eax, eax	372	xor eax, eax
371	pop esi ebx	373	pop esi ebx
372	ret 12	374	ret 12
373	.error:	375	.error:
374	mov eax, ecx	376	mov eax, ecx
375	pop esi ebx	377	pop esi ebx
376	ret 12	378	ret 12
377		379
378		380
379	;---------------------------------------------------------------	381	;---------------------------------------------------------------
380	; push buffer	382	; push buffer
381	; push inode_hi	383	; push inode_hi
382	; push inode_lo	384	; push inode_lo
383	; call xfs_read_inode	385	; call xfs_read_inode
384	; test eax, eax	386	; test eax, eax
385	;---------------------------------------------------------------	387	;---------------------------------------------------------------
386	xfs_read_inode:	388	xfs_read_inode:
387	;DEBUGF 1,"reading inode: 0x%x%x\n",[esp+8],[esp+4]	389	;DEBUGF 1,"reading inode: 0x%x%x\n",[esp+8],[esp+4]
388	push ebx	390	push ebx
389	mov eax, [esp + 8] ; inode_lo	391	mov eax, [esp + 8] ; inode_lo
390	mov edx, [esp + 12] ; inode_hi	392	mov edx, [esp + 12] ; inode_hi
391	mov ebx, [esp + 16] ; buffer	393	mov ebx, [esp + 16] ; buffer
392		394
393	; inodes are packed into blocks	395	; inodes are packed into blocks
394	; 1. calculate block number	396	; 1. calculate block number
395	; 2. read the block	397	; 2. read the block
396	; 3. add inode offset to block base address	398	; 3. add inode offset to block base address
397		399
398	; 1.	400	; 1.
399	mov ecx, [ebp + XFS.inodetoblocklog]	401	mov ecx, [ebp + XFS.inodetoblocklog]
400	shrd eax, edx, cl	402	shrd eax, edx, cl
401	shr edx, cl	403	shr edx, cl
402	; 2.	404	; 2.
403	call xfs_read_block	405	call xfs_read_block
404	test eax, eax	406	test eax, eax
405	jnz .error	407	jnz .error
406		408
407	; note that inode numbers should be first extracted from bitfields using mask	409	; note that inode numbers should be first extracted from bitfields using mask
408		410
409	mov eax, [esp + 8]	411	mov eax, [esp + 8]
410	mov edx, 1	412	mov edx, 1
411	mov ecx, [ebp + XFS.inopblog]	413	mov ecx, [ebp + XFS.inopblog]
412	shl edx, cl	414	shl edx, cl
413	dec edx ; get inode number mask	415	dec edx ; get inode number mask
414	and eax, edx ; apply mask	416	and eax, edx ; apply mask
415	mov ecx, [ebp + XFS.inodelog]	417	mov ecx, [ebp + XFS.inodelog]
416	shl eax, cl	418	shl eax, cl
417	add ebx, eax	419	add ebx, eax
418		420
419	cmp word[ebx], XFS_DINODE_MAGIC ; test signature	421	cmp word[ebx], XFS_DINODE_MAGIC ; test signature
420	jne .error	422	jne .error
421	.quit:	423	.quit:
422	xor eax, eax	424	xor eax, eax
423	mov edx, ebx	425	mov edx, ebx
424	pop ebx	426	pop ebx
425	ret 12	427	ret 12
426	.error:	428	.error:
427	movi eax, ERROR_FS_FAIL	429	movi eax, ERROR_FS_FAIL
428	mov edx, ebx	430	mov edx, ebx
429	pop ebx	431	pop ebx
430	ret 12	432	ret 12
431		433
432		434
433	;----------------------------------------------------------------	435	;----------------------------------------------------------------
434	; push encoding ; ASCII / UNICODE	436	; push encoding ; ASCII / UNICODE
435	; push src ; inode	437	; push src ; inode
436	; push dst ; bdfe	438	; push dst ; bdfe
437	; push entries_to_read	439	; push entries_to_read
438	; push start_number ; from 0	440	; push start_number ; from 0
439	;----------------------------------------------------------------	441	;----------------------------------------------------------------
440	xfs_dir_get_bdfes:	442	xfs_dir_get_bdfes:
441	DEBUGF 1,"xfs_dir_get_bdfes: %d entries from %d\n",[esp+8],[esp+4]	443	DEBUGF 1,"xfs_dir_get_bdfes: %d entries from %d\n",[esp+8],[esp+4]
442	sub esp, 4 ; local vars	444	sub esp, 4 ; local vars
443	push ecx edx esi edi	445	push ecx edx esi edi
444		446
445	mov ebx, [esp + 36] ; src	447	mov ebx, [esp + 36] ; src
446	mov edx, [esp + 32] ; dst	448	mov edx, [esp + 32] ; dst
447	mov ecx, [esp + 24] ; start_number	449	mov ecx, [esp + 24] ; start_number
448		450
449	; define directory ondisk format and jump to corresponding label	451	; define directory ondisk format and jump to corresponding label
450		452
451	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_LOCAL	453	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_LOCAL
452	jne .not_shortdir	454	jne .not_shortdir
453	jmp .shortdir	455	jmp .shortdir
454	.not_shortdir:	456	.not_shortdir:
455	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS	457	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
456	jne .not_blockdir	458	jne .not_blockdir
457	mov eax, [ebx + xfs_inode.di_core.di_nextents]	459	mov eax, [ebx + xfs_inode.di_core.di_nextents]
458	bswap eax	460	bswap eax
459	cmp eax, 1	461	cmp eax, 1
460	jne .not_blockdir	462	jne .not_blockdir
461	jmp .blockdir	463	jmp .blockdir
462	.not_blockdir:	464	.not_blockdir:
463	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS	465	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
464	jne .not_leafdir	466	jne .not_leafdir
465	mov eax, [ebx + xfs_inode.di_core.di_nextents]	467	mov eax, [ebx + xfs_inode.di_core.di_nextents]
466	bswap eax	468	bswap eax
467	cmp eax, 4	469	cmp eax, 4
468	ja .not_leafdir	470	ja .not_leafdir
469	jmp .leafdir	471	jmp .leafdir
470	.not_leafdir:	472	.not_leafdir:
471	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS	473	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_EXTENTS
472	jne .not_nodedir	474	jne .not_nodedir
473	jmp .nodedir	475	jmp .nodedir
474	.not_nodedir:	476	.not_nodedir:
475	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_BTREE	477	cmp byte[ebx + xfs_inode.di_core.di_format], XFS_DINODE_FMT_BTREE
476	jne .not_btreedir	478	jne .not_btreedir
477	jmp .btreedir	479	jmp .btreedir
478	.not_btreedir:	480	.not_btreedir:
479	movi eax, ERROR_FS_FAIL	481	movi eax, ERROR_FS_FAIL
480	jmp .error	482	jmp .error
481		483
482	; short form directory (all the data fits into inode)	484	; short form directory (all the data fits into inode)
483	.shortdir:	485	.shortdir:
484	;DEBUGF 1,"shortdir\n",	486	;DEBUGF 1,"shortdir\n",
485	movzx eax, word[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count]	487	movzx eax, word[ebx + xfs_inode.di_u + xfs_dir2_sf_hdr.count]
486	test al, al ; is count zero?	488	test al, al ; is count zero?
487	jnz @f ; if not, use it (i8count must be zero then)	489	jnz @f ; if not, use it (i8count must be zero then)
488	shr eax, 8 ; use i8count	490	shr eax, 8 ; use i8count
489	@@:	491	@@:
490	add eax, 1 ; '..' and '.' are implicit	492	add eax, 1 ; '..' and '.' are implicit
491	mov dword[edx + 0], 1 ; version	493	mov dword[edx + 0], 1 ; version
492	mov [edx + 8], eax ; total entries	494	mov [edx + 8], eax ; total entries
493	sub eax, [esp + 24] ; start number	495	sub eax, [esp + 24] ; start number
494	cmp eax, [esp + 28] ; entries to read	496	cmp eax, [esp + 28] ; entries to read
495	jbe @f	497	jbe @f
496	mov eax, [esp + 28]	498	mov eax, [esp + 28]
497	@@:	499	@@:
498	mov [esp + 28], eax	500	mov [esp + 28], eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/xfs.asm – Rev 4850 → 5089