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: 6643 $
+$Revision: 6726 $
 ; EXT external functions
 ;   in:
         pop     eax eax
         movi    eax, ERROR_DISK_FULL
         xor     ecx, ecx
         jmp     .ret
-extfsGetFileBlock:
+extfsGetExtent:
-; in: esi -> inode, ecx = file block number
+; in: ecx = starting file block
+; out: eax = first block number, ecx = extent size
+        push    ebx edx esi
-; out: ecx = block number
+        lea     esi, [ebp+EXTFS.inodeBuffer]
         test    [esi+INODE.featureFlags], EXTENTS_USED
-        jz      .listTreeSearch
-        pushad
+        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
-        add     esi, sizeof.NODEHEADER
+        jz      .noBlock
         cmp     word [esi-sizeof.NODEHEADER+NODEHEADER.currentDepth], 0
         je      .leaf_block
-        test    ebx, ebx
+        dec     ebx
-        jz      .fail   ; empty
+        jz      .end_search_index
-@@:
-        cmp     ebx, 1
-        je      .end_search_index
-        cmp     ecx, [esi+INDEX.fileBlock]
-        jb      .fail
+@@:
         cmp     ecx, [esi+sizeof.INDEX+INDEX.fileBlock]
         jb      .end_search_index
         add     esi, sizeof.INDEX
         dec     ebx
-        jmp     @b
         jnz     @b
 .end_search_index:
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         mov     eax, [esi+INDEX.nodeBlock]
         call    extfsReadBlock
-        jc      .fail
+        jc      .fail2
         mov     esi, ebx
+        jmp     .extentTreeSearch
+.fail:
+        movi    eax, ERROR_FS_FAIL
-        jmp     .extentTreeSearch
+        jmp     .fail2
-.leaf_block:
-        test    ebx, ebx
-        jz      .fail
-        mov     edx, [esi+EXTENT.fileBlock]
-        cmp     ecx, edx
-        jb      .fail
+.leaf_block:
-        movzx   edi, [esi+EXTENT.blocksCount]
+        movzx   edx, [esi+EXTENT.blocksCount]
-        add     edx, edi
+        add     edx, [esi+EXTENT.fileBlock]
-        cmp     ecx, edx
+        sub     edx, ecx
-        jb      .end_search_extent
+        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
-        dec     ebx
+        stc
-        jmp     .leaf_block
+        ret
 .end_search_extent:
-.end_search_extent:
-        sub     ecx, [esi+EXTENT.fileBlock]
-        add     ecx, [esi+EXTENT.fsBlock]
+        sub     ecx, [esi+EXTENT.fileBlock]
-        mov     PUSHAD_ECX, ecx
-        popad
-        xor     eax, eax
-        ret
-.fail:
-        popad
-        movi    eax, ERROR_FS_FAIL
-        stc
-        ret
+        jc      .fail
-.get_indirect_block:
-        mov     eax, [esi+INODE.addressBlock]
-        test    eax, eax
-        jz      .noBlock
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
-        call    extfsReadBlock
+        add     ecx, [esi+EXTENT.fsBlock]
-        jc      .fail2
-        mov     ecx, [ebx+ecx*4]
-        pop     ebx edx
-        ret
-.get_direct_block:
+        mov     eax, ecx
-        mov     ecx, [esi+INODE.blockNumbers+ecx*4]
+        mov     ecx, edx
-        xor     eax, eax
+        pop     esi edx ebx
         ret
 .listTreeSearch:
-        cmp     ecx, 12
+.listTreeSearch:
-        jb      .get_direct_block
+        cmp     ecx, 12
-        push    edx ebx
+        jb      .get_direct_block
         sub     ecx, 12
         call    extfsReadBlock
         jc      .fail2
         mov     eax, edx
         jmp     @f
-.noBlock:
+.get_direct_block:
+        mov     edx, ecx
+        mov     cl, 12
+        lea     ebx, [esi+INODE.blockNumbers]
+        jmp     .calculateExtent
-        xor     ecx, ecx
+.get_indirect_block:
-.fail2:
+        mov     eax, [esi+INODE.addressBlock]
+        test    eax, eax
+        jz      .noBlock
+        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
-        pop     ebx edx
+        call    extfsReadBlock
+        jc      .fail2
+        mov     edx, ecx
+        mov     ecx, [ebp+EXTFS.dwordsPerBlock]
-        ret
+        jmp     .calculateExtent
 .get_double_indirect_block:
         mov     eax, [esi+INODE.doubleAddress]
         call    extfsReadBlock
         jc      .fail2
         mov     eax, ecx
 @@:
         xor     edx, edx
