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: 6880 $
 
; 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  ?
UUID                rb  16
volumeLabel         rb  16
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
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  ?
bytesPerBlock       dd  ?
sectorsPerBlock     dd  ?
dwordsPerBlock      dd  ?
dwordsPerBranch     dd  ?   ; dwordsPerBlock ^ 2
mainBlockBuffer     dd  ?
tempBlockBuffer     dd  ?
descriptorTable     dd  ?
descriptorTableEnd  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], 512
        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     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
@@:
        mov     eax, [ebx+SUPERBLOCK.inodesTotal]
        dec     eax
        xor     edx, edx
        div     [ebx+SUPERBLOCK.inodesPerGroup]
        inc     eax
        shl     eax, 5
        push    eax eax
        call    kernel_alloc
        pop     ecx
        test    eax, eax
        jz      .error2
        mov     [ebp+EXTFS.descriptorTable], eax
        mov     ebx, eax
        add     eax, ecx
        mov     [ebp+EXTFS.descriptorTableEnd], eax
        mov     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        inc     eax
        mul     [ebp+EXTFS.sectorsPerBlock]
        dec     ecx
        shr     ecx, 9
        inc     ecx
        call    fs_read64_sys
        test    eax, eax
        jnz     @f
        mov     al, ROOT_INODE
        lea     ebx, [ebp+EXTFS.rootInodeBuffer]
        call    readInode
        test    eax, eax
        jnz     @f
        mov     eax, ebp
        pop     edi esi ebp ebx
        ret
 
@@:
        stdcall kernel_free, [ebp+EXTFS.descriptorTable]
.error2:
        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 [eax+EXTFS.mainBlockBuffer]
        stdcall kernel_free, [eax+EXTFS.descriptorTable]
        call    kernel_free
        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
 
extfsWriteDescriptor:
; in: ebx = block group descriptor
        mov     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        inc     eax
        mul     [ebp+EXTFS.sectorsPerBlock]
        sub     ebx, [ebp+EXTFS.descriptorTable]
        shr     ebx, 9
        add     eax, ebx
        shl     ebx, 9
        add     ebx, [ebp+EXTFS.descriptorTable]
        call    fs_write32_sys
        ret
 
extfsExtentFree:
; in: eax = first block number, ecx = extent size
        push    ebx edx edi
        sub     eax, [ebp+EXTFS.superblock.firstGroupBlock]
        xor     edx, edx
        mov     ebx, [ebp+EXTFS.superblock.blocksPerGroup]
        div     ebx
        sub     ebx, edx
        sub     ebx, ecx
        jc      .ret
        push    edx
        mov     ebx, [ebp+EXTFS.descriptorTable]
        shl     eax, 5
        add     ebx, eax
        mov     eax, ecx
        mul     [ebp+EXTFS.sectorsPerBlock]
        add     [ebx+BGDESCR.blocksFree], cx
        add     [ebp+EXTFS.superblock.blocksFree], ecx
        sub     [ebp+EXTFS.inodeBuffer.sectorsUsed], eax
        push    [ebx+BGDESCR.blockBitmap]
        call    extfsWriteDescriptor
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     edx, eax
        call    extfsReadBlock
        pop     eax
        jc      .ret
        push    ebx edx
        mov     edi, eax
        shr     edi, 5
        shl     edi, 2
        add     edi, ebx
        mov     edx, ecx
        and     eax, 31
        jz      .aligned
        mov     ecx, 32
        sub     ecx, eax
        sub     edx, ecx
        jnc     @f
        add     ecx, edx
        xor     edx, edx
@@:
        or      ebx, -1
        shl     ebx, cl
        not     ebx
        mov     ecx, eax
        shl     ebx, cl
        not     ebx
        and     [edi], ebx
        add     edi, 4
        xor     eax, eax
.aligned:
        mov     ecx, edx
        shr     ecx, 5
        rep stosd
        and     edx, 31
        jz      @f
        mov     ecx, edx
        not     eax
        shl     eax, cl
        and     [edi], eax
@@:
        pop     eax ebx
        call    extfsWriteBlock
.ret:
        pop     edi edx ebx
        xor     eax, eax
        ret
 
extfsInodeAlloc:
; in: eax = parent inode number
; out: ebx = allocated inode number
        push    ecx edx edi
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        mov     ebx, [ebp+EXTFS.descriptorTable]
        shl     eax, 5
        add     ebx, eax
        push    ebx
.test_block_group:
        push    ebx
        cmp     [ebx+BGDESCR.blocksFree], 0
        jz      .next
        cmp     [ebx+BGDESCR.inodesFree], 0
        jz      .next
        dec     [ebx+BGDESCR.inodesFree]
        dec     [ebp+EXTFS.superblock.inodesFree]
        push    [ebx+BGDESCR.inodeBitmap]
        call    extfsWriteDescriptor
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     edx, eax
        mov     edi, ebx
        call    extfsReadBlock
        jc      .fail
        mov     ecx, [ebp+EXTFS.superblock.inodesPerGroup]
        or      eax, -1
        shr     ecx, 5
        repz scasd
        jz      .next
        sub     edi, 4
        mov     eax, [edi]
        not     eax
        bsf     eax, eax
        bts     [edi], eax
        sub     edi, [ebp+EXTFS.tempBlockBuffer]
        shl     edi, 3
        add     eax, edi
        mov     ecx, eax
        mov     eax, edx
        call    extfsWriteBlock
        pop     eax
        sub     eax, [ebp+EXTFS.descriptorTable]
        shr     eax, 5
        mul     [ebp+EXTFS.superblock.inodesPerGroup]
        lea     ebx, [eax+ecx+1]
        xor     eax, eax
.ret:
        pop     edi edi edx ecx
        ret
 
.next:      ; search forward, then backward
        pop     ebx
        cmp     ebx, [esp]
        jc      .backward
        add     ebx, 32
        cmp     ebx, [ebp+EXTFS.descriptorTableEnd]
        jc      .test_block_group
        mov     ebx, [esp]
.backward:
        sub     ebx, 32
        cmp     ebx, [ebp+EXTFS.descriptorTable]
        jnc     .test_block_group
        movi    eax, ERROR_DISK_FULL
        push    eax
.fail:
        pop     edi
        jmp     .ret
 
extfsExtentAlloc:
; in: eax = parent inode number, ecx = blocks max
; out: ebx = first block number, ecx = blocks allocated
        push    edx esi edi ecx
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        mov     ebx, [ebp+EXTFS.descriptorTable]
        shl     eax, 5
        add     ebx, eax
        push    ebx
.test_block_group:
        push    ebx
        cmp     [ebx+BGDESCR.blocksFree], 0
        jz      .next
        mov     eax, [ebx+BGDESCR.blockBitmap]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     edx, eax
        mov     edi, ebx
        call    extfsReadBlock
        jc      .fail
        mov     ecx, [ebp+EXTFS.superblock.blocksPerGroup]
        shr     ecx, 5
        or      eax, -1
        repz scasd
        jz      .next
        mov     esi, edi
        sub     esi, 4
        push    edx ecx
        mov     eax, [esi]
        not     eax
        bsf     ecx, eax
        not     eax
        shr     eax, cl
        shl     eax, cl
        mov     ebx, 32
        bsf     ebx, eax
        sub     ebx, ecx
        mov     eax, [esp+16]
        cmp     ebx, eax
        jc      @f
        mov     ebx, eax
@@:
        or      eax, -1
        cmp     ebx, 32
        jz      @f
        xchg    ebx, ecx
        shl     eax, cl
        not     eax
        xchg    ebx, ecx
        shl     eax, cl
@@:
        or      [esi], eax
        sub     esi, [ebp+EXTFS.tempBlockBuffer]
        shl     esi, 3
        add     esi, ecx
        mov     eax, [esp+16]
        sub     eax, ebx
        mov     [esp+16], ebx
        add     ebx, ecx
        pop     ecx
        test    eax, eax
        jz      .done
        cmp     ebx, 32
        jnz     .done
        jecxz   .done
        mov     ebx, eax
        shr     eax, 5
        inc     eax
        and     ebx, 31
        cmp     ecx, eax
        jnc     @f
        mov     eax, ecx
        mov     bl, 32
@@:
        mov     ecx, eax
        shl     eax, 5
        add     [esp+12], eax
        xor     eax, eax
        push    edi
        repz scasd
        jz      @f
        mov     eax, [edi-4]
        bsf     eax, eax
        xchg    eax, ebx
        test    ecx, ecx
        jnz     @f
        cmp     ebx, eax
        jc      @f
        mov     ebx, eax
@@:
        inc     ecx
        shl     ecx, 5
        sub     ecx, ebx
        sub     [esp+16], ecx
        mov     ecx, edi
        pop     edi
        sub     ecx, edi
        shr     ecx, 2
        dec     ecx
        or      eax, -1
        rep stosd
        mov     ecx, ebx
        jecxz   .done
        neg     ecx
        add     ecx, 32
        shr     eax, cl
        or      [edi], eax
.done:
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        mov     ebx, [esp]
        mov     ecx, [esp+8]
        sub     [ebx+BGDESCR.blocksFree], cx
        jnc     @f
        mov     [ebx+BGDESCR.blocksFree], 0
