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


$Revision: 431 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; System function 70 - files with long names (LFN)
; diamond, 2006
 
iglobal
; in this table names must be in lowercase
rootdirs:
        db      2,'rd'
        dd      fs_OnRamdisk
        dd      fs_NextRamdisk
        db      7,'ramdisk'
        dd      fs_OnRamdisk
        dd      fs_NextRamdisk
        db      2,'fd'
        dd      fs_OnFloppy
        dd      fs_NextFloppy
        db      10,'floppydisk'
        dd      fs_OnFloppy
        dd      fs_NextFloppy
        db      3,'hd0'
        dd      fs_OnHd0
        dd      fs_NextHd0
        db      3,'hd1'
        dd      fs_OnHd1
        dd      fs_NextHd1
        db      3,'hd2'
        dd      fs_OnHd2
        dd      fs_NextHd2
        db      3,'hd3'
        dd      fs_OnHd3
        dd      fs_NextHd3
;**********************************************
        db      3,'cd0'
        dd      fs_OnCd0
        dd      fs_NextCd
        db      3,'cd1'
        dd      fs_OnCd1
        dd      fs_NextCd
        db      3,'cd2'
        dd      fs_OnCd2
        dd      fs_NextCd
        db      3,'cd3'
        dd      fs_OnCd3
        dd      fs_NextCd
;***********************************************
        db      0
 
 
virtual_root_query:
        dd      fs_HasRamdisk
        db      'rd',0
        dd      fs_HasFloppy
        db      'fd',0
        dd      fs_HasHd0
        db      'hd0',0
        dd      fs_HasHd1
        db      'hd1',0
        dd      fs_HasHd2
        db      'hd2',0
        dd      fs_HasHd3
        db      'hd3',0
;**********************************************
        dd      fs_HasCd0
        db      'cd0',0
        dd      fs_HasCd1
        db      'cd1',0
        dd      fs_HasCd2
        db      'cd2',0
        dd      fs_HasCd3
        db      'cd3',0
;**********************************************
        dd      0
endg
 
file_system_lfn:
; in: eax->fileinfo block
; operation codes:
; 0 : read file
; 1 : read folder
; 2 : create/rewrite file
; 3 : write/append to file
; 4 : set end of file
; 5 : get file/directory attributes structure
; 6 : set file/directory attributes structure
; 7 : start application
; 8 : delete file
; 9 : create directory
 
        add     eax, std_application_base_address
; parse file name
        xchg    ebx, eax
        lea     esi, [ebx+20]
        mov     ebp, esi        ; for 'start app' function full path must be known
        lodsb
        test    al, al
        jnz     @f
        mov     esi, [esi]
        add     esi, std_application_base_address
        mov     ebp, esi
        lodsb
@@:
        cmp dword [ebx], 7
        jne @F
        mov edx, [ebx+4]
        mov ebx, [ebx+8]
        test ebx, ebx
        jz .l1
        add ebx, new_app_base
.l1:
        call fs_execute  ; ebp, ebx, edx
        mov [esp+36], eax
        ret
@@:
        cmp     al, '/'
        jz      @f
.notfound:
        mov     dword [esp+36], 5       ; file not found
        ret
@@:
        cmp     byte [esi], 0
        jz      .rootdir
        mov     edi, rootdirs-8
        xor     ecx, ecx
        push    esi
.scan1:
        pop     esi
        add     edi, ecx
        scasd
        scasd
        mov     cl, byte [edi]
        jecxz   .notfound
        inc     edi
        push    esi
@@:
        lodsb
        or      al, 20h
        scasb
        loopz   @b
        jnz     .scan1
        lodsb
        cmp     al, '/'
        jz      .found1
        test    al, al
        jnz     .scan1
        pop     eax
; directory /xxx
.maindir:
        cmp     dword [ebx], 1
        jnz     .access_denied
        xor     eax, eax
        mov     ebp, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        push    dword [ebx+4]   ; first block
        mov     ebx, [ebx+8]    ; flags
        mov     esi, [edi+4]
; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
        mov     edi, edx
        mov     ecx, 32/4
        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], 0x10       ; attributes: folder
        mov     dword [edi+4], 1        ; name type: UNICODE
        push    eax
        xor     eax, eax
        add     edi, 8
        mov     ecx, 40/4-2
        rep     stosd
        pop     eax
        push    eax edx
; convert number in eax to decimal UNICODE string
        push    edi
        push    -'0'
        mov     cl, 10
@@:
        xor     edx, edx
        div     ecx
        push    edx
        test    eax, eax
        jnz     @b
@@:
        pop     eax
        add     al, '0'
        stosb
        test    bl, 1           ; UNICODE name?
        jz      .ansi2
        mov     byte [edi], 0
        inc     edi
.ansi2:
        test    al, al
        jnz     @b
        mov     byte [edi-1], 0
        pop     edi
; UNICODE name length is 520 bytes, ANSI - 264
        add     edi, 520
        test    bl, 1
        jnz     @f
        sub     edi, 520-264
@@:
        pop     edx eax
        jmp     .maindir_loop
.maindir_done:
        pop     eax
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ebp
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
; directory /
.rootdir:
        cmp     dword [ebx], 1  ; read folder?
        jz      .readroot
.access_denied:
        mov     dword [esp+36], 10      ; access denied
        ret
 
.readroot:
; virtual root folder - special handler
        mov     esi, virtual_root_query
        mov     ebp, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        push    dword [ebx+4]   ; first block
        mov     ebx, [ebx+8]    ; flags
        xor     eax, eax
; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
        mov     edi, edx
        mov     ecx, 32/4
        rep     stosd
        mov     byte [edx], 1   ; version
