WebSVN – Kolibri OS – Diff – /kernel/trunk/fs/ext2/inode.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Contains ext2 inode handling code.                           ;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
;; Distributed under the terms of the new BSD license.          ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 4850 $
 
 
;---------------------------------------------------------------------
; Receives block number from extent-based inode.
; Input:        ecx = number of block in inode
;               esi = address of extent header
;               ebp = pointer to EXTFS
; Output:       ecx = address of next block, if successful
;               eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext4_block_recursive_search:
        cmp     word [esi + EXT4_EXTENT_HEADER.eh_magic], 0xF30A ;EXT4_EXT_MAGIC
        jne     .fail
        
        movzx   ebx, [esi + EXT4_EXTENT_HEADER.eh_entries]
        add     esi, sizeof.EXT4_EXTENT_HEADER
        cmp     word [esi - sizeof.EXT4_EXTENT_HEADER + EXT4_EXTENT_HEADER.eh_depth], 0
        je      .leaf_block     ;листовой ли это блок?
        
        ;не листовой блок, а индексный ; eax - ext4_extent_idx
        test    ebx, ebx
        jz      .fail               ;пустой индексный блок -> ошибка
 
        ;цикл по индексам экстентов
    @@:
        cmp     ebx, 1              ;у индексов не хранится длина, 
        je      .end_search_index   ;поэтому, если остался последний - то это нужный
        
        cmp     ecx, [esi + EXT4_EXTENT_IDX.ei_block]
        jb      .fail
        
        cmp     ecx, [esi + sizeof.EXT4_EXTENT_IDX + EXT4_EXTENT_IDX.ei_block] ;блок слeдующего индекса
        jb      .end_search_index ;следующий дальше - значит текущий, то что нам нужен
        
        add     esi, sizeof.EXT4_EXTENT_IDX
        dec     ebx
        jmp     @B
 
    .end_search_index:
        ;ebp указывает на нужный extent_idx, считываем следующий блок
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        mov     eax, [esi + EXT4_EXTENT_IDX.ei_leaf_lo]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail
        mov     esi, ebx
        jmp     ext4_block_recursive_search ;рекурсивно прыгаем в начало
        
    .leaf_block:    ;листовой блок esi - ext4_extent
        ;цикл по экстентам
    @@: 
        test    ebx, ebx
        jz      .fail       ;ни один узел не подошел - ошибка
 
        mov     edx, [esi + EXT4_EXTENT.ee_block]
        cmp     ecx, edx
        jb      .fail       ;если меньше, значит он был в предыдущих блоках -> ошибка
 
        movzx   edi, [esi + EXT4_EXTENT.ee_len]
        add     edx, edi
        cmp     ecx, edx
        jb      .end_search_extent     ;нашли нужный блок
        
        add     esi, sizeof.EXT4_EXTENT
        dec     ebx
        jmp     @B
        
    .end_search_extent:
        mov     edx, [esi + EXT4_EXTENT.ee_start_lo]
        sub     ecx, [esi + EXT4_EXTENT.ee_block] ;разница в ext4 блоках
        add     ecx, edx
        xor     eax, eax
        ret
 
    .fail:
        mov     eax, ERROR_FS_FAIL
        ret
 
;---------------------------------------------------------------------
; Frees triply indirect block.
; Input:        eax = triply indirect block.
;               [ebp + EXTFS.ext2_save_inode] = the inode.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_free_triply_indirect:
        push    ebx edx
 
        test    eax, eax
        jz      .success
        push    eax
        ; Read the triple indirect block.
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        pop     eax
        jnz     .fail
 
        ; Free the triple indirect block.
        call    ext2_block_free
        test    eax, eax
        jnz     .fail
 
        mov     edx, ebx
        add     edx, [ebp + EXTFS.block_size]
 
    @@:
        mov     eax, [ebx]
        test    eax, eax
        jz      .success
 
        call    ext2_inode_free_doubly_indirect
        cmp     eax, 1
        je      .success
        cmp     eax, 0xFFFFFFFF
        je      .fail
 
        add     ebx, 4
        cmp     ebx, edx
        jb      @B
 
    .success:
        xor     eax, eax
    .ret:
        pop     edx ebx
        ret
 
    .fail:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Frees double indirect block.
; Input:        eax = double indirect block.
;               [ebp + EXTFS.ext2_save_inode] = the inode.
; Output:       eax = error code, 1 implies finished, ~0 implies error
;---------------------------------------------------------------------
ext2_inode_free_doubly_indirect:
        push    ebx edx
 
        test    eax, eax
        jz      .complete
        push    eax
        ; Read the double indirect block.
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        pop     eax
        jnz     .fail
 
        call    ext2_block_free
        test    eax, eax
        jnz     .fail
 
        mov     edx, ebx
        add     edx, [ebp + EXTFS.block_size]
 
    @@:
        mov     eax, [ebx]
        test    eax, eax
        jz      .complete
 
        call    ext2_block_free
        test    eax, eax
        jnz     .fail
 
        add     ebx, 4
        cmp     ebx, edx
        jb      @B
 
    .success:
        xor     eax, eax
    .ret:
        pop     edx ebx
        ret
 
    .complete:
        xor     eax, eax
        inc     eax
        jmp     .ret
 
    .fail:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Frees all indirect blocks.
; Input:        ebp = pointer to EXTFS.
;               [ebp + EXTFS.ext2_save_inode] = the inode.
; Output:       eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_free_indirect_blocks:
        push    edi
 
        mov     edi, [ebp + EXTFS.ext2_save_inode]
 
        ; Free indirect block.
        mov     eax, [edi + EXT2_INODE_STRUC.i_block + 12*4]
        test    eax, eax
        jz      .success
 
        call    ext2_block_free
        test    eax, eax
        jnz     .fail
 
        mov     eax, [edi + EXT2_INODE_STRUC.i_block + 13*4]
        call    ext2_inode_free_doubly_indirect
        cmp     eax, 1
        je      .success
        cmp     eax, 0xFFFFFFFF
        je      .fail
 
        mov     eax, [edi + EXT2_INODE_STRUC.i_block + 14*4]
        call    ext2_inode_free_triply_indirect
        test    eax, eax
        jnz     .fail
 
    .success:
        xor     eax, eax
    .ret:
        pop     edi
        ret
 
    .fail:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Allocates block for inode.
; Input:        esi = address of inode
;               ebp = pointer to EXTFS.
; Output:       eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_calloc_block:
        push    ecx
 
        ; TODO: fix to have correct preference.
        mov     eax, EXT2_ROOT_INO
        call    ext2_block_calloc
        test    eax, eax
        jnz     .fail
 
        mov     ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
        mov     eax, 2
        shl     eax, cl
        add     [esi + EXT2_INODE_STRUC.i_blocks], eax
 
    .success:
        xor     eax, eax
    .ret:
        pop     ecx
        ret
 
    .fail:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Sets block ID for indirect-addressing inode.
; Input:        ecx = index of block in inode
;               edi = block ID to set to
;               esi = address of inode
;               ebp = pointer to EXTFS.
; Output:       eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_set_block:
        push    ebx ecx edx
 
        ; 0 to 11: direct blocks.
        cmp     ecx, 12
        jb      .direct_block
 
        ; Indirect blocks
        sub     ecx, 12
        cmp     ecx, [ebp + EXTFS.count_pointer_in_block] 
        jb      .indirect_block
 
        ; Double indirect blocks.
        sub     ecx, [ebp + EXTFS.count_pointer_in_block]
        cmp     ecx, [ebp + EXTFS.count_pointer_in_block_square]
        jb      .double_indirect_block
 
        ; Triple indirect blocks.
        sub     ecx, [ebp + EXTFS.count_pointer_in_block_square]
 
        ; Get triply-indirect block in temp_block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 14*4]
        test    eax, eax
        jnz     @F
 
        call    ext2_inode_calloc_block
        test    eax, eax
        jnz     .fail_alloc
 
        mov     [esi + EXT2_INODE_STRUC.i_block + 14*4], ebx
        mov     eax, ebx
 
    @@:
        push    eax
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_alloc_4
 
        ; Get index in triply-indirect block.
        xor     edx, edx
        mov     eax, ecx
        div     [ebp + EXTFS.count_pointer_in_block_square]
 
        ; eax: index in triply-indirect block, edx: index in doubly-indirect block.
        lea     ecx, [ebx + eax*4]
        mov     eax, [ebx + eax*4]
        test    eax, eax
        jnz     @F
 
        call    ext2_inode_calloc_block
        test    eax, eax
        jnz     .fail_alloc_4
 
        mov     [ecx], ebx
 
        mov     eax, [esp]
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write    
        test    eax, eax
        jnz     .fail_alloc_4
 
        mov     eax, [ecx]
    @@:
        mov     [esp], eax
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_alloc_4
 
        mov     eax, edx
        jmp     @F
 
    .double_indirect_block:
        ; Get doubly-indirect block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 13*4]
        test    eax, eax
        jnz     .double_indirect_present
 
        call    ext2_inode_calloc_block
        test    eax, eax
        jnz     .fail_alloc
 
        mov     [esi + EXT2_INODE_STRUC.i_block + 13*4], ebx
        mov     eax, ebx
 
    .double_indirect_present:
        ; Save block we're at.
        push    eax
 
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_alloc_4
 
        mov     eax, ecx
    @@:
        xor     edx, edx
        div     [ebp + EXTFS.count_pointer_in_block]
 
        ; eax: index in doubly-indirect block, edx: index in indirect block.
        lea     ecx, [ebx + edx*4]
        push    ecx
 
        lea     ecx, [ebx + eax*4]
        cmp     dword[ecx], 0
        jne     @F
 
        call    ext2_inode_calloc_block
        test    eax, eax
        jnz     .fail_alloc_8
 
        mov     [ecx], ebx
 
        mov     eax, [esp + 4]
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write    
        test    eax, eax
        jnz     .fail_alloc_8       
 
    @@:
        mov     eax, [ecx]
        push    eax
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_alloc_12
 
        pop     eax
        pop     ecx
        mov     [ecx], edi
        call    ext2_block_write
 
        add     esp, 4
        jmp     .return
 
    .indirect_block:
        ; Get index of indirect block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 12*4]
        test    eax, eax
        jnz     @F
 
        call    ext2_inode_calloc_block
        test    eax, eax
        jnz     .fail_alloc
        
        mov     [esi + EXT2_INODE_STRUC.i_block + 12*4], ebx
        mov     eax, ebx
    
    @@:
        push    eax
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_alloc_4
        
        ; Get the block ID.
        mov     [ebx + ecx*4], edi
        pop     eax
        call    ext2_block_write
        jmp     .return
 
    .direct_block:
        mov     [esi + EXT2_INODE_STRUC.i_block + ecx*4], edi
        xor     eax, eax
 
    .return:
        pop     edx ecx ebx
        ret
 
    .fail_alloc:
        xor     eax, eax
        not     eax
        jmp     .return
 
    .fail_alloc_12:
        add     esp, 4
    .fail_alloc_8:
        add     esp, 4
    .fail_alloc_4:
        add     esp, 4
        jmp     .fail_alloc
 