-        div     [ebp+EXTFS.dwordsPerBlock]
+        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
-        mov     ecx, [ebx+edx*4]
+.calculateExtent:
-        pop     ebx edx
+        lea     esi, [ebx+edx*4]
-        ret
+        lodsd
-extfsReadFileBlock:
-;   in:
-; eax = file block number
-; [ebp+EXTFS.inodeBuffer] = inode
-;   out:
-; [ebp+EXTFS.mainBlockBuffer] -> block
-        push    ebx ecx edx esi
-        mov     ecx, eax
+        mov     ebx, eax
-        lea     esi, [ebp+EXTFS.inodeBuffer]
-        call    extfsGetFileBlock
-        jc      .ret
-        test    ecx, ecx
+        sub     ecx, edx
-        jz      @f
-        mov     eax, ecx
+        xor     edx, edx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
-        call    extfsReadBlock
-.ret:
-        pop     esi edx ecx ebx
-        ret
 @@:
-        movi    eax, ERROR_FS_FAIL
+        inc     edx
-        stc
+        dec     ecx
-        jmp     .ret
+        jz      @f
-extfsWriteFileBlock:
-;   in:
-; eax = file block number
-; ebx -> data
+        lodsd
-; [ebp+EXTFS.inodeBuffer] = inode
-        push    ecx edx esi
-        mov     ecx, eax
+        sub     eax, ebx
-        lea     esi, [ebp+EXTFS.inodeBuffer]
-        call    extfsGetFileBlock
-        jc      @f
-        test    ecx, ecx
+        sub     eax, edx
         jz      @b
-        mov     eax, ecx
-        call    extfsWriteBlock
 @@:
+        mov     eax, ebx
+        mov     ecx, edx
-        pop     esi edx ecx
+        pop     esi edx ebx
+        clc
         ret
 getInodeLocation:
 ; in: eax = inode number
 .searchBlock:
         push    eax     ; blocks total
         push    ecx     ; current file block number
         cmp     eax, ecx
         jz      .alloc_block
-        call    extfsGetFileBlock
+        call    extfsGetExtent
         jc      .error_get_inode_block
-        test    ecx, ecx
-        jz      .alloc_block
-        push    ecx
+        push    eax
-        mov     eax, ecx
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsReadBlock
         jc      .error_block_read
         mov     ecx, [esp+12]
         mov     edi, [ebp+EXTFS.tempBlockBuffer]
         jb      .searchSpace
         pop     ecx ecx eax
         inc     ecx
         jmp     .searchBlock
-.alloc_block:
-        mov     ecx, [esi+INODE.fileSize]
-        add     ecx, [ebp+EXTFS.bytesPerBlock]
-        mov     eax, [esp+24]
-        call    extfsExtendFile
-        jc      .error_get_inode_block
-        mov     eax, [esp+24]
-        mov     ebx, esi
-        call    writeInode
-        jc      .error_get_inode_block
-        jmp     @f
 .zeroLength:
         mov     [edi+DIRENTRY.entryLength], cx
         mov     eax, edx
         sub     eax, edi
 ; this block wasn't linking to the next one, so write it, and use the next block
         pop     eax
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsWriteBlock
         jc      .error_get_inode_block
