forked from KolibriOS/kolibrios
2772 lines
90 KiB
NASM
2772 lines
90 KiB
NASM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
|
|
;; Distributed under terms of the GNU General Public License. ;;
|
|
;; ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
$Revision$
|
|
|
|
; XFS external functions
|
|
; in:
|
|
; ebx -> parameter structure of sysfunc 70
|
|
; ebp -> XFS structure
|
|
; [esi]+[[esp+4]] = name
|
|
; out:
|
|
; eax, ebx = return values for sysfunc 70
|
|
iglobal
|
|
align 4
|
|
xfs_user_functions:
|
|
dd xfs_free
|
|
dd (xfs_user_functions_end - xfs_user_functions - 4) / 4
|
|
dd xfs_ReadFile
|
|
dd xfs_ReadFolder
|
|
dd 0;xfs_CreateFile
|
|
dd 0;xfs_WriteFile
|
|
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
|
|
|
|
include 'xfs.inc'
|
|
|
|
; Mount if it's a valid XFS partition.
|
|
xfs_create_partition:
|
|
; in:
|
|
; ebp -> PARTITION structure
|
|
; ebx -> boot sector
|
|
; out:
|
|
; eax -> XFS structure, 0 = not XFS
|
|
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
|
|
|
|
|
|
; 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
|
|
sub eax, 978307200 ; 01.01.1970-01.01.2001 = (365*31+8)*24*60*60
|
|
call fsTime2bdfe
|
|
pop edx
|
|
|
|
mov eax, [edx + xfs_inode.di_core.di_atime.t_sec]
|
|
bswap eax
|
|
push edx
|
|
sub eax, 978307200
|
|
call fsTime2bdfe
|
|
pop edx
|
|
|
|
mov eax, [edx + xfs_inode.di_core.di_mtime.t_sec]
|
|
bswap eax
|
|
push edx
|
|
sub eax, 978307200
|
|
call fsTime2bdfe
|
|
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_ReadFile - 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_ReadFile:
|
|
push ebx ecx edx esi edi
|
|
call xfs_lock
|
|
add esi, [esp + 24]
|
|
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
|