kolibrios/kernel/branches/Kolibri-acpi/fs/ext2.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;   02.02.2010  turbanoff  - support 70.5                      ;;
;;   23.01.2010  turbanoff  - support 70.0 70.1                 ;;
;;   21.06.2013  yogev_ezra - Translate Russian comments        ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision$

EXT2_BAD_INO         = 1
EXT2_ROOT_INO        = 2
EXT2_ACL_IDX_INO     = 3
EXT2_ACL_DATA_INO    = 4
EXT2_BOOT_LOADER_INO = 5
EXT2_UNDEL_DIR_INO   = 6

;RUS: флаги, указываемые в inode файла   ;ENG: flags specified in file inode
EXT2_S_IFREG         = 0x8000
EXT2_S_IFDIR         = 0x4000
EXT2_S_IFMT          = 0xF000 ;RUS: маска для типа файла  ;ENG: mask for file type

;RUS: флаги, указываемые в linked list родительской папки
;ENG: flags specified in linked list of parent folder
EXT2_FT_REG_FILE     = 1     ;RUS: это файл, запись в родительском каталоге
                             ;ENG: this is a file, record in parent catalog
EXT2_FT_DIR          = 2     ;RUS: это папка   ;ENG: this is a folder

;RUS: флаги используемые KolibriOS   ;ENG: flags used by KolibriOS
FS_FT_HIDDEN         = 2
FS_FT_DIR            = 0x10  ;RUS: это папка      ;ENG: this is a folder
FS_FT_ASCII          = 0     ;RUS: имя в ascii    ;ENG: name in ASCII
FS_FT_UNICODE        = 1     ;RUS: имя в unicode  ;ENG: name in UNICODE

EXT2_FEATURE_INCOMPAT_FILETYPE = 0x0002 ;RUS: тип файла должен указываться в директории
                                        ;ENG: file type must be specified in the folder
EXT4_FEATURE_INCOMPAT_EXTENTS  = 0x0040 ;RUS: экстенты   ;ENG: extents
EXT4_FEATURE_INCOMPAT_FLEX_BG  = 0x0200 ;RUS: гибкие группы блоков   ;ENG: flexible block groups

;RUS: реализованные ext[234] features   ;ENG: implemented ext[234] features
EXT4_FEATURE_INCOMPAT_SUPP = EXT2_FEATURE_INCOMPAT_FILETYPE \
        or      EXT4_FEATURE_INCOMPAT_EXTENTS \
                or EXT4_FEATURE_INCOMPAT_FLEX_BG

;RUS: флаги, указываемые для inode в i_flags   ;ENG: flags specified for inode in i_flags
EXT2_EXTENTS_FL      = 0x00080000

struct  EXT2_INODE_STRUC
        i_mode          dw ?
        i_uid           dw ?
        i_size          dd ?
        i_atime         dd ?
        i_ctime         dd ?
        i_mtime         dd ?
        i_dtime         dd ?
        i_gid           dw ?
        i_links_count   dw ?
        i_blocks        dd ?
        i_flags         dd ?
        i_osd1          dd ?
        i_block         rd 15
        i_generation    dd ?
        i_file_acl      dd ?
        i_dir_acl       dd ?
        i_faddr         dd ?
        i_osd2          dd ? ; 1..12
ends

struct  EXT2_DIR_STRUC
        inode           dd ?
        rec_len         dw ?
        name_len        db ?
        file_type       db ?
        name            db ? ; 0..255
ends

struct  EXT2_BLOCK_GROUP_DESC
        block_bitmap            dd ? ;+0
        inode_bitmap            dd ? ;+4
        inode_table             dd ? ;+8
        free_blocks_count       dw ? ;+12
        free_inodes_count       dw ? ;+14
        used_dirs_count         dw ? ;+16
        pad                     dw ? ;+18
        reserved                rb 12;+20
ends

struct  EXT2_SB_STRUC
        inodes_count            dd ? ;+0
        blocks_count            dd ? ;+4
        r_block_count           dd ? ;+8
        free_block_count        dd ? ;+12
        free_inodes_count       dd ? ;+16
        first_data_block        dd ? ;+20
        log_block_size          dd ? ;+24
        log_frag_size           dd ? ;+28
        blocks_per_group        dd ? ;+32
        frags_per_group         dd ? ;+36
        inodes_per_group        dd ? ;+40
        mtime                   dd ? ;+44
        wtime                   dd ? ;+48
        mnt_count               dw ? ;+52
        max_mnt_count           dw ? ;+54
        magic                   dw ? ;+56
        state                   dw ? ;+58
        errors                  dw ? ;+60
        minor_rev_level         dw ? ;+62
        lastcheck               dd ? ;+64
        check_intervals         dd ? ;+68
        creator_os              dd ? ;+72
        rev_level               dd ? ;+76
        def_resuid              dw ? ;+80
        def_resgid              dw ? ;+82
        first_ino               dd ? ;+84
        inode_size              dw ? ;+88
        block_group_nr          dw ? ;+90
        feature_compat          dd ? ;+92
        feature_incompat        dd ? ;+96
        feature_ro_compat       dd ? ;+100
        uuid                    rb 16 ;+104
        volume_name             rb 16 ;+120
        last_mounted            rb 64 ;+136
        algo_bitmap             dd ? ;+200
        prealloc_blocks         db ? ;+204
        preallock_dir_blocks    db ? ;+205
        reserved_gdt_blocks     dw ? ;+206
        journal_uuid            rb 16 ;+208
        journal_inum            dd ? ;+224
        journal_dev             dd ? ;+228
        last_orphan             dd ? ;+232
        hash_seed               rd 4 ;+236
        def_hash_version        db ? ;+252
                                rb 3 ;+253 reserved
        default_mount_options   dd ? ;+256
        first_meta_bg           dd ? ;+260
        mkfs_time               dd ? ;+264
        jnl_blocks              rd 17 ;+268
        blocks_count_hi         dd ? ;+336
        r_blocks_count_hi       dd ? ;+340
        free_blocks_count_hi    dd ? ;+344
        min_extra_isize         dw ? ;+348
        want_extra_isize        dw ? ;+350
        flags                   dd ? ;+352
        raid_stride             dw ? ;+356
        mmp_interval            dw ? ;+358
        mmp_block               dq ? ;+360
        raid_stripe_width       dd ? ;+368
        log_groups_per_flex     db ? ;+372