+        pop     ecx
+        inc     ecx
-        inc     dword[esp]
+        cmp     ecx, [esp]
+        push    ecx
+        jnz     @f
-@@:
+.alloc_block:
+        mov     ecx, [esi+INODE.fileSize]
+        add     ecx, [ebp+EXTFS.bytesPerBlock]
+        mov     eax, [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    extfsGetFileBlock
+        call    extfsGetExtent
         jc      .error_get_inode_block
-        test    ecx, ecx
-        jz      .alloc_block
-        push    ecx
+        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
         push    edx ebx
         lea     ebx, [ebp+EXTFS.inodeBuffer]
         call    readInode
         jc      .fail
         push    eax
-        lea     esi, [ebp+EXTFS.inodeBuffer]
 .loop:
         mov     ecx, [esp]
-        call    extfsGetFileBlock
+        call    extfsGetExtent
         jc      .fail_loop
-        test    ecx, ecx
-        jz      .fail_loop
-        mov     eax, ecx
-        mov     edi, ecx
+        mov     edi, eax
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsReadBlock
         jc      .fail_loop
 .first_dir_entry:   ; edi -> block
         mov     eax, [esp+4]
 .next_path_part:
         push    [edx+INODE.sectorsUsed]
         xor     ecx, ecx
 .folder_block_cycle:
         push    ecx
-        xchg    esi, edx
-        call    extfsGetFileBlock
+        call    extfsGetExtent
         jc      @b
-        xchg    esi, edx
-        mov     eax, ecx
         mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      @b
         push    esi edx
         mov     edx, ebx
         push    0           ; [edi+4]  files in folder
         push    0           ; [edi]    current block index
         mov     edi, esp    ; edi -> local variables
         add     edx, 32
         xor     ecx, ecx
-        call    extfsGetFileBlock
+        call    extfsGetExtent
         jc      .error_get_block
-        mov     eax, ecx
         mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      .error_get_block
         mov     eax, ebx
         add     eax, [ebp+EXTFS.bytesPerBlock]
         cmp     [esi+INODE.fileSize], 0
         jle     .end_dir
         inc     dword [edi]
         push    ecx
         mov     ecx, [edi]
-        call    extfsGetFileBlock
+        call    extfsGetExtent
         jc      .error_get_block
-        mov     eax, ecx
         mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      .error_get_block
         pop     ecx
         mov     eax, ebx
         jmp     .error_ret
 ;----------------------------------------------------------------
 ext_ReadFile:
         call    ext_lock
-        push    ERROR_ACCESS_DENIED
+        pushd   0 ERROR_ACCESS_DENIED
         cmp     byte [esi], 0
-        jz      .error  ; root
+        jz      .ret  ; root
         mov     [esp], ebx
         call    findInode
         pop     ebx
-        jc      .error_eax
+        push    eax
-        push    ERROR_ACCESS_DENIED
+        jc      .ret
+        lea     esi, [ebp+EXTFS.inodeBuffer]
-        lea     esi, [ebp+EXTFS.inodeBuffer]
+        mov     byte [esp], ERROR_ACCESS_DENIED
-        mov     ax, [esi+INODE.accessMode]
+        test    [esi+INODE.accessMode], FLAG_FILE
-        and     ax, TYPE_MASK
+        jz      .ret    ; not a file
-        cmp     ax, FLAG_FILE
+        mov     byte [esp], ERROR_END_OF_FILE
+        mov     eax, [esi+INODE.fileSize]
-        jnz     .error  ; not a file
+        mov     edx, [esi+INODE.fileSizeHigh]
-        pop     eax
+        sub     eax, [ebx+4]
+        sbb     edx, [ebx+8]
-        mov     edi, [ebx+16]
+        jc      .ret
         mov     ecx, [ebx+12]
-        mov     eax, [ebx+4]
+        sub     eax, ecx
-        mov     edx, [ebx+8]
-        push    ERROR_END_OF_FILE
-        cmp     [esi+INODE.fileSizeHigh], edx
+        sbb     edx, 0
-        ja      @f
+        jc      @f
-        jb      .error
-        cmp     [esi+INODE.fileSize], eax
+        xor     eax, eax
-        jna     .error
+        mov     [esp], eax
-@@:
-        add     esp, 4
+@@:
-        add     eax, ecx
-        adc     edx, 0
-        cmp     [esi+INODE.fileSizeHigh], edx
-        ja      .read_till_requested
-        jb      .read_whole_file
-        cmp     [esi+INODE.fileSize], eax
-        jae     .read_till_requested
-.read_whole_file:
-        push    1   ; read till the end of file
-        mov     ecx, [esi+INODE.fileSize]
-        sub     ecx, [ebx+4]
-        jmp     @f
-.read_till_requested:
-        push    0   ; read as much as requested
-@@: ; ecx = bytes to read, edi -> buffer
-        push    ecx
-; read part of the first block
-        mov     edx, [ebx+8]
+        add     ecx, eax
+        mov     eax, [ebx+4]
+        mov     edx, [ebx+8]
-        mov     eax, [ebx+4]
+        mov     edi, [ebx+16]
         div     [ebp+EXTFS.bytesPerBlock]
+        test    edx, edx
+        jz      .aligned
-        push    eax
+.piece:
+        push    eax ecx
-        push    ecx
+        mov     esi, edx
         mov     ecx, eax
-        call    extfsGetFileBlock
+        call    extfsGetExtent
+        jc      .errorGet
+        mov     ecx, [ebp+EXTFS.sectorsPerBlock]
-        jc      .error_at_first_block
+        mul     ecx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
-        mov     eax, ecx
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
-        call    extfsReadBlock
-        jc      .error_at_first_block
+        call    fs_read64_sys
-        pop     ecx
+        test    eax, eax
-        add     ebx, edx
+        jnz     .errorRead
-        neg     edx
+        pop     eax
-        add     edx, [ebp+EXTFS.bytesPerBlock]
+        mov     ecx, [ebp+EXTFS.bytesPerBlock]
-        cmp     ecx, edx
+        sub     ecx, esi
-        jbe     .only_one_block
+        sub     eax, ecx
-        mov     eax, ecx
+        jnc     @f
-        sub     eax, edx    ; bytes to read
+        add     ecx, eax
+        xor     eax, eax
-        mov     ecx, edx
+@@:
-        push    esi
+        add     esi, ebx
-        mov     esi, ebx
+        add     [esp+8], ecx
+        rep movsb
-        rep movsb
+        mov     ecx, eax
-        pop     esi
+        pop     eax
-        mov     ebx, edi
+        inc     eax
+        xor     edx, edx
+        jecxz   .ret
+.aligned:
-        xor     edx, edx
+        xchg    eax, ecx
+        div     [ebp+EXTFS.bytesPerBlock]
-        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
-        mov     edi, eax
+        xor     edx, edx
 @@:
-        test    edi, edi
+        add     [esp], ecx
-        jz      .finish_block
+        imul    ecx, [ebp+EXTFS.sectorsPerBlock]
-        inc     dword [esp]
+        mov     ebx, edi
-        mov     ecx, [esp]
+        push    edx ecx
-        call    extfsGetFileBlock
+        mul     [ebp+EXTFS.sectorsPerBlock]
-        jc      .error_at_read_cycle
+        call    fs_read64_sys
-        mov     eax, ecx
+        pop     ecx edx
-        call    extfsReadBlock
+        test    eax, eax
+        jnz     .errorRead
+        shl     ecx, 9
-        jc      .error_at_read_cycle
+        add     edi, ecx
-        add     ebx, [ebp+EXTFS.bytesPerBlock]
+        add     [esp+12], ecx
-        dec     edi
+        pop     ecx
-        jmp     @b
-.finish_block:  ; edx = number of bytes in the last block
+        jmp     .writeExtent
-        test    edx, edx
-        jz      .end_read
-        pop     ecx     ; block counter
-        inc     ecx
-        call    extfsGetFileBlock
         jc      .error_at_finish_block
-        mov     edi, ebx
-        mov     eax, ecx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
-        call    extfsReadBlock
+.end:
-        jc      .error_at_finish_block
-        push    eax
-        mov     ecx, edx
-.only_one_block:
-        mov     esi, ebx
-        rep movsb
-.end_read:
-        call    ext_unlock
+        mov     eax, ecx
-        pop     eax ebx eax
+        pop     ecx
-        test    eax, eax
-        jz      @f
-        movi    eax, ERROR_END_OF_FILE
-@@:
-        ret
+        jecxz   .ret
-.error_at_first_block:
+        jmp     .piece
-        pop     ebx
-.error_at_read_cycle:
+.errorRead:
-        pop     ebx
-.error_at_finish_block:
+        movi    eax, ERROR_DEVICE
-        pop     ebx ebx
+.errorGet:
-.error_eax:
+        pop     ebx ebx
-        push    eax
+        mov     [esp], eax
-.error:
-        call    ext_unlock
+.ret:
-        xor     ebx, ebx
+        call    ext_unlock
-        pop     eax
+        pop     eax ebx
         ret
         lea     edx, [ebp+EXTFS.inodeBuffer]
         movzx   edx, [edx+INODE.accessMode]
         and     edx, TYPE_MASK
         cmp     edx, DIRECTORY
         jne     .file
-        push    ebx ecx edx 0
+        push    ebx ecx edx
-        lea     esi, [ebp+EXTFS.inodeBuffer]
+        xor     ecx, ecx
 .checkDirectory:
-        mov     ecx, [esp]
+        push    ecx
-        call    extfsGetFileBlock
+        call    extfsGetExtent
-        jc      .not_empty_eax
-        test    ecx, ecx
-        jz      .empty
+        jc      .empty
-        mov     eax, ecx
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsReadBlock
         jc      .not_empty_eax
         mov     edx, ebx
         add     edx, [ebp+EXTFS.bytesPerBlock]
         jne     .not_empty
         movzx   ecx, [ebx+DIRENTRY.entryLength]
         add     ebx, ecx
         cmp     ebx, edx
         jb      .dir_entry
+        pop     ecx
-        inc     dword[esp]
+        inc     ecx
         jmp     .checkDirectory
+.empty:
+        cmp     eax, ERROR_END_OF_FILE
-.empty:
+        jnz     .not_empty_eax
         pop     edx edx ecx ebx
 .file:
         mov     eax, ecx
         push    ebx ecx
 parent_link db "..", 0
 ;----------------------------------------------------------------
 ext_CreateFile:
         call    extfsWritingInit
-        push    0 ebx
+        pushd   0 0 ebx
         call    findInode
         jnc     .exist
         test    edi, edi
         jz      .error
         mov     esi, edi
         mov     dl, DIR_FLAG_FILE
         call    linkInode
         jc      .error2
         pop     esi ebx
-        push    ebx esi
         mov     ecx, [ebx+12]
         jmp     ext_WriteFile.start
-.exist:
-        lea     edx, [ebp+EXTFS.inodeBuffer]
+.exist:
         movi    eax, ERROR_ACCESS_DENIED
-        test    [edx+INODE.accessMode], FLAG_FILE
+        test    [ebp+EXTFS.inodeBuffer.accessMode], FLAG_FILE
         jz      .error  ; not a file
-        pop     ebx
-        push    ebx esi
+        pop     ebx
         mov     ecx, [ebx+12]
         call    extfsTruncateFile
         jmp     ext_WriteFile.start
 .error2:
         pop     ebx
 .error:
         push    eax
-        call    ext_unlock
-        pop     eax ebx ebx
+        call    ext_unlock
-        xor     ebx, ebx
+        pop     eax ebx ebx ebx
         ret
 ;----------------------------------------------------------------
 ext_WriteFile:
         call    extfsWritingInit
-        push    0 ebx
+        push    ebx
         call    findInode
-        pop     ebx
-        push    ebx esi
+        pop     ebx
-        jc      .error
+        pushd   0 eax
-        lea     edx, [ebp+EXTFS.inodeBuffer]
+        jc      .ret
-        movi    eax, ERROR_ACCESS_DENIED
+        mov     byte [esp], ERROR_ACCESS_DENIED
-        test    [edx+INODE.accessMode], FLAG_FILE
+        test    [ebp+EXTFS.inodeBuffer.accessMode], FLAG_FILE
-        jz      .error  ; not a file
+        jz      .ret    ; not a file
+        mov     ecx, [ebx+4]
-        mov     ecx, [ebx+4]
+        add     ecx, [ebx+12]
-        add     ecx, [ebx+12]
+.start:
-.start:
-        mov     eax, esi
-        call    extfsExtendFile
+        push    esi
-        mov     ecx, [ebx+12]
-        push    eax
+        mov     eax, esi
-        jc      .error_inode_size
+        call    extfsExtendFile
-        pop     eax
+        jc      .errorExtend
+        mov     eax, [ebx+4]
-        mov     eax, [ebx+4]
+        mov     ecx, [ebx+12]
-        mov     ebx, [ebx+16]
+        mov     esi, [ebx+16]
-        push    eax
+.write:
         xor     edx, edx
+        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
-        div     [ebp+EXTFS.bytesPerBlock]
+        test    eax, eax
-        test    edx, edx
+        jnz     .errorDevice
-        jz      .start_aligned
+        pop     eax
-        mov     esi, [ebp+EXTFS.bytesPerBlock]
+        mov     ecx, [ebp+EXTFS.bytesPerBlock]
+        sub     ecx, edi
-        sub     esi, edx
+        sub     eax, ecx
-        cmp     esi, ecx
+        jnc     @f
-        jbe     @f
-        mov     esi, ecx
-@@:
-        mov     edi, eax
-        call    extfsReadFileBlock
-        jc      .error_inode_size
-        mov     eax, edi
-        push    ebx ecx
-        mov     ecx, esi
-        mov     edi, [ebp+EXTFS.mainBlockBuffer]
+        add     ecx, eax
-        mov     esi, ebx
+        xor     eax, eax
-        mov     ebx, edi
+@@:
-        add     edi, edx
-        mov     edx, ecx
-        rep movsb
-        call    extfsWriteFileBlock
-        pop     ecx ebx
+        add     edi, ebx
-        jc      .error_inode_size
+        add     [esp+20], ecx
-        add     [esp], edx
-        add     ebx, edx
-        sub     ecx, edx
-        jz      .write_inode
-.start_aligned:
-        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
+        rep movsb
-        jb      @f
-        mov     eax, [esp]
+        mov     edi, eax
-        xor     edx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
-        call    extfsWriteFileBlock
+        pop     eax ecx
-        jc      .error_inode_size
+        xor     edx, edx
-        mov     eax, [ebp+EXTFS.bytesPerBlock]
-        sub     ecx, eax
-        add     ebx, eax
-        add     [esp], eax
-        jmp     .start_aligned
+        call    fs_write64_sys
-@@: ; handle the remaining bytes
-        test    ecx, ecx
+        mov     ecx, edi
+        pop     eax
+        inc     eax
+        xor     edx, edx
-        jz      .write_inode
+        jecxz   .done
+.aligned:
+        xchg    eax, ecx
+        div     [ebp+EXTFS.bytesPerBlock]
+        push    edx
+        mov     edx, eax
-        mov     eax, [esp]
+.writeExtent:
+        test    edx, edx
+        jz      .end
+        push    ecx
+        call    extfsGetExtent
+        jc      .errorGet2
-        xor     edx, edx
+        sub     edx, ecx
+        jnc     @f
+        add     ecx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
+        xor     edx, edx
-        push    ecx
+@@:
+        add     [esp], ecx
+        imul    ecx, [ebp+EXTFS.sectorsPerBlock]
+        mov     ebx, esi
+        push    edx ecx
+        mul     [ebp+EXTFS.sectorsPerBlock]
+        call    fs_write64_sys
-        mov     esi, ebx
+        test    eax, eax
+        jnz     .errorDevice
+        pop     ebx edx ecx
+        shl     ebx, 9
+        add     esi, ebx
+        add     [esp+12], ebx
+        jmp     .writeExtent
         mov     edi, [ebp+EXTFS.mainBlockBuffer]
-        mov     ebx, edi
-        rep movsb
+.end:
-        pop     ecx
+        mov     eax, ecx
+        pop     ecx
-        call    extfsWriteFileBlock
+        jecxz   .done
-        jc      .error_inode_size
-        xor     ecx, ecx
-.error_inode_size:
-        mov     [esp+12], eax
+        jmp     .piece
-.write_inode:
+.errorDevice:
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
+        pop     eax eax
+        movi    eax, ERROR_DEVICE
-        pop     eax eax
+.errorGet2:
+        pop     ebx
-        call    writeInode
+.errorGet:
+        pop     ebx
+.errorExtend:
-        pop     ebx
+        mov     [esp+4], eax
-        mov     ebx, [ebx+12]
+.done:
-        sub     ebx, ecx
+        lea     ebx, [ebp+EXTFS.inodeBuffer]
-        test    eax, eax
-        jz      @f
+        pop     eax
-        mov     [esp], eax
+        call    writeInode
-@@:
+        add     [esp], eax
         call    writeSuperblock
         mov     esi, [ebp+PARTITION.Disk]
         call    disk_sync
-@@:
+.ret:
         call    ext_unlock
-        pop     eax
+        pop     eax ebx
         ret
-.error:
+.erase:
-        pop     ebx ebx ebx
+        push    eax eax edx
-        push    eax
+        mov     eax, ebx
-        jmp     @b
+        jmp     .write
+;----------------------------------------------------------------
-;----------------------------------------------------------------
+ext_SetFileEnd:
-ext_SetFileEnd:
+        call    extfsWritingInit
-        call    extfsWritingInit
+        pushd   [ebx+4]
-        pushd   [ebx+4]
+        call    findInode
-        call    findInode
+        pop     ecx
-        jc      .error2
-        lea     edi, [ebp+EXTFS.inodeBuffer]
+        jc      .error2
-        movi    eax, ERROR_ACCESS_DENIED
+        lea     edi, [ebp+EXTFS.inodeBuffer]
-        cmp     [edi+INODE.accessMode], FLAG_FILE
+        movi    eax, ERROR_ACCESS_DENIED
-        jnz     .error2 ; not a file
+        test    [edi+INODE.accessMode], FLAG_FILE
-        pop     ecx
+        jz      .error2 ; not a file
-        push    esi
-        mov     ebx, [edi+INODE.fileSize]
-        mov     eax, esi
-        cmp     ebx, ecx
-        jc      @f
+        push    esi
-        call    extfsTruncateFile
+        mov     ebx, [edi+INODE.fileSize]
-        jmp     .done
+        mov     eax, esi
+        cmp     ebx, ecx
+        jnc     @f
+        call    extfsExtendFile
+        jc      .error
+        sub     ecx, ebx
+        cmp     ecx, 1000001h
+        jnc     .done
+        push    ecx
+        stdcall kernel_alloc, ecx
-@@:
+        pop     ecx
-        call    extfsExtendFile
+        test    eax, eax
-        jc      .error
+        jz      .error
-        sub     ecx, ebx
-        mov     eax, ebx
-        xor     edx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
-        mov     edi, eax
-        test    edx, edx
-        jz      .start_aligned
-        call    extfsReadFileBlock
-        jc      .error
-        mov     eax, [ebp+EXTFS.bytesPerBlock]
-        sub     eax, edx
-        cmp     eax, ecx
-        jbe     @f
-        mov     eax, ecx
-@@:
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        push    ecx
-        push    edi ecx
-        mov     ecx, eax
+        add     ecx, 3
-        mov     edi, ebx
+        shr     ecx, 2
-        add     edi, edx
+        mov     esi, eax
-        xor     eax, eax
+        mov     edi, eax
-        mov     edx, ecx
+        xor     eax, eax
-        rep stosb
-        pop     ecx edi
-        mov     eax, edi
-        call    extfsWriteFileBlock
-        jc      .error
-        sub     ecx, edx
-        jz      .done
-        inc     edi
-.start_aligned:
-        mov     eax, ecx
-        mov     ecx, [ebp+EXTFS.bytesPerBlock]
-        dec     eax
-        xor     edx, edx
-        div     ecx
+        rep stosd
-        inc     eax
+        pop     ecx edx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        push    esi
-        push    eax edi
+        call    ext_WriteFile.erase
-        mov     edi, ebx
-        xor     eax, eax
+        call    kernel_free
-        rep stosb
-        pop     edi ecx
-@@:
-        mov     eax, edi
+        xor     eax, eax
-        call    extfsWriteFileBlock
+        ret
         jc      .error
-        inc     edi
+@@:
-        loop    @b
+        call    extfsTruncateFile
 .done:
-        xor     eax, eax
-.error:
+        xor     eax, eax
-        xchg    eax, [esp]
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
+.error:
-        call    writeInode
+        xchg    eax, [esp]
-        jnc     @f
+        lea     ebx, [ebp+EXTFS.inodeBuffer]
-        mov     [esp], eax
+        call    writeInode
-@@:
+        add     [esp], eax
         call    writeSuperblock
         mov     esi, [ebp+PARTITION.Disk]
         call    disk_sync
-        mov     eax, [esp]
+        pop     eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ext.inc – Rev 6643 → 6726