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



;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 

$Revision: 6558 $
 
; EXT external functions
;   in:

sectorsPerBlock     dd  ?
dwordsPerBlock      dd  ?
dwordsPerBranch     dd  ?   ; dwordsPerBlock ^ 2
mainBlockBuffer     dd  ?
tempBlockBuffer     dd  ?
align0  rb  200h-EXTFS.align0
superblock          SUPERBLOCK
align1  rb  400h-EXTFS.align1
rootInodeBuffer     INODE
align2  rb  600h-EXTFS.align2
inodeBuffer         INODE
 
align3  rb  800h-EXTFS.align3
ends

 
; mount if it's a valid EXT partition
ext2_create_partition:

        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]

        ret

 
@@:
        stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
.error:
        mov     eax, ebp
        call    free
        pop     edi esi ebp
.fail:
        pop     ebx
        xor     eax, eax

; unmount EXT partition
ext_free:
; in: eax -> EXTFS structure
        push    eax
        stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]
        pop     eax
        jmp     free

 
extfsWriteBlock:
        push    fs_write64_sys
        jmp     @f

.complete:
        inc     eax
        ret

 
inodeBlockAlloc:
; in: esi -> inode, eax = inode number
 
 
; out: ebx = block number
        call    extfsBlockAlloc
        jc      @f
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        add     [esi+INODE.sectorsUsed], eax

        movi    eax, ERROR_FS_FAIL
        stc
        ret

 
 
.get_indirect_block:
        mov     eax, [esi+INODE.addressBlock]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
 
        mov     ecx, [ebx+ecx*4]
        pop     ebx edx

        ret
 

        ret

 
.listTreeSearch:
        cmp     ecx, 12
        jb      .get_direct_block
        push    edx ebx
        sub     ecx, 12
        cmp     ecx, [ebp+EXTFS.dwordsPerBlock]
        jb      .get_indirect_block
        sub     ecx, [ebp+EXTFS.dwordsPerBlock]
        cmp     ecx, [ebp+EXTFS.dwordsPerBranch]
        jb      .get_double_indirect_block
; triply-indirect blocks
 
        sub     ecx, [ebp+EXTFS.dwordsPerBranch]
        mov     eax, [esi+INODE.tripleAddress]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        xor     edx, edx
        mov     eax, ecx
        div     [ebp+EXTFS.dwordsPerBranch]
; eax = number in triply-indirect block, edx = number in branch
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jz      .noBlock
        call    extfsReadBlock
        jc      .fail2
        mov     eax, edx

        jmp     @f
 
.noBlock:
        xor     ecx, ecx
 
 
.fail2:

        pop     ebx edx
 
        ret
 
.get_double_indirect_block:
        mov     eax, [esi+INODE.doubleAddress]
        test    eax, eax
        jz      .noBlock
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .fail2
        mov     eax, ecx
@@:
        xor     edx, edx
        div     [ebp+EXTFS.dwordsPerBlock]
; eax = number in doubly-indirect block, edx = number in indirect block
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jz      .noBlock
 
        call    extfsReadBlock
        jc      .fail2

        mov     ecx, [ebx+edx*4]
        pop     ebx edx
        ret
 
extfsSetFileBlock:
;   in:
; ecx = file block number
; edi = block number
; edx = inode number
; esi -> inode

; triple indirect blocks
        sub     ecx, [ebp+EXTFS.dwordsPerBranch]
        mov     eax, [esi+INODE.tripleAddress]
        test    eax, eax
        jnz     @f
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.tripleAddress], ebx
        mov     eax, ebx
@@:

; eax = number in triply-indirect block, edx = number in branch
        lea     ecx, [ebx+eax*4]
        mov     eax, [ebx+eax*4]
        test    eax, eax
        jnz     @f
        mov     eax, [esp+4]
        call    inodeBlockAlloc
        jc      .fail_alloc_4
        mov     [ecx], ebx
        mov     eax, [esp]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]

 
.double_indirect_block:
        mov     eax, [esi+INODE.doubleAddress]
        test    eax, eax
        jnz     .double_indirect_present
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.doubleAddress], ebx
        mov     eax, ebx

        lea     ecx, [ebx+edx*4]
        push    ecx
        lea     ecx, [ebx+eax*4]
        cmp     dword[ecx], 0
        jne     @f
        mov     eax, [esp+8]
        call    inodeBlockAlloc
        jc      .fail_alloc_8
        mov     [ecx], ebx
        mov     eax, [esp+4]
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]

 
.indirect_block:
        mov     eax, [esi+INODE.addressBlock]
        test    eax, eax
        jnz     @f
        mov     eax, edx
        call    inodeBlockAlloc
        jc      .ret
        mov     [esi+INODE.addressBlock], ebx
        mov     eax, ebx

 
extfsEraseFileBlock:    ; also allocates
;   in:
; edx = inode number
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
        push    ebx ecx edx edi esi
        mov     edi, eax
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      .allocate

        mov     eax, edx
        call    extfsBlockAlloc
        jc      @f
        mov     ecx, edi
        mov     edi, ebx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsSetFileBlock
        jc      @f
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        add     [esi+INODE.sectorsUsed], eax
        xor     eax, eax

        ret

 
extfsFreeFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
        push    ebx ecx edx edi esi
        mov     edi, eax
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      @f
        mov     eax, ecx
        xor     ecx, ecx
        call    extfsResourceFree
        mov     ecx, edi
        xor     edi, edi
        movi    edx, ROOT_INODE
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsSetFileBlock
        mov     eax, [ebp+EXTFS.sectorsPerBlock]
        sub     [esi+INODE.sectorsUsed], eax
        xor     eax, eax
@@:
        pop     esi edi edx ecx ebx

        ret
 
extfsReadFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
;   out:
; [ebp+EXTFS.mainBlockBuffer] -> block
        push    ebx ecx edx esi
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      .ret
        test    ecx, ecx

        jmp     .ret

 