ends

struct EXT4_EXTENT_HEADER       ;RUS: заголовок блока экстентов/индексов
        eh_magic        dw ?    ;RUS: в текущей реализации ext4 должно быть 0xF30A
        eh_entries      dw ?    ;RUS: количество экстентов/индексов в блоке
        eh_max          dw ?    ;RUS: max количество (используется при записи)
        eh_depth        dw ?    ;RUS: глубина дерева (0, если это блок экстентов)
        eh_generation   dd ?    ;???
ends

struct EXT4_EXTENT              ;RUS: экстент            ;ENG: extent
        ee_block        dd ?    ;RUS: номер ext4 блока   ;ENG: number of ext4 block
        ee_len          dw ?    ;RUS: длина экстента     ;ENG: extent length
        ee_start_hi     dw ?    ;RUS: старшие 16 бит 48-битного адреса (пока не используются в KOS)
                                ;ENG: upper 16 bits of the 48-bit address (not used in KolibriOS yet)
        ee_start_lo     dd ?    ;RUS: младшие 32 бита 48-битного адреса
                                ;ENG: lower 32 bits of the 48-bit address
ends

struct EXT4_EXTENT_IDX          ;RUS: индекс - указатель на блок с экстентами/индексами
                                ;ENG: index - pointer to block of extents/indexes
        ei_block        dd ?    ;RUS: номер ext4 блока   ;ENG: number of ext4 block
        ei_leaf_lo      dd ?    ;RUS: младшие 32 бит 48-битного адреса
                                ;ENG: lower 32 bits of the 48-bit address
        ei_leaf_hi      dw ?    ;RUS: старшие 16 бит 48-битного адреса (пока не используются в KOS)
                                ;ENG: upper 16 bits of the 48-bit address (not used in KolibriOS yet)
        ei_unused       dw ?    ;RUS: зарезервировано   ;ENG: reserved
ends

struct EXTFS PARTITION
    Lock                           MUTEX
    log_block_size                 dd ?
    block_size                     dd ?
    count_block_in_block           dd ?
    blocks_per_group               dd ?
    global_desc_table              dd ?
    root_inode                     dd ?   ; pointer to root inode in memory
    inode_size                     dd ?
    count_pointer_in_block         dd ?   ;  block_size / 4
    count_pointer_in_block_square  dd ?   ; (block_size / 4)**2
    ext2_save_block                dd ?   ;RUS: блок на глобальную 1 процедуру   ;ENG: block for 1 global procedure
    ext2_temp_block                dd ?   ;RUS: блок для мелких процедур         ;ENG: block for small procedures
    ext2_save_inode                dd ?   ;RUS: inode на глобальную процедуру    ;ENG: inode for global procedure
    ext2_temp_inode                dd ?   ;RUS: inode для мелких процедур        ;ENG: inode for small procedures
    groups_count                   dd ?
    superblock                     rd 512/4
ends

iglobal
align 4
ext2_user_functions:
        dd      ext2_free
        dd      (ext2_user_functions_end - ext2_user_functions - 4) / 4
        dd      ext2_Read
        dd      ext2_ReadFolder
        dd      ext2_Rewrite
        dd      ext2_Write
        dd      ext2_SetFileEnd
        dd      ext2_GetFileInfo
        dd      ext2_SetFileInfo
        dd      0
        dd      ext2_Delete
        dd      ext2_CreateFolder
ext2_user_functions_end:
endg

proc ext2_create_partition
        push    ebx

        mov     eax, 2                  ;superblock start at 1024b
        add     ebx, 512        ; get pointer to fs-specific buffer
        call    fs_read32_sys

        cmp     [ebx + EXT2_SB_STRUC.log_block_size], 3  ;0,1,2,3
        ja      .no
        cmp     [ebx + EXT2_SB_STRUC.magic], 0xEF53
        jne     .no
        cmp     [ebx + EXT2_SB_STRUC.state], 1        ;EXT_VALID_FS=1
        jne     .no
        cmp     [ebx + EXT2_SB_STRUC.inodes_per_group], 0
        je      .no
        
        mov     eax, [ebx + EXT2_SB_STRUC.feature_incompat]
        test    eax, EXT2_FEATURE_INCOMPAT_FILETYPE
        jz      .no
        test    eax, not EXT4_FEATURE_INCOMPAT_SUPP
        jz      ext2_setup

   .no:
    ; No, this superblock isn't EXT2
        pop     ebx
        xor     eax, eax
        ret

    ; OK, this is correct EXT2 superblock