@@:
        sub     [ebp+EXTFS.superblock.blocksFree], ecx
        call    extfsWriteDescriptor
        pop     eax ebx
        sub     eax, [ebp+EXTFS.descriptorTable]
        shr     eax, 5
        mul     [ebp+EXTFS.superblock.blocksPerGroup]
        mov     ebx, eax
        add     ebx, esi
        add     ebx, [ebp+EXTFS.superblock.firstGroupBlock]
        pop     ecx
        mov     eax, ecx
        mul     [ebp+EXTFS.sectorsPerBlock]
        add     [ebp+EXTFS.inodeBuffer.sectorsUsed], eax
        xor     eax, eax
.ret:
        pop     edi esi edx
        ret
 
.next:      ; search forward, then backward
        pop     ebx
        cmp     ebx, [esp]
        jc      .backward
        add     ebx, 32
        cmp     ebx, [ebp+EXTFS.descriptorTableEnd]
        jc      .test_block_group
        mov     ebx, [esp]
.backward:
        sub     ebx, 32
        cmp     ebx, [ebp+EXTFS.descriptorTable]
        jnc     .test_block_group
        movi    eax, ERROR_DISK_FULL
        push    eax
.fail:
        add     esp, 12
        xor     ecx, ecx
        stc
        jmp     .ret
 
extfsGetExtent:
; in: ecx = starting file block
; out: eax = first block number, ecx = extent size
        push    ebx edx esi
        lea     esi, [ebp+EXTFS.inodeBuffer]
        test    [esi+INODE.featureFlags], EXTENTS_USED
        jz      .listTreeSearch
        add     esi, INODE.blockNumbers
.extentTreeSearch:
        cmp     word [esi+NODEHEADER.magic], 0xF30A
        jne     .fail
        movzx   ebx, [esi+NODEHEADER.entriesFolow]
        add     esi, sizeof.NODEHEADER
        test    ebx, ebx
        jz      .noBlock
        cmp     word [esi-sizeof.NODEHEADER+NODEHEADER.currentDepth], 0
        je      .leaf_block
        dec     ebx
        jz      .end_search_index
@@:
        cmp     ecx, [esi+sizeof.INDEX+INDEX.fileBlock]
        jb      .end_search_index
        add     esi, sizeof.INDEX
        dec     ebx
        jnz     @b
.end_search_index:
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     eax, [esi+INDEX.nodeBlock]
        call    extfsReadBlock
        jc      .fail2
        mov     esi, ebx
        jmp     .extentTreeSearch
 
.fail:
        movi    eax, ERROR_FS_FAIL
        jmp     .fail2
 
.leaf_block:
        movzx   edx, [esi+EXTENT.blocksCount]
        add     edx, [esi+EXTENT.fileBlock]
        sub     edx, ecx
        ja      .end_search_extent
        add     esi, sizeof.EXTENT
        dec     ebx
        jnz     .leaf_block
.noBlock:
        movi    eax, ERROR_END_OF_FILE
.fail2:
        pop     esi edx ebx
        stc
        ret
 
.end_search_extent:
        sub     ecx, [esi+EXTENT.fileBlock]
        jc      .fail
        add     ecx, [esi+EXTENT.fsBlock]
        mov     eax, ecx
        mov     ecx, edx
        pop     esi edx ebx
        ret
 
.listTreeSearch:
        cmp     ecx, 12
        jb      .get_direct_block
        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
 
.get_direct_block:
        mov     edx, ecx
        mov     cl, 12
        lea     ebx, [esi+INODE.blockNumbers]
        jmp     .calculateExtent
 
.get_indirect_block:
        mov     eax, [esi+INODE.addressBlock]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        mov     edx, ecx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        jmp     .calculateExtent
 
.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
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        div     ecx
; 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
.calculateExtent:
        lea     esi, [ebx+edx*4]
        lodsd
        test    eax, eax
        jz      .noBlock
        mov     ebx, eax
        sub     ecx, edx
        xor     edx, edx
@@:
        inc     edx
        dec     ecx
        jz      @f
        lodsd
        sub     eax, ebx
        sub     eax, edx
        jz      @b
@@:
        mov     eax, ebx
        mov     ecx, edx
        pop     esi edx ebx
        clc
        ret
 
getInodeLocation:
; in: eax = inode number
; out: eax = inode sector, edx = offset in sector
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        shl     eax, 5
        add     eax, [ebp+EXTFS.descriptorTable]
        mov     ebx, [eax+BGDESCR.inodeTable]
        imul    ebx, [ebp+EXTFS.sectorsPerBlock]
        movzx   eax, [ebp+EXTFS.superblock.inodeSize]
        mul     edx
        mov     edx, eax
        shr     eax, 9
        and     edx, 511
        add     eax, ebx
        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
        cmp     eax, ROOT_INODE
        jnz     @f
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     esi, edi
        lea     edi, [ebp+EXTFS.rootInodeBuffer]
        rep movsb
@@:
        call    getInodeLocation
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     ecx, eax
        call    fs_read32_sys
        test    eax, eax
        jnz     @f
        mov     eax, ecx
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     edi, edx
        add     edi, ebx
        mov     esi, [esp]
        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
        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
 
indirectBlockAlloc:
;   in:
; edi -> indirect block number
; ebx = starting extent block
; ecx = extent size
; edx = starting file block
        mov     eax, [edi]
        test    eax, eax
        jz      .newBlock
        push    edi ebx ecx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .err2
        lea     edi, [ebx+edx*4]
        test    edx, edx
        jz      @f
        cmp     dword[edi-4], 0
        jnz     @f
        pop     ecx ebx edi
.err:
        mov     al, ERROR_FS_FAIL
        stc
        ret
 
.err2:
        pop     ecx ebx edi
        ret
 
.newBlock:
        test    edx, edx
        jnz     .err
        mov     [edi], ebx
        inc     ebx
        dec     ecx
        push    edi ebx ecx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        push    edi
        rep stosd
        pop     edi
@@:
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        sub     ecx, edx
        pop     ebx eax
        sub     ebx, ecx
        jnc     @f
        add     ecx, ebx
        xor     ebx, ebx
@@:
        jecxz   .done
        add     edx, ecx
@@:
        stosd
        inc     eax
        loop    @b
.done:
        pop     edi
        push    eax ebx
        mov     eax, [edi]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        pop     ecx ebx
        ret
 
doublyIndirectBlockAlloc:
;   in:
; edi -> indirect block number
; edx = starting file block
; ebx = starting extent block
; ecx = extent size
; [esp+4] = rest of size
; [esp+8] = parent inode number
        mov     eax, [edi]
        test    eax, eax
        jz      .newBlock
        push    edi ecx ebx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      .err2
        mov     eax, edx
        xor     edx, edx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        div     ecx
        lea     edi, [ebx+eax*4]
        pop     ebx
        test    eax, eax
        jz      @f
        cmp     dword[edi-4], 0
        jnz     @f
        pop     ecx edi
.err:
        mov     al, ERROR_FS_FAIL
        stc
        ret
 
.err2:
        pop     ebx ecx edi
        ret
 
.newBlock:
        test    edx, edx
        jnz     .err
        mov     [edi], ebx
        inc     ebx
        dec     ecx
        inc     dword[esp+4]
        push    edi ecx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        mov     edi, [ebp+EXTFS.mainBlockBuffer]
        push    ecx edi
        rep stosd
        pop     edi ecx
@@:
        sub     ecx, eax
        xchg    [esp], ecx
.loop:
        cmp     dword[edi], 0
        jnz     @f
        inc     dword[esp+12]
@@:
        jecxz   .extentAlloc
        call    indirectBlockAlloc
        jc      .end
        cmp     edx, [ebp+EXTFS.dwordsPerBlock]
        jnz     @b
        add     edi, 4
        xor     edx, edx
        dec     dword[esp]
        jnz     .loop
.end:
        pop     edi edi
        push    ebx eax
        mov     eax, [edi]
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsWriteBlock
        pop     ebx
        add     eax, ebx
        xor     ebx, ebx
        cmp     ebx, eax
        pop     ebx
        ret
 
.extentAlloc:
        mov     ecx, [esp+12]
        xor     eax, eax
        jecxz   .end
        mov     eax, [esp+16]
        call    extfsExtentAlloc
        jc      .end
        sub     [esp+12], ecx
        jmp     @b
 
extfsExtendFile:
;   in:
; [ebp+EXTFS.inodeBuffer] = inode
; ecx = inode number
; edx:eax = new size
        push    ebx esi edi ecx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ebx, [esi+INODE.fileSize]
        mov     ecx, [esi+INODE.fileSizeHigh]
        cmp     ebx, eax
        sbb     ecx, edx
        jnc     .ret
        mov     ecx, [esi+INODE.fileSizeHigh]
        mov     [esi+INODE.fileSize], eax
        mov     [esi+INODE.fileSizeHigh], edx
        sub     eax, 1
        sbb     edx, 0
        div     [ebp+EXTFS.bytesPerBlock]
        inc     eax
        xchg    eax, ebx
        mov     edx, ecx
        sub     eax, 1
        sbb     edx, 0
        jc      @f
        div     [ebp+EXTFS.bytesPerBlock]
@@:
        inc     eax
        sub     ebx, eax
        jz      .ret
        push    ebx
        mov     edx, eax