extfsWriteFileBlock:
;   in:
; eax = file block number
; [ebp+EXTFS.inodeBuffer] = inode
; [ebp+EXTFS.mainBlockBuffer] -> block to write
        push    ebx ecx edx esi
        mov     ecx, eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
        call    extfsGetFileBlock
        jc      @f
        test    ecx, ecx
        jz      @b

        pop     ebx ecx esi edi edx
        ret

 
extfsExtendFile:
;   in:
; [ebp+EXTFS.inodeBuffer] = inode
; eax = inode number
; ecx = new size
        push    ebx ecx edx esi edi eax
 
 
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        cmp     [ebx+INODE.fileSize], ecx
        jnc     .ret
        mov     eax, [ebx+INODE.fileSize]
        push    eax

        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        add     [esp], esi
        sub     ecx, esi
        jz      .done
.start_aligned:
        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
        jb      @f
        mov     eax, [esp]
        xor     edx, edx

        add     [esp], eax
        jmp     .start_aligned

 
@@: ; handle the remaining bytes
        test    ecx, ecx
        jz      .done
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        mov     edx, [esp+4]
        call    extfsEraseFileBlock
        jc      .error_inode_size
        add     [esp], ecx
.done:
        xor     eax, eax
.error_inode_size:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
 
 
 
 
 
 
 
        pop     [ebx+INODE.fileSize]
.ret:
        pop     edi edi esi edx ecx ebx

        ret
 
extfsTruncateFile:
;   in:
; [ebp+EXTFS.inodeBuffer] = inode
; ecx = new size
 
 
        push    ebx ecx edx esi edi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        cmp     ecx, [ebx+INODE.fileSize]
        jnc     .ret
        mov     eax, [ebx+INODE.fileSize]

        rep stosb
        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        sub     [esp], ecx
        jmp     .done

 
@@:
        call    extfsFreeFileBlock
        sub     [esp], esi
        sub     ecx, esi
        jz      .done
.start_aligned:
        cmp     ecx, [ebp+EXTFS.bytesPerBlock]
        jb      @f
        mov     eax, [esp]

        sub     [esp], eax
        jmp     .start_aligned

 
@@: ; handle the remaining bytes
        test    ecx, ecx
        jz      .done
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp+EXTFS.bytesPerBlock]
        dec     eax

        rep stosb
        pop     ecx eax
        call    extfsWriteFileBlock
        jc      .error_inode_size
        sub     [esp], ecx
.done:
        xor     eax, eax
.error_inode_size:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     [ebx+INODE.fileSize]
 
 
 
 
 
 
 
.ret:
        pop     edi esi edx ecx ebx
        ret

 
linkInode:
;   in:

        push    esi edi ebx ecx eax edx
        call    strlen
        add     ecx, 8  ; directory entry size
        push    esi ebx ecx
        xor     ecx, ecx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ebx, esi
        call    readInode
        jc      .error_inode_read
        mov     ecx, [ebp+EXTFS.sectorsPerBlockLog]
        mov     eax, [esi+INODE.sectorsUsed]
        shr     eax, cl
        xor     ecx, ecx
 
 
.searchBlock:
        push    eax     ; blocks total
        push    ecx     ; current file block number
        cmp     eax, ecx
        jz      .alloc_block
        call    extfsGetFileBlock
        jc      .error_get_inode_block
        test    ecx, ecx
        jz      .alloc_block
        push    ecx
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsReadBlock
        jc      .error_block_read
        mov     ecx, [esp+12]
        mov     edi, [ebp+EXTFS.tempBlockBuffer]
        mov     edx, edi
        add     edx, [ebp+EXTFS.bytesPerBlock]
.searchSpace:
        movzx   eax, [edi+DIRENTRY.entryLength]

        jge     .found
.nextEntry:
        add     edi, eax
        cmp     edi, edx
        jb      .searchSpace
        pop     ecx ecx eax
        inc     ecx
        jmp     .searchBlock

 
.zeroLength:
        mov     [edi+DIRENTRY.entryLength], cx
        mov     eax, edx

        test    ecx, ecx
        jz      .alloc_block
        push    ecx
        jmp     .prepare_block

 
 
 
 
 
 
 
.alloc_block:
        mov     eax, [esp+24]
        mov     edx, eax
        call    extfsBlockAlloc
        jc      .error_get_inode_block
        mov     ecx, [esp]
        mov     edi, ebx

        mov     eax, edx
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .error_block_write
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .error_block_write
        pop     eax
        inc     [ebx+INODE.linksCount]
        call    writeInode

; eax = inode from which to unlink
; ebx = inode to unlink
;   out:
; eax = current number of links to inode, -1 = error
        push    edx ebx
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .fail
        push    eax
        lea     esi, [ebp+EXTFS.inodeBuffer]
.loop:
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .fail_loop
        test    ecx, ecx

        mov     eax, edi
        mov     ebx, [ebp+EXTFS.tempBlockBuffer]
        call    extfsWriteBlock
        jc      .fail
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .fail
        dec     word [ebx+INODE.linksCount]
        mov     eax, [esp]
        call    writeInode

findInode:
; in: esi -> path string in UTF-8
;   out:
; edi -> file name in UTF-8
; esi = last inode number
; [ebp+EXTFS.inodeBuffer] = last inode
; ecx = parent inode number
; CF=1 -> file not found, edi=0 -> error
        push    esi
        lea     esi, [ebp+EXTFS.rootInodeBuffer]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        mov     edx, esi
        rep movsb
        pop     esi
        pushd   0 ROOT_INODE
        mov     edi, esi
        cmp     [edx+INODE.sectorsUsed], 0
        jz      .not_found
        cmp     byte [esi], 0
        jnz     .next_path_part
        xor     eax, eax
 
        pop     esi ecx
        ret

 
