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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/fs/xfs.asm – Rev 4265 → 5201