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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc – Rev 237 → 256