@@:

 
@@:
        pop     eax
        mov     [esp], eax
        mov     eax, [ebx+DIRENTRY.inodeNumber]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        push    eax
        call    readInode
        jc      .error
        cmp     byte [esi], 0

        movzx   eax, [ebx+INODE.accessMode]
        and     eax, TYPE_MASK
        cmp     eax, DIRECTORY
        jz      .next_path_part
        xor     edi, edi    ; path folder is a file
        jmp     @f
 
.not_found:
        mov     esi, edi
        call    strlen
        mov     al, '/'
        repnz scasb
        mov     edi, esi
        jnz     @f
        xor     edi, edi    ; path folder not found
@@:
        movi    eax, ERROR_FILE_NOT_FOUND
        stc
.ret:
        pop     esi ecx
        ret

        jz      .root_folder
        push    ebx
        call    findInode
        pop     ebx
        jc      .error_ret
        lea     esi, [ebp+EXTFS.inodeBuffer]
        test    [esi+INODE.accessMode], FLAG_FILE
        jnz     .error_not_found
        jmp     @f

 
.root_folder:
        lea     esi, [ebp+EXTFS.rootInodeBuffer]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        shr     ecx, 2
        push    edi
        rep movsd

        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]

        mov     [esp], ebx
        call    findInode
        pop     ebx
        jc      .error_eax
        push    ERROR_ACCESS_DENIED
        lea     esi, [ebp+EXTFS.inodeBuffer]
        mov     ax, [esi+INODE.accessMode]
        and     ax, TYPE_MASK
        cmp     ax, FLAG_FILE
        jnz     .error  ; not a file
        pop     eax

        cmp     byte [esi], 0
        jz      .is_root
        push    edx
        call    findInode
        pop     edx
        lea     esi, [ebp+EXTFS.inodeBuffer]
        jnc     @f
        push    eax
        call    ext_unlock
        pop     eax
        ret

        call    findInode
        pop     edx
        jc      @f
        push    esi     ; inode number
        lea     esi, [edx+16]
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsCalculateTime
        add     eax, 978307200  ; 01.01.1970-01.01.2001 = (365*31+8)*24*60*60
        mov     [edi+INODE.accessedTime], eax

 

        call    findInode
        mov     ebx, esi
        push    eax
        jc      .ret
        pop     eax
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movzx   edx, [edx+INODE.accessMode]
        and     edx, TYPE_MASK
        cmp     edx, DIRECTORY
        jne     .file
        push    ebx ecx edx 0
        lea     esi, [ebp+EXTFS.inodeBuffer]
.checkDirectory:
        mov     ecx, [esp]
        call    extfsGetFileBlock
        jc      .not_empty_eax
        test    ecx, ecx

        jnz     .error_stack4_eax   ; hardlinks
        mov     eax, [esp]
        call    unlinkInode
@@:
        mov     eax, [esp]
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    readInode
        jc      .error_stack4_eax
; free file's data
        lea     esi, [ebp+EXTFS.inodeBuffer]
        xor     ecx, ecx
@@:
        push    ecx
        call    extfsGetFileBlock
        jc      .error_stack8_eax

        jmp     @b

 
@@: ; free indirect blocks
        pop     ecx
        push    edx
        lea     edi, [ebp+EXTFS.inodeBuffer]
        mov     eax, [edi+INODE.addressBlock]
        test    eax, eax
        jz      .success
        xor     ecx, ecx

        jb      @b
.success:   ; clear the inode, and add deletion time
        xor     eax, eax
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        pop     edx
        add     eax, 978307200
        mov     [edi+INODE.deletedTime], eax
        mov     eax, [esp]

        call    extfsResourceAlloc
        jc      .error
        inc     ebx
        push    ebx esi edi
        xor     al, al
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        add     eax, 978307200
        mov     [edi+INODE.accessedTime], eax
        mov     [edi+INODE.dataModified], eax
        mov     ebx, edi

        call    extfsResourceAlloc
        jc      .error
        inc     ebx
        push    ebx ebx esi edi
        xor     al, al
        lea     edi, [ebp+EXTFS.inodeBuffer]
        movzx   ecx, [ebp+EXTFS.superblock.inodeSize]
        rep stosb
        lea     edi, [ebp+EXTFS.inodeBuffer]
        call    fsGetTime
        add     eax, 978307200
        mov     [edi+INODE.accessedTime], eax
        mov     [edi+INODE.dataModified], eax
        mov     ebx, edi

        push    ebx esi
        mov     ecx, [ebx+12]
        jmp     ext_WriteFile.start

 
.exist:
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        test    [edx+INODE.accessMode], FLAG_FILE
        jz      .error  ; not a file
        pop     ebx
 
        push    ebx esi
        mov     ecx, [ebx+12]
        call    extfsTruncateFile
        jnc     ext_WriteFile.start
.error2:

        push    0 ebx
        call    findInode
        pop     ebx
        push    ebx esi
        jc      .error
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        test    [edx+INODE.accessMode], FLAG_FILE
        jz      .error  ; not a file
        mov     ecx, [ebx+4]
        add     ecx, [ebx+12]

        add     [esp], ecx
        xor     ecx, ecx
.error_inode_size:
        mov     [esp+12], eax
.write_inode:
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        pop     eax eax
        call    writeInode
        pop     ebx
        mov     ebx, [ebx+12]
        sub     ebx, ecx

        call    extfsWritingInit
        pushd   [ebx+4]
        call    findInode
        pop     ecx
        jc      @f
        lea     edx, [ebp+EXTFS.inodeBuffer]
        movi    eax, ERROR_ACCESS_DENIED
        cmp     [edx+INODE.accessMode], FLAG_FILE
        jnz     @f      ; not a file
        mov     eax, esi
        call    extfsExtendFile
        jc      @f
 
        call    extfsTruncateFile
        jc      @f
        mov     eax, esi
        lea     ebx, [ebp+EXTFS.inodeBuffer]
        call    writeInode
@@:
        push    eax
        call    writeSuperblock
        mov     esi, [ebp+PARTITION.Disk]

