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


 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 593 $
 
 
image_of_eax EQU esp+36
image_of_ebx EQU esp+24
 
; 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
 
; parse file name
	xchg	ebx, eax
	lea	esi, [ebx+20]
	lodsb
	test	al, al
	jnz	@f
	mov	esi, [esi]
	lodsb
@@:
	cmp	al, '/'
	jz	.notcurdir
	dec	esi
	mov	ebp, esi
	test	al, al
	jnz	@f
	xor	ebp, ebp
@@:
	mov	esi, [current_slot]
	mov	esi, [esi+APPDATA.cur_dir]
	jmp	.parse_normal
.notcurdir:
	cmp	byte [esi], 0
	jz	.rootdir
	call	process_replace_file_name
.parse_normal:
	cmp dword [ebx], 7
	jne @F
	mov edx, [ebx+4]
	mov ebx, [ebx+8]
	call fs_execute  ; esi+ebp, ebx, edx
	mov [image_of_eax], eax
	ret
@@:
	mov	edi, rootdirs-8
	xor	ecx, ecx
	push	esi
.scan1:
	pop	esi
	add	edi, ecx
	scasd
	scasd
	mov	cl, byte [edi]
	test	cl, cl
	jz	.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	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
; directory /
.rootdir:
	cmp	dword [ebx], 1	; read folder?
	jz	.readroot
.access_denied:
	mov	dword [image_of_eax], 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	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.notfound:
	mov	dword [image_of_eax], ERROR_FILE_NOT_FOUND
	and	dword [image_of_ebx], 0
	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
	lea	ecx, [ecx*5]
	lea	ecx, [ecx*2+eax]
	jmp	@b
.done1:
	jecxz	.notfound
	test	al, al
	jnz	@f
	dec	esi
@@:
	cmp	byte [esi], 0
	jnz	@f
	test	ebp, ebp
	jz	@f
	mov	esi, ebp
	xor	ebp, ebp
@@:
; 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
;     ebp = 0 or pointer to rest of name from folder addressed by esi
; out: [image_of_eax]=image of eax, [image_of_ebx]=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	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	mov	dword [image_of_eax], 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
	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	[image_of_eax], eax
	mov	[image_of_ebx], 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
	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 [image_of_eax], 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	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	call	free_hd_channel
	and	[hd1_status], 0
	mov	dword [image_of_eax], 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
	dd	fs_HdDelete
	dd	fs_HdCreateFolder
fs_NumHdServices = ($ - fs_HdServices)/4
 
;*******************************************************
fs_OnCd0:
	call	reserve_cd
	mov  [ChannelNumber],1
	mov  [DiskNumber],0
	push	6
	push	1
	jmp	fs_OnCd
fs_OnCd1:
	call	reserve_cd
	mov  [ChannelNumber],1
	mov  [DiskNumber],1
	push	4
	push	2
	jmp	fs_OnCd
fs_OnCd2:
	call	reserve_cd
	mov  [ChannelNumber],2
	mov  [DiskNumber],0
	push	2
	push	3
	jmp	fs_OnCd
fs_OnCd3:
	call	reserve_cd
	mov  [ChannelNumber],2
	mov  [DiskNumber],1
	push	0
	push	4
fs_OnCd:
	call	reserve_cd_channel
	pop	eax
	mov	[cdpos], eax
	pop	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 [image_of_eax], 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	[image_of_eax], eax
	mov	[image_of_ebx], ebx
	ret
.not_impl:
	call	free_cd_channel
	and	[cd_status], 0
	mov	dword [image_of_eax], 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	0
	dd	fs_NotImplemented
	dd	fs_NotImplemented
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
;*******************************************************
 
process_replace_file_name:
	mov	ebp, [full_file_name_table]
	mov	edi, [full_file_name_table.size]
	dec	edi
	shl	edi, 7
	add	edi, ebp
.loop:
	cmp	edi, ebp
	jb	.notfound
	push	esi edi
@@:
	cmp	byte [edi], 0
	jz	.dest_done
	lodsb
	test	al, al
	jz	.cont
	or	al, 20h
	scasb
	jz	@b
	jmp	.cont
.dest_done:
	cmp	byte [esi], 0
	jz	.found
	cmp	byte [esi], '/'
	jnz	.cont
	inc	esi
	jmp	.found
.cont:
	pop	edi esi
	sub	edi, 128
	jmp	.loop
.found:
	pop	edi eax
	mov	ebp, esi
	cmp	byte [esi], 0
	lea	esi, [edi+64]
	jnz	.ret
.notfound:
	xor	ebp, ebp
.ret:
	ret
 
sys_current_directory:
	mov	esi, [current_slot]
	mov	esi, [esi+APPDATA.cur_dir]
	mov	edx, esi
	dec	eax
	jz	.set
	dec	eax
	jz	.get
	ret
.get:
; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len
; for our code: ebx->buffer,ecx=len
@@:
	lodsb
	test	al, al
	jnz	@b
	sub	esi, edx
	inc	esi
	mov	[esp+36], esi
	cmp	ecx, esi
	jbe	@f
	mov	ecx, esi
@@:
	cmp	ecx, 1
	jbe	.ret
	mov	esi, edx
	mov	edi, ebx
	mov	al, '/'
	stosb
	dec	ecx
	dec	ecx
	rep	movsb
	mov	byte [edi], 0
.ret:
	ret
.set:
; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string
; for our code: ebx->string to set
@@:
	inc	esi
	cmp	byte [esi-1], 0
	jnz	@b
	dec	esi
	cmp	byte [ebx], '/'
	jz	.set_absolute
; string gives relative path
.relative:
	cmp	byte [ebx], 0
	jz	.set_ok
	cmp	word [ebx], '.'
	jz	.set_ok
	cmp	word [ebx], './'
	jnz	@f
	add	ebx, 2
	jmp	.relative
@@:
	cmp	word [ebx], '..'
	jnz	.doset_relative
	cmp	byte [ebx+2], 0
	jz	@f
	cmp	byte [ebx+2], '/'
	jnz	.doset_relative
@@:
	dec	esi
	cmp	byte [esi], '/'
	jnz	@b
	mov	byte [esi], 0
	add	ebx, 3
	jmp	.relative
.doset_relative:
	add	edx, 0x1000
	mov	byte [esi], '/'
	inc	esi
	cmp	esi, edx
	jae	.overflow_esi
@@:
	mov	al, [ebx]
	inc	ebx
	mov	[esi], al
	inc	esi
	test	al, al
	jz	.set_ok
	cmp	esi, edx
	jb	@b
.overflow_esi:
	mov	byte [esi-1], 0 	; force null-terminated string
.set_ok:
	ret
.set_absolute:
	lea	esi, [ebx+1]
	call	process_replace_file_name
	mov	edi, edx
	add	edx, 0x1000
.set_copy:
	lodsb
	stosb
	test	al, al
	jz	.set_part2
.set_copy_cont:
	cmp	edi, edx
	jb	.set_copy
.overflow_edi:
	mov	byte [edi-1], 0
	ret
.set_part2:
	mov	esi, ebp
	xor	ebp, ebp
	test	esi, esi
	jz	.set_ok
	mov	byte [edi-1], '/'
	jmp	.set_copy_cont

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fs_lfn.inc – Rev 588 → 593