;---------------------------------------------------------------------
; Receives block ID from indirect-addressing inode.
; Input:        ecx = index of block in inode
;               esi = address of inode
;               ebp = pointer to EXTFS
; Output:       ecx = block ID, if successful
;               eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_get_block:
        ; If inode is extent-based, use ext4_block_recursive_search.
        test    [esi + EXT2_INODE_STRUC.i_flags], EXT2_EXTENTS_FL
        jz      @F
 
        pushad
 
        ; Get extent header in EBP.
        add     esi, EXT2_INODE_STRUC.i_block
        call    ext4_block_recursive_search
        mov     PUSHAD_ECX, ecx
        mov     PUSHAD_EAX, eax
 
        popad
        ret
 
    @@:
        ; 0 to 11: direct blocks.
        cmp     ecx, 12
        jb      .get_direct_block
 
        ; Indirect blocks
        sub     ecx, 12
        cmp     ecx, [ebp + EXTFS.count_pointer_in_block] 
        jb      .get_indirect_block
 
        ; Double indirect blocks.
        sub     ecx, [ebp + EXTFS.count_pointer_in_block]
        cmp     ecx, [ebp + EXTFS.count_pointer_in_block_square]
        jb      .get_double_indirect_block
 
        ; Triple indirect blocks.
        sub     ecx, [ebp + EXTFS.count_pointer_in_block_square]
        push    edx ebx
 
        ; Get triply-indirect block in temp_block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 14*4]
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail
 
        ; Get index in triply-indirect block.
        xor     edx, edx
        mov     eax, ecx
        div     [ebp + EXTFS.count_pointer_in_block_square]
 
        ; eax: index in triply-indirect block, edx: index in doubly-indirect block.
        mov     eax, [ebx + eax*4]
        test    eax, eax
        jz      .fail_triple_indirect_block
 
        call    ext2_block_read
        test    eax, eax
        jnz     .fail
 
        mov     eax, edx
        jmp     @F
 
    .get_double_indirect_block:
        push    edx ebx
 
        ; Get doubly-indirect block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 13*4]
        test    eax, eax
        jz      .fail_double_indirect_block
 
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail
 
        mov     eax, ecx
    @@:
        xor     edx, edx
        div     [ebp + EXTFS.count_pointer_in_block]
 
        ; eax: index in doubly-indirect block, edx: index in indirect block.
        mov     eax, [ebx + eax*4]
        test    eax, eax
        jz      .fail_double_indirect_block
 
        call    ext2_block_read
        test    eax, eax
        jnz     .fail
 
        mov     ecx, [ebx + edx*4]
    .fail:
        pop     ebx edx
 
        ret
 
    .get_indirect_block:
        push    ebx
 
        ; Get index of indirect block.
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 12*4]
        test    eax, eax
        jz      .fail_indirect_block
 
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     @F
        
        mov     ecx, [ebx + ecx*4]
    @@:
        pop     ebx
 
        ret
 
    .get_direct_block:
        mov     ecx, [esi + EXT2_INODE_STRUC.i_block + ecx*4]
        xor     eax, eax
 
        ret
 
    .fail_indirect_block:
        pop     ebx
 
    .fail_triple_indirect_block:
        xor     eax, eax
        xor     ecx, ecx
        ret
 
    .fail_double_indirect_block:
        pop     ebx edx
        jmp     .fail_triple_indirect_block
 
;---------------------------------------------------------------------
; Get block containing inode.
; Input:        eax = inode number.
;               ebp = pointer to EXTFS.
; Output:       ebx = block (hard disk) containing inode.
;               edx = index inside block.
;               eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_read_block_of_inode:
        pushad
 
        dec     eax
        xor     edx, edx
        
        ; EAX = block group.
        div     [ebp + EXTFS.superblock + EXT2_SB_STRUC.inodes_per_group]
 
        push    edx                             ; Index in group.
 
        mov     edx, 32
        mul     edx                             ; Get index of descriptor in global_desc_table.
 
        ; eax: inode group offset relative to global descriptor table start
        ; Find the block this block descriptor is in.
        div     [ebp + EXTFS.block_size]
        add     eax, [ebp + EXTFS.superblock + EXT2_SB_STRUC.first_data_block]
        inc     eax
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .return     
 
        add     ebx, edx                        ; edx: local index of descriptor inside block
        mov     eax, [ebx + EXT2_BLOCK_GROUP_DESC.inode_table]   ; Block number of inode table - in ext2 terms.
        mov     ecx, [ebp + EXTFS.log_block_size]
        shl     eax, cl
 
        ; eax: points to inode table on HDD.
        mov     esi, eax
 
        ; Add local address of inode.
        pop     eax
        mov     ecx, [ebp + EXTFS.inode_size]
        mul     ecx                             ; (index * inode_size)
 
        mov     ebp, 512
        div     ebp                             ; Divide by hard disk block size.
 
        add     eax, esi                        ; Found block to read.
        mov     ebx, eax                        ; Get it inside ebx.
 
        xor     eax, eax
    .return:
        mov     PUSHAD_EAX, eax
        mov     PUSHAD_EBX, ebx
        mov     PUSHAD_EDX, edx
 
        popad
        ret
 
;---------------------------------------------------------------------
; Sets content of inode by number.
; Input:        eax = inode number.
;               ebx = address from where to write inode content.
;               ebp = pointer to EXTFS.
; Output:       eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_write:
        push    edx edi esi ecx ebx
        mov     esi, ebx
 
        ; Ext2 actually stores time of modification of inode in ctime.
        lea     edi, [ebx + EXT2_INODE_STRUC.i_ctime]
        call    current_unix_time
 
        ; Get block where inode is situated.
        call    ext2_read_block_of_inode
        test    eax, eax
        jnz     .error
 
        mov     eax, ebx                        ; Get block into EAX.
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
 
        mov     ecx, eax                        ; Save block.    
        call    fs_read32_sys
        test    eax, eax
        jz      @F
 
    .error:
        mov     eax, ERROR_DEVICE
        jmp     .return
 
    @@:
        mov     eax, ecx
        mov     ecx, [ebp + EXTFS.inode_size]
        mov     edi, edx                        ; The index into the block.
        add     edi, ebx
        rep movsb
 
        ; Write the block.
        call    fs_write32_sys
 
    .return:
        pop     ebx ecx esi edi edx
        ret
 
;---------------------------------------------------------------------
; Get content of inode by number.
; Input:        eax = inode number.
;               ebx = address where to store inode content.
;               ebp = pointer to EXTFS.
; Output:       eax = error code (0 implies no error)
;---------------------------------------------------------------------
ext2_inode_read:
        push    edx edi esi ecx ebx
        mov     edi, ebx
 
        ; Get block where inode is situated.
        call    ext2_read_block_of_inode
        test    eax, eax
        jnz     .error
 
        mov     eax, ebx                        ; Get block into EAX.
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    fs_read32_sys
        test    eax, eax
        jz      @F
 
    .error:
        mov     eax, ERROR_DEVICE
        jmp     .return
 
    @@:
        mov     ecx, [ebp + EXTFS.inode_size]
        mov     esi, edx                        ; The index into the inode.
        add     esi, ebx
        rep movsb
 
        xor     eax, eax
    .return:
        pop     ebx ecx esi edi edx
        ret
 