@@:
        mov     ecx, [esp]
        mov     eax, [esp+4]
        test    ecx, ecx
        jz      .done
        call    extfsExtentAlloc
        jc      .errDone
        sub     [esp], ecx
        cmp     edx, 12
        jc      .directBlocks
        sub     edx, 12
        cmp     edx, [ebp+EXTFS.dwordsPerBlock]
        jc      .indirectBlocks
        sub     edx, [ebp+EXTFS.dwordsPerBlock]
        cmp     edx, [ebp+EXTFS.dwordsPerBranch]
        jc      .doublyIndirectBlock
        sub     edx, [ebp+EXTFS.dwordsPerBranch]
        jmp     .triplyIndirectBlock
 
.newExtent:
        jmp     @b
 
.directBlocks:
        lea     edi, [esi+INODE.blockNumbers+edx*4]
        test    edx, edx
        jz      @f
        cmp     dword[edi-4], 0
        jz      .errDone
@@:
        mov     eax, ebx
        mov     ebx, ecx
        mov     ecx, 12
        sub     ecx, edx
        sub     ebx, ecx
        jnc     @f
        add     ecx, ebx
        xor     ebx, ebx
@@:
        add     edx, ecx
@@:
        stosd
        inc     eax
        loop    @b
        mov     ecx, ebx
        mov     ebx, eax
        jecxz   .newExtent
        xor     edx, edx
.indirectBlocks:
        lea     edi, [esi+INODE.addressBlock]
        cmp     dword[edi], 0
        jnz     @f
        inc     dword[esp]
@@:
        call    indirectBlockAlloc
        jc      .errDone
        add     edx, 12
        jecxz   .newExtent
        xor     edx, edx
.doublyIndirectBlock:
        lea     edi, [esi+INODE.doubleAddress]
        call    doublyIndirectBlockAlloc
        jc      .errDone
        mov     edx, [ebp+EXTFS.dwordsPerBranch]
        add     edx, [ebp+EXTFS.dwordsPerBlock]
        add     edx, 12
        jecxz   .newExtent
        xor     edx, edx
.triplyIndirectBlock:
        push    ecx ebx edx
        stdcall kernel_alloc, [ebp+EXTFS.bytesPerBlock]
        pop     edx
        mov     esi, eax
        mov     eax, [ebp+EXTFS.inodeBuffer.tripleAddress]
        test    eax, eax
        jz      .newBlock
        mov     ebx, esi
        call    extfsReadBlock
        pop     ebx ecx
        jc      .errFree
        mov     eax, edx
        xor     edx, edx
        div     [ebp+EXTFS.dwordsPerBranch]
        lea     edi, [esi+eax*4]
        test    eax, eax
        jz      @f
        cmp     dword[edi-4], 0
        jnz     @f
        mov     al, ERROR_FS_FAIL
.errFree:
        push    ecx eax
        stdcall kernel_free, esi
        pop     eax ecx
.errDone:
        imul    ecx, [ebp+EXTFS.sectorsPerBlock]
        sub     [ebp+EXTFS.inodeBuffer.sectorsUsed], ecx
        pop     ebx
        imul    ebx, [ebp+EXTFS.sectorsPerBlock]
        add     ebx, ecx
        shl     ebx, 9
        sub     [ebp+EXTFS.inodeBuffer.fileSize], ebx
        stc
        jmp     .ret
 
.newBlock:
        pop     ebx ecx
        mov     al, ERROR_FS_FAIL
        test    edx, edx
        jnz     .errFree
        mov     [ebp+EXTFS.inodeBuffer.tripleAddress], ebx
        inc     ebx
        dec     ecx
        inc     dword[esp]
        push    ecx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        mov     edi, esi
        xor     eax, eax
        rep stosd
        mov     edi, esi
        pop     ecx
@@:
        jecxz   .extentAlloc
        call    doublyIndirectBlockAlloc
        jc      .errSave
        add     edi, 4
        jmp     @b
 
.extentAlloc:
        mov     ecx, [esp]
        mov     eax, [esp+4]
        jecxz   @f
        call    extfsExtentAlloc
        jc      .errSave
        sub     [esp], ecx
        jmp     @b
 
@@:
        mov     eax, [ebp+EXTFS.inodeBuffer.tripleAddress]
        mov     ebx, esi
        call    extfsWriteBlock
        stdcall kernel_free, esi
.done:
        xor     eax, eax
        pop     edi
.ret:
        pop     edi edi esi ebx
        ret
 
.errSave:
        push    eax
        mov     eax, [ebp+EXTFS.inodeBuffer.tripleAddress]
        mov     ebx, esi
        call    extfsWriteBlock
        pop     eax
        jmp     .errFree
 
freeBlockList:
; in: edi -> list of blocks, edx = amount of blocks
; out: ebx=0 -> end of list
        mov     ebx, [edi]
        test    ebx, ebx
        jz      .ret
        xor     eax, eax
        xor     ecx, ecx
@@:
        stosd
        inc     ecx
        dec     edx
        jz      @f
        mov     eax, [edi]
        sub     eax, ebx
        sub     eax, ecx
        jz      @b
@@:
        mov     eax, ebx
        call    extfsExtentFree
        test    edx, edx
        jnz     freeBlockList
.ret:
        ret
 
freeIndirectBlock:
; in: edi -> indirect block number, edx = starting block
; out: edi = edi+4, eax=0 -> end
        pushd   ecx 0 edi edx
        mov     eax, [edi]
        test    eax, eax
        jz      .ret
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsReadBlock
        jc      .ret
        lea     edi, [ebx+edx*4]
        neg     edx
        add     edx, [ebp+EXTFS.dwordsPerBlock]
        call    freeBlockList
        test    ebx, ebx
        jz      @f
        inc     dword[esp+8]
@@:
        pop     edx edi
        mov     eax, [edi]
        test    edx, edx
        jnz     @f
        xor     ecx, ecx
        inc     ecx
        call    extfsExtentFree
        stosd
        jmp     .done
 
@@:
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    extfsWriteBlock
        add     edi, 4
.done:
        pop     eax ecx
        xor     edx, edx
        ret
 
.ret:
        pop     edi edi edx ecx
        ret
 
freeDoublyIndirectBlock:
; in: edi -> doubly-indirect block number, edx = starting block
; out: edi = edi+4, eax=-1 -> done, eax=0 -> end
        mov     eax, [edi]
        test    eax, eax
        jz      .ret
        push    ecx eax edx
        stdcall kernel_alloc, [ebp+EXTFS.bytesPerBlock]
        mov     ebx, eax
        pop     edx eax
        pushd   0 ebx edx
        call    extfsReadBlock
        jc      .err
        mov     eax, edx
        xor     edx, edx
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        div     ecx
        sub     ecx, eax
        push    edi
        lea     edi, [ebx+eax*4]
@@:
        call    freeIndirectBlock
        test    eax, eax
        jz      .end
        dec     ecx
        jnz     @b
        dec     dword[esp+12]
.end:
        pop     edi edx
        mov     eax, [edi]
        test    edx, edx
        jnz     @f
        xor     ecx, ecx
        inc     ecx
        call    extfsExtentFree
        stosd
        jmp     .done
 
@@:
        mov     ebx, [esp]
        call    extfsWriteBlock
        add     edi, 4
        jmp     .done
 
.err:
        mov     [esp+8], eax
        pop     eax
.done:
        call    kernel_free
        pop     eax ecx
.ret:
        xor     edx, edx
        ret
 
extfsTruncateFile:
; in: edx:eax = new size, [ebp+EXTFS.inodeBuffer] = inode
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ecx, edx
        cmp     eax, [esi+INODE.fileSize]
        sbb     ecx, [esi+INODE.fileSizeHigh]
        jnc     .ret
        mov     [esi+INODE.fileSize], eax
        mov     [esi+INODE.fileSizeHigh], edx
        sub     eax, 1
        sbb     edx, 0
        jc      @f
        div     [ebp+EXTFS.bytesPerBlock]
@@:
        inc     eax
        mov     edx, eax
        cmp     edx, 12
        jc      .directBlocks
        sub     edx, 12
        cmp     edx, [ebp+EXTFS.dwordsPerBlock]
        jc      .indirectBlocks
        sub     edx, [ebp+EXTFS.dwordsPerBlock]
        cmp     edx, [ebp+EXTFS.dwordsPerBranch]
        jc      .doublyIndirectBlock
        sub     edx, [ebp+EXTFS.dwordsPerBranch]
        jmp     .triplyIndirectBlock
 
.directBlocks:
        lea     edi, [esi+INODE.blockNumbers+edx*4]
        neg     edx
        add     edx, 12
        call    freeBlockList
        test    ebx, ebx
        jz      .ret
.indirectBlocks:
        lea     edi, [esi+INODE.addressBlock]
        call    freeIndirectBlock
        test    eax, eax
        jz      .ret
.doublyIndirectBlock:
        lea     edi, [esi+INODE.doubleAddress]
        call    freeDoublyIndirectBlock
        test    eax, eax
        jz      .ret
.triplyIndirectBlock:
        mov     eax, [esi+INODE.tripleAddress]
        test    eax, eax
        jz      .ret
        push    eax edx
        stdcall kernel_alloc, [ebp+EXTFS.bytesPerBlock]
        mov     ebx, eax
        pop     edx eax
        push    ebx eax edx
        call    extfsReadBlock
        jc      .err
        mov     eax, edx
        xor     edx, edx
        div     [ebp+EXTFS.dwordsPerBranch]
        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
        sub     ecx, eax
        lea     edi, [ebx+eax*4]