.readroot_loop:
        cmp     dword [esi], eax
        jz      .readroot_done
        call    dword [esi]
        add     esi, 4
        test    eax, eax
        jnz     @f
.readroot_next:
        or      ecx, -1
        xchg    esi, edi
        repnz   scasb
        xchg    esi, edi
        jmp     .readroot_loop
@@:
        xor     eax, eax
        inc     dword [edx+8]
        dec     dword [esp]
        jns     .readroot_next
        dec     ebp
        js      .readroot_next
        inc     dword [edx+4]
        mov     dword [edi], 0x10       ; attributes: folder
        mov     dword [edi+4], 1        ; name type: UNICODE
        add     edi, 8
        mov     ecx, 40/4-2
        rep     stosd
        push    edi
@@:
        lodsb
        stosb
        test    bl, 1
        jz      .ansi
        mov     byte [edi], 0
        inc     edi
.ansi:
        test    eax, eax
        jnz     @b
        pop     edi
        add     edi, 520
        test    bl, 1
        jnz     .readroot_loop
        sub     edi, 520-264
        jmp     .readroot_loop
.readroot_done:
        pop     eax
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ebp
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
 
.found1:
        pop     eax
        cmp     byte [esi], 0
        jz      .maindir
; read partition number
        xor     ecx, ecx
        xor     eax, eax
@@:
        lodsb
        cmp     al, '/'
        jz      .done1
        test    al, al
        jz      .done1
        sub     al, '0'
        cmp     al, 9
        ja      .notfound
        imul    ecx, 10
        add     ecx, eax
        jmp     @b
.done1:
        test    ecx, ecx
        jz      .notfound
        test    al, al
        jnz     @f
        dec     esi
@@:
; now [edi] contains handler address, ecx - partition number,
; esi points to ASCIIZ string - rest of name
        jmp     dword [edi]
 
; handlers for devices
; in: ecx = 0 => query virtual directory /xxx
; in: ecx = partition number
;     esi -> relative (for device) name
;     ebx -> fileinfo
; out: [esp+36]=image of eax, [esp+24]=image of ebx
 
fs_OnRamdisk:
        cmp     ecx, 1
        jnz     file_system_lfn.notfound
        mov     eax, [ebx]
        cmp     eax, fs_NumRamdiskServices
        jae     .not_impl
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        add     ebx, 4
        call    dword [fs_RamdiskServices + eax*4]
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        mov     dword [esp+36], 2       ; not implemented
        ret
 
fs_NotImplemented:
        mov     eax, 2
        ret
 
fs_RamdiskServices:
        dd      fs_RamdiskRead
        dd      fs_RamdiskReadFolder
        dd      fs_RamdiskRewrite
        dd      fs_RamdiskWrite
        dd      fs_RamdiskSetFileEnd
        dd      fs_RamdiskGetFileInfo
        dd      fs_RamdiskSetFileInfo
        dd      0 ;fs_RamdiskExecute
        dd      fs_RamdiskDelete
        dd      fs_RamdiskCreateFolder
fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
 
fs_OnFloppy:
        cmp     ecx, 2
        ja      file_system_lfn.notfound
        mov     eax, [ebx]
        cmp     eax, fs_NumFloppyServices
        jae     fs_OnRamdisk.not_impl
        call    reserve_flp
        mov     [flp_number], cl
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        add     ebx, 4
        call    dword [fs_FloppyServices + eax*4]
        and     [flp_status], 0
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
 
fs_FloppyServices:
        dd      fs_FloppyRead
        dd      fs_FloppyReadFolder
        dd      fs_FloppyRewrite
        dd      fs_FloppyWrite
        dd      fs_FloppySetFileEnd
        dd      fs_FloppyGetFileInfo
        dd      fs_FloppySetFileInfo
        dd      0 ;fs_FloppyExecute
        dd      fs_FloppyDelete
        dd      fs_FloppyCreateFolder
fs_NumFloppyServices = ($ - fs_FloppyServices)/4
 
fs_OnHd0:
        call    reserve_hd1
        mov     [hdbase], 0x1F0
        mov     [hdid], 0
        push    1
        jmp     fs_OnHd
fs_OnHd1:
        call    reserve_hd1
        mov     [hdbase], 0x1F0
        mov     [hdid], 0x10
        push    2
        jmp     fs_OnHd
fs_OnHd2:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0
        push    3
        jmp     fs_OnHd
fs_OnHd3:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0x10
        push    4
fs_OnHd:
        call    reserve_hd_channel
        pop     eax
        mov     [hdpos], eax
        cmp     ecx, 0x100
        jae     .nf
        cmp     cl, [DRIVE_DATA+1+eax]
        jbe     @f
.nf:
        call    free_hd_channel
        and     [hd1_status], 0
        mov     dword [esp+36], 5       ; not found
        ret
@@:
        mov     [fat32part], ecx
        push    ebx esi
        call    choice_necessity_partition_1
        pop     esi ebx
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        mov     eax, [ebx]
        cmp     eax, fs_NumHdServices
        jae     .not_impl
        add     ebx, 4
        call    dword [fs_HdServices + eax*4]
        call    free_hd_channel
        and     [hd1_status], 0
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        call    free_hd_channel
        and     [hd1_status], 0
        mov     dword [esp+36], 2       ; not implemented
        ret
 
fs_HdServices:
        dd      fs_HdRead
        dd      fs_HdReadFolder
        dd      fs_HdRewrite
        dd      fs_HdWrite
        dd      fs_HdSetFileEnd
        dd      fs_HdGetFileInfo
        dd      fs_HdSetFileInfo
        dd      0 ;fs_HdExecute
        dd      fs_HdDelete
        dd      fs_HdCreateFolder