;---------------------------------------------------------------------
; Seek inode from the path.
; Input:        esi + [esp + 4] = name.
;               ebp = pointer to EXTFS.
; Output:       eax = error code (0 implies no error)
;               esi = inode number.
;                dl = first byte of file/folder name.
;                     [ext2_data.ext2_save_inode] stores the inode.
;---------------------------------------------------------------------
ext2_inode_find:
        mov     edx, [ebp + EXTFS.root_inode]
 
        ; Check for empty root.
        cmp     [edx + EXT2_INODE_STRUC.i_blocks], 0
        je      .error_empty_root
 
        ; Check for root.
        cmp     byte[esi], 0
        jne     .next_path_part
 
        push    edi ecx
        mov     esi, [ebp + EXTFS.root_inode]
        mov     edi, [ebp + EXTFS.ext2_save_inode]
        mov     ecx, [ebp + EXTFS.inode_size]
        rep movsb
        pop     ecx edi
 
        xor     eax, eax
        xor     dl, dl
        mov     esi, EXT2_ROOT_INO
        ret     4
    
    .next_path_part:
        push    [edx + EXT2_INODE_STRUC.i_blocks]
        xor     ecx, ecx
 
    .folder_block_cycle:
        push    ecx
        xchg    esi, edx
        call    ext2_inode_get_block
        xchg    esi, edx
        test    eax, eax
        jnz     .error_get_inode_block
        
        mov     eax, ecx
        mov     ebx, [ebp + EXTFS.ext2_save_block]              ; Get directory records from directory.
        call    ext2_block_read
        test    eax, eax
        jnz     .error_get_block
        
        push    esi
        push    edx
        call    ext2_block_find_parent
        pop     edx
        pop     edi ecx
 
        cmp     edi, esi                                        ; Did something match?
        je      .next_folder_block                              ; No, move to next block.
        
        cmp     byte [esi], 0                                   ; Reached the "end" of path successfully. 
        jnz     @F
        cmp     dword[esp + 8], 0
        je      .get_inode_ret
        mov     esi, [esp + 8]
        mov     dword[esp + 8], 0
 
    @@:
        mov     eax, [ebx + EXT2_DIR_STRUC.inode]
        mov     ebx, [ebp + EXTFS.ext2_save_inode]
        call    ext2_inode_read
        test    eax, eax
        jnz     .error_get_inode
 
        movzx   eax, [ebx + EXT2_INODE_STRUC.i_mode]
        and     eax, EXT2_S_IFMT                                ; Get the mask.
        cmp     eax, EXT2_S_IFDIR
        jne     .not_found                                      ; Matched till part, but directory entry we got doesn't point to folder.
 
        pop     ecx                                             ; Stack top contains number of blocks.
        mov     edx, ebx
        jmp     .next_path_part
        
    .next_folder_block:
        ; Next block in current folder.
        pop     eax                                             ; Get blocks counter.
        sub     eax, [ebp + EXTFS.count_block_in_block]
        jle     .not_found
        
        push    eax
        inc     ecx
        jmp     .folder_block_cycle
 
    .not_found:
        mov     eax, ERROR_FILE_NOT_FOUND
        ret     4
 
    .get_inode_ret:
        pop     ecx                                             ; Stack top contains number of blocks.
 
        mov     dl, [ebx + EXT2_DIR_STRUC.name]                 ; First character of file-name.
        mov     eax, [ebx + EXT2_DIR_STRUC.inode]
        mov     ebx, [ebp + EXTFS.ext2_save_inode]
        mov     esi, eax
 
        ; If we can't get the inode, eax contains the error.        
        call    ext2_inode_read
        ret     4
 
    .error_get_inode_block:
    .error_get_block:
        pop     ecx
    .error_get_inode:
        pop     ebx
    .error_empty_root:
        mov     eax, ERROR_FS_FAIL
        ret     4
 
;---------------------------------------------------------------------
; Seeks parent inode from path.
; Input:        esi = path.
;               ebp = pointer to EXTFS.
; Output:       eax = error code.
;               esi = inode.
;               edi = pointer to file name.
;---------------------------------------------------------------------
ext2_inode_find_parent:
        push    esi
        xor     edi, edi  
 
    .loop:
        cmp     byte[esi], '/'
        jne     @F
 
        mov     edi, esi
        inc     esi
        jmp     .loop
 
    @@:
        inc     esi
        cmp     byte[esi - 1], 0
        jne     .loop
 
        ; If it was just a filename (without any additional directories),
        ; use the last byte as "parent path".
        cmp     edi, 0
        jne     @F
 
        pop     edi
        dec     esi
        jmp     .get_inode
 
        ; It had some additional directories, so handle it that way.
    @@:
        mov     byte[edi], 0
        inc     edi
        pop     esi
 
    .get_inode:
        push    ebx edx
        stdcall ext2_inode_find, 0
        pop     edx ebx
 
    .return:
        ret
 
;---------------------------------------------------------------------
; Link an inode.
; Input:        eax = inode on which to link.
;               ebx = inode to link.
;                dl = file type.
;               esi = name.
;               ebp = pointer to EXTFS.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_link:
        push    eax
        push    esi edi ebx ecx edx
 
        ; Get string length, and then directory entry structure size.
        call    strlen
        add     ecx, 8
 
        push    esi ebx ecx
 
        xor     ecx, ecx
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        mov     ebx, esi
 
        call    ext2_inode_read
        test    eax, eax
        jnz     .error_inode_read
 
        ; Get the maximum addressible i_block index by (i_blocks/(2 << s_log_block_size)).
        ; Note that i_blocks contains number of reserved 512B blocks, which is why we've to
        ; find out the ext2 blocks.
        mov     eax, 2
        mov     ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
        shl     eax, cl
        mov     ecx, eax
 
        mov     eax, [esi + EXT2_INODE_STRUC.i_blocks]
        xor     edx, edx
 
        div     ecx
 
        ; EAX is the maximum index inside i_block we can go.
        push    eax
        push    dword 0
 
        ; ECX contains the "block inside i_block" index.
        xor     ecx, ecx
    @@:
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error_get_inode_block
        test    ecx, ecx
        jz      .alloc_block        ; We've got no block here, so allocate one.
 
        push    ecx                 ; Save block number.
 
        mov     eax, ecx
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .error_block_read
 
        ; Try to find free space in current block.
        mov     ecx, [esp + 8]
        call    ext2_block_find_fspace
        test    eax, eax
        jz      .found
 
        cmp     eax, 0x00000001
        jne     .next_iter
 
        ; This block wasn't linking to the next block, so fix that, and use the next one.
        ; Write the block.
        pop     eax
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write    
        test    eax, eax
        jnz     .error_get_inode_block
 
        inc     dword [esp]
        mov     ecx, [esp]
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error_get_inode_block
 
        test    ecx, ecx
        jz      .alloc_block
 
        ; If there was a block there, prepare it for our use!
        push    ecx
        jmp     .prepare_block
 
    .next_iter:
        add     esp, 4
 
        inc     dword [esp]
        mov     ecx, [esp]
        cmp     ecx, [esp + 4]
        jbe     @B      
 
    .alloc_block:
        mov     eax, [esp + 12]     ; Get inode ID of what we're linking.
        call    ext2_block_calloc
        test    eax, eax
        jnz     .error_get_inode_block
 
        mov     ecx, [esp]          ; Get the index of it inside the inode.
        mov     edi, ebx            ; And what to set to.
        call    ext2_inode_set_block
        test    eax, eax
        jnz     .error_get_inode_block
 
        ; Update i_size.
        mov     eax, [ebp + EXTFS.block_size]
        add     [esi + EXT2_INODE_STRUC.i_size], eax
 
        ; Update i_blocks.
        mov     ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
        mov     eax, 2
        shl     eax, cl
        add     [esi + EXT2_INODE_STRUC.i_blocks], eax
 
        ; Write the inode.
        mov     eax, [esp + 40]
        mov     ebx, esi
        call    ext2_inode_write
        test    eax, eax
        jnz     .error_get_inode_block
 
        push    edi                 ; Save the block we just allocated.
 
    ; If we've allocated/using-old-block outside of loop, prepare it.
    .prepare_block:
        mov     eax, [esp]
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .error_block_read
 
        mov     edi, ebx
        mov     eax, [ebp + EXTFS.block_size]
        mov     [edi + EXT2_DIR_STRUC.rec_len], ax
 
    .found:
        pop     edx 
        add     esp, 8
        pop     ecx ebx esi
 
        push    ebx
        mov     [edi], ebx          ; Save inode.
 
        mov     eax, [esp + 4]      ; Get EDX off the stack -- contains the file_type.
        cmp     [ebp + EXTFS.superblock + EXT2_SB_STRUC.rev_level], EXT2_GOOD_OLD_REV
        je      .name
 
        ; Set the file-type.
        mov     [edi + EXT2_DIR_STRUC.file_type], al
 
    .name:
        ; Save name.
        sub     ecx, 8
        mov     [edi + EXT2_DIR_STRUC.name_len], cl
        add     edi, 8
        rep movsb
 
        ; Write block.
        mov     eax, edx
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write
        test    eax, eax
        jnz     .error_block_write
 
        mov     eax, [esp]
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_read
        test    eax, eax
        jnz     .error_block_write
 
        pop     eax
        inc     [ebx + EXT2_INODE_STRUC.i_links_count]
        call    ext2_inode_write
        test    eax, eax
        jnz     .error
 
        xor     eax, eax
    .ret:
        pop     edx ecx ebx edi esi
        add     esp, 4
        ret
 
    .error_block_read:
        add     esp, 4 
    .error_get_inode_block:
        add     esp, 8
    .error_inode_read:
        add     esp, 8
    .error_block_write:
        add     esp, 4
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Unlink an inode.
; Input:        eax = inode from which to unlink.
;               ebx = inode to unlink.
;               ebp = pointer to EXTFS.
; Output:       eax = number of links to inode, after unlinking (0xFFFFFFFF implies error)
;---------------------------------------------------------------------
ext2_inode_unlink:
        push    ebx ecx edx esi edi
 
        push    ebx
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_read
 
        test    eax, eax
        jnz     .fail_get_inode
 
        ; The index into the inode block data.
        push    dword 0
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        
    .loop:
        mov     ecx, [esp]
        call    ext2_inode_get_block
 
        test    eax, eax
        jnz     .fail_loop
        test    ecx, ecx
        jz      .fail_loop
 
        mov     eax, ecx
        mov     edi, eax
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .fail_loop
 
    ; edi -> block.
    .first_dir_entry:
        mov     eax, [esp + 4]
        cmp     [ebx], eax
        jne     @F
 
        mov     dword[ebx], 0                               ; inode.
        mov     word[ebx + 6], 0                            ; name_len + file_type.
        jmp     .write_block
 
    @@:
        mov     edx, ebx
        add     edx, [ebp + EXTFS.block_size]
        push    edx
 
        mov     edx, ebx
        movzx   ecx, [ebx + EXT2_DIR_STRUC.rec_len]
        add     ebx, ecx
 
    .dir_entry:
        cmp     [ebx], eax
        jne     @F
 
        mov     cx, [ebx + EXT2_DIR_STRUC.rec_len]
        add     [edx + EXT2_DIR_STRUC.rec_len], cx
        add     esp, 4
        jmp     .write_block
 
    @@:
        mov     edx, ebx
        movzx   ecx, [ebx + EXT2_DIR_STRUC.rec_len]
        
        ; If it's a zero length entry, error.
        test    ecx, ecx
        jz      .fail_inode
 
        add     ebx, ecx
 
        cmp     ebx, [esp]
        jb      .dir_entry
 
        add     esp, 4
        inc     dword[esp]
        jmp     .loop
 
    .write_block:
        mov     eax, edi
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write
        test    eax, eax
        jnz     .fail_loop
 
        add     esp, 4
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        mov     eax, [esp]
        call    ext2_inode_read
        test    eax, eax
        jnz     .fail_get_inode
 
        dec     word[ebx + EXT2_INODE_STRUC.i_links_count]
        movzx   eax, word[ebx + EXT2_INODE_STRUC.i_links_count]
        push    eax
 
        mov     eax, [esp + 4]
        call    ext2_inode_write
        test    eax, eax
        jnz     .fail_loop
 
        pop     eax
        add     esp, 4
    .return:
        pop     edi esi edx ecx ebx
        ret
 
    .fail_inode:
        add     esp, 4
 
    .fail_loop:
        add     esp, 4
 
    .fail_get_inode:
        add     esp, 4
 
    .fail:
        xor     eax, eax
        not     eax
        jmp     .return
 