@@:
        call    freeDoublyIndirectBlock
        test    eax, eax
        jz      .end
        dec     ecx
        jnz     @b
.end:
        pop     edx eax
        test    edx, edx
        jnz     @f
        xor     ecx, ecx
        inc     ecx
        call    extfsExtentFree
        mov     [esi+INODE.tripleAddress], eax
        jmp     .done
 
@@:
        mov     ebx, [esp]
        call    extfsWriteBlock
        jmp     .done
 
.err:
        pop     eax eax
.done:
        call    kernel_free
.ret:
        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
        push    esi ebx ecx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ebx, esi
        call    readInode
        jc      .error_inode_read
        mov     eax, [esi+INODE.fileSize]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        xor     ecx, ecx
.searchBlock:
        push    eax     ; blocks total
        push    ecx     ; current file block number
        cmp     eax, ecx
        jz      .alloc_block
        call    extfsGetExtent
        jc      .error_get_inode_block
        push    eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .error_block_read
        mov     ecx, [esp+12]
        add     ecx, 8  ; directory entry size
        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
@@:
        pop     ecx eax
        inc     ecx
        jmp     .searchBlock
 
.zeroLength:
        mov     eax, edx
        sub     eax, edi
        mov     [edi+DIRENTRY.entryLength], ax
        cmp     eax, ecx
        jge     .found
        mov     [edi+DIRENTRY.inodeNumber], 0
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jmp     @b
 
.alloc_block:
        mov     eax, [esi+INODE.fileSize]
        add     eax, [ebp+EXTFS.bytesPerBlock]
        xor     edx, edx
        mov     ecx, [esp+24]
        call    extfsExtendFile
        jc      .error_get_inode_block
        mov     eax, [esp+24]
        mov     ebx, esi
        call    writeInode
        jc      .error_get_inode_block
        mov     ecx, [esp]
        call    extfsGetExtent
        jc      .error_get_inode_block
        push    eax
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        mov     eax, [ebp+EXTFS.bytesPerBlock]
        mov     [edi+DIRENTRY.entryLength], ax
.found:
        pop     edx ecx ecx ecx ebx esi
        mov     [edi+DIRENTRY.inodeNumber], ebx
        mov     word [edi+DIRENTRY.nameLength], cx
        sub     eax, 8
        cmp     ecx, eax
        adc     ecx, 0
        test    [ebp+EXTFS.superblock.incompatibleFlags], 2
        jz      @f
        mov     eax, [esp]
        mov     [edi+DIRENTRY.fileType], al
@@:
        push    ebx
        add     edi, 8
        rep movsb
        mov     eax, edx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        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 = directory inode number, esi = inode to unlink
        push    edi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .ret
        xor     ecx, ecx
.loop:
        push    ecx
        call    extfsGetExtent
        jc      .fail_loop
        mov     edi, eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail_loop
.first_dir_entry:   ; edi -> block
        cmp     [ebx+DIRENTRY.inodeNumber], esi
        jne     @f
        mov     [ebx+DIRENTRY.inodeNumber], 0
        mov     word [ebx+DIRENTRY.nameLength], 0   ; fileType = 0
        jmp     .write_block
 
.fail:
        pop     edi
        movi    eax, ERROR_FS_FAIL
        stc
.fail_loop:
        pop     edi
        jmp     .ret
 
.next:
        pop     ecx ecx
        inc     ecx
        jmp     .loop
 
@@:
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
        push    edx
@@:
        movzx   ecx, [ebx+DIRENTRY.entryLength]
        jecxz   .fail
        mov     edx, ebx
        add     ebx, ecx
        cmp     ebx, [esp]
        jnc     .next
        cmp     [ebx+DIRENTRY.inodeNumber], esi
        jnz     @b
        mov     cx, [ebx+DIRENTRY.entryLength]
        add     [edx+DIRENTRY.entryLength], cx
        pop     eax
.write_block:
        pop     eax
        mov     eax, edi
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
.ret:
        pop     edi
        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   ebx 0 ROOT_INODE
        mov     edi, esi
        cmp     [edx+INODE.fileSize], 0
        jz      .not_found
        cmp     byte [esi], 0
        jnz     .next_path_part
        xor     eax, eax
        pop     esi ecx ebx
        ret
 
@@:
        pop     esi esi
.error:
        pop     esi ecx ebx
        xor     edi, edi
        stc
        ret
 
.next_path_part:
        push    [edx+INODE.fileSize]
        xor     ecx, ecx
.folder_block_cycle:
        push    ecx
        call    extfsGetExtent
        jc      @b
        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   ecx, [ebx+DIRENTRY.entryLength]
        jecxz   .stop
        add     ebx, ecx
        cmp     ebx, edx
        jb      .start_rec
        jmp     .stop
 
.test_find:
        cmp     byte [esi], 0
        je      @f
        cmp     byte [esi], '/'
        jne     @b
        inc     esi
@@:
        pop     edx
.stop:
        pop     edx edi ecx eax
; ebx -> matched directory entry, esi -> name without parent, or not changed
        cmp     edi, esi
        jnz     @f
        sub     eax, [ebp+EXTFS.bytesPerBlock]
        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 ebx
        ret
 
writeSuperblock:
        push    ebx
        mov     eax, 2
        lea     ebx, [ebp+EXTFS.superblock]
        call    fs_write32_sys
        pop     ebx
        ret
 
extfsWritingInit:
        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
        call    findInode
        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    extfsGetExtent
        jc      .error_get_block
        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    extfsGetExtent
        jc      .error_get_block
        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]
        cmp     byte [esi], '.'
        jnz     @f
        or      byte [edx], KOS_HIDDEN
@@:
        lea     edi, [edx+40]
        cmp     byte [edx+4], 3
        jz      .utf8
        add     ecx, esi
        cmp     byte [edx+4], 2
        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
 
.utf8:
        rep movsb
        mov     byte [edi], 0
        add     edx, 40+520
        jmp     @b
 
.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:
        xor     ebx, ebx
        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
        call    findInode
        pushd   0 eax
        jc      .ret
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     byte [esp], ERROR_ACCESS_DENIED
        test    [esi+INODE.accessMode], FLAG_FILE
        jz      .ret    ; not a file
        mov     byte [esp], ERROR_END_OF_FILE
        mov     eax, [esi+INODE.fileSize]
        mov     edx, [esi+INODE.fileSizeHigh]
        sub     eax, [ebx+4]
        sbb     edx, [ebx+8]
        jc      .ret
        mov     ecx, [ebx+12]
        sub     eax, ecx
        sbb     edx, 0
        jc      @f
        xor     eax, eax
        mov     [esp], eax
@@:
        add     ecx, eax
        mov     eax, [ebx+4]
        mov     edx, [ebx+8]
        mov     edi, [ebx+16]
        div     [ebp+EXTFS.bytesPerBlock]
        test    edx, edx
        jz      .aligned
.piece:
        push    eax ecx
        mov     esi, edx
        mov     ecx, eax
        call    extfsGetExtent
        jc      .errorGet
        mov     ecx, [ebp+EXTFS.sectorsPerBlock]
        mul     ecx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    fs_read64_sys
        test    eax, eax
        jnz     .errorRead
        pop     eax
        mov     ecx, [ebp+EXTFS.bytesPerBlock]
        sub     ecx, esi
        sub     eax, ecx
        jnc     @f
        add     ecx, eax
        xor     eax, eax
@@:
        add     esi, ebx
        add     [esp+8], ecx
        rep movsb
        mov     ecx, eax
        pop     eax
        inc     eax
        xor     edx, edx
        jecxz   .ret
.aligned:
        xchg    eax, ecx
        div     [ebp+EXTFS.bytesPerBlock]
        push    edx
        mov     edx, eax
.writeExtent:
        test    edx, edx
        jz      .end
        push    ecx
        call    extfsGetExtent
        jc      .errorGet
        sub     edx, ecx
        jnc     @f
        add     ecx, edx
        xor     edx, edx
@@:
        add     [esp], ecx
        imul    ecx, [ebp+EXTFS.sectorsPerBlock]
        mov     ebx, edi
        push    edx ecx
        mul     [ebp+EXTFS.sectorsPerBlock]
        call    fs_read64_sys
        pop     ecx edx
        test    eax, eax
        jnz     .errorRead
        shl     ecx, 9
        add     edi, ecx
        add     [esp+12], ecx
        pop     ecx
        jmp     .writeExtent
 
.end:
        mov     eax, ecx
        pop     ecx
        jecxz   .ret
        jmp     .piece
 
.errorRead:
        movi    eax, ERROR_DEVICE
.errorGet:
        pop     ebx ebx
        mov     [esp], eax
.ret:
        call    ext_unlock
        pop     eax ebx
        ret
 
;----------------------------------------------------------------
ext_GetFileInfo:
        cmp     byte [esi], 0
        jz      .volume
        call    ext_lock
        call    findInode
        jc      .ret
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     edx, [ebx+16]
        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
        xor     eax, eax
.ret:
        push    eax
        call    ext_unlock
        pop     eax
@@:
        ret
 
