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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9894 $
 
ERROR_SUCCESS        = 0
ERROR_DISK_BASE      = 1
ERROR_UNSUPPORTED_FS = 2
ERROR_UNKNOWN_FS     = 3
ERROR_PARTITION      = 4
ERROR_FILE_NOT_FOUND = 5
ERROR_END_OF_FILE    = 6
ERROR_MEMORY_POINTER = 7
ERROR_DISK_FULL      = 8
ERROR_FS_FAIL        = 9
ERROR_ACCESS_DENIED  = 10
ERROR_DEVICE         = 11
 
maxPathLength = 1000h
 
image_of_eax EQU esp+32
image_of_ebx EQU esp+20
 
; fs api for drivers
struct  FileSystem
        Next            dd ?
        Prev            dd ?
        Creat_part      dd ?  ; %FSNAME%_create_partition
        UserFuncs       dd ? ; for fs_del
        Name            rd 16 ;ascii string + \n
ends
 
 
fs_list:
        dd      fs_list
        dd      fs_list
;.look:  dd      0
 
; IN: ecx = %FSNAME%_create_partition
;     edx = ptr to UserFuncs
;     [esp] = fs name
;OUT: eax = list item
fs_add:
        push    ecx edx
        ; add in fs_list
        mov     eax, sizeof.FileSystem
        call    malloc
        pop     edx ecx
        test    eax, eax
        jz      .err
 
        mov     [eax + FileSystem.Creat_part], ecx
        mov     [eax + FileSystem.UserFuncs], edx
        mov     edx, [esp + 4]
        mov     [eax + FileSystem.Name], edx
        mov     edx, eax
 
        cli          ; DELETE
        list_add_tail edx, fs_list
        sti          ; DELETE
        mov     edx, ecx ; save function
 
        ;DEBUGF  1, 'K : FS: find partition\n'
        ; check all disks
        mov     esi, [disk_list]
.new_disk:
        cmp     dword[esi], disk_list
        jz      .end
 
        push    edx
        mov     eax, [esi + DISK.MediaInfo.SectorSize]
        shl     eax, 2
        stdcall kernel_alloc, eax   ;get buffer
        test    eax, eax
        pop     edx
        jz      .end ; no memory
        mov     ebx, eax
 
        mov     ecx, [esi + DISK.NumPartitions]
        dec     ecx
        shl     ecx, 2 ; to dword
        add     ecx, [esi + DISK.Partitions]
@@:
        mov     ebp, [ecx]
        cmp     [ebp + PARTITION.FSUserFunctions], default_fs_functions
        jnz     .no_fs
 
        ;DEBUGF  1, 'K : FS: found partition\n'
        push    ecx edx
 
        xor     eax, eax     ; first sector of the partition
        call    fs_read32_sys
        push    eax
        ;DEBUGF  1, 'K : FS: call driver func = %x\n', edx
 
        call    edx ; creat_partition
        add     esp, 4
        ;DEBUGF  1, 'K : FS: end call\n'
        pop     edx ecx
 
        test    eax, eax
        jz      .no_fs
        ; save and delete old struct
        xchg    [ecx], eax
        push    ecx edx
        call    free
        pop     edx ecx
        ;DEBUGF  1, 'K : FS: set fs for partition\n'
.no_fs:
        ;sub     ecx, 4
        cmp     ecx, [esi + DISK.Partitions]
        lea     ecx, [ecx - 4]
        jnz     @b
 
        push    edx
        stdcall kernel_free, ebx
        pop     edx
 
        mov     esi, [esi]
        jmp     .new_disk
.end:
.err:
        ret
; IN: ecx = list item
;OUT: -
;fs_del:
;
;        ret
 
 
 
; System function 70 security check
align 4
proc file_system_is_operation_safe stdcall, inf_struct_ptr: dword
; in:
;      inf_struct_ptr = pointer to information structure was given to sysfn70
; out: ZF = 1 if operation is safe
;      ZF = 0 if operation can cause kernel crash
        push    ebx ecx edx
        xor     ecx, ecx ; ecx - length of target buffer
 
        mov     ebx, [inf_struct_ptr]
        mov     edx, [ebx + 16] ; base of target buffer
 
        cmp     dword [ebx], 0 ; if 70.0
        jnz     .case1
        mov     ecx, dword [ebx + 12]
        jmp     .end_switch
 
.case1:
        cmp     dword [ebx], 1 ; if 70.1
        jnz     .case2_3
        ;mov     ecx, 32
        cmp     dword [ebx + 8], 1 ; check encoding
        jbe     .case1_304 ; if encdoing <= 1 i.e cpp866 
        mov     ecx, 560 ; if unicode then bdvk block len is 560 bytes
        jmp     .case1_end
.case1_304:
        mov     ecx, 304 ; if cp866 then bdvk block len is 304 bytes
.case1_end:
        imul    ecx, dword [ebx + 12] ; multiply bdvk length by their count
        add     ecx, 32 ; add result header len
        jmp     .end_switch
 
.case2_3:
        cmp     dword [ebx], 3
        ja      .case5 ; if subfn > 3
        mov     ecx, dword [ebx + 12]
        jmp     .end_switch
 
.case5:
        cmp     dword [ebx], 5
        jnz     .case6
        mov     ecx, 40
        jmp     .end_switch
 
.case6:
        cmp     dword [ebx], 6
        jnz     .switch_none
        mov     ecx, 32
        jmp     .end_switch
 
.switch_none:
        cmp     ecx, ecx
        jmp     .ret
      
.end_switch:
        stdcall is_region_userspace, edx, ecx
.ret:
        pop     edx ecx ebx
        ret
endp
 
sys_fileSystemUnicode: ; with user pointer correctness checking
; in: ebx -> f.80 parameter structure
        stdcall file_system_is_operation_safe, ebx
        jz      @f
 
        DEBUGF  1, "sysfn80 addr error\n"
        mov     dword [image_of_eax], ERROR_MEMORY_POINTER
        ret
@@:
        jmp     fileSystemUnicode
 
;System function 70
sys_file_system_lfn: ; with user pointer correctness checking
; in: ebx -> f.70 parameter structure
        stdcall file_system_is_operation_safe, ebx
        jz      @f
 
        DEBUGF  1, "sysfn70 addr error\n"
        mov     dword [image_of_eax], ERROR_MEMORY_POINTER
        ret