;---------------------------------------------------------------------
; Checks if a directory is empty.
; Input:        ebx = inode to check.
;               ebp = pointer to EXTFS.
;               [EXTFS.ext2_save_inode] = points to saved inode.
; Output:       eax = 0 signifies empty directory.
;---------------------------------------------------------------------
ext2_dir_empty:
        push    ebx ecx edx
        
        ; The index into the inode block data.
        push    dword 0
        mov     esi, [ebp + EXTFS.ext2_save_inode]
        
    .loop:
        mov     ecx, [esp]
        call    ext2_inode_get_block
 
        ; Treat a failure as not-empty.
        test    eax, eax
        jnz     .not_empty
        test    ecx, ecx
        jz      .empty
 
        mov     eax, ecx
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .not_empty
 
        mov     edx, ebx
        add     edx, [ebp + EXTFS.block_size]
 
        movzx   ecx, [ebx + EXT2_DIR_STRUC.rec_len]
        add     ebx, ecx
 
    .dir_entry:
        ; Process entry.
        cmp     byte[ebx + EXT2_DIR_STRUC.name_len], 1
        jne     @F
 
        cmp     byte[ebx + EXT2_DIR_STRUC.name], '.'
        jne     .not_empty
 
    @@:
        cmp     byte[ebx + EXT2_DIR_STRUC.name_len], 2
        jne     .not_empty
 
        cmp     word[ebx + EXT2_DIR_STRUC.name], '..'
        jne     .not_empty
 
    @@:
        movzx   ecx, [ebx + EXT2_DIR_STRUC.rec_len]
        add     ebx, ecx
 
        cmp     ebx, edx
        jb      .dir_entry
 
        inc     dword[esp]
        jmp     .loop
 
    .empty:
        xor     eax, eax
    .return:
        add     esp, 4
        pop     edx ecx ebx
        ret
 
    .not_empty:
        xor     eax, eax
        not     eax
        jmp     .return
 
;---------------------------------------------------------------------
; Gets the block group's inode bitmap.
; Input:        eax = block group.
; Output:       eax = if zero, error; else, points to block group descriptor.
;               ebx = inode bitmap's block (hard disk).
;---------------------------------------------------------------------
ext2_bg_read_inode_bitmap:
        push    ecx
 
        call    ext2_bg_read_desc
        test    eax, eax
        jz      .fail
 
        mov     ebx, [eax + EXT2_BLOCK_GROUP_DESC.inode_bitmap] ; Block number of inode bitmap - in ext2 terms.
 
    .return:
        pop     ecx
        ret
 
    .fail:
        xor     eax, eax
        jmp     .return
 
;---------------------------------------------------------------------
; Allocates a inode.
; Input:        eax = inode ID for "preference".
;               ebp = pointer to EXTFS.
; Output:       Inode marked as set in inode group.
;               eax = error code.
;               ebx = inode ID.
;---------------------------------------------------------------------
ext2_inode_alloc:
        push    [ebp + EXTFS.superblock + EXT2_SB_STRUC.inodes_count]
        push    EXT2_BLOCK_GROUP_DESC.free_inodes_count
        push    [ebp + EXTFS.superblock + EXT2_SB_STRUC.inodes_per_group]
 
        lea     ebx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.free_inodes_count]
        push    ebx
 
        push    ext2_bg_read_inode_bitmap
 
        call    ext2_resource_alloc
 
        ; Inode table starts with 1.
        inc     ebx
 
        ret
 
;---------------------------------------------------------------------
; Frees a inode.
; Input:        eax = inode ID.
;               ebp = pointer to EXTFS.
; Output:       inode marked as free in block group.
;               eax = error code.
;---------------------------------------------------------------------
ext2_inode_free:
        push    edi ecx
 
        ; Inode table starts with 1.
        dec     eax
 
        mov     edi, ext2_bg_read_inode_bitmap
        xor     ecx, ecx
        inc     cl
        call    ext2_resource_free
 
        pop     ecx edi
        ret
 
