WebSVN – Kolibri OS – Diff – /kernel/trunk/fs/ext.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6558 $
 
; EXT external functions
;   in:
; ebx -> parameter structure of sysfunc 70
; ebp -> EXTFS structure
; esi -> path string in UTF-8
;   out:
; eax, ebx = return values for sysfunc 70
iglobal
align 4
ext_user_functions:
        dd      ext_free
        dd      (ext_user_functions_end - ext_user_functions - 4) / 4
        dd      ext_ReadFile
        dd      ext_ReadFolder
        dd      ext_CreateFile
        dd      ext_WriteFile
        dd      ext_SetFileEnd
        dd      ext_GetFileInfo
        dd      ext_SetFileInfo
        dd      0
        dd      ext_Delete
        dd      ext_CreateFolder
ext_user_functions_end:
endg
 
struct DIRENTRY
inodeNumber     dd  ?
entryLength     dw  ?
nameLength      db  ?
fileType        db  ?
name            db  ?   ; rb [nameLength]
ends
 
struct INODE
accessMode      dw  ?
UID             dw  ?
fileSize        dd  ?
accessedTime    dd  ?
inodeModified   dd  ?
dataModified    dd  ?
deletedTime     dd  ?
GID             dw  ?
linksCount      dw  ?
sectorsUsed     dd  ?
featureFlags    dd  ?
reserved        dd  ?
blockNumbers    rd  12
addressBlock    dd  ?
doubleAddress   dd  ?
tripleAddress   dd  ?
generation      dd  ?
ACL             dd  ?
fileSizeHigh    dd  ?
ends
 
struct BGDESCR  ; block group descriptor
blockBitmap         dd  ?
inodeBitmap         dd  ?
inodeTable          dd  ?
blocksFree          dw  ?
inodesFree          dw  ?
directoriesCount    dw  ?
reserved            rb  14
ends
 
struct SUPERBLOCK
inodesTotal         dd  ?
blocksTotal         dd  ?
blocksReserved      dd  ?
blocksFree          dd  ?
inodesFree          dd  ?
firstGroupBlock     dd  ?
sectorsPerBlockLog  dd  ?   ; shift for 1024
fragmentSizeLog     dd  ?
blocksPerGroup      dd  ?
fragmentsPerGroup   dd  ?
inodesPerGroup      dd  ?
lastMountTime       dd  ?
lastWriteTime       dd  ?
mountCount          dw  ?
mountMax            dw  ?
magic               dw  ?
state               dw  ?
errorHandling       dw  ?
additionalVersion   dw  ?
lastCheck           dd  ?
checkInterval       dd  ?
creatorOS           dd  ?
dynamicVersionFlag  dd  ?
reservedUID         dw  ?
reservedGID         dw  ?
firstInode          dd  ?
inodeSize           dw  ?
thisBlockGroup      dw  ?
compatibleFlags     dd  ?
incompatibleFlags   dd  ?
RO_compatibleFlags  dd  ?
ends
 
; ext4 extent tree
struct NODEHEADER       ; tree node header
magic           dw  ?   ; 0xF30A
entriesFolow    dw  ?
entriesMax      dw  ?
currentDepth    dw  ?
generation      dd  ?
ends
 
struct INDEX    ; root/branch
fileBlock       dd  ?
nodeBlock       dd  ?
nodeBlockHigh   dw  ?
reserved        dw  ?
ends
 
struct EXTENT   ; leaf
fileBlock       dd  ?
blocksCount     dw  ?
fsBlockHigh     dw  ?
fsBlock         dd  ?
ends
 
ROOT_INODE = 2
PERMISSIONS = 110110110b
EXTENTS_USED = 80000h
TYPE_MASK = 0F000h
FLAG_FILE = 8000h
DIRECTORY = 4000h
DIR_FLAG_FILE = 1
DIR_DIRECTORY = 2
KOS_HIDDEN = 2
KOS_DIRECTORY = 10h
READ_ONLY = 1
 
; Implemented "incompatible" features:
; 2 = have file type in directory entry
; 40h = extents
; 200h = flexible block groups
INCOMPATIBLE_SUPPORT = 242h
; Read only support for "incompatible" features:
INCOMPATIBLE_READ_SUPPORT = 240h
 
; Implemented "read-only" features:
; 1 = sparse superblock
; 2 = 64-bit file size
READ_ONLY_SUPPORT = 3
 
struct EXTFS PARTITION
Lock                MUTEX
mountType           dd  ?
sectorsPerBlockLog  dd  ?   ; shift for 512
bytesPerBlock       dd  ?
sectorsPerBlock     dd  ?
dwordsPerBlock      dd  ?
dwordsPerBranch     dd  ?   ; dwordsPerBlock ^ 2
mainBlockBuffer     dd  ?
tempBlockBuffer     dd  ?
align0  rb  200h-EXTFS.align0
superblock          SUPERBLOCK
align1  rb  400h-EXTFS.align1
rootInodeBuffer     INODE
align2  rb  600h-EXTFS.align2
inodeBuffer         INODE
 
align3  rb  800h-EXTFS.align3
ends
 
