keXa/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

coalesce reads for file content on FAT

Browse Source 
git-svn-id: svn://kolibrios.org@5578 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Pathoswithin 2015-07-17 16:45:23 +00:00
parent e9583ee97f
commit 8ac94ee0c0
1 changed files with 174 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
kernel/trunk/fs/fat.inc
View File

@ -1,15 +1,14 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; FAT32.INC ;;
;; ;;
;; FAT functions for KolibriOS ;; ;; FAT functions for KolibriOS ;;
;; ;; ;; ;;
;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;; ;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;;
;; ;; ;; ;;
;; See file COPYING for details ;; ;; See file COPYING for details ;;
;; 06.2015 fs_read64 - pathoswithin ;;
;; 04.02.2007 LFN create folder - diamond ;; ;; 04.02.2007 LFN create folder - diamond ;;
;; 08.10.2006 LFN delete file/folder - diamond ;; ;; 08.10.2006 LFN delete file/folder - diamond ;;
;; 20.08.2006 LFN set file size (truncate/extend) - diamond ;; ;; 20.08.2006 LFN set file size (truncate/extend) - diamond ;;
@ -34,19 +33,18 @@
;; 30.10.2004 file_read return also dirsize in bytes - ATV ;; ;; 30.10.2004 file_read return also dirsize in bytes - ATV ;;
;; 20.10.2004 Makedir/Removedir - ATV ;; ;; 20.10.2004 Makedir/Removedir - ATV ;;
;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;; ;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;;
;; 06.9.2004 Fix free space by Mario79 added - MH ;; ;; 06.09.2004 Fix free space - Mario79 ;;
;; 24.5.2004 Write back buffer for File_write -VT ;; ;; 24.05.2004 Write back buffer for File_write - VT ;;
;; 20.5.2004 File_read function to work with syscall 58 - VT ;; ;; 20.05.2004 File_read function to work with syscall 58 - VT ;;
;; 30.3.2004 Error parameters at function return - VT ;; ;; 30.03.2004 Error parameters at function return - VT ;;
;; 01.5.2002 Bugfix in device write - VT ;; ;; 29.06.2002 Improved fat32 verification - VT ;;
;; 20.5.2002 Hd status check - VT ;; ;; 20.05.2002 Hd status check - VT ;;
;; 29.6.2002 Improved fat32 verification - VT ;; ;; 01.05.2002 Bugfix in device write - VT ;;
;; ;; ;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$Revision$ $Revision$
cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00 cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00
PUSHAD_EAX equ [esp+28] PUSHAD_EAX equ [esp+28]
@ -62,11 +60,9 @@ struct FAT PARTITION
fs_type db ? fs_type db ?
fat16_root db 0 ; flag for fat16 rootdir fat16_root db 0 ; flag for fat16 rootdir
fat_change db 0 ; 1=fat has changed fat_change db 0 ; 1=fat has changed
db ? ; alignment rb 1
Lock MUTEX ? ; currently operations with one partition Lock MUTEX ? ; currently operations with one partition
; can not be executed in parallel since the ; can not be executed in parallel since the legacy code is not ready
; legacy code is not ready; this mutex guards
; all operations
SECTORS_PER_FAT dd 0x1f3a SECTORS_PER_FAT dd 0x1f3a
NUMBER_OF_FATS dd 0x2 NUMBER_OF_FATS dd 0x2
SECTORS_PER_CLUSTER dd 0x8 SECTORS_PER_CLUSTER dd 0x8
@ -85,19 +81,16 @@ fatEND dd 0x0FFFFFF8
fatMASK dd 0x0FFFFFFF fatMASK dd 0x0FFFFFFF
fatStartScan dd 2 fatStartScan dd 2
cluster_tmp dd 0 ; used by analyze_directory cluster_tmp dd 0 ; used by analyze_directory
; and analyze_directory_to_write ; and analyze_directory_to_write
longname_sec1 dd 0 ; used by analyze_directory to save 2 previous longname_sec1 dd 0 ; used by analyze_directory to save 2 previous
longname_sec2 dd 0 ; directory sectors for delete long filename longname_sec2 dd 0 ; directory sectors for delete long filename
fat_in_cache dd -1 fat_in_cache dd -1
; For FAT16/FAT32, this points to 512-byte buffer for the current sector of FAT. ; For FAT16/FAT32, this points to 512-byte buffer for the current sector of FAT.
; For FAT12, the entire FAT structure is read ; For FAT12, the entire FAT structure is read
; and unpacked from 12bit per cluster to word per cluster. ; and unpacked from 12bit per cluster to word per cluster.
;
; Note: work with unpacked copy of FAT12 means ; Note: work with unpacked copy of FAT12 means
; additional memory and additional code for packing/unpacking. ; additional memory and additional code for packing/unpacking.
; I'm not sure that the economy justifies the cost, but anyway, ; I'm not sure that the economy justifies the cost, but anyway,
@ -111,11 +104,9 @@ ends
uglobal uglobal
align 4 align 4
partition_count dd 0 ; partitions found by set_FAT32_variables partition_count dd 0 ; partitions found by set_FAT32_variables
hd_error dd 0
hd_error dd 0 ; set by wait_for_sector_buffer
hd_setup dd 0 hd_setup dd 0
hd_wait_timeout dd 0 hd_wait_timeout dd 0
cache_search_start dd 0 ; used by find_empty_slot cache_search_start dd 0 ; used by find_empty_slot
endg endg
@ -123,7 +114,7 @@ uglobal
align 4 align 4
Sector512: ; label for dev_hdcd.inc Sector512: ; label for dev_hdcd.inc
buffer: buffer:
times 512 db 0 rb 512
endg endg
iglobal iglobal
@ -1788,14 +1779,12 @@ fat_Read:
jnz @f jnz @f
.noaccess: .noaccess:
pop edi pop edi
.noaccess_2:
call fat_unlock call fat_unlock
or ebx, -1 or ebx, -1
mov eax, ERROR_ACCESS_DENIED mov eax, ERROR_ACCESS_DENIED
ret ret
@@: @@:
stdcall hd_find_lfn, [esp+4+4] stdcall hd_find_lfn, [esp+8]
jnc .found jnc .found
pop edi pop edi
push eax push eax
@ -1803,27 +1792,25 @@ fat_Read:
pop eax pop eax
or ebx, -1 or ebx, -1
ret ret
.found: .found:
test byte [edi+11], 0x10 ; do not allow read directories test byte [edi+11], 0x10 ; do not allow read directories
jnz .noaccess jnz .noaccess
cmp dword [ebx+8], 0 cmp dword [ebx+8], 0
jz @f jz @f
xor ebx, ebx xor ebx, ebx
.reteof:
call fat_unlock call fat_unlock
mov eax, ERROR_END_OF_FILE mov eax, ERROR_END_OF_FILE
pop edi pop edi
ret ret
@@: @@:
mov edx, [ebx+4] ; file offset
mov ecx, [ebx+12] ; size mov ecx, [ebx+12] ; size
mov edx, [ebx+16] ; pointer mov ebx, [ebx+16] ; buffer
mov ebx, [ebx+4] ; file offset push ebx
push edx
push 0 push 0
mov eax, [edi+28] mov eax, [edi+28]
sub eax, ebx sub eax, edx
jb .eof jb .fileEnd
cmp eax, ecx cmp eax, ecx
jae @f jae @f
mov ecx, eax mov ecx, eax
@ -1831,87 +1818,145 @@ fat_Read:
@@: @@:
mov eax, [edi+20-2] mov eax, [edi+20-2]
mov ax, [edi+26] mov ax, [edi+26]
; now eax=cluster, ebx=position, ecx=count, edx=buffer for data ; now eax=cluster, ebx=buffer for data, ecx=count, edx=position
.new_cluster:
jecxz .new_sector
cmp eax, 2
jb .eof
cmp eax, [ebp+FAT.fatRESERVED]
jae .eof
mov [ebp+FAT.cluster_tmp], eax
dec eax
dec eax
mov edi, [ebp+FAT.SECTORS_PER_CLUSTER] mov edi, [ebp+FAT.SECTORS_PER_CLUSTER]
imul eax, edi shl edi, 9
@@:
cmp eax, 2
jb .fileEnd
cmp eax, [ebp+FAT.fatRESERVED]
jae .fileEnd
sub edx, edi
jc @f
call get_FAT
jc .noaccess2
jmp @b
@@:
mov esi, eax
dec eax
dec eax
imul eax, [ebp+FAT.SECTORS_PER_CLUSTER]
add eax, [ebp+FAT.DATA_START] add eax, [ebp+FAT.DATA_START]
.new_sector: add edx, edi
test ecx, ecx jz .alignedCluster
jz .done mov edi, edx
sub ebx, 512 shr edi, 9
jae .skip add eax, edi
add ebx, 512 and edx, 511
jnz .force_buf jz .alignedSector
cmp ecx, 512 .sectorPiece:
jb .force_buf
; we may read directly to given buffer
push eax ebx
mov ebx, edx
call fs_read32_app
test eax, eax
pop ebx eax
jne .noaccess_1
add edx, 512
sub ecx, 512
jmp .skip
.force_buf:
; we must read sector to temporary buffer and then copy it to destination
push eax ebx push eax ebx
lea ebx, [ebp+FAT.buffer] lea ebx, [ebp+FAT.buffer]
call fs_read32_app call fs_read32_app
test eax, eax test eax, eax
mov eax, ebx mov eax, ebx
pop ebx pop ebx
jne .noaccess_3 jne .noaccess3
add eax, ebx add eax, edx
push ecx push ecx
add ecx, ebx add ecx, edx
cmp ecx, 512 cmp ecx, 512
jbe @f jbe @f
mov ecx, 512 mov ecx, 512
@@: @@:
sub ecx, ebx sub ecx, edx
mov ebx, edx
call memmove call memmove
add edx, ecx
sub [esp], ecx sub [esp], ecx
pop ecx add ebx, ecx
pop eax pop ecx eax
xor ebx, ebx xor edx, edx
.skip: inc edi
inc eax inc eax
dec edi test ecx, ecx
jnz .new_sector jz .done
mov eax, [ebp+FAT.cluster_tmp] .alignedSector:
cmp ecx, 512
jc .sectorPiece
shl edi, 9
add ecx, edi
mov edi, [ebp+FAT.SECTORS_PER_CLUSTER]
shl edi, 9
.alignedCluster:
cmp ecx, 512
jc .sectorPiece
mov edx, eax
mov eax, esi
@@:
sub ecx, edi
jbe .readEnd
call get_FAT call get_FAT
jc .noaccess_1 jc .noaccess4
cmp eax, 2
jmp .new_cluster jb .fileEnd2
.noaccess_3: cmp eax, [ebp+FAT.fatRESERVED]
jae .fileEnd2
inc esi
cmp eax, esi
jz @b
.fragmentEnd:
xchg eax, esi
dec eax
dec eax
imul eax, [ebp+FAT.SECTORS_PER_CLUSTER]
add eax, [ebp+FAT.DATA_START]
sub eax, edx
.readFragment:
push ecx
mov ecx, eax
mov eax, edx
xor edx, edx
push eax
call fs_read64_app
add [esp], ecx
shl ecx, 9
add ebx, ecx
test eax, eax
pop eax pop eax
.noaccess_1: jnz .noaccess3
pop ecx
xor edx, edx
jcxz .done
cmp ecx, 512
jc .sectorPiece
mov eax, esi
dec eax
dec eax
imul eax, [ebp+FAT.SECTORS_PER_CLUSTER]
add eax, [ebp+FAT.DATA_START]
jmp .alignedCluster
.readEnd:
add ecx, edi
mov edi, ecx
and ecx, 511
shr edi, 9
dec eax
dec eax
imul eax, [ebp+FAT.SECTORS_PER_CLUSTER]
add eax, [ebp+FAT.DATA_START]
sub eax, edx
add eax, edi
jmp .readFragment
.noaccess3:
pop eax pop eax
push ERROR_DEVICE .noaccess2:
mov byte [esp], ERROR_DEVICE
.done: .done:
mov ebx, edx
call fat_unlock call fat_unlock
pop eax edx edi pop eax edx edi
sub ebx, edx sub ebx, edx
ret ret
.eof: .fileEnd:
mov ebx, edx mov byte [esp], ERROR_END_OF_FILE
pop eax edx jmp .done
sub ebx, edx .noaccess4:
jmp .reteof mov byte [esp], ERROR_DEVICE
jmp @f
.fileEnd2:
mov byte [esp], ERROR_END_OF_FILE
@@:
inc esi
xor ecx, ecx
jmp .fragmentEnd
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_ReadFolder - FAT implementation of reading a folder ; fat_ReadFolder - FAT implementation of reading a folder