ext2_setup:
        movi    eax, sizeof.EXTFS
        call    malloc
        test    eax, eax
        jz      ext2_create_partition.no

        mov     ecx, dword [ebp+PARTITION.FirstSector]
        mov     dword [eax+EXTFS.FirstSector], ecx
        mov     ecx, dword [ebp+PARTITION.FirstSector+4]
        mov     dword [eax+EXTFS.FirstSector+4], ecx
        mov     ecx, dword [ebp+PARTITION.Length]
        mov     dword [eax+EXTFS.Length], ecx
        mov     ecx, dword [ebp+PARTITION.Length+4]
        mov     dword [eax+EXTFS.Length+4], ecx
        mov     ecx, [ebp+PARTITION.Disk]
        mov     [eax+EXTFS.Disk], ecx
        mov     [eax+EXTFS.FSUserFunctions], ext2_user_functions
        push    ebp esi edi
        mov     ebp, eax
        lea     ecx, [eax+EXTFS.Lock]
        call    mutex_init

        mov     esi, ebx
        lea     edi, [ebp+EXTFS.superblock]
        mov     ecx, 512/4
        rep movsd                                       ; copy sb to reserved mem

        mov     eax, [ebx + EXT2_SB_STRUC.blocks_count]
        sub     eax, [ebx + EXT2_SB_STRUC.first_data_block]
        dec     eax
        xor     edx, edx
        div     [ebx + EXT2_SB_STRUC.blocks_per_group]
        inc     eax
        mov     [ebp+EXTFS.groups_count], eax

        mov     ecx, [ebx + EXT2_SB_STRUC.log_block_size]
        inc     ecx
        mov     [ebp+EXTFS.log_block_size], ecx    ; 1, 2, 3, 4   equ 1kb, 2kb, 4kb, 8kb

        mov     eax, 1
        shl     eax, cl
        mov     [ebp+EXTFS.count_block_in_block], eax

        shl     eax, 7
        mov     [ebp+EXTFS.count_pointer_in_block], eax
        mov     edx, eax   ;RUS: потом еще квадрат найдем   ;ENG: we'll find a square later

        shl     eax, 2
        mov     [ebp+EXTFS.block_size], eax

        push    eax eax                                 ; 2 kernel_alloc

        mov     eax, edx
        mul     edx
        mov     [ebp+EXTFS.count_pointer_in_block_square], eax

        call    kernel_alloc
        mov     [ebp+EXTFS.ext2_save_block], eax        ; and for temp block
        call    kernel_alloc
        mov     [ebp+EXTFS.ext2_temp_block], eax        ; and for get_inode proc

        movzx   eax, word [ebx + EXT2_SB_STRUC.inode_size]
        mov     ecx, [ebx + EXT2_SB_STRUC.blocks_per_group]

        mov     [ebp+EXTFS.inode_size], eax
        mov     [ebp+EXTFS.blocks_per_group], ecx

        push    eax eax eax                             ;3 kernel_alloc
        call    kernel_alloc
        mov     [ebp+EXTFS.ext2_save_inode], eax
        call    kernel_alloc
        mov     [ebp+EXTFS.ext2_temp_inode], eax
        call    kernel_alloc
        mov     [ebp+EXTFS.root_inode], eax

        mov     ebx, eax
        mov     eax, EXT2_ROOT_INO
        call    ext2_get_inode                          ; read root inode

        mov     eax, ebp        ; return pointer to EXTFS
        pop     edi esi ebp ebx
        ret
endp

proc ext2_free
        push    ebp
        xchg    ebp, eax
        stdcall kernel_free, [ebp+EXTFS.ext2_save_block]
        stdcall kernel_free, [ebp+EXTFS.ext2_temp_block]
        stdcall kernel_free, [ebp+EXTFS.ext2_save_inode]
        stdcall kernel_free, [ebp+EXTFS.ext2_temp_inode]
        stdcall kernel_free, [ebp+EXTFS.root_inode]
        xchg    ebp, eax
        call    free
        pop     ebp
        ret
endp

proc ext2_lock
        lea     ecx, [ebp+EXTFS.Lock]
        jmp     mutex_lock
endp

proc ext2_unlock
        lea     ecx, [ebp+EXTFS.Lock]
        jmp     mutex_unlock
endp

;==================================================================
;read ext2 block form FS to memory
;in:  eax = i_block (address of block in ext2 terms)
;     ebx = pointer to return memory
;     ebp = pointer to EXTFS
;out: eax - error code (0 = no_error)
ext2_get_block:
        push    ebx ecx
        mov     ecx, [ebp+EXTFS.log_block_size]
        shl     eax, cl
        mov     ecx, eax
        push    [ebp+EXTFS.count_block_in_block]
    @@:
        mov     eax, ecx
        call    fs_read32_sys
        test    eax, eax
        jnz     .fail
        inc     ecx
        add     ebx, 512
        dec     dword [esp]
        jnz     @B
        pop     ecx
        xor     eax, eax
    @@:
        pop     ecx ebx
        ret
    .fail:
        mov     eax, ERROR_DEVICE
        jmp     @B
        