@@:
        jmp     file_system_lfn
 
;file_system_lfn_protected returns values not in registers, but in their images
;on stack. Make a short wrapper to actually return values in registers.
file_system_lfn_protected_registers:
        pushad
        call    file_system_lfn_protected
        popad
        ret
 
file_system_lfn_protected:
        pushad
        call    protect_from_terminate
        call    file_system_lfn
        call    unprotect_from_terminate
        popad
        mov     [image_of_eax], eax
        mov     [image_of_ebx], ebx
        ret
 
fileSystemUnicode:
; in: ebx -> f.80 parameter structure
        mov     edi, [ebx+20]
        mov     esi, [ebx+24]
        jmp     @f
 
file_system_lfn:
; in: ebx -> f.70 parameter structure
        xor     edi, edi
        lea     esi, [ebx+20]
        cmp     byte [esi], 0
        jnz     @f
        mov     esi, [ebx+21]
@@:
        cmp     word [esi], '/'
        jnz     @f
        cmp     edi, 2
        jnz     .rootdir
        cmp     dword[esi], '/'
        jz      .rootdir
@@:
        stdcall kernel_alloc, maxPathLength
        push    eax ebx
        xchg    eax, edi
        call    getFullPath
        pop     ebx ebp
        test    eax, eax
        jz      .notfound
        cmp     dword[ebx], 7   ; start application
        jnz     @f
        mov     edx, [ebx+4]
        mov     ecx, [ebx+8]
        mov     ebx, ebp
        call    fs_execute
        mov     [image_of_eax], eax
        ret
 
@@:
        lea     esi, [ebp+2]
        mov     ax, [esi]
        or      ax, 2020h
        cmp     ax, 'cd'
        jz      .CD
        call    dyndisk_handler ; not returns if success
.notfound:
        stdcall kernel_free, ebp
        mov     dword[image_of_eax], ERROR_FILE_NOT_FOUND
        ret
 
.CD:
        add     esi, 2
        xor     eax, eax
        lodsb       ; disk number
        sub     eax, '0'
        cmp     eax, 10
        jnc     .notfound
        mov     edi, eax
        lodsb
        test    eax, eax
        jz      .maindir
        cmp     al, '/'
        jnz     .notfound
        lodsb       ; partition number
        test    eax, eax
        jz      .maindir
        cmp     al, '1'
        jnz     .notfound
        cmp     byte [esi], '/'
        jnz     @f
        inc     esi
@@:
        call    reserve_cd
        mov     eax, edi
        bt      eax, 0
        setc    [DiskNumber]
        bt      eax, 1
        setc    [ChannelNumber]
        inc     [ChannelNumber]
        inc     eax
        mov     [cdpos], eax
        call    reserve_cd_channel
        mov     eax, edi
        not     eax
        and     eax, 3
        shl     eax, 1
        inc     eax
        shr     edi, 2
        mov     dword[image_of_eax], ERROR_FILE_NOT_FOUND
        bt      [edi*5+DRIVE_DATA+1], ax
        jnc     @f
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        mov     eax, [ebx]
        mov     dword[image_of_eax], ERROR_UNSUPPORTED_FS
        cmp     eax, fs_NumCdServices
        jae     @f
        add     ebx, 4
        push    ebp
        call    dword[fs_CdServices + eax*4]
        pop     ebp
        mov     [image_of_eax], eax
        mov     [image_of_ebx], ebx
@@:
        call    free_cd_channel
        and     [cd_status], 0
        stdcall kernel_free, ebp
        ret
 
.nextCD:
        test    eax, eax    ; partition number
        jnz     @f
        inc     eax     ; /cdX/1
        ret
 
@@:
        stc
        ret
 
.maindir:   ; list partitions
        mov     esi, .nextCD
        xor     ecx, ecx
.maindir_noesi:     ; backjump from dyndisk_handler
        push    ebp
        mov     ebp, ecx
        call    kernel_free
        mov     edi, [ebx+16]   ; buffer
        cmp     byte [ebx], 5
        jz      .deviceInfo
        cmp     byte [ebx], 1   ; read folder?
        jnz     .access_denied
        push    ebp
        pushd   [ebx+4]         ; first block
        mov     ebp, [ebx+12]   ; the number of blocks to read
        mov     ebx, [ebx+8]    ; flags
        mov     ecx, 32/4
        mov     edx, edi
        xor     eax, eax
        rep stosd
        mov     byte [edx], 1   ; version
.maindir_loop:
        call    esi
        jc      .maindir_done
        inc     dword[edx+8]
        dec     dword[esp]
        jns     .maindir_loop
        dec     ebp
        js      .maindir_loop
        inc     dword[edx+4]
        mov     dword[edi], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        push    eax
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        pop     eax
        push    eax edx edi
; convert number in eax to decimal string
        push    -'0'
        mov     ecx, 10
@@:
        xor     edx, edx
        div     ecx
        push    edx
        test    eax, eax
        jnz     @b
        cmp     ebx, 2
        jz      .uni
@@:
        pop     eax
        add     eax, '0'
        stosb
        test    eax, eax
        jnz     @b
        pop     edi edx eax
        cmp     ebx, 3
        jz      @f
        add     edi, 264
        jmp     .maindir_loop
 
.uni:
        pop     eax
        add     eax, '0'
        stosw
        test    eax, eax
        jnz     .uni
        pop     edi edx eax
@@:
        add     edi, 520
        jmp     .maindir_loop
 
.maindir_done:
        pop     eax eax
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ebp
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [image_of_eax], eax
        mov     [image_of_ebx], ebx
        ret
 
.access_denied:
        mov     dword[image_of_eax], ERROR_ACCESS_DENIED
        ret
 
.deviceInfo:
        test    ebp, ebp
        jz      @f
        mov     eax, dword[ebp+DISK.MediaInfo.Capacity]
        mov     edx, dword[ebp+DISK.MediaInfo.Capacity+4]
        shld    edx, eax, 9
        shl     eax, 9
        mov     [edi+36], edx
        mov     [edi+32], eax