;---------------------------------------------------------------------
; Blanks a particular entry in an inode.
; Input:        eax = index into block.
;               edx = inode.
;               ebp = pointer to EXTFS.
;               [ebp + EXTFS.ext2_temp_inode] = the inode.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_blank_entry:
        push    ebx ecx edx edi esi
 
        mov     edi, eax
 
        mov     ecx, eax
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error
 
        test    ecx, ecx
        jz      .allocate
 
        mov     edx, ecx
        mov     ecx, [ebp + EXTFS.block_size]
        mov     edi, [ebp + EXTFS.ext2_temp_block]
        xor     eax, eax
        rep stosb
 
        mov     eax, edx
        mov     ebx, [ebp + EXTFS.ext2_temp_block]
        call    ext2_block_write
        test    eax, eax
        jnz     .error
 
        jmp     .success
 
    ; Need to allocate a block.
    .allocate:
        mov     eax, edx
        call    ext2_block_calloc
        test    eax, eax
        jnz     .error
 
        mov     ecx, edi
        mov     edi, ebx
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_set_block
        test    eax, eax
        jnz     .error
 
        mov     ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
        mov     eax, 2
        shl     eax, cl
        add     [esi + EXT2_INODE_STRUC.i_blocks], eax
 
    .success:
        xor     eax, eax
 
    .ret:
        pop     esi edi edx ecx ebx
        ret
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Frees a particular entry in an inode.
; Input:        eax = index into block.
;               ebp = pointer to EXTFS.
;               [ebp + EXTFS.ext2_temp_inode] = the inode.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_free_entry:
        push    ebx ecx edi esi
 
        mov     edi, eax
 
        mov     ecx, eax
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error
 
        test    ecx, ecx
        jz      .success
 
        mov     eax, ecx
        call    ext2_block_free
        test    eax, eax
        jnz     .error
 
        mov     ecx, edi
        xor     edi, edi
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_set_block
 
        mov     ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
        mov     eax, 2
        shl     eax, cl
        sub     [esi + EXT2_INODE_STRUC.i_blocks], eax
 
    .success:
        xor     eax, eax
 
    .ret:
        pop     esi edi ecx ebx
        ret
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Reads a particular entry from an inode.
; Input:        eax = index into block.
;               ebp = pointer to EXTFS.
;               [ebp + EXTFS.ext2_temp_inode] = the inode.
; Output:       eax = error code.
;               [ebp + EXTFS.ext2_save_block] = the read block.
;---------------------------------------------------------------------
ext2_inode_read_entry:
        push    ebx ecx edx esi
 
        mov     ecx, eax
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error
 
        test    ecx, ecx
        jz      .error
 
        mov     eax, ecx
        mov     ebx, [ebp + EXTFS.ext2_save_block]
        call    ext2_block_read
        test    eax, eax
        jnz     .error
 
    .ret:
        pop     esi edx ecx ebx
        ret
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Writes a particular entry from an inode.
; Input:        eax = index into block.
;               ebp = pointer to EXTFS.
;               [ebp + EXTFS.ext2_temp_inode] = the inode.
;               [ebp + EXTFS.ext2_save_block] = the block to write.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_write_entry:
        push    ebx ecx edx esi
 
        mov     ecx, eax
        mov     esi, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_get_block
        test    eax, eax
        jnz     .error
 
        test    ecx, ecx
        jz      .error
 
        mov     eax, ecx
        mov     ebx, [ebp + EXTFS.ext2_save_block]
        call    ext2_block_write
        test    eax, eax
        jnz     .error
 
    .ret:
        pop     esi edx ecx ebx
        ret
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Extends inode to said size.
; Input:        eax = inode ID.
;               ecx = size to extend to.
;               ebp = pointer to EXTFS.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_extend:
        push    ebx ecx edx esi edi
 
        ; Save the inode.
        push    eax
 
        ; Read the inode.
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_read
        test    eax, eax
        jnz     .error
 
        mov     eax, [ebx + EXT2_INODE_STRUC.i_size]
        cmp     eax, ecx
        jge     .success
 
        ; Save the size of the inode.
        push    eax
 
        ; ECX contains the size we've to write.
        sub     ecx, eax
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
 
        test    edx, edx
        jz      .start_aligned
 
        ; Start isn't aligned, so deal with the non-aligned bytes.
        mov     esi, [ebp + EXTFS.block_size]
        sub     esi, edx
 
        cmp     esi, ecx
        jbe     @F
 
        ; If the size to entend to fits in current block, limit to that.
        mov     esi, ecx
 
    @@:
        ; Clear ESI bytes, in EAX indexed block.
        push    eax
        call    ext2_inode_read_entry
        test    eax, eax
        pop     eax
        jnz     .error_inode_size
 
        push    eax ecx
        
        xor     eax, eax
        mov     ecx, esi
        mov     edi, ebx
        add     edi, edx
 
        rep stosb
 
        pop     ecx eax
 
        ; Write the block.
        call    ext2_inode_write_entry
        test    eax, eax
        jnz     .error_inode_size
        
        add     [esp], esi
        sub     ecx, esi
        jz      .write_inode
 
    .start_aligned:
        cmp     ecx, [ebp + EXTFS.block_size]
        jb      @F
 
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
 
        mov     edx, [esp + 4]
        call    ext2_inode_blank_entry
 
        test    eax, eax
        jnz     .error_inode_size
 
        mov     eax, [ebp + EXTFS.block_size]
        sub     ecx, eax
        add     [esp], eax
        jmp     .start_aligned        
 
    ; Handle the remaining bytes.
    @@:
        test    ecx, ecx
        jz      .write_inode
 
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
 
        mov     edx, [esp + 4]
        call    ext2_inode_blank_entry
 
        test    eax, eax
        jnz     .error_inode_size
        add     [esp], ecx
 
    .write_inode:
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        pop     eax
        mov     [ebx + EXT2_INODE_STRUC.i_size], eax
        mov     eax, [esp]
        call    ext2_inode_write
 
        test    eax, eax
        jnz     .error
 
    .success:
        xor     eax, eax
 
    .ret:
        add     esp, 4
 
        pop     edi esi edx ecx ebx
        ret
 
    .error_inode_size:
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        pop     eax
        mov     [ebx + EXT2_INODE_STRUC.i_size], eax
        mov     eax, [esp]
        call    ext2_inode_write
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret
 
;---------------------------------------------------------------------
; Truncates inode to said size.
; Input:        eax = inode ID.
;               ecx = size to truncate to.
;               ebp = pointer to EXTFS.
; Output:       eax = error code.
;---------------------------------------------------------------------
ext2_inode_truncate:
        push    ebx ecx edx esi edi
 
        ; Save the inode.
        push    eax
 
        ; Read the inode.
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        call    ext2_inode_read
        test    eax, eax
        jnz     .error
 
        mov     eax, [ebx + EXT2_INODE_STRUC.i_size]
        cmp     ecx, eax
        jge     .success
 
        ; Save the size of the inode.
        push    eax
 
        ; ECX contains the size we've to truncate.
        sub     ecx, eax
        not     ecx
        inc     ecx
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
 
        test    edx, edx
        jz      .start_aligned
 
        ; Start isn't aligned, so deal with the non-aligned bytes.
        mov     esi, edx
 
        cmp     esi, ecx
        jbe     @F
 
        ; If the size to truncate is smaller than the un-aligned bytes
        ; we're going to have to mark neccessary bytes from the EOF
        ; as 0.
        push    eax
        call    ext2_inode_read_entry
        test    eax, eax
        pop     eax
        jnz     .error_inode_size
 
        mov     edi, [ebp + EXTFS.ext2_save_block]
        sub     edx, ecx
        add     edi, edx
 
        push    ecx eax
        xor     eax, eax
        rep stosb
        pop     eax ecx
 
        call    ext2_inode_write_entry
        test    eax, eax
        jnz     .error_inode_size
 
        sub     [esp], ecx
        jmp     .write_inode
 
    @@:
        ; Since ECX is greater than or equal to the bytes here un-aligned
        ; just free the block.
        call    ext2_inode_free_entry
 
        sub     [esp], esi
        sub     ecx, esi
        jz      .write_inode
 
    .start_aligned:
        cmp     ecx, [ebp + EXTFS.block_size]
        jb      @F
 
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
        dec     eax
 
        call    ext2_inode_free_entry
 
        test    eax, eax
        jnz     .error_inode_size
 
        mov     eax, [ebp + EXTFS.block_size]
        sub     ecx, eax
        sub     [esp], eax
        jmp     .start_aligned        
 
    ; Handle the remaining bytes.
    @@:
        test    ecx, ecx
        jz      .write_inode
 
        mov     eax, [esp]
        xor     edx, edx
        div     [ebp + EXTFS.block_size]
        dec     eax
 
        push    eax
        call    ext2_inode_read_entry
        test    eax, eax
        pop     eax
        jnz     .error_inode_size
 
        mov     edi, [ebp + EXTFS.ext2_save_block]
        mov     edx, [ebp + EXTFS.block_size]
        sub     edx, ecx
        add     edi, edx
 
        push    ecx eax
        xor     eax, eax
        rep stosb
        pop     eax ecx
 
        call    ext2_inode_write_entry
        test    eax, eax
        jnz     .error_inode_size
 
        sub     [esp], ecx
 
    .write_inode:
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        pop     eax
        mov     [ebx + EXT2_INODE_STRUC.i_size], eax
        mov     eax, [esp]
        call    ext2_inode_write
 
        test    eax, eax
        jnz     .error
 
    .success:
        xor     eax, eax
 
    .ret:
        add     esp, 4
 
        pop     edi esi edx ecx ebx
        ret
 
    .error_inode_size:
        mov     ebx, [ebp + EXTFS.ext2_temp_inode]
        pop     eax
        mov     [ebx + EXT2_INODE_STRUC.i_size], eax
        mov     eax, [esp]
        call    ext2_inode_write
 
    .error:
        xor     eax, eax
        not     eax
        jmp     .ret

