0,0 → 1,2827 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; FAT32.INC ;; |
;; ;; |
;; FAT16/32 functions for MenuetOS ;; |
;; ;; |
;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;; |
;; ;; |
;; See file COPYING for details ;; |
;; ;; |
;; 15.01.2005 get file size/attr/date, file_append - ATV ;; |
;; 04.12.2004 skip volume label, file delete bug fixed - ATV ;; |
;; 29.11.2004 get_free_FAT changed, append dir bug fixed - ATV ;; |
;; 23.11.2004 don't allow overwrite dir with file - ATV ;; |
;; 18.11.2004 get_disk_info and more error codes - ATV ;; |
;; 17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV ;; |
;; 10.11.2004 removedir clear whole directory structure - ATV ;; |
;; 08.11.2004 rename - ATV ;; |
;; 30.10.2004 file_read return also dirsize in bytes - ATV ;; |
;; 20.10.2004 Makedir/Removedir - ATV ;; |
;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;; |
;; 06.9.2004 Fix free space by Mario79 added - MH ;; |
;; 24.5.2004 Write back buffer for File_write -VT ;; |
;; 20.5.2004 File_read function to work with syscall 58 - VT ;; |
;; 30.3.2004 Error parameters at function return - VT ;; |
;; 01.5.2002 Bugfix in device write - VT ;; |
;; 20.5.2002 Hd status check - VT ;; |
;; 29.6.2002 Improved fat32 verification - VT ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|
cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00 |
|
ERROR_DISK_BASE equ 1 |
ERROR_UNSUPPORTED_FS equ 2 |
ERROR_UNKNOWN_FS equ 3 |
ERROR_PARTITION equ 4 |
ERROR_FILE_NOT_FOUND equ 5 |
ERROR_END_OF_FILE equ 6 |
ERROR_MEMORY_POINTER equ 7 |
ERROR_DISK_FULL equ 8 |
ERROR_FAT_TABLE equ 9 |
ERROR_ACCESS_DENIED equ 10 |
|
PUSHAD_EAX equ [esp+28] |
PUSHAD_ECX equ [esp+24] |
PUSHAD_EDX equ [esp+20] |
PUSHAD_EBX equ [esp+16] |
PUSHAD_EBP equ [esp+8] |
PUSHAD_ESI equ [esp+4] |
PUSHAD_EDI equ [esp+0] |
|
align 4 |
;****************************************************** |
; Please do not change this place - variables in text |
; Mario79 |
; START place |
;****************************************************** |
PARTITION_START dd 0x3f |
PARTITION_END dd 0 |
SECTORS_PER_FAT dd 0x1f3a |
NUMBER_OF_FATS dd 0x2 |
SECTORS_PER_CLUSTER dd 0x8 |
BYTES_PER_SECTOR dd 0x200 ; Note: if BPS <> 512 need lots of changes |
ROOT_CLUSTER dd 2 ; first rootdir cluster |
FAT_START dd 0 ; start of fat table |
ROOT_START dd 0 ; start of rootdir (only fat16) |
ROOT_SECTORS dd 0 ; count of rootdir sectors (only fat16) |
DATA_START dd 0 ; start of data area (=first cluster 2) |
LAST_CLUSTER dd 0 ; last availabe cluster |
ADR_FSINFO dd 0 ; used only by fat32 |
|
fatRESERVED dd 0x0FFFFFF6 |
fatBAD dd 0x0FFFFFF7 |
fatEND dd 0x0FFFFFF8 |
fatMASK dd 0x0FFFFFFF |
|
fat_type db 0 ; 0=none, 16=fat16, 32=fat32 |
;*************************************************************************** |
; End place |
; Mario79 |
;*************************************************************************** |
cluster dd 0 ; used by file_write,makedir,append |
partition_count dd 0 ; partitions found by set_FAT32_variables |
longname_sec1 dd 0 ; used by analyze_directory to save 2 previous |
longname_sec2 dd 0 ; directory sectors for delete long filename |
|
hd_error dd 0 ; set by wait_for_sector_buffer |
hd_setup dd 0 |
hd_wait_timeout dd 0 |
|
cluster_tmp dd 0 ; used by analyze_directory |
; and analyze_directory_to_write |
|
file_size dd 0 ; used by file_read |
|
sector_tmp dd 0 ; used by rename,append,file_write |
entry_pos dd 0 ; used by rename,append,file_write |
|
old_filesize dd 0 ; used by append |
new_filepos dd 0 ; used by append |
bytes2write dd 0 ; used by append |
|
cache_search_start dd 0 ; used by find_empty_slot |
|
fat_in_cache dd -1 |
fat_cache: times 512 db 0 |
|
uglobal |
Sector512: ; label for dev_hdcd.inc |
buffer: times 512 db 0 |
deltree_buffer: times 512 db 0 |
endg |
|
iglobal |
NewDirEntry1 db ". ",0x10 |
times 20 db 0 |
NewDirEntry2 db ".. ",0x10 |
times 20 db 0 |
endg |
|
uglobal |
dir_entry: times 32 db 0 |
|
startpath: times 255 db 0 |
|
fat16_root db 0 ; flag for fat16 rootdir |
f_del db 0 ; 1=overwrite fat entry |
fat_change db 0 ; 1=fat has changed |
|
endg |
|
iglobal |
partition_types: ; list of fat16/32 partitions |
db 0x04 ; DOS: fat16 <32M |
db 0x06 ; DOS: fat16 >32M |
db 0x0b ; WIN95: fat32 |
db 0x0c ; WIN95: fat32, LBA-mapped |
db 0x0e ; WIN95: fat16, LBA-mapped |
db 0x14 ; Hidden DOS: fat16 <32M |
db 0x16 ; Hidden DOS: fat16 >32M |
db 0x1b ; Hidden WIN95: fat32 |
db 0x1c ; Hidden WIN95: fat32, LBA-mapped |
db 0x1e ; Hidden WIN95: fat16, LBA-mapped |
db 0xc4 ; DRDOS/secured: fat16 <32M |
db 0xc6 ; DRDOS/secured: fat16 >32M |
db 0xcb ; DRDOS/secured: fat32 |
db 0xcc ; DRDOS/secured: fat32, LBA-mapped |
db 0xce ; DRDOS/secured: fat16, LBA-mapped |
db 0xd4 ; Old Multiuser DOS secured: fat16 <32M |
db 0xd6 ; Old Multiuser DOS secured: fat16 >32M |
partition_types_end: |
|
|
extended_types: ; list of extended partitions |
db 0x05 ; DOS: extended partition |
db 0x0f ; WIN95: extended partition, LBA-mapped |
db 0xc5 ; DRDOS/secured: extended partition |
db 0xd5 ; Old Multiuser DOS secured: extended partition |
extended_types_end: |
|
endg |
|
|
reserve_hd1: |
|
cli |
cmp [hd1_status],0 |
je reserve_ok1 |
|
sti |
call change_task |
jmp reserve_hd1 |
|
reserve_ok1: |
|
push eax |
mov eax,[0x3000] |
shl eax,5 |
mov eax,[eax+0x3000+4] |
mov [hd1_status],eax |
pop eax |
sti |
ret |
|
|
clear_hd_cache: |
|
push eax ecx edi |
mov edi,0x600000 |
mov ecx,16384 |
xor eax,eax |
cld |
rep stosd ; clear hd cache with 0 |
mov [cache_search_start],eax |
mov [fat_in_cache],-1 |
mov [fat_change],0 |
pop edi ecx eax |
ret |
|
problem_partition db 0 ; used for partitions search |
|
; Partition chain used: |
; MBR ; PARTITION2 ; PARTITION3 ; PARTITION4 |
;========================================================== |
; fat16/32 +-- fat16/32 +-- fat16/32 +-- fat16/32 +-- |
; extended --+ extended --+ extended --+ extended --+ |
; 0 0 0 0 |
; 0 0 0 0 |
; Notes: |
; - extended partition need to be in second entry on table |
; - it will skip over removed partitions |
|
set_FAT32_variables: |
mov [0xfe10],dword 0 ; entries in hd cache |
mov [problem_partition],0 |
call reserve_hd1 |
call clear_hd_cache |
|
cmp dword [hdpos],0 |
je problem_hd |
|
pushad |
xor ecx,ecx ; partition count |
mov edx,-1 ; flag for partition |
xor eax,eax ; read MBR |
xor ebp,ebp ; extended partition start |
|
new_partition: |
test ebp,ebp ; is there extended partition? |
jnz extended_already_set ; yes |
xchg ebp,eax ; no. set it now |
|
extended_already_set: |
add eax,ebp ; mbr=mbr+0, ext_part=ext_start+relat_start |
mov ebx,buffer |
call hd_read |
|
cmp word [ebx+0x1fe],0xaa55 ; is it valid boot sector? |
jnz end_partition_chain |
cmp dword [ebx+0x1be+0xc],0 ; skip over empty partition |
jz next_partition |
|
push eax ecx |
mov edi,partition_types |
mov ecx,partition_types_end-partition_types |
mov al,[ebx+0x1be+4] ; get partition type |
cld |
repne scasb ; is partition type ok? |
pop ecx eax |
jnz next_partition ; no. skip over |
|
inc ecx |
cmp ecx,[fat32part] ; is it wanted partition? |
jnz next_partition ; no |
|
mov edx,eax ; start sector |
add edx,[ebx+0x1be+8] ; add relative start |
|
next_partition: |
push ecx |
mov edi,extended_types |
mov ecx,extended_types_end-extended_types |
mov al,[ebx+0x1be+4+16] ; get second partition type |
cld |
repne scasb ; is it extended partition? |
pop ecx |
jnz end_partition_chain ; no. end chain |
|
mov eax,[ebx+0x1be+8+16] ; get start of extended partition |
test eax,eax ; is there extended partition? |
jnz new_partition ; yes. read it |
|
end_partition_chain: |
mov [partition_count],ecx |
|
cmp edx,-1 ; found wanted partition? |
jnz hd_and_partition_ok ; yes. install it |
jmp problem_partition_or_fat |
|
problem_fat_dec_count: ; bootsector is missing or another problem |
dec [partition_count] ; remove it from partition_count |
|
problem_partition_or_fat: |
popad |
|
problem_hd: |
mov [fat_type],0 |
mov [hd1_status],0 ; free |
mov [problem_partition],1 |
ret |
|
hd_and_partition_ok: |
mov eax,edx |
mov [PARTITION_START],eax |
|
mov [hd_setup],1 |
mov ebx,buffer |
call hd_read ; read boot sector of partition |
mov [hd_setup],0 |
|
cmp word [ebx+0x1fe],0xaa55 ; is it valid boot sector? |
jnz problem_fat_dec_count |
|
movzx eax,word [ebx+0xe] ; sectors reserved |
add eax,[PARTITION_START] |
mov [FAT_START],eax ; fat_start = partition_start + reserved |
|
movzx eax,byte [ebx+0xd] ; sectors per cluster |
mov [SECTORS_PER_CLUSTER],eax |
|
movzx ecx,word [ebx+0xb] ; bytes per sector |
mov [BYTES_PER_SECTOR],ecx |
|
movzx eax,word [ebx+0x11] ; count of rootdir entries (=0 fat32) |
mov edx,32 |
mul edx |
dec ecx |
add eax,ecx ; round up if not equal count |
inc ecx ; bytes per sector |
div ecx |
mov [ROOT_SECTORS],eax ; count of rootdir sectors |
|
movzx eax,word [ebx+0x16] ; sectors per fat <65536 |
test eax,eax |
jnz fat16_fatsize |
mov eax,[ebx+0x24] ; sectors per fat |
fat16_fatsize: |
mov [SECTORS_PER_FAT],eax |
|
movzx eax,byte [ebx+0x10] ; number of fats |
test eax,eax ; if 0 it's not fat partition |
jz problem_fat_dec_count |
mov [NUMBER_OF_FATS],eax |
imul eax,[SECTORS_PER_FAT] |
add eax,[FAT_START] |
mov [ROOT_START],eax ; rootdir = fat_start + fat_size * fat_count |
add eax,[ROOT_SECTORS] ; rootdir sectors should be 0 on fat32 |
mov [DATA_START],eax ; data area = rootdir + rootdir_size |
|
movzx eax,word [ebx+0x13] ; total sector count <65536 |
test eax,eax |
jnz fat16_total |
mov eax,[ebx+0x20] ; total sector count |
fat16_total: |
add eax,[PARTITION_START] |
dec eax |
mov [PARTITION_END],eax |
inc eax |
sub eax,[DATA_START] ; eax = count of data sectors |
xor edx,edx |
div dword [SECTORS_PER_CLUSTER] |
inc eax |
mov [LAST_CLUSTER],eax |
dec eax ; cluster count |
|
; limits by Microsoft Hardware White Paper v1.03 |
cmp eax,4085 ; 0xff5 |
jb problem_fat_dec_count ; fat12 not supported |
cmp eax,65525 ; 0xfff5 |
jb fat16_partition |
|
fat32_partition: |
mov eax,[ebx+0x2c] ; rootdir cluster |
mov [ROOT_CLUSTER],eax |
movzx eax,word [ebx+0x30] ; fs info sector |
add eax,[PARTITION_START] |
mov [ADR_FSINFO],eax |
|
popad |
|
mov [fatRESERVED],0x0FFFFFF6 |
mov [fatBAD],0x0FFFFFF7 |
mov [fatEND],0x0FFFFFF8 |
mov [fatMASK],0x0FFFFFFF |
mov [fat_type],32 ; Fat32 |
mov [hd1_status],0 ; free |
ret |
|
fat16_partition: |
xor eax,eax |
mov [ROOT_CLUSTER],eax |
|
popad |
|
mov [fatRESERVED],0x0000FFF6 |
mov [fatBAD],0x0000FFF7 |
mov [fatEND],0x0000FFF8 |
mov [fatMASK],0x0000FFFF |
mov [fat_type],16 ; Fat16 |
mov [hd1_status],0 ; free |
ret |
|
|
set_FAT: |
;-------------------------------- |
; input : EAX = cluster |
; EDX = value to save |
; output : EDX = old value |
;-------------------------------- |
push eax ebx esi |
|
cmp eax,2 |
jb sfc_error |
cmp eax,[LAST_CLUSTER] |
ja sfc_error |
cmp [fat_type],16 |
je sfc_1 |
add eax,eax |
sfc_1: |
add eax,eax |
mov esi,511 |
and esi,eax ; esi = position in fat sector |
shr eax,9 ; eax = fat sector |
add eax,[FAT_START] |
mov ebx,fat_cache |
|
cmp eax,[fat_in_cache] ; is fat sector already in memory? |
je sfc_in_cache ; yes |
|
cmp [fat_change],0 ; is fat changed? |
je sfc_no_change ; no |
call write_fat_sector ; yes. write it into disk |
|
sfc_no_change: |
mov [fat_in_cache],eax ; save fat sector |
call hd_read |
|
sfc_in_cache: |
cmp [fat_type],16 |
jne sfc_test32 |
|
cmp [f_del],1 ; overwrite previous value? |
je sfc_set16 ; yes |
cmp word [ebx+esi],0 ; is cluster free? |
je sfc_set16 ; yes |
mov dword [8*0x100000],0xffffff |
mov edx,[ebx+esi] ; get old value |
jmp sfc_nonzero |
|
sfc_set16: |
xchg [ebx+esi],dx ; save new value and get old value |
jmp sfc_write |
|
sfc_test32: |
mov eax,[fatMASK] |
cmp [f_del],1 ; overwrite previous value? |
je sfc_set32 ; yes |
test eax,[ebx+esi] ; is cluster free? |
je sfc_set32 ; yes |
mov dword [8*0x100000],0xffffff |
mov edx,[ebx+esi] ; get old value |
jmp sfc_nonzero |
|
sfc_set32: |
and edx,eax |
xor eax,-1 ; mask for high bits |
and eax,[ebx+esi] ; get high 4 bits |
or eax,edx |
mov edx,[ebx+esi] ; get old value |
mov [ebx+esi],eax ; save new value |
|
sfc_write: |
mov [fat_change],1 ; fat has changed |
|
sfc_nonzero: |
and edx,[fatMASK] |
|
sfc_error: |
pop esi ebx eax |
ret |
|
|
get_FAT: |
;-------------------------------- |
; input : EAX = cluster |
; output : EAX = next cluster |
;-------------------------------- |
push ebx esi |
|
cmp [fat_type],16 |
je gfc_1 |
add eax,eax |
gfc_1: |
add eax,eax |
mov esi,511 |
and esi,eax ; esi = position in fat sector |
shr eax,9 ; eax = fat sector |
add eax,[FAT_START] |
mov ebx,fat_cache |
|
cmp eax,[fat_in_cache] ; is fat sector already in memory? |
je gfc_in_cache |
|
cmp [fat_change],0 ; is fat changed? |
je gfc_no_change ; no |
call write_fat_sector ; yes. write it into disk |
|
gfc_no_change: |
mov [fat_in_cache],eax |
call hd_read |
|
gfc_in_cache: |
mov eax,[ebx+esi] |
and eax,[fatMASK] |
pop esi ebx |
ret |
|
|
get_free_FAT: |
;----------------------------------------------------------- |
; input : EAX = # cluster for start the searching |
; output : if CARRY=0 EAX = # first cluster found free |
; if CARRY=1 disk full |
; Note : for more speed need to use fat_cache directly |
;----------------------------------------------------------- |
push ecx |
mov ecx,[LAST_CLUSTER] ; counter for full disk |
sub ecx,2 |
|
gff_test: |
cmp eax,[LAST_CLUSTER] ; if above last cluster start at cluster 2 |
jbe gff_in_range |
mov eax,2 |
|
gff_in_range: |
push eax |
call get_FAT ; get cluster state |
test eax,eax ; is it free? |
pop eax |
je gff_found ; yes |
inc eax ; next cluster |
dec ecx ; is all checked? |
jns gff_test ; no |
|
gff_not_found: |
pop ecx ; yes. disk is full |
stc |
ret |
|
gff_found: |
pop ecx |
clc |
ret |
|
|
write_fat_sector: |
;----------------------------------------------------------- |
; write changed fat to disk |
;----------------------------------------------------------- |
push eax ebx ecx |
|
mov [fat_change],0 |
mov eax,[fat_in_cache] |
cmp eax,-1 |
jz write_fat_not_used |
mov ebx,fat_cache |
mov ecx,[NUMBER_OF_FATS] |
|
write_next_fat: |
call hd_write |
add eax,[SECTORS_PER_FAT] |
dec ecx |
jnz write_next_fat |
|
write_fat_not_used: |
pop ecx ebx eax |
ret |
|
|
analyze_directory: |
;----------------------------------------------------------- |
; input : EAX = first cluster of the directory |
; EBX = pointer to filename |
; output : IF CARRY=0 EAX = sector where th file is found |
; EBX = pointer in buffer |
; [buffer .. buffer+511] |
; ECX,EDX,ESI,EDI not changed |
; IF CARRY=1 filename not found |
; Note : if cluster=0 it's changed to read rootdir |
; save 2 previous directory sectors in longname_sec |
;----------------------------------------------------------- |
push ecx edx esi edi ebx ; ebx = [esp+0] |
mov [longname_sec1],0 |
mov [longname_sec2],0 |
|
adr_new_cluster: |
mov [cluster_tmp],eax |
mov [fat16_root],0 |
cmp eax,[LAST_CLUSTER] |
ja adr_not_found ; too big cluster number, something is wrong |
cmp eax,2 |
jnb adr_data_cluster |
|
mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir |
cmp [fat_type],16 |
jne adr_data_cluster |
mov eax,[ROOT_START] |
mov edx,[ROOT_SECTORS] |
mov [fat16_root],1 ; flag for fat16 rootdir |
jmp adr_new_sector |
|
adr_data_cluster: |
sub eax,2 |
mov edx,[SECTORS_PER_CLUSTER] |
imul eax,edx |
add eax,[DATA_START] |
|
adr_new_sector: |
mov ebx,buffer |
call hd_read |
mov ecx,512/32 ; count of dir entrys per sector = 16 |
|
adr_analyze: |
mov edi,[ebx+11] ; file attribute |
and edi,0xf |
cmp edi,0xf |
je adr_long_filename |
test edi,0x8 ; skip over volume label |
jne adr_long_filename ; Note: label can be same name as file/dir |
|
mov esi,[esp+0] ; filename need to be uppercase |
mov edi,ebx |
push ecx |
mov ecx,11 |
cld |
rep cmpsb ; compare 8+3 filename |
pop ecx |
je adr_found |
|
adr_long_filename: |
add ebx,32 ; position of next dir entry |
dec ecx |
jnz adr_analyze |
|
mov ecx,[longname_sec1] ; save 2 previous directory sectors |
mov [longname_sec1],eax ; for delete long filename |
mov [longname_sec2],ecx |
inc eax ; next sector |
dec edx |
jne adr_new_sector |
cmp [fat16_root],1 ; end of fat16 rootdir |
je adr_not_found |
|
adr_next_cluster: |
mov eax,[cluster_tmp] |
call get_FAT ; get next cluster |
cmp eax,2 ; incorrect fat chain? |
jb adr_not_found ; yes |
cmp eax,[fatRESERVED] ; is it end of directory? |
jb adr_new_cluster ; no. analyse it |
|
adr_not_found: |
pop edi edi esi edx ecx ; first edi will remove ebx |
stc ; file not found |
ret |
|
adr_found: |
pop edi edi esi edx ecx ; first edi will remove ebx |
clc ; file found |
ret |
|
|
analyze_directory_to_write: |
;----------------------------------------------------------- |
; input : EAX = first cluster of the directory |
; output : IF CARRY=0 EAX = sector where the empty pos is found |
; EBX = pointer in buffer |
; [buffer .. buffer+511] |
; ECX,EDX,ESI,EDI not changed |
; IF CARRY=1 disk full or fat corrupted |
; Note : if cluster=0 it's changed to read rootdir |
;----------------------------------------------------------- |
push ecx edx edi |
|
adw_new_cluster: |
mov [cluster_tmp],eax |
mov [fat16_root],0 |
cmp eax,[LAST_CLUSTER] |
ja adw_not_found ; too big cluster number, something is wrong |
cmp eax,2 |
jnb adw_data_cluster |
|
mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir |
cmp [fat_type],16 |
jne adw_data_cluster |
mov eax,[ROOT_START] |
mov edx,[ROOT_SECTORS] |
mov [fat16_root],1 ; flag for fat16 rootdir |
jmp adw_new_sector |
|
adw_data_cluster: |
sub eax,2 |
mov edx,[SECTORS_PER_CLUSTER] |
imul eax,edx |
add eax,[DATA_START] |
|
adw_new_sector: |
mov ebx,buffer |
call hd_read |
mov ecx,512/32 ; count of dir entrys per sector = 16 |
|
adw_analyze: |
cmp byte [ebx],0x00 ; is free entry? |
je adw_found ; yes |
cmp byte [ebx],0xe5 ; is deleted entry? |
je adw_found ; yes |
add ebx,32 ; position of next dir entry |
dec ecx |
jnz adw_analyze |
|
inc eax ; next sector |
dec edx |
jne adw_new_sector |
cmp [fat16_root],1 ; end of fat16 rootdir |
je adw_not_found |
|
mov eax,[cluster_tmp] |
call get_FAT ; get next cluster |
cmp eax,2 ; incorrect fat chain? |
jb adw_not_found ; yes |
cmp eax,[fatRESERVED] ; is it end of directory? |
jb adw_new_cluster ; no. analyse it |
|
mov eax,2 ; this block of code add a new cluster |
call get_free_FAT ; for the directory because the directory |
jc adw_not_found ; is full |
|
mov edx,[fatEND] ; new end for directory |
call set_FAT |
|
push eax ; save new cluster |
mov edx,eax |
mov eax,[cluster_tmp] ; change last cluster to point new cluster |
mov [f_del],1 |
call set_FAT |
mov [f_del],0 |
|
mov ecx,-1 ; remove 1 cluster from free disk space |
call add_disk_free_space |
|
mov ecx,512/4 |
xor eax,eax |
mov edi,buffer |
cld |
rep stosd ; clear new directory cluster |
pop eax |
|
sub eax,2 |
mov ecx,[SECTORS_PER_CLUSTER] |
imul eax,ecx |
add eax,[DATA_START] |
mov ebx,buffer |
push eax ; save sector number |
|
adw_set_empty_directory: |
call hd_write |
inc eax ; next sector |
dec ecx |
jnz adw_set_empty_directory |
|
pop eax |
|
adw_found: |
pop edi edx ecx |
clc ; free space found |
ret |
|
adw_not_found: |
pop edi edx ecx |
stc ; free space not found |
ret |
|
|
get_data_cluster: |
;----------------------------------------------------------- |
; input : EAX = cluster |
; EBX = pointer to buffer |
; EDX = # blocks to read in buffer |
; ESI = # blocks to skip over |
; output : if CARRY=0 ok EBX/EDX/ESI updated |
; if CARRY=1 cluster out of range |
; Note : if cluster=0 it's changed to read rootdir |
;----------------------------------------------------------- |
push eax ecx |
|
mov [fat16_root],0 |
cmp eax,[LAST_CLUSTER] |
ja gdc_error ; too big cluster number, something is wrong |
cmp eax,2 |
jnb gdc_cluster |
|
mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir |
cmp [fat_type],16 |
jne gdc_cluster |
mov eax,[ROOT_START] |
mov ecx,[ROOT_SECTORS] ; Note: not cluster size |
mov [fat16_root],1 ; flag for fat16 rootdir |
jmp gdc_read |
|
gdc_cluster: |
sub eax,2 |
mov ecx,[SECTORS_PER_CLUSTER] |
imul eax,ecx |
add eax,[DATA_START] |
|
gdc_read: |
test esi,esi ; first wanted block |
je gdcl1 ; yes, skip count is 0 |
dec esi |
jmp gdcl2 |
|
gdcl1: |
call hd_read |
add ebx,512 ; update pointer |
dec edx |
|
gdcl2: |
test edx,edx ; is all read? |
je out_of_read |
|
inc eax ; next sector |
dec ecx |
jnz gdc_read |
|
out_of_read: |
pop ecx eax |
clc |
ret |
|
gdc_error: |
pop ecx eax |
stc |
ret |
|
|
set_data_cluster: |
;----------------------------------------------------------- |
; input : EAX = cluster |
; EBX = pointer to buffer |
; output : if CARRY=0 ok |
; if CARRY=1 cluster out of range |
;----------------------------------------------------------- |
push eax ebx edx |
|
cmp eax,[LAST_CLUSTER] |
ja sdc_error ; too big cluster number, something is wrong |
sub eax,2 |
jb sdc_error ; don't allow rootdir write |
|
mov edx,[SECTORS_PER_CLUSTER] |
imul eax,edx |
add eax,[DATA_START] |
|
sdc_write: |
call hd_write |
add ebx,512 ; update pointer |
inc eax |
dec edx |
jnz sdc_write |
pop edx ebx eax |
clc |
ret |
|
sdc_error: |
pop edx ebx eax |
stc |
ret |
|
|
get_cluster_of_a_path: |
;--------------------------------------------------------- |
; input : EBX = pointer to a path string |
; (example: the path "/files/data/document" become |
; "files......data.......document...0" |
; '.' = space char |
; '0' = char(0) (ASCII=0) !!! ) |
; output : if (CARRY=1) -> ERROR in the PATH |
; if (CARRY=0) -> EAX=cluster |
;--------------------------------------------------------- |
push ebx edx |
|
mov eax,[ROOT_CLUSTER] |
mov edx,ebx |
|
search_end_of_path: |
cmp byte [edx],0 |
je found_end_of_path |
|
inc edx ; '/' |
mov ebx,edx |
call analyze_directory |
jc directory_not_found |
|
mov eax,[ebx+20-2] ; read the HIGH 16bit cluster field |
mov ax,[ebx+26] ; read the LOW 16bit cluster field |
and eax,[fatMASK] |
add edx,11 ; 8+3 (name+extension) |
jmp search_end_of_path |
|
found_end_of_path: |
pop edx ebx |
clc ; no errors |
ret |
|
directory_not_found: |
pop edx ebx |
stc ; errors occour |
ret |
|
|
bcd2bin: |
;---------------------------------- |
; input : AL=BCD number (eg. 0x11) |
; output : AH=0 |
; AL=decimal number (eg. 11) |
;---------------------------------- |
xor ah,ah |
shl ax,4 |
shr al,4 |
aad |
ret |
|
|
get_date_for_file: |
;----------------------------------------------------- |
; Get date from CMOS and pack day,month,year in AX |
; DATE bits 0..4 : day of month 0..31 |
; 5..8 : month of year 1..12 |
; 9..15 : count of years from 1980 |
;----------------------------------------------------- |
mov al,0x7 ;day |
out 0x70,al |
in al,0x71 |
call bcd2bin |
ror eax,5 |
|
mov al,0x8 ;month |
out 0x70,al |
in al,0x71 |
call bcd2bin |
ror eax,4 |
|
mov al,0x9 ;year |
out 0x70,al |
in al,0x71 |
call bcd2bin |
add ax,20 ;because CMOS return only the two last |
;digit (eg. 2000 -> 00 , 2001 -> 01) and we |
rol eax,9 ;need the difference with 1980 (eg. 2001-1980) |
ret |
|
|
get_time_for_file: |
;----------------------------------------------------- |
; Get time from CMOS and pack hour,minute,second in AX |
; TIME bits 0..4 : second (the low bit is lost) |
; 5..10 : minute 0..59 |
; 11..15 : hour 0..23 |
;----------------------------------------------------- |
mov al,0x0 ;second |
out 0x70,al |
in al,0x71 |
call bcd2bin |
ror eax,6 |
|
mov al,0x2 ;minute |
out 0x70,al |
in al,0x71 |
call bcd2bin |
ror eax,6 |
|
mov al,0x4 ;hour |
out 0x70,al |
in al,0x71 |
call bcd2bin |
rol eax,11 |
ret |
|
|
set_current_time_for_entry: |
;----------------------------------------------------- |
; Set current time/date for file entry |
; input : ebx = file entry pointer |
;----------------------------------------------------- |
push eax |
call get_time_for_file ; update files date/time |
mov [ebx+22],ax |
call get_date_for_file |
mov [ebx+24],ax |
pop eax |
ret |
|
|
makedir: |
;----------------------------------------------------- |
; input : eax = directory name |
; edx = path |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 8 - disk full |
; 10 - access denied |
; Note : can only make one directory at time |
;----------------------------------------------------- |
cmp [fat_type],0 |
jnz make_dir_fat_ok |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
make_dir_fat_ok: |
; call reserve_hd1 |
|
pushad |
|
mov ebx,edx |
call get_cluster_of_a_path |
jnc make_dir_found_path |
|
make_dir_path_not_found: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
make_dir_disk_full: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_DISK_FULL |
ret |
|
make_dir_already_exist: |
mov eax,[cluster] ; directory cluster |
xor edx,edx ; free |
mov [f_del],1 |
call set_FAT |
mov [f_del],0 |
|
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_ACCESS_DENIED |
ret |
|
make_dir_found_path: |
cmp eax,[ROOT_CLUSTER] |
jnz make_dir_not_root |
xor eax,eax |
|
make_dir_not_root: |
mov ecx,eax ; directorys start cluster |
mov word [NewDirEntry2+26],cx ; 16 bits low of cluster |
shr ecx,16 |
mov word [NewDirEntry2+20],cx ; 16 bits high of cluster (=0 fat16) |
|
push eax ; save parent directory cluster |
mov eax,2 |
call get_free_FAT |
mov [cluster],eax ; first free cluster |
pop eax |
jc make_dir_disk_full |
|
push eax |
mov eax,[cluster] ; directory cluster |
mov edx,[fatEND] ; end for directory |
call set_FAT |
pop eax |
|
mov ebx,PUSHAD_EAX ; dir name |
push eax |
call analyze_directory ; check if directory already exist |
pop eax |
jnc make_dir_already_exist ; need to free allocated cluster! |
|
call analyze_directory_to_write |
jc make_dir_already_exist ; need to free allocated cluster! |
|
mov esi,PUSHAD_EAX ; dir name |
mov edi,ebx ; pointer in buffer |
mov ecx,11 |
cld |
rep movsb |
|
mov dword [ebx+28],0 ; dir size is always 0 |
mov ecx,[cluster] |
mov [ebx+26],cx ; 16 bits low of cluster |
mov word [NewDirEntry1+26],cx |
shr ecx,16 |
mov [ebx+20],cx ; 16 bits high of cluster (=0 fat16) |
mov word [NewDirEntry1+20],cx |
mov byte [ebx+11],0x10 ; attribute = directory |
|
call set_current_time_for_entry |
mov ecx,[ebx+22] |
mov dword [NewDirEntry1+22],ecx |
mov dword [NewDirEntry2+22],ecx |
|
mov ebx,buffer ; save the directory name,length,cluster |
call hd_write |
|
mov ecx,512/4 |
xor eax,eax |
mov edi,buffer |
cld |
rep stosd ; clear new directory cluster |
|
mov eax,[cluster] ; new directory cluster |
sub eax,2 |
mov edx,[SECTORS_PER_CLUSTER] |
imul eax,edx |
add eax,[DATA_START] |
mov ebx,buffer |
add eax,edx ; start from last sector |
|
dir_set_empty_directory: |
dec eax ; next sector |
cmp edx,1 ; is first directory sector? |
jnz not_first_sector ; no. write empty sector |
mov esi,NewDirEntry1 |
mov edi,buffer |
mov ecx,64/4 |
cld |
rep movsd ; copy 2 first directory entrys "." and ".." |
|
not_first_sector: |
call hd_write |
dec edx |
jnz dir_set_empty_directory |
|
mov ecx,-1 ; remove 1 cluster from free disk space |
call add_disk_free_space |
|
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
|
removedir: |
;----------------------------------------------------- |
; input : eax = file/directory name |
; edx = path |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 10 - access denied |
;----------------------------------------------------- |
cmp [fat_type],0 |
jnz remove_dir_fat_ok |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
remove_dir_fat_ok: |
; call reserve_hd1 |
|
push edi |
mov edi,1 ; allow directory remove |
call file_delete |
pop edi |
|
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
ret |
|
|
add_disk_free_space: |
;----------------------------------------------------- |
; input : ecx = cluster count |
; Note : negative = remove clusters from free space |
; positive = add clusters to free space |
;----------------------------------------------------- |
test ecx,ecx ; no change |
je add_dfs_no |
cmp [fat_type],32 ; free disk space only used by fat32 |
jne add_dfs_no |
|
push eax ebx |
mov eax,[ADR_FSINFO] |
mov ebx,buffer |
call hd_read |
cmp dword [ebx+0x1fc],0xaa550000 ; check sector id |
jne add_not_fs |
|
add [ebx+0x1e8],ecx |
call hd_write |
|
add_not_fs: |
pop ebx eax |
|
add_dfs_no: |
ret |
|
|
file_append: |
;----------------------------------------------------- |
; input : eax = file name |
; edx = path |
; ecx = pointer to buffer |
; ebx = bytes to write (0 = truncate file) |
; esi = start position (-1 = end of file) |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 6 - end of file |
; 8 - disk full |
; 9 - fat table corrupted |
; 10 - access denied |
; ebx = bytes written |
;----------------------------------------------------- |
cmp [fat_type],0 |
jnz append_fat_ok |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
append_fat_ok: |
; call reserve_hd1 |
|
pushad |
|
mov ebx,edx |
call get_cluster_of_a_path |
jc append_not_found |
|
mov ebx,PUSHAD_EAX ; file name |
call analyze_directory |
jc append_not_found |
|
mov [sector_tmp],eax |
mov [entry_pos],ebx |
|
test byte [ebx+11],0x10 ; is it directory? |
jnz append_access ; yes |
|
mov ecx,[ebx+28] ; file size |
mov edi,PUSHAD_ESI ; write position |
cmp edi,-1 ; -1 = eof |
jnz append_inside_file |
mov edi,ecx ; file size |
|
append_inside_file: |
cmp edi,ecx ; start above old file size? |
ja append_eof ; yes |
|
mov [old_filesize],ecx |
mov [new_filepos],edi |
|
mov ecx,PUSHAD_EBX ; bytes to write |
test ecx,ecx ; truncate? |
jz append_truncate ; yes |
|
mov [bytes2write],ecx ; bytes to write |
mov esi,PUSHAD_ECX ; pointer to buffer |
mov eax,[ebx+20-2] ; FAT entry |
mov ax,[ebx+26] |
and eax,[fatMASK] |
jnz append_find_pos ; first cluster <> 0 |
|
mov eax,2 |
call get_free_FAT |
jc append_disk_full |
mov ecx,eax ; set files first cluster |
mov [ebx+26],cx ; 16 bits low of cluster |
shr ecx,16 |
mov [ebx+20],cx ; 16 bits high of cluster (=0 fat16) |
mov edx,[fatEND] ; new end for cluster chain |
call set_FAT |
|
push eax ; save first cluster |
mov eax,[sector_tmp] |
mov ebx,buffer |
call hd_write ; write new file entry back to disk |
pop eax |
|
append_remove_free: |
mov ecx,-1 ; remove 1 cluster from free disk space |
call add_disk_free_space ; Note: uses buffer |
|
append_found_cluster: |
mov [cluster],eax |
sub eax,2 |
mov ecx,[SECTORS_PER_CLUSTER] |
imul eax,ecx |
add eax,[DATA_START] |
xor edi,edi |
|
append_new_sector: |
push ecx |
mov ecx,[bytes2write] ; bytes left in buffer |
mov ebx,512 |
sub ebx,edi ; bytes left in sector |
cmp ecx,ebx |
jb append_bytes_ok |
mov ecx,ebx |
|
append_bytes_ok: |
cmp ecx,512 ; overwrite full sector? |
jz append_full_sector ; yes |
mov ebx,buffer ; overwrite part of sector |
call hd_read ; read old sector |
|
append_full_sector: |
sub [bytes2write],ecx |
add [new_filepos],ecx |
add edi,buffer |
cld |
rep movsb |
pop ecx |
|
mov ebx,buffer |
call hd_write |
cmp [bytes2write],0 ; is all done? |
jz append_done |
xor edi,edi |
inc eax |
dec ecx |
jnz append_new_sector |
|
mov eax,[cluster] |
call get_FAT |
cmp eax,2 |
jb append_fat |
cmp eax,[LAST_CLUSTER] |
jbe append_found_cluster |
|
append_alloc_cluster: |
mov eax,2 ; ToDo: use temp array to keep track |
call get_free_FAT ; of last free cluster |
jc append_disk_full |
push eax ; save new cluster |
mov edx,[fatEND] ; new end for cluster chain |
call set_FAT |
mov edx,eax |
mov eax,[cluster] |
mov [f_del],1 |
call set_FAT ; update previous cluster |
mov [f_del],0 |
pop eax |
jmp append_remove_free |
|
append_find_pos: |
call find_filepos |
mov [cluster],ebx |
jnc append_new_sector |
test edi,edi |
jz append_alloc_cluster |
|
append_fat: |
mov eax,ERROR_FAT_TABLE |
jmp append_ret_code |
|
append_disk_full: |
mov eax,ERROR_DISK_FULL |
jmp append_ret_code |
|
append_done: |
xor eax,eax |
|
append_ret_code: |
mov PUSHAD_EAX,eax ; return code |
|
mov eax,[sector_tmp] ; update directory entry |
mov ebx,buffer |
call hd_read |
mov ebx,[entry_pos] |
mov ecx,[new_filepos] |
cmp ecx,[old_filesize] ; is file pos above old size? |
jbe append_size_ok ; no |
mov [ebx+28],ecx ; new file size |
|
append_size_ok: |
call set_current_time_for_entry |
mov ebx,buffer |
call hd_write ; write new file entry back to disk |
|
sub ecx,PUSHAD_ESI ; start position |
mov PUSHAD_EBX,ecx ; bytes written |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
ret |
|
append_eof: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_END_OF_FILE |
ret |
|
append_not_found: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
append_access: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_ACCESS_DENIED |
ret |
|
append_truncate: |
mov edx,[ebx+20-2] ; FAT entry |
mov dx,[ebx+26] |
and edx,[fatMASK] |
mov [ebx+28],edi ; set new file size |
test edi,edi ; 0 length file? |
jnz truncate_save_size ; no |
mov [ebx+20],di ; FAT entry = 0 |
mov [ebx+26],di |
|
truncate_save_size: |
call set_current_time_for_entry |
mov ebx,buffer |
call hd_write |
mov eax,edx ; first cluster |
test edi,edi ; 0 length file? |
jz truncate_clear_chain |
|
imul esi,[SECTORS_PER_CLUSTER],512 ; esi = cluster size in bytes |
|
truncate_new_cluster: |
cmp eax,2 ; incorrect fat chain? |
jb truncate_eof ; yes |
cmp eax,[fatRESERVED] ; is it end of file? |
jnb truncate_eof ; yes |
sub edi,esi |
jbe truncate_pos_found |
call get_FAT ; get next cluster |
jmp truncate_new_cluster |
|
truncate_pos_found: |
mov edx,[fatEND] ; new end for cluster chain |
mov [f_del],1 |
call set_FAT |
mov [f_del],0 |
mov eax,edx ; clear rest of chain |
|
truncate_clear_chain: |
call clear_cluster_chain |
|
truncate_eof: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
xor ebx,ebx |
xor eax,eax |
ret |
|
|
find_filepos: |
;----------------------------------------------------- |
; input : eax = first cluster |
; edi = bytes to skip over (start position) |
; output : if CARRY=0 file position found |
; if CARRY=1 end of file found |
; eax = current file sector |
; ebx = last cluster |
; ecx = sector count in last cluster |
; edi = bytes to skip over (sector position) |
;----------------------------------------------------- |
push esi |
mov ecx,[SECTORS_PER_CLUSTER] |
imul esi,ecx,512 ; esi = cluster size in bytes |
mov ebx,eax |
|
filepos_new_cluster: |
cmp eax,2 ; incorrect fat chain? |
jb filepos_eof ; yes |
cmp eax,[fatRESERVED] ; is it end of file? |
jnb filepos_eof ; yes |
|
mov ebx,eax |
cmp edi,esi ; skip over full cluster? |
jb filepos_cluster_ok ; no |
|
sub edi,esi |
call get_FAT ; get next cluster |
jmp filepos_new_cluster |
|
filepos_cluster_ok: |
sub eax,2 |
imul eax,ecx |
add eax,[DATA_START] |
|
filepos_new_sector: |
cmp edi,512 ; skip over full sector? |
jb filepos_sector_ok ; no |
sub edi,512 |
inc eax |
dec ecx |
jnz filepos_new_sector |
|
filepos_eof: |
pop esi |
stc |
ret |
|
filepos_sector_ok: |
pop esi |
clc |
ret |
|
|
file_write: |
;-------------------------------------------------------------------------- |
; INPUT : user-reg register-in-this meaning symbol-in-this-routine |
; |
; EAX EDI system call to write / |
; EBX EAX (PAR0) pointer to file-name PAR0 |
; EDX ECX (PAR1) pointer to buffer PAR1 |
; ECX EBX (PAR2) file size PAR2 |
; ESI EDX (PAR3) pointer to path PAR3 |
; |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 8 - disk full |
; 10 - access denied |
;-------------------------------------------------------------------------- |
cmp [fat_type],0 |
jnz fat_ok_for_writing |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
fat_ok_for_writing: |
; call reserve_hd1 |
|
pushad |
|
xor edi,edi ; don't allow directory remove |
call file_delete ; try to delete the file first |
test eax,eax |
jz old_deleted ; deleted ok |
cmp eax,ERROR_FILE_NOT_FOUND |
jnz exit_write_access ; it exist but can't delete |
|
old_deleted: |
mov ebx,PUSHAD_EDX |
call get_cluster_of_a_path |
jnc found_directory_for_writing |
|
exit_writing_with_error: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
exit_writing_disk_full_clear: |
mov eax,[sector_tmp] |
mov ebx,buffer |
call hd_read ; read directory sector |
mov edx,[entry_pos] |
mov byte [edx],0xe5 ; mark as deleted |
call hd_write |
mov eax,[edx+20-2] ; FAT entry |
mov ax,[edx+26] |
and eax,[fatMASK] |
call clear_cluster_chain |
|
exit_writing_disk_full: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_DISK_FULL |
ret |
|
exit_write_access: |
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
mov eax,ERROR_ACCESS_DENIED |
ret |
|
found_directory_for_writing: |
call analyze_directory_to_write |
jc exit_writing_disk_full |
|
mov [sector_tmp],eax |
mov [entry_pos],ebx |
push eax ; save directory sector |
mov eax,2 |
call get_free_FAT |
mov [cluster],eax ; first free cluster |
pop eax |
jc exit_writing_disk_full |
|
mov esi,PUSHAD_EAX ; file name |
mov edi,ebx ; pointer in buffer |
mov ecx,11 |
cld |
rep movsb |
|
mov esi,PUSHAD_EBX ; file size (bytes left) |
mov [ebx+28],esi ; file size |
mov ecx,[cluster] |
mov [ebx+26],cx ; 16 bits low of cluster |
shr ecx,16 |
mov [ebx+20],cx ; 16 bits high of cluster (=0 fat16) |
mov byte [ebx+11],0x20 ; attribute = archive |
|
call set_current_time_for_entry |
|
mov ebx,buffer ; save the directory name,length,cluster |
call hd_write |
|
imul edi,[SECTORS_PER_CLUSTER],512 ; edi = cluster size in bytes |
xor ecx,ecx ; cluster count |
mov ebx,PUSHAD_ECX ; ebx = buffer |
|
hd_new_block_write: |
|
mov eax,[cluster] ; eax = block |
call set_data_cluster |
|
sub esi,edi ; sub wrote bytes |
jbe file_saved_OK ; end if all done |
add ebx,edi ; update buffer position |
|
inc eax |
call get_free_FAT ; next free in FAT |
jc exit_writing_disk_full_clear |
|
mov edx,eax |
xchg eax,[cluster] ; get old cluster and save new cluster |
call set_FAT ; add it in cluster chain |
dec ecx ; update cluster count |
jmp hd_new_block_write |
|
file_saved_OK: |
|
mov edx,[fatEND] ; new end for cluster chain |
call set_FAT |
dec ecx ; update cluster count |
|
call add_disk_free_space ; remove clusters from free disk space |
|
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
|
file_read: |
;-------------------------------------------------------------------------- |
; INPUT : user-register register-in-this meaning symbol-in-this |
; |
; EAX EDI system call to write / |
; EBX EAX (PAR0) pointer to file-name PAR0 |
; EDX ECX (PAR1) pointer to buffer PAR1 |
; ECX EBX (PAR2) vt file blocks to read PAR2 |
; ESI EDX (PAR3) pointer to path PAR3 |
; EDI ESI vt first 512 block to read |
; EDI if 0 - read root |
; |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 6 - end of file |
; 9 - fat table corrupted |
; ebx = size of file/directory |
;-------------------------------------------------------------------------- |
cmp [fat_type],0 |
jnz fat_ok_for_reading |
xor ebx,ebx |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
fat_ok_for_reading: |
; call reserve_hd1 |
|
pushad |
|
mov ebx,edx |
call get_cluster_of_a_path |
jc file_to_read_not_found |
|
test edi,edi ; read rootdir |
jne no_read_root |
|
xor eax,eax |
call get_dir_size ; return rootdir size |
mov [file_size],eax |
mov eax,[ROOT_CLUSTER] |
jmp file_read_start |
|
no_read_root: |
mov ebx,PUSHAD_EAX ; file name |
call analyze_directory |
jc file_to_read_not_found |
|
mov eax,[ebx+28] ; file size |
test byte [ebx+11],0x10 ; is it directory? |
jz read_set_size ; no |
|
mov eax,[ebx+20-2] ; FAT entry |
mov ax,[ebx+26] |
and eax,[fatMASK] |
call get_dir_size |
|
read_set_size: |
mov [file_size],eax |
|
mov eax,[ebx+20-2] ; FAT entry |
mov ax,[ebx+26] |
and eax,[fatMASK] |
|
file_read_start: |
mov ebx,PUSHAD_ECX ; pointer to buffer |
mov edx,PUSHAD_EBX ; file blocks to read |
mov esi,PUSHAD_ESI ; first 512 block to read |
|
file_read_new_cluster: |
call get_data_cluster |
jc file_read_eof ; end of file or cluster out of range |
|
test edx,edx ; is all read? |
je file_read_OK ; yes |
|
call get_FAT ; get next cluster |
cmp eax,[fatRESERVED] ; end of file |
jnb file_read_eof |
cmp eax,2 ; incorrect fat chain |
jnb file_read_new_cluster |
|
popad |
mov [hd1_status],0 |
mov ebx,[file_size] |
mov eax,ERROR_FAT_TABLE |
ret |
|
file_read_eof: |
popad |
mov [hd1_status],0 |
mov ebx,[file_size] |
mov eax,ERROR_END_OF_FILE |
ret |
|
file_read_OK: |
popad |
mov [hd1_status],0 |
mov ebx,[file_size] |
xor eax,eax |
ret |
|
file_to_read_not_found: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
|
get_dir_size: |
;----------------------------------------------------- |
; input : eax = first cluster (0=rootdir) |
; output : eax = directory size in bytes |
;----------------------------------------------------- |
push edx |
xor edx,edx ; count of directory clusters |
test eax,eax |
jnz dir_size_next |
|
mov eax,[ROOT_SECTORS] |
shl eax,9 ; fat16 rootdir size in bytes |
cmp [fat_type],16 |
je dir_size_ret |
mov eax,[ROOT_CLUSTER] |
|
dir_size_next: |
cmp eax,2 ; incorrect fat chain |
jb dir_size_end |
cmp eax,[fatRESERVED] ; end of directory |
ja dir_size_end |
call get_FAT ; get next cluster |
inc edx |
jmp dir_size_next |
|
dir_size_end: |
imul eax,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes |
imul eax,edx |
|
dir_size_ret: |
pop edx |
ret |
|
|
file_delete: |
;----------------------------------------------------- |
; input : eax = file/directory name |
; edx = path |
; edi = 1 - allow directory remove else don't remove directory |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 10 - access denied |
;----------------------------------------------------- |
cmp [fat_type],0 |
jnz file_del_fat_ok |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
file_del_fat_ok: |
pushad |
|
mov ebx,edx |
call get_cluster_of_a_path |
jc file_to_delete_not_found |
|
mov ebx,PUSHAD_EAX ; file/directory name |
call analyze_directory |
jc file_to_delete_not_found |
|
test byte [ebx+11],0x10 ; is it directory? |
jz delete_notdir ; no. it's file |
cmp edi,1 ; allow directory remove |
jnz delete_no_access ; no |
|
push eax ; save directory sector |
mov eax,[ebx+20-2] ; first cluster of file |
mov ax,[ebx+26] ; 0 length files start cluster = 0 |
and eax,[fatMASK] |
xor ebp,ebp ; counter for directory deepnes |
call clear_directory |
pop eax |
jc delete_no_access |
|
push ebx ; save directory pointer in buffer |
mov ebx,buffer |
call hd_read ; read directory sector |
pop ebx |
|
delete_notdir: |
call delete_entry_name |
mov eax,ecx ; first cluster of file |
call clear_cluster_chain |
popad |
xor eax,eax |
ret |
|
delete_no_access: |
popad |
mov eax,ERROR_ACCESS_DENIED |
ret |
|
file_to_delete_not_found: |
popad |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
|
clear_cluster_chain: |
;----------------------------------------------------- |
; input : eax = first cluster |
;----------------------------------------------------- |
push eax ecx edx |
xor ecx,ecx ; cluster count |
mov [f_del],1 ; delete on |
|
clean_new_chain: |
cmp eax,[LAST_CLUSTER] ; end of file |
ja delete_OK |
cmp eax,2 ; unfinished fat chain or zero length file |
jb delete_OK |
cmp eax,[ROOT_CLUSTER] ; don't remove root cluster |
jz delete_OK |
|
xor edx,edx |
call set_FAT ; clear fat entry |
inc ecx ; update cluster count |
mov eax,edx ; old cluster |
jmp clean_new_chain |
|
delete_OK: |
call add_disk_free_space ; add clusters to free disk space |
mov [f_del],0 |
pop edx ecx eax |
ret |
|
|
clear_directory: |
;----------------------------------------------------- |
; input : eax = directory cluster |
; ebp = directory deepnes |
; Note : use recursive call |
;----------------------------------------------------- |
pushad |
inc ebp |
cmp ebp,64 ; if over 63 directory deep |
jnb clear_error ; something must be wrong |
|
clear_new_cluster: |
cmp eax,[LAST_CLUSTER] |
ja clear_end |
cmp eax,[ROOT_CLUSTER] ; don't remove root cluster |
jz clear_end |
mov esi,eax ; esi = current directory cluster |
sub eax,2 |
jb clear_end |
mov ecx,[SECTORS_PER_CLUSTER] |
imul eax,ecx |
add eax,[DATA_START] |
|
clear_new_sector: |
mov edi,eax ; edi = current directory sector |
mov ebx,deltree_buffer |
call hd_read |
mov edx,512/32 ; count of dir entrys per sector = 16 |
|
clear_analyze: |
mov al,[ebx+11] ; file attribute |
and al,0xf |
cmp al,0xf |
je clear_long_filename |
|
cmp byte [ebx],'.' ; parent or current directory |
je clear_next_entry |
cmp byte [ebx],0xe5 ; deleted |
je clear_next_entry |
cmp byte [ebx],0 ; empty |
je clear_write_last |
;je clear_next_entry |
|
mov eax,[ebx+20-2] ; first cluster of entry |
mov ax,[ebx+26] |
and eax,[fatMASK] |
|
test byte [ebx+11],0x10 ; is it directory? |
jz clear_file ; no |
|
push eax ebx |
mov eax,edi |
mov ebx,deltree_buffer ; save buffer over recursive call |
call hd_write ; write directory sector to disk |
pop ebx eax |
|
call clear_directory ; recursive call !!! |
jc clear_error ; exit if error found |
|
push eax ebx |
mov eax,edi |
mov ebx,deltree_buffer |
call hd_read ; read directory sector again |
pop ebx eax |
|
clear_file: |
call clear_cluster_chain |
|
clear_long_filename: |
mov byte [ebx],0xe5 |
|
clear_next_entry: |
add ebx,32 ; position of next dir entry |
dec edx |
jnz clear_analyze |
|
mov eax,edi |
mov ebx,deltree_buffer |
call hd_write ; write directory sector to disk |
|
inc eax ; next sector |
dec ecx |
jnz clear_new_sector |
|
mov eax,esi |
call get_FAT ; get next cluster |
jmp clear_new_cluster ; clear it |
|
clear_write_last: |
mov eax,edi |
mov ebx,deltree_buffer |
call hd_write ; write directory sector to disk |
|
clear_end: |
popad |
clc |
ret |
|
clear_error: |
popad |
stc |
ret |
|
|
delete_entry_name: |
;----------------------------------------------------- |
; input : eax = directory sector |
; ebx = directory pointer in buffer |
; longname_sec = 2 previous directory sectors |
; output : ecx = first cluster |
; change : eax,ebx,edx |
;----------------------------------------------------- |
mov byte [ebx],0xe5 |
mov ecx,[ebx+20-2] ; first cluster of file |
mov cx,[ebx+26] ; 0 length files start cluster = 0 |
and ecx,[fatMASK] |
|
delete_empty: |
sub ebx,32 |
cmp ebx,buffer |
jnb delete_test_long |
|
mov ebx,buffer |
call hd_write ; write directory sector back |
xor eax,eax |
xchg eax,[longname_sec2] |
xchg eax,[longname_sec1] |
test eax,eax ; is there previous directory sector? |
jz delete_name_end ; no |
|
mov ebx,buffer |
call hd_read ; read previous sector |
mov ebx,buffer+0x1e0 ; start from last entry |
|
delete_test_long: |
mov dh,[ebx+11] ; file attribute |
and dh,0xf |
cmp dh,0xf |
jne delete_write_buffer |
|
cmp byte [ebx],0x40 ; end of long dir entry? |
mov byte [ebx],0xe5 |
jb delete_empty |
|
delete_write_buffer: |
mov ebx,buffer |
call hd_write ; write directory sector back |
|
delete_name_end: |
ret |
|
|
rename: |
;----------------------------------------------------------- |
; input : eax = source directory name |
; edx = source path |
; ebx = dest directory name |
; edi = dest path |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; 8 - disk full |
; 10 - access denied |
;----------------------------------------------------------- |
cmp [fat_type],0 |
jnz fat_ok_for_rename |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
fat_ok_for_rename: |
; call reserve_hd1 |
|
pushad |
|
mov ebx,edx ; source path |
call get_cluster_of_a_path |
jc rename_entry_not_found |
|
mov ebx,PUSHAD_EAX ; source directory name |
call analyze_directory |
jc rename_entry_not_found |
|
mov [sector_tmp],eax ; save source sector |
mov [entry_pos],ebx |
mov esi,ebx |
mov edi,dir_entry |
mov ecx,32/4 |
cld |
rep movsd ; save entry |
|
mov ebx,PUSHAD_EDI ; dest path |
call get_cluster_of_a_path |
jc rename_entry_not_found |
|
mov edx,eax ; save dest directory cluster |
mov ebx,PUSHAD_EBX ; dest directory name |
push [longname_sec1] |
push [longname_sec2] |
call analyze_directory ; check if entry already exist |
pop [longname_sec2] |
pop [longname_sec1] |
jnc rename_entry_already_exist |
|
mov eax,edx |
call analyze_directory_to_write |
jc rename_disk_full |
|
mov esi,dir_entry |
mov edi,ebx |
mov ecx,32/4 |
cld |
rep movsd ; copy entry |
mov esi,PUSHAD_EBX ; dest directory name |
mov edi,ebx |
mov ecx,11 |
rep movsb ; copy name |
|
mov ebx,buffer ; save the directory name,length,cluster |
call hd_write |
|
test byte [dir_entry+11],0x10 ; is it directory? |
jz rename_not_dir ; no |
mov eax,[dir_entry+20-2] ; FAT entry |
mov ax,[dir_entry+26] |
and eax,[fatMASK] |
call change_2dot_cluster |
|
rename_not_dir: |
mov eax,[sector_tmp] |
mov ebx,buffer |
call hd_read ; read source directory sector |
|
mov ebx,[entry_pos] |
call delete_entry_name |
|
popad |
call update_disk ; write all of cache and fat to hd |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
rename_entry_not_found: |
popad |
mov [hd1_status],0 |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
rename_entry_already_exist: |
popad |
mov [hd1_status],0 |
mov eax,ERROR_ACCESS_DENIED |
ret |
|
rename_disk_full: |
popad |
mov [hd1_status],0 |
mov eax,ERROR_DISK_FULL |
ret |
|
|
change_2dot_cluster: |
;----------------------------------------------------------- |
; input : eax = directory cluster |
; edx = value to save |
; change : eax,ebx,edx |
;----------------------------------------------------------- |
cmp eax,[LAST_CLUSTER] |
ja not_2dot ; too big cluster number, something is wrong |
sub eax,2 |
jb not_2dot |
|
imul eax,[SECTORS_PER_CLUSTER] |
add eax,[DATA_START] |
mov ebx,buffer |
call hd_read |
|
cmp dword [ebx+32],'.. ' |
jnz not_2dot |
|
cmp edx,[ROOT_CLUSTER] ; is rootdir cluster? |
jne not_2dot_root |
xor edx,edx ; yes. set it zero |
|
not_2dot_root: |
mov [ebx+32+26],dx ; 16 bits low of cluster |
shr edx,16 |
mov [ebx+32+20],dx ; 16 bits high of cluster (=0 fat16) |
call hd_write |
|
not_2dot: |
ret |
|
|
get_filesize: |
;----------------------------------------------------------- |
; input : eax = file name |
; edx = path |
; edi = if 0 - read rootdir else normal dir/file size |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; ebx = file size |
;----------------------------------------------------------- |
cmp [fat_type],0 |
jnz get_filesize_fat_ok |
xor ebx,ebx |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
get_filesize_fat_ok: |
; call reserve_hd1 |
|
pushad |
xor eax,eax |
test edi,edi ; is read rootdir? |
je get_filesize_dirsize ; yes |
|
get_filesize_no_root: |
mov ebx,edx |
call get_cluster_of_a_path |
jc get_filesize_not_found |
|
mov ebx,PUSHAD_EAX ; file name |
call analyze_directory |
jc get_filesize_not_found |
|
mov eax,[ebx+28] ; file size |
test byte [ebx+11],0x10 ; is it directory? |
jz get_filesize_set_size ; no |
|
mov eax,[ebx+20-2] ; FAT entry |
mov ax,[ebx+26] |
and eax,[fatMASK] |
|
get_filesize_dirsize: |
call get_dir_size |
|
get_filesize_set_size: |
mov PUSHAD_EBX,eax |
popad |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
get_filesize_not_found: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
|
get_fileattr: |
;----------------------------------------------------------- |
; input : eax = file name |
; edx = path |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; ebx = file attribute |
;----------------------------------------------------------- |
cmp [fat_type],0 |
jnz get_fileattr_fat_ok |
xor ebx,ebx |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
get_fileattr_fat_ok: |
; call reserve_hd1 |
|
pushad |
mov ebx,edx |
call get_cluster_of_a_path |
jc get_fileattr_not_found |
|
mov ebx,PUSHAD_EAX ; file name |
call analyze_directory |
jc get_fileattr_not_found |
|
movzx eax,byte [ebx+11] ; file attribute |
mov PUSHAD_EBX,eax |
popad |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
get_fileattr_not_found: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
|
get_filedate: |
;----------------------------------------------------------- |
; input : eax = file name |
; edx = path |
; output : eax = 0 - ok |
; 3 - unknown FS |
; 5 - file not found |
; ebx = file date/time |
; bits 31..25 = year-1980 |
; bits 24..21 = month |
; bits 20..16 = day |
; bits 15..11 = hour |
; bits 10..5 = minute |
; bits 4..0 = second/2 |
;----------------------------------------------------------- |
cmp [fat_type],0 |
jnz get_filedate_fat_ok |
xor ebx,ebx |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
get_filedate_fat_ok: |
; call reserve_hd1 |
|
pushad |
mov ebx,edx |
call get_cluster_of_a_path |
jc get_filedate_not_found |
|
mov ebx,PUSHAD_EAX ; file name |
call analyze_directory |
jc get_filedate_not_found |
|
mov eax,[ebx+22] ; file date/time |
mov PUSHAD_EBX,eax |
popad |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
get_filedate_not_found: |
popad |
mov [hd1_status],0 |
xor ebx,ebx |
mov eax,ERROR_FILE_NOT_FOUND |
ret |
|
|
get_hd_info: |
;----------------------------------------------------------- |
; output : eax = 0 - ok |
; 3 - unknown FS |
; edx = cluster size in bytes |
; ebx = total clusters on disk |
; ecx = free clusters on disk |
;----------------------------------------------------------- |
cmp [fat_type],0 |
jnz info_fat_ok |
xor edx,edx |
xor ebx,ebx |
xor ecx,ecx |
mov eax,ERROR_UNKNOWN_FS |
ret |
|
info_fat_ok: |
; call reserve_hd1 |
|
xor ecx,ecx ; count of free clusters |
mov eax,2 |
mov ebx,[LAST_CLUSTER] |
|
info_cluster: |
push eax |
call get_FAT ; get cluster info |
test eax,eax ; is it free? |
jnz info_used ; no |
inc ecx |
|
info_used: |
pop eax |
inc eax |
cmp eax,ebx ; is above last cluster? |
jbe info_cluster ; no. test next cluster |
|
dec ebx ; cluster count |
imul edx,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes |
mov [hd1_status],0 |
xor eax,eax |
ret |
|
|
update_disk: |
;----------------------------------------------------------- |
; write changed fat and cache to disk |
;----------------------------------------------------------- |
cmp [fat_change],0 ; is fat changed? |
je upd_no_change |
|
call write_fat_sector |
|
upd_no_change: |
|
call write_cache |
ret |
|
|
;************************************************************************** |
; |
; 0x600008 - first entry in cache list |
; |
; +0 - lba sector |
; +4 - state of cache sector |
; 0 = empty |
; 1 = used for read ( same as in hd ) |
; 2 = used for write ( differs from hd ) |
; |
; +65536 - cache entries |
; |
;************************************************************************** |
|
|
hd_read: |
;----------------------------------------------------------- |
; input : eax = block to read |
; ebx = destination |
;----------------------------------------------------------- |
push ecx esi edi ; scan cache |
|
mov ecx,cache_max ; entries in cache |
mov esi,0x600000+8 |
mov edi,1 |
|
hdreadcache: |
|
cmp dword [esi+4],0 ; empty |
je nohdcache |
|
cmp [esi],eax ; correct sector |
je yeshdcache |
|
nohdcache: |
|
add esi,8 |
inc edi |
dec ecx |
jnz hdreadcache |
|
call find_empty_slot ; ret in edi |
|
call wait_for_hd_idle |
push eax edx |
|
cli |
xor eax,eax |
mov edx,[hdbase] |
inc edx |
out dx,al ; ATAFeatures ðåãèñòð "îñîáåííîñòåé" |
inc edx |
inc eax |
out dx,al ; ATASectorCount ñ÷åò÷èê ñåêòîðîâ |
inc edx |
mov eax,[esp+4] |
out dx,al ; ATASectorNumber ðåãèñòð íîìåðà ñåêòîðà |
shr eax,8 |
inc edx |
out dx,al ; ATACylinder íîìåð öèëèíäðà (ìëàäøèé áàéò) |
shr eax,8 |
inc edx |
out dx,al ; íîìåð öèëèíäðà (ñòàðøèé áàéò) |
shr eax,8 |
inc edx |
and al,1+2+4+8 |
add al,byte [hdid] |
add al,128+64+32 |
out dx,al ; íîìåð ãîëîâêè/íîìåð äèñêà |
inc edx |
mov al,20h |
out dx,al ; ATACommand ðåãèñòð êîìàíä |
sti |
|
call wait_for_sector_buffer |
|
cmp [hd_error],0 |
jne hd_read_error |
|
cli |
push edi |
shl edi,9 |
add edi,0x600000+65536 |
mov ecx,256 |
mov edx,[hdbase] |
cld |
rep insw |
pop edi |
sti |
|
pop edx eax |
blok_read_2: |
lea esi,[edi*8+0x600000] |
mov [esi],eax ; sector number |
mov dword [esi+4],1 ; hd read - mark as same as in hd |
|
yeshdcache: |
|
mov esi,edi |
shl esi,9 |
add esi,0x600000+65536 |
mov edi,ebx |
mov ecx,512/4 |
cld |
rep movsd ; move data |
; blok_read_2: |
pop edi esi ecx |
ret |
|
|
hd_write: |
;----------------------------------------------------------- |
; input : eax = block |
; ebx = pointer to memory |
;----------------------------------------------------------- |
push ecx esi edi |
|
; check if the cache already has the sector and overwrite it |
|
mov ecx,cache_max |
mov esi,0x600000+8 |
mov edi,1 |
|
hdwritecache: |
|
cmp dword [esi+4],0 ; if cache slot is empty |
je not_in_cache_write |
|
cmp [esi],eax ; if the slot has the sector |
je yes_in_cache_write |
|
not_in_cache_write: |
|
add esi,8 |
inc edi |
dec ecx |
jnz hdwritecache |
|
; sector not found in cache |
; write the block to a new location |
|
call find_empty_slot ; ret in edi |
|
lea esi,[edi*8+0x600000] |
mov [esi],eax ; sector number |
|
yes_in_cache_write: |
|
mov dword [esi+4],2 ; write - differs from hd |
|
shl edi,9 |
add edi,0x600000+65536 |
mov esi,ebx |
mov ecx,512/4 |
cld |
rep movsd ; move data |
|
pop edi esi ecx |
ret |
|
|
write_cache: |
;----------------------------------------------------------- |
; write all changed sectors to disk |
;----------------------------------------------------------- |
push eax ecx edx esi edi |
|
; write difference ( 2 ) from cache to hd |
|
mov ecx,cache_max |
mov esi,0x600000+8 |
mov edi,1 |
|
write_cache_more: |
|
cmp dword [esi+4],2 ; if cache slot is not different |
jne does_not_need_writing |
|
mov dword [esi+4],1 ; same as in hd |
mov eax,[esi] ; eax = sector to write |
|
cmp eax,[PARTITION_START] |
jb danger |
cmp eax,[PARTITION_END] |
ja danger |
|
call wait_for_hd_idle |
|
cli |
xor eax,eax |
mov edx,[hdbase] |
inc edx |
out dx,al |
inc edx |
inc eax |
out dx,al |
inc edx |
mov eax,[esi] ; eax = sector to write |
out dx,al |
shr eax,8 |
inc edx |
out dx,al |
shr eax,8 |
inc edx |
out dx,al |
shr eax,8 |
inc edx |
and al,1+2+4+8 |
add al,byte [hdid] |
add al,128+64+32 |
out dx,al |
inc edx |
mov al,30h |
out dx,al |
sti |
|
call wait_for_sector_buffer |
|
cmp [hd_error],0 |
jne hd_write_error |
|
push ecx esi |
|
cli |
mov esi,edi |
shl esi,9 |
add esi,0x600000+65536 ; esi = from memory position |
mov ecx,256 |
mov edx,[hdbase] |
cld |
rep outsw |
sti |
|
pop esi ecx |
|
danger: |
does_not_need_writing: |
|
add esi,8 |
inc edi |
dec ecx |
jnz write_cache_more |
|
pop edi esi edx ecx eax |
ret |
|
|
find_empty_slot: |
;----------------------------------------------------------- |
; find empty or read slot, flush cache if next 10% is used by write |
; output : edi = cache slot |
;----------------------------------------------------------- |
push ecx esi |
|
search_again: |
|
mov ecx,cache_max*10/100 |
mov edi,[cache_search_start] |
|
search_for_empty: |
|
inc edi |
cmp edi,cache_max |
jbe inside_cache |
mov edi,1 |
|
inside_cache: |
|
cmp dword [edi*8+0x600000+4],2 ; get cache slot info |
jb found_slot ; it's empty or read |
dec ecx |
jnz search_for_empty |
|
call write_cache ; no empty slots found, write all |
jmp search_again ; and start again |
|
found_slot: |
|
mov [cache_search_start],edi |
|
pop esi ecx |
ret |
|
|
save_hd_wait_timeout: |
|
push eax |
mov eax,[timer_ticks];[0xfdf0] |
add eax,300 ; 3 sec timeout |
mov [hd_wait_timeout],eax |
pop eax |
ret |
|
|
check_hd_wait_timeout: |
|
push eax |
mov eax,[hd_wait_timeout] |
cmp [timer_ticks], eax ;[0xfdf0],eax |
jg hd_timeout_error |
pop eax |
ret |
|
iglobal |
hd_timeout_str db 'K : FS - HD timeout',13,10,0 |
hd_read_str db 'K : FS - HD read error',13,10,0 |
hd_write_str db 'K : FS - HD write error',13,10,0 |
endg |
|
hd_timeout_error: |
|
call clear_hd_cache |
call clear_application_table_status |
mov esi,hd_timeout_str |
call sys_msg_board_str |
jmp $ |
|
|
hd_read_error: |
|
call clear_hd_cache |
call clear_application_table_status |
mov esi,hd_read_str |
call sys_msg_board_str |
jmp $ |
|
hd_write_error: |
|
call clear_hd_cache |
call clear_application_table_status |
mov esi,hd_write_str |
call sys_msg_board_str |
jmp $ |
|
|
|
|
wait_for_hd_idle: |
|
push eax edx |
|
call save_hd_wait_timeout |
|
mov edx,[hdbase] |
add edx,0x7 |
|
wfhil1: |
|
call check_hd_wait_timeout |
|
in al,dx |
test al,128 |
jnz wfhil1 |
|
pop edx eax |
ret |
|
|
wait_for_sector_buffer: |
|
push eax edx |
|
mov edx,[hdbase] |
add edx,0x7 |
|
call save_hd_wait_timeout |
|
hdwait_sbuf: ; wait for sector buffer to be ready |
|
call check_hd_wait_timeout |
|
in al,dx |
test al,8 |
jz hdwait_sbuf |
|
mov [hd_error],0 |
|
cmp [hd_setup],1 ; do not mark error for setup request |
je buf_wait_ok |
|
test al,1 ; previous command ended up with an error |
jz buf_wait_ok |
mov [hd_error],1 |
|
buf_wait_ok: |
|
pop edx eax |
ret |
|
|
|
read_hd_file: |
;----------------------------------------------------------------- |
; |
; Converting old reading function for hd-application start. |
; |
; IN: |
; |
; eax - pointer to file (0 = read only first sector of drive: eg 'label') |
; ebx - file lenght |
; ecx - start 512 byte block number |
; edx - number of blocks to read |
; esi - pointer to return/work area (atleast 20 000 bytes) |
; |
; For new read function |
; |
; EAX (PAR0) pointer to file-name |
; ECX (PAR1) pointer to buffer |
; EBX (PAR2) vt file blocks to read |
; EDX (PAR3) pointer to path |
; ESI vt first 512 block to read |
; EDI if 0 - return root |
;-------------------------------------------------------------------------- |
|
push ecx esi edi |
mov esi,eax |
mov edi,startpath |
mov ecx,250 |
cld |
rep movsb |
pop edi esi ecx |
|
mov eax,startpath |
mov [eax+ebx-12],byte 0 |
|
push eax ebx ecx edx esi |
|
pop ecx ; pointer to buffer |
add ecx,1024 |
pop ebx ; number of blocks to read |
pop esi ; first block to read |
dec esi |
pop eax ; file length |
pop edx ; pointer to path |
|
mov edi,12 |
lea eax,[eax+edx-12+1] |
call file_read |
|
ret |
|