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

 ;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
 ;;  Distributed under terms of the GNU General Public License.  ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 6558 $
+$Revision: 6575 $
 ; EXT external functions
 ;   in:
         jmp     free
 extfsWriteBlock:
         push    fs_write64_sys
-        jmp     @f
-;   in:
+        jmp     @f
-; eax = block number
-; ebx -> buffer
+; in: eax = block number, ebx -> buffer
 extfsReadBlock:
         push    fs_read64_sys
 @@:
         push    ecx edx
 ; eax = block/inode number
         push    ebx edx
         sub     eax, [ebp+EXTFS.superblock.firstGroupBlock]
         xor     edx, edx
         div     [ebp+EXTFS.superblock.blocksPerGroup]
-        push    eax edx
+        push    edx eax
         call    extfsReadDescriptor
-        jc      .fail
+        jc      .fail2
         inc     [eax+BGDESCR.blocksFree+ecx*2]
-        mov     eax, [eax+BGDESCR.blockBitmap+ecx*4]
+        mov     edx, [eax+BGDESCR.blockBitmap+ecx*4]
+        pop     eax
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        call    extfsWriteDescriptor
+        jc      .fail
-        mov     edx, eax
+        mov     eax, edx
+        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsReadBlock
         jc      .fail
         pop     eax
         push    edx
         mov     edx, eax
         and     edx, 31
         shr     eax, 5
         shl     eax, 2
-        add     eax, [ebp+EXTFS.mainBlockBuffer]
+        add     eax, [ebp+EXTFS.tempBlockBuffer]
         btr     [eax], edx
         pop     eax
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsWriteBlock
         jc      @f
         inc     [ebp+EXTFS.superblock.blocksFree+ecx*4]
-        pop     eax
-        call    extfsWriteDescriptor
-.ret:
+@@:
         pop     edx ebx
         ret
-.fail:
+.fail2:
         pop     eax
-@@:
+.fail:
         pop     eax
         movi    eax, ERROR_DEVICE
-        jmp     .ret
+        jmp     @b
 freeDoublyIndirectBlock:
 ; in: eax = doubly-indirect block number
 ; out: eax=1 -> finished
         test    eax, eax
         jz      .complete
         push    eax
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         pop     eax
         jc      .ret
 .complete:
         inc     eax
         ret
-inodeBlockAlloc:
+inodeBlockAlloc:    ; also erases
-; in: esi -> inode, eax = inode number
-; out: ebx = block number
-        call    extfsBlockAlloc
-        jc      @f
-        mov     eax, [ebp+EXTFS.sectorsPerBlock]
-        add     [esi+INODE.sectorsUsed], eax
-        xor     eax, eax
-@@:
-        ret
-extfsBlockAlloc:    ; also erases
-; in: eax = inode number
+; in: esi -> inode, eax = inode number
 ; out: ebx = block number
         xor     ebx, ebx
         call    extfsResourceAlloc
         jc      @f
         push    ebx ecx edi
         mov     ecx, [ebp+EXTFS.dwordsPerBlock]
         mov     edi, [ebp+EXTFS.tempBlockBuffer]
         mov     ebx, edi
         xor     eax, eax
         rep stosd
-        pop     edi ecx
+        pop     edi ecx eax
-        mov     eax, [esp]
+        push    eax
+        call    extfsWriteBlock
+        pop     ebx
+        jc      @f
+        mov     eax, [ebp+EXTFS.sectorsPerBlock]
-        call    extfsWriteBlock
+        add     [esi+INODE.sectorsUsed], eax
-        pop     ebx
+        xor     eax, eax
 @@:
         ret
         mov     esi, .forward   ; search forward, then backward
 .test_block_group:
         call    extfsReadDescriptor
         jc      .fail
         dec     [eax+BGDESCR.blocksFree+ebx*2]