.volume:
        mov     eax, dword[ebp+EXTFS.Length]
        mov     edx, dword[ebp+EXTFS.Length+4]
        mov     edi, [ebx+16]
        shld    edx, eax, 9
        shl     eax, 9
        mov     [edi+36], edx
        mov     [edi+32], eax
        mov     eax, [ebx+8]
        mov     byte [edi], 8
        mov     [edi+4], eax
        test    eax, eax
        jz      @b
        lea     esi, [ebp+EXTFS.superblock.volumeLabel]
        mov     ecx, 16
        add     edi, 40
        cmp     eax, 3
        jz      .utf8
        add     ecx, esi
        cmp     eax, 2
        jz      .utf16
@@:
        call    utf8to16
        call    uni2ansi_char
        stosb
        cmp     esi, ecx
        jc      @b
        jmp     @f
 
.utf8:
        rep movsb
        jmp     @f
 
.utf16:
        call    utf8to16
        stosw
        cmp     esi, ecx
        jc      .utf16
@@:
        xor     eax, eax
        mov     [edi], ax
        ret
 
;----------------------------------------------------------------
ext_SetFileInfo:
        call    extfsWritingInit
        call    findInode
        jc      @f
        push    esi
        mov     esi, [ebx+16]
        add     esi, 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
        jc      .error
        push    ecx
        movzx   edi, [ebp+EXTFS.inodeBuffer.accessMode]
        and     edi, TYPE_MASK
        cmp     edi, DIRECTORY
        jne     .file
        xor     ecx, ecx
.checkDirectory:
        push    ecx
        call    extfsGetExtent
        jc      .empty
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .error8
        mov     edx, ebx
        add     edx, [ebp+EXTFS.bytesPerBlock]
.dir_entry:
        movzx   ecx, [ebx+DIRENTRY.nameLength]
        mov     ax, word [ebx+DIRENTRY.name]
        jecxz   @f
        cmp     al, '.'
        jnz     .not_empty
        dec     ecx
        jz      @f
        cmp     al, ah
        jnz     .not_empty
        dec     ecx
        jnz     .not_empty
@@:
        mov     cx, [ebx+DIRENTRY.entryLength]
        jecxz   @f
        add     ebx, ecx
        cmp     ebx, edx
        jb      .dir_entry
@@:
        pop     ecx
        inc     ecx
        jmp     .checkDirectory
 
.not_empty:
        pop     eax eax
        push    ERROR_ACCESS_DENIED
        jmp     .ret
 
.error8:
        pop     ebx
.error4:
        pop     ebx
.error:
        push    eax
        jmp     .ret
 
.empty:
        pop     ecx ecx
        cmp     eax, ERROR_END_OF_FILE
        jnz     .error
        push    ecx
.file:
        mov     eax, ecx
        call    unlinkInode
        jc      .error4
        pop     eax
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        cmp     edi, DIRECTORY
        jnz     @f
        dec     [ebx+INODE.linksCount]
        call    writeInode
@@:
        mov     eax, esi
        call    readInode
        jc      .error
        dec     [ebx+INODE.linksCount]
        jz      @f
        cmp     edi, DIRECTORY
        jnz     .hardlinks
@@:
        push    esi edi
        xor     eax, eax
        xor     edx, edx
        call    extfsTruncateFile   ; free file's data
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        xor     eax, eax
        push    edi
        rep stosb
        call    fsGetTime
        pop     ebx edi esi
        add     eax, 978307200
        mov     [ebx+INODE.deletedTime], eax
        mov     eax, esi
        dec     eax
        xor     edx, edx
        div     [ebp+EXTFS.superblock.inodesPerGroup]
        push    edx
        mov     ebx, [ebp+EXTFS.descriptorTable]
        shl     eax, 5
        add     ebx, eax
        cmp     edi, DIRECTORY
        jnz     @f
        dec     [ebx+BGDESCR.directoriesCount]
@@:
        inc     [ebx+BGDESCR.inodesFree]
        push    [ebx+BGDESCR.inodeBitmap]
        call    extfsWriteDescriptor
        pop     eax
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        mov     ecx, eax
        call    extfsReadBlock
        pop     edx
        jc      .error
        mov     eax, edx
        and     edx, 31
        shr     eax, 5
        shl     eax, 2
        add     eax, ebx
        btr     [eax], edx
        mov     eax, ecx
        call    extfsWriteBlock
        inc     [ebp+EXTFS.superblock.inodesFree]
.hardlinks:
        mov     eax, esi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    writeInode
        push    eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
.ret:
        call    ext_unlock
        xor     ebx, ebx
        pop     eax
        ret
 
;----------------------------------------------------------------
ext_CreateFolder:
        call    extfsWritingInit
        call    findInode
        jnc     .success    ; exist
        test    edi, edi
        jz      .error
        mov     eax, esi
        call    extfsInodeAlloc
        jc      .error
        push    ebx esi edi
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        xor     eax, eax
        rep stosb
        call    fsGetTime
        add     eax, 978307200
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        mov     [ebx+INODE.accessedTime], eax
        mov     [ebx+INODE.dataModified], eax
        pop     edi esi edx
; edx = allocated inode number, edi -> filename, esi = parent inode number
        mov     [ebx+INODE.accessMode], DIRECTORY or 511
        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     ebx, [ebp+EXTFS.descriptorTable]
        shl     eax, 5
        add     ebx, eax
        inc     [ebx+BGDESCR.directoriesCount]
        call    extfsWriteDescriptor
.success:
.error:
        push    eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
        call    ext_unlock
        pop     eax
        ret
 
self_link   db ".", 0
parent_link db "..", 0
 
;----------------------------------------------------------------
ext_CreateFile:
        call    extfsWritingInit
        pushd   0 0 ebx
        call    findInode
        jnc     .exist
        test    edi, edi
        jz      .error
        mov     eax, esi
        call    extfsInodeAlloc
        jc      .error
        push    ebx ebx esi edi
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        xor     eax, eax
        rep stosb
        call    fsGetTime
        add     eax, 978307200
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        mov     [ebx+INODE.accessedTime], eax
        mov     [ebx+INODE.dataModified], eax
        pop     edi esi edx
; edx = allocated inode number, edi -> filename, esi = parent inode number
        mov     [ebx+INODE.accessMode], FLAG_FILE or 110110110b
        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
        mov     eax, [ebx+12]
        xor     edx, edx
        jmp     ext_WriteFile.start
 
.exist:
        movi    eax, ERROR_ACCESS_DENIED
        test    [ebp+EXTFS.inodeBuffer.accessMode], FLAG_FILE
        jz      .error  ; not a file
        pop     ebx
        mov     eax, [ebx+12]
        xor     edx, edx
        push    eax edx ebx esi
        call    extfsTruncateFile
        pop     esi ebx edx eax
        jmp     ext_WriteFile.start
 
.error2:
        pop     ebx
.error:
        push    eax
        call    ext_unlock
        pop     eax ebx ebx ebx
        ret
 
;----------------------------------------------------------------
ext_WriteFile:
        call    extfsWritingInit
        call    findInode
        pushd   0 eax
        jc      .ret
        mov     byte [esp], ERROR_ACCESS_DENIED
        test    [ebp+EXTFS.inodeBuffer.accessMode], FLAG_FILE
        jz      .ret    ; not a file
        mov     byte [esp], 0
        mov     eax, [ebx+4]
        mov     edx, [ebx+8]
        add     eax, [ebx+12]
        adc     edx, 0
.start:
        push    esi
        mov     ecx, esi
        call    extfsExtendFile
        jc      .errorExtend
        mov     eax, [ebx+4]
        mov     edx, [ebx+8]
        mov     ecx, [ebx+12]
        mov     esi, [ebx+16]
.write:
        jecxz   .zero
        div     [ebp+EXTFS.bytesPerBlock]
        test    edx, edx
        jz      .aligned
.piece:
        mov     ebx, ecx
        mov     edi, edx
        mov     ecx, eax
        push    eax
        call    extfsGetExtent
        jc      .errorGet
        mov     ecx, [ebp+EXTFS.sectorsPerBlock]
        mul     ecx
        push    ecx eax ebx
        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
        call    fs_read64_sys
        test    eax, eax
        jnz     .errorDevice
        pop     eax
        mov     ecx, [ebp+EXTFS.bytesPerBlock]
        sub     ecx, edi
        sub     eax, ecx
        jnc     @f
        add     ecx, eax
        xor     eax, eax
@@:
        add     edi, ebx
        add     [esp+20], ecx
        rep movsb
        mov     edi, eax
        pop     eax ecx
        xor     edx, edx
        call    fs_write64_sys
        mov     ecx, edi
        pop     eax
        inc     eax
        xor     edx, edx
.zero:
        jecxz   .done
.aligned:
        xchg    eax, ecx
        div     [ebp+EXTFS.bytesPerBlock]
        push    edx
        mov     edx, eax
.writeExtent:
        test    edx, edx
        jz      .end
        push    ecx
        call    extfsGetExtent
        jc      .errorGet2
        sub     edx, ecx
        jnc     @f
        add     ecx, edx
        xor     edx, edx
@@:
        add     [esp], ecx
        imul    ecx, [ebp+EXTFS.sectorsPerBlock]
        mov     ebx, esi
        push    edx ecx
        mul     [ebp+EXTFS.sectorsPerBlock]
        call    fs_write64_sys
        test    eax, eax
        jnz     .errorDevice
        pop     ebx edx ecx
        shl     ebx, 9
        add     esi, ebx
        add     [esp+12], ebx
        jmp     .writeExtent
 