fs_NumHdServices = ($ - fs_HdServices)/4
 
;*******************************************************
fs_OnCd0:
        call    reserve_cd
        mov  [ChannelNumber],1
        mov  [DiskNumber],0
        push    6
        jmp     fs_OnCd
fs_OnCd1:
        call    reserve_cd
        mov  [ChannelNumber],1
        mov  [DiskNumber],1
        push    4
        jmp     fs_OnCd
fs_OnCd2:
        call    reserve_cd
        mov  [ChannelNumber],2
        mov  [DiskNumber],0
        push    2
        jmp     fs_OnCd
fs_OnCd3:
        call    reserve_cd
        mov  [ChannelNumber],2
        mov  [DiskNumber],1
        push    0
fs_OnCd:
        call    reserve_cd_channel
        pop     eax
        mov     [hdpos], eax
        cmp     ecx, 0x100
        jae     .nf
        push    ecx ebx
        mov     cl,al
        mov     bl,[DRIVE_DATA+1]
        shr     bl,cl
        test    bl,2
        pop     ebx ecx
 
        jnz     @f
.nf:
        call    free_cd_channel
        and    [cd_status], 0
        mov     dword [esp+36], 5       ; not found
        ret
@@:
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        add     edx, std_application_base_address
        mov     eax, [ebx]
        cmp     eax,fs_NumCdServices
        jae      .not_impl
        add     ebx, 4
        call    dword [fs_CdServices + eax*4]
        call    free_cd_channel
        and     [cd_status], 0
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
.not_impl:
        call    free_cd_channel
        and     [cd_status], 0
        mov     dword [esp+36], 2       ; not implemented
        ret
 
fs_CdServices:
        dd      fs_CdRead
        dd      fs_CdReadFolder
        dd      fs_NotImplemented
        dd      fs_NotImplemented
        dd      fs_NotImplemented
        dd      fs_CdGetFileInfo
        dd      fs_NotImplemented
        dd      fs_CdExecute
fs_NumCdServices = ($ - fs_CdServices)/4
 
;*******************************************************
 
fs_HasRamdisk:
        mov     al, 1   ; we always have ramdisk
        ret
 
fs_HasFloppy:
        cmp     byte [DRIVE_DATA], 0
        setnz   al
        ret
 
fs_HasHd0:
        mov     al, [DRIVE_DATA+1]
        and     al, 11000000b
        cmp     al, 01000000b
        setz    al
        ret
fs_HasHd1:
        mov     al, [DRIVE_DATA+1]
        and     al, 00110000b
        cmp     al, 00010000b
        setz    al
        ret
fs_HasHd2:
        mov     al, [DRIVE_DATA+1]
        and     al, 00001100b
        cmp     al, 00000100b
        setz    al
        ret
fs_HasHd3:
        mov     al, [DRIVE_DATA+1]
        and     al, 00000011b
        cmp     al, 00000001b
        setz    al
        ret
 
;*******************************************************
fs_HasCd0:
        mov     al, [DRIVE_DATA+1]
        and     al, 11000000b
        cmp     al, 10000000b
        setz    al
        ret
fs_HasCd1:
        mov     al, [DRIVE_DATA+1]
        and     al, 00110000b
        cmp     al, 00100000b
        setz    al
        ret
fs_HasCd2:
        mov     al, [DRIVE_DATA+1]
        and     al, 00001100b
        cmp     al, 00001000b
        setz    al
        ret
fs_HasCd3:
        mov     al, [DRIVE_DATA+1]
        and     al, 00000011b
        cmp     al, 00000010b
        setz    al
        ret
;*******************************************************
 
; fs_NextXXX functions:
; in: eax = partition number, from which start to scan
; out: CF=1 => no more partitions
;      CF=0 => eax=next partition number
 
fs_NextRamdisk:
; we always have /rd/1
        test    eax, eax
        stc
        jnz     @f
        mov     al, 1
        clc
@@:
        ret
 
fs_NextFloppy:
; we have /fd/1 iff (([DRIVE_DATA] and 0xF0) != 0) and /fd/2 iff (([DRIVE_DATA] and 0x0F) != 0)
        test    byte [DRIVE_DATA], 0xF0
        jz      .no1
        test    eax, eax
        jnz     .no1
        inc     eax
        ret     ; CF cleared
.no1:
        test    byte [DRIVE_DATA], 0x0F
        jz      .no2
        cmp     al, 2
        jae     .no2
        mov     al, 2
        clc
        ret
.no2:
        stc
        ret
 
; on hdx, we have partitions from 1 to [0x40002+x]
fs_NextHd0:
        push    0
        jmp     fs_NextHd
fs_NextHd1:
        push    1
        jmp     fs_NextHd
fs_NextHd2:
        push    2
        jmp     fs_NextHd
fs_NextHd3:
        push    3
fs_NextHd:
        pop     ecx
        movzx   ecx, byte [DRIVE_DATA+2+ecx]
        cmp     eax, ecx
        jae     fs_NextFloppy.no2
        inc     eax
        clc
        ret
 
;*******************************************************
fs_NextCd:
; we always have /cdX/1
        test    eax, eax
        stc
        jnz     @f
        mov     al, 1
        clc
@@:
        ret
;*******************************************************