@@:
        and     dword[image_of_eax], 0
        ret
 
.rootdir:   ; / - virtual root folder
        cmp     byte [ebx], 5
        jz      @b
        cmp     byte [ebx], 1   ; read folder?
        jnz     .access_denied
        mov     ebp, [ebx+12]   ; number of blocks
        mov     edx, [ebx+16]   ; return area
        push    dword[ebx+4]    ; first block
        mov     ebx, [ebx+8]    ; flags
        mov     ecx, 32/4
        mov     edi, edx
        xor     eax, eax
        rep stosd
        mov     byte [edx], 1   ; version
        sub     esp, 16
.rootdir_loop:
        push    edi
        lea     edi, [esp+4]
        call    dyndisk_enum_root
        pop     edi
        test    eax, eax
        jz      .rootdirCD
        inc     dword[edx+8]
        dec     dword[esp+16]
        jns     .rootdir_loop
        dec     ebp
        js      .rootdir_loop
        inc     dword[edx+4]
        mov     dword[edi], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        push    eax
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        push    edi
        lea     esi, [esp+8]
        cmp     ebx, 2
        jz      .uni2
@@:
        lodsb
        stosb
        test    eax, eax
        jnz     @b
        pop     edi eax
        cmp     ebx, 3
        jz      @f
        add     edi, 264
        jmp     .rootdir_loop
 
.uni2:
        lodsb
        stosw
        test    eax, eax
        jnz     .uni2
        pop     edi eax
@@:
        add     edi, 520
        jmp     .rootdir_loop
 
.rootdirCD:
        add     esp, 16
        or      esi, -1
.rootdirCD_loop:
        inc     esi
        cmp     esi, 10
        jnc     .rootdir_done
        mov     eax, esi
        not     eax
        and     eax, 3
        shl     eax, 1
        inc     eax
        mov     ecx, esi
        shr     ecx, 2
        bt      [ecx*5+DRIVE_DATA+1], ax
        jnc     .rootdirCD_loop
        inc     dword[edx+8]
        dec     dword[esp]
        jns     .rootdirCD_loop
        dec     ebp
        js      .rootdirCD_loop
        inc     dword[edx+4]
        mov     dword[edi], 16      ; attributes: folder
        mov     dword[edi+4], ebx   ; name encoding
        mov     ecx, 32/4
        add     edi, 8
        xor     eax, eax
        rep stosd
        mov     eax, esi
        add     eax, '0'
        cmp     ebx, 1
        jz      @f
        mov     word [edi], 'cd'
        mov     [edi+2], ax
        add     edi, 264
        jmp     .rootdirCD_loop
 
@@:
        mov     dword[edi], 640063h
        mov     [edi+4], eax
        add     edi, 520
        jmp     .rootdirCD_loop
 
.rootdir_done:
        pop     eax
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ebp
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [image_of_eax], eax
        mov     [image_of_ebx], ebx
        ret
 
;-----------------------------------------------------------------------------
process_replace_file_name:
; in: [esi] = virtual path
; out: [esi]+[ebp] = physical path
        xor     edi, edi
        xor     ebp, ebp
.loop:
        cmp     edi, [full_file_name_table.size]
        jae     .notfound
        push    esi edi
        shl     edi, 7
        add     edi, [full_file_name_table]
@@:
        cmp     byte [edi], 0
        jz      .dest_done
        lodsb
        test    al, al
        jz      .cont
        scasb
        jz      @b
        or      al, 20h
        cmp     [edi-1], al
        jz      @b
.cont:
        pop     edi esi
        inc     edi
        jmp     .loop
 
.dest_done:
        cmp     byte [esi], 0
        jz      .found
        cmp     byte [esi], '/'
        jnz     .cont
.found:
        pop     edi eax
        shl     edi, 7
        add     edi, [full_file_name_table]
        mov     ebp, esi
        lea     esi, [edi+64]
.notfound:
        ret
 
;-----------------------------------------------------------------------------
uglobal
addDirSeal db  ?
endg
 
sys_current_directory:  ; sysfunction 30
        mov     eax, [current_slot]
        mov     edi, [eax+APPDATA.cur_dir]
        xor     eax, eax
        dec     ebx
        jz      .set
        dec     ebx
        jz      .get
        dec     ebx
        jz      .mount_additional_directory
        mov     eax, edx
        dec     ebx
        jz      .set
        mov     eax, esi
        dec     ebx
        jz      .get
@@:
        ret
 
.mount_additional_directory:
; in: ecx -> dir name+dir path (128)
        mov     al, 1
        xchg    [addDirSeal], al
        test    al, al
        jnz     @b
        mov     esi, ecx
        mov     edi, sysdir_name1
        mov     ecx, 64
        rep movsb   ; copying fake directory name
        mov     byte [edi-1], 0
        mov     cl, 63
        call    cp866toUTF8_string
        mov     byte [edi], 0
        mov     [full_file_name_table.size], 2
        ret
 
.get:
; in: ecx -> buffer, edx = length, eax = encoding
        stdcall is_region_userspace, ecx, edx
        jz      @f
 
        ; if illegal buffer given
        xor     edx, edx
        jmp     .ret
@@:
 
        mov     esi, edi
        inc     esi
        mov     edi, ecx
        cmp     edx, maxPathLength
        jc      @f
        mov     edx, maxPathLength
@@:
        mov     ecx, edx
        jecxz   .ret
        cmp     eax, 2
        jz      .get16
        cmp     eax, 3
        jz      .get8
@@:
        dec     ecx
        js      @f
        call    utf8to16
        call    uni2ansi_char
        stosb
        test    al, al
        jnz     @b
        sub     edx, ecx
@@:
        mov     byte [edi-1], 0
.ret:
        mov     [esp+32], edx
        ret
 
.get8:
        push    edi
        mov     edi, esi
        xor     eax, eax
        repnz scasb
        sub     edx, ecx
        mov     ecx, edx
        pop     edi
        rep movsb
        jmp     @b
 
.get16:
        shr     ecx, 1
        shr     edx, 1
@@:
        dec     ecx
        js      @f
        call    utf8to16
        stosw
        test    ax, ax
        jnz     @b
        sub     edx, ecx