.end:
        mov     eax, ecx
        pop     ecx
        jecxz   .done
        jmp     .piece
 
.errorDevice:
        pop     eax eax
        movi    eax, ERROR_DEVICE
.errorGet2:
        pop     ebx
.errorGet:
        pop     ebx
.errorExtend:
        mov     [esp+4], eax
.done:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     eax
        call    writeInode
        add     [esp], eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
.ret:
        call    ext_unlock
        pop     eax ebx
        ret
 
.erase:
        push    eax eax edi
        mov     eax, ebx
        jmp     .write
 
;----------------------------------------------------------------
ext_SetFileEnd:
        call    extfsWritingInit
        call    findInode
        jc      .error2
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        test    [edi+INODE.accessMode], FLAG_FILE
        jz      .error2 ; not a file
        mov     eax, [ebx+4]
        mov     edx, [ebx+8]
        mov     ebx, [edi+INODE.fileSize]
        mov     ecx, [edi+INODE.fileSizeHigh]
        push    esi ecx
        cmp     ebx, eax
        sbb     ecx, edx
        mov     ecx, esi
        jnc     @f
        call    extfsExtendFile
        pop     esi
        jc      .error
        mov     eax, [edi+INODE.fileSize]
        mov     edx, [edi+INODE.fileSizeHigh]
        sub     eax, ebx
        sbb     edx, esi
        jnz     .done
        cmp     eax, 1000001h
        jnc     .done
        push    eax
        stdcall kernel_alloc, eax
        pop     ecx
        test    eax, eax
        jz      .error
        push    ecx
        add     ecx, 3
        shr     ecx, 2
        mov     edx, esi
        mov     esi, eax
        mov     edi, eax
        xor     eax, eax
        rep stosd
        pop     ecx edi
        push    esi
        call    ext_WriteFile.erase
        call    kernel_free
        xor     eax, eax
        ret
 
@@:
        call    extfsTruncateFile
        pop     eax
.done:
        xor     eax, eax
.error:
        xchg    eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    writeInode
        add     [esp], eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
        pop     eax
.error2:
        push    eax
        call    ext_unlock
        pop     eax
        ret