Rev 425	Rev 431
1	$Revision: 425 $	1	$Revision: 431 $
-		2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		3	;; ;;
-		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
-		5	;; Distributed under terms of the GNU General Public License ;;
-		6	;; ;;
-		7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		8
2	; System function 70 - files with long names (LFN)	9	; System function 70 - files with long names (LFN)
3	; diamond, 2006	10	; diamond, 2006
4		11
5	iglobal	12	iglobal
6	; in this table names must be in lowercase	13	; in this table names must be in lowercase
7	rootdirs:	14	rootdirs:
8	db 2,'rd'	15	db 2,'rd'
9	dd fs_OnRamdisk	16	dd fs_OnRamdisk
10	dd fs_NextRamdisk	17	dd fs_NextRamdisk
11	db 7,'ramdisk'	18	db 7,'ramdisk'
12	dd fs_OnRamdisk	19	dd fs_OnRamdisk
13	dd fs_NextRamdisk	20	dd fs_NextRamdisk
14	db 2,'fd'	21	db 2,'fd'
15	dd fs_OnFloppy	22	dd fs_OnFloppy
16	dd fs_NextFloppy	23	dd fs_NextFloppy
17	db 10,'floppydisk'	24	db 10,'floppydisk'
18	dd fs_OnFloppy	25	dd fs_OnFloppy
19	dd fs_NextFloppy	26	dd fs_NextFloppy
20	db 3,'hd0'	27	db 3,'hd0'
21	dd fs_OnHd0	28	dd fs_OnHd0
22	dd fs_NextHd0	29	dd fs_NextHd0
23	db 3,'hd1'	30	db 3,'hd1'
24	dd fs_OnHd1	31	dd fs_OnHd1
25	dd fs_NextHd1	32	dd fs_NextHd1
26	db 3,'hd2'	33	db 3,'hd2'
27	dd fs_OnHd2	34	dd fs_OnHd2
28	dd fs_NextHd2	35	dd fs_NextHd2
29	db 3,'hd3'	36	db 3,'hd3'
30	dd fs_OnHd3	37	dd fs_OnHd3
31	dd fs_NextHd3	38	dd fs_NextHd3
32	;**********************************************	39	;**********************************************
33	db 3,'cd0'	40	db 3,'cd0'
34	dd fs_OnCd0	41	dd fs_OnCd0
35	dd fs_NextCd	42	dd fs_NextCd
36	db 3,'cd1'	43	db 3,'cd1'
37	dd fs_OnCd1	44	dd fs_OnCd1
38	dd fs_NextCd	45	dd fs_NextCd
39	db 3,'cd2'	46	db 3,'cd2'
40	dd fs_OnCd2	47	dd fs_OnCd2
41	dd fs_NextCd	48	dd fs_NextCd
42	db 3,'cd3'	49	db 3,'cd3'
43	dd fs_OnCd3	50	dd fs_OnCd3
44	dd fs_NextCd	51	dd fs_NextCd
45	;***********************************************	52	;***********************************************
46	db 0	53	db 0
47		54
48		55
49	virtual_root_query:	56	virtual_root_query:
50	dd fs_HasRamdisk	57	dd fs_HasRamdisk
51	db 'rd',0	58	db 'rd',0
52	dd fs_HasFloppy	59	dd fs_HasFloppy
53	db 'fd',0	60	db 'fd',0
54	dd fs_HasHd0	61	dd fs_HasHd0
55	db 'hd0',0	62	db 'hd0',0
56	dd fs_HasHd1	63	dd fs_HasHd1
57	db 'hd1',0	64	db 'hd1',0
58	dd fs_HasHd2	65	dd fs_HasHd2
59	db 'hd2',0	66	db 'hd2',0
60	dd fs_HasHd3	67	dd fs_HasHd3
61	db 'hd3',0	68	db 'hd3',0
62	;**********************************************	69	;**********************************************
63	dd fs_HasCd0	70	dd fs_HasCd0
64	db 'cd0',0	71	db 'cd0',0
65	dd fs_HasCd1	72	dd fs_HasCd1
66	db 'cd1',0	73	db 'cd1',0
67	dd fs_HasCd2	74	dd fs_HasCd2
68	db 'cd2',0	75	db 'cd2',0
69	dd fs_HasCd3	76	dd fs_HasCd3
70	db 'cd3',0	77	db 'cd3',0
71	;**********************************************	78	;**********************************************
72	dd 0	79	dd 0
73	endg	80	endg
74		81
75	file_system_lfn:	82	file_system_lfn:
76	; in: eax->fileinfo block	83	; in: eax->fileinfo block
77	; operation codes:	84	; operation codes:
78	; 0 : read file	85	; 0 : read file
79	; 1 : read folder	86	; 1 : read folder
80	; 2 : create/rewrite file	87	; 2 : create/rewrite file
81	; 3 : write/append to file	88	; 3 : write/append to file
82	; 4 : set end of file	89	; 4 : set end of file
83	; 5 : get file/directory attributes structure	90	; 5 : get file/directory attributes structure
84	; 6 : set file/directory attributes structure	91	; 6 : set file/directory attributes structure
85	; 7 : start application	92	; 7 : start application
86	; 8 : delete file	93	; 8 : delete file
87	; 9 : create directory	94	; 9 : create directory
88		95
89	add eax, std_application_base_address	96	add eax, std_application_base_address
90	; parse file name	97	; parse file name
91	xchg ebx, eax	98	xchg ebx, eax
92	lea esi, [ebx+20]	99	lea esi, [ebx+20]
93	mov ebp, esi ; for 'start app' function full path must be known	100	mov ebp, esi ; for 'start app' function full path must be known
94	lodsb	101	lodsb
95	test al, al	102	test al, al
96	jnz @f	103	jnz @f
97	mov esi, [esi]	104	mov esi, [esi]
98	add esi, std_application_base_address	105	add esi, std_application_base_address
99	mov ebp, esi	106	mov ebp, esi
100	lodsb	107	lodsb
101	@@:	108	@@:
102	cmp dword [ebx], 7	109	cmp dword [ebx], 7
103	jne @F	110	jne @F
104	mov edx, [ebx+4]	111	mov edx, [ebx+4]
105	mov ebx, [ebx+8]	112	mov ebx, [ebx+8]
106	test ebx, ebx	113	test ebx, ebx
107	jz .l1	114	jz .l1
108	add ebx, new_app_base	115	add ebx, new_app_base
109	.l1:	116	.l1:
110	call fs_execute ; ebp, ebx, edx	117	call fs_execute ; ebp, ebx, edx
111	mov [esp+36], eax	118	mov [esp+36], eax
112	ret	119	ret
113	@@:	120	@@:
114	cmp al, '/'	121	cmp al, '/'
115	jz @f	122	jz @f
116	.notfound:	123	.notfound:
117	mov dword [esp+36], 5 ; file not found	124	mov dword [esp+36], 5 ; file not found
118	ret	125	ret
119	@@:	126	@@:
120	cmp byte [esi], 0	127	cmp byte [esi], 0
121	jz .rootdir	128	jz .rootdir
122	mov edi, rootdirs-8	129	mov edi, rootdirs-8
123	xor ecx, ecx	130	xor ecx, ecx
124	push esi	131	push esi
125	.scan1:	132	.scan1:
126	pop esi	133	pop esi
127	add edi, ecx	134	add edi, ecx
128	scasd	135	scasd
129	scasd	136	scasd
130	mov cl, byte [edi]	137	mov cl, byte [edi]
131	jecxz .notfound	138	jecxz .notfound
132	inc edi	139	inc edi
133	push esi	140	push esi
134	@@:	141	@@:
135	lodsb	142	lodsb
136	or al, 20h	143	or al, 20h
137	scasb	144	scasb
138	loopz @b	145	loopz @b
139	jnz .scan1	146	jnz .scan1
140	lodsb	147	lodsb
141	cmp al, '/'	148	cmp al, '/'
142	jz .found1	149	jz .found1
143	test al, al	150	test al, al
144	jnz .scan1	151	jnz .scan1
145	pop eax	152	pop eax
146	; directory /xxx	153	; directory /xxx
147	.maindir:	154	.maindir:
148	cmp dword [ebx], 1	155	cmp dword [ebx], 1
149	jnz .access_denied	156	jnz .access_denied
150	xor eax, eax	157	xor eax, eax
151	mov ebp, [ebx+12]	158	mov ebp, [ebx+12]
152	mov edx, [ebx+16]	159	mov edx, [ebx+16]
153	add edx, std_application_base_address	160	add edx, std_application_base_address
154	push dword [ebx+4] ; first block	161	push dword [ebx+4] ; first block
155	mov ebx, [ebx+8] ; flags	162	mov ebx, [ebx+8] ; flags
156	mov esi, [edi+4]	163	mov esi, [edi+4]
157	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler	164	; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler
158	mov edi, edx	165	mov edi, edx
159	mov ecx, 32/4	166	mov ecx, 32/4
160	rep stosd	167	rep stosd
161	mov byte [edx], 1 ; version	168	mov byte [edx], 1 ; version
162	.maindir_loop:	169	.maindir_loop:
163	call esi	170	call esi
164	jc .maindir_done	171	jc .maindir_done
165	inc dword [edx+8]	172	inc dword [edx+8]
166	dec dword [esp]	173	dec dword [esp]
167	jns .maindir_loop	174	jns .maindir_loop
168	dec ebp	175	dec ebp
169	js .maindir_loop	176	js .maindir_loop
170	inc dword [edx+4]	177	inc dword [edx+4]
171	mov dword [edi], 0x10 ; attributes: folder	178	mov dword [edi], 0x10 ; attributes: folder
172	mov dword [edi+4], 1 ; name type: UNICODE	179	mov dword [edi+4], 1 ; name type: UNICODE
173	push eax	180	push eax
174	xor eax, eax	181	xor eax, eax
175	add edi, 8	182	add edi, 8
176	mov ecx, 40/4-2	183	mov ecx, 40/4-2
177	rep stosd	184	rep stosd
178	pop eax	185	pop eax
179	push eax edx	186	push eax edx
180	; convert number in eax to decimal UNICODE string	187	; convert number in eax to decimal UNICODE string
181	push edi	188	push edi
182	push -'0'	189	push -'0'
183	mov cl, 10	190	mov cl, 10
184	@@:	191	@@:
185	xor edx, edx	192	xor edx, edx
186	div ecx	193	div ecx
187	push edx	194	push edx
188	test eax, eax	195	test eax, eax
189	jnz @b	196	jnz @b
190	@@:	197	@@:
191	pop eax	198	pop eax
192	add al, '0'	199	add al, '0'
193	stosb	200	stosb
194	test bl, 1 ; UNICODE name?	201	test bl, 1 ; UNICODE name?
195	jz .ansi2	202	jz .ansi2
196	mov byte [edi], 0	203	mov byte [edi], 0
197	inc edi	204	inc edi
198	.ansi2:	205	.ansi2:
199	test al, al	206	test al, al
200	jnz @b	207	jnz @b
201	mov byte [edi-1], 0	208	mov byte [edi-1], 0
202	pop edi	209	pop edi
203	; UNICODE name length is 520 bytes, ANSI - 264	210	; UNICODE name length is 520 bytes, ANSI - 264
204	add edi, 520	211	add edi, 520
205	test bl, 1	212	test bl, 1
206	jnz @f	213	jnz @f
207	sub edi, 520-264	214	sub edi, 520-264
208	@@:	215	@@:
209	pop edx eax	216	pop edx eax
210	jmp .maindir_loop	217	jmp .maindir_loop
211	.maindir_done:	218	.maindir_done:
212	pop eax	219	pop eax
213	mov ebx, [edx+4]	220	mov ebx, [edx+4]
214	xor eax, eax	221	xor eax, eax
215	dec ebp	222	dec ebp
216	js @f	223	js @f
217	mov al, ERROR_END_OF_FILE	224	mov al, ERROR_END_OF_FILE
218	@@:	225	@@:
219	mov [esp+36], eax	226	mov [esp+36], eax
220	mov [esp+24], ebx	227	mov [esp+24], ebx
221	ret	228	ret
222	; directory /	229	; directory /
223	.rootdir:	230	.rootdir:
224	cmp dword [ebx], 1 ; read folder?	231	cmp dword [ebx], 1 ; read folder?
225	jz .readroot	232	jz .readroot
226	.access_denied:	233	.access_denied:
227	mov dword [esp+36], 10 ; access denied	234	mov dword [esp+36], 10 ; access denied
228	ret	235	ret
229		236
230	.readroot:	237	.readroot:
231	; virtual root folder - special handler	238	; virtual root folder - special handler
232	mov esi, virtual_root_query	239	mov esi, virtual_root_query
233	mov ebp, [ebx+12]	240	mov ebp, [ebx+12]
234	mov edx, [ebx+16]	241	mov edx, [ebx+16]
235	add edx, std_application_base_address	242	add edx, std_application_base_address
236	push dword [ebx+4] ; first block	243	push dword [ebx+4] ; first block
237	mov ebx, [ebx+8] ; flags	244	mov ebx, [ebx+8] ; flags
238	xor eax, eax	245	xor eax, eax
239	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area	246	; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area
240	mov edi, edx	247	mov edi, edx
241	mov ecx, 32/4	248	mov ecx, 32/4
242	rep stosd	249	rep stosd
243	mov byte [edx], 1 ; version	250	mov byte [edx], 1 ; version
244	.readroot_loop:	251	.readroot_loop:
245	cmp dword [esi], eax	252	cmp dword [esi], eax
246	jz .readroot_done	253	jz .readroot_done
247	call dword [esi]	254	call dword [esi]
248	add esi, 4	255	add esi, 4
249	test eax, eax	256	test eax, eax
250	jnz @f	257	jnz @f
251	.readroot_next:	258	.readroot_next:
252	or ecx, -1	259	or ecx, -1
253	xchg esi, edi	260	xchg esi, edi
254	repnz scasb	261	repnz scasb
255	xchg esi, edi	262	xchg esi, edi
256	jmp .readroot_loop	263	jmp .readroot_loop
257	@@:	264	@@:
258	xor eax, eax	265	xor eax, eax
259	inc dword [edx+8]	266	inc dword [edx+8]
260	dec dword [esp]	267	dec dword [esp]
261	jns .readroot_next	268	jns .readroot_next
262	dec ebp	269	dec ebp
263	js .readroot_next	270	js .readroot_next
264	inc dword [edx+4]	271	inc dword [edx+4]
265	mov dword [edi], 0x10 ; attributes: folder	272	mov dword [edi], 0x10 ; attributes: folder
266	mov dword [edi+4], 1 ; name type: UNICODE	273	mov dword [edi+4], 1 ; name type: UNICODE
267	add edi, 8	274	add edi, 8
268	mov ecx, 40/4-2	275	mov ecx, 40/4-2
269	rep stosd	276	rep stosd
270	push edi	277	push edi
271	@@:	278	@@:
272	lodsb	279	lodsb
273	stosb	280	stosb
274	test bl, 1	281	test bl, 1
275	jz .ansi	282	jz .ansi
276	mov byte [edi], 0	283	mov byte [edi], 0
277	inc edi	284	inc edi
278	.ansi:	285	.ansi:
279	test eax, eax	286	test eax, eax
280	jnz @b	287	jnz @b
281	pop edi	288	pop edi
282	add edi, 520	289	add edi, 520
283	test bl, 1	290	test bl, 1
284	jnz .readroot_loop	291	jnz .readroot_loop
285	sub edi, 520-264	292	sub edi, 520-264
286	jmp .readroot_loop	293	jmp .readroot_loop
287	.readroot_done:	294	.readroot_done:
288	pop eax	295	pop eax
289	mov ebx, [edx+4]	296	mov ebx, [edx+4]
290	xor eax, eax	297	xor eax, eax
291	dec ebp	298	dec ebp
292	js @f	299	js @f
293	mov al, ERROR_END_OF_FILE	300	mov al, ERROR_END_OF_FILE
294	@@:	301	@@:
295	mov [esp+36], eax	302	mov [esp+36], eax
296	mov [esp+24], ebx	303	mov [esp+24], ebx
297	ret	304	ret
298		305
299	.found1:	306	.found1:
300	pop eax	307	pop eax
301	cmp byte [esi], 0	308	cmp byte [esi], 0
302	jz .maindir	309	jz .maindir
303	; read partition number	310	; read partition number
304	xor ecx, ecx	311	xor ecx, ecx
305	xor eax, eax	312	xor eax, eax
306	@@:	313	@@:
307	lodsb	314	lodsb
308	cmp al, '/'	315	cmp al, '/'
309	jz .done1	316	jz .done1
310	test al, al	317	test al, al
311	jz .done1	318	jz .done1
312	sub al, '0'	319	sub al, '0'
313	cmp al, 9	320	cmp al, 9
314	ja .notfound	321	ja .notfound
315	imul ecx, 10	322	imul ecx, 10
316	add ecx, eax	323	add ecx, eax
317	jmp @b	324	jmp @b
318	.done1:	325	.done1:
319	test ecx, ecx	326	test ecx, ecx
320	jz .notfound	327	jz .notfound
321	test al, al	328	test al, al
322	jnz @f	329	jnz @f
323	dec esi	330	dec esi
324	@@:	331	@@:
325	; now [edi] contains handler address, ecx - partition number,	332	; now [edi] contains handler address, ecx - partition number,
326	; esi points to ASCIIZ string - rest of name	333	; esi points to ASCIIZ string - rest of name
327	jmp dword [edi]	334	jmp dword [edi]
328		335
329	; handlers for devices	336	; handlers for devices
330	; in: ecx = 0 => query virtual directory /xxx	337	; in: ecx = 0 => query virtual directory /xxx
331	; in: ecx = partition number	338	; in: ecx = partition number
332	; esi -> relative (for device) name	339	; esi -> relative (for device) name
333	; ebx -> fileinfo	340	; ebx -> fileinfo
334	; out: [esp+36]=image of eax, [esp+24]=image of ebx	341	; out: [esp+36]=image of eax, [esp+24]=image of ebx
335		342
336	fs_OnRamdisk:	343	fs_OnRamdisk:
337	cmp ecx, 1	344	cmp ecx, 1
338	jnz file_system_lfn.notfound	345	jnz file_system_lfn.notfound
339	mov eax, [ebx]	346	mov eax, [ebx]
340	cmp eax, fs_NumRamdiskServices	347	cmp eax, fs_NumRamdiskServices
341	jae .not_impl	348	jae .not_impl
342	mov ecx, [ebx+12]	349	mov ecx, [ebx+12]
343	mov edx, [ebx+16]	350	mov edx, [ebx+16]
344	add edx, std_application_base_address	351	add edx, std_application_base_address
345	add ebx, 4	352	add ebx, 4
346	call dword [fs_RamdiskServices + eax*4]	353	call dword [fs_RamdiskServices + eax*4]
347	mov [esp+36], eax	354	mov [esp+36], eax
348	mov [esp+24], ebx	355	mov [esp+24], ebx
349	ret	356	ret
350	.not_impl:	357	.not_impl:
351	mov dword [esp+36], 2 ; not implemented	358	mov dword [esp+36], 2 ; not implemented
352	ret	359	ret
353		360
354	fs_NotImplemented:	361	fs_NotImplemented:
355	mov eax, 2	362	mov eax, 2
356	ret	363	ret
357		364
358	fs_RamdiskServices:	365	fs_RamdiskServices:
359	dd fs_RamdiskRead	366	dd fs_RamdiskRead
360	dd fs_RamdiskReadFolder	367	dd fs_RamdiskReadFolder
361	dd fs_RamdiskRewrite	368	dd fs_RamdiskRewrite
362	dd fs_RamdiskWrite	369	dd fs_RamdiskWrite
363	dd fs_RamdiskSetFileEnd	370	dd fs_RamdiskSetFileEnd
364	dd fs_RamdiskGetFileInfo	371	dd fs_RamdiskGetFileInfo
365	dd fs_RamdiskSetFileInfo	372	dd fs_RamdiskSetFileInfo
366	dd 0 ;fs_RamdiskExecute	373	dd 0 ;fs_RamdiskExecute
367	dd fs_RamdiskDelete	374	dd fs_RamdiskDelete
368	dd fs_RamdiskCreateFolder	375	dd fs_RamdiskCreateFolder
369	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4	376	fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4
370		377
371	fs_OnFloppy:	378	fs_OnFloppy:
372	cmp ecx, 2	379	cmp ecx, 2
373	ja file_system_lfn.notfound	380	ja file_system_lfn.notfound
374	mov eax, [ebx]	381	mov eax, [ebx]
375	cmp eax, fs_NumFloppyServices	382	cmp eax, fs_NumFloppyServices
376	jae fs_OnRamdisk.not_impl	383	jae fs_OnRamdisk.not_impl
377	call reserve_flp	384	call reserve_flp
378	mov [flp_number], cl	385	mov [flp_number], cl
379	mov ecx, [ebx+12]	386	mov ecx, [ebx+12]
380	mov edx, [ebx+16]	387	mov edx, [ebx+16]
381	add edx, std_application_base_address	388	add edx, std_application_base_address
382	add ebx, 4	389	add ebx, 4
383	call dword [fs_FloppyServices + eax*4]	390	call dword [fs_FloppyServices + eax*4]
384	and [flp_status], 0	391	and [flp_status], 0
385	mov [esp+36], eax	392	mov [esp+36], eax
386	mov [esp+24], ebx	393	mov [esp+24], ebx
387	ret	394	ret
388		395
389	fs_FloppyServices:	396	fs_FloppyServices:
390	dd fs_FloppyRead	397	dd fs_FloppyRead
391	dd fs_FloppyReadFolder	398	dd fs_FloppyReadFolder
392	dd fs_FloppyRewrite	399	dd fs_FloppyRewrite
393	dd fs_FloppyWrite	400	dd fs_FloppyWrite
394	dd fs_FloppySetFileEnd	401	dd fs_FloppySetFileEnd
395	dd fs_FloppyGetFileInfo	402	dd fs_FloppyGetFileInfo
396	dd fs_FloppySetFileInfo	403	dd fs_FloppySetFileInfo
397	dd 0 ;fs_FloppyExecute	404	dd 0 ;fs_FloppyExecute
398	dd fs_FloppyDelete	405	dd fs_FloppyDelete
399	dd fs_FloppyCreateFolder	406	dd fs_FloppyCreateFolder
400	fs_NumFloppyServices = ($ - fs_FloppyServices)/4	407	fs_NumFloppyServices = ($ - fs_FloppyServices)/4
401		408
402	fs_OnHd0:	409	fs_OnHd0:
403	call reserve_hd1	410	call reserve_hd1
404	mov [hdbase], 0x1F0	411	mov [hdbase], 0x1F0
405	mov [hdid], 0	412	mov [hdid], 0
406	push 1	413	push 1
407	jmp fs_OnHd	414	jmp fs_OnHd
408	fs_OnHd1:	415	fs_OnHd1:
409	call reserve_hd1	416	call reserve_hd1
410	mov [hdbase], 0x1F0	417	mov [hdbase], 0x1F0
411	mov [hdid], 0x10	418	mov [hdid], 0x10
412	push 2	419	push 2
413	jmp fs_OnHd	420	jmp fs_OnHd
414	fs_OnHd2:	421	fs_OnHd2:
415	call reserve_hd1	422	call reserve_hd1
416	mov [hdbase], 0x170	423	mov [hdbase], 0x170
417	mov [hdid], 0	424	mov [hdid], 0
418	push 3	425	push 3
419	jmp fs_OnHd	426	jmp fs_OnHd
420	fs_OnHd3:	427	fs_OnHd3:
421	call reserve_hd1	428	call reserve_hd1
422	mov [hdbase], 0x170	429	mov [hdbase], 0x170
423	mov [hdid], 0x10	430	mov [hdid], 0x10
424	push 4	431	push 4
425	fs_OnHd:	432	fs_OnHd:
426	call reserve_hd_channel	433	call reserve_hd_channel
427	pop eax	434	pop eax
428	mov [hdpos], eax	435	mov [hdpos], eax
429	cmp ecx, 0x100	436	cmp ecx, 0x100
430	jae .nf	437	jae .nf
431	cmp cl, [DRIVE_DATA+1+eax]	438	cmp cl, [DRIVE_DATA+1+eax]
432	jbe @f	439	jbe @f
433	.nf:	440	.nf:
434	call free_hd_channel	441	call free_hd_channel
435	and [hd1_status], 0	442	and [hd1_status], 0
436	mov dword [esp+36], 5 ; not found	443	mov dword [esp+36], 5 ; not found
437	ret	444	ret
438	@@:	445	@@:
439	mov [fat32part], ecx	446	mov [fat32part], ecx
440	push ebx esi	447	push ebx esi
441	call choice_necessity_partition_1	448	call choice_necessity_partition_1
442	pop esi ebx	449	pop esi ebx
443	mov ecx, [ebx+12]	450	mov ecx, [ebx+12]
444	mov edx, [ebx+16]	451	mov edx, [ebx+16]
445	add edx, std_application_base_address	452	add edx, std_application_base_address
446	mov eax, [ebx]	453	mov eax, [ebx]
447	cmp eax, fs_NumHdServices	454	cmp eax, fs_NumHdServices
448	jae .not_impl	455	jae .not_impl
449	add ebx, 4	456	add ebx, 4
450	call dword [fs_HdServices + eax*4]	457	call dword [fs_HdServices + eax*4]
451	call free_hd_channel	458	call free_hd_channel
452	and [hd1_status], 0	459	and [hd1_status], 0
453	mov [esp+36], eax	460	mov [esp+36], eax
454	mov [esp+24], ebx	461	mov [esp+24], ebx
455	ret	462	ret
456	.not_impl:	463	.not_impl:
457	call free_hd_channel	464	call free_hd_channel
458	and [hd1_status], 0	465	and [hd1_status], 0
459	mov dword [esp+36], 2 ; not implemented	466	mov dword [esp+36], 2 ; not implemented
460	ret	467	ret
461		468
462	fs_HdServices:	469	fs_HdServices:
463	dd fs_HdRead	470	dd fs_HdRead
464	dd fs_HdReadFolder	471	dd fs_HdReadFolder
465	dd fs_HdRewrite	472	dd fs_HdRewrite
466	dd fs_HdWrite	473	dd fs_HdWrite
467	dd fs_HdSetFileEnd	474	dd fs_HdSetFileEnd
468	dd fs_HdGetFileInfo	475	dd fs_HdGetFileInfo
469	dd fs_HdSetFileInfo	476	dd fs_HdSetFileInfo
470	dd 0 ;fs_HdExecute	477	dd 0 ;fs_HdExecute
471	dd fs_HdDelete	478	dd fs_HdDelete
472	dd fs_HdCreateFolder	479	dd fs_HdCreateFolder
473	fs_NumHdServices = ($ - fs_HdServices)/4	480	fs_NumHdServices = ($ - fs_HdServices)/4
474		481
475	;*******************************************************	482	;*******************************************************
476	fs_OnCd0:	483	fs_OnCd0:
477	call reserve_cd	484	call reserve_cd
478	mov [ChannelNumber],1	485	mov [ChannelNumber],1
479	mov [DiskNumber],0	486	mov [DiskNumber],0
480	push 6	487	push 6
481	jmp fs_OnCd	488	jmp fs_OnCd
482	fs_OnCd1:	489	fs_OnCd1:
483	call reserve_cd	490	call reserve_cd
484	mov [ChannelNumber],1	491	mov [ChannelNumber],1
485	mov [DiskNumber],1	492	mov [DiskNumber],1
486	push 4	493	push 4
487	jmp fs_OnCd	494	jmp fs_OnCd
488	fs_OnCd2:	495	fs_OnCd2:
489	call reserve_cd	496	call reserve_cd
490	mov [ChannelNumber],2	497	mov [ChannelNumber],2
491	mov [DiskNumber],0	498	mov [DiskNumber],0
492	push 2	499	push 2
493	jmp fs_OnCd	500	jmp fs_OnCd

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc – Rev 425 → 431