@@:
        shl     edx, 1
        mov     word [edi-2], 0
        jmp     .ret
 
.set:
        mov     esi, ecx
getFullPath:
; in: esi -> file path, eax = string encoding, edi -> destination
; out: UTF-8 string (with marker), eax = length, 0 -> error
        test    eax, eax
        jnz     @f
        cmp     byte [esi], 4
        jnc     @f
        cmp     byte [esi], 0
        jz      @f
        lodsb
@@:
        cmp     byte [esi], '/'
        jnz     .relative
        cmp     eax, 2
        jnz     @f
        cmp     word [esi], '/'
        jnz     .relative
        inc     esi
        inc     esi
        jmp     .start
 
@@:
        inc     esi
        cmp     byte [esi], 4
        jnc     .start
        lodsb
        cmp     byte [esi], '/'
        jnz     .start
        inc     esi
.start:
        push    eax edi
        call    process_replace_file_name
        mov     edi, [esp]
        mov     ecx, maxPathLength
        mov     al, 3
        mov     ah, '/'
        stosw
        sub     ecx, 2
        test    ebp, ebp
        jz      .absolute
@@:
        lodsb
        stosb
        dec     ecx
        test    al, al
        jnz     @b
        mov     esi, ebp
        dec     edi
.absolute:
        cmp     byte [esp+4], 2
        jz      .utf16
        cmp     byte [esp+4], 3
        jz      .utf8
        call    cp866toUTF8_string
        jns     .end
        jmp     .fail
 
.utf8:
        dec     ecx
        js      .fail
        lodsb
        stosb
        test    al, al
        jz      .end
        jmp     .utf8
 
.utf16:
        call    UTF16to8_string
        jns     .end
.fail:
        mov     byte [edi], 0
        pop     eax eax
        xor     eax, eax
        ret
 
.relative:
        push    eax edi
        mov     ebx, esi
        mov     edi, [current_slot]
        mov     edi, [edi+APPDATA.cur_dir]
        mov     edx, edi
        mov     ecx, maxPathLength
        xor     eax, eax
        repnz scasb
        mov     esi, edi
        mov     edi, [esp]
        jecxz   .fail
        cmp     byte [ebx], 0
        jz      .set_ok
        dec     esi
        cmp     edx, edi    ; is destination equal to cur_dir?
        mov     edi, esi
        jz      @f
        mov     edi, [esp]
        mov     ecx, esi
        sub     ecx, edx
        mov     esi, edx
        mov     edx, edi
        rep movsb
@@:
        mov     byte [edi], '/'
        inc     edi
        mov     esi, ebx
        mov     ecx, edx
        add     ecx, maxPathLength
        sub     ecx, edi
        jmp     .absolute
 
.set_ok:
        cmp     edx, edi    ; is destination equal to cur_dir?
        jz      @f
        mov     ecx, esi
        sub     ecx, edx
        mov     esi, edx
        rep movsb
@@:
        pop     eax
        sub     edi, eax
        pop     eax
        mov     eax, edi
        ret
 
.end:
        or      ecx, -1
        mov     edi, [esp]
        xor     eax, eax
        push    edi
        repnz scasb
        not     ecx
        pop     edi
.parse:
        mov     al, '/'
        repnz scasb
        jecxz   @b
        cmp     byte [edi], '.'
        jnz     .parse
        mov     esi, edi
@@:
        lodsw
        sub     ecx, 2
        cmp     ax, './'
        jz      @b
        cmp     ax, '..'
        jnz     @f
        cmp     byte [esi], '/'
        jnz     @f
        mov     edx, ecx
        mov     ecx, edi
        sub     ecx, [esp]
        sub     ecx, 2
        jc      .fail
        sub     edi, 2
        lodsb
        dec     edx
        std
        repnz scasb
        cld
        add     edi, 2
        mov     ecx, edx
        jmp     @b
 
@@:
        sub     esi, 2
        add     ecx, 2
        cmp     esi, edi
        jz      .parse
        push    edi ecx
        rep movsb
        pop     ecx edi
        jmp     .parse
 
include "parse_fn.inc"
include "fs_common.inc"
include "iso9660.inc"   ; read for CD filesystem
include "fat.inc"
include "exfat.inc"
include "ntfs.inc"
include "ext.inc"
include "xfs.asm"