Rev 6522	Rev 6558
Line 3...	Line 3...
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	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 7...	Line 7...
7		7
Line 8...	Line 8...
8	$Revision: 6522 $	8	$Revision: 6558 $
9		9
10	; EXT external functions	10	; EXT external functions
11	; in:	11	; in:
Line 162...	Line 162...
162	sectorsPerBlock dd ?	162	sectorsPerBlock dd ?
163	dwordsPerBlock dd ?	163	dwordsPerBlock dd ?
164	dwordsPerBranch dd ? ; dwordsPerBlock ^ 2	164	dwordsPerBranch dd ? ; dwordsPerBlock ^ 2
165	mainBlockBuffer dd ?	165	mainBlockBuffer dd ?
166	tempBlockBuffer dd ?	166	tempBlockBuffer dd ?
167	align 512	167	align0 rb 200h-EXTFS.align0
168	superblock SUPERBLOCK	168	superblock SUPERBLOCK
169	align 1024	169	align1 rb 400h-EXTFS.align1
170	rootInodeBuffer INODE	170	rootInodeBuffer INODE
171	align 1024	171	align2 rb 600h-EXTFS.align2
172	mainInodeBuffer INODE	172	inodeBuffer INODE
173	align 1024	-
174	tempInodeBuffer INODE	173	align3 rb 800h-EXTFS.align3
175	ends	174	ends
Line 176...	Line 175...
176		175
177	; mount if it's a valid EXT partition	176	; mount if it's a valid EXT partition
178	ext2_create_partition:	177	ext2_create_partition:
Line 202...	Line 201...
202	ja .fail	201	ja .fail
203	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0	202	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0
204	je .fail	203	je .fail
205	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0	204	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0
206	je .fail	205	je .fail
-		206	movi eax, sizeof.EXTFS
207	stdcall kernel_alloc, 1000h	207	call malloc
208	test eax, eax	208	test eax, eax
209	jz .fail	209	jz .fail
210	mov ecx, dword [ebp+PARTITION.FirstSector]	210	mov ecx, dword [ebp+PARTITION.FirstSector]
211	mov dword [eax+EXTFS.FirstSector], ecx	211	mov dword [eax+EXTFS.FirstSector], ecx
212	mov ecx, dword [ebp+PARTITION.FirstSector+4]	212	mov ecx, dword [ebp+PARTITION.FirstSector+4]
Line 265...	Line 265...
265	ret	265	ret
Line 266...	Line 266...
266		266
267	@@:	267	@@:
268	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]	268	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
-		269	.error:
269	.error:	270	mov eax, ebp
270	stdcall kernel_free, ebp	271	call free
271	pop edi esi ebp	272	pop edi esi ebp
272	.fail:	273	.fail:
273	pop ebx	274	pop ebx
274	xor eax, eax	275	xor eax, eax
Line 277...	Line 278...
277	; unmount EXT partition	278	; unmount EXT partition
278	ext_free:	279	ext_free:
279	; in: eax -> EXTFS structure	280	; in: eax -> EXTFS structure
280	push eax	281	push eax
281	stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]	282	stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]
282	call kernel_free	283	pop eax
283	ret	284	jmp free
Line 284...	Line 285...
284		285
285	extfsWriteBlock:	286	extfsWriteBlock:
286	push fs_write64_sys	287	push fs_write64_sys
287	jmp @f	288	jmp @f
Line 416...	Line 417...
416	.complete:	417	.complete:
417	inc eax	418	inc eax
418	ret	419	ret
Line 419...	Line 420...
419		420
420	inodeBlockAlloc:	421	inodeBlockAlloc:
421	; in: esi -> inode	422	; in: esi -> inode, eax = inode number
422	; out: ebx = block number	-
423	; TODO: fix to have correct preference.	-
424	mov eax, ROOT_INODE	423	; out: ebx = block number
425	call extfsBlockAlloc	424	call extfsBlockAlloc
426	jc @f	425	jc @f
427	mov eax, [ebp+EXTFS.sectorsPerBlock]	426	mov eax, [ebp+EXTFS.sectorsPerBlock]
428	add [esi+INODE.sectorsUsed], eax	427	add [esi+INODE.sectorsUsed], eax
Line 601...	Line 600...
601	movi eax, ERROR_FS_FAIL	600	movi eax, ERROR_FS_FAIL
602	stc	601	stc
603	ret	602	ret
Line 604...	Line 603...
604		603
605	.get_indirect_block:	-
606	push edx ebx	604	.get_indirect_block:
607	mov eax, [esi+INODE.addressBlock]	605	mov eax, [esi+INODE.addressBlock]
608	test eax, eax	606	test eax, eax
609	jz .fail3	607	jz .noBlock
610	mov ebx, [ebp+EXTFS.tempBlockBuffer]	608	mov ebx, [ebp+EXTFS.tempBlockBuffer]
611	call extfsReadBlock	609	call extfsReadBlock
612	jc @f	610	jc .fail2
613	mov ecx, [ebx+ecx*4]	-
614	@@:	611	mov ecx, [ebx+ecx*4]
615	pop ebx edx	612	pop ebx edx
Line 616...	Line 613...
616	ret	613	ret
617		614
Line 621...	Line 618...
621	ret	618	ret
Line 622...	Line 619...
622		619
623	.listTreeSearch:	620	.listTreeSearch:
624	cmp ecx, 12	621	cmp ecx, 12
-		622	jb .get_direct_block
625	jb .get_direct_block	623	push edx ebx
626	sub ecx, 12	624	sub ecx, 12
627	cmp ecx, [ebp+EXTFS.dwordsPerBlock]	625	cmp ecx, [ebp+EXTFS.dwordsPerBlock]
628	jb .get_indirect_block	626	jb .get_indirect_block
629	sub ecx, [ebp+EXTFS.dwordsPerBlock]	627	sub ecx, [ebp+EXTFS.dwordsPerBlock]
630	cmp ecx, [ebp+EXTFS.dwordsPerBranch]	628	cmp ecx, [ebp+EXTFS.dwordsPerBranch]
631	jb .get_double_indirect_block	629	jb .get_double_indirect_block
632	; triply-indirect blocks	630	; triply-indirect blocks
633	sub ecx, [ebp+EXTFS.dwordsPerBranch]	-
634	push edx ebx	631	sub ecx, [ebp+EXTFS.dwordsPerBranch]
-		632	mov eax, [esi+INODE.tripleAddress]
-		633	test eax, eax
635	mov eax, [esi+INODE.tripleAddress]	634	jz .noBlock
636	mov ebx, [ebp+EXTFS.tempBlockBuffer]	635	mov ebx, [ebp+EXTFS.tempBlockBuffer]
637	call extfsReadBlock	636	call extfsReadBlock
638	jc .fail2	637	jc .fail2
639	xor edx, edx	638	xor edx, edx
640	mov eax, ecx	639	mov eax, ecx
641	div [ebp+EXTFS.dwordsPerBranch]	640	div [ebp+EXTFS.dwordsPerBranch]
642	; eax = number in triply-indirect block, edx = number in branch	641	; eax = number in triply-indirect block, edx = number in branch
643	mov eax, [ebx+eax*4]	642	mov eax, [ebx+eax*4]
644	test eax, eax	643	test eax, eax
645	jz .fail3	644	jz .noBlock
646	call extfsReadBlock	645	call extfsReadBlock
647	jc .fail2	646	jc .fail2
648	mov eax, edx	647	mov eax, edx
Line -...	Line 648...
-		648	jmp @f
-		649
649	jmp @f	650	.noBlock:
650		651	xor ecx, ecx
651	.fail3:	-
652	pop ebx edx	-
653	movi eax, ERROR_FS_FAIL	652	.fail2:
Line 654...	Line 653...
654	stc	653	pop ebx edx
655	ret	-
656		654	ret
657	.get_double_indirect_block:	655
658	push edx ebx	656	.get_double_indirect_block:
659	mov eax, [esi+INODE.doubleAddress]	657	mov eax, [esi+INODE.doubleAddress]
660	test eax, eax	658	test eax, eax
661	jz .fail3	659	jz .noBlock
662	mov ebx, [ebp+EXTFS.tempBlockBuffer]	660	mov ebx, [ebp+EXTFS.tempBlockBuffer]
663	call extfsReadBlock	661	call extfsReadBlock
664	jc .fail2	662	jc .fail2
665	mov eax, ecx	663	mov eax, ecx
666	@@:	664	@@:
667	xor edx, edx	665	xor edx, edx
668	div [ebp+EXTFS.dwordsPerBlock]	666	div [ebp+EXTFS.dwordsPerBlock]
669	; eax = number in doubly-indirect block, edx = number in indirect block	667	; eax = number in doubly-indirect block, edx = number in indirect block
670	mov eax, [ebx+eax*4]	668	mov eax, [ebx+eax*4]
671	test eax, eax	669	test eax, eax
672	jz .fail3	670	jz .noBlock
673	call extfsReadBlock	-
674	jc .fail2	671	call extfsReadBlock
675	mov ecx, [ebx+edx*4]	672	jc .fail2
Line 676...	Line 673...
676	.fail2:	673	mov ecx, [ebx+edx*4]
677	pop ebx edx	674	pop ebx edx
678	ret	675	ret
679		676
-		677	extfsSetFileBlock:
680	extfsSetFileBlock:	678	; in:
681	; in:	679	; ecx = file block number
682	; ecx = file block number	680	; edi = block number
683	; edi = block number	681	; edx = inode number
684	; esi -> inode	682	; esi -> inode
Line 694...	Line 692...
694	; triple indirect blocks	692	; triple indirect blocks
695	sub ecx, [ebp+EXTFS.dwordsPerBranch]	693	sub ecx, [ebp+EXTFS.dwordsPerBranch]
696	mov eax, [esi+INODE.tripleAddress]	694	mov eax, [esi+INODE.tripleAddress]
697	test eax, eax	695	test eax, eax
698	jnz @f	696	jnz @f
-		697	mov eax, edx
699	call inodeBlockAlloc	698	call inodeBlockAlloc
700	jc .ret	699	jc .ret
701	mov [esi+INODE.tripleAddress], ebx	700	mov [esi+INODE.tripleAddress], ebx
702	mov eax, ebx	701	mov eax, ebx
703	@@:	702	@@:
Line 711...	Line 710...
711	; eax = number in triply-indirect block, edx = number in branch	710	; eax = number in triply-indirect block, edx = number in branch
712	lea ecx, [ebx+eax*4]	711	lea ecx, [ebx+eax*4]
713	mov eax, [ebx+eax*4]	712	mov eax, [ebx+eax*4]
714	test eax, eax	713	test eax, eax
715	jnz @f	714	jnz @f
-		715	mov eax, [esp+4]
716	call inodeBlockAlloc	716	call inodeBlockAlloc
717	jc .fail_alloc_4	717	jc .fail_alloc_4
718	mov [ecx], ebx	718	mov [ecx], ebx
719	mov eax, [esp]	719	mov eax, [esp]
720	mov ebx, [ebp+EXTFS.tempBlockBuffer]	720	mov ebx, [ebp+EXTFS.tempBlockBuffer]
Line 730...	Line 730...
730		730
731	.double_indirect_block:	731	.double_indirect_block:
732	mov eax, [esi+INODE.doubleAddress]	732	mov eax, [esi+INODE.doubleAddress]
733	test eax, eax	733	test eax, eax
-		734	jnz .double_indirect_present
734	jnz .double_indirect_present	735	mov eax, edx
735	call inodeBlockAlloc	736	call inodeBlockAlloc
736	jc .ret	737	jc .ret
737	mov [esi+INODE.doubleAddress], ebx	738	mov [esi+INODE.doubleAddress], ebx
738	mov eax, ebx	739	mov eax, ebx
Line 749...	Line 750...
749	lea ecx, [ebx+edx*4]	750	lea ecx, [ebx+edx*4]
750	push ecx	751	push ecx
751	lea ecx, [ebx+eax*4]	752	lea ecx, [ebx+eax*4]
752	cmp dword[ecx], 0	753	cmp dword[ecx], 0
753	jne @f	754	jne @f
-		755	mov eax, [esp+8]
754	call inodeBlockAlloc	756	call inodeBlockAlloc
755	jc .fail_alloc_8	757	jc .fail_alloc_8
756	mov [ecx], ebx	758	mov [ecx], ebx
757	mov eax, [esp+4]	759	mov eax, [esp+4]
758	mov ebx, [ebp+EXTFS.tempBlockBuffer]	760	mov ebx, [ebp+EXTFS.tempBlockBuffer]
Line 770...	Line 772...
770		772
771	.indirect_block:	773	.indirect_block:
772	mov eax, [esi+INODE.addressBlock]	774	mov eax, [esi+INODE.addressBlock]
773	test eax, eax	775	test eax, eax
-		776	jnz @f
774	jnz @f	777	mov eax, edx
775	call inodeBlockAlloc	778	call inodeBlockAlloc
776	jc .ret	779	jc .ret
777	mov [esi+INODE.addressBlock], ebx	780	mov [esi+INODE.addressBlock], ebx
778	mov eax, ebx	781	mov eax, ebx
Line 803...	Line 806...
803		806
804	extfsEraseFileBlock: ; also allocates	807	extfsEraseFileBlock: ; also allocates
805	; in:	808	; in:
806	; edx = inode number	809	; edx = inode number
807	; eax = file block number	810	; eax = file block number
808	; [ebp+EXTFS.tempInodeBuffer] = inode	811	; [ebp+EXTFS.inodeBuffer] = inode
809	push ebx ecx edx edi esi	812	push ebx ecx edx edi esi
810	mov edi, eax	813	mov edi, eax
811	mov ecx, eax	814	mov ecx, eax
812	lea esi, [ebp+EXTFS.tempInodeBuffer]	815	lea esi, [ebp+EXTFS.inodeBuffer]
813	call extfsGetFileBlock	816	call extfsGetFileBlock
814	jc @f	817	jc @f
815	test ecx, ecx	818	test ecx, ecx
816	jz .allocate	819	jz .allocate
Line 828...	Line 831...
828	mov eax, edx	831	mov eax, edx
829	call extfsBlockAlloc	832	call extfsBlockAlloc
830	jc @f	833	jc @f
831	mov ecx, edi	834	mov ecx, edi
832	mov edi, ebx	835	mov edi, ebx
833	lea esi, [ebp+EXTFS.tempInodeBuffer]	836	lea esi, [ebp+EXTFS.inodeBuffer]
834	call extfsSetFileBlock	837	call extfsSetFileBlock
835	jc @f	838	jc @f
836	mov eax, [ebp+EXTFS.sectorsPerBlock]	839	mov eax, [ebp+EXTFS.sectorsPerBlock]
837	add [esi+INODE.sectorsUsed], eax	840	add [esi+INODE.sectorsUsed], eax
838	xor eax, eax	841	xor eax, eax
Line 841...	Line 844...
841	ret	844	ret
Line 842...	Line 845...
842		845
843	extfsFreeFileBlock:	846	extfsFreeFileBlock:
844	; in:	847	; in:
845	; eax = file block number	848	; eax = file block number
846	; [ebp+EXTFS.tempInodeBuffer] = inode	849	; [ebp+EXTFS.inodeBuffer] = inode
847	push ebx ecx edi esi	850	push ebx ecx edx edi esi
848	mov edi, eax	851	mov edi, eax
849	mov ecx, eax	852	mov ecx, eax
850	lea esi, [ebp+EXTFS.tempInodeBuffer]	853	lea esi, [ebp+EXTFS.inodeBuffer]
851	call extfsGetFileBlock	854	call extfsGetFileBlock
852	jc @f	855	jc @f
853	test ecx, ecx	856	test ecx, ecx
854	jz @f	857	jz @f
855	mov eax, ecx	858	mov eax, ecx
856	xor ecx, ecx	859	xor ecx, ecx
857	call extfsResourceFree	860	call extfsResourceFree
858	mov ecx, edi	861	mov ecx, edi
-		862	xor edi, edi
859	xor edi, edi	863	movi edx, ROOT_INODE
860	lea esi, [ebp+EXTFS.tempInodeBuffer]	864	lea esi, [ebp+EXTFS.inodeBuffer]
861	call extfsSetFileBlock	865	call extfsSetFileBlock
862	mov eax, [ebp+EXTFS.sectorsPerBlock]	866	mov eax, [ebp+EXTFS.sectorsPerBlock]
863	sub [esi+INODE.sectorsUsed], eax	867	sub [esi+INODE.sectorsUsed], eax
864	xor eax, eax	868	xor eax, eax
865	@@:	869	@@:
866	pop esi edi ecx ebx	870	pop esi edi edx ecx ebx
Line 867...	Line 871...
867	ret	871	ret
868		872
869	extfsReadFileBlock:	873	extfsReadFileBlock:
870	; in:	874	; in:
871	; eax = file block number	875	; eax = file block number
872	; [ebp+EXTFS.tempInodeBuffer] = inode	876	; [ebp+EXTFS.inodeBuffer] = inode
873	; out:	877	; out:
874	; [ebp+EXTFS.mainBlockBuffer] -> block	878	; [ebp+EXTFS.mainBlockBuffer] -> block
875	push ebx ecx edx esi	879	push ebx ecx edx esi
876	mov ecx, eax	880	mov ecx, eax
877	lea esi, [ebp+EXTFS.tempInodeBuffer]	881	lea esi, [ebp+EXTFS.inodeBuffer]
878	call extfsGetFileBlock	882	call extfsGetFileBlock
879	jc .ret	883	jc .ret
880	test ecx, ecx	884	test ecx, ecx
Line 892...	Line 896...
892	jmp .ret	896	jmp .ret
Line 893...	Line 897...
893		897
894	extfsWriteFileBlock:	898	extfsWriteFileBlock:
895	; in:	899	; in:
896	; eax = file block number	900	; eax = file block number
897	; [ebp+EXTFS.tempInodeBuffer] = inode	901	; [ebp+EXTFS.inodeBuffer] = inode
898	; [ebp+EXTFS.mainBlockBuffer] -> block to write	902	; [ebp+EXTFS.mainBlockBuffer] -> block to write
899	push ebx ecx edx esi	903	push ebx ecx edx esi
900	mov ecx, eax	904	mov ecx, eax
901	lea esi, [ebp+EXTFS.tempInodeBuffer]	905	lea esi, [ebp+EXTFS.inodeBuffer]
902	call extfsGetFileBlock	906	call extfsGetFileBlock
903	jc @f	907	jc @f
904	test ecx, ecx	908	test ecx, ecx
905	jz @b	909	jz @b
Line 997...	Line 1001...
997	pop ebx ecx esi edi edx	1001	pop ebx ecx esi edi edx
998	ret	1002	ret
Line 999...	Line 1003...
999		1003
1000	extfsExtendFile:	1004	extfsExtendFile:
-		1005	; in:
1001	; in:	1006	; [ebp+EXTFS.inodeBuffer] = inode
1002	; eax = inode number	1007	; eax = inode number
1003	; ecx = new size	1008	; ecx = new size
1004	push ebx ecx edx esi edi eax	1009	push ebx ecx edx esi edi eax
1005	lea ebx, [ebp+EXTFS.tempInodeBuffer]	-
1006	call readInode	-
1007	jc .ret	1010	lea ebx, [ebp+EXTFS.inodeBuffer]
1008	cmp [ebx+INODE.fileSize], ecx	1011	cmp [ebx+INODE.fileSize], ecx
1009	jnc .ret	1012	jnc .ret
1010	mov eax, [ebx+INODE.fileSize]	1013	mov eax, [ebx+INODE.fileSize]
1011	push eax	1014	push eax
Line 1033...	Line 1036...
1033	pop ecx eax	1036	pop ecx eax
1034	call extfsWriteFileBlock	1037	call extfsWriteFileBlock
1035	jc .error_inode_size	1038	jc .error_inode_size
1036	add [esp], esi	1039	add [esp], esi
1037	sub ecx, esi	1040	sub ecx, esi
1038	jz .write_inode	1041	jz .done
1039	.start_aligned:	1042	.start_aligned:
1040	cmp ecx, [ebp+EXTFS.bytesPerBlock]	1043	cmp ecx, [ebp+EXTFS.bytesPerBlock]
1041	jb @f	1044	jb @f
1042	mov eax, [esp]	1045	mov eax, [esp]
1043	xor edx, edx	1046	xor edx, edx
Line 1050...	Line 1053...
1050	add [esp], eax	1053	add [esp], eax
1051	jmp .start_aligned	1054	jmp .start_aligned
Line 1052...	Line 1055...
1052		1055
1053	@@: ; handle the remaining bytes	1056	@@: ; handle the remaining bytes
1054	test ecx, ecx	1057	test ecx, ecx
1055	jz .write_inode	1058	jz .done
1056	mov eax, [esp]	1059	mov eax, [esp]
1057	xor edx, edx	1060	xor edx, edx
1058	div [ebp+EXTFS.bytesPerBlock]	1061	div [ebp+EXTFS.bytesPerBlock]
1059	mov edx, [esp+4]	1062	mov edx, [esp+4]
1060	call extfsEraseFileBlock	1063	call extfsEraseFileBlock
1061	jc .error_inode_size	1064	jc .error_inode_size
1062	add [esp], ecx	1065	add [esp], ecx
1063	.write_inode:	1066	.done:
1064	xor eax, eax	1067	xor eax, eax
1065	.error_inode_size:	1068	.error_inode_size:
1066	lea ebx, [ebp+EXTFS.tempInodeBuffer]	1069	lea ebx, [ebp+EXTFS.inodeBuffer]
1067	pop [ebx+INODE.fileSize]	-
1068	push eax	-
1069	mov eax, [esp+4]	-
1070	call writeInode	-
1071	pop ebx	-
1072	jc .ret	-
1073	xchg eax, ebx	-
1074	cmp ebx, eax ; set CF	1070	pop [ebx+INODE.fileSize]
1075	.ret:	1071	.ret:
1076	pop edi edi esi edx ecx ebx	1072	pop edi edi esi edx ecx ebx
Line 1077...	Line 1073...
1077	ret	1073	ret
1078		1074
1079	extfsTruncateFile:	1075	extfsTruncateFile:
1080	; in:	1076	; in:
1081	; eax = inode number	1077	; [ebp+EXTFS.inodeBuffer] = inode
1082	; ecx = new size	1078	; ecx = new size
1083	push ebx ecx edx esi edi eax	-
1084	lea ebx, [ebp+EXTFS.tempInodeBuffer]	-
1085	call readInode	1079	push ebx ecx edx esi edi
1086	jc .ret	1080	lea ebx, [ebp+EXTFS.inodeBuffer]
1087	cmp ecx, [ebx+INODE.fileSize]	1081	cmp ecx, [ebx+INODE.fileSize]
1088	jnc .ret	1082	jnc .ret
1089	mov eax, [ebx+INODE.fileSize]	1083	mov eax, [ebx+INODE.fileSize]
Line 1112...	Line 1106...
1112	rep stosb	1106	rep stosb
1113	pop ecx eax	1107	pop ecx eax
1114	call extfsWriteFileBlock	1108	call extfsWriteFileBlock
1115	jc .error_inode_size	1109	jc .error_inode_size
1116	sub [esp], ecx	1110	sub [esp], ecx
1117	jmp .write_inode	1111	jmp .done
Line 1118...	Line 1112...
1118		1112
1119	@@:	1113	@@:
1120	call extfsFreeFileBlock	1114	call extfsFreeFileBlock
1121	sub [esp], esi	1115	sub [esp], esi
1122	sub ecx, esi	1116	sub ecx, esi
1123	jz .write_inode	1117	jz .done
1124	.start_aligned:	1118	.start_aligned:
1125	cmp ecx, [ebp+EXTFS.bytesPerBlock]	1119	cmp ecx, [ebp+EXTFS.bytesPerBlock]
1126	jb @f	1120	jb @f
1127	mov eax, [esp]	1121	mov eax, [esp]
Line 1134...	Line 1128...
1134	sub [esp], eax	1128	sub [esp], eax
1135	jmp .start_aligned	1129	jmp .start_aligned
Line 1136...	Line 1130...
1136		1130
1137	@@: ; handle the remaining bytes	1131	@@: ; handle the remaining bytes
1138	test ecx, ecx	1132	test ecx, ecx
1139	jz .write_inode	1133	jz .done
1140	mov eax, [esp]	1134	mov eax, [esp]
1141	xor edx, edx	1135	xor edx, edx
1142	div [ebp+EXTFS.bytesPerBlock]	1136	div [ebp+EXTFS.bytesPerBlock]
1143	dec eax	1137	dec eax
Line 1154...	Line 1148...
1154	rep stosb	1148	rep stosb
1155	pop ecx eax	1149	pop ecx eax
1156	call extfsWriteFileBlock	1150	call extfsWriteFileBlock
1157	jc .error_inode_size	1151	jc .error_inode_size
1158	sub [esp], ecx	1152	sub [esp], ecx
1159	.write_inode:	1153	.done:
1160	xor eax, eax	1154	xor eax, eax
1161	.error_inode_size:	1155	.error_inode_size:
1162	lea ebx, [ebp+EXTFS.tempInodeBuffer]	1156	lea ebx, [ebp+EXTFS.inodeBuffer]
1163	pop [ebx+INODE.fileSize]	1157	pop [ebx+INODE.fileSize]
1164	push eax	-
1165	mov eax, [esp+4]	-
1166	call writeInode	-
1167	pop ebx	-
1168	jc .ret	-
1169	xchg eax, ebx	-
1170	cmp ebx, eax ; set CF	-
1171	.ret:	1158	.ret:
1172	pop edi edi esi edx ecx ebx	1159	pop edi esi edx ecx ebx
1173	ret	1160	ret
Line 1174...	Line 1161...
1174		1161
1175	linkInode:	1162	linkInode:
1176	; in:	1163	; in:
Line 1181...	Line 1168...
1181	push esi edi ebx ecx eax edx	1168	push esi edi ebx ecx eax edx
1182	call strlen	1169	call strlen
1183	add ecx, 8 ; directory entry size	1170	add ecx, 8 ; directory entry size
1184	push esi ebx ecx	1171	push esi ebx ecx
1185	xor ecx, ecx	1172	xor ecx, ecx
1186	lea esi, [ebp+EXTFS.tempInodeBuffer]	1173	lea esi, [ebp+EXTFS.inodeBuffer]
1187	mov ebx, esi	1174	mov ebx, esi
1188	call readInode	1175	call readInode
1189	jc .error_inode_read	1176	jc .error_inode_read
1190	mov ecx, [ebp+EXTFS.sectorsPerBlockLog]	1177	mov ecx, [ebp+EXTFS.sectorsPerBlockLog]
1191	mov eax, [esi+INODE.sectorsUsed]	1178	mov eax, [esi+INODE.sectorsUsed]
1192	shr eax, cl	1179	shr eax, cl
1193	xor ecx, ecx	1180	xor ecx, ecx
1194	push eax ; maximum file block number	-
1195	push ecx ; current file block number	-
1196	.searchBlock:	1181	.searchBlock:
-		1182	push eax ; blocks total
-		1183	push ecx ; current file block number
-		1184	cmp eax, ecx
-		1185	jz .alloc_block
1197	call extfsGetFileBlock	1186	call extfsGetFileBlock
1198	jc .error_get_inode_block	1187	jc .error_get_inode_block
1199	test ecx, ecx	1188	test ecx, ecx
1200	jz .alloc_block	1189	jz .alloc_block
1201	push ecx	1190	push ecx
1202	mov eax, ecx	1191	mov eax, ecx
1203	mov ebx, [ebp+EXTFS.tempBlockBuffer]	1192	mov ebx, [ebp+EXTFS.tempBlockBuffer]
1204	call extfsReadBlock	1193	call extfsReadBlock
1205	jc .error_block_read	1194	jc .error_block_read
1206	mov ecx, [esp+8]	1195	mov ecx, [esp+12]
1207	mov edi, [ebp+EXTFS.tempBlockBuffer]	1196	mov edi, [ebp+EXTFS.tempBlockBuffer]
1208	mov edx, edi	1197	mov edx, edi
1209	add edx, [ebp+EXTFS.bytesPerBlock]	1198	add edx, [ebp+EXTFS.bytesPerBlock]
1210	.searchSpace:	1199	.searchSpace:
1211	movzx eax, [edi+DIRENTRY.entryLength]	1200	movzx eax, [edi+DIRENTRY.entryLength]
Line 1231...	Line 1220...
1231	jge .found	1220	jge .found
1232	.nextEntry:	1221	.nextEntry:
1233	add edi, eax	1222	add edi, eax
1234	cmp edi, edx	1223	cmp edi, edx
1235	jb .searchSpace	1224	jb .searchSpace
-		1225	pop ecx ecx eax
-		1226	inc ecx
1236	jmp .nextBlock	1227	jmp .searchBlock
Line 1237...	Line 1228...
1237		1228

Subversion Repositories Kolibri OS

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