;===================================================================
;RUS: получает номер блока из extent inode                    ;ENG: receives block number from extent inode
;RUS: in:  ecx = номер блока по порядку                       ;ENG: in:  ecx = consecutive block number
;RUS:      esi = адрес extent header`а                        ;ENG:      esi = address of extent header
;RUS:      ebp = указатель на структуру EXTFS                 ;ENG:      ebp = pointer to EXTFS
;RUS: out: ecx - адрес очередного блока в случае успеха       ;ENG: out: ecx - address of next block, if successful
;RUS:      eax - номер ошибки (если равно 0, то ошибки нет)   ;ENG:      eax - error number (0 - 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_get_block
        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

;===================================================================
;получает адрес ext2 блока из inode с определнным номером
;RUS: in:  ecx = номер блока в inode (0..)   ;ENG: in:  ecx = number of block in inode (0..)
;RUS:      esi = адрес inode                 ;ENG:      esi = inode address
;RUS:      ebp = указатель на структуру EXTFS;ENG:      ebp = pointer to EXTFS
;RUS: out: ecx = адрес очередного блока      ;ENG: out: ecx = next block address
;RUS:      eax - error code                  ;ENG:      eax - error code
ext2_get_inode_block:
        test    [esi + EXT2_INODE_STRUC.i_flags], EXT2_EXTENTS_FL
        jz      @F

        pushad
        add     esi, EXT2_INODE_STRUC.i_block             ;esi - extent_header
        call    ext4_block_recursive_search
        mov     PUSHAD_ECX, ecx
        mov     PUSHAD_EAX, eax
        popad
        ret

    @@:
        cmp     ecx, 12                                         ; 0..11 - direct block address
        jb      .get_direct_block

        sub     ecx, 12
        cmp     ecx, [ebp+EXTFS.count_pointer_in_block]         ; 12.. - indirect blocks
        jb      .get_indirect_block

        sub     ecx, [ebp+EXTFS.count_pointer_in_block]
        cmp     ecx, [ebp+EXTFS.count_pointer_in_block_square]
        jb      .get_double_indirect_block

        sub     ecx, [ebp+EXTFS.count_pointer_in_block_square]
    ;triple indirect block
        push    edx ebx

        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 14*4]
        mov     ebx, [ebp+EXTFS.ext2_temp_block]
        call    ext2_get_block
        test    eax, eax
        jnz     .fail

        xor     edx, edx
        mov     eax, ecx
        div     [ebp+EXTFS.count_pointer_in_block_square]

    ;RUS: eax - номер в полученном блоке   edx - номер дальше
    ;ENG: eax - current block number, edx - next block number
        mov     eax, [ebx + eax*4]
        call    ext2_get_block
        test    eax, eax
        jnz     .fail

        mov     eax, edx
        jmp     @F

    .get_double_indirect_block:
        push    edx ebx

        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 13*4]
        mov     ebx, [ebp+EXTFS.ext2_temp_block]
        call    ext2_get_block
        test    eax, eax
        jnz     .fail

        mov     eax, ecx
    @@:
        xor     edx, edx
        div     [ebp+EXTFS.count_pointer_in_block]

        mov     eax, [ebx + eax*4]
        call    ext2_get_block
        test    eax, eax
        jnz     .fail

        mov     ecx, [ebx + edx*4]
    .fail:
        pop     ebx edx
        ret

    .get_indirect_block:
        push    ebx
        mov     eax, [esi + EXT2_INODE_STRUC.i_block + 12*4]
        mov     ebx, [ebp+EXTFS.ext2_temp_block]
        call    ext2_get_block
        test    eax, eax
        jnz     @F          ;RUS: если не было ошибки   ;ENG: if there was no error

        mov     ecx, [ebx + ecx*4]   ;RUS: заносим результат   ;ENG: ???
    @@:
        pop     ebx
        ret

    .get_direct_block:
        mov     ecx, [esi + EXT2_INODE_STRUC.i_block + ecx*4]
        xor     eax, eax
        ret

;===================================================================
;get content inode by num
;in:  eax = inode_num
;     ebx = address of inode content
;     ebp = pointer to EXTFS
;out: eax - error code
ext2_get_inode:
        pushad
        mov     edi, ebx   ;сохраним адрес inode
        dec     eax
        xor     edx, edx
        
        div     [ebp + EXT2_SB_STRUC.inodes_per_group + EXTFS.superblock]

        push    edx                             ;locale num in group

        mov     edx, 32
        mul     edx                             ; address block_group in global_desc_table

        ;RUS: в eax - смещение группы с inode-ом относительно начала глобальной дескрипторной таблицы
        ;RUS: найдем блок в котором он находится
        ;ENG: in eax - inode group offset relative to global descriptor table start
        ;ENG: let's find the block this inode is in
        div     [ebp+EXTFS.block_size]
        add     eax, [ebp + EXT2_SB_STRUC.first_data_block + EXTFS.superblock]
        inc     eax
        mov     ebx, [ebp+EXTFS.ext2_temp_block]
        call    ext2_get_block
        test    eax, eax
        jnz     .fail

        add     ebx, edx   ;RUS: локальный номер в блоке   ;ENG: local number inside block
        mov     eax, [ebx + EXT2_BLOCK_GROUP_DESC.inode_table]   ;RUS: номер блока - в терминах ext2
                                                                 ;ENG: block number - in ext2 terms
        mov     ecx, [ebp+EXTFS.log_block_size]
        shl     eax, cl
        ;RUS: eax - указывает на таблицу inode-ов на hdd   ;ENG: eax - points to inode table on HDD
        mov     esi, eax   ;RUS: сохраним его пока в esi   ;ENG: let's save it in esi for now

        ;RUS: прибавим локальный адрес inode-а   ;ENG: add local address of inode
        pop     eax                             ; index
        mov     ecx, [ebp+EXTFS.inode_size]
        mul     ecx                             ; (index * inode_size)
                ;RUS: поделим на размер блока        ;ENG: divide by block size
        mov     ecx, eax
        and     ecx, 512 - 1
        shrd    eax, edx, 9

        add     eax, esi   ;RUS: нашли адрес блока для чтения   ;ENG: found block address to read
        mov     ebx, [ebp+EXTFS.ext2_temp_block]
        call    fs_read32_sys
        test    eax, eax
        jnz     .fail

        mov     esi, ecx         ;RUS: добавим "остаток"   ;ENG: add the "remainder"
        mov     ecx, [ebp+EXTFS.inode_size]
        add     esi, ebx         ;RUS: к адресу            ;ENG: to the address
        rep movsb                ;RUS: копируем inode      ;ENG: copy inode
        xor     eax, eax
    .fail:
        mov     PUSHAD_EAX, eax
        popad
        ret

;----------------------------------------------------------------
; ext2_ReadFolder - EXT2FS implementation of reading a folder
; in:  ebp = pointer to EXTFS structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
ext2_ReadFolder:
        call    ext2_lock
        cmp     byte [esi], 0
        jz      .root_folder

        push    ebx
        stdcall ext2_find_lfn, [esp+4+4]    ;вернет в esi адрес inode
        pop     ebx
        test    eax, eax
        jnz     .error_ret
        test    [esi + EXT2_INODE_STRUC.i_mode], EXT2_S_IFDIR
        jz      .error_not_found
        jmp     @F

    .root_folder:
        mov     esi, [ebp+EXTFS.root_inode]
        test    [esi + EXT2_INODE_STRUC.i_mode], EXT2_S_IFDIR
        jz      .error_root
        ;придется копировать inode
        mov     edi, [ebp+EXTFS.ext2_save_inode]
        mov     ecx, [ebp+EXTFS.inode_size]
        shr     ecx, 2
        push    edi
        rep movsd
        pop     esi
    @@:
        cmp     [esi + EXT2_INODE_STRUC.i_size], 0 ;папка пуста
        je      .error_empty_dir
        
        mov     edx, [ebx + 16]
        push    edx      ;адрес результата              [edi + 28]
        push    0        ;конец очередного блока папки   [edi + 24]
        push    dword [ebx +12];сколько файлов нужно прочитать [edi + 20]
        push    dword [ebx + 4];первый "нужный" файл           [edi + 16]
        push    dword [ebx + 8];флаги                        [edi + 12]
        push    0       ;[EXT2_read_in_folder]     [edi + 8]
        push    0       ;[EXT2_files_in_folder]    [edi + 4]
        push    0       ;номер блока по порядку    [edi]

        mov     edi, edx
        mov     ecx, 32/4
        rep stosd                               ; fill header zero
        
        mov     edi, esp                        ; edi - указатель на локальные переменные
        add     edx, 32                         ; edx = current mem for return

        xor     ecx, ecx                        ; получим номер первого блока
        call    ext2_get_inode_block
        test    eax, eax
        jnz     .error_get_block

        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.ext2_save_block]
        call    ext2_get_block                  ; и считываем блок с hdd
        test    eax, eax
        jnz     .error_get_block

        mov     eax, ebx                         ; ebx = current dir record
        add     eax, [ebp+EXTFS.block_size]
        mov     [edi + 24], eax               ; запомним конец очередного блока

        mov     ecx, [edi + 16]                        ; ecx = first wanted (flags ommited)

    .find_wanted_start:
        jecxz   .find_wanted_end
    .find_wanted_cycle:
        cmp     [ebx + EXT2_DIR_STRUC.inode], 0     ; if (inode = 0) => not used
        jz      @F
        inc     dword [edi + 4]                        ; EXT2_files_in_folder
        dec     ecx
    @@:
        movzx   eax, [ebx + EXT2_DIR_STRUC.rec_len]

        cmp     eax, 12                                 ; минимальная длина записи
        jb      .error_bad_len
        test    eax, 0x3                                ; длина записи должна делиться на 4
        jnz     .error_bad_len

        sub     [esi + EXT2_INODE_STRUC.i_size], eax    ;вычитаем напрямую из структуры inode
        add     ebx, eax                                ; к следующей записи
        cmp     ebx, [edi + 24]                        ; сравниваем с концом блока
        jb      .find_wanted_start

        push    .find_wanted_start
   .end_block:                                              ;вылетели из цикла
        cmp     [esi + EXT2_INODE_STRUC.i_size], 0
        jle     .end_dir

        inc     dword [edi]                                 ;получаем новый блок
        push    ecx
        mov     ecx, [edi]
        call    ext2_get_inode_block
        test    eax, eax
        jnz     .error_get_block

        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.ext2_save_block]
        call    ext2_get_block
        test    eax, eax
        jnz     .error_get_block

        pop     ecx
        mov     eax, ebx
        add     eax, [ebp+EXTFS.block_size]
        mov     [edi + 24], eax                            ;запомним конец блока
        ret                                                 ; опять в цикл

    .wanted_end:
        loop    .find_wanted_cycle                          ; ecx 0 => -1 нужно посчитать сколько файлов

    ;дошли до первого "нужного" файла
    .find_wanted_end:
        mov     ecx, [edi + 20]
    .wanted_start:                                          ; ищем first_wanted+count
        jecxz   .wanted_end
        cmp     [ebx + EXT2_DIR_STRUC.inode], 0         ; if (inode = 0) => not used
        jz      .empty_rec
        inc     dword [edi + 8]
        inc     dword [edi + 4]

        push    edi ecx
        mov     edi, edx                            ;обнуляем место под очереное имя файла/папки
        xor     eax, eax
        mov     ecx, 40 / 4
        rep stosd
        pop     ecx edi

        push    ebx edi edx
        mov     eax, [ebx + EXT2_DIR_STRUC.inode]             ;получим дочерний inode
        mov     ebx, [ebp+EXTFS.ext2_temp_inode]
        call    ext2_get_inode
        test    eax, eax
        jnz     .error_read_subinode

        lea     edi, [edx + 8]

        mov     eax, [ebx + EXT2_INODE_STRUC.i_ctime]           ; переведем время в ntfs формат
        xor     edx, edx
        add     eax, 3054539008                                     ;(369 * 365 + 89) * 24 * 3600
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        mov     eax, [ebx + EXT2_INODE_STRUC.i_atime]
        xor     edx, edx
        add     eax, 3054539008
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        mov     eax, [ebx + EXT2_INODE_STRUC.i_mtime]
        xor     edx, edx
        add     eax, 3054539008
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        pop     edx                                                 ; пока достаем только буфер
        test    [ebx + EXT2_INODE_STRUC.i_mode], EXT2_S_IFDIR   ; для папки размер
        jnz     @F                                                  ; не возвращаем

        mov     eax, [ebx + EXT2_INODE_STRUC.i_size]            ;low size
        stosd
        mov     eax, [ebx + EXT2_INODE_STRUC.i_dir_acl]         ;high size
        stosd
        xor     dword [edx], FS_FT_DIR                              ;помечаем, что это файл(2 раза xor)
    @@:
        xor     dword [edx], FS_FT_DIR                              ;помечаем, что это файл

        ;теперь скопируем имя, сконвертировав из UTF-8 в CP866
        push    ecx esi ;edi уже сохранен в стеке
        mov     esi, [esp+12]
        movzx   ecx, [esi + EXT2_DIR_STRUC.name_len]
        lea     edi, [edx + 40]
        lea     esi, [esi + EXT2_DIR_STRUC.name]
        call    utf8_to_cp866
        and     byte [edi], 0
        pop     esi ecx edi ebx

        cmp     byte [edx + 40], '.'                    ; в linux файл, начинающийся с точки - скрытый
        jne     @F
        or      dword [edx], FS_FT_HIDDEN
    @@:

        add     edx, 40 + 264                           ; go to next record
        dec     ecx                                     ; если запись пустая ecx не надо уменьшать
    .empty_rec:
        movzx   eax, [ebx + EXT2_DIR_STRUC.rec_len]
        cmp     eax, 12                                 ; минимальная длина записи
        jb      .error_bad_len
        test    eax, 0x3                                ; длина записи должна делиться на 4
        jnz     .error_bad_len

        sub     [esi + EXT2_INODE_STRUC.i_size], eax    ;вычитаем напрямую из структуры inode
        add     ebx, eax
        cmp     ebx, [edi + 24]                         ;дошли ли до конца блока?
        jb      .wanted_start

        push    .wanted_start                           ; дошли 
        jmp     .end_block

    .end_dir:   ;конец папки, когда еще не дошли до нужного файла
        call    ext2_unlock
        mov     edx, [edi + 28] ;адрес структуры результата
        mov     ebx, [edi + 8] ;EXT2_read_in_folder
        mov     ecx, [edi + 4] ;EXT2_files_in_folder
        mov     dword [edx], 1    ;version
        mov     [edx + 4], ebx
        mov     [edx + 8], ecx
        
        lea     esp, [edi + 32]
        
        xor     eax, eax        ;RUS: зарезервировано: нули в текущей реализации
                                ;ENG: reserved: zeros in current implementation
        lea     edi, [edx + 12]
        mov     ecx, 20 / 4
        rep stosd
        ret

    .error_bad_len:
        mov     eax, ERROR_FS_FAIL
    .error_read_subinode:
    .error_get_block:
        lea     esp, [edi + 32]
    .error_ret:
        or      ebx, -1
        push    eax
        call    ext2_unlock
        pop     eax
        ret
        
    .error_empty_dir:   ;RUS: inode папки без блоков   ;ENG: inode of folder without blocks
    .error_root:        ;RUS: root - не папка          ;ENG: root is not a folder
        mov     eax, ERROR_FS_FAIL
        jmp     .error_ret

    .error_not_found:   ;RUS: файл не найден           ;ENG: file not found
        mov     eax, ERROR_FILE_NOT_FOUND
        jmp     .error_ret
            
;============================================
;convert UTF-8 string to ASCII-string (codepage 866)
;in:  ecx = length source
;     esi = source
;     edi = buffer
; destroys: eax,esi,edi
utf8_to_cp866:
        jecxz   .ret
    .start:
        lodsw
        cmp     al, 0x80
        jb      .ascii

        xchg    al, ah              ; big-endian
        cmp     ax, 0xd080
        jz      .yo1
        cmp     ax, 0xd191
        jz      .yo2
        cmp     ax, 0xd090
        jb      .unk
        cmp     ax, 0xd180
        jb      .rus1
        cmp     ax, 0xd190
        jb      .rus2
    .unk:
        mov     al, '_'
        jmp     .doit
    .yo1:
        mov     al, 0xf0    ; Ё capital
        jmp     .doit
    .yo2:
        mov     al, 0xf1    ; ё small
        jmp     .doit
    .rus1:
        sub     ax, 0xd090 - 0x80
        jmp     .doit
    .rus2:
        sub     ax, 0xd18f - 0xEF
    .doit:
        stosb
        sub     ecx, 2
        ja      .start
        ret

    .ascii:
        stosb
        dec     esi
        dec     ecx
        jnz     .start
    .ret:
        ret

;----------------------------------------------------------------
; ext2_Read - EXT2FS implementation of reading a file
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
ext2_Read:
        call    ext2_lock
        cmp     byte [esi], 0
        jnz     @F

    .this_is_nofile:
        call    ext2_unlock
        or      ebx, -1
        mov     eax, ERROR_ACCESS_DENIED
        ret

    @@:
        push    ebx
        stdcall ext2_find_lfn, [esp+4+4]
        pop     ebx
        test    eax, eax
        jz      @F

        call    ext2_unlock
        or      ebx, -1
        mov     eax, ERROR_FILE_NOT_FOUND
        ret

    @@:
        mov     ax, [esi + EXT2_INODE_STRUC.i_mode]
        and     ax, EXT2_S_IFMT     ;оставляем только тип inode в ax
        cmp     ax, EXT2_S_IFREG
        jne     .this_is_nofile

        mov     edi, [ebx+16]       ; edi = pointer to return mem
        mov     ecx, [ebx+12]

        mov     eax, [ebx+4]
        mov     edx, [ebx+8] ;RUS: edx : eax - стартовый номер байта   ;ENG: edx : eax - start byte number

        ;RUS: ///// сравним хватит ли нам файла или нет    ;ENG: ///// check if file is big enough for us
        cmp     [esi + EXT2_INODE_STRUC.i_dir_acl], edx
        ja      .size_great
        jb      .size_less

        cmp     [esi + EXT2_INODE_STRUC.i_size], eax
        ja      .size_great

    .size_less:
        call    ext2_unlock
        xor     ebx, ebx
        mov     eax, ERROR_END_OF_FILE
        ret
        
    .size_great:
        add     eax, ecx    ;RUS: add to first_wanted кол-во байт для чтения
                            ;ENG: add to first_wanted number of bytes to read
        adc     edx, 0

        cmp     [esi + EXT2_INODE_STRUC.i_dir_acl], edx
        ja      .size_great_great
        jb      .size_great_less
        cmp     [esi + EXT2_INODE_STRUC.i_size], eax
        jae     .size_great_great   ; and if it's equal, no matter where we jump

    .size_great_less:
        push    1            ;RUS: читаем по границе размера   ;ENG: reading till the end of file
        mov     ecx, [esi + EXT2_INODE_STRUC.i_size]
        sub     ecx, [ebx+4] ;RUS: (размер - старт) = сколько читать   ;ENG: to read = (size - start)
        jmp     @F

    .size_great_great:
        push    0            ;RUS: читаем столько, сколько запросили   ;ENG: reading as much as requested

    @@:
        ;здесь мы точно знаем сколько байт читать - ecx
        ;edi - return memory
        ;esi -> first wanted

        push    ecx                             ;количество считанных байт

        ;получим кусок из первого блока
        mov     edx, [ebx+8]
        mov     eax, [ebx+4]
        div     [ebp+EXTFS.block_size]

        push    eax       ;счетчик блоков ложим в стек
        
        push    ecx
        mov     ecx, eax
        call    ext2_get_inode_block
        test    eax, eax
        jnz     .error_at_first_block
        mov     ebx, [ebp+EXTFS.ext2_save_block]
        mov     eax, ecx
        call    ext2_get_block
        test    eax, eax
        jnz     .error_at_first_block
        pop     ecx
        add     ebx, edx

        neg     edx
        add     edx, [ebp+EXTFS.block_size]     ;RUS: block_size - стартовый байт = сколько байт 1-го блока
                                                ;ENG: block_size - start byte = number of bytes in 1st block
        cmp     ecx, edx
        jbe     .only_one_block

        mov     eax, ecx
        sub     eax, edx
        mov     ecx, edx

        push    esi
        mov     esi, ebx
        rep movsb                               ;RUS: кусок 1-го блока   ;ENG: part of 1st block
        pop     esi

        ;теперь в eax кол-во оставшихся байт для чтения
    .calc_blocks_count:
        mov     ebx, edi                        ;чтение блока прям в ->ebx
        xor     edx, edx
        div     [ebp+EXTFS.block_size]       ;кол-во байт в последнем блоке (остаток) в edx
        mov     edi, eax                        ;кол-во целых блоков в edi
    @@:
        test    edi, edi
        jz      .finish_block
        inc     dword [esp]
        mov     ecx, [esp]
        call    ext2_get_inode_block
        test    eax, eax
        jnz     .error_at_read_cycle

        mov     eax, ecx                        ;а ebx уже забит нужным значением
        call    ext2_get_block
        test    eax, eax
        jnz     .error_at_read_cycle
        add     ebx, [ebp+EXTFS.block_size]

        dec     edi
        jmp     @B

    .finish_block:          ;в edx - кол-во байт в последнем блоке
        test    edx, edx
        jz      .end_read

        pop     ecx         ;счетчик блоков -> ecx
        inc     ecx
        call    ext2_get_inode_block
        test    eax, eax
        jnz     .error_at_finish_block

        mov     edi, ebx
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.ext2_save_block]
        call    ext2_get_block
        test    eax, eax
        jnz     .error_at_finish_block

        mov     ecx, edx
        mov     esi, ebx
        rep movsb                               ;кусок last блока
        jmp     @F

    .end_read:
        pop     ecx                             ;счетчик блоков, который хранился в стеке
    @@:
        pop     ebx                             ;количество считанных байт
        call    ext2_unlock
        pop     eax                             ; 1 или 0 - достигли ли конца файла
        test    eax, eax
        jz      @F

        mov     eax, ERROR_END_OF_FILE
        ret
    @@:
        xor     eax, eax
        ret
        
    .only_one_block:
        mov     esi, ebx
        rep movsb                               ;кусок last блока
        jmp     .end_read
        
   .error_at_first_block:
        pop     edx
   .error_at_read_cycle:
        pop     ebx
   .error_at_finish_block:
        pop     ecx edx
        or      ebx, -1
        push    eax
        call    ext2_unlock
        pop     eax
        ret

;----------------------------------------------------------------
; in:  esi = file path
;      ebx = pointer to dir block
;      ebp = pointer to EXTFS structure
; out: esi - name without parent or not_changed
;      ebx - dir_rec of inode children
ext2_test_block_by_name:
        sub     esp, 256        ;EXT2_filename
        mov     edx, ebx
        add     edx, [ebp+EXTFS.block_size]   ;RUS: запомним конец блока   ;ENG: save block end

    .start_rec:
        cmp     [ebx + EXT2_DIR_STRUC.inode], 0
        jz      .next_rec

        mov     edi, esp
        push    esi
        movzx   ecx, [ebx + EXT2_DIR_STRUC.name_len]
        lea     esi, [ebx + EXT2_DIR_STRUC.name]
        call    utf8_to_cp866

        mov     ecx, edi
        lea     edi, [esp + 4]
        sub     ecx, edi   ;RUS: кол-во байт в получившейся строке   ;ENG: number of bytes in resulting string

        mov     esi, [esp]
    @@:
        jecxz   .test_find
        dec     ecx

        lodsb
        call    char_toupper

        mov     ah, [edi]
        inc     edi
        xchg    al, ah
        call    char_toupper
        cmp     al, ah
        je      @B
    @@:                           ;RUS: не подошло   ;ENG: didn't fit
        pop     esi
    .next_rec:
        movzx   eax, [ebx + EXT2_DIR_STRUC.rec_len]
        add     ebx, eax          ;RUS: к след. записи      ;ENG: go to next record
        cmp     ebx, edx          ;RUS: проверим конец ли   ;ENG: check if this is the end
        jb      .start_rec
        add     esp, 256
        ret

    .test_find:
        cmp     byte [esi], 0
        je      .ret              ;RUS: нашли конец         ;ENG: the end reached
        cmp     byte [esi], '/'
        jne     @B
        inc     esi
    .ret:
        add     esp, 256 + 4
        ret

;========================
;Ищет inode по строке пути
;in:  esi+[esp+4] = name
;     ebp = pointer to EXTFS
;out: eax - error code
;     esi = inode
;      dl - первый байт из имени файла/папки
ext2_find_lfn:
        mov     edx, [ebp+EXTFS.root_inode]
        cmp     [edx + EXT2_INODE_STRUC.i_blocks], 0
        je      .error_empty_root
        
    .next_path_part:
        push    [edx + EXT2_INODE_STRUC.i_blocks]
        xor     ecx, ecx
    .folder_block_cycle:
        push    ecx
        xchg    esi, edx
        call    ext2_get_inode_block
        xchg    esi, edx
        test    eax, eax
        jnz     .error_get_inode_block
        
        mov     eax, ecx
        mov     ebx, [ebp+EXTFS.ext2_save_block]        ;ebx = cur dir record
        call    ext2_get_block
        test    eax, eax
        jnz     .error_get_block
        
        push    esi
        push    edx
        call    ext2_test_block_by_name
        pop     edx
        pop     edi ecx

        cmp     edi, esi             ;RUS: нашли имя?   ;ENG: did we find a name?
        je      .next_folder_block   ;RUS: не нашли -> к след. блоку   ;ENG: we didn't -> moving to next block
        
        cmp     byte [esi], 0   ;RUS: дошли до "конца" пути -> возваращаемся
                                ;ENG: reached the "end" of path -> returning
        jnz     @f
        cmp     dword [esp+8], 0
        jz      .get_inode_ret
        mov     esi, [esp+8]
        mov     dword [esp+8], 0
    @@:

        cmp     [ebx + EXT2_DIR_STRUC.file_type], EXT2_FT_DIR   ;RUS: нашли, но это не папка
        jne     .not_found                                      ;ENG: found, but it's not a folder

        mov     eax, [ebx + EXT2_DIR_STRUC.inode]
        mov     ebx, [ebp+EXTFS.ext2_save_inode]   ;RUS: все же папка.   ;ENG: it's a folder afterall
        call    ext2_get_inode
        test    eax, eax
        jnz     .error_get_inode
        pop     ecx   ;RUS: в стеке лежит кол-во блоков   ;ENG: stack top contains number of blocks
        mov     edx, ebx
        jmp     .next_path_part
        
    .next_folder_block:
        ;к следующему блоку в текущей папке
        pop     eax                ;RUS: счетчик блоков   ;ENG: 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   ;RUS: в стеке лежит кол-во блоков   ;ENG: stack top contains number of blocks
        mov     dl, [ebx + EXT2_DIR_STRUC.name]   ;RUS: в dl - первый символ ()   ;ENG: ???
        mov     eax, [ebx + EXT2_DIR_STRUC.inode]
        mov     ebx, [ebp+EXTFS.ext2_save_inode]
        call    ext2_get_inode
        mov     esi, ebx
        xor     eax, eax
        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

;----------------------------------------------------------------
; ext2_GetFileInfo - EXT2 implementation of getting file info
; in:  ebp = pointer to EXTFS structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
ext2_GetFileInfo:
        call    ext2_lock
        mov     edx, [ebx+16]
        cmp     byte [esi], 0
        jz      .is_root

        push    edx
        stdcall ext2_find_lfn, [esp+4+4]
        mov     ebx, edx
        pop     edx
        test    eax, eax
        jz      @F
        push    eax
        call    ext2_unlock
        pop     eax
        ret

    .is_root:
        xor     ebx, ebx      ;RUS: root не может быть скрытым   ;ENG: root cannot be hidden
        mov     esi, [ebp+EXTFS.root_inode]
    @@:
        xor     eax, eax
        mov     edi, edx
        mov     ecx, 40/4
        rep stosd                   ; fill zero

        cmp     bl, '.'
        jne     @F
        or      dword [edx], FS_FT_HIDDEN
    @@:

        test    [esi + EXT2_INODE_STRUC.i_mode], EXT2_S_IFDIR
        jnz     @F
        mov     eax, [esi + EXT2_INODE_STRUC.i_size]            ;low size
        mov     ebx, [esi + EXT2_INODE_STRUC.i_dir_acl]         ;high size
        mov     dword [edx+32], eax
        mov     dword [edx+36], ebx
        xor     dword [edx], FS_FT_DIR
    @@:
        xor     dword [edx], FS_FT_DIR

        lea     edi, [edx + 8]
        mov     eax, [esi + EXT2_INODE_STRUC.i_ctime]
        xor     edx, edx
        add     eax, 3054539008
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        mov     eax, [esi + EXT2_INODE_STRUC.i_atime]
        xor     edx, edx
        add     eax, 3054539008
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        mov     eax, [esi + EXT2_INODE_STRUC.i_mtime]
        xor     edx, edx
        add     eax, 3054539008
        adc     edx, 2
        call    ntfs_datetime_to_bdfe.sec

        call    ext2_unlock
        xor     eax, eax
        ret

ext2_Rewrite:
ext2_Write:
ext2_SetFileEnd:
ext2_SetFileInfo:
ext2_Delete:
ext2_CreateFolder:
        xor     ebx, ebx
        mov     eax, ERROR_UNSUPPORTED_FS
        ret