; mount if it's a valid EXT partition
ext2_create_partition:
;   in:
; ebp -> PARTITION structure
; ebx -> boot sector
; ebx+512 -> buffer
;   out:
; eax -> EXTFS structure, 0 = not EXT
        push    ebx
        cmp     dword [esi+DISK.MediaInfo.SectorSize], 512
        jnz     .fail
        mov     eax, 2
        add     ebx, 512
        call    fs_read32_sys
        test    eax, eax
        jnz     .fail
        cmp     [ebx+SUPERBLOCK.magic], 0xEF53
        jne     .fail
        cmp     [ebx+SUPERBLOCK.state], 1
        ja      .fail
        test    [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT
        jnz     .fail
        cmp     [ebx+SUPERBLOCK.sectorsPerBlockLog], 6  ; 64KB
        ja      .fail
        cmp     [ebx+SUPERBLOCK.inodeSize], 1024
        ja      .fail
        cmp     [ebx+SUPERBLOCK.blocksPerGroup], 0
        je      .fail
        cmp     [ebx+SUPERBLOCK.inodesPerGroup], 0
        je      .fail
        movi    eax, sizeof.EXTFS
        call    malloc
        test    eax, eax
        jz      .fail
        mov     ecx, dword [ebp+PARTITION.FirstSector]
        mov     dword [eax+EXTFS.FirstSector], ecx
        mov     ecx, dword [ebp+PARTITION.FirstSector+4]
        mov     dword [eax+EXTFS.FirstSector+4], ecx
        mov     ecx, dword [ebp+PARTITION.Length]
        mov     dword [eax+EXTFS.Length], ecx
        mov     ecx, dword [ebp+PARTITION.Length+4]
        mov     dword [eax+EXTFS.Length+4], ecx
        mov     ecx, [ebp+PARTITION.Disk]
        mov     [eax+EXTFS.Disk], ecx
        mov     [eax+EXTFS.FSUserFunctions], ext_user_functions
 
        push    ebp esi edi
        mov     ebp, eax
        lea     ecx, [eax+EXTFS.Lock]
        call    mutex_init
        mov     esi, ebx
        lea     edi, [ebp+EXTFS.superblock]
        mov     ecx, 512/4
        rep movsd   ; copy superblock
        mov     ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]
        inc     ecx
        mov     [ebp+EXTFS.sectorsPerBlockLog], ecx
        mov     eax, 1
        shl     eax, cl
        mov     [ebp+EXTFS.sectorsPerBlock], eax
        shl     eax, 9
        mov     [ebp+EXTFS.bytesPerBlock], eax
        shl     eax, 1
        push    eax
        shr     eax, 3
        mov     [ebp+EXTFS.dwordsPerBlock], eax
        mul     eax
        mov     [ebp+EXTFS.dwordsPerBranch], eax
        call    kernel_alloc
        test    eax, eax
        jz      .error
        mov     [ebp+EXTFS.mainBlockBuffer], eax
        add     eax, [ebp+EXTFS.bytesPerBlock]
        mov     [ebp+EXTFS.tempBlockBuffer], eax
        mov     [ebp+EXTFS.mountType], 0
        test    [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT
        jnz     .read_only
        test    [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT
        jz      @f
.read_only:
        or      [ebp+EXTFS.mountType], READ_ONLY
@@: ; read root inode
        lea     ebx, [ebp+EXTFS.rootInodeBuffer]
        mov     eax, ROOT_INODE
        call    readInode
        test    eax, eax
        jnz     @f
        mov     eax, ebp
        pop     edi esi ebp ebx
        ret
 
@@:
        stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
.error:
        mov     eax, ebp
        call    free
        pop     edi esi ebp
.fail:
        pop     ebx
        xor     eax, eax
        ret
 
; unmount EXT partition
ext_free:
; in: eax -> EXTFS structure
        push    eax
        stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]
        pop     eax
        jmp     free
 
extfsWriteBlock:
        push    fs_write64_sys
        jmp     @f
;   in:
; eax = block number
; ebx -> buffer
extfsReadBlock:
        push    fs_read64_sys
@@:
        push    ecx edx
        mov     ecx, [ebp+EXTFS.sectorsPerBlock]
        mul     ecx
        call    dword[esp+8]
        pop     edx ecx
        add     esp, 4
        test    eax, eax
        jz      @f
        movi    eax, ERROR_DEVICE
        stc
@@:
        ret
 
extfsReadDescriptor:
; in: eax = block group number
;   out:
; [ebp+EXTFS.tempBlockBuffer] -> relevant block
; eax -> block group descriptor, 0 = error
        push    edx ebx
        shl     eax, 5
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        add     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        inc     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail
        mov     eax, ebx
        add     eax, edx
@@:
        pop     ebx edx
        ret
 
.fail:
        xor     eax, eax
        stc
        jmp     @b
 
extfsWriteDescriptor:
;   in:
; eax = block group number
; [ebp+EXTFS.tempBlockBuffer] -> relevant block
        push    edx ebx
        shl     eax, 5
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        add     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        inc     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        pop     ebx edx
        ret
 
extfsResourceFree:
;   in:
; ecx=0 -> block, ecx=1 -> inode
; eax = block/inode number
        push    ebx edx
        sub     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        xor     edx, edx
        div     [ebp+EXTFS.superblock.blocksPerGroup]
        push    eax edx
        call    extfsReadDescriptor
        jc      .fail
        inc     [eax+BGDESCR.blocksFree+ecx*2]
        mov     eax, [eax+BGDESCR.blockBitmap+ecx*4]
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        mov     edx, eax
        call    extfsReadBlock
        jc      .fail
        pop     eax
        push    edx
        mov     edx, eax
        and     edx, 31
        shr     eax, 5
        shl     eax, 2
        add     eax, [ebp+EXTFS.mainBlockBuffer]
        btr     [eax], edx
        pop     eax
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsWriteBlock
        jc      @f
        inc     [ebp+EXTFS.superblock.blocksFree+ecx*4]
        pop     eax
        call    extfsWriteDescriptor
.ret:
        pop     edx ebx
        ret
 
.fail:
        pop     eax
@@:
        pop     eax
        movi    eax, ERROR_DEVICE
        jmp     .ret
 
freeDoublyIndirectBlock:
; in: eax = doubly-indirect block number
; out: eax=1 -> finished
        test    eax, eax
        jz      .complete
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        pop     eax
        jc      .ret
        xor     ecx, ecx
        call    extfsResourceFree
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
@@:
        mov     eax, [ebx]
        test    eax, eax
        jz      .complete
        call    extfsResourceFree
        add     ebx, 4
        cmp     ebx, edx
        jb      @b
.ret:
        xor     eax, eax
        ret
 
.complete:
        inc     eax
        ret
 
inodeBlockAlloc:
; in: esi -> inode, eax = inode number
; out: ebx = block number
 
 
        call    extfsBlockAlloc
        jc      @f
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        add     [esi+INODE.sectorsUsed], eax
        xor     eax, eax
@@:
        ret
 
extfsBlockAlloc:    ; also erases
; in: eax = inode number
; out: ebx = block number
        xor     ebx, ebx
        call    extfsResourceAlloc
        jc      @f
        push    ebx ecx edi
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        mov     ebx, edi
        xor     eax, eax
        rep stosd
        pop     edi ecx
        mov     eax, [esp]
        call    extfsWriteBlock
        pop     ebx
@@:
        ret
 
extfsResourceAlloc:
;   in:
; eax = inode number
; ebx=0 -> block, ebx=1 -> inode
;   out:
; ebx = block/inode number
        push    ecx edx esi edi
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        push    eax eax
        mov     esi, .forward   ; search forward, then backward
.test_block_group:
        call    extfsReadDescriptor
        jc      .fail
        dec     [eax+BGDESCR.blocksFree+ebx*2]
        mov     eax, [eax+BGDESCR.blockBitmap+ebx*4]
        push    ebx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        mov     edx, eax
        mov     edi, ebx
        call    extfsReadBlock
        pop     ebx
        jc      .fail
        mov     ecx, [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
        or      eax, -1
        shr     ecx, 5
        jz      .next
        repz scasd
        jz      .next
        sub     edi, 4
        mov     eax, [edi]
        not     eax
        bsf     eax, eax
        bts     [edi], eax
        sub     edi, [ebp+EXTFS.mainBlockBuffer]
        shl     edi, 3
        add     eax, edi
        mov     ecx, eax
        mov     eax, edx
        push    ebx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsWriteBlock
        pop     ebx
        jc      .fail
        mov     eax, [esp]
        mul     [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
        add     eax, ecx
        dec     [ebp+EXTFS.superblock.blocksFree+ebx*4]
        mov     ebx, eax
        pop     eax
        add     esp, 4
        call    extfsWriteDescriptor
@@:
        pop     edi esi edx ecx
        ret
 
.fail:
        pop     eax eax
        movi    eax, ERROR_DEVICE
        jmp     @b
 
.next:
        jmp     esi
 
.forward:
        inc     dword[esp]
        mov     eax, [esp]
        mul     [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
        neg     ebx
        cmp     eax, [ebp+EXTFS.superblock.blocksTotal+ebx*4]
        ja      @f
        neg     ebx
        mov     eax, [esp]
        jmp     .test_block_group
 
@@:
        neg     ebx
        mov     eax, [esp+4]
        mov     [esp], eax
        mov     esi, .backward
.backward:
        sub     dword[esp], 1
        jc      .fail
        mov     eax, [esp]
        jmp     .test_block_group
 
extfsGetFileBlock:
;   in:
; ecx = file block number
; esi -> inode
;   out:
; ecx = block number
        test    [esi+INODE.featureFlags], EXTENTS_USED
        jz      .listTreeSearch
        pushad
        add     esi, INODE.blockNumbers
.extentTreeSearch:
        cmp     word [esi+NODEHEADER.magic], 0xF30A
        jne     .fail
        movzx   ebx, [esi+NODEHEADER.entriesFolow]
        add     esi, sizeof.NODEHEADER
        cmp     word [esi-sizeof.NODEHEADER+NODEHEADER.currentDepth], 0
        je      .leaf_block
        test    ebx, ebx
        jz      .fail   ; empty
@@:
        cmp     ebx, 1
        je      .end_search_index
        cmp     ecx, [esi+INDEX.fileBlock]
        jb      .fail
        cmp     ecx, [esi+sizeof.INDEX+INDEX.fileBlock]
        jb      .end_search_index
        add     esi, sizeof.INDEX
        dec     ebx
        jmp     @b
 
.end_search_index:
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     eax, [esi+INDEX.nodeBlock]
        call    extfsReadBlock
        jc      .fail
        mov     esi, ebx
        jmp     .extentTreeSearch
 
.leaf_block:
        test    ebx, ebx
        jz      .fail
        mov     edx, [esi+EXTENT.fileBlock]
        cmp     ecx, edx
        jb      .fail
        movzx   edi, [esi+EXTENT.blocksCount]
        add     edx, edi
        cmp     ecx, edx
        jb      .end_search_extent
        add     esi, sizeof.EXTENT
        dec     ebx
        jmp     .leaf_block
 
.end_search_extent:
        sub     ecx, [esi+EXTENT.fileBlock]
        add     ecx, [esi+EXTENT.fsBlock]
        mov     PUSHAD_ECX, ecx
        popad
        xor     eax, eax
        ret
 
.fail:
        popad
        movi    eax, ERROR_FS_FAIL
        stc
        ret
 
.get_indirect_block:
 
        mov     eax, [esi+INODE.addressBlock]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        mov     ecx, [ebx+ecx*4]
 
        pop     ebx edx
        ret
 
.get_direct_block:
        mov     ecx, [esi+INODE.blockNumbers+ecx*4]
        xor     eax, eax
        ret
 
.listTreeSearch:
        cmp     ecx, 12
        jb      .get_direct_block
        push    edx ebx
        sub     ecx, 12
        cmp     ecx, [ebp+EXTFS.dwordsPerBlock]
        jb      .get_indirect_block
        sub     ecx, [ebp+EXTFS.dwordsPerBlock]
        cmp     ecx, [ebp+EXTFS.dwordsPerBranch]
        jb      .get_double_indirect_block
; triply-indirect blocks
        sub     ecx, [ebp+EXTFS.dwordsPerBranch]
 
        mov     eax, [esi+INODE.tripleAddress]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        xor     edx, edx
        mov     eax, ecx
        div     [ebp+EXTFS.dwordsPerBranch]
; eax = number in triply-indirect block, edx = number in branch
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jz      .noBlock
        call    extfsReadBlock
        jc      .fail2
        mov     eax, edx
        jmp     @f
 
.noBlock:
        xor     ecx, ecx
.fail2:
 
 
        pop     ebx edx
        ret
 
.get_double_indirect_block:
 
        mov     eax, [esi+INODE.doubleAddress]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        mov     eax, ecx
@@:
        xor     edx, edx
        div     [ebp+EXTFS.dwordsPerBlock]
; eax = number in doubly-indirect block, edx = number in indirect block
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jz      .noBlock
        call    extfsReadBlock
        jc      .fail2
        mov     ecx, [ebx+edx*4]
 
        pop     ebx edx
        ret
 
extfsSetFileBlock:
;   in:
; ecx = file block number
; edi = block number
; edx = inode number
; esi -> inode
        push    ebx ecx edx
        cmp     ecx, 12
        jb      .direct_block
        sub     ecx, 12
        cmp     ecx, [ebp+EXTFS.dwordsPerBlock]
        jb      .indirect_block
        sub     ecx, [ebp+EXTFS.dwordsPerBlock]
        cmp     ecx, [ebp+EXTFS.dwordsPerBranch]
        jb      .double_indirect_block
; triple indirect blocks
        sub     ecx, [ebp+EXTFS.dwordsPerBranch]
        mov     eax, [esi+INODE.tripleAddress]
        test    eax, eax
        jnz     @f
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.tripleAddress], ebx
        mov     eax, ebx
@@:
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail_alloc_4
        xor     edx, edx
        mov     eax, ecx
        div     [ebp+EXTFS.dwordsPerBranch]
; eax = number in triply-indirect block, edx = number in branch
        lea     ecx, [ebx+eax*4]
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jnz     @f
        mov     eax, [esp+4]
        call    inodeBlockAlloc
        jc      .fail_alloc_4
        mov     [ecx], ebx
        mov     eax, [esp]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .fail_alloc_4
        mov     eax, [ecx]
@@:
        mov     [esp], eax
        call    extfsReadBlock
        jc      .fail_alloc_4
        mov     eax, edx
        jmp     @f
 
.double_indirect_block:
        mov     eax, [esi+INODE.doubleAddress]
        test    eax, eax
        jnz     .double_indirect_present
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.doubleAddress], ebx
        mov     eax, ebx
.double_indirect_present:
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail_alloc_4
        mov     eax, ecx
@@:
        xor     edx, edx
        div     [ebp+EXTFS.dwordsPerBlock]
; eax = number in doubly-indirect block, edx = number in indirect block
        lea     ecx, [ebx+edx*4]
        push    ecx
        lea     ecx, [ebx+eax*4]
        cmp     dword[ecx], 0
        jne     @f
        mov     eax, [esp+8]
        call    inodeBlockAlloc
        jc      .fail_alloc_8
        mov     [ecx], ebx
        mov     eax, [esp+4]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .fail_alloc_8
@@:
        mov     eax, [ecx]
        push    eax
        call    extfsReadBlock
        jc      .fail_alloc_12
        pop     eax ecx edx
        mov     [ecx], edi
        call    extfsWriteBlock
        jmp     .ret
 
.indirect_block:
        mov     eax, [esi+INODE.addressBlock]
        test    eax, eax
        jnz     @f
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.addressBlock], ebx
        mov     eax, ebx
@@:
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail_alloc_4
        mov     [ebx+ecx*4], edi
        pop     eax
        call    extfsWriteBlock
        jmp     .ret
 
.direct_block:
        mov     [esi+INODE.blockNumbers+ecx*4], edi
        xor     eax, eax
.ret:
        pop     edx ecx ebx
        ret
 
.fail_alloc_12:
        pop     ebx
.fail_alloc_8:
        pop     ebx
.fail_alloc_4:
        pop     ebx
        jmp     .ret
 
extfsEraseFileBlock:    ; also allocates
;   in:
; edx = inode number
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
        push    ebx ecx edx edi esi
        mov     edi, eax
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      .allocate
        mov     edx, ecx
        mov     ecx, [ebp+EXTFS.bytesPerBlock]
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        xor     eax, eax
        rep stosb
        mov     eax, edx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jmp     @f
 
.allocate:
        mov     eax, edx
        call    extfsBlockAlloc
        jc      @f
        mov     ecx, edi
        mov     edi, ebx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsSetFileBlock
        jc      @f
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        add     [esi+INODE.sectorsUsed], eax
        xor     eax, eax
@@:
        pop     esi edi edx ecx ebx
        ret
 
extfsFreeFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
        push    ebx ecx edx edi esi
        mov     edi, eax
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      @f
        mov     eax, ecx
        xor     ecx, ecx
        call    extfsResourceFree
        mov     ecx, edi
        xor     edi, edi
        movi    edx, ROOT_INODE
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsSetFileBlock
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        sub     [esi+INODE.sectorsUsed], eax
        xor     eax, eax
@@:
        pop     esi edi edx ecx ebx
        ret
 
extfsReadFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
;   out:
; [ebp+EXTFS.mainBlockBuffer] -> block
        push    ebx ecx edx esi
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      .ret
        test    ecx, ecx
        jz      @f
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
.ret:
        pop     esi edx ecx ebx
        ret
 
@@:
        movi    eax, ERROR_FS_FAIL
        stc
        jmp     .ret
 
extfsWriteFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
; [ebp+EXTFS.mainBlockBuffer] -> block to write
        push    ebx ecx edx esi
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      @b
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsWriteBlock
@@:
        pop     esi edx ecx ebx
        ret
 
getInodeLocation:
; in: eax = inode number
;   out:
; ebx = inode sector
; edx = offset in sector
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        mov     ecx, edx
        shl     eax, 5
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        add     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        inc     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      @f
        add     ebx, edx
        mov     ebx, [ebx+BGDESCR.inodeTable]
        mov     eax, ecx
        mov     ecx, [ebp+EXTFS.sectorsPerBlockLog]
        shl     ebx, cl
        mul     [ebp+EXTFS.superblock.inodeSize]
        mov     edx, eax
        shr     eax, 9
        and     edx, 511
        add     ebx, eax
        xor     eax, eax
@@:
        ret
 
writeInode:
;   in:
; eax = inode number
; ebx -> inode data
        push    edx edi esi ecx ebx eax
        mov     edi, ebx
        call    fsGetTime
        add     eax, 978307200
        mov     [edi+INODE.inodeModified], eax
        pop     eax
        call    getInodeLocation
        jc      .ret
        mov     eax, ebx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     ecx, eax
        call    fs_read32_sys
        test    eax, eax
        jnz     @f
        mov     eax, ecx
        mov     esi, edi
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     edi, edx
        add     edi, ebx
        rep movsb
        call    fs_write32_sys
.ret:
        pop     ebx ecx esi edi edx
        ret
 
@@:
        movi    eax, ERROR_DEVICE
        stc
        jmp     .ret
 
readInode:
;   in:
; eax = inode number
; ebx -> inode buffer
        push    edx edi esi ecx ebx
        mov     edi, ebx
        call    getInodeLocation
        jc      @f
        mov     eax, ebx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    fs_read32_sys
        test    eax, eax
        jnz     @b
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     esi, edx
        add     esi, ebx
        rep movsb
        xor     eax, eax
@@:
        pop     ebx ecx esi edi edx
        ret
 
extfsExtendFile:
;   in:
; [ebp+EXTFS.inodeBuffer] = inode
; eax = inode number
; ecx = new size
        push    ebx ecx edx esi edi eax
        lea     ebx, [ebp+EXTFS.inodeBuffer]
 
 
        cmp     [ebx+INODE.fileSize], ecx
        jnc     .ret
        mov     eax, [ebx+INODE.fileSize]
        push    eax
        sub     ecx, eax
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        test    edx, edx
        jz      .start_aligned
        mov     esi, [ebp+EXTFS.bytesPerBlock]
        sub     esi, edx
        cmp     esi, ecx
        jbe     @f
        mov     esi, ecx
@@: ; clear esi trailing bytes in block number eax
        push    eax
        call    extfsReadFileBlock
        pop     edi
        jc      .error_inode_size
        push    edi ecx
        xor     eax, eax
        mov     ecx, esi
        mov     edi, ebx
        add     edi, edx
        rep stosb
        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        add     [esp], esi
        sub     ecx, esi
        jz      .done
.start_aligned:
        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
        jb      @f
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        mov     edx, [esp+4]
        call    extfsEraseFileBlock
        jc      .error_inode_size
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        sub     ecx, eax
        add     [esp], eax
        jmp     .start_aligned
 
@@: ; handle the remaining bytes
        test    ecx, ecx
        jz      .done
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        mov     edx, [esp+4]
        call    extfsEraseFileBlock
        jc      .error_inode_size
        add     [esp], ecx
.done:
        xor     eax, eax
.error_inode_size:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     [ebx+INODE.fileSize]
 
 
 
 
 
 
 
.ret:
        pop     edi edi esi edx ecx ebx
        ret
 
extfsTruncateFile:
;   in:
; [ebp+EXTFS.inodeBuffer] = inode
; ecx = new size
        push    ebx ecx edx esi edi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
 
 
        cmp     ecx, [ebx+INODE.fileSize]
        jnc     .ret
        mov     eax, [ebx+INODE.fileSize]
        push    eax
        sub     ecx, eax
        not     ecx
        inc     ecx
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        test    edx, edx
        jz      .start_aligned
        mov     esi, edx
        cmp     esi, ecx
        jbe     @f
; if the size to truncate is smaller than the unaligned bytes
; we're going to clear neccessary bytes from the EOF
        push    eax
        call    extfsReadFileBlock
        pop     edi
        jc      .error_inode_size
        push    edi ecx
        mov     edi, [ebp+EXTFS.mainBlockBuffer]
        sub     edx, ecx
        add     edi, edx
        xor     eax, eax
        rep stosb
        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        sub     [esp], ecx
        jmp     .done
 
@@:
        call    extfsFreeFileBlock
        sub     [esp], esi
        sub     ecx, esi
        jz      .done
.start_aligned:
        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
        jb      @f
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        dec     eax
        call    extfsFreeFileBlock
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        sub     ecx, eax
        sub     [esp], eax
        jmp     .start_aligned
 
@@: ; handle the remaining bytes
        test    ecx, ecx
        jz      .done
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        dec     eax
        push    eax
        call    extfsReadFileBlock
        pop     edi
        jc      .error_inode_size
        push    edi ecx
        mov     edi, [ebp+EXTFS.mainBlockBuffer]
        mov     edx, [ebp+EXTFS.bytesPerBlock]
        sub     edx, ecx
        add     edi, edx
        xor     eax, eax
        rep stosb
        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        sub     [esp], ecx
.done:
        xor     eax, eax
.error_inode_size:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     [ebx+INODE.fileSize]
 
 
 
 
 
 
 
.ret:
        pop     edi esi edx ecx ebx
        ret
 
linkInode:
;   in:
; eax = inode on which to link
; ebx = inode to link
; esi -> name in UTF-8
;  dl = file type
        push    esi edi ebx ecx eax edx
        call    strlen
        add     ecx, 8  ; directory entry size
        push    esi ebx ecx
        xor     ecx, ecx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ebx, esi
        call    readInode
        jc      .error_inode_read
        mov     ecx, [ebp+EXTFS.sectorsPerBlockLog]
        mov     eax, [esi+INODE.sectorsUsed]
        shr     eax, cl
        xor     ecx, ecx
 
 
.searchBlock:
        push    eax     ; blocks total
        push    ecx     ; current file block number
        cmp     eax, ecx
        jz      .alloc_block
        call    extfsGetFileBlock
        jc      .error_get_inode_block
        test    ecx, ecx
        jz      .alloc_block
        push    ecx
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .error_block_read
        mov     ecx, [esp+12]
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        mov     edx, edi
        add     edx, [ebp+EXTFS.bytesPerBlock]
.searchSpace:
        movzx   eax, [edi+DIRENTRY.entryLength]
        test    eax, eax
        jz      .zeroLength
        cmp     [edi+DIRENTRY.inodeNumber], 0
        je      .unusedEntry
        movzx   ebx, [edi+DIRENTRY.nameLength]
        add     ebx, 8+3
        and     ebx, -4
        sub     eax, ebx
        add     edi, ebx
        cmp     eax, ecx
        jb      .nextEntry
        sub     edi, ebx
        mov     [edi+DIRENTRY.entryLength], bx
        add     edi, ebx
        mov     [edi+DIRENTRY.entryLength], ax
        jmp     .found
 
.unusedEntry:
        cmp     eax, ecx
        jge     .found
.nextEntry:
        add     edi, eax
        cmp     edi, edx
        jb      .searchSpace
        pop     ecx ecx eax
        inc     ecx
        jmp     .searchBlock
 
.zeroLength:
        mov     [edi+DIRENTRY.entryLength], cx
        mov     eax, edx
        sub     eax, edi
        cmp     eax, ecx
        jge     .found
        mov     [edi+DIRENTRY.inodeNumber], 0
        mov     [edi+DIRENTRY.entryLength], ax
; this block wasn't linking to the next one, so write it, and use the next block
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .error_get_inode_block
        inc     dword[esp]
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .error_get_inode_block
        test    ecx, ecx
        jz      .alloc_block
        push    ecx
        jmp     .prepare_block
 
 
 
 
 
 
 
.alloc_block:
        mov     eax, [esp+24]
        mov     edx, eax
        call    extfsBlockAlloc
        jc      .error_get_inode_block
        mov     ecx, [esp]
        mov     edi, ebx
        call    extfsSetFileBlock
        jc      .error_get_inode_block
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        add     [esi+INODE.fileSize], eax
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        add     [esi+INODE.sectorsUsed], eax
        mov     eax, [esp+24]
        mov     ebx, esi
        call    writeInode
        jc      .error_get_inode_block
        push    edi     ; save the block we just allocated
.prepare_block:
        mov     eax, [esp]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .error_block_read
        mov     edi, ebx
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        mov     [edi+DIRENTRY.entryLength], ax
.found:
        pop     edx ecx ecx ecx ebx esi
        push    ebx
        mov     [edi], ebx  ; save inode
        mov     eax, [esp+4]
        cmp     [ebp+EXTFS.superblock.dynamicVersionFlag], 0
        je      .name
        mov     [edi+DIRENTRY.fileType], al
.name:
        sub     ecx, 8
        mov     [edi+DIRENTRY.nameLength], cl
        add     edi, 8
        rep movsb
        mov     eax, edx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .error_block_write
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .error_block_write
        pop     eax
        inc     [ebx+INODE.linksCount]
        call    writeInode
        jc      @f
        xor     eax, eax
@@:
        pop     edx ecx ecx ebx edi esi
        ret
 
.error_block_read:
        pop     ebx
.error_get_inode_block:
        pop     ebx ebx
.error_inode_read:
        pop     ebx ebx
.error_block_write:
        pop     ebx
        jmp     @b
 
unlinkInode:
;   in:
; eax = inode from which to unlink
; ebx = inode to unlink
;   out:
; eax = current number of links to inode, -1 = error
        push    edx ebx
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .fail
        push    eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
.loop:
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .fail_loop
        test    ecx, ecx
        jz      .fail_loop
        mov     eax, ecx
        mov     edi, ecx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail_loop
.first_dir_entry:   ; edi -> block
        mov     eax, [esp+4]
        cmp     [ebx+DIRENTRY.inodeNumber], eax
        jne     @f
        mov     [ebx+DIRENTRY.inodeNumber], 0
        mov     word [ebx+DIRENTRY.nameLength], 0   ; fileType = 0
        jmp     .write_block
 
@@:
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
        push    edx
        mov     edx, ebx
        movzx   ecx, [ebx+DIRENTRY.entryLength]
        add     ebx, ecx
.dir_entry:
        cmp     [ebx+DIRENTRY.inodeNumber], eax
        jne     @f
        mov     cx, [ebx+DIRENTRY.entryLength]
        add     [edx+DIRENTRY.entryLength], cx
        pop     eax
        jmp     .write_block
 
@@:
        mov     edx, ebx
        movzx   ecx, [ebx+DIRENTRY.entryLength]
        test    ecx, ecx
        jz      .fail_inode
        add     ebx, ecx
        cmp     ebx, [esp]
        jb      .dir_entry
        pop     ecx
        inc     dword[esp]
        jmp     .loop
 
.fail_inode:
        pop     eax
.fail_loop:
        pop     eax
.fail:
        or      eax, -1
        jmp     @f
 
.write_block:
        pop     eax
        mov     eax, edi
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .fail
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .fail
        dec     word [ebx+INODE.linksCount]
        mov     eax, [esp]
        call    writeInode
        jc      .fail
        movzx   eax, word [ebx+INODE.linksCount]
@@:
        pop     ebx edx
        ret
 
findInode:
; in: esi -> path string in UTF-8
;   out:
; edi -> file name in UTF-8
; esi = last inode number
; [ebp+EXTFS.inodeBuffer] = last inode
; ecx = parent inode number
; CF=1 -> file not found, edi=0 -> error
        push    esi
        lea     esi, [ebp+EXTFS.rootInodeBuffer]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     edx, esi
        rep movsb
        pop     esi
        pushd   0 ROOT_INODE
        mov     edi, esi
        cmp     [edx+INODE.sectorsUsed], 0
        jz      .not_found
        cmp     byte [esi], 0
        jnz     .next_path_part
        xor     eax, eax
 
        pop     esi ecx
        ret
 
@@:
        pop     esi esi
.error:
        pop     esi ecx
        xor     edi, edi
        stc
        ret
 
.next_path_part:
        push    [edx+INODE.sectorsUsed]
        xor     ecx, ecx
.folder_block_cycle:
        push    ecx
        xchg    esi, edx
        call    extfsGetFileBlock
        jc      @b
        xchg    esi, edx
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      @b
        push    esi edx
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
.start_rec:
        cmp     [ebx+DIRENTRY.inodeNumber], 0
        jz      .next_rec
        push    esi
        movzx   ecx, [ebx+DIRENTRY.nameLength]
        lea     edi, [ebx+DIRENTRY.name]
        repz cmpsb
        jz      .test_find
@@: ; doesn't match
        pop     esi
.next_rec:
        movzx   eax, [ebx+DIRENTRY.entryLength]
        add     ebx, eax
        cmp     ebx, edx
        jb      .start_rec
        push    eax
        jmp     @f
 
.test_find:
        cmp     byte [esi], 0
        je      @f
        cmp     byte [esi], '/'
        jne     @b
        inc     esi
@@:
        pop     edx edx edi ecx eax
; ebx -> matched directory entry, esi -> name without parent, or not changed
        cmp     edi, esi
        jnz     @f
        sub     eax, [ebp+EXTFS.sectorsPerBlock]
        jle     .not_found
        push    eax
        inc     ecx
        jmp     .folder_block_cycle
 
@@:
        pop     eax
        mov     [esp], eax
        mov     eax, [ebx+DIRENTRY.inodeNumber]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        push    eax
        call    readInode
        jc      .error
        cmp     byte [esi], 0
        je      .ret
        mov     edx, ebx
        movzx   eax, [ebx+INODE.accessMode]
        and     eax, TYPE_MASK
        cmp     eax, DIRECTORY
        jz      .next_path_part
        xor     edi, edi    ; path folder is a file
        jmp     @f
 
.not_found:
        mov     esi, edi
        call    strlen
        mov     al, '/'
        repnz scasb
        mov     edi, esi
        jnz     @f
        xor     edi, edi    ; path folder not found
@@:
        movi    eax, ERROR_FILE_NOT_FOUND
        stc
.ret:
        pop     esi ecx
        ret
 
writeSuperblock:
        push    ebx
        mov     eax, 2
        lea     ebx, [ebp+EXTFS.superblock]
        call    fs_write32_sys
        pop     ebx
        ret
 
extfsWritingInit:
        movi    eax, ERROR_ACCESS_DENIED
        cmp     byte [esi], 0
        jz      @f
        movi    eax, ERROR_UNSUPPORTED_FS
        test    [ebp+EXTFS.mountType], READ_ONLY
        jnz     @f
ext_lock:
        lea     ecx, [ebp+EXTFS.Lock]
        jmp     mutex_lock
 
@@:
        pop     ebx
        xor     ebx, ebx
        ret
 
ext_unlock:
        lea     ecx, [ebp+EXTFS.Lock]
        jmp     mutex_unlock
 
;----------------------------------------------------------------
ext_ReadFolder:
        call    ext_lock
        cmp     byte [esi], 0
        jz      .root_folder
        push    ebx
        call    findInode
        pop     ebx
        jc      .error_ret
        lea     esi, [ebp+EXTFS.inodeBuffer]
        test    [esi+INODE.accessMode], FLAG_FILE
        jnz     .error_not_found
        jmp     @f
 
.root_folder:
        lea     esi, [ebp+EXTFS.rootInodeBuffer]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        shr     ecx, 2
        push    edi
        rep movsd
        pop     esi
@@:
        cmp     [esi+INODE.fileSize], 0
        je      .error_empty_dir
        mov     edx, [ebx+16]
        push    edx         ; [edi+28] result buffer
        push    0           ; [edi+24] end of the current block in folder
        pushd   [ebx+12]    ; [edi+20] files to read
        pushd   [ebx+4]     ; [edi+16] first wanted file
        pushd   [ebx+8]     ; [edi+12] flags
        push    0           ; [edi+8]  read files
        push    0           ; [edi+4]  files in folder
        push    0           ; [edi]    current block index
        mov     edi, esp    ; edi -> local variables
        add     edx, 32
        xor     ecx, ecx
        call    extfsGetFileBlock
        jc      .error_get_block
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      .error_get_block
        mov     eax, ebx
        add     eax, [ebp+EXTFS.bytesPerBlock]
        mov     [edi+24], eax
        mov     ecx, [edi+16]
.find_wanted_start:
        jecxz   .find_wanted_end
.find_wanted_cycle:
        cmp     [ebx+DIRENTRY.inodeNumber], 0
        jz      @f
        inc     dword [edi+4]
        dec     ecx
@@:
        movzx   eax, [ebx+DIRENTRY.entryLength]
        cmp     eax, 12     ; minimum entry length
        jb      .error_bad_len
        test    eax, 3      ; length must be aligned
        jnz     .error_bad_len
        sub     [esi+INODE.fileSize], eax
        add     ebx, eax
        cmp     ebx, [edi+24]
        jb      .find_wanted_start
        push    .find_wanted_start
.end_block: ; read next block
        cmp     [esi+INODE.fileSize], 0
        jle     .end_dir
        inc     dword [edi]
        push    ecx
        mov     ecx, [edi]
        call    extfsGetFileBlock
        jc      .error_get_block
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      .error_get_block
        pop     ecx
        mov     eax, ebx
        add     eax, [ebp+EXTFS.bytesPerBlock]
        mov     [edi+24], eax
        ret
 
.wanted_end:
        loop    .find_wanted_cycle
.find_wanted_end:
        mov     ecx, [edi+20]
.wanted_start:
        jecxz   .wanted_end
        cmp     [ebx+DIRENTRY.inodeNumber], 0
        jz      .empty_rec
        inc     dword [edi+8]
        inc     dword [edi+4]
        push    ebx edi ecx esi edx edi
        pushd   [edi+12]
        mov     edi, edx
        xor     eax, eax
        mov     ecx, 40 / 4
        rep stosd
        popd    [edx+4] edi
        mov     eax, [ebx+DIRENTRY.inodeNumber]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    readInode
        jc      .error_read_subinode
        mov     esi, ebx
        lea     edi, [edx+8]
        mov     eax, [ebx+INODE.inodeModified]
        sub     eax, 978307200  ; 01.01.1970-01.01.2001 = (365*31+8)*24*60*60
        call    fsTime2bdfe
 
        mov     eax, [esi+INODE.accessedTime]
        sub     eax, 978307200
        call    fsTime2bdfe
 
        mov     eax, [esi+INODE.dataModified]
        sub     eax, 978307200
        call    fsTime2bdfe
        pop     edx
        or      dword [edx], KOS_DIRECTORY
        test    [esi+INODE.accessMode], FLAG_FILE
        jz      @f
        xor     dword [edx], KOS_DIRECTORY  ; mark as file
        mov     eax, [esi+INODE.fileSize]
        stosd
        mov     eax, [esi+INODE.fileSizeHigh]
        stosd
@@:
        mov     esi, [esp+12]
        movzx   ecx, [esi+DIRENTRY.nameLength]
        lea     esi, [esi+DIRENTRY.name]
        add     ecx, esi
        cmp     byte [esi], '.'
        jnz     @f
        or      byte [edx], KOS_HIDDEN
@@:
        lea     edi, [edx+40]
        cmp     byte [edx+4], 1
        jz      .utf16
@@:
        call    utf8to16
        call    uni2ansi_char
        stosb
        cmp     esi, ecx
        jc      @b
        and     byte [edi], 0
        add     edx, 40+264
@@:
        pop     esi ecx edi ebx
        dec     ecx
.empty_rec:
        movzx   eax, [ebx+DIRENTRY.entryLength]
        cmp     eax, 12
        jb      .error_bad_len
        test    eax, 3
        jnz     .error_bad_len
        sub     [esi+INODE.fileSize], eax
        add     ebx, eax
        cmp     ebx, [edi+24]
        jb      .wanted_start
        push    .wanted_start
        jmp     .end_block
 
.utf16:
        call    utf8to16
        stosw
        cmp     esi, ecx
        jc      .utf16
        and     word [edi], 0
        add     edx, 40+520
        jmp     @b
 
.end_dir:
        call    ext_unlock
        mov     edx, [edi+28]
        mov     ebx, [edi+8]
        mov     ecx, [edi+4]
        mov     dword [edx], 1  ; version
        mov     [edx+4], ebx
        mov     [edx+8], ecx
        lea     esp, [edi+32]
        mov     ecx, 20/4
        lea     edi, [edx+12]
        xor     eax, eax
        rep stosd
        ret
 
.error_bad_len:
        movi    eax, ERROR_FS_FAIL
.error_read_subinode:
.error_get_block:
        lea     esp, [edi+32]
.error_ret:
        or      ebx, -1
        push    eax
        call    ext_unlock
        pop     eax
        ret
 
.error_empty_dir:
        movi    eax, ERROR_FS_FAIL
        jmp     .error_ret
 
.error_not_found:
        movi    eax, ERROR_FILE_NOT_FOUND
        jmp     .error_ret
 
;----------------------------------------------------------------
ext_ReadFile:
        call    ext_lock
        push    ERROR_ACCESS_DENIED
        cmp     byte [esi], 0
        jz      .error  ; root
        mov     [esp], ebx
        call    findInode
        pop     ebx
        jc      .error_eax
        push    ERROR_ACCESS_DENIED
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ax, [esi+INODE.accessMode]
        and     ax, TYPE_MASK
        cmp     ax, FLAG_FILE
        jnz     .error  ; not a file
        pop     eax
        mov     edi, [ebx+16]
        mov     ecx, [ebx+12]
        mov     eax, [ebx+4]
        mov     edx, [ebx+8]
        push    ERROR_END_OF_FILE
        cmp     [esi+INODE.fileSizeHigh], edx
        ja      @f
        jb      .error
        cmp     [esi+INODE.fileSize], eax
        jna     .error
@@:
        add     esp, 4
        add     eax, ecx
        adc     edx, 0
        cmp     [esi+INODE.fileSizeHigh], edx
        ja      .read_till_requested
        jb      .read_whole_file
        cmp     [esi+INODE.fileSize], eax
        jae     .read_till_requested
.read_whole_file:
        push    1   ; read till the end of file
        mov     ecx, [esi+INODE.fileSize]
        sub     ecx, [ebx+4]
        jmp     @f
 
.read_till_requested:
        push    0   ; read as much as requested
@@: ; ecx = bytes to read, edi -> buffer
        push    ecx
; read part of the first block
        mov     edx, [ebx+8]
        mov     eax, [ebx+4]
        div     [ebp+EXTFS.bytesPerBlock]
        push    eax
        push    ecx
        mov     ecx, eax
        call    extfsGetFileBlock
        jc      .error_at_first_block
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        mov     eax, ecx
        call    extfsReadBlock
        jc      .error_at_first_block
        pop     ecx
        add     ebx, edx
        neg     edx
        add     edx, [ebp+EXTFS.bytesPerBlock]
        cmp     ecx, edx
        jbe     .only_one_block
        mov     eax, ecx
        sub     eax, edx    ; bytes to read
        mov     ecx, edx
        push    esi
        mov     esi, ebx
        rep movsb
        pop     esi
        mov     ebx, edi
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        mov     edi, eax
@@:
        test    edi, edi
        jz      .finish_block
        inc     dword [esp]
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .error_at_read_cycle
        mov     eax, ecx
        call    extfsReadBlock
        jc      .error_at_read_cycle
        add     ebx, [ebp+EXTFS.bytesPerBlock]
        dec     edi
        jmp     @b
 
.finish_block:  ; edx = number of bytes in the last block
        test    edx, edx
        jz      .end_read
        pop     ecx     ; block counter
        inc     ecx
        call    extfsGetFileBlock
        jc      .error_at_finish_block
        mov     edi, ebx
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      .error_at_finish_block
        push    eax
        mov     ecx, edx
.only_one_block:
        mov     esi, ebx
        rep movsb
.end_read:
        call    ext_unlock
        pop     eax ebx eax
        test    eax, eax
        jz      @f
        movi    eax, ERROR_END_OF_FILE
@@:
        ret
 
.error_at_first_block:
        pop     ebx
.error_at_read_cycle:
        pop     ebx
.error_at_finish_block:
        pop     ebx ebx
.error_eax:
        push    eax
.error:
        call    ext_unlock
        xor     ebx, ebx
        pop     eax
        ret
 
;----------------------------------------------------------------
ext_GetFileInfo:
        call    ext_lock
        mov     edx, [ebx+16]
        cmp     byte [esi], 0
        jz      .is_root
        push    edx
        call    findInode
        pop     edx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        jnc     @f
        push    eax
        call    ext_unlock
        pop     eax
        ret
 
.is_root:
        mov     edi, esi
        lea     esi, [ebp+EXTFS.rootInodeBuffer]
@@:
        mov     bl, [edi]
        xor     eax, eax
        mov     edi, edx
        mov     ecx, 40/4
        rep stosd
        cmp     bl, '.'
        jne     @f
        or      dword [edx], KOS_HIDDEN
@@:
        or      dword [edx], KOS_DIRECTORY
        test    [esi+INODE.accessMode], FLAG_FILE
        jz      @f
        xor     dword [edx], KOS_DIRECTORY  ; mark as file
        mov     eax, [esi+INODE.fileSize]
        mov     ebx, [esi+INODE.fileSizeHigh]
        mov     dword [edx+32], eax
        mov     dword [edx+36], ebx
@@:
        lea     edi, [edx+8]
        mov     eax, [esi+INODE.inodeModified]
        sub     eax, 978307200  ; 01.01.1970-01.01.2001 = (365*31+8)*24*60*60
        call    fsTime2bdfe
 
        mov     eax, [esi+INODE.accessedTime]
        sub     eax, 978307200
        call    fsTime2bdfe
 
        mov     eax, [esi+INODE.dataModified]
        sub     eax, 978307200
        call    fsTime2bdfe
        call    ext_unlock
        xor     eax, eax
        ret
 
;----------------------------------------------------------------
ext_SetFileInfo:
        call    extfsWritingInit
        pushd   [ebx+16]
        call    findInode
        pop     edx
        jc      @f
        push    esi     ; inode number
        lea     esi, [edx+16]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsCalculateTime
        add     eax, 978307200  ; 01.01.1970-01.01.2001 = (365*31+8)*24*60*60
        mov     [edi+INODE.accessedTime], eax
 
        add     esi, 8
        call    fsCalculateTime
        add     eax, 978307200
        mov     [edi+INODE.dataModified], eax
        mov     ebx, edi
        pop     eax
        call    writeInode
@@:
        push    eax
        jc      @f
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
@@:
        call    ext_unlock
        pop     eax
        ret
 
;----------------------------------------------------------------
ext_Delete:
        call    extfsWritingInit
        call    findInode
        mov     ebx, esi
        push    eax
        jc      .ret
        pop     eax
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movzx   edx, [edx+INODE.accessMode]
        and     edx, TYPE_MASK
        cmp     edx, DIRECTORY
        jne     .file
        push    ebx ecx edx 0
        lea     esi, [ebp+EXTFS.inodeBuffer]
.checkDirectory:
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .not_empty_eax
        test    ecx, ecx
        jz      .empty
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .not_empty_eax
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
        movzx   ecx, [ebx+DIRENTRY.entryLength]
        add     ebx, ecx
.dir_entry:
        cmp     byte [ebx+DIRENTRY.nameLength], 1
        jne     @f
        cmp     byte [ebx+DIRENTRY.name], '.'
        jne     .not_empty
@@:
        cmp     byte [ebx+DIRENTRY.nameLength], 2
        jne     .not_empty
        cmp     word [ebx+DIRENTRY.name], '..'
        jne     .not_empty
        movzx   ecx, [ebx+DIRENTRY.entryLength]
        add     ebx, ecx
        cmp     ebx, edx
        jb      .dir_entry
        inc     dword[esp]
        jmp     .checkDirectory
 
.empty:
        pop     edx edx ecx ebx
.file:
        mov     eax, ecx
        push    ebx ecx
        call    unlinkInode
        cmp     eax, -1
        je      .error_stack8
        pop     ebx
        test    eax, eax
        jz      @f
        xor     eax, eax
        cmp     edx, DIRECTORY
        jnz     .error_stack4_eax   ; hardlinks
        mov     eax, [esp]
        call    unlinkInode
@@:
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .error_stack4_eax
; free file's data
        lea     esi, [ebp+EXTFS.inodeBuffer]
        xor     ecx, ecx
@@:
        push    ecx
        call    extfsGetFileBlock
        jc      .error_stack8_eax
        mov     eax, ecx
        test    eax, eax
        jz      @f
        xor     ecx, ecx
        call    extfsResourceFree
        pop     ecx
        inc     ecx
        jmp     @b
 
@@: ; free indirect blocks
        pop     ecx
        push    edx
        lea     edi, [ebp+EXTFS.inodeBuffer]
        mov     eax, [edi+INODE.addressBlock]
        test    eax, eax
        jz      .success
        xor     ecx, ecx
        call    extfsResourceFree
        mov     eax, [edi+INODE.doubleAddress]
        call    freeDoublyIndirectBlock
        cmp     eax, 1
        je      .success
        mov     eax, [edi+INODE.tripleAddress]
        test    eax, eax
        jz      .success
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        pop     ecx
        jc      .error_stack8_eax
        mov     eax, ecx
        xor     ecx, ecx
        call    extfsResourceFree
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
@@:
        mov     eax, [ebx]
        test    eax, eax
        jz      .success
        push    ebx edx
        call    freeDoublyIndirectBlock
        pop     edx ebx
        cmp     eax, 1
        je      .success
        add     ebx, 4
        cmp     ebx, edx
        jb      @b
.success:   ; clear the inode, and add deletion time
        xor     eax, eax
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        pop     edx
        add     eax, 978307200
        mov     [edi+INODE.deletedTime], eax
        mov     eax, [esp]
        mov     ebx, edi
        call    writeInode
        jc      .error_stack4_eax
        cmp     edx, DIRECTORY
        jne     @f
        mov     eax, [esp]
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        push    eax
        call    extfsReadDescriptor
        jc      .error_stack8
        dec     [eax+BGDESCR.directoriesCount]
        pop     eax
        call    extfsWriteDescriptor
@@: ; free inode
        pop     eax
        dec     eax
        xor     ecx, ecx
        inc     ecx
        call    extfsResourceFree
        push    eax
.disk_sync:
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
.ret:
        call    ext_unlock
        xor     ebx, ebx
        pop     eax
        ret
 
.not_empty:
        pop     eax
.error_stack8:
        pop     eax eax
        push    ERROR_ACCESS_DENIED
        jmp     .disk_sync
 
.not_empty_eax:
        pop     ebx
.error_stack8_eax:
        pop     ebx
.error_stack4_eax:
        pop     ebx
.error:
        push    eax
        jmp     .disk_sync
 
;----------------------------------------------------------------
ext_CreateFolder:
        call    extfsWritingInit
        call    findInode
        jnc     .success    ; exist
        test    edi, edi
        jz      .error
        mov     eax, esi
        xor     ebx, ebx
        inc     ebx
        call    extfsResourceAlloc
        jc      .error
        inc     ebx
        push    ebx esi edi
        xor     al, al
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        add     eax, 978307200
        mov     [edi+INODE.accessedTime], eax
        mov     [edi+INODE.dataModified], eax
        mov     ebx, edi
        pop     edi esi edx
; edx = allocated inode number, edi -> filename, esi = parent inode number
        mov     [ebx+INODE.accessMode], DIRECTORY or PERMISSIONS
        mov     eax, edx
        call    writeInode
        jc      .error
; link to self
        push    edx esi
        mov     eax, edx
        mov     ebx, eax
        mov     dl, DIR_DIRECTORY
        mov     esi, self_link
        call    linkInode
        pop     esi edx
        jc      .error
; link to parent
        push    edx esi
        mov     eax, ebx
        mov     ebx, esi
        mov     dl, DIR_DIRECTORY
        mov     esi, parent_link
        call    linkInode
        pop     esi edx
        jc      .error
; link parent to child
        mov     eax, esi
        mov     ebx, edx
        mov     esi, edi
        mov     dl, DIR_DIRECTORY
        call    linkInode
        jc      .error
        mov     eax, ebx
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        mov     edx, eax
        call    extfsReadDescriptor
        jc      @f
        inc     [eax+BGDESCR.directoriesCount]
        mov     eax, edx
        call    extfsWriteDescriptor
.success:
.error:
        push    eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
        call    ext_unlock
        pop     eax
        ret
 
@@:
        movi    eax, ERROR_DEVICE
        jmp     .error
 
self_link   db ".", 0
parent_link db "..", 0
 
;----------------------------------------------------------------
ext_CreateFile:
        call    extfsWritingInit
        push    0 ebx
        call    findInode
        jnc     .exist
        test    edi, edi
        jz      .error
        mov     eax, esi
        xor     ebx, ebx
        inc     ebx
        call    extfsResourceAlloc
        jc      .error
        inc     ebx
        push    ebx ebx esi edi
        xor     al, al
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        add     eax, 978307200
        mov     [edi+INODE.accessedTime], eax
        mov     [edi+INODE.dataModified], eax
        mov     ebx, edi
        pop     edi esi edx
; edx = allocated inode number, edi -> filename, esi = parent inode number
        mov     [ebx+INODE.accessMode], FLAG_FILE or PERMISSIONS
        mov     eax, edx
        call    writeInode
        jc      .error2
; link parent to child
        mov     eax, esi
        mov     ebx, edx
        mov     esi, edi
        mov     dl, DIR_FLAG_FILE
        call    linkInode
        jc      .error2
        pop     esi ebx
        push    ebx esi
        mov     ecx, [ebx+12]
        jmp     ext_WriteFile.start
 
.exist:
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        test    [edx+INODE.accessMode], FLAG_FILE
        jz      .error  ; not a file
        pop     ebx
        push    ebx esi
 
        mov     ecx, [ebx+12]
        call    extfsTruncateFile
        jnc     ext_WriteFile.start
.error2:
        pop     ebx
.error:
        push    eax
        call    ext_unlock
        pop     eax ebx ebx
        xor     ebx, ebx
        ret
 
;----------------------------------------------------------------
ext_WriteFile:
        call    extfsWritingInit
        push    0 ebx
        call    findInode
        pop     ebx
        push    ebx esi
        jc      .error
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        test    [edx+INODE.accessMode], FLAG_FILE
        jz      .error  ; not a file
        mov     ecx, [ebx+4]
        add     ecx, [ebx+12]
.start:
        mov     eax, esi
        call    extfsExtendFile
        jc      .error
        mov     eax, [ebx+4]
        mov     ecx, [ebx+12]
        mov     esi, [ebx+16]
        push    eax
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        test    edx, edx
        jz      .start_aligned
        mov     ebx, [ebp+EXTFS.bytesPerBlock]
        sub     ebx, edx
        cmp     ebx, ecx
        jbe     @f
        mov     ebx, ecx
@@:
        push    eax
        call    extfsReadFileBlock
        pop     edi
        jc      .error_inode_size
        mov     eax, edi
        push    ecx
        mov     ecx, ebx
        mov     edi, ebx
        add     edi, edx
        rep movsb
        pop     ecx
        call    extfsWriteFileBlock
        jc      .error_inode_size
        add     [esp], ebx
        sub     ecx, ebx
        jz      .write_inode
.start_aligned:
        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
        jb      @f
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        mov     edx, [esp+4]
        push    eax
        call    extfsEraseFileBlock
        pop     edi
        jc      .error_inode_size
        mov     eax, edi
        push    ecx
        mov     ecx, [ebp+EXTFS.bytesPerBlock]
        mov     edi, [ebp+EXTFS.mainBlockBuffer]
        rep movsb
        pop     ecx
        call    extfsWriteFileBlock
        jc      .error_inode_size
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        sub     ecx, eax
        add     [esp], eax
        jmp     .start_aligned
@@:         ; Handle the remaining bytes.
        test    ecx, ecx
        jz      .write_inode
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        push    eax
        call    extfsReadFileBlock
        pop     eax
        jnc     @f
        mov     edx, [esp+4]
        push    eax
        call    extfsEraseFileBlock
        pop     edi
        jc      .error_inode_size
        mov     eax, edi
@@:
        push    ecx
        mov     edi, [ebp+EXTFS.mainBlockBuffer]
        rep movsb
        pop     ecx
        call    extfsWriteFileBlock
        jc      .error_inode_size
        add     [esp], ecx
        xor     ecx, ecx
.error_inode_size:
        mov     [esp+12], eax
.write_inode:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     eax eax
        call    writeInode
        pop     ebx
        mov     ebx, [ebx+12]
        sub     ebx, ecx
        test    eax, eax
        jz      @f
        mov     [esp], eax
@@:
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
@@:
        call    ext_unlock
        pop     eax
        ret
 
.error:
        pop     ebx ebx ebx
        push    eax
        jmp     @b
 
;----------------------------------------------------------------
ext_SetFileEnd:
        call    extfsWritingInit
        pushd   [ebx+4]
        call    findInode
        pop     ecx
        jc      @f
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        cmp     [edx+INODE.accessMode], FLAG_FILE
        jnz     @f      ; not a file
        mov     eax, esi
        call    extfsExtendFile
        jc      @f
 
        call    extfsTruncateFile
        jc      @f
        mov     eax, esi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    writeInode
@@:
        push    eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
        call    ext_unlock
        pop     eax
        ret

Rev 6522	Rev 6558
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License. ;;	4	;; Distributed under terms of the GNU General Public License. ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 6522 $	8	$Revision: 6558 $
9		9
10	; EXT external functions	10	; EXT external functions
11	; in:	11	; in:
12	; ebx -> parameter structure of sysfunc 70	12	; ebx -> parameter structure of sysfunc 70
13	; ebp -> EXTFS structure	13	; ebp -> EXTFS structure
14	; esi -> path string in UTF-8	14	; esi -> path string in UTF-8
15	; out:	15	; out:
16	; eax, ebx = return values for sysfunc 70	16	; eax, ebx = return values for sysfunc 70
17	iglobal	17	iglobal
18	align 4	18	align 4
19	ext_user_functions:	19	ext_user_functions:
20	dd ext_free	20	dd ext_free
21	dd (ext_user_functions_end - ext_user_functions - 4) / 4	21	dd (ext_user_functions_end - ext_user_functions - 4) / 4
22	dd ext_ReadFile	22	dd ext_ReadFile
23	dd ext_ReadFolder	23	dd ext_ReadFolder
24	dd ext_CreateFile	24	dd ext_CreateFile
25	dd ext_WriteFile	25	dd ext_WriteFile
26	dd ext_SetFileEnd	26	dd ext_SetFileEnd
27	dd ext_GetFileInfo	27	dd ext_GetFileInfo
28	dd ext_SetFileInfo	28	dd ext_SetFileInfo
29	dd 0	29	dd 0
30	dd ext_Delete	30	dd ext_Delete
31	dd ext_CreateFolder	31	dd ext_CreateFolder
32	ext_user_functions_end:	32	ext_user_functions_end:
33	endg	33	endg
34		34
35	struct DIRENTRY	35	struct DIRENTRY
36	inodeNumber dd ?	36	inodeNumber dd ?
37	entryLength dw ?	37	entryLength dw ?
38	nameLength db ?	38	nameLength db ?
39	fileType db ?	39	fileType db ?
40	name db ? ; rb [nameLength]	40	name db ? ; rb [nameLength]
41	ends	41	ends
42		42
43	struct INODE	43	struct INODE
44	accessMode dw ?	44	accessMode dw ?
45	UID dw ?	45	UID dw ?
46	fileSize dd ?	46	fileSize dd ?
47	accessedTime dd ?	47	accessedTime dd ?
48	inodeModified dd ?	48	inodeModified dd ?
49	dataModified dd ?	49	dataModified dd ?
50	deletedTime dd ?	50	deletedTime dd ?
51	GID dw ?	51	GID dw ?
52	linksCount dw ?	52	linksCount dw ?
53	sectorsUsed dd ?	53	sectorsUsed dd ?
54	featureFlags dd ?	54	featureFlags dd ?
55	reserved dd ?	55	reserved dd ?
56	blockNumbers rd 12	56	blockNumbers rd 12
57	addressBlock dd ?	57	addressBlock dd ?
58	doubleAddress dd ?	58	doubleAddress dd ?
59	tripleAddress dd ?	59	tripleAddress dd ?
60	generation dd ?	60	generation dd ?
61	ACL dd ?	61	ACL dd ?
62	fileSizeHigh dd ?	62	fileSizeHigh dd ?
63	ends	63	ends
64		64
65	struct BGDESCR ; block group descriptor	65	struct BGDESCR ; block group descriptor
66	blockBitmap dd ?	66	blockBitmap dd ?
67	inodeBitmap dd ?	67	inodeBitmap dd ?
68	inodeTable dd ?	68	inodeTable dd ?
69	blocksFree dw ?	69	blocksFree dw ?
70	inodesFree dw ?	70	inodesFree dw ?
71	directoriesCount dw ?	71	directoriesCount dw ?
72	reserved rb 14	72	reserved rb 14
73	ends	73	ends
74		74
75	struct SUPERBLOCK	75	struct SUPERBLOCK
76	inodesTotal dd ?	76	inodesTotal dd ?
77	blocksTotal dd ?	77	blocksTotal dd ?
78	blocksReserved dd ?	78	blocksReserved dd ?
79	blocksFree dd ?	79	blocksFree dd ?
80	inodesFree dd ?	80	inodesFree dd ?
81	firstGroupBlock dd ?	81	firstGroupBlock dd ?
82	sectorsPerBlockLog dd ? ; shift for 1024	82	sectorsPerBlockLog dd ? ; shift for 1024
83	fragmentSizeLog dd ?	83	fragmentSizeLog dd ?
84	blocksPerGroup dd ?	84	blocksPerGroup dd ?
85	fragmentsPerGroup dd ?	85	fragmentsPerGroup dd ?
86	inodesPerGroup dd ?	86	inodesPerGroup dd ?
87	lastMountTime dd ?	87	lastMountTime dd ?
88	lastWriteTime dd ?	88	lastWriteTime dd ?
89	mountCount dw ?	89	mountCount dw ?
90	mountMax dw ?	90	mountMax dw ?
91	magic dw ?	91	magic dw ?
92	state dw ?	92	state dw ?
93	errorHandling dw ?	93	errorHandling dw ?
94	additionalVersion dw ?	94	additionalVersion dw ?
95	lastCheck dd ?	95	lastCheck dd ?
96	checkInterval dd ?	96	checkInterval dd ?
97	creatorOS dd ?	97	creatorOS dd ?
98	dynamicVersionFlag dd ?	98	dynamicVersionFlag dd ?
99	reservedUID dw ?	99	reservedUID dw ?
100	reservedGID dw ?	100	reservedGID dw ?
101	firstInode dd ?	101	firstInode dd ?
102	inodeSize dw ?	102	inodeSize dw ?
103	thisBlockGroup dw ?	103	thisBlockGroup dw ?
104	compatibleFlags dd ?	104	compatibleFlags dd ?
105	incompatibleFlags dd ?	105	incompatibleFlags dd ?
106	RO_compatibleFlags dd ?	106	RO_compatibleFlags dd ?
107	ends	107	ends
108		108
109	; ext4 extent tree	109	; ext4 extent tree
110	struct NODEHEADER ; tree node header	110	struct NODEHEADER ; tree node header
111	magic dw ? ; 0xF30A	111	magic dw ? ; 0xF30A
112	entriesFolow dw ?	112	entriesFolow dw ?
113	entriesMax dw ?	113	entriesMax dw ?
114	currentDepth dw ?	114	currentDepth dw ?
115	generation dd ?	115	generation dd ?
116	ends	116	ends
117		117
118	struct INDEX ; root/branch	118	struct INDEX ; root/branch
119	fileBlock dd ?	119	fileBlock dd ?
120	nodeBlock dd ?	120	nodeBlock dd ?
121	nodeBlockHigh dw ?	121	nodeBlockHigh dw ?
122	reserved dw ?	122	reserved dw ?
123	ends	123	ends
124		124
125	struct EXTENT ; leaf	125	struct EXTENT ; leaf
126	fileBlock dd ?	126	fileBlock dd ?
127	blocksCount dw ?	127	blocksCount dw ?
128	fsBlockHigh dw ?	128	fsBlockHigh dw ?
129	fsBlock dd ?	129	fsBlock dd ?
130	ends	130	ends
131		131
132	ROOT_INODE = 2	132	ROOT_INODE = 2
133	PERMISSIONS = 110110110b	133	PERMISSIONS = 110110110b
134	EXTENTS_USED = 80000h	134	EXTENTS_USED = 80000h
135	TYPE_MASK = 0F000h	135	TYPE_MASK = 0F000h
136	FLAG_FILE = 8000h	136	FLAG_FILE = 8000h
137	DIRECTORY = 4000h	137	DIRECTORY = 4000h
138	DIR_FLAG_FILE = 1	138	DIR_FLAG_FILE = 1
139	DIR_DIRECTORY = 2	139	DIR_DIRECTORY = 2
140	KOS_HIDDEN = 2	140	KOS_HIDDEN = 2
141	KOS_DIRECTORY = 10h	141	KOS_DIRECTORY = 10h
142	READ_ONLY = 1	142	READ_ONLY = 1
143		143
144	; Implemented "incompatible" features:	144	; Implemented "incompatible" features:
145	; 2 = have file type in directory entry	145	; 2 = have file type in directory entry
146	; 40h = extents	146	; 40h = extents
147	; 200h = flexible block groups	147	; 200h = flexible block groups
148	INCOMPATIBLE_SUPPORT = 242h	148	INCOMPATIBLE_SUPPORT = 242h
149	; Read only support for "incompatible" features:	149	; Read only support for "incompatible" features:
150	INCOMPATIBLE_READ_SUPPORT = 240h	150	INCOMPATIBLE_READ_SUPPORT = 240h
151		151
152	; Implemented "read-only" features:	152	; Implemented "read-only" features:
153	; 1 = sparse superblock	153	; 1 = sparse superblock
154	; 2 = 64-bit file size	154	; 2 = 64-bit file size
155	READ_ONLY_SUPPORT = 3	155	READ_ONLY_SUPPORT = 3
156		156
157	struct EXTFS PARTITION	157	struct EXTFS PARTITION
158	Lock MUTEX	158	Lock MUTEX
159	mountType dd ?	159	mountType dd ?
160	sectorsPerBlockLog dd ? ; shift for 512	160	sectorsPerBlockLog dd ? ; shift for 512
161	bytesPerBlock dd ?	161	bytesPerBlock dd ?
162	sectorsPerBlock dd ?	162	sectorsPerBlock dd ?
163	dwordsPerBlock dd ?	163	dwordsPerBlock dd ?
164	dwordsPerBranch dd ? ; dwordsPerBlock ^ 2	164	dwordsPerBranch dd ? ; dwordsPerBlock ^ 2
165	mainBlockBuffer dd ?	165	mainBlockBuffer dd ?
166	tempBlockBuffer dd ?	166	tempBlockBuffer dd ?
167	align 512	167	align0 rb 200h-EXTFS.align0
168	superblock SUPERBLOCK	168	superblock SUPERBLOCK
169	align 1024	169	align1 rb 400h-EXTFS.align1
170	rootInodeBuffer INODE	170	rootInodeBuffer INODE
171	align 1024	171	align2 rb 600h-EXTFS.align2
172	mainInodeBuffer INODE	172	inodeBuffer INODE
173	align 1024	-
174	tempInodeBuffer INODE	173	align3 rb 800h-EXTFS.align3
175	ends	174	ends
176		175
177	; mount if it's a valid EXT partition	176	; mount if it's a valid EXT partition
178	ext2_create_partition:	177	ext2_create_partition:
179	; in:	178	; in:
180	; ebp -> PARTITION structure	179	; ebp -> PARTITION structure
181	; ebx -> boot sector	180	; ebx -> boot sector
182	; ebx+512 -> buffer	181	; ebx+512 -> buffer
183	; out:	182	; out:
184	; eax -> EXTFS structure, 0 = not EXT	183	; eax -> EXTFS structure, 0 = not EXT
185	push ebx	184	push ebx
186	cmp dword [esi+DISK.MediaInfo.SectorSize], 512	185	cmp dword [esi+DISK.MediaInfo.SectorSize], 512
187	jnz .fail	186	jnz .fail
188	mov eax, 2	187	mov eax, 2
189	add ebx, 512	188	add ebx, 512
190	call fs_read32_sys	189	call fs_read32_sys
191	test eax, eax	190	test eax, eax
192	jnz .fail	191	jnz .fail
193	cmp [ebx+SUPERBLOCK.magic], 0xEF53	192	cmp [ebx+SUPERBLOCK.magic], 0xEF53
194	jne .fail	193	jne .fail
195	cmp [ebx+SUPERBLOCK.state], 1	194	cmp [ebx+SUPERBLOCK.state], 1
196	ja .fail	195	ja .fail
197	test [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT	196	test [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT
198	jnz .fail	197	jnz .fail
199	cmp [ebx+SUPERBLOCK.sectorsPerBlockLog], 6 ; 64KB	198	cmp [ebx+SUPERBLOCK.sectorsPerBlockLog], 6 ; 64KB
200	ja .fail	199	ja .fail
201	cmp [ebx+SUPERBLOCK.inodeSize], 1024	200	cmp [ebx+SUPERBLOCK.inodeSize], 1024
202	ja .fail	201	ja .fail
203	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0	202	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0
204	je .fail	203	je .fail
205	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0	204	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0
206	je .fail	205	je .fail
-		206	movi eax, sizeof.EXTFS
207	stdcall kernel_alloc, 1000h	207	call malloc
208	test eax, eax	208	test eax, eax
209	jz .fail	209	jz .fail
210	mov ecx, dword [ebp+PARTITION.FirstSector]	210	mov ecx, dword [ebp+PARTITION.FirstSector]
211	mov dword [eax+EXTFS.FirstSector], ecx	211	mov dword [eax+EXTFS.FirstSector], ecx
212	mov ecx, dword [ebp+PARTITION.FirstSector+4]	212	mov ecx, dword [ebp+PARTITION.FirstSector+4]
213	mov dword [eax+EXTFS.FirstSector+4], ecx	213	mov dword [eax+EXTFS.FirstSector+4], ecx
214	mov ecx, dword [ebp+PARTITION.Length]	214	mov ecx, dword [ebp+PARTITION.Length]
215	mov dword [eax+EXTFS.Length], ecx	215	mov dword [eax+EXTFS.Length], ecx
216	mov ecx, dword [ebp+PARTITION.Length+4]	216	mov ecx, dword [ebp+PARTITION.Length+4]
217	mov dword [eax+EXTFS.Length+4], ecx	217	mov dword [eax+EXTFS.Length+4], ecx
218	mov ecx, [ebp+PARTITION.Disk]	218	mov ecx, [ebp+PARTITION.Disk]
219	mov [eax+EXTFS.Disk], ecx	219	mov [eax+EXTFS.Disk], ecx
220	mov [eax+EXTFS.FSUserFunctions], ext_user_functions	220	mov [eax+EXTFS.FSUserFunctions], ext_user_functions
221		221
222	push ebp esi edi	222	push ebp esi edi
223	mov ebp, eax	223	mov ebp, eax
224	lea ecx, [eax+EXTFS.Lock]	224	lea ecx, [eax+EXTFS.Lock]
225	call mutex_init	225	call mutex_init
226	mov esi, ebx	226	mov esi, ebx
227	lea edi, [ebp+EXTFS.superblock]	227	lea edi, [ebp+EXTFS.superblock]
228	mov ecx, 512/4	228	mov ecx, 512/4
229	rep movsd ; copy superblock	229	rep movsd ; copy superblock
230	mov ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]	230	mov ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]
231	inc ecx	231	inc ecx
232	mov [ebp+EXTFS.sectorsPerBlockLog], ecx	232	mov [ebp+EXTFS.sectorsPerBlockLog], ecx
233	mov eax, 1	233	mov eax, 1
234	shl eax, cl	234	shl eax, cl
235	mov [ebp+EXTFS.sectorsPerBlock], eax	235	mov [ebp+EXTFS.sectorsPerBlock], eax
236	shl eax, 9	236	shl eax, 9
237	mov [ebp+EXTFS.bytesPerBlock], eax	237	mov [ebp+EXTFS.bytesPerBlock], eax
238	shl eax, 1	238	shl eax, 1
239	push eax	239	push eax
240	shr eax, 3	240	shr eax, 3
241	mov [ebp+EXTFS.dwordsPerBlock], eax	241	mov [ebp+EXTFS.dwordsPerBlock], eax
242	mul eax	242	mul eax
243	mov [ebp+EXTFS.dwordsPerBranch], eax	243	mov [ebp+EXTFS.dwordsPerBranch], eax
244	call kernel_alloc	244	call kernel_alloc
245	test eax, eax	245	test eax, eax
246	jz .error	246	jz .error
247	mov [ebp+EXTFS.mainBlockBuffer], eax	247	mov [ebp+EXTFS.mainBlockBuffer], eax
248	add eax, [ebp+EXTFS.bytesPerBlock]	248	add eax, [ebp+EXTFS.bytesPerBlock]
249	mov [ebp+EXTFS.tempBlockBuffer], eax	249	mov [ebp+EXTFS.tempBlockBuffer], eax
250	mov [ebp+EXTFS.mountType], 0	250	mov [ebp+EXTFS.mountType], 0
251	test [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT	251	test [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT
252	jnz .read_only	252	jnz .read_only
253	test [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT	253	test [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT
254	jz @f	254	jz @f
255	.read_only:	255	.read_only:
256	or [ebp+EXTFS.mountType], READ_ONLY	256	or [ebp+EXTFS.mountType], READ_ONLY
257	@@: ; read root inode	257	@@: ; read root inode
258	lea ebx, [ebp+EXTFS.rootInodeBuffer]	258	lea ebx, [ebp+EXTFS.rootInodeBuffer]
259	mov eax, ROOT_INODE	259	mov eax, ROOT_INODE
260	call readInode	260	call readInode
261	test eax, eax	261	test eax, eax
262	jnz @f	262	jnz @f
263	mov eax, ebp	263	mov eax, ebp
264	pop edi esi ebp ebx	264	pop edi esi ebp ebx
265	ret	265	ret
266		266
267	@@:	267	@@:
268	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]	268	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
269	.error:	269	.error:
-		270	mov eax, ebp
270	stdcall kernel_free, ebp	271	call free
271	pop edi esi ebp	272	pop edi esi ebp
272	.fail:	273	.fail:
273	pop ebx	274	pop ebx
274	xor eax, eax	275	xor eax, eax
275	ret	276	ret
276		277
277	; unmount EXT partition	278	; unmount EXT partition
278	ext_free:	279	ext_free:
279	; in: eax -> EXTFS structure	280	; in: eax -> EXTFS structure
280	push eax	281	push eax
281	stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]	282	stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]
282	call kernel_free	283	pop eax
283	ret	284	jmp free
284		285
285	extfsWriteBlock:	286	extfsWriteBlock:
286	push fs_write64_sys	287	push fs_write64_sys
287	jmp @f	288	jmp @f
288	; in:	289	; in:
289	; eax = block number	290	; eax = block number
290	; ebx -> buffer	291	; ebx -> buffer
291	extfsReadBlock:	292	extfsReadBlock:
292	push fs_read64_sys	293	push fs_read64_sys
293	@@:	294	@@:
294	push ecx edx	295	push ecx edx
295	mov ecx, [ebp+EXTFS.sectorsPerBlock]	296	mov ecx, [ebp+EXTFS.sectorsPerBlock]
296	mul ecx	297	mul ecx
297	call dword[esp+8]	298	call dword[esp+8]
298	pop edx ecx	299	pop edx ecx
299	add esp, 4	300	add esp, 4
300	test eax, eax	301	test eax, eax
301	jz @f	302	jz @f
302	movi eax, ERROR_DEVICE	303	movi eax, ERROR_DEVICE
303	stc	304	stc
304	@@:	305	@@:
305	ret	306	ret
306		307
307	extfsReadDescriptor:	308	extfsReadDescriptor:
308	; in: eax = block group number	309	; in: eax = block group number
309	; out:	310	; out:
310	; [ebp+EXTFS.tempBlockBuffer] -> relevant block	311	; [ebp+EXTFS.tempBlockBuffer] -> relevant block
311	; eax -> block group descriptor, 0 = error	312	; eax -> block group descriptor, 0 = error
312	push edx ebx	313	push edx ebx
313	shl eax, 5	314	shl eax, 5
314	xor edx, edx	315	xor edx, edx
315	div [ebp+EXTFS.bytesPerBlock]	316	div [ebp+EXTFS.bytesPerBlock]
316	add eax, [ebp+EXTFS.superblock.firstGroupBlock]	317	add eax, [ebp+EXTFS.superblock.firstGroupBlock]
317	inc eax	318	inc eax
318	mov ebx, [ebp+EXTFS.tempBlockBuffer]	319	mov ebx, [ebp+EXTFS.tempBlockBuffer]
319	call extfsReadBlock	320	call extfsReadBlock
320	jc .fail	321	jc .fail
321	mov eax, ebx	322	mov eax, ebx
322	add eax, edx	323	add eax, edx
323	@@:	324	@@:
324	pop ebx edx	325	pop ebx edx
325	ret	326	ret
326		327
327	.fail:	328	.fail:
328	xor eax, eax	329	xor eax, eax
329	stc	330	stc
330	jmp @b	331	jmp @b
331		332
332	extfsWriteDescriptor:	333	extfsWriteDescriptor:
333	; in:	334	; in:
334	; eax = block group number	335	; eax = block group number
335	; [ebp+EXTFS.tempBlockBuffer] -> relevant block	336	; [ebp+EXTFS.tempBlockBuffer] -> relevant block
336	push edx ebx	337	push edx ebx
337	shl eax, 5	338	shl eax, 5
338	xor edx, edx	339	xor edx, edx
339	div [ebp+EXTFS.bytesPerBlock]	340	div [ebp+EXTFS.bytesPerBlock]
340	add eax, [ebp+EXTFS.superblock.firstGroupBlock]	341	add eax, [ebp+EXTFS.superblock.firstGroupBlock]
341	inc eax	342	inc eax
342	mov ebx, [ebp+EXTFS.tempBlockBuffer]	343	mov ebx, [ebp+EXTFS.tempBlockBuffer]
343	call extfsWriteBlock	344	call extfsWriteBlock
344	pop ebx edx	345	pop ebx edx
345	ret	346	ret
346		347
347	extfsResourceFree:	348	extfsResourceFree:
348	; in:	349	; in:
349	; ecx=0 -> block, ecx=1 -> inode	350	; ecx=0 -> block, ecx=1 -> inode
350	; eax = block/inode number	351	; eax = block/inode number
351	push ebx edx	352	push ebx edx
352	sub eax, [ebp+EXTFS.superblock.firstGroupBlock]	353	sub eax, [ebp+EXTFS.superblock.firstGroupBlock]
353	xor edx, edx	354	xor edx, edx
354	div [ebp+EXTFS.superblock.blocksPerGroup]	355	div [ebp+EXTFS.superblock.blocksPerGroup]
355	push eax edx	356	push eax edx
356	call extfsReadDescriptor	357	call extfsReadDescriptor
357	jc .fail	358	jc .fail
358	inc [eax+BGDESCR.blocksFree+ecx*2]	359	inc [eax+BGDESCR.blocksFree+ecx*2]
359	mov eax, [eax+BGDESCR.blockBitmap+ecx*4]	360	mov eax, [eax+BGDESCR.blockBitmap+ecx*4]
360	mov ebx, [ebp+EXTFS.mainBlockBuffer]	361	mov ebx, [ebp+EXTFS.mainBlockBuffer]
361	mov edx, eax	362	mov edx, eax
362	call extfsReadBlock	363	call extfsReadBlock
363	jc .fail	364	jc .fail
364	pop eax	365	pop eax
365	push edx	366	push edx
366	mov edx, eax	367	mov edx, eax
367	and edx, 31	368	and edx, 31
368	shr eax, 5	369	shr eax, 5
369	shl eax, 2	370	shl eax, 2
370	add eax, [ebp+EXTFS.mainBlockBuffer]	371	add eax, [ebp+EXTFS.mainBlockBuffer]
371	btr [eax], edx	372	btr [eax], edx
372	pop eax	373	pop eax
373	mov ebx, [ebp+EXTFS.mainBlockBuffer]	374	mov ebx, [ebp+EXTFS.mainBlockBuffer]
374	call extfsWriteBlock	375	call extfsWriteBlock
375	jc @f	376	jc @f
376	inc [ebp+EXTFS.superblock.blocksFree+ecx*4]	377	inc [ebp+EXTFS.superblock.blocksFree+ecx*4]
377	pop eax	378	pop eax
378	call extfsWriteDescriptor	379	call extfsWriteDescriptor
379	.ret:	380	.ret:
380	pop edx ebx	381	pop edx ebx
381	ret	382	ret
382		383
383	.fail:	384	.fail:
384	pop eax	385	pop eax
385	@@:	386	@@:
386	pop eax	387	pop eax
387	movi eax, ERROR_DEVICE	388	movi eax, ERROR_DEVICE
388	jmp .ret	389	jmp .ret
389		390
390	freeDoublyIndirectBlock:	391	freeDoublyIndirectBlock:
391	; in: eax = doubly-indirect block number	392	; in: eax = doubly-indirect block number
392	; out: eax=1 -> finished	393	; out: eax=1 -> finished
393	test eax, eax	394	test eax, eax
394	jz .complete	395	jz .complete
395	push eax	396	push eax
396	mov ebx, [ebp+EXTFS.tempBlockBuffer]	397	mov ebx, [ebp+EXTFS.tempBlockBuffer]
397	call extfsReadBlock	398	call extfsReadBlock
398	pop eax	399	pop eax
399	jc .ret	400	jc .ret
400	xor ecx, ecx	401	xor ecx, ecx
401	call extfsResourceFree	402	call extfsResourceFree
402	mov edx, ebx	403	mov edx, ebx
403	add edx, [ebp+EXTFS.bytesPerBlock]	404	add edx, [ebp+EXTFS.bytesPerBlock]
404	@@:	405	@@:
405	mov eax, [ebx]	406	mov eax, [ebx]
406	test eax, eax	407	test eax, eax
407	jz .complete	408	jz .complete
408	call extfsResourceFree	409	call extfsResourceFree
409	add ebx, 4	410	add ebx, 4
410	cmp ebx, edx	411	cmp ebx, edx
411	jb @b	412	jb @b
412	.ret:	413	.ret:
413	xor eax, eax	414	xor eax, eax
414	ret	415	ret
415		416
416	.complete:	417	.complete:
417	inc eax	418	inc eax
418	ret	419	ret
419		420
420	inodeBlockAlloc:	421	inodeBlockAlloc:
421	; in: esi -> inode	422	; in: esi -> inode, eax = inode number
422	; out: ebx = block number	423	; out: ebx = block number
423	; TODO: fix to have correct preference.	-
424	mov eax, ROOT_INODE	-
425	call extfsBlockAlloc	424	call extfsBlockAlloc
426	jc @f	425	jc @f
427	mov eax, [ebp+EXTFS.sectorsPerBlock]	426	mov eax, [ebp+EXTFS.sectorsPerBlock]
428	add [esi+INODE.sectorsUsed], eax	427	add [esi+INODE.sectorsUsed], eax
429	xor eax, eax	428	xor eax, eax
430	@@:	429	@@:
431	ret	430	ret
432		431
433	extfsBlockAlloc: ; also erases	432	extfsBlockAlloc: ; also erases
434	; in: eax = inode number	433	; in: eax = inode number
435	; out: ebx = block number	434	; out: ebx = block number
436	xor ebx, ebx	435	xor ebx, ebx
437	call extfsResourceAlloc	436	call extfsResourceAlloc
438	jc @f	437	jc @f
439	push ebx ecx edi	438	push ebx ecx edi
440	mov ecx, [ebp+EXTFS.dwordsPerBlock]	439	mov ecx, [ebp+EXTFS.dwordsPerBlock]
441	mov edi, [ebp+EXTFS.tempBlockBuffer]	440	mov edi, [ebp+EXTFS.tempBlockBuffer]
442	mov ebx, edi	441	mov ebx, edi
443	xor eax, eax	442	xor eax, eax
444	rep stosd	443	rep stosd
445	pop edi ecx	444	pop edi ecx
446	mov eax, [esp]	445	mov eax, [esp]
447	call extfsWriteBlock	446	call extfsWriteBlock
448	pop ebx	447	pop ebx
449	@@:	448	@@:
450	ret	449	ret
451		450
452	extfsResourceAlloc:	451	extfsResourceAlloc:
453	; in:	452	; in:
454	; eax = inode number	453	; eax = inode number
455	; ebx=0 -> block, ebx=1 -> inode	454	; ebx=0 -> block, ebx=1 -> inode
456	; out:	455	; out:
457	; ebx = block/inode number	456	; ebx = block/inode number
458	push ecx edx esi edi	457	push ecx edx esi edi
459	dec eax	458	dec eax
460	xor edx, edx	459	xor edx, edx
461	div [ebp+EXTFS.superblock.inodesPerGroup]	460	div [ebp+EXTFS.superblock.inodesPerGroup]
462	push eax eax	461	push eax eax
463	mov esi, .forward ; search forward, then backward	462	mov esi, .forward ; search forward, then backward
464	.test_block_group:	463	.test_block_group:
465	call extfsReadDescriptor	464	call extfsReadDescriptor
466	jc .fail	465	jc .fail
467	dec [eax+BGDESCR.blocksFree+ebx*2]	466	dec [eax+BGDESCR.blocksFree+ebx*2]
468	mov eax, [eax+BGDESCR.blockBitmap+ebx*4]	467	mov eax, [eax+BGDESCR.blockBitmap+ebx*4]
469	push ebx	468	push ebx
470	mov ebx, [ebp+EXTFS.mainBlockBuffer]	469	mov ebx, [ebp+EXTFS.mainBlockBuffer]
471	mov edx, eax	470	mov edx, eax
472	mov edi, ebx	471	mov edi, ebx
473	call extfsReadBlock	472	call extfsReadBlock
474	pop ebx	473	pop ebx
475	jc .fail	474	jc .fail
476	mov ecx, [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]	475	mov ecx, [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
477	or eax, -1	476	or eax, -1
478	shr ecx, 5	477	shr ecx, 5
479	jz .next	478	jz .next
480	repz scasd	479	repz scasd
481	jz .next	480	jz .next
482	sub edi, 4	481	sub edi, 4
483	mov eax, [edi]	482	mov eax, [edi]
484	not eax	483	not eax
485	bsf eax, eax	484	bsf eax, eax
486	bts [edi], eax	485	bts [edi], eax
487	sub edi, [ebp+EXTFS.mainBlockBuffer]	486	sub edi, [ebp+EXTFS.mainBlockBuffer]
488	shl edi, 3	487	shl edi, 3
489	add eax, edi	488	add eax, edi
490	mov ecx, eax	489	mov ecx, eax
491	mov eax, edx	490	mov eax, edx
492	push ebx	491	push ebx
493	mov ebx, [ebp+EXTFS.mainBlockBuffer]	492	mov ebx, [ebp+EXTFS.mainBlockBuffer]
494	call extfsWriteBlock	493	call extfsWriteBlock
495	pop ebx	494	pop ebx
496	jc .fail	495	jc .fail
497	mov eax, [esp]	496	mov eax, [esp]
498	mul [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]	497	mul [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ext.inc – Rev 6522 → 6558