+        js      .next
-        mov     eax, [eax+BGDESCR.blockBitmap+ebx*4]
+        mov     edx, [eax+BGDESCR.blockBitmap+ebx*4]
+        mov     eax, [esp]
+        call    extfsWriteDescriptor
+        jc      .fail
         push    ebx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        mov     eax, edx
-        mov     edx, eax
+        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         mov     edi, ebx
         call    extfsReadBlock
         pop     ebx
         jc      .fail
         mov     ecx, [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
         sub     edi, 4
         mov     eax, [edi]
         not     eax
         bsf     eax, eax
         bts     [edi], eax
-        sub     edi, [ebp+EXTFS.mainBlockBuffer]
+        sub     edi, [ebp+EXTFS.tempBlockBuffer]
         shl     edi, 3
         add     eax, edi
         mov     ecx, eax
         mov     eax, edx
         push    ebx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         call    extfsWriteBlock
         pop     ebx
         jc      .fail
-        mov     eax, [esp]
+        pop     eax
         mul     [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
         add     eax, ecx
         dec     [ebp+EXTFS.superblock.blocksFree+ebx*4]
         mov     ebx, eax
         pop     eax
-        add     esp, 4
+        xor     eax, eax
-        call    extfsWriteDescriptor
 @@:
         pop     edi esi edx ecx
         ret
         jc      .fail
         mov     eax, [esp]
         jmp     .test_block_group
-extfsGetFileBlock:
-;   in:
+extfsGetFileBlock:
-; ecx = file block number
-; esi -> inode
-;   out:
+; in: esi -> inode, ecx = file block number
-; ecx = block number
+; out: ecx = block number
         test    [esi+INODE.featureFlags], EXTENTS_USED
         jz      .listTreeSearch
         pushad
         add     esi, INODE.blockNumbers
         jc      .ret
         mov     [esi+INODE.tripleAddress], ebx
         mov     eax, ebx
 @@:
         push    eax
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      .fail_alloc_4
         xor     edx, edx
         mov     eax, ecx
         div     [ebp+EXTFS.dwordsPerBranch]
         mov     eax, [esp+4]
         call    inodeBlockAlloc
         jc      .fail_alloc_4
         mov     [ecx], ebx
         mov     eax, [esp]
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsWriteBlock
         jc      .fail_alloc_4
         mov     eax, [ecx]
 @@:
         mov     [esp], eax
         jc      .ret
         mov     [esi+INODE.doubleAddress], ebx
         mov     eax, ebx
 .double_indirect_present:
         push    eax
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      .fail_alloc_4
         mov     eax, ecx
 @@:
         xor     edx, edx
         mov     eax, [esp+8]
         call    inodeBlockAlloc
         jc      .fail_alloc_8
         mov     [ecx], ebx
         mov     eax, [esp+4]
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsWriteBlock
         jc      .fail_alloc_8
 @@:
         mov     eax, [ecx]
         push    eax
         jc      .ret
         mov     [esi+INODE.addressBlock], ebx
         mov     eax, ebx
 @@:
         push    eax
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
         jc      .fail_alloc_4
         mov     [ebx+ecx*4], edi
         pop     eax
         call    extfsWriteBlock
         pop     ebx
 .fail_alloc_4:
         pop     ebx
         jmp     .ret
-extfsEraseFileBlock:    ; also allocates
+extfsFileBlockAlloc:
+;   in:
-;   in:
+; esi -> inode
 ; edx = inode number
 ; eax = file block number
-; [ebp+EXTFS.inodeBuffer] = inode
+;   out:
-        push    ebx ecx edx edi esi
+; edi = allocated block number
-        mov     edi, eax
+        push    ebx ecx
-        mov     ecx, eax
-        lea     esi, [ebp+EXTFS.inodeBuffer]
-        call    extfsGetFileBlock
-        jc      @f
-        test    ecx, ecx
-        jz      .allocate
-        mov     edx, ecx
-        mov     ecx, [ebp+EXTFS.bytesPerBlock]
-        mov     edi, [ebp+EXTFS.tempBlockBuffer]
-        xor     eax, eax
-        rep stosb
+        mov     ecx, eax
-        mov     eax, edx
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
-        call    extfsWriteBlock
-        jmp     @f
-.allocate:
+        mov     eax, edx
-        mov     eax, edx
+        xor     ebx, ebx
-        call    extfsBlockAlloc
+        call    extfsResourceAlloc
-        jc      @f
-        mov     ecx, edi
+        jc      @f
-        mov     edi, ebx
-        lea     esi, [ebp+EXTFS.inodeBuffer]
+        mov     edi, ebx
         call    extfsSetFileBlock
         jc      @f
         mov     eax, [ebp+EXTFS.sectorsPerBlock]
         add     [esi+INODE.sectorsUsed], eax
         xor     eax, eax
-@@:
-        pop     esi edi edx ecx ebx
-        ret
-extfsFreeFileBlock:
-;   in:
-; eax = file block number
-; [ebp+EXTFS.inodeBuffer] = inode
-        push    ebx ecx edx edi esi
-        mov     edi, eax
+@@:
-        mov     ecx, eax
-        lea     esi, [ebp+EXTFS.inodeBuffer]
-        call    extfsGetFileBlock
-        jc      @f
-        test    ecx, ecx
-        jz      @f
-        mov     eax, ecx
-        xor     ecx, ecx
-        call    extfsResourceFree
-        mov     ecx, edi
-        xor     edi, edi
-        movi    edx, ROOT_INODE
-        lea     esi, [ebp+EXTFS.inodeBuffer]
-        call    extfsSetFileBlock
-        mov     eax, [ebp+EXTFS.sectorsPerBlock]
-        sub     [esi+INODE.sectorsUsed], eax
-        xor     eax, eax
-@@:
-        pop     esi edi edx ecx ebx
+        pop     ecx ebx
         ret
 extfsReadFileBlock:
         jmp     .ret
 extfsWriteFileBlock:
 ;   in:
+; eax = file block number
-; eax = file block number
+; ebx -> data
-; [ebp+EXTFS.inodeBuffer] = inode
-; [ebp+EXTFS.mainBlockBuffer] -> block to write
+; [ebp+EXTFS.inodeBuffer] = inode
-        push    ebx ecx edx esi
+        push    ecx edx esi
         mov     ecx, eax
         lea     esi, [ebp+EXTFS.inodeBuffer]
         call    extfsGetFileBlock
         jc      @f
         test    ecx, ecx
         jz      @b
-        mov     eax, ecx
-        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        mov     eax, ecx
         call    extfsWriteBlock
 @@:
-        pop     esi edx ecx ebx
+        pop     esi edx ecx
         ret
-getInodeLocation:
-; in: eax = inode number
-;   out:
+getInodeLocation:
-; ebx = inode sector
+; in: eax = inode number
-; edx = offset in sector
+; out: ebx = inode sector, edx = offset in sector
         dec     eax
         xor     edx, edx
         div     [ebp+EXTFS.superblock.inodesPerGroup]
         xor     eax, eax
 @@:
         ret
-writeInode:
-;   in:
+writeInode:
-; eax = inode number
-; ebx -> inode data
+; in: eax = inode number, ebx -> inode data
         push    edx edi esi ecx ebx eax
         mov     edi, ebx
         call    fsGetTime
         add     eax, 978307200
         movi    eax, ERROR_DEVICE
         stc
         jmp     .ret
-readInode:
-;   in:
-; eax = inode number
+readInode:
-; ebx -> inode buffer
+; in: eax = inode number, ebx -> inode buffer
         push    edx edi esi ecx ebx
         mov     edi, ebx
         call    getInodeLocation
         jc      @f
 ;   in:
 ; [ebp+EXTFS.inodeBuffer] = inode
 ; eax = inode number
 ; ecx = new size
         push    ebx ecx edx esi edi eax
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
+        lea     esi, [ebp+EXTFS.inodeBuffer]
-        cmp     [ebx+INODE.fileSize], ecx
-        jnc     .ret
-        mov     eax, [ebx+INODE.fileSize]
+        mov     eax, [esi+INODE.fileSize]
-        push    eax
         sub     ecx, eax
+        jna     .ret
+        mov     ebx, eax
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
         test    edx, edx
         jz      .start_aligned
-        mov     esi, [ebp+EXTFS.bytesPerBlock]
+        mov     eax, [ebp+EXTFS.bytesPerBlock]
-        sub     esi, edx
+        sub     eax, edx
-        cmp     esi, ecx
+        cmp     eax, ecx
         jbe     @f
-        mov     esi, ecx
+        mov     eax, ecx
-@@: ; clear esi trailing bytes in block number eax
-        push    eax
-        call    extfsReadFileBlock
-        pop     edi
+@@:
-        jc      .error_inode_size
-        push    edi ecx
-        xor     eax, eax
-        mov     ecx, esi
-        mov     edi, ebx
-        add     edi, edx
+        add     ebx, eax
-        rep stosb
-        pop     ecx eax
-        call    extfsWriteFileBlock
-        jc      .error_inode_size
-        add     [esp], esi
-        sub     ecx, esi
+        sub     ecx, eax
         jz      .done
 .start_aligned:
-        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
-        jb      @f
-        mov     eax, [esp]
+        mov     eax, ebx
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
-        mov     edx, [esp+4]
+        mov     edx, [esp]
-        call    extfsEraseFileBlock
+        call    extfsFileBlockAlloc
-        jc      .error_inode_size
+        jc      .error
         mov     eax, [ebp+EXTFS.bytesPerBlock]
+        add     ebx, eax
         sub     ecx, eax
-        add     [esp], eax
-        jmp     .start_aligned
+        ja      .start_aligned
-@@: ; handle the remaining bytes
-        test    ecx, ecx
-        jz      .done
-        mov     eax, [esp]
-        xor     edx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
-        mov     edx, [esp+4]
-        call    extfsEraseFileBlock
-        jc      .error_inode_size
-        add     [esp], ecx
+        add     ebx, ecx
 .done:
         xor     eax, eax
-.error_inode_size:
+.error:
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
-        pop     [ebx+INODE.fileSize]
+        mov     [esi+INODE.fileSize], ebx
 .ret:
         pop     edi edi esi edx ecx ebx
         ret
 extfsTruncateFile:
 ;   in:
 ; [ebp+EXTFS.inodeBuffer] = inode
 ; ecx = new size
         push    ebx ecx edx esi edi
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
-        cmp     ecx, [ebx+INODE.fileSize]
-        jnc     .ret
+        lea     esi, [ebp+EXTFS.inodeBuffer]
-        mov     eax, [ebx+INODE.fileSize]
-        push    eax
+        mov     eax, [esi+INODE.fileSize]
         sub     ecx, eax
-        not     ecx
+        jnc     .ret
+        neg     ecx
-        inc     ecx
+        mov     ebx, eax
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
-        test    edx, edx
-        jz      .start_aligned
-        mov     esi, edx
-        cmp     esi, ecx
+        test    edx, edx
-        jbe     @f
-; if the size to truncate is smaller than the unaligned bytes
-; we're going to clear neccessary bytes from the EOF
-        push    eax
-        call    extfsReadFileBlock
-        pop     edi
-        jc      .error_inode_size
-        push    edi ecx
-        mov     edi, [ebp+EXTFS.mainBlockBuffer]
-        sub     edx, ecx
-        add     edi, edx
-        xor     eax, eax
-        rep stosb
-        pop     ecx eax
-        call    extfsWriteFileBlock
-        jc      .error_inode_size
-        sub     [esp], ecx
-        jmp     .done
-@@:
-        call    extfsFreeFileBlock
-        sub     [esp], esi
-        sub     ecx, esi
-        jz      .done
+        jnz     @f
 .start_aligned:
-        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
-        jb      @f
-        mov     eax, [esp]
-        xor     edx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
+        mov     edx, [ebp+EXTFS.bytesPerBlock]
+        dec     eax
-        dec     eax
+@@:
-        call    extfsFreeFileBlock
+        cmp     ecx, edx
-        mov     eax, [ebp+EXTFS.bytesPerBlock]
+        jc      .tail
-        sub     ecx, eax
+        push    ecx edx
-        sub     [esp], eax
+        mov     edi, eax
-        jmp     .start_aligned
+        mov     ecx, eax
+        call    extfsGetFileBlock
-@@: ; handle the remaining bytes
+        jc      .error
+        test    ecx, ecx
+        jz      @f
+        mov     eax, ecx
+        xor     ecx, ecx
+        call    extfsResourceFree
+        mov     ecx, edi
+        xor     edi, edi
+        movi    edx, ROOT_INODE
+        call    extfsSetFileBlock
+        mov     eax, [ebp+EXTFS.sectorsPerBlock]
+        sub     [esi+INODE.sectorsUsed], eax
+@@:
+        pop     edx ecx
+        sub     ebx, edx
-        test    ecx, ecx
+        sub     ecx, edx
         jz      .done
-        mov     eax, [esp]
+        mov     eax, ebx
         xor     edx, edx
-        div     [ebp+EXTFS.bytesPerBlock]
-        dec     eax
-        push    eax
+        div     [ebp+EXTFS.bytesPerBlock]
-        call    extfsReadFileBlock
+        jmp     .start_aligned
-        pop     edi
-        jc      .error_inode_size
-        push    edi ecx
-        mov     edi, [ebp+EXTFS.mainBlockBuffer]
-        mov     edx, [ebp+EXTFS.bytesPerBlock]
+.tail:      ; handle the remaining bytes
-        sub     edx, ecx
-        add     edi, edx
-        xor     eax, eax
-        rep stosb
-        pop     ecx eax
-        call    extfsWriteFileBlock
-        jc      .error_inode_size
-        sub     [esp], ecx
+        sub     ebx, ecx
 .done:
         xor     eax, eax
-.error_inode_size:
-        lea     ebx, [ebp+EXTFS.inodeBuffer]
+@@:
-        pop     [ebx+INODE.fileSize]
+        mov     [esi+INODE.fileSize], ebx
 .ret:
         pop     edi esi edx ecx ebx
+        ret
+.error:
+        pop     edx ecx
+        jmp     @b
         ret
 linkInode:
 ;   in:
 ; eax = inode on which to link
         jz      .alloc_block
         push    ecx
         jmp     .prepare_block
 .alloc_block:
-        mov     eax, [esp+24]
-        mov     edx, eax
-        call    extfsBlockAlloc
-        jc      .error_get_inode_block
+        mov     eax, [esp]
-        mov     ecx, [esp]
-        mov     edi, ebx
+        mov     edx, [esp+24]
-        call    extfsSetFileBlock
+        call    extfsFileBlockAlloc
         jc      .error_get_inode_block
         mov     eax, [ebp+EXTFS.bytesPerBlock]
-        add     [esi+INODE.fileSize], eax
-        mov     eax, [ebp+EXTFS.sectorsPerBlock]
-        add     [esi+INODE.sectorsUsed], eax
+        add     [esi+INODE.fileSize], eax
         mov     eax, [esp+24]
         mov     ebx, esi
         call    writeInode
         jc      .error_get_inode_block
         push    edi     ; save the block we just allocated
-.prepare_block:
-        mov     eax, [esp]
+.prepare_block:
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
-        call    extfsReadBlock
-        jc      .error_block_read
-        mov     edi, ebx
+        mov     edi, [ebp+EXTFS.tempBlockBuffer]
         mov     eax, [ebp+EXTFS.bytesPerBlock]
         mov     [edi+DIRENTRY.entryLength], ax
 .found:
         pop     edx ecx ecx ecx ebx esi
         push    ebx
-        mov     [edi], ebx  ; save inode
+        mov     [edi+DIRENTRY.inodeNumber], ebx
+        sub     ecx, 8
-        mov     eax, [esp+4]
+        mov     word [edi+DIRENTRY.nameLength], cx
         cmp     [ebp+EXTFS.superblock.dynamicVersionFlag], 0
+        je      .name
-        je      .name
+        mov     eax, [esp+4]
         mov     [edi+DIRENTRY.fileType], al
-.name:
-        sub     ecx, 8
-        mov     [edi+DIRENTRY.nameLength], cl
+.name:
         add     edi, 8
         rep movsb
         mov     eax, edx
         mov     ebx, [ebp+EXTFS.tempBlockBuffer]
         cmp     eax, 1
         je      .success
         mov     eax, [edi+INODE.tripleAddress]
         test    eax, eax
         jz      .success
+        xor     edx, edx
+        mov     ecx, eax
+@@:
-        push    eax
+        mov     eax, ecx
-        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
         call    extfsReadBlock
-        pop     ecx
         jc      .error_stack8_eax
-        mov     eax, ecx
-        xor     ecx, ecx
-        call    extfsResourceFree
-        mov     edx, ebx
-        add     edx, [ebp+EXTFS.bytesPerBlock]
-@@:
-        mov     eax, [ebx]
+        mov     eax, [ebx+edx]
         test    eax, eax
-        jz      .success
+        jz      @f
-        push    ebx edx
+        push    ecx edx
         call    freeDoublyIndirectBlock
-        pop     edx ebx
+        pop     edx ecx
         cmp     eax, 1
-        je      .success
+        je      @f
-        add     ebx, 4
+        add     edx, 4
-        cmp     ebx, edx
+        cmp     edx, [ebp+EXTFS.bytesPerBlock]
         jb      @b
+@@:
+        mov     eax, ecx
+        xor     ecx, ecx
+        call    extfsResourceFree
 .success:   ; clear the inode, and add deletion time
         xor     eax, eax
         movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
         rep stosb
         lea     edi, [ebp+EXTFS.inodeBuffer]
         mov     eax, esi
         call    extfsExtendFile
         jc      .error
         mov     eax, [ebx+4]
         mov     ecx, [ebx+12]
-        mov     esi, [ebx+16]
+        mov     ebx, [ebx+16]
         push    eax
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
         test    edx, edx
         jz      .start_aligned
-        mov     ebx, [ebp+EXTFS.bytesPerBlock]
+        mov     esi, [ebp+EXTFS.bytesPerBlock]
-        sub     ebx, edx
+        sub     esi, edx
-        cmp     ebx, ecx
+        cmp     esi, ecx
         jbe     @f
-        mov     ebx, ecx
+        mov     esi, ecx
 @@:
-        push    eax
+        mov     edi, eax
         call    extfsReadFileBlock
-        pop     edi
         jc      .error_inode_size
         mov     eax, edi
-        push    ecx
+        push    ebx ecx
-        mov     ecx, ebx
+        mov     ecx, esi
+        mov     edi, [ebp+EXTFS.mainBlockBuffer]
-        mov     edi, ebx
+        mov     esi, ebx
+        mov     ebx, edi
         add     edi, edx
+        mov     edx, ecx
         rep movsb
-        pop     ecx
         call    extfsWriteFileBlock
+        pop     ecx ebx
         jc      .error_inode_size
-        add     [esp], ebx
+        add     [esp], edx
+        add     ebx, edx
-        sub     ecx, ebx
+        sub     ecx, edx
         jz      .write_inode
 .start_aligned:
         cmp     ecx, [ebp+EXTFS.bytesPerBlock]
         jb      @f
         mov     eax, [esp]
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
-        mov     edx, [esp+4]
-        push    eax
-        call    extfsEraseFileBlock
-        pop     edi
-        jc      .error_inode_size
-        mov     eax, edi
-        push    ecx
-        mov     ecx, [ebp+EXTFS.bytesPerBlock]
-        mov     edi, [ebp+EXTFS.mainBlockBuffer]
-        rep movsb
-        pop     ecx
         call    extfsWriteFileBlock
         jc      .error_inode_size
         mov     eax, [ebp+EXTFS.bytesPerBlock]
         sub     ecx, eax
+        add     ebx, eax
         add     [esp], eax
         jmp     .start_aligned
-@@:         ; Handle the remaining bytes.
+@@: ; handle the remaining bytes
         test    ecx, ecx
         jz      .write_inode
         mov     eax, [esp]
         xor     edx, edx
         div     [ebp+EXTFS.bytesPerBlock]
-        push    eax
-        call    extfsReadFileBlock
-        pop     eax
-        jnc     @f
-        mov     edx, [esp+4]
-        push    eax
-        call    extfsEraseFileBlock
-        pop     edi
-        jc      .error_inode_size
-        mov     eax, edi
-@@:
         push    ecx
+        mov     esi, ebx
         mov     edi, [ebp+EXTFS.mainBlockBuffer]
+        mov     ebx, edi
         rep movsb
         pop     ecx
         call    extfsWriteFileBlock
         jc      .error_inode_size
-        add     [esp], ecx
         xor     ecx, ecx
 .error_inode_size:
         mov     [esp+12], eax
 .write_inode:
         lea     ebx, [ebp+EXTFS.inodeBuffer]
 ;----------------------------------------------------------------
 ext_SetFileEnd:
         call    extfsWritingInit
         pushd   [ebx+4]
         call    findInode
-        pop     ecx
-        jc      @f
+        jc      .error
-        lea     edx, [ebp+EXTFS.inodeBuffer]
+        lea     edi, [ebp+EXTFS.inodeBuffer]
         movi    eax, ERROR_ACCESS_DENIED
-        cmp     [edx+INODE.accessMode], FLAG_FILE
+        cmp     [edi+INODE.accessMode], FLAG_FILE
-        jnz     @f      ; not a file
+        jnz     .error  ; not a file
+        pop     ecx
+        push    esi
+        mov     ebx, [edi+INODE.fileSize]
         mov     eax, esi
-        call    extfsExtendFile
+        cmp     ebx, ecx
         jc      @f
         call    extfsTruncateFile
+        jc      .error
+        jmp     .done
+@@:
+        call    extfsExtendFile
+        jc      .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
-        jc      @f
+        jbe     @f
+        mov     eax, ecx
+@@:
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        push    edi ecx
+        mov     ecx, eax
+        mov     edi, ebx
+        add     edi, edx
+        xor     eax, eax
+        mov     edx, ecx
+        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
+        inc     eax
+        mov     ebx, [ebp+EXTFS.mainBlockBuffer]
+        push    eax edi
+        mov     edi, ebx
+        xor     eax, eax
+        rep stosb
+        pop     edi ecx
+@@:
-        mov     eax, esi
+        mov     eax, edi
+        call    extfsWriteFileBlock
+        jc      .error
+        inc     edi
+        loop    @b
+.done:
+        mov     eax, [esp]
         lea     ebx, [ebp+EXTFS.inodeBuffer]
         call    writeInode
-@@:
-        push    eax
+        jc      .error
         call    writeSuperblock
         mov     esi, [ebp+PARTITION.Disk]
         call    disk_sync
+        xor     eax, eax
+.error:
+        mov     [esp], eax
         call    ext_unlock
         pop     eax
         ret

Subversion Repositories Kolibri OS

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