Rev 4066	Rev 4850
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Contains ext2 inode handling code. ;;	3	;; Contains ext2 inode handling code. ;;
4	;; ;;	4	;; ;;
5	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	5	;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
6	;; Distributed under the terms of the new BSD license. ;;	6	;; Distributed under the terms of the new BSD license. ;;
7	;; ;;	7	;; ;;
8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		9
-		10	$Revision: 4850 $
-		11
9		12
10	;---------------------------------------------------------------------	13	;---------------------------------------------------------------------
11	; Receives block number from extent-based inode.	14	; Receives block number from extent-based inode.
12	; Input: ecx = number of block in inode	15	; Input: ecx = number of block in inode
13	; esi = address of extent header	16	; esi = address of extent header
14	; ebp = pointer to EXTFS	17	; ebp = pointer to EXTFS
15	; Output: ecx = address of next block, if successful	18	; Output: ecx = address of next block, if successful
16	; eax = error code (0 implies no error)	19	; eax = error code (0 implies no error)
17	;---------------------------------------------------------------------	20	;---------------------------------------------------------------------
18	ext4_block_recursive_search:	21	ext4_block_recursive_search:
19	cmp word [esi + EXT4_EXTENT_HEADER.eh_magic], 0xF30A ;EXT4_EXT_MAGIC	22	cmp word [esi + EXT4_EXTENT_HEADER.eh_magic], 0xF30A ;EXT4_EXT_MAGIC
20	jne .fail	23	jne .fail
21		24
22	movzx ebx, [esi + EXT4_EXTENT_HEADER.eh_entries]	25	movzx ebx, [esi + EXT4_EXTENT_HEADER.eh_entries]
23	add esi, sizeof.EXT4_EXTENT_HEADER	26	add esi, sizeof.EXT4_EXTENT_HEADER
24	cmp word [esi - sizeof.EXT4_EXTENT_HEADER + EXT4_EXTENT_HEADER.eh_depth], 0	27	cmp word [esi - sizeof.EXT4_EXTENT_HEADER + EXT4_EXTENT_HEADER.eh_depth], 0
25	je .leaf_block ;листовой ли это блок?	28	je .leaf_block ;листовой ли это блок?
26		29
27	;не листовой блок, а индексный ; eax - ext4_extent_idx	30	;не листовой блок, а индексный ; eax - ext4_extent_idx
28	test ebx, ebx	31	test ebx, ebx
29	jz .fail ;пустой индексный блок -> ошибка	32	jz .fail ;пустой индексный блок -> ошибка
30		33
31	;цикл по индексам экстентов	34	;цикл по индексам экстентов
32	@@:	35	@@:
33	cmp ebx, 1 ;у индексов не хранится длина,	36	cmp ebx, 1 ;у индексов не хранится длина,
34	je .end_search_index ;поэтому, если остался последний - то это нужный	37	je .end_search_index ;поэтому, если остался последний - то это нужный
35		38
36	cmp ecx, [esi + EXT4_EXTENT_IDX.ei_block]	39	cmp ecx, [esi + EXT4_EXTENT_IDX.ei_block]
37	jb .fail	40	jb .fail
38		41
39	cmp ecx, [esi + sizeof.EXT4_EXTENT_IDX + EXT4_EXTENT_IDX.ei_block] ;блок слeдующего индекса	42	cmp ecx, [esi + sizeof.EXT4_EXTENT_IDX + EXT4_EXTENT_IDX.ei_block] ;блок слeдующего индекса
40	jb .end_search_index ;следующий дальше - значит текущий, то что нам нужен	43	jb .end_search_index ;следующий дальше - значит текущий, то что нам нужен
41		44
42	add esi, sizeof.EXT4_EXTENT_IDX	45	add esi, sizeof.EXT4_EXTENT_IDX
43	dec ebx	46	dec ebx
44	jmp @B	47	jmp @B
45		48
46	.end_search_index:	49	.end_search_index:
47	;ebp указывает на нужный extent_idx, считываем следующий блок	50	;ebp указывает на нужный extent_idx, считываем следующий блок
48	mov ebx, [ebp + EXTFS.ext2_temp_block]	51	mov ebx, [ebp + EXTFS.ext2_temp_block]
49	mov eax, [esi + EXT4_EXTENT_IDX.ei_leaf_lo]	52	mov eax, [esi + EXT4_EXTENT_IDX.ei_leaf_lo]
50	call ext2_block_read	53	call ext2_block_read
51	test eax, eax	54	test eax, eax
52	jnz .fail	55	jnz .fail
53	mov esi, ebx	56	mov esi, ebx
54	jmp ext4_block_recursive_search ;рекурсивно прыгаем в начало	57	jmp ext4_block_recursive_search ;рекурсивно прыгаем в начало
55		58
56	.leaf_block: ;листовой блок esi - ext4_extent	59	.leaf_block: ;листовой блок esi - ext4_extent
57	;цикл по экстентам	60	;цикл по экстентам
58	@@:	61	@@:
59	test ebx, ebx	62	test ebx, ebx
60	jz .fail ;ни один узел не подошел - ошибка	63	jz .fail ;ни один узел не подошел - ошибка
61		64
62	mov edx, [esi + EXT4_EXTENT.ee_block]	65	mov edx, [esi + EXT4_EXTENT.ee_block]
63	cmp ecx, edx	66	cmp ecx, edx
64	jb .fail ;если меньше, значит он был в предыдущих блоках -> ошибка	67	jb .fail ;если меньше, значит он был в предыдущих блоках -> ошибка
65		68
66	movzx edi, [esi + EXT4_EXTENT.ee_len]	69	movzx edi, [esi + EXT4_EXTENT.ee_len]
67	add edx, edi	70	add edx, edi
68	cmp ecx, edx	71	cmp ecx, edx
69	jb .end_search_extent ;нашли нужный блок	72	jb .end_search_extent ;нашли нужный блок
70		73
71	add esi, sizeof.EXT4_EXTENT	74	add esi, sizeof.EXT4_EXTENT
72	dec ebx	75	dec ebx
73	jmp @B	76	jmp @B
74		77
75	.end_search_extent:	78	.end_search_extent:
76	mov edx, [esi + EXT4_EXTENT.ee_start_lo]	79	mov edx, [esi + EXT4_EXTENT.ee_start_lo]
77	sub ecx, [esi + EXT4_EXTENT.ee_block] ;разница в ext4 блоках	80	sub ecx, [esi + EXT4_EXTENT.ee_block] ;разница в ext4 блоках
78	add ecx, edx	81	add ecx, edx
79	xor eax, eax	82	xor eax, eax
80	ret	83	ret
81		84
82	.fail:	85	.fail:
83	mov eax, ERROR_FS_FAIL	86	mov eax, ERROR_FS_FAIL
84	ret	87	ret
85		88
86	;---------------------------------------------------------------------	89	;---------------------------------------------------------------------
87	; Frees triply indirect block.	90	; Frees triply indirect block.
88	; Input: eax = triply indirect block.	91	; Input: eax = triply indirect block.
89	; [ebp + EXTFS.ext2_save_inode] = the inode.	92	; [ebp + EXTFS.ext2_save_inode] = the inode.
90	; Output: eax = error code.	93	; Output: eax = error code.
91	;---------------------------------------------------------------------	94	;---------------------------------------------------------------------
92	ext2_inode_free_triply_indirect:	95	ext2_inode_free_triply_indirect:
93	push ebx edx	96	push ebx edx
94		97
95	test eax, eax	98	test eax, eax
96	jz .success	99	jz .success
97	push eax	100	push eax
98	; Read the triple indirect block.	101	; Read the triple indirect block.
99	mov ebx, [ebp + EXTFS.ext2_temp_block]	102	mov ebx, [ebp + EXTFS.ext2_temp_block]
100	call ext2_block_read	103	call ext2_block_read
101	test eax, eax	104	test eax, eax
102	pop eax	105	pop eax
103	jnz .fail	106	jnz .fail
104		107
105	; Free the triple indirect block.	108	; Free the triple indirect block.
106	call ext2_block_free	109	call ext2_block_free
107	test eax, eax	110	test eax, eax
108	jnz .fail	111	jnz .fail
109		112
110	mov edx, ebx	113	mov edx, ebx
111	add edx, [ebp + EXTFS.block_size]	114	add edx, [ebp + EXTFS.block_size]
112		115
113	@@:	116	@@:
114	mov eax, [ebx]	117	mov eax, [ebx]
115	test eax, eax	118	test eax, eax
116	jz .success	119	jz .success
117		120
118	call ext2_inode_free_doubly_indirect	121	call ext2_inode_free_doubly_indirect
119	cmp eax, 1	122	cmp eax, 1
120	je .success	123	je .success
121	cmp eax, 0xFFFFFFFF	124	cmp eax, 0xFFFFFFFF
122	je .fail	125	je .fail
123		126
124	add ebx, 4	127	add ebx, 4
125	cmp ebx, edx	128	cmp ebx, edx
126	jb @B	129	jb @B
127		130
128	.success:	131	.success:
129	xor eax, eax	132	xor eax, eax
130	.ret:	133	.ret:
131	pop edx ebx	134	pop edx ebx
132	ret	135	ret
133		136
134	.fail:	137	.fail:
135	xor eax, eax	138	xor eax, eax
136	not eax	139	not eax
137	jmp .ret	140	jmp .ret
138		141
139	;---------------------------------------------------------------------	142	;---------------------------------------------------------------------
140	; Frees double indirect block.	143	; Frees double indirect block.
141	; Input: eax = double indirect block.	144	; Input: eax = double indirect block.
142	; [ebp + EXTFS.ext2_save_inode] = the inode.	145	; [ebp + EXTFS.ext2_save_inode] = the inode.
143	; Output: eax = error code, 1 implies finished, ~0 implies error	146	; Output: eax = error code, 1 implies finished, ~0 implies error
144	;---------------------------------------------------------------------	147	;---------------------------------------------------------------------
145	ext2_inode_free_doubly_indirect:	148	ext2_inode_free_doubly_indirect:
146	push ebx edx	149	push ebx edx
147		150
148	test eax, eax	151	test eax, eax
149	jz .complete	152	jz .complete
150	push eax	153	push eax
151	; Read the double indirect block.	154	; Read the double indirect block.
152	mov ebx, [ebp + EXTFS.ext2_temp_block]	155	mov ebx, [ebp + EXTFS.ext2_temp_block]
153	call ext2_block_read	156	call ext2_block_read
154	test eax, eax	157	test eax, eax
155	pop eax	158	pop eax
156	jnz .fail	159	jnz .fail
157		160
158	call ext2_block_free	161	call ext2_block_free
159	test eax, eax	162	test eax, eax
160	jnz .fail	163	jnz .fail
161		164
162	mov edx, ebx	165	mov edx, ebx
163	add edx, [ebp + EXTFS.block_size]	166	add edx, [ebp + EXTFS.block_size]
164		167
165	@@:	168	@@:
166	mov eax, [ebx]	169	mov eax, [ebx]
167	test eax, eax	170	test eax, eax
168	jz .complete	171	jz .complete
169		172
170	call ext2_block_free	173	call ext2_block_free
171	test eax, eax	174	test eax, eax
172	jnz .fail	175	jnz .fail
173		176
174	add ebx, 4	177	add ebx, 4
175	cmp ebx, edx	178	cmp ebx, edx
176	jb @B	179	jb @B
177		180
178	.success:	181	.success:
179	xor eax, eax	182	xor eax, eax
180	.ret:	183	.ret:
181	pop edx ebx	184	pop edx ebx
182	ret	185	ret
183		186
184	.complete:	187	.complete:
185	xor eax, eax	188	xor eax, eax
186	inc eax	189	inc eax
187	jmp .ret	190	jmp .ret
188		191
189	.fail:	192	.fail:
190	xor eax, eax	193	xor eax, eax
191	not eax	194	not eax
192	jmp .ret	195	jmp .ret
193		196
194	;---------------------------------------------------------------------	197	;---------------------------------------------------------------------
195	; Frees all indirect blocks.	198	; Frees all indirect blocks.
196	; Input: ebp = pointer to EXTFS.	199	; Input: ebp = pointer to EXTFS.
197	; [ebp + EXTFS.ext2_save_inode] = the inode.	200	; [ebp + EXTFS.ext2_save_inode] = the inode.
198	; Output: eax = error code (0 implies no error)	201	; Output: eax = error code (0 implies no error)
199	;---------------------------------------------------------------------	202	;---------------------------------------------------------------------
200	ext2_inode_free_indirect_blocks:	203	ext2_inode_free_indirect_blocks:
201	push edi	204	push edi
202		205
203	mov edi, [ebp + EXTFS.ext2_save_inode]	206	mov edi, [ebp + EXTFS.ext2_save_inode]
204		207
205	; Free indirect block.	208	; Free indirect block.
206	mov eax, [edi + EXT2_INODE_STRUC.i_block + 12*4]	209	mov eax, [edi + EXT2_INODE_STRUC.i_block + 12*4]
207	test eax, eax	210	test eax, eax
208	jz .success	211	jz .success
209		212
210	call ext2_block_free	213	call ext2_block_free
211	test eax, eax	214	test eax, eax
212	jnz .fail	215	jnz .fail
213		216
214	mov eax, [edi + EXT2_INODE_STRUC.i_block + 13*4]	217	mov eax, [edi + EXT2_INODE_STRUC.i_block + 13*4]
215	call ext2_inode_free_doubly_indirect	218	call ext2_inode_free_doubly_indirect
216	cmp eax, 1	219	cmp eax, 1
217	je .success	220	je .success
218	cmp eax, 0xFFFFFFFF	221	cmp eax, 0xFFFFFFFF
219	je .fail	222	je .fail
220		223
221	mov eax, [edi + EXT2_INODE_STRUC.i_block + 14*4]	224	mov eax, [edi + EXT2_INODE_STRUC.i_block + 14*4]
222	call ext2_inode_free_triply_indirect	225	call ext2_inode_free_triply_indirect
223	test eax, eax	226	test eax, eax
224	jnz .fail	227	jnz .fail
225		228
226	.success:	229	.success:
227	xor eax, eax	230	xor eax, eax
228	.ret:	231	.ret:
229	pop edi	232	pop edi
230	ret	233	ret
231		234
232	.fail:	235	.fail:
233	xor eax, eax	236	xor eax, eax
234	not eax	237	not eax
235	jmp .ret	238	jmp .ret
236		239
237	;---------------------------------------------------------------------	240	;---------------------------------------------------------------------
238	; Allocates block for inode.	241	; Allocates block for inode.
239	; Input: esi = address of inode	242	; Input: esi = address of inode
240	; ebp = pointer to EXTFS.	243	; ebp = pointer to EXTFS.
241	; Output: eax = error code (0 implies no error)	244	; Output: eax = error code (0 implies no error)
242	;---------------------------------------------------------------------	245	;---------------------------------------------------------------------
243	ext2_inode_calloc_block:	246	ext2_inode_calloc_block:
244	push ecx	247	push ecx
245		248
246	; TODO: fix to have correct preference.	249	; TODO: fix to have correct preference.
247	mov eax, EXT2_ROOT_INO	250	mov eax, EXT2_ROOT_INO
248	call ext2_block_calloc	251	call ext2_block_calloc
249	test eax, eax	252	test eax, eax
250	jnz .fail	253	jnz .fail
251		254
252	mov ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]	255	mov ecx, [ebp + EXTFS.superblock + EXT2_SB_STRUC.log_block_size]
253	mov eax, 2	256	mov eax, 2
254	shl eax, cl	257	shl eax, cl
255	add [esi + EXT2_INODE_STRUC.i_blocks], eax	258	add [esi + EXT2_INODE_STRUC.i_blocks], eax
256		259
257	.success:	260	.success:
258	xor eax, eax	261	xor eax, eax
259	.ret:	262	.ret:
260	pop ecx	263	pop ecx
261	ret	264	ret
262		265
263	.fail:	266	.fail:
264	xor eax, eax	267	xor eax, eax
265	not eax	268	not eax
266	jmp .ret	269	jmp .ret
267		270
268	;---------------------------------------------------------------------	271	;---------------------------------------------------------------------
269	; Sets block ID for indirect-addressing inode.	272	; Sets block ID for indirect-addressing inode.
270	; Input: ecx = index of block in inode	273	; Input: ecx = index of block in inode
271	; edi = block ID to set to	274	; edi = block ID to set to
272	; esi = address of inode	275	; esi = address of inode
273	; ebp = pointer to EXTFS.	276	; ebp = pointer to EXTFS.
274	; Output: eax = error code (0 implies no error)	277	; Output: eax = error code (0 implies no error)
275	;---------------------------------------------------------------------	278	;---------------------------------------------------------------------
276	ext2_inode_set_block:	279	ext2_inode_set_block:
277	push ebx ecx edx	280	push ebx ecx edx
278		281
279	; 0 to 11: direct blocks.	282	; 0 to 11: direct blocks.
280	cmp ecx, 12	283	cmp ecx, 12
281	jb .direct_block	284	jb .direct_block
282		285
283	; Indirect blocks	286	; Indirect blocks
284	sub ecx, 12	287	sub ecx, 12
285	cmp ecx, [ebp + EXTFS.count_pointer_in_block]	288	cmp ecx, [ebp + EXTFS.count_pointer_in_block]
286	jb .indirect_block	289	jb .indirect_block
287		290
288	; Double indirect blocks.	291	; Double indirect blocks.
289	sub ecx, [ebp + EXTFS.count_pointer_in_block]	292	sub ecx, [ebp + EXTFS.count_pointer_in_block]
290	cmp ecx, [ebp + EXTFS.count_pointer_in_block_square]	293	cmp ecx, [ebp + EXTFS.count_pointer_in_block_square]
291	jb .double_indirect_block	294	jb .double_indirect_block
292		295
293	; Triple indirect blocks.	296	; Triple indirect blocks.
294	sub ecx, [ebp + EXTFS.count_pointer_in_block_square]	297	sub ecx, [ebp + EXTFS.count_pointer_in_block_square]
295		298
296	; Get triply-indirect block in temp_block.	299	; Get triply-indirect block in temp_block.
297	mov eax, [esi + EXT2_INODE_STRUC.i_block + 14*4]	300	mov eax, [esi + EXT2_INODE_STRUC.i_block + 14*4]
298	test eax, eax	301	test eax, eax
299	jnz @F	302	jnz @F
300		303
301	call ext2_inode_calloc_block	304	call ext2_inode_calloc_block
302	test eax, eax	305	test eax, eax
303	jnz .fail_alloc	306	jnz .fail_alloc
304		307
305	mov [esi + EXT2_INODE_STRUC.i_block + 14*4], ebx	308	mov [esi + EXT2_INODE_STRUC.i_block + 14*4], ebx
306	mov eax, ebx	309	mov eax, ebx
307		310
308	@@:	311	@@:
309	push eax	312	push eax
310	mov ebx, [ebp + EXTFS.ext2_temp_block]	313	mov ebx, [ebp + EXTFS.ext2_temp_block]
311	call ext2_block_read	314	call ext2_block_read
312	test eax, eax	315	test eax, eax
313	jnz .fail_alloc_4	316	jnz .fail_alloc_4
314		317
315	; Get index in triply-indirect block.	318	; Get index in triply-indirect block.
316	xor edx, edx	319	xor edx, edx
317	mov eax, ecx	320	mov eax, ecx
318	div [ebp + EXTFS.count_pointer_in_block_square]	321	div [ebp + EXTFS.count_pointer_in_block_square]
319		322
320	; eax: index in triply-indirect block, edx: index in doubly-indirect block.	323	; eax: index in triply-indirect block, edx: index in doubly-indirect block.
321	lea ecx, [ebx + eax*4]	324	lea ecx, [ebx + eax*4]
322	mov eax, [ebx + eax*4]	325	mov eax, [ebx + eax*4]
323	test eax, eax	326	test eax, eax
324	jnz @F	327	jnz @F
325		328
326	call ext2_inode_calloc_block	329	call ext2_inode_calloc_block
327	test eax, eax	330	test eax, eax
328	jnz .fail_alloc_4	331	jnz .fail_alloc_4
329		332
330	mov [ecx], ebx	333	mov [ecx], ebx
331		334
332	mov eax, [esp]	335	mov eax, [esp]
333	mov ebx, [ebp + EXTFS.ext2_temp_block]	336	mov ebx, [ebp + EXTFS.ext2_temp_block]
334	call ext2_block_write	337	call ext2_block_write
335	test eax, eax	338	test eax, eax
336	jnz .fail_alloc_4	339	jnz .fail_alloc_4
337		340
338	mov eax, [ecx]	341	mov eax, [ecx]
339	@@:	342	@@:
340	mov [esp], eax	343	mov [esp], eax
341	call ext2_block_read	344	call ext2_block_read
342	test eax, eax	345	test eax, eax
343	jnz .fail_alloc_4	346	jnz .fail_alloc_4
344		347
345	mov eax, edx	348	mov eax, edx
346	jmp @F	349	jmp @F
347		350
348	.double_indirect_block:	351	.double_indirect_block:
349	; Get doubly-indirect block.	352	; Get doubly-indirect block.
350	mov eax, [esi + EXT2_INODE_STRUC.i_block + 13*4]	353	mov eax, [esi + EXT2_INODE_STRUC.i_block + 13*4]
351	test eax, eax	354	test eax, eax
352	jnz .double_indirect_present	355	jnz .double_indirect_present
353		356
354	call ext2_inode_calloc_block	357	call ext2_inode_calloc_block
355	test eax, eax	358	test eax, eax
356	jnz .fail_alloc	359	jnz .fail_alloc
357		360
358	mov [esi + EXT2_INODE_STRUC.i_block + 13*4], ebx	361	mov [esi + EXT2_INODE_STRUC.i_block + 13*4], ebx
359	mov eax, ebx	362	mov eax, ebx
360		363
361	.double_indirect_present:	364	.double_indirect_present:
362	; Save block we're at.	365	; Save block we're at.
363	push eax	366	push eax
364		367
365	mov ebx, [ebp + EXTFS.ext2_temp_block]	368	mov ebx, [ebp + EXTFS.ext2_temp_block]
366	call ext2_block_read	369	call ext2_block_read
367	test eax, eax	370	test eax, eax
368	jnz .fail_alloc_4	371	jnz .fail_alloc_4
369		372
370	mov eax, ecx	373	mov eax, ecx
371	@@:	374	@@:
372	xor edx, edx	375	xor edx, edx
373	div [ebp + EXTFS.count_pointer_in_block]	376	div [ebp + EXTFS.count_pointer_in_block]
374		377
375	; eax: index in doubly-indirect block, edx: index in indirect block.	378	; eax: index in doubly-indirect block, edx: index in indirect block.
376	lea ecx, [ebx + edx*4]	379	lea ecx, [ebx + edx*4]
377	push ecx	380	push ecx
378		381
379	lea ecx, [ebx + eax*4]	382	lea ecx, [ebx + eax*4]
380	cmp dword[ecx], 0	383	cmp dword[ecx], 0
381	jne @F	384	jne @F
382		385
383	call ext2_inode_calloc_block	386	call ext2_inode_calloc_block
384	test eax, eax	387	test eax, eax
385	jnz .fail_alloc_8	388	jnz .fail_alloc_8
386		389
387	mov [ecx], ebx	390	mov [ecx], ebx
388		391
389	mov eax, [esp + 4]	392	mov eax, [esp + 4]
390	mov ebx, [ebp + EXTFS.ext2_temp_block]	393	mov ebx, [ebp + EXTFS.ext2_temp_block]
391	call ext2_block_write	394	call ext2_block_write
392	test eax, eax	395	test eax, eax
393	jnz .fail_alloc_8	396	jnz .fail_alloc_8
394		397
395	@@:	398	@@:
396	mov eax, [ecx]	399	mov eax, [ecx]
397	push eax	400	push eax
398	call ext2_block_read	401	call ext2_block_read
399	test eax, eax	402	test eax, eax
400	jnz .fail_alloc_12	403	jnz .fail_alloc_12
401		404
402	pop eax	405	pop eax
403	pop ecx	406	pop ecx
404	mov [ecx], edi	407	mov [ecx], edi
405	call ext2_block_write	408	call ext2_block_write
406		409
407	add esp, 4	410	add esp, 4
408	jmp .return	411	jmp .return
409		412
410	.indirect_block:	413	.indirect_block:
411	; Get index of indirect block.	414	; Get index of indirect block.
412	mov eax, [esi + EXT2_INODE_STRUC.i_block + 12*4]	415	mov eax, [esi + EXT2_INODE_STRUC.i_block + 12*4]
413	test eax, eax	416	test eax, eax
414	jnz @F	417	jnz @F
415		418
416	call ext2_inode_calloc_block	419	call ext2_inode_calloc_block
417	test eax, eax	420	test eax, eax
418	jnz .fail_alloc	421	jnz .fail_alloc
419		422
420	mov [esi + EXT2_INODE_STRUC.i_block + 12*4], ebx	423	mov [esi + EXT2_INODE_STRUC.i_block + 12*4], ebx
421	mov eax, ebx	424	mov eax, ebx
422		425
423	@@:	426	@@:
424	push eax	427	push eax
425	mov ebx, [ebp + EXTFS.ext2_temp_block]	428	mov ebx, [ebp + EXTFS.ext2_temp_block]
426	call ext2_block_read	429	call ext2_block_read
427	test eax, eax	430	test eax, eax
428	jnz .fail_alloc_4	431	jnz .fail_alloc_4
429		432
430	; Get the block ID.	433	; Get the block ID.
431	mov [ebx + ecx*4], edi	434	mov [ebx + ecx*4], edi
432	pop eax	435	pop eax
433	call ext2_block_write	436	call ext2_block_write
434	jmp .return	437	jmp .return
435		438
436	.direct_block:	439	.direct_block:
437	mov [esi + EXT2_INODE_STRUC.i_block + ecx*4], edi	440	mov [esi + EXT2_INODE_STRUC.i_block + ecx*4], edi
438	xor eax, eax	441	xor eax, eax
439		442
440	.return:	443	.return:
441	pop edx ecx ebx	444	pop edx ecx ebx
442	ret	445	ret
443		446
444	.fail_alloc:	447	.fail_alloc:
445	xor eax, eax	448	xor eax, eax
446	not eax	449	not eax
447	jmp .return	450	jmp .return
448		451
449	.fail_alloc_12:	452	.fail_alloc_12:
450	add esp, 4	453	add esp, 4
451	.fail_alloc_8:	454	.fail_alloc_8:
452	add esp, 4	455	add esp, 4
453	.fail_alloc_4:	456	.fail_alloc_4:
454	add esp, 4	457	add esp, 4
455	jmp .fail_alloc	458	jmp .fail_alloc
456		459
457	;---------------------------------------------------------------------	460	;---------------------------------------------------------------------
458	; Receives block ID from indirect-addressing inode.	461	; Receives block ID from indirect-addressing inode.
459	; Input: ecx = index of block in inode	462	; Input: ecx = index of block in inode
460	; esi = address of inode	463	; esi = address of inode
461	; ebp = pointer to EXTFS	464	; ebp = pointer to EXTFS
462	; Output: ecx = block ID, if successful	465	; Output: ecx = block ID, if successful
463	; eax = error code (0 implies no error)	466	; eax = error code (0 implies no error)
464	;---------------------------------------------------------------------	467	;---------------------------------------------------------------------
465	ext2_inode_get_block:	468	ext2_inode_get_block:
466	; If inode is extent-based, use ext4_block_recursive_search.	469	; If inode is extent-based, use ext4_block_recursive_search.
467	test [esi + EXT2_INODE_STRUC.i_flags], EXT2_EXTENTS_FL	470	test [esi + EXT2_INODE_STRUC.i_flags], EXT2_EXTENTS_FL
468	jz @F	471	jz @F
469		472
470	pushad	473	pushad
471		474
472	; Get extent header in EBP.	475	; Get extent header in EBP.
473	add esi, EXT2_INODE_STRUC.i_block	476	add esi, EXT2_INODE_STRUC.i_block
474	call ext4_block_recursive_search	477	call ext4_block_recursive_search
475	mov PUSHAD_ECX, ecx	478	mov PUSHAD_ECX, ecx
476	mov PUSHAD_EAX, eax	479	mov PUSHAD_EAX, eax
477		480
478	popad	481	popad
479	ret	482	ret
480		483
481	@@:	484	@@:
482	; 0 to 11: direct blocks.	485	; 0 to 11: direct blocks.
483	cmp ecx, 12	486	cmp ecx, 12
484	jb .get_direct_block	487	jb .get_direct_block
485		488
486	; Indirect blocks	489	; Indirect blocks
487	sub ecx, 12	490	sub ecx, 12
488	cmp ecx, [ebp + EXTFS.count_pointer_in_block]	491	cmp ecx, [ebp + EXTFS.count_pointer_in_block]
489	jb .get_indirect_block	492	jb .get_indirect_block
490		493
491	; Double indirect blocks.	494	; Double indirect blocks.
492	sub ecx, [ebp + EXTFS.count_pointer_in_block]	495	sub ecx, [ebp + EXTFS.count_pointer_in_block]
493	cmp ecx, [ebp + EXTFS.count_pointer_in_block_square]	496	cmp ecx, [ebp + EXTFS.count_pointer_in_block_square]
494	jb .get_double_indirect_block	497	jb .get_double_indirect_block
495		498
496	; Triple indirect blocks.	499	; Triple indirect blocks.
497	sub ecx, [ebp + EXTFS.count_pointer_in_block_square]	500	sub ecx, [ebp + EXTFS.count_pointer_in_block_square]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ext2/inode.inc – Rev 4066 → 4850