Rev 9734	Rev 9894
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License. ;;	4	;; Distributed under terms of the GNU General Public License. ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 9734 $	8	$Revision: 9894 $
9		9
10	ERROR_SUCCESS = 0	10	ERROR_SUCCESS = 0
11	ERROR_DISK_BASE = 1	11	ERROR_DISK_BASE = 1
12	ERROR_UNSUPPORTED_FS = 2	12	ERROR_UNSUPPORTED_FS = 2
13	ERROR_UNKNOWN_FS = 3	13	ERROR_UNKNOWN_FS = 3
14	ERROR_PARTITION = 4	14	ERROR_PARTITION = 4
15	ERROR_FILE_NOT_FOUND = 5	15	ERROR_FILE_NOT_FOUND = 5
16	ERROR_END_OF_FILE = 6	16	ERROR_END_OF_FILE = 6
17	ERROR_MEMORY_POINTER = 7	17	ERROR_MEMORY_POINTER = 7
18	ERROR_DISK_FULL = 8	18	ERROR_DISK_FULL = 8
19	ERROR_FS_FAIL = 9	19	ERROR_FS_FAIL = 9
20	ERROR_ACCESS_DENIED = 10	20	ERROR_ACCESS_DENIED = 10
21	ERROR_DEVICE = 11	21	ERROR_DEVICE = 11
22		22
23	maxPathLength = 1000h	23	maxPathLength = 1000h
24		24
25	image_of_eax EQU esp+32	25	image_of_eax EQU esp+32
26	image_of_ebx EQU esp+20	26	image_of_ebx EQU esp+20
-		27
-		28	; fs api for drivers
-		29	struct FileSystem
-		30	Next dd ?
-		31	Prev dd ?
-		32	Creat_part dd ? ; %FSNAME%_create_partition
-		33	UserFuncs dd ? ; for fs_del
-		34	Name rd 16 ;ascii string + \n
-		35	ends
-		36
-		37
-		38	fs_list:
-		39	dd fs_list
-		40	dd fs_list
-		41	;.look: dd 0
-		42
-		43	; IN: ecx = %FSNAME%_create_partition
-		44	; edx = ptr to UserFuncs
-		45	; [esp] = fs name
-		46	;OUT: eax = list item
-		47	fs_add:
-		48	push ecx edx
-		49	; add in fs_list
-		50	mov eax, sizeof.FileSystem
-		51	call malloc
-		52	pop edx ecx
-		53	test eax, eax
-		54	jz .err
-		55
-		56	mov [eax + FileSystem.Creat_part], ecx
-		57	mov [eax + FileSystem.UserFuncs], edx
-		58	mov edx, [esp + 4]
-		59	mov [eax + FileSystem.Name], edx
-		60	mov edx, eax
-		61
-		62	cli ; DELETE
-		63	list_add_tail edx, fs_list
-		64	sti ; DELETE
-		65	mov edx, ecx ; save function
-		66
-		67	;DEBUGF 1, 'K : FS: find partition\n'
-		68	; check all disks
-		69	mov esi, [disk_list]
-		70	.new_disk:
-		71	cmp dword[esi], disk_list
-		72	jz .end
-		73
-		74	push edx
-		75	mov eax, [esi + DISK.MediaInfo.SectorSize]
-		76	shl eax, 2
-		77	stdcall kernel_alloc, eax ;get buffer
-		78	test eax, eax
-		79	pop edx
-		80	jz .end ; no memory
-		81	mov ebx, eax
-		82
-		83	mov ecx, [esi + DISK.NumPartitions]
-		84	dec ecx
-		85	shl ecx, 2 ; to dword
-		86	add ecx, [esi + DISK.Partitions]
-		87	@@:
-		88	mov ebp, [ecx]
-		89	cmp [ebp + PARTITION.FSUserFunctions], default_fs_functions
-		90	jnz .no_fs
-		91
-		92	;DEBUGF 1, 'K : FS: found partition\n'
-		93	push ecx edx
-		94
-		95	xor eax, eax ; first sector of the partition
-		96	call fs_read32_sys
-		97	push eax
-		98	;DEBUGF 1, 'K : FS: call driver func = %x\n', edx
-		99
-		100	call edx ; creat_partition
-		101	add esp, 4
-		102	;DEBUGF 1, 'K : FS: end call\n'
-		103	pop edx ecx
-		104
-		105	test eax, eax
-		106	jz .no_fs
-		107	; save and delete old struct
-		108	xchg [ecx], eax
-		109	push ecx edx
-		110	call free
-		111	pop edx ecx
-		112	;DEBUGF 1, 'K : FS: set fs for partition\n'
-		113	.no_fs:
-		114	;sub ecx, 4
-		115	cmp ecx, [esi + DISK.Partitions]
-		116	lea ecx, [ecx - 4]
-		117	jnz @b
-		118
-		119	push edx
-		120	stdcall kernel_free, ebx
-		121	pop edx
-		122
-		123	mov esi, [esi]
-		124	jmp .new_disk
-		125	.end:
-		126	.err:
-		127	ret
-		128	; IN: ecx = list item
-		129	;OUT: -
-		130	;fs_del:
-		131	;
-		132	; ret
-		133
-		134
27		135
28	; System function 70 security check	136	; System function 70 security check
29	align 4	137	align 4
30	proc file_system_is_operation_safe stdcall, inf_struct_ptr: dword	138	proc file_system_is_operation_safe stdcall, inf_struct_ptr: dword
31	; in:	139	; in:
32	; inf_struct_ptr = pointer to information structure was given to sysfn70	140	; inf_struct_ptr = pointer to information structure was given to sysfn70
33	; out: ZF = 1 if operation is safe	141	; out: ZF = 1 if operation is safe
34	; ZF = 0 if operation can cause kernel crash	142	; ZF = 0 if operation can cause kernel crash
35	push ebx ecx edx	143	push ebx ecx edx
36	xor ecx, ecx ; ecx - length of target buffer	144	xor ecx, ecx ; ecx - length of target buffer
37		145
38	mov ebx, [inf_struct_ptr]	146	mov ebx, [inf_struct_ptr]
39	mov edx, [ebx + 16] ; base of target buffer	147	mov edx, [ebx + 16] ; base of target buffer
40		148
41	cmp dword [ebx], 0 ; if 70.0	149	cmp dword [ebx], 0 ; if 70.0
42	jnz .case1	150	jnz .case1
43	mov ecx, dword [ebx + 12]	151	mov ecx, dword [ebx + 12]
44	jmp .end_switch	152	jmp .end_switch
45		153
46	.case1:	154	.case1:
47	cmp dword [ebx], 1 ; if 70.1	155	cmp dword [ebx], 1 ; if 70.1
48	jnz .case2_3	156	jnz .case2_3
49	;mov ecx, 32	157	;mov ecx, 32
50	cmp dword [ebx + 8], 1 ; check encoding	158	cmp dword [ebx + 8], 1 ; check encoding
51	jbe .case1_304 ; if encdoing <= 1 i.e cpp866	159	jbe .case1_304 ; if encdoing <= 1 i.e cpp866
52	mov ecx, 560 ; if unicode then bdvk block len is 560 bytes	160	mov ecx, 560 ; if unicode then bdvk block len is 560 bytes
53	jmp .case1_end	161	jmp .case1_end
54	.case1_304:	162	.case1_304:
55	mov ecx, 304 ; if cp866 then bdvk block len is 304 bytes	163	mov ecx, 304 ; if cp866 then bdvk block len is 304 bytes
56	.case1_end:	164	.case1_end:
57	imul ecx, dword [ebx + 12] ; multiply bdvk length by their count	165	imul ecx, dword [ebx + 12] ; multiply bdvk length by their count
58	add ecx, 32 ; add result header len	166	add ecx, 32 ; add result header len
59	jmp .end_switch	167	jmp .end_switch
60		168
61	.case2_3:	169	.case2_3:
62	cmp dword [ebx], 3	170	cmp dword [ebx], 3
63	ja .case5 ; if subfn > 3	171	ja .case5 ; if subfn > 3
64	mov ecx, dword [ebx + 12]	172	mov ecx, dword [ebx + 12]
65	jmp .end_switch	173	jmp .end_switch
66		174
67	.case5:	175	.case5:
68	cmp dword [ebx], 5	176	cmp dword [ebx], 5
69	jnz .case6	177	jnz .case6
70	mov ecx, 40	178	mov ecx, 40
71	jmp .end_switch	179	jmp .end_switch
72		180
73	.case6:	181	.case6:
74	cmp dword [ebx], 6	182	cmp dword [ebx], 6
75	jnz .switch_none	183	jnz .switch_none
76	mov ecx, 32	184	mov ecx, 32
77	jmp .end_switch	185	jmp .end_switch
78		186
79	.switch_none:	187	.switch_none:
80	cmp ecx, ecx	188	cmp ecx, ecx
81	jmp .ret	189	jmp .ret
82		190
83	.end_switch:	191	.end_switch:
84	stdcall is_region_userspace, edx, ecx	192	stdcall is_region_userspace, edx, ecx
85	.ret:	193	.ret:
86	pop edx ecx ebx	194	pop edx ecx ebx
87	ret	195	ret
88	endp	196	endp
89		197
90	sys_fileSystemUnicode: ; with user pointer correctness checking	198	sys_fileSystemUnicode: ; with user pointer correctness checking
91	; in: ebx -> f.80 parameter structure	199	; in: ebx -> f.80 parameter structure
92	stdcall file_system_is_operation_safe, ebx	200	stdcall file_system_is_operation_safe, ebx
93	jz @f	201	jz @f
94		202
95	DEBUGF 1, "sysfn80 addr error\n"	203	DEBUGF 1, "sysfn80 addr error\n"
96	mov dword [image_of_eax], ERROR_MEMORY_POINTER	204	mov dword [image_of_eax], ERROR_MEMORY_POINTER
97	ret	205	ret
98	@@:	206	@@:
99	jmp fileSystemUnicode	207	jmp fileSystemUnicode
100		208
101	;System function 70	209	;System function 70
102	sys_file_system_lfn: ; with user pointer correctness checking	210	sys_file_system_lfn: ; with user pointer correctness checking
103	; in: ebx -> f.70 parameter structure	211	; in: ebx -> f.70 parameter structure
104	stdcall file_system_is_operation_safe, ebx	212	stdcall file_system_is_operation_safe, ebx
105	jz @f	213	jz @f
106		214
107	DEBUGF 1, "sysfn70 addr error\n"	215	DEBUGF 1, "sysfn70 addr error\n"
108	mov dword [image_of_eax], ERROR_MEMORY_POINTER	216	mov dword [image_of_eax], ERROR_MEMORY_POINTER
109	ret	217	ret
110	@@:	218	@@:
111	jmp file_system_lfn	219	jmp file_system_lfn
112		220
113	;file_system_lfn_protected returns values not in registers, but in their images	221	;file_system_lfn_protected returns values not in registers, but in their images
114	;on stack. Make a short wrapper to actually return values in registers.	222	;on stack. Make a short wrapper to actually return values in registers.
115	file_system_lfn_protected_registers:	223	file_system_lfn_protected_registers:
116	pushad	224	pushad
117	call file_system_lfn_protected	225	call file_system_lfn_protected
118	popad	226	popad
119	ret	227	ret
120		228
121	file_system_lfn_protected:	229	file_system_lfn_protected:
122	pushad	230	pushad
123	call protect_from_terminate	231	call protect_from_terminate
124	call file_system_lfn	232	call file_system_lfn
125	call unprotect_from_terminate	233	call unprotect_from_terminate
126	popad	234	popad
127	mov [image_of_eax], eax	235	mov [image_of_eax], eax
128	mov [image_of_ebx], ebx	236	mov [image_of_ebx], ebx
129	ret	237	ret
130		238
131	fileSystemUnicode:	239	fileSystemUnicode:
132	; in: ebx -> f.80 parameter structure	240	; in: ebx -> f.80 parameter structure
133	mov edi, [ebx+20]	241	mov edi, [ebx+20]
134	mov esi, [ebx+24]	242	mov esi, [ebx+24]
135	jmp @f	243	jmp @f
136		244
137	file_system_lfn:	245	file_system_lfn:
138	; in: ebx -> f.70 parameter structure	246	; in: ebx -> f.70 parameter structure
139	xor edi, edi	247	xor edi, edi
140	lea esi, [ebx+20]	248	lea esi, [ebx+20]
141	cmp byte [esi], 0	249	cmp byte [esi], 0
142	jnz @f	250	jnz @f
143	mov esi, [ebx+21]	251	mov esi, [ebx+21]
144	@@:	252	@@:
145	cmp word [esi], '/'	253	cmp word [esi], '/'
146	jnz @f	254	jnz @f
147	cmp edi, 2	255	cmp edi, 2
148	jnz .rootdir	256	jnz .rootdir
149	cmp dword[esi], '/'	257	cmp dword[esi], '/'
150	jz .rootdir	258	jz .rootdir
151	@@:	259	@@:
152	stdcall kernel_alloc, maxPathLength	260	stdcall kernel_alloc, maxPathLength
153	push eax ebx	261	push eax ebx
154	xchg eax, edi	262	xchg eax, edi
155	call getFullPath	263	call getFullPath
156	pop ebx ebp	264	pop ebx ebp
157	test eax, eax	265	test eax, eax
158	jz .notfound	266	jz .notfound
159	cmp dword[ebx], 7 ; start application	267	cmp dword[ebx], 7 ; start application
160	jnz @f	268	jnz @f
161	mov edx, [ebx+4]	269	mov edx, [ebx+4]
162	mov ecx, [ebx+8]	270	mov ecx, [ebx+8]
163	mov ebx, ebp	271	mov ebx, ebp
164	call fs_execute	272	call fs_execute
165	mov [image_of_eax], eax	273	mov [image_of_eax], eax
166	ret	274	ret
167		275
168	@@:	276	@@:
169	lea esi, [ebp+2]	277	lea esi, [ebp+2]
170	mov ax, [esi]	278	mov ax, [esi]
171	or ax, 2020h	279	or ax, 2020h
172	cmp ax, 'cd'	280	cmp ax, 'cd'
173	jz .CD	281	jz .CD
174	call dyndisk_handler ; not returns if success	282	call dyndisk_handler ; not returns if success
175	.notfound:	283	.notfound:
176	stdcall kernel_free, ebp	284	stdcall kernel_free, ebp
177	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND	285	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND
178	ret	286	ret
179		287
180	.CD:	288	.CD:
181	add esi, 2	289	add esi, 2
182	xor eax, eax	290	xor eax, eax
183	lodsb ; disk number	291	lodsb ; disk number
184	sub eax, '0'	292	sub eax, '0'
185	cmp eax, 10	293	cmp eax, 10
186	jnc .notfound	294	jnc .notfound
187	mov edi, eax	295	mov edi, eax
188	lodsb	296	lodsb
189	test eax, eax	297	test eax, eax
190	jz .maindir	298	jz .maindir
191	cmp al, '/'	299	cmp al, '/'
192	jnz .notfound	300	jnz .notfound
193	lodsb ; partition number	301	lodsb ; partition number
194	test eax, eax	302	test eax, eax
195	jz .maindir	303	jz .maindir
196	cmp al, '1'	304	cmp al, '1'
197	jnz .notfound	305	jnz .notfound
198	cmp byte [esi], '/'	306	cmp byte [esi], '/'
199	jnz @f	307	jnz @f
200	inc esi	308	inc esi
201	@@:	309	@@:
202	call reserve_cd	310	call reserve_cd
203	mov eax, edi	311	mov eax, edi
204	bt eax, 0	312	bt eax, 0
205	setc [DiskNumber]	313	setc [DiskNumber]
206	bt eax, 1	314	bt eax, 1
207	setc [ChannelNumber]	315	setc [ChannelNumber]
208	inc [ChannelNumber]	316	inc [ChannelNumber]
209	inc eax	317	inc eax
210	mov [cdpos], eax	318	mov [cdpos], eax
211	call reserve_cd_channel	319	call reserve_cd_channel
212	mov eax, edi	320	mov eax, edi
213	not eax	321	not eax
214	and eax, 3	322	and eax, 3
215	shl eax, 1	323	shl eax, 1
216	inc eax	324	inc eax
217	shr edi, 2	325	shr edi, 2
218	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND	326	mov dword[image_of_eax], ERROR_FILE_NOT_FOUND
219	bt [edi*5+DRIVE_DATA+1], ax	327	bt [edi*5+DRIVE_DATA+1], ax
220	jnc @f	328	jnc @f
221	mov ecx, [ebx+12]	329	mov ecx, [ebx+12]
222	mov edx, [ebx+16]	330	mov edx, [ebx+16]
223	mov eax, [ebx]	331	mov eax, [ebx]
224	mov dword[image_of_eax], ERROR_UNSUPPORTED_FS	332	mov dword[image_of_eax], ERROR_UNSUPPORTED_FS
225	cmp eax, fs_NumCdServices	333	cmp eax, fs_NumCdServices
226	jae @f	334	jae @f
227	add ebx, 4	335	add ebx, 4
228	push ebp	336	push ebp
229	call dword[fs_CdServices + eax*4]	337	call dword[fs_CdServices + eax*4]
230	pop ebp	338	pop ebp
231	mov [image_of_eax], eax	339	mov [image_of_eax], eax
232	mov [image_of_ebx], ebx	340	mov [image_of_ebx], ebx
233	@@:	341	@@:
234	call free_cd_channel	342	call free_cd_channel
235	and [cd_status], 0	343	and [cd_status], 0
236	stdcall kernel_free, ebp	344	stdcall kernel_free, ebp
237	ret	345	ret
238		346
239	.nextCD:	347	.nextCD:
240	test eax, eax ; partition number	348	test eax, eax ; partition number
241	jnz @f	349	jnz @f
242	inc eax ; /cdX/1	350	inc eax ; /cdX/1
243	ret	351	ret
244		352
245	@@:	353	@@:
246	stc	354	stc
247	ret	355	ret
248		356
249	.maindir: ; list partitions	357	.maindir: ; list partitions
250	mov esi, .nextCD	358	mov esi, .nextCD
251	xor ecx, ecx	359	xor ecx, ecx
252	.maindir_noesi: ; backjump from dyndisk_handler	360	.maindir_noesi: ; backjump from dyndisk_handler
253	push ebp	361	push ebp
254	mov ebp, ecx	362	mov ebp, ecx
255	call kernel_free	363	call kernel_free
256	mov edi, [ebx+16] ; buffer	364	mov edi, [ebx+16] ; buffer
257	cmp byte [ebx], 5	365	cmp byte [ebx], 5
258	jz .deviceInfo	366	jz .deviceInfo
259	cmp byte [ebx], 1 ; read folder?	367	cmp byte [ebx], 1 ; read folder?
260	jnz .access_denied	368	jnz .access_denied
261	push ebp	369	push ebp
262	pushd [ebx+4] ; first block	370	pushd [ebx+4] ; first block
263	mov ebp, [ebx+12] ; the number of blocks to read	371	mov ebp, [ebx+12] ; the number of blocks to read
264	mov ebx, [ebx+8] ; flags	372	mov ebx, [ebx+8] ; flags
265	mov ecx, 32/4	373	mov ecx, 32/4
266	mov edx, edi	374	mov edx, edi
267	xor eax, eax	375	xor eax, eax
268	rep stosd	376	rep stosd
269	mov byte [edx], 1 ; version	377	mov byte [edx], 1 ; version
270	.maindir_loop:	378	.maindir_loop:
271	call esi	379	call esi
272	jc .maindir_done	380	jc .maindir_done
273	inc dword[edx+8]	381	inc dword[edx+8]
274	dec dword[esp]	382	dec dword[esp]
275	jns .maindir_loop	383	jns .maindir_loop
276	dec ebp	384	dec ebp
277	js .maindir_loop	385	js .maindir_loop
278	inc dword[edx+4]	386	inc dword[edx+4]
279	mov dword[edi], 16 ; attributes: folder	387	mov dword[edi], 16 ; attributes: folder
280	mov dword[edi+4], ebx ; name encoding	388	mov dword[edi+4], ebx ; name encoding
281	push eax	389	push eax
282	mov ecx, 32/4	390	mov ecx, 32/4
283	add edi, 8	391	add edi, 8
284	xor eax, eax	392	xor eax, eax
285	rep stosd	393	rep stosd
286	pop eax	394	pop eax
287	push eax edx edi	395	push eax edx edi
288	; convert number in eax to decimal string	396	; convert number in eax to decimal string
289	push -'0'	397	push -'0'
290	mov ecx, 10	398	mov ecx, 10
291	@@:	399	@@:
292	xor edx, edx	400	xor edx, edx
293	div ecx	401	div ecx
294	push edx	402	push edx
295	test eax, eax	403	test eax, eax
296	jnz @b	404	jnz @b
297	cmp ebx, 2	405	cmp ebx, 2
298	jz .uni	406	jz .uni
299	@@:	407	@@:
300	pop eax	408	pop eax
301	add eax, '0'	409	add eax, '0'
302	stosb	410	stosb
303	test eax, eax	411	test eax, eax
304	jnz @b	412	jnz @b
305	pop edi edx eax	413	pop edi edx eax
306	cmp ebx, 3	414	cmp ebx, 3
307	jz @f	415	jz @f
308	add edi, 264	416	add edi, 264
309	jmp .maindir_loop	417	jmp .maindir_loop
310		418
311	.uni:	419	.uni:
312	pop eax	420	pop eax
313	add eax, '0'	421	add eax, '0'
314	stosw	422	stosw
315	test eax, eax	423	test eax, eax
316	jnz .uni	424	jnz .uni
317	pop edi edx eax	425	pop edi edx eax
318	@@:	426	@@:
319	add edi, 520	427	add edi, 520
320	jmp .maindir_loop	428	jmp .maindir_loop
321		429
322	.maindir_done:	430	.maindir_done:
323	pop eax eax	431	pop eax eax
324	mov ebx, [edx+4]	432	mov ebx, [edx+4]
325	xor eax, eax	433	xor eax, eax
326	dec ebp	434	dec ebp
327	js @f	435	js @f
328	mov al, ERROR_END_OF_FILE	436	mov al, ERROR_END_OF_FILE
329	@@:	437	@@:
330	mov [image_of_eax], eax	438	mov [image_of_eax], eax
331	mov [image_of_ebx], ebx	439	mov [image_of_ebx], ebx
332	ret	440	ret
333		441
334	.access_denied:	442	.access_denied:
335	mov dword[image_of_eax], ERROR_ACCESS_DENIED	443	mov dword[image_of_eax], ERROR_ACCESS_DENIED
336	ret	444	ret
337		445
338	.deviceInfo:	446	.deviceInfo:
339	test ebp, ebp	447	test ebp, ebp
340	jz @f	448	jz @f
341	mov eax, dword[ebp+DISK.MediaInfo.Capacity]	449	mov eax, dword[ebp+DISK.MediaInfo.Capacity]
342	mov edx, dword[ebp+DISK.MediaInfo.Capacity+4]	450	mov edx, dword[ebp+DISK.MediaInfo.Capacity+4]
343	shld edx, eax, 9	451	shld edx, eax, 9
344	shl eax, 9	452	shl eax, 9
345	mov [edi+36], edx	453	mov [edi+36], edx
346	mov [edi+32], eax	454	mov [edi+32], eax
347	@@:	455	@@:
348	and dword[image_of_eax], 0	456	and dword[image_of_eax], 0
349	ret	457	ret
350		458
351	.rootdir: ; / - virtual root folder	459	.rootdir: ; / - virtual root folder
352	cmp byte [ebx], 5	460	cmp byte [ebx], 5
353	jz @b	461	jz @b
354	cmp byte [ebx], 1 ; read folder?	462	cmp byte [ebx], 1 ; read folder?
355	jnz .access_denied	463	jnz .access_denied
356	mov ebp, [ebx+12] ; number of blocks	464	mov ebp, [ebx+12] ; number of blocks
357	mov edx, [ebx+16] ; return area	465	mov edx, [ebx+16] ; return area
358	push dword[ebx+4] ; first block	466	push dword[ebx+4] ; first block
359	mov ebx, [ebx+8] ; flags	467	mov ebx, [ebx+8] ; flags
360	mov ecx, 32/4	468	mov ecx, 32/4
361	mov edi, edx	469	mov edi, edx
362	xor eax, eax	470	xor eax, eax
363	rep stosd	471	rep stosd
364	mov byte [edx], 1 ; version	472	mov byte [edx], 1 ; version
365	sub esp, 16	473	sub esp, 16
366	.rootdir_loop:	474	.rootdir_loop:
367	push edi	475	push edi
368	lea edi, [esp+4]	476	lea edi, [esp+4]
369	call dyndisk_enum_root	477	call dyndisk_enum_root
370	pop edi	478	pop edi
371	test eax, eax	479	test eax, eax
372	jz .rootdirCD	480	jz .rootdirCD
373	inc dword[edx+8]	481	inc dword[edx+8]
374	dec dword[esp+16]	482	dec dword[esp+16]
375	jns .rootdir_loop	483	jns .rootdir_loop
376	dec ebp	484	dec ebp
377	js .rootdir_loop	485	js .rootdir_loop
378	inc dword[edx+4]	486	inc dword[edx+4]
379	mov dword[edi], 16 ; attributes: folder	487	mov dword[edi], 16 ; attributes: folder
380	mov dword[edi+4], ebx ; name encoding	488	mov dword[edi+4], ebx ; name encoding
381	push eax	489	push eax
382	mov ecx, 32/4	490	mov ecx, 32/4
383	add edi, 8	491	add edi, 8
384	xor eax, eax	492	xor eax, eax
385	rep stosd	493	rep stosd
386	push edi	494	push edi
387	lea esi, [esp+8]	495	lea esi, [esp+8]
388	cmp ebx, 2	496	cmp ebx, 2
389	jz .uni2	497	jz .uni2
390	@@:	498	@@:
391	lodsb	499	lodsb
392	stosb	500	stosb

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc @ 549 – Rev 9734 → 9894