Rev 6876	Rev 6880
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: 6876 $	8	$Revision: 6880 $
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	UUID rb 16	107	UUID rb 16
108	volumeLabel rb 16	108	volumeLabel rb 16
109	ends	109	ends
110		110
111	; ext4 extent tree	111	; ext4 extent tree
112	struct NODEHEADER ; tree node header	112	struct NODEHEADER ; tree node header
113	magic dw ? ; 0xF30A	113	magic dw ? ; 0xF30A
114	entriesFolow dw ?	114	entriesFolow dw ?
115	entriesMax dw ?	115	entriesMax dw ?
116	currentDepth dw ?	116	currentDepth dw ?
117	generation dd ?	117	generation dd ?
118	ends	118	ends
119		119
120	struct INDEX ; root/branch	120	struct INDEX ; root/branch
121	fileBlock dd ?	121	fileBlock dd ?
122	nodeBlock dd ?	122	nodeBlock dd ?
123	nodeBlockHigh dw ?	123	nodeBlockHigh dw ?
124	reserved dw ?	124	reserved dw ?
125	ends	125	ends
126		126
127	struct EXTENT ; leaf	127	struct EXTENT ; leaf
128	fileBlock dd ?	128	fileBlock dd ?
129	blocksCount dw ?	129	blocksCount dw ?
130	fsBlockHigh dw ?	130	fsBlockHigh dw ?
131	fsBlock dd ?	131	fsBlock dd ?
132	ends	132	ends
133		133
134	ROOT_INODE = 2	134	ROOT_INODE = 2
135	EXTENTS_USED = 80000h	135	EXTENTS_USED = 80000h
136	TYPE_MASK = 0F000h	136	TYPE_MASK = 0F000h
137	FLAG_FILE = 8000h	137	FLAG_FILE = 8000h
138	DIRECTORY = 4000h	138	DIRECTORY = 4000h
139	DIR_FLAG_FILE = 1	139	DIR_FLAG_FILE = 1
140	DIR_DIRECTORY = 2	140	DIR_DIRECTORY = 2
141	KOS_HIDDEN = 2	141	KOS_HIDDEN = 2
142	KOS_DIRECTORY = 10h	142	KOS_DIRECTORY = 10h
143	READ_ONLY = 1	143	READ_ONLY = 1
144		144
145	; Implemented "incompatible" features:	145	; Implemented "incompatible" features:
146	; 2 = have file type in directory entry	146	; 2 = have file type in directory entry
147	; 40h = extents	147	; 40h = extents
148	; 200h = flexible block groups	148	; 200h = flexible block groups
149	INCOMPATIBLE_SUPPORT = 242h	149	INCOMPATIBLE_SUPPORT = 242h
150	; Read only support for "incompatible" features:	150	; Read only support for "incompatible" features:
151	INCOMPATIBLE_READ_SUPPORT = 240h	151	INCOMPATIBLE_READ_SUPPORT = 240h
152		152
153	; Implemented "read-only" features:	153	; Implemented "read-only" features:
154	; 1 = sparse superblock	154	; 1 = sparse superblock
155	; 2 = 64-bit file size	155	; 2 = 64-bit file size
156	READ_ONLY_SUPPORT = 3	156	READ_ONLY_SUPPORT = 3
157		157
158	struct EXTFS PARTITION	158	struct EXTFS PARTITION
159	Lock MUTEX	159	Lock MUTEX
160	mountType dd ?	160	mountType dd ?
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	descriptorTable dd ?	167	descriptorTable dd ?
168	descriptorTableEnd dd ?	168	descriptorTableEnd dd ?
169	align0 rb 200h-EXTFS.align0	169	align0 rb 200h-EXTFS.align0
170	superblock SUPERBLOCK	170	superblock SUPERBLOCK
171	align1 rb 400h-EXTFS.align1	171	align1 rb 400h-EXTFS.align1
172	rootInodeBuffer INODE	172	rootInodeBuffer INODE
173	align2 rb 600h-EXTFS.align2	173	align2 rb 600h-EXTFS.align2
174	inodeBuffer INODE	174	inodeBuffer INODE
175	align3 rb 800h-EXTFS.align3	175	align3 rb 800h-EXTFS.align3
176	ends	176	ends
177		177
178	; mount if it's a valid EXT partition	178	; mount if it's a valid EXT partition
179	ext2_create_partition:	179	ext2_create_partition:
180	; in:	180	; in:
181	; ebp -> PARTITION structure	181	; ebp -> PARTITION structure
182	; ebx -> boot sector	182	; ebx -> boot sector
183	; ebx+512 -> buffer	183	; ebx+512 -> buffer
184	; out:	184	; out:
185	; eax -> EXTFS structure, 0 = not EXT	185	; eax -> EXTFS structure, 0 = not EXT
186	push ebx	186	push ebx
187	cmp dword [esi+DISK.MediaInfo.SectorSize], 512	187	cmp dword [esi+DISK.MediaInfo.SectorSize], 512
188	jnz .fail	188	jnz .fail
189	mov eax, 2	189	mov eax, 2
190	add ebx, 512	190	add ebx, 512
191	call fs_read32_sys	191	call fs_read32_sys
192	test eax, eax	192	test eax, eax
193	jnz .fail	193	jnz .fail
194	cmp [ebx+SUPERBLOCK.magic], 0xEF53	194	cmp [ebx+SUPERBLOCK.magic], 0xEF53
195	jne .fail	195	jne .fail
196	cmp [ebx+SUPERBLOCK.state], 1	196	cmp [ebx+SUPERBLOCK.state], 1
197	ja .fail	197	ja .fail
198	test [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT	198	test [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT
199	jnz .fail	199	jnz .fail
200	cmp [ebx+SUPERBLOCK.sectorsPerBlockLog], 6 ; 64KB	200	cmp [ebx+SUPERBLOCK.sectorsPerBlockLog], 6 ; 64KB
201	ja .fail	201	ja .fail
202	cmp [ebx+SUPERBLOCK.inodeSize], 512	202	cmp [ebx+SUPERBLOCK.inodeSize], 512
203	ja .fail	203	ja .fail
204	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0	204	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0
205	je .fail	205	je .fail
206	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0	206	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0
207	je .fail	207	je .fail
208	movi eax, sizeof.EXTFS	208	movi eax, sizeof.EXTFS
209	call malloc	209	call malloc
210	test eax, eax	210	test eax, eax
211	jz .fail	211	jz .fail
212	mov ecx, dword [ebp+PARTITION.FirstSector]	212	mov ecx, dword [ebp+PARTITION.FirstSector]
213	mov dword [eax+EXTFS.FirstSector], ecx	213	mov dword [eax+EXTFS.FirstSector], ecx
214	mov ecx, dword [ebp+PARTITION.FirstSector+4]	214	mov ecx, dword [ebp+PARTITION.FirstSector+4]
215	mov dword [eax+EXTFS.FirstSector+4], ecx	215	mov dword [eax+EXTFS.FirstSector+4], ecx
216	mov ecx, dword [ebp+PARTITION.Length]	216	mov ecx, dword [ebp+PARTITION.Length]
217	mov dword [eax+EXTFS.Length], ecx	217	mov dword [eax+EXTFS.Length], ecx
218	mov ecx, dword [ebp+PARTITION.Length+4]	218	mov ecx, dword [ebp+PARTITION.Length+4]
219	mov dword [eax+EXTFS.Length+4], ecx	219	mov dword [eax+EXTFS.Length+4], ecx
220	mov ecx, [ebp+PARTITION.Disk]	220	mov ecx, [ebp+PARTITION.Disk]
221	mov [eax+EXTFS.Disk], ecx	221	mov [eax+EXTFS.Disk], ecx
222	mov [eax+EXTFS.FSUserFunctions], ext_user_functions	222	mov [eax+EXTFS.FSUserFunctions], ext_user_functions
223		223
224	push ebp esi edi	224	push ebp esi edi
225	mov ebp, eax	225	mov ebp, eax
226	lea ecx, [eax+EXTFS.Lock]	226	lea ecx, [eax+EXTFS.Lock]
227	call mutex_init	227	call mutex_init
228	mov esi, ebx	228	mov esi, ebx
229	lea edi, [ebp+EXTFS.superblock]	229	lea edi, [ebp+EXTFS.superblock]
230	mov ecx, 512/4	230	mov ecx, 512/4
231	rep movsd ; copy superblock	231	rep movsd ; copy superblock
232	mov ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]	232	mov ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]
233	inc ecx	233	inc ecx
234	mov eax, 1	234	mov eax, 1
235	shl eax, cl	235	shl eax, cl
236	mov [ebp+EXTFS.sectorsPerBlock], eax	236	mov [ebp+EXTFS.sectorsPerBlock], eax
237	shl eax, 9	237	shl eax, 9
238	mov [ebp+EXTFS.bytesPerBlock], eax	238	mov [ebp+EXTFS.bytesPerBlock], eax
239	shl eax, 1	239	shl eax, 1
240	push eax	240	push eax
241	shr eax, 3	241	shr eax, 3
242	mov [ebp+EXTFS.dwordsPerBlock], eax	242	mov [ebp+EXTFS.dwordsPerBlock], eax
243	mul eax	243	mul eax
244	mov [ebp+EXTFS.dwordsPerBranch], eax	244	mov [ebp+EXTFS.dwordsPerBranch], eax
245	call kernel_alloc	245	call kernel_alloc
246	test eax, eax	246	test eax, eax
247	jz .error	247	jz .error
248	mov [ebp+EXTFS.mainBlockBuffer], eax	248	mov [ebp+EXTFS.mainBlockBuffer], eax
249	add eax, [ebp+EXTFS.bytesPerBlock]	249	add eax, [ebp+EXTFS.bytesPerBlock]
250	mov [ebp+EXTFS.tempBlockBuffer], eax	250	mov [ebp+EXTFS.tempBlockBuffer], eax
251	mov [ebp+EXTFS.mountType], 0	251	mov [ebp+EXTFS.mountType], 0
252	test [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT	252	test [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT
253	jnz .read_only	253	jnz .read_only
254	test [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT	254	test [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT
255	jz @f	255	jz @f
256	.read_only:	256	.read_only:
257	or [ebp+EXTFS.mountType], READ_ONLY	257	or [ebp+EXTFS.mountType], READ_ONLY
258	@@:	258	@@:
259	mov eax, [ebx+SUPERBLOCK.inodesTotal]	259	mov eax, [ebx+SUPERBLOCK.inodesTotal]
260	dec eax	260	dec eax
261	xor edx, edx	261	xor edx, edx
262	div [ebx+SUPERBLOCK.inodesPerGroup]	262	div [ebx+SUPERBLOCK.inodesPerGroup]
263	inc eax	263	inc eax
264	shl eax, 5	264	shl eax, 5
265	push eax eax	265	push eax eax
266	call kernel_alloc	266	call kernel_alloc
267	pop ecx	267	pop ecx
268	test eax, eax	268	test eax, eax
269	jz .error2	269	jz .error2
270	mov [ebp+EXTFS.descriptorTable], eax	270	mov [ebp+EXTFS.descriptorTable], eax
271	mov ebx, eax	271	mov ebx, eax
272	add eax, ecx	272	add eax, ecx
273	mov [ebp+EXTFS.descriptorTableEnd], eax	273	mov [ebp+EXTFS.descriptorTableEnd], eax
274	mov eax, [ebp+EXTFS.superblock.firstGroupBlock]	274	mov eax, [ebp+EXTFS.superblock.firstGroupBlock]
275	inc eax	275	inc eax
276	mul [ebp+EXTFS.sectorsPerBlock]	276	mul [ebp+EXTFS.sectorsPerBlock]
277	dec ecx	277	dec ecx
278	shr ecx, 9	278	shr ecx, 9
279	inc ecx	279	inc ecx
280	call fs_read64_sys	280	call fs_read64_sys
281	test eax, eax	281	test eax, eax
282	jnz @f	282	jnz @f
283	mov al, ROOT_INODE	283	mov al, ROOT_INODE
284	lea ebx, [ebp+EXTFS.rootInodeBuffer]	284	lea ebx, [ebp+EXTFS.rootInodeBuffer]
285	call readInode	285	call readInode
286	test eax, eax	286	test eax, eax
287	jnz @f	287	jnz @f
288	mov eax, ebp	288	mov eax, ebp
289	pop edi esi ebp ebx	289	pop edi esi ebp ebx
290	ret	290	ret
291		291
292	@@:	292	@@:
293	stdcall kernel_free, [ebp+EXTFS.descriptorTable]	293	stdcall kernel_free, [ebp+EXTFS.descriptorTable]
294	.error2:	294	.error2:
295	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]	295	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
296	.error:	296	.error:
297	mov eax, ebp	297	mov eax, ebp
298	call free	298	call free
299	pop edi esi ebp	299	pop edi esi ebp
300	.fail:	300	.fail:
301	pop ebx	301	pop ebx
302	xor eax, eax	302	xor eax, eax
303	ret	303	ret
304		304
305	; unmount EXT partition	305	; unmount EXT partition
306	ext_free:	306	ext_free:
307	; in: eax -> EXTFS structure	307	; in: eax -> EXTFS structure
308	push eax [eax+EXTFS.mainBlockBuffer]	308	push eax [eax+EXTFS.mainBlockBuffer]
309	stdcall kernel_free, [eax+EXTFS.descriptorTable]	309	stdcall kernel_free, [eax+EXTFS.descriptorTable]
310	call kernel_free	310	call kernel_free
311	pop eax	311	pop eax
312	jmp free	312	jmp free
313		313
314	extfsWriteBlock:	314	extfsWriteBlock:
315	push fs_write64_sys	315	push fs_write64_sys
316	jmp @f	316	jmp @f
317	; in: eax = block number, ebx -> buffer	317	; in: eax = block number, ebx -> buffer
318	extfsReadBlock:	318	extfsReadBlock:
319	push fs_read64_sys	319	push fs_read64_sys
320	@@:	320	@@:
321	push ecx edx	321	push ecx edx
322	mov ecx, [ebp+EXTFS.sectorsPerBlock]	322	mov ecx, [ebp+EXTFS.sectorsPerBlock]
323	mul ecx	323	mul ecx
324	call dword[esp+8]	324	call dword[esp+8]
325	pop edx ecx	325	pop edx ecx
326	add esp, 4	326	add esp, 4
327	test eax, eax	327	test eax, eax
328	jz @f	328	jz @f
329	movi eax, ERROR_DEVICE	329	movi eax, ERROR_DEVICE
330	stc	330	stc
331	@@:	331	@@:
332	ret	332	ret
333		333
334	extfsWriteDescriptor:	334	extfsWriteDescriptor:
335	; in: ebx = block group descriptor	335	; in: ebx = block group descriptor
336	mov eax, [ebp+EXTFS.superblock.firstGroupBlock]	336	mov eax, [ebp+EXTFS.superblock.firstGroupBlock]
337	inc eax	337	inc eax
338	mul [ebp+EXTFS.sectorsPerBlock]	338	mul [ebp+EXTFS.sectorsPerBlock]
339	sub ebx, [ebp+EXTFS.descriptorTable]	339	sub ebx, [ebp+EXTFS.descriptorTable]
340	shr ebx, 9	340	shr ebx, 9
341	add eax, ebx	341	add eax, ebx
342	shl ebx, 9	342	shl ebx, 9
343	add ebx, [ebp+EXTFS.descriptorTable]	343	add ebx, [ebp+EXTFS.descriptorTable]
344	call fs_write32_sys	344	call fs_write32_sys
345	ret	345	ret
346		346
347	extfsExtentFree:	347	extfsExtentFree:
348	; in: eax = first block number, ecx = extent size	348	; in: eax = first block number, ecx = extent size
349	push ebx edx edi	349	push ebx edx edi
350	sub eax, [ebp+EXTFS.superblock.firstGroupBlock]	350	sub eax, [ebp+EXTFS.superblock.firstGroupBlock]
351	xor edx, edx	351	xor edx, edx
352	mov ebx, [ebp+EXTFS.superblock.blocksPerGroup]	352	mov ebx, [ebp+EXTFS.superblock.blocksPerGroup]
353	div ebx	353	div ebx
354	sub ebx, edx	354	sub ebx, edx
355	sub ebx, ecx	355	sub ebx, ecx
356	jc .ret	356	jc .ret
357	push edx	357	push edx
358	mov ebx, [ebp+EXTFS.descriptorTable]	358	mov ebx, [ebp+EXTFS.descriptorTable]
359	shl eax, 5	359	shl eax, 5
360	add ebx, eax	360	add ebx, eax
361	mov eax, ecx	361	mov eax, ecx
362	mul [ebp+EXTFS.sectorsPerBlock]	362	mul [ebp+EXTFS.sectorsPerBlock]
363	add [ebx+BGDESCR.blocksFree], cx	363	add [ebx+BGDESCR.blocksFree], cx
364	add [ebp+EXTFS.superblock.blocksFree], ecx	364	add [ebp+EXTFS.superblock.blocksFree], ecx
365	sub [ebp+EXTFS.inodeBuffer.sectorsUsed], eax	365	sub [ebp+EXTFS.inodeBuffer.sectorsUsed], eax
366	push [ebx+BGDESCR.blockBitmap]	366	push [ebx+BGDESCR.blockBitmap]
367	call extfsWriteDescriptor	367	call extfsWriteDescriptor
368	pop eax	368	pop eax
369	mov ebx, [ebp+EXTFS.tempBlockBuffer]	369	mov ebx, [ebp+EXTFS.tempBlockBuffer]
370	mov edx, eax	370	mov edx, eax
371	call extfsReadBlock	371	call extfsReadBlock
372	pop eax	372	pop eax
373	jc .ret	373	jc .ret
374	push ebx edx	374	push ebx edx
375	mov edi, eax	375	mov edi, eax
376	shr edi, 5	376	shr edi, 5
377	shl edi, 2	377	shl edi, 2
378	add edi, ebx	378	add edi, ebx
379	mov edx, ecx	379	mov edx, ecx
380	and eax, 31	380	and eax, 31
381	jz .aligned	381	jz .aligned
382	mov ecx, 32	382	mov ecx, 32
383	sub ecx, eax	383	sub ecx, eax
384	sub edx, ecx	384	sub edx, ecx
385	jnc @f	385	jnc @f
386	add ecx, edx	386	add ecx, edx
387	xor edx, edx	387	xor edx, edx
388	@@:	388	@@:
389	or ebx, -1	389	or ebx, -1
390	shl ebx, cl	390	shl ebx, cl
391	not ebx	391	not ebx
392	mov ecx, eax	392	mov ecx, eax
393	shl ebx, cl	393	shl ebx, cl
394	not ebx	394	not ebx
395	and [edi], ebx	395	and [edi], ebx
396	add edi, 4	396	add edi, 4
397	xor eax, eax	397	xor eax, eax
398	.aligned:	398	.aligned:
399	mov ecx, edx	399	mov ecx, edx
400	shr ecx, 5	400	shr ecx, 5
401	rep stosd	401	rep stosd
402	and edx, 31	402	and edx, 31
403	jz @f	403	jz @f
404	mov ecx, edx	404	mov ecx, edx
405	not eax	405	not eax
406	shl eax, cl	406	shl eax, cl
407	and [edi], eax	407	and [edi], eax
408	@@:	408	@@:
409	pop eax ebx	409	pop eax ebx
410	call extfsWriteBlock	410	call extfsWriteBlock
411	.ret:	411	.ret:
412	pop edi edx ebx	412	pop edi edx ebx
413	xor eax, eax	413	xor eax, eax
414	ret	414	ret
415		415
416	extfsInodeAlloc:	416	extfsInodeAlloc:
417	; in: eax = parent inode number	417	; in: eax = parent inode number
418	; out: ebx = allocated inode number	418	; out: ebx = allocated inode number
419	push ecx edx edi	419	push ecx edx edi
420	dec eax	420	dec eax
421	xor edx, edx	421	xor edx, edx
422	div [ebp+EXTFS.superblock.inodesPerGroup]	422	div [ebp+EXTFS.superblock.inodesPerGroup]
423	mov ebx, [ebp+EXTFS.descriptorTable]	423	mov ebx, [ebp+EXTFS.descriptorTable]
424	shl eax, 5	424	shl eax, 5
425	add ebx, eax	425	add ebx, eax
426	push ebx	426	push ebx
427	.test_block_group:	427	.test_block_group:
428	push ebx	428	push ebx
429	cmp [ebx+BGDESCR.blocksFree], 0	429	cmp [ebx+BGDESCR.blocksFree], 0
430	jz .next	430	jz .next
431	cmp [ebx+BGDESCR.inodesFree], 0	431	cmp [ebx+BGDESCR.inodesFree], 0
432	jz .next	432	jz .next
433	dec [ebx+BGDESCR.inodesFree]	433	dec [ebx+BGDESCR.inodesFree]
434	dec [ebp+EXTFS.superblock.inodesFree]	434	dec [ebp+EXTFS.superblock.inodesFree]
435	push [ebx+BGDESCR.inodeBitmap]	435	push [ebx+BGDESCR.inodeBitmap]
436	call extfsWriteDescriptor	436	call extfsWriteDescriptor
437	pop eax	437	pop eax
438	mov ebx, [ebp+EXTFS.tempBlockBuffer]	438	mov ebx, [ebp+EXTFS.tempBlockBuffer]
439	mov edx, eax	439	mov edx, eax
440	mov edi, ebx	440	mov edi, ebx
441	call extfsReadBlock	441	call extfsReadBlock
442	jc .fail	442	jc .fail
443	mov ecx, [ebp+EXTFS.superblock.inodesPerGroup]	443	mov ecx, [ebp+EXTFS.superblock.inodesPerGroup]
444	or eax, -1	444	or eax, -1
445	shr ecx, 5	445	shr ecx, 5
446	repz scasd	446	repz scasd
447	jz .next	447	jz .next
448	sub edi, 4	448	sub edi, 4
449	mov eax, [edi]	449	mov eax, [edi]
450	not eax	450	not eax
451	bsf eax, eax	451	bsf eax, eax
452	bts [edi], eax	452	bts [edi], eax
453	sub edi, [ebp+EXTFS.tempBlockBuffer]	453	sub edi, [ebp+EXTFS.tempBlockBuffer]
454	shl edi, 3	454	shl edi, 3
455	add eax, edi	455	add eax, edi
456	mov ecx, eax	456	mov ecx, eax
457	mov eax, edx	457	mov eax, edx
458	call extfsWriteBlock	458	call extfsWriteBlock
459	pop eax	459	pop eax
460	sub eax, [ebp+EXTFS.descriptorTable]	460	sub eax, [ebp+EXTFS.descriptorTable]
461	shr eax, 5	461	shr eax, 5
462	mul [ebp+EXTFS.superblock.inodesPerGroup]	462	mul [ebp+EXTFS.superblock.inodesPerGroup]
463	lea ebx, [eax+ecx+1]	463	lea ebx, [eax+ecx+1]
464	xor eax, eax	464	xor eax, eax
465	.ret:	465	.ret:
466	pop edi edi edx ecx	466	pop edi edi edx ecx
467	ret	467	ret
468		468
469	.next: ; search forward, then backward	469	.next: ; search forward, then backward
470	pop ebx	470	pop ebx
471	cmp ebx, [esp]	471	cmp ebx, [esp]
472	jc .backward	472	jc .backward
473	add ebx, 32	473	add ebx, 32
474	cmp ebx, [ebp+EXTFS.descriptorTableEnd]	474	cmp ebx, [ebp+EXTFS.descriptorTableEnd]
475	jc .test_block_group	475	jc .test_block_group
476	mov ebx, [esp]	476	mov ebx, [esp]
477	.backward:	477	.backward:
478	sub ebx, 32	478	sub ebx, 32
479	cmp ebx, [ebp+EXTFS.descriptorTable]	479	cmp ebx, [ebp+EXTFS.descriptorTable]
480	jnc .test_block_group	480	jnc .test_block_group
481	movi eax, ERROR_DISK_FULL	481	movi eax, ERROR_DISK_FULL
482	push eax	482	push eax
483	.fail:	483	.fail:
484	pop edi	484	pop edi
485	jmp .ret	485	jmp .ret
486		486
487	extfsExtentAlloc:	487	extfsExtentAlloc:
488	; in: eax = parent inode number, ecx = blocks max	488	; in: eax = parent inode number, ecx = blocks max
489	; out: ebx = first block number, ecx = blocks allocated	489	; out: ebx = first block number, ecx = blocks allocated
490	push edx esi edi ecx	490	push edx esi edi ecx
491	dec eax	491	dec eax
492	xor edx, edx	492	xor edx, edx
493	div [ebp+EXTFS.superblock.inodesPerGroup]	493	div [ebp+EXTFS.superblock.inodesPerGroup]
494	mov ebx, [ebp+EXTFS.descriptorTable]	494	mov ebx, [ebp+EXTFS.descriptorTable]
495	shl eax, 5	495	shl eax, 5
496	add ebx, eax	496	add ebx, eax
497	push ebx	497	push ebx
498	.test_block_group:	498	.test_block_group:
499	push ebx	499	push ebx
500	cmp [ebx+BGDESCR.blocksFree], 0	500	cmp [ebx+BGDESCR.blocksFree], 0

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ext.inc @ 6726 – Rev 6876 → 6880