kolibrios/kernel/trunk/fs/exfat.inc
Doczom d8b8010bbd Krn: Fixed the number of functions in the file system drivers
git-svn-id: svn://kolibrios.org@10015 a494cfbc-eb01-0410-851d-a64ba20cac60
2024-05-09 14:22:13 +00:00

2711 lines
89 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2021-2022. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License. ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$Revision$
; exFAT external functions
; in:
; ebx -> parameter structure of sysfunc 70
; ebp -> exFAT structure
; esi -> path string in UTF-8
; out:
; eax, ebx = return values for sysfunc 70
iglobal
align 4
exFAT_user_functions:
dd exFAT_free
dd (exFAT_user_functions_end - exFAT_user_functions - 8) / 4
dd exFAT_ReadFile
dd exFAT_ReadFolder
dd 0 ;exFAT_CreateFile
dd 0 ;exFAT_Write
dd 0 ;exFAT_SetFileEnd
dd exFAT_GetFileInfo
dd exFAT_SetFileInfo
dd 0
dd exFAT_Delete
dd 0 ;exFAT_CreateFolder
dd 0 ;exFAT_Rename
exFAT_user_functions_end:
endg
struct exFAT PARTITION
fat_change db ? ; 1=fat has changed
ClstHeap_change db ? ; 1=Cluster Heap has changed
createOption db ?
rb 2
Lock MUTEX ; currently operations with one partition
; can not be executed in parallel since the legacy code is not ready
FAT_START dd ? ; start of fat table
ROOT_START dd ? ; start of rootdir
SECTORS_PER_CLUSTER dd ?
BYTES_PER_SECTOR dd ? ; Note: if BPS <> 512 need lots of changes
SECTORS_PER_FAT dd ?
NUMBER_OF_FATS dd ?
CLUSTER_HEAP_START dd ?
CLUSTER_COUNT dd ?
DATA_START dd ? ; start of data area (=first cluster 2)
LAST_CLUSTER dd ? ; last availabe cluster
fatRESERVED dd ?
fatBAD dd ?
fatEND dd ?
fatMASK dd ?
fatStartScan dd ?
cluster_tmp dd ? ; used by analyze_directory and analyze_directory_to_write
ROOT_CLUSTER dd ? ; first rootdir cluster
points_to_BDFE dd ?
secondary_dir_entry dd ?
longname_sec1 dd ? ; used by analyze_directory to save 2 previous
longname_sec2 dd ? ; directory sectors for delete long filename
longname_sector1 dd ? ; used by analyze_directory to save 2 previous
longname_sector2 dd ? ; directory sectors for delete long filename
LFN_reserve_place dd ?
path_in_UTF8 dd ?
General_Sec_Flags dd ?
valid_data_length dd ?
RAX_high dd ?
RCX_high dd ?
RDX_high dd ?
RDI_high dd ?
current_hash dd ?
hash_flag dd ?
need_hash dd ?
buffer_curr_sector dd ?
buff_file_dirsect dd ?
buff_file_dir_pos dd ?
fname_extdir_offset dd ?
fat_in_cache dd ?
fat_cache_ptr dd ?
ClstHeap_in_cache dd ?
ClstHeap_cache_ptr dd ?
volumeLabel rb 12
; The next areas (32*19) should be arranged sequentially.
; Do not change their location!!!
file_dir_entry rb 32 ; Entry Type 0x85
str_ext_dir_entry rb 32 ; Entry Type 0xC0
fname_ext_dir_entry rb 32*17 ; Entry Type 0xC1 * 17 Entries
buffer rb 512
ends
; these labels are located before the main function to make
; most of jumps to these be short
exFAT_create_partition.free_return0:
mov eax, ebp
call free
pop ebp
; DEBUGF 1, "K : exFAT_create_partition.free_return0 EAX: %x\n", eax
exFAT_create_partition.return0:
xor eax, eax
; DEBUGF 1, "K : exFAT_create_partition.return0 EAX: %x\n", eax
ret
; Mount if it's a valid exFAT partition.
exFAT_create_partition:
; DEBUGF 1, "K : exFAT_create_partition EAX: %x\n", eax
; in:
; ebp -> PARTITION structure
; ebx -> boot sector
; ebx+512 -> buffer
; out:
; eax -> exFAT structure, 0 = not exFAT
cmp dword [esi+DISK.MediaInfo.SectorSize], 512
jnz .return0
; DEBUGF 1, "K : exFAT DISK.MediaInfo.SectorSize=512\n"
; bootsector must have been successfully read
cmp dword [esp+4], 0
jnz .return0
; DEBUGF 1, "K : exFAT bootsector successfully read\n"
; offset +510 = bootsector signature must be correct
cmp word [ebx+0x1fe], 0xaa55
jnz .return0
; DEBUGF 1, "K : exFAT bootsector signature correct\n"
; offset +109 = sectors per cluster must be nonzero
cmp byte [ebx+0x6d], 0
jz .return0
; DEBUGF 1, "K : exFAT sectors per cluster = nonzero\n"
; offset +108 = bytes per sector must be 0x200
; (LEGACY! In the future, increase support to 4096)
; the value for exFAT is a power of 2
cmp byte [ebx+0x6c], 9
jnz .return0
; DEBUGF 1, "K : exFAT bytes per sector = 512\n"
; Test name = 'EXFAT '
cmp dword [ebx+3], 'EXFA'
jnz .return0
cmp dword [ebx+7], 'T '
jnz .return0
; DEBUGF 1, "K : exFAT Test name EXFAT = OK \n"
movi eax, sizeof.exFAT
call malloc
test eax, eax
jz .return0
; DEBUGF 1, "K : exFAT malloc sizeof.exFAT = OK \n"
mov ecx, dword [ebp+PARTITION.FirstSector]
mov dword [eax+exFAT.FirstSector], ecx
; DEBUGF 1, "K : exFAT PARTITION.FirstSector ECX: %x\n", ecx
mov ecx, dword [ebp+PARTITION.FirstSector+4]
mov dword [eax+exFAT.FirstSector+4], ecx
; DEBUGF 1, "K : exFAT PARTITION.FirstSector+4 ECX: %x\n", ecx
mov ecx, dword [ebp+PARTITION.Length]
mov dword [eax+exFAT.Length], ecx
; DEBUGF 1, "K : exFAT PARTITION.Length ECX: %x\n", ecx
mov ecx, dword [ebp+PARTITION.Length+4]
mov dword [eax+exFAT.Length+4], ecx
; DEBUGF 1, "K : exFAT PARTITION.Length+4 ECX: %x\n", ecx
mov ecx, [ebp+PARTITION.Disk]
mov [eax+exFAT.Disk], ecx
; DEBUGF 1, "K : exFAT PARTITION.Disk ECX: %x\n", ecx
mov [eax+exFAT.FSUserFunctions], exFAT_user_functions
or [eax+exFAT.fat_in_cache], -1
mov [eax+exFAT.fat_change], 0
push ebp
mov ebp, eax
lea ecx, [ebp+exFAT.Lock]
call mutex_init
; offset +80 = sectors reserved
mov eax, [ebx+0x50]
mov [ebp+exFAT.FAT_START], eax
; DEBUGF 1, "K : exFAT.FAT_START EAX: %x\n", eax
; offset +109 = sectors per cluster. This is power of 2; Minimal value is 1;
; 2^0 =1 sector (512 Bytes) and maximum 32 MB cluster size in bytes
movzx ecx, byte [ebx+0x6d]
mov eax, 1
shl eax, cl
mov [ebp+exFAT.SECTORS_PER_CLUSTER], eax
; DEBUGF 1, "K : exFAT.SECTORS_PER_CLUSTER EAX: %x\n", eax
; offset +108 = bytes per sector. This is power of 2; Minimal value is 9;
; 2^9 =512 Bytes and maximum 2^12 =4096 Bytes
movzx ecx, byte [ebx+0x6c] ; bytes per sector
mov eax, 1
shl eax, cl
mov [ebp+exFAT.BYTES_PER_SECTOR], eax
; DEBUGF 1, "K : exFAT.BYTES_PER_SECTOR EAX: %x\n", eax
;------------------------------------------------------------------------------
; movzx eax, word [ebx+0x11] ; count of rootdir entries (=0 fat32)
; shl eax, 5 ; mul 32
; dec ecx
; add eax, ecx ; round up if not equal count
; inc ecx ; bytes per sector
; xor edx, edx
; div ecx
; mov [ebp+FAT.ROOT_SECTORS], eax ; count of rootdir sectors
;------------------------------------------------------------------------------
; offset +84 = Size of FAT in sectors
mov eax, [ebx+0x54] ; sectors per fat
mov [ebp+exFAT.SECTORS_PER_FAT], eax
; DEBUGF 1, "K : exFAT.SECTORS_PER_FAT EAX: %x\n", eax
;------------------------------------------------------------------------------
; offset +88 = Starting sector of cluster heap
mov eax, [ebx+0x58] ; Cluster offset
mov [ebp+exFAT.CLUSTER_HEAP_START], eax
; DEBUGF 1, "K : exFAT.CLUSTER_HEAP_START EAX: %x\n", eax
;------------------------------------------------------------------------------
; offset +92 = Number of clusters
mov eax, [ebx+0x5c] ; Cluster count
mov [ebp+exFAT.CLUSTER_COUNT], eax
; DEBUGF 1, "K : exFAT.CLUSTER_COUNT EAX: %x\n", eax
;------------------------------------------------------------------------------
; offset +110 = Either 1 or 2; if TexFAT is supported then it will be 2
movzx eax, byte [ebx+0x6e] ; number of fats
mov [ebp+exFAT.NUMBER_OF_FATS], eax
; DEBUGF 1, "K : exFAT.NUMBER_OF_FATS EAX: %x\n", eax
mul [ebp+exFAT.SECTORS_PER_FAT]
; DEBUGF 1, "K : exFAT.SECTORS_PER_FAT mul EAX: %x\n", eax
; test edx, edx
; jnz .free_return0
add eax, [ebp+exFAT.FAT_START]
jc .free_return0
; mov [ebp+FAT.ROOT_START], eax ; rootdir = fat_start + fat_size * fat_count
; add eax, [ebp+FAT.ROOT_SECTORS] ; rootdir sectors should be 0 on fat32
; jc .free_return0
mov [ebp+exFAT.DATA_START], eax
; DEBUGF 1, "K : exFAT.DATA_START EAX: %x\n", eax
;------------------------------------------------------------------------------
; offset +72 = Total number of Sectors
mov eax, [ebx+0x48+4] ; total sector count high part
test eax, eax
jnz .free_return0 ; 32-BIT LIMIT - MODIFY LATER WITY RASP !!!
; DEBUGF 1, "K : exFAT Total number of Sectors+4 EAX: %x\n", eax
mov eax, [ebx+0x48] ; total sector count low part
; DEBUGF 1, "K : exFAT Total number of Sectors EAX: %x\n", eax
cmp dword [ebp+exFAT.Length+4], 0
jnz @f
; DEBUGF 1, "K : exFAT.Length+4 = 0\n"
cmp eax, dword [ebp+exFAT.Length]
ja .free_return0
; DEBUGF 1, "K : exFAT.Length >= Total number of Sectors\n"
@@:
mov dword [ebp+exFAT.Length], eax
and dword [ebp+exFAT.Length+4], 0
sub eax, [ebp+exFAT.DATA_START] ; eax = count of data sectors
jc .free_return0
; DEBUGF 1, "K : EAX - exFAT.DATA_START EAX: %x\n", eax
xor edx, edx
div [ebp+exFAT.SECTORS_PER_CLUSTER]
inc eax
mov [ebp+exFAT.LAST_CLUSTER], eax
; DEBUGF 1, "K : exFAT.LAST_CLUSTER EAX: %x\n", eax
dec eax ; cluster count
jz .free_return0
; DEBUGF 1, "K : exFAT.LAST_CLUSTER >= 2 EAX: %x\n",eax
mov [ebp+exFAT.fatStartScan], 2
; cmp eax, 0xfff5
; jb .fat16
;------------------------------------------------------------------------------
;.fat32:
; pusha
; lea esi, [ebx+71]
; lea edi, [ebp+exFAT.volumeLabel]
; movsd
; movsd
; movsd
; popa
;------------------------------------------------------------------------------
; offset +96 = First cluster of root directory
mov eax, [ebx+0x60] ; rootdir cluster
mov [ebp+exFAT.ROOT_CLUSTER], eax
; DEBUGF 1, "K : exFAT.ROOT_CLUSTER EAX: %x\n", eax
dec eax
dec eax
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
mov [ebp+exFAT.ROOT_START], eax
; DEBUGF 1, "K : exFAT.ROOT_START EAX: %x\n", eax
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; movzx eax, word [ebx+0x30]
; mov [ebp+FAT.ADR_FSINFO], eax
;------------------------------------------------------------------------------
; push ebx
; add ebx, 512
; call fs_read32_sys
; test eax, eax
; jnz @f
; mov eax, [ebx+0x1ec]
; cmp eax, -1
; jz @f
; mov [ebp+exFAT.fatStartScan], eax
;@@:
; pop ebx
;------------------------------------------------------------------------------
mov [ebp+exFAT.fatRESERVED], 0x0FFFFFF6
mov [ebp+exFAT.fatBAD], 0x0FFFFFF7
mov [ebp+exFAT.fatEND], 0x0FFFFFF8
mov [ebp+exFAT.fatMASK], 0x0FFFFFFF
;------------------------------------------------------------------------------
; mov al, 32
;.fat_not_12_finalize:
; mov [ebp+FAT.fs_type], al
;------------------------------------------------------------------------------
; For FAT16 and FAT32, allocate 512 bytes for FAT cache.
; For exFAT allocate 512 bytes for Cluster Heap cache.
mov eax, 512*2
call malloc
test eax, eax
jz .free_return0
mov [ebp+exFAT.fat_cache_ptr], eax
add eax, 512
mov [ebp+exFAT.ClstHeap_cache_ptr], eax
; DEBUGF 1, "K : malloc exFAT.fat_cache_ptr EAX: %x\n", eax
mov eax, ebp
pop ebp
ret
;------------------------------------------------------------------------------
exFAT_free:
push eax
mov eax, [eax+exFAT.fat_cache_ptr]
; DEBUGF 1, "K : exFAT_free exFAT.fat_cache_ptr EAX: %x\n", eax
call free
pop eax
jmp free
;------------------------------------------------------------------------------
exFAT_lock:
; DEBUGF 1, "K : exFAT_lock \n"
lea ecx, [ebp+exFAT.Lock]
jmp mutex_lock
exFAT_unlock:
; DEBUGF 1, "K : exFAT_unlock \n"
lea ecx, [ebp+exFAT.Lock]
jmp mutex_unlock
;------------------------------------------------------------------------------
exFAT_get_name:
cmp byte [edi], 0
jz .no
; DEBUGF 1, "K : exFAT_get_name EDI:%x [EDI]:%x\n", edi, [edi]
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4+4]
; DEBUGF 1, "K : exFAT_get_name START Input FS EBP:%x\n", ebp
; pop ebp
; in: edi -> FAT entry, esi -> buffer for UTF-16 name
; out: CF=1 -> no valid entry
cmp byte [edi], 0x85 ; File/Folder Directory Entry of ExFAT
jz .file_directory_entry
cmp byte [edi], 0xC0 ; Stream Extension Directory Entry of ExFAT
jz .stream_extension_directory_entry
cmp byte [edi], 0xC1 ; File Name Extension Directory Entry of ExFAT
jz .longname
push edi esi
xchg esi, edi
; DEBUGF 1, "K : exFAT Volume label dword [ESI]: %x\n", [esi]
cmp byte [esi], 0x83 ; Indicates that the Volume label exists
jnz .no_label
.label:
; DEBUGF 1, "K : exFAT_get_name.label \n"
add esi, 2
lea edi, [ebp+exFAT.volumeLabel]
push ecx
mov ecx, 12
call UTF16to8_string
pop ecx
; push edi
; lea edi, [ebp+exFAT.volumeLabel]
; DEBUGF 1, "K : exFAT Volume label: %s\n", edi
; pop edi
.no_label:
; DEBUGF 1, "K : exFAT_get_name.no_label \n"
pop esi edi
.no:
; DEBUGF 1, "K : exFAT_get_name.no \n"
stc
ret
;--------------------------------------
.save_curr_sector_number:
mov eax, [ebp+exFAT.buffer_curr_sector]
cmp eax, [ebp+exFAT.longname_sector2]
je @f
push [ebp+exFAT.longname_sector2]
pop [ebp+exFAT.longname_sector1]
mov [ebp+exFAT.longname_sector2], eax
@@:
ret
;--------------------------------------
.file_directory_entry:
; DEBUGF 1, "K : exFAT_get_name 0x85\n"
mov eax, [ebp+exFAT.buffer_curr_sector]
mov [ebp+exFAT.buff_file_dirsect], eax
mov [ebp+exFAT.buff_file_dir_pos], edi
lea eax, [ebp+exFAT.fname_ext_dir_entry]
mov [ebp+exFAT.fname_extdir_offset], eax
xor eax, eax
mov [ebp+exFAT.longname_sector1], eax
mov [ebp+exFAT.longname_sector2], eax
mov [ebp+exFAT.hash_flag], eax ; dword 0
mov al, byte [edi+1] ; Number of Secondary directory entries
dec eax
mov [ebp+exFAT.secondary_dir_entry], eax
; DEBUGF 1, "K : exFAT_get_name 0x85 SDE: %x\n", eax
lea esi, [ebp+exFAT.file_dir_entry]
; DEBUGF 1, "K : exFAT.file_dir_entry ESI: %x [ESI]: %x\n", esi, [esi]
jmp @f
;--------------------------------------
.stream_extension_directory_entry:
; DEBUGF 1, "K : exFAT_get_name 0xC0\n"
; DEBUGF 1, "K : exFAT SEDE need_hash :%x\n", [ebp+exFAT.need_hash]
call .save_curr_sector_number
mov eax, [ebp+exFAT.need_hash]
test eax, eax
jz .stream_extension_directory_entry_1 ; @f
movzx eax, word [edi+4] ; hash of the file name
; DEBUGF 1, "K : exFAT hash 1 :%x\n", eax
; DEBUGF 1, "K : exFAT hash 2 :%x\n", [ebp+exFAT.current_hash]
cmp eax, [ebp+exFAT.current_hash]
je .stream_extension_directory_entry_1 ; @f
xor eax, eax
inc eax
mov [ebp+exFAT.hash_flag], eax ; dword 1
; DEBUGF 1, "K : exFAT hashes don't match! \n"
.stream_extension_directory_entry_1:
lea esi, [ebp+exFAT.str_ext_dir_entry]
; DEBUGF 1, "K : exFAT.str_ext_dir_entry ESI: %x [ESI]: %x\n", esi, [esi]
@@:
push edi
xchg esi, edi
movsd
movsd
movsd
movsd
movsd
movsd
movsd
movsd
pop edi
; lea esi, [esp+20]
mov esi, [ebp+exFAT.LFN_reserve_place]
mov word [esi+260*2], 0 ; force null-terminating for orphans
jmp .no
;--------------------------------------
.longname:
; DEBUGF 1, "K : exFAT_get_name 0xC1\n"
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4+4]
; DEBUGF 1, "K : exFAT_get_name.longname 0 Input FS EBP:%x\n", ebp
; pop ebp
; DEBUGF 1, "K : exFAT_get_name.longname \n"
; DEBUGF 1, "K : exFAT_get_name.longname EDI:%x [EDI]:%x ESI:%x [ESI]:%x EBP:%x NAME:%s\n", edi, [edi], esi, [esi], ebp, ebp
; copy name (15 chars in UTF-16)
; mov word [esi+260*2], 0 ; force null-terminating for orphans
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4+4]
; DEBUGF 1, "K : exFAT_get_name.longname Input FS EBP:%x\n", ebp
; pop ebp
call .save_curr_sector_number
mov eax, [ebp+exFAT.hash_flag]
test eax, eax
jnz .no
; DEBUGF 1, "K : exFAT_get_name.longname hash match! \n"
; copy File Name Extension Directory Entry [0xC1] for calculate SetChecksum Field
lea eax, [ebp+exFAT.fname_ext_dir_entry+32*17]
cmp eax, [ebp+exFAT.fname_extdir_offset]
je .no
push edi esi
xchg esi, edi
mov edi, [ebp+exFAT.fname_extdir_offset]
movsd
movsd
movsd
movsd
movsd
movsd
movsd
movsd
mov [ebp+exFAT.fname_extdir_offset], edi
pop esi edi
; copy name
push edi esi
xchg esi, edi
add esi, 2
movsd
movsd
movsd
movsd
movsd
movsd
movsd
movsw
; force null-terminating for incomplete name
xor eax, eax
stosw
pop esi edi
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4+4]
; DEBUGF 1, "K : exFAT_get_name.longname Output FS EBP:%x\n", ebp
; pop ebp
mov eax, [ebp+exFAT.secondary_dir_entry]
dec eax
mov [ebp+exFAT.secondary_dir_entry], eax
jz @f
add esi, 30
; DEBUGF 1, "K : exFAT_get_name 0xC1 CONT\n"
jmp .no
; test ax, ax
; jnz .no ; if this is not first entry, more processing required
@@:
; mov esi, [ebp+exFAT.LFN_reserve_place]
; DEBUGF 1, "K : exFAT_get_name.longname END \n"
; DEBUGF 1, "K : exFAT_get_name 0xC1 END\n"
ret
;------------------------------------------------------------------------------
exFAT_entry_to_bdfe:
; DEBUGF 1, "K : exFAT_ReadFolder exFAT_entry_to_bdfe \n"
; convert FAT entry at edi to BDFE (block of data of folder entry) at esi, advance esi
mov eax, [ebp-4]
mov [esi+4], eax ; cp866/UNICODE name
exFAT_entry_to_bdfe2:
; movzx eax, byte [edi+11]
movzx eax, byte [edi+4]
mov [esi], eax ; attributes
; movzx eax, word [edi+14]
movzx eax, word [edi+8]
call fat_time_to_bdfe
mov [esi+8], eax ; creation time
; movzx eax, word [edi+16]
movzx eax, word [edi+8+2]
call fat_date_to_bdfe
mov [esi+12], eax ; creation date
; and dword [esi+16], 0 ; last access time is not supported on FAT
movzx eax, word [edi+16]
call fat_time_to_bdfe
mov [esi+16], eax ; last access time
; movzx eax, word [edi+18]
movzx eax, word [edi+16+2]
call fat_date_to_bdfe
mov [esi+20], eax ; last access date
; movzx eax, word [edi+22]
movzx eax, word [edi+12]
call fat_time_to_bdfe
mov [esi+24], eax ; last write time
; movzx eax, word [edi+24]
movzx eax, word [edi+12+2]
call fat_date_to_bdfe
mov [esi+28], eax ; last write date
mov al, [esi]
test al, 10000b
jz .file_size
xor eax, eax
mov [esi+32], eax ; file size (low dword)
mov [esi+36], eax ; file size (high dword)
jmp @f
.file_size:
mov eax, [edi+32+8]
mov [esi+32], eax ; file size (low dword)
mov eax, [edi+32+8+4]
mov [esi+36], eax ; file size (high dword)
@@:
test ebp, ebp
jz .ret
.copy_path:
add esi, 40
push edi esi
mov edi, esi
mov esi, ebp
cmp byte [ebp-4], 2
jz .utf16
cmp byte [ebp-4], 3
jz .utf8
@@:
lodsw
call uni2ansi_char
stosb
test al, al
jnz @b
pop esi edi
add esi, 264
.ret:
; DEBUGF 1, "K : exFAT_entry_to_bdfe +264 ESI:%x\n", esi
ret
.utf8:
push ecx
mov ecx, 519
call UTF16to8_string
pop ecx
jmp @f
.utf16:
lodsw
stosw
test eax, eax
jnz .utf16
@@:
pop esi edi
add esi, 520
; DEBUGF 1, "K : exFAT_entry_to_bdfe +520 ESI:%x\n", esi
ret
;------------------------------------------------------------------------------
exFAT_bdfe_to_fat_entry:
; convert BDFE at edx to FAT entry at edi
; destroys eax
; attributes byte
; test byte [edi+11], 8 ; volume label?
; jnz @f
mov al, [edx]
; movzx eax, al
; DEBUGF 1, "K : bdfe file attributes: %x\n", eax
and al, 0x27
; and byte [edi+11], 0x10
; or byte [edi+11], al
and byte [edi+4], 0x10
or byte [edi+4], al
; movzx eax, byte [edi+4]
; DEBUGF 1, "K : exFAT file attributes: %x\n", eax
;@@:
mov eax, [edx+8]
; DEBUGF 1, "K : bdfe creation time: %x\n", eax
call bdfe_to_fat_time
; mov [edi+14], ax ; creation time
mov [edi+8], ax ; creation time
; DEBUGF 1, "K : exFAT creation time: %x\n", ax
mov eax, [edx+12]
; DEBUGF 1, "K : bdfe creation date: %x\n", eax
call bdfe_to_fat_date
; mov [edi+16], ax ; creation date
mov [edi+8+2], ax ; creation date
; DEBUGF 1, "K : exFAT creation date: %x\n", ax
mov eax, [edx+16]
; DEBUGF 1, "K : bdfe access time: %x\n", eax
call bdfe_to_fat_time
mov [edi+16], ax ; last access time
; DEBUGF 1, "K : exFAT access time: %x\n", ax
mov eax, [edx+20]
; DEBUGF 1, "K : bdfe access date: %x\n", eax
call bdfe_to_fat_date
; mov [edi+18], ax ; last access date
mov [edi+16+2], ax ; last access date
; DEBUGF 1, "K : exFAT access date: %x\n", ax
mov eax, [edx+24]
; DEBUGF 1, "K : bdfe write time: %x\n", eax
call bdfe_to_fat_time
; mov [edi+22], ax ; last write time
mov [edi+12], ax ; last write time
; DEBUGF 1, "K : exFAT write time: %x\n", ax
mov eax, [edx+28]
; DEBUGF 1, "K : bdfe write date: %x\n", eax
call bdfe_to_fat_date
; mov [edi+24], ax ; last write date
mov [edi+12+2], ax ; last write date
; DEBUGF 1, "K : exFAT write date: %x\n", ax
ret
;------------------------------------------------------------------------------
exFAT_set_FAT:
; in: eax = cluster, edx = value to save
; out: edx = old value, CF=1 -> error
push eax ebx esi
cmp eax, 2
jc .ret
cmp [ebp+exFAT.LAST_CLUSTER], eax
jc .ret
add eax, eax
@@:
add eax, eax
mov esi, 511
and esi, eax
shr eax, 9
add eax, [ebp+exFAT.FAT_START]
mov ebx, [ebp+exFAT.fat_cache_ptr]
cmp eax, [ebp+exFAT.fat_in_cache]
je .inCache
cmp [ebp+exFAT.fat_change], 0
je @f
call exFAT_write_fat_sector
@@:
mov [ebp+exFAT.fat_in_cache], eax
call fs_read32_sys
test eax, eax
jne .error
.inCache:
mov eax, [ebp+exFAT.fatMASK]
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
.write:
mov [ebp+exFAT.fat_change], 1
and edx, [ebp+exFAT.fatMASK]
.ret:
pop esi ebx eax
ret
.error:
stc
jmp .ret
;------------------------------------------------------------------------------
exFAT_get_FAT:
; DEBUGF 1, "K : exFAT_get_FAT \n"
; in: eax = cluster
; out: eax = next cluster, CF=1 -> error
push ebx esi
; cmp [ebp+FAT.fs_type], 12
; je .FAT12
; cmp [ebp+FAT.fs_type], 16
; je @f
; add eax, eax
;@@:
; add eax, eax
shl eax, 2
mov esi, 511
and esi, eax
shr eax, 9
add eax, [ebp+exFAT.FAT_START]
mov ebx, [ebp+exFAT.fat_cache_ptr]
cmp eax, [ebp+exFAT.fat_in_cache]
je .inCache
cmp [ebp+exFAT.fat_change], 0
je @f
call exFAT_write_fat_sector
@@:
mov [ebp+exFAT.fat_in_cache], eax
call fs_read32_sys
test eax, eax
jnz .error
.inCache:
; DEBUGF 1, "K : exFAT_get_FAT.inCache \n"
mov eax, [ebx+esi]
and eax, [ebp+exFAT.fatMASK]
.ret:
pop esi ebx
ret
.error:
; DEBUGF 1, "K : exFAT_get_FAT.error \n"
stc
jmp .ret
;------------------------------------------------------------------------------
exFAT_hd_find_lfn:
; DEBUGF 1, "K : exFAT_hd_find_lfn path ESI: %s\n", esi
; in: esi -> path string in UTF-8
; out: CF=1 - file not found, eax=error code
; else CF=0 and edi->direntry, eax=sector
push esi edi
push 0
push 0
push exFAT_notroot_first ; 0 ; fat1x_root_first
push exFAT_notroot_next ; 0 ; fat1x_root_next
xor eax, eax
mov [ebp+exFAT.General_Sec_Flags], eax
mov dword [ebp+exFAT.valid_data_length], 0xffffffff ; for ROOT
mov eax, [ebp+exFAT.ROOT_CLUSTER]
; mov [ebp+exFAT.secondary_dir_entry], dword 1
; cmp [ebp+FAT.fs_type], 32
; jz .fat32
jmp @f ; .fat32
.loop:
and [ebp+exFAT.longname_sec1], 0
and [ebp+exFAT.longname_sec2], 0
; push ebp
; mov ebp,[esp+12+8+4+4+7*4]
; DEBUGF 1, "K : exFAT_find_lfn Input FS EBP:%x\n", ebp
; pop ebp
call exFAT_find_lfn
; push ebp
; mov ebp,[esp+12+8+4+4+7*4]
; DEBUGF 1, "K : exFAT_find_lfn Output FS EBP:%x\n", ebp
; pop ebp
jc .notfound
; DEBUGF 1, "K : exFAT_hd_find_lfn [ESI]: %x\n", [esi]
cmp byte [esi], 0
jz .found
; test byte [edi+11], 10h
push eax
lea eax, [ebp+exFAT.file_dir_entry]
; DEBUGF 1, "K : exFAT_hd_find_lfn exFAT.file_dir_entry [EAX]: %x\n", [eax]
test byte [eax+4], 10000b
pop eax
jz .notfound
and dword [esp+12], 0
; this entrys first cluster number
; mov eax, [edi+20-2]
; mov ax, [edi+26] ; cluster
lea eax, [ebp+exFAT.str_ext_dir_entry]
push eax
movzx eax, byte [eax+1]
mov [ebp+exFAT.General_Sec_Flags], eax
; DEBUGF 1, "K : exFAT General_Sec_Flags %x\n", eax
mov eax, [esp]
mov eax, [eax+8] ; LOW dword of Valid data length - WARNING!!! late rewrite
mov [ebp+exFAT.valid_data_length], eax
; DEBUGF 1, "K : exFAT.valid_data_length 1 %x\n", eax
pop eax
mov eax, [eax+20] ; cluster
;.fat32:
@@:
; DEBUGF 1, "K : exFAT_hd_find_lfn exFAT cluster EAX: %x\n", eax
mov [esp+8], eax
; mov dword [esp+4], exFAT_notroot_first ; fat_notroot_first
; mov dword [esp], exFAT_notroot_next ; fat_notroot_next
jmp .loop
.notfound:
; DEBUGF 1, "K : exFAT_hd_find_lfn.notfound EAX:%x\n", eax
add esp, 16
pop edi esi
stc
ret
.found:
; DEBUGF 1, "K : exFAT_hd_find_lfn.found \n"
lea eax, [esp+8]
cmp dword [eax], 0
jz .root
call exFAT_get_sector
jmp .cmn
.root:
; DEBUGF 1, "K : exFAT_hd_find_lfn.found.root \n"
mov eax, [eax+4]
add eax, [ebp+exFAT.ROOT_START]
.cmn:
; DEBUGF 1, "K : exFAT_hd_find_lfn.found.cmn \n"
add esp, 20 ; CF=0
pop esi
ret
;------------------------------------------------------------------------------
exFAT_find_lfn:
; DEBUGF 1, "K : exFAT_find_lfn \n"
; in:
; esi -> path in UTF-8
; parameters in the stack
; out:
; esi -> next name in the path
; edi -> direntry
; CF=1 -> file not found, eax = error code
xor eax, eax
inc eax
mov [ebp+exFAT.secondary_dir_entry], eax ; dword 1
mov [ebp+exFAT.need_hash], eax ; dword 1
lea eax, [esp+12]
call dword [eax-4] ; exFAT_notroot_first
jc .reterr
sub esp, 262*2 ; reserve place for LFN
; lea eax, [esp]
mov eax, esp
mov [ebp+exFAT.LFN_reserve_place], eax
mov [ebp+exFAT.path_in_UTF8], esi
; DEBUGF 1, "K : exFAT_find_lfn Path: %s\n", esi
; DEBUGF 1, "K : exFAT Path: %s\n", esi
; DEBUGF 1, "K : exFAT Path1: %x %x %x\n", [esi], [esi+4], [esi+8]
push esi edi
; lea edi, [esp+8]
mov edi, eax
align 4
@@:
; in: esi -> UTF-8 char (increasing)
; out: ax = UTF-16 char
call utf8to16
call utf16toUpper
stosw
test ax, ax
jz @f
cmp ax, word 0x002f ; "/"
jne @b
@@:
; mov [edi-2], dword 0
mov esi, [ebp+exFAT.LFN_reserve_place]
; DEBUGF 1, "K : exFAT Path2: %x %x %x\n", [esi], [esi+4], [esi+8]
push ebx ecx
mov ecx, edi
sub ecx, esi
sub ecx, 2 ; correction for zero or "/"
; exFAT_hash_calculate
; in:
; esi -> NameUTF16
; ecx -> NameUTF16 length
; out: ax = hash
xor eax, eax
xor ebx, ebx
;--------------------------------------
align 4
.start:
; DEBUGF 1, "Hash start EAX:%x ECX:%x\n", eax, ecx
mov bx, ax
; (Hash&1) ? 0x8000 : 0)
and ax, 0x1
jz .else
mov ax, 0x8000
jmp @f
;--------------------------------------
.else:
xor ax, ax
;--------------------------------------
@@:
; DEBUGF 1, "(Hash&1) EAX:%x\n", eax
; (Hash>>1)
shr bx, 1
; DEBUGF 1, "(Hash>>1) EBX:%x\n", ebx
add ax, bx
; DEBUGF 1, "+ (Hash>>1)) EAX:%x\n", eax
movzx bx, byte [esi]
add ax, bx
; DEBUGF 1, "+ (UInt16)Buffer[Index] EAX:%x\n", eax
inc esi
dec ecx
jnz .start
;--------------------------------------
pop ecx ebx
mov [ebp+exFAT.current_hash], eax
; DEBUGF 1, "K : exFAT current hash :%x\n", eax
pop edi esi
.l1:
; push esi
; lea esi, [esp+4]
; mov esi, [ebp+exFAT.LFN_reserve_place]
; DEBUGF 1, "K : exFAT_find_lfn.exFAT_get_name \n"
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4]
; DEBUGF 1, "K : exFAT_get_name Input FS EBP:%x\n", ebp
; pop ebp
; DEBUGF 1, "K : exFAT FL need_hash :%x\n", [ebp+exFAT.need_hash]
call exFAT_get_name
; mov [ebp+exFAT.LFN_reserve_place], esi
; pop esi
; push ebp
; mov ebp,[esp+12+8+4+4+7*4+262*2+4]
; DEBUGF 1, "K : exFAT_get_name Output FS EBP:%x\n", ebp
; pop ebp
jc .no
; push eax
xor eax, eax
cmp [ebp+exFAT.secondary_dir_entry], eax
; pop eax
jnz .no
push edi esi
mov esi, [ebp+exFAT.path_in_UTF8]
lea edi, [esp+8]
@@:
call utf8to16
call utf16toUpper
mov edx, eax
mov ax, [edi]
call utf16toUpper
cmp ax, dx
jnz .done
add edi, 2
test ax, ax
jnz @b
dec esi
pop eax edi
.found:
; DEBUGF 1, "K : exFAT_find_lfn.found \n"
add esp, 262*2
; if this is LFN entry, advance to true entry
; cmp byte [edi+11], 0xF
; jnz @f
xor eax, eax
cmp [ebp+exFAT.secondary_dir_entry], eax
jz @f
lea eax, [esp+12]
call dword[eax-8] ; exFAT_notroot_next
jc .reterr
@@:
; DEBUGF 1, "K : exFAT_find_lfn.OK \n"
xor eax, eax
ret
.done:
; DEBUGF 1, "K : exFAT_find_lfn.done \n"
cmp dx, '/'
jnz @f
test ax, ax
jnz @f
mov [esp], esi
@@:
pop esi edi
jz .found
.no:
; DEBUGF 1, "K : exFAT_find_lfn.no \n"
lea eax, [esp+262*2+12]
; DEBUGF 1, "K : exFAT General_Sec_Flags %x\n", [ebp+exFAT.General_Sec_Flags]
; DEBUGF 1, "K : exFAT.valid_data_length 2 %x\n", [ebp+exFAT.valid_data_length]
cmp [ebp+exFAT.valid_data_length], 0
jbe .error
; DEBUGF 1, "K : exFAT_find_lfn call dword[eax-8] ; exFAT_notroot_next: \n"
call dword[eax-8] ; exFAT_notroot_next
jnc .l1
@@:
; DEBUGF 1, "K : exFAT_find_lfn.@@: \n"
add esp, 262*2
.reterr:
; DEBUGF 1, "K : exFAT_find_lfn.reterr \n"
stc
ret
.error:
movi eax, ERROR_FILE_NOT_FOUND
jmp @b
;------------------------------------------------------------------------------
exFAT_ReadFile:
; DEBUGF 1, "K : exFAT_ReadFile \n"
; DEBUGF 1, "K : exFAT F70 +00: %x\n", [ebx]
; DEBUGF 1, "K : exFAT F70 +04: %x\n", [ebx+4]
; DEBUGF 1, "K : exFAT F70 +08: %x\n", [ebx+8]
; DEBUGF 1, "K : exFAT F70 +12: %x\n", [ebx+12]
; DEBUGF 1, "K : exFAT F70 +16: %x\n", [ebx+16]
; DEBUGF 1, "K : exFAT F70 +20: %x\n", [ebx+20]
; DEBUGF 1, "K : exFAT Path: %s\n", esi
; push eax
; pushfd
; pop eax
; DEBUGF 1, "K : eFlags:%x\n",eax
; pop eax
; DEBUGF 1, "K : EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
; DEBUGF 1, "K : EBP:%x ESI:%x EDI:%x\n", ebp, esi, edi
; in:
; ebx -> parameter structure of sysfunc 70
; ebp -> exFAT structure
; esi -> path string in UTF-8
; out:
; eax, ebx = return values for sysfunc 70
call exFAT_lock
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
call exFAT_hd_find_lfn
jc .notFound
; test byte [edi+11], 0x10 ; do not allow read directories
; jnz .noaccess
lea eax, [ebp+exFAT.file_dir_entry]
test byte [eax+4], 10000b ; do not allow read directories
jnz .noaccess
; Rewrite code to work with more than 4 GB files !!!
; cmp dword [ebx+8], 0
; jnz .endOfFile
mov edx, [ebx+8] ; file offset high
; DEBUGF 1, "K : exFAT_ReadFile Hdword file offset EDX:%x\n", edx
mov [ebp+exFAT.RDX_high], edx
mov edx, [ebx+4] ; file offset low
; DEBUGF 1, "K : exFAT_ReadFile Ldword file offset EAX:%x\n", edx
mov ecx, [ebx+12] ; size
mov ebx, [ebx+16] ; buffer
push ebx
push 0
test ecx, ecx ; read size 0?
jz .done
; mov eax, [edi+28] ; real file size
lea eax, [ebp+exFAT.str_ext_dir_entry]
; DEBUGF 1, "K : exFAT 0xC0 +00: %x\n", [eax]
; DEBUGF 1, "K : exFAT 0xC0 +04: %x\n", [eax+4]
; DEBUGF 1, "K : exFAT 0xC0 +08: %x\n", [eax+8]
; DEBUGF 1, "K : exFAT 0xC0 +12: %x\n", [eax+12]
; DEBUGF 1, "K : exFAT 0xC0 +16: %x\n", [eax+16]
; DEBUGF 1, "K : exFAT 0xC0 +20: %x\n", [eax+20]
; DEBUGF 1, "K : exFAT 0xC0 +24: %x\n", [eax+24]
; DEBUGF 1, "K : exFAT 0xC0 +28: %x\n", [eax+28]
push eax
movzx eax, byte [eax+1]
mov [ebp+exFAT.General_Sec_Flags], eax
pop eax
push eax
mov eax, [eax+12] ; high dword of real file size
mov [ebp+exFAT.RAX_high], eax
; DEBUGF 1, "K : exFAT_ReadFile Hdword file size EAX:%x\n", eax
pop eax
mov eax, [eax+8] ; low dword of real file size
; DEBUGF 1, "K : exFAT_ReadFile Ldword file size EAX:%x\n", eax
; sub eax, edx ; low dword file size - file offset low = rest of file
; jb .fileEnd
sub eax, edx ; low dword file size - file offset low = rest of file
push eax
mov eax, [ebp+exFAT.RDX_high]
sbb [ebp+exFAT.RAX_high], eax
pop eax
jb .fileEnd
; DEBUGF 1, "K : exFAT_ReadFile Hdword rest of file RAX:%x\n", [ebp+exFAT.RAX_high]
; DEBUGF 1, "K : exFAT_ReadFile Ldword rest of file EAX:%x\n", eax
push eax
mov eax, [ebp+exFAT.RAX_high]
test eax, eax
pop eax
jnz @f
cmp eax, ecx ; rest of file - requested size
jae @f
; DEBUGF 1, "K : exFAT_ReadFile 6=EOF EAX:%x ECX:%x EDX:%x\n", eax, ecx, edx
mov ecx, eax
mov byte [esp], 6 ; 6 = end of file, EOF
@@:
lea eax, [ebp+exFAT.str_ext_dir_entry]
mov eax, [eax+20] ; cluster
; DEBUGF 1, "K : exFAT EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
; now eax=cluster, ebx=buffer for data, ecx=count, edx=position
mov edi, [ebp+exFAT.SECTORS_PER_CLUSTER]
shl edi, 9 ; bytes per cluster
@@:
cmp eax, 2
jb .fileEnd
.continue_1:
cmp eax, [ebp+exFAT.fatRESERVED]
jae .fileEnd
push eax
xor eax, eax
sub edx, edi ; file_offset_low - bytes per cluster
sbb [ebp+exFAT.RDX_high], eax
pop eax
jc @f
; push edi
; lea edi, [ebp+exFAT.file_dir_entry]
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
; test byte [edi+1], 11b
; pop edi
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT_1
inc eax
jmp .continue_1
.get_FAT_1:
call exFAT_get_FAT
jc .noaccess2
jmp @b
.notFound:
; DEBUGF 1, "K : exFAT_ReadFile.notFound: \n"
push eax
jmp .ret
.noaccess:
; DEBUGF 1, "K : exFAT_ReadFile.noaccess \n"
push ERROR_ACCESS_DENIED
jmp .ret
.endOfFile:
; DEBUGF 1, "K : exFAT_ReadFile.endOfFile \n"
push ERROR_END_OF_FILE
.ret:
call exFAT_unlock
pop eax
xor ebx, ebx
; DEBUGF 1, "K : exFAT_ReadFile Return EBX:%x\n", ebx
ret
@@:
; DEBUGF 1, "K : exFAT_ReadFile CONTINUE cluster EAX:%x\n", eax
mov esi, eax
dec eax
dec eax
push ebx edx
xor edx, edx
; DEBUGF 1, "K : exFAT_ReadFile IMUL in EDX:%x EAX:%x\n", EDX, eax
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER] ; Sector edx:eax
; DEBUGF 1, "K : exFAT_ReadFile IMUL out EDX:%x EAX:%x\n", EDX, eax
xor ebx, ebx
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
adc edx, ebx
mov [ebp+exFAT.RAX_high], edx
pop edx ebx
; DEBUGF 1, "K : exFAT_ReadFile start sector RAX_H:%x EAX:%x RDX_H:%x EDX:%x EDI:%x\n", [ebp+exFAT.RAX_high], eax, [ebp+exFAT.RDX_high], edx, edi
push eax
xor eax, eax
add edx, edi ; file offset low + bytes per cluster
adc [ebp+exFAT.RDX_high], eax
pop eax
test edx, edx
jz .alignedCluster
mov edi, edx ; file offset low
push eax
mov eax, [ebp+exFAT.RDX_high]
mov [ebp+exFAT.RDI_high], eax
pop eax
; shr edi, 9
push ebx
mov ebx, [ebp+exFAT.RDI_high]
shrd edi, ebx, 5 ; /32
shr ebx, 5 ; /32
shrd edi, ebx, 4 ; /16
shr ebx, 4 ; /16
mov [ebp+exFAT.RDI_high], ebx
pop ebx
add eax, edi ; RFile_start_sector_low - file_sector_offset_low
push ebx
mov ebx, [ebp+exFAT.RDI_high]
adc [ebp+exFAT.RAX_high], ebx
pop ebx
and edx, 511
and dword [ebp+exFAT.RDX_high], 0
cmp ecx, 512
jc .sectorPiece
test edx, edx
jz .alignedSector
.sectorPiece:
; DEBUGF 1, "K : exFAT_ReadFile.sectorPiece \n"
push eax ebx ecx edx
lea ebx, [ebp+exFAT.buffer]
mov edx, [ebp+exFAT.RAX_high]
xor ecx, ecx
inc ecx
; DEBUGF 1, "K : exFAT fs_read64_app EDX:%x EAX:%x ECX:%x EBX:%x EBP:%x\n", edx, eax, ecx, ebx, ebp
; call fs_read32_app
call fs_read64_app
; DEBUGF 1, "K : exFAT fs_read64_app Output EAX:%x ECX:%x EBX:%x\n", eax, ecx, ebx
test eax, eax
; lea eax, [ebp+exFAT.buffer]
mov eax, ebx ; exFAT.buffer
pop edx ecx ebx
jne .noaccess3
; DEBUGF 1, "K : exFAT_ReadFile memmove(-1) EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
add eax, edx ; exFAT.buffer + offset within a sector
push ecx
add ecx, edx ; requested size + offset within a sector
cmp ecx, 512
jbe @f
mov ecx, 512
@@:
sub ecx, edx ; requested size - offset within a sector
; DEBUGF 1, "K : exFAT_ReadFile memmove EAX:%x EBX:%x ECX:%x\n", eax, ebx, ecx
; eax = from
; ebx = to
; ecx = no of bytes
call memmove
; DEBUGF 1, "K : exFAT_ReadFile memmove(1) EAX:%x EBX:%x ECX:%x\n", eax, ebx, ecx
sub [esp], ecx
add ebx, ecx
; DEBUGF 1, "K : exFAT_ReadFile memmove(2) EAX:%x EBX:%x ECX:%x\n", eax, ebx, ecx
pop ecx eax
xor edx, edx
; inc edi ; file_sector_offset_low
push eax
xor eax, eax
add edi, 1 ; you cannot use INC EDI for qword!!!
adc [ebp+exFAT.RDI_high], eax
pop eax
; inc eax ; RFile_start_sector_low
push ebx
xor ebx, ebx
add eax, 1 ; you cannot use INC EAX for qword!!!
adc [ebp+exFAT.RAX_high], ebx
pop ebx
test ecx, ecx
jz .done
.alignedSector:
; DEBUGF 1, "K : exFAT_ReadFile.alignedSector \n"
; shl edi, 9 ; RFile_start_sector_low * 512
push ebx
mov ebx, [ebp+exFAT.RDI_high]
shld ebx, edi, 5 ; *32
shl edi, 5 ; *32
shld ebx, edi, 4 ; *16
shl edi, 4 ; *16
mov [ebp+exFAT.RDI_high], ebx
pop ebx
push ebx
xor ebx, ebx
mov [ebp+exFAT.RCX_high], ebx
add ecx, edi ; requested size + file_offset_low
mov ebx, [ebp+exFAT.RDI_high]
adc [ebp+exFAT.RCX_high], ebx
pop ebx
xor edi, edi
mov [ebp+exFAT.RDI_high], edi
mov edi, [ebp+exFAT.SECTORS_PER_CLUSTER]
shl edi, 9 ; bytes per cluster
.alignedCluster:
; DEBUGF 1, "K : exFAT_ReadFile.alignedCluster RAX_H:%x EAX:%x RDX_H:%x EDX:%x EDI:%x\n", [ebp+exFAT.RAX_high], eax, [ebp+exFAT.RDX_high], edx, edi
cmp ecx, 512
jc .sectorPiece
mov edx, [ebp+exFAT.RAX_high]
mov [ebp+exFAT.RDX_high], edx
mov edx, eax ; edx << RFile_start_sector_low
xor eax, eax
mov [ebp+exFAT.RAX_high], eax
mov eax, esi ; eax << cluster
@@:
push eax
xor eax, eax
sub ecx, edi ; requested size low - bytes per cluster
sbb [ebp+exFAT.RCX_high], eax
pop eax
jbe .readEnd
; push edi
; lea edi, [ebp+exFAT.file_dir_entry]
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
; test byte [edi+1], 11b
; pop edi
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT
inc eax ; inc cluster
jmp .continue
.get_FAT:
; DEBUGF 1, "K : exFAT_ReadFile.get_FAT \n"
call exFAT_get_FAT
jc .noaccess4
cmp eax, 2
jb .fileEnd2
.continue:
; DEBUGF 1, "K : exFAT_ReadFile.continue \n"
cmp eax, [ebp+exFAT.fatRESERVED]
jae .fileEnd2
inc esi ; inc cluster
cmp eax, esi
jz @b
.fragmentEnd:
; DEBUGF 1, "K : exFAT_ReadFile.fragmentEnd \n"
xchg eax, esi
dec eax
dec eax
push ebx edx
xor edx, edx
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER] ; Sector edx:eax
xor ebx, ebx
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
adc edx, ebx
mov [ebp+exFAT.RAX_high], edx
pop edx ebx
push dword [ebp+exFAT.RCX_high]
push ecx ; requested size low
mov ecx, [ebp+exFAT.RAX_high]
mov [ebp+exFAT.RCX_high], ecx
mov ecx, eax ; ecx << RFile_start_sector_low
xor eax, eax
mov [ebp+exFAT.RAX_high], eax
mov eax, esi ; eax << custer
dec eax
dec eax
push ebx edx
xor edx, edx
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER] ; Sector edx:eax
xor ebx, ebx
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
adc edx, ebx
mov [ebp+exFAT.RAX_high], edx
pop edx ebx
push dword [ebp+exFAT.RAX_high]
push eax
.readFragment:
; DEBUGF 1, "K : exFAT_ReadFile.readFragment \n"
push eax
mov eax, [ebp+exFAT.RDX_high]
sub ecx, edx ; RFile_start_sector_low - RFile_start_sector_low
sbb [ebp+exFAT.RCX_high], eax
pop eax
mov eax, edx
; xor edx, edx
mov edx, [ebp+exFAT.RDX_high]
; DEBUGF 1, "K : exFAT fs_read64_app EDX:%x EAX:%x ECX:%x EBX:%x EBP:%x\n", edx, eax, ecx, ebx, ebp
call fs_read64_app
; DEBUGF 1, "K : exFAT fs_read64_app Output EAX:%x ECX:%x EBX:%x\n", eax, ecx, ebx
; shl ecx, 9
push ebx
mov ebx, [ebp+exFAT.RCX_high]
shld ebx, ecx, 5 ; *32
shl ecx, 5 ; *32
shld ebx, ecx, 4 ; *16
shl ecx, 4 ; *16
mov [ebp+exFAT.RCX_high], ebx
pop ebx
add ebx, ecx
test eax, eax
pop eax
pop dword [ebp+exFAT.RAX_high]
jnz .noaccess3
pop ecx
pop dword [ebp+exFAT.RCX_high]
xor edx, edx
mov [ebp+exFAT.RDX_high], edx
jecxz .done_1
jmp .alignedCluster
.done_1:
jmp .done
.readEnd:
; DEBUGF 1, "K : exFAT_ReadFile.readEnd \n"
push ebx
add ecx, edi ; requested size + bytes per cluster
mov ebx, [ebp+exFAT.RDI_high]
adc [ebp+exFAT.RCX_high], ebx
pop ebx
mov edi, [ebp+exFAT.RCX_high]
mov [ebp+exFAT.RDI_high], edi
mov edi, ecx
and ecx, 511
and dword [ebp+exFAT.RCX_high], 0
; shr edi, 9
push ebx
mov ebx, [ebp+exFAT.RDI_high]
shrd edi, ebx, 5 ; /32
shr ebx, 5 ; /32
shrd edi, ebx, 4 ; /16
shr ebx, 4 ; /16
mov [ebp+exFAT.RDI_high], ebx
pop ebx
dec eax
dec eax
push ebx edx
xor edx, edx
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER] ; Sector edx:eax
xor ebx, ebx
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
adc edx, ebx
mov [ebp+exFAT.RAX_high], edx
pop edx ebx
add eax, edi ; RFile_start_sector_low - file_sector_offset_low
push ebx
mov ebx, [ebp+exFAT.RDI_high]
adc [ebp+exFAT.RAX_high], ebx
pop ebx
push dword [ebp+exFAT.RCX_high]
push ecx
push dword [ebp+exFAT.RAX_high]
push eax
mov ecx, [ebp+exFAT.RAX_high]
mov [ebp+exFAT.RCX_high], ecx
mov ecx, eax
jmp .readFragment
.noaccess3:
; DEBUGF 1, "K : exFAT_ReadFile.noaccess3 \n"
pop eax
pop dword [ebp+exFAT.RAX_high]
.noaccess2:
; DEBUGF 1, "K : exFAT_ReadFile.noaccess2 \n"
mov byte [esp], ERROR_DEVICE
.done:
; DEBUGF 1, "K : exFAT_ReadFile.done \n"
call exFAT_unlock
pop eax edx
sub ebx, edx
; DEBUGF 1, "K : exFAT_ReadFile Return EBX:%x\n", ebx
; push eax
; pushfd
; pop eax
; DEBUGF 1, "K : eFlags:%x\n",eax
; pop eax
; DEBUGF 1, "K : EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
; DEBUGF 1, "K : EBP:%x ESI:%x EDI:%x\n", ebp, esi, edi
ret
.fileEnd:
; DEBUGF 1, "K : exFAT_ReadFile.fileEnd \n"
mov byte [esp], ERROR_END_OF_FILE
jmp .done
.noaccess4:
; DEBUGF 1, "K : exFAT_ReadFile.noaccess4 \n"
mov byte [esp], ERROR_DEVICE
jmp @f
.fileEnd2:
; DEBUGF 1, "K : exFAT_ReadFile.fileEnd2 \n"
mov byte [esp], ERROR_END_OF_FILE
@@:
inc esi
xor ecx, ecx
mov [ebp+exFAT.RCX_high], ecx
jmp .fragmentEnd
;------------------------------------------------------------------------------
exFAT_ReadFolder:
; DEBUGF 1, "K : exFAT_ReadFolder \n"
; DEBUGF 1, "K : exFAT F70 +00: %x\n", [ebx]
; DEBUGF 1, "K : exFAT F70 +04: %x\n", [ebx+4]
; DEBUGF 1, "K : exFAT F70 +08: %x\n", [ebx+8]
; DEBUGF 1, "K : exFAT F70 +12: %x\n", [ebx+12]
; DEBUGF 1, "K : exFAT F70 +16: %x\n", [ebx+16]
; DEBUGF 1, "K : exFAT F70 +20: %x\n", [ebx+20]
; DEBUGF 1, "K : exFAT Path: %s\n", esi
; push eax
; pushfd
; pop eax
; DEBUGF 1, "K : eFlags:%x\n",eax
; pop eax
; DEBUGF 1, "K : EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
; DEBUGF 1, "K : EBP:%x ESI:%x EDI:%x\n", ebp, esi, edi
; in:
; ebx -> parameter structure of sysfunc 70
; ebp -> exFAT structure
; esi -> path string in UTF-8
; out:
; eax, ebx = return values for sysfunc 70
call exFAT_lock
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
mov [ebp+exFAT.General_Sec_Flags], eax
; DEBUGF 1, "K : exFAT_ReadFolder General_Sec_Flags 1 %x\n", eax
mov eax, [ebp+exFAT.ROOT_CLUSTER]
; DEBUGF 1, "K : exFAT.ROOT_CLUSTER: %x\n", eax
cmp byte [esi], 0
jz .doit
; push ebp
; mov ebp,[esp+12+8+4+4]
; DEBUGF 1, "K : exFAT Input FS EBP:%x\n", ebp
; pop ebp
call exFAT_hd_find_lfn
; push ebp
; mov ebp,[esp+12+8+4+4]
; DEBUGF 1, "K : exFAT Output FS EBP:%x\n", ebp
; pop ebp
jc .error
; jmp .error
; test byte [edi+11], 0x10 ; do not allow read files
; jz .accessDenied
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
lea eax, [ebp+exFAT.file_dir_entry]
test byte [eax+4], 10000b ; do not allow read files
jz .accessDenied
; mov eax, [edi+20-2]
; mov ax, [edi+26] ; eax=cluster
lea eax, [ebp+exFAT.str_ext_dir_entry]
push eax
movzx eax, byte [eax+1]
mov [ebp+exFAT.General_Sec_Flags], eax
; DEBUGF 1, "K : exFAT_ReadFolder General_Sec_Flags 2 %x\n", eax
mov eax, [esp]
mov eax, [eax+8] ; LOW dword of Valid data length - WARNING!!! late rewrite
mov [ebp+exFAT.valid_data_length], eax
pop eax
mov eax, [eax+20] ; cluster
jmp .doit_1
.doit:
mov dword [ebp+exFAT.valid_data_length], 0xffffffff ; for ROOT
.doit_1:
; DEBUGF 1, "K : exFAT.valid_data_length %x\n", [ebp+exFAT.valid_data_length]
; DEBUGF 1, "K : exFAT_ReadFolder.doit \n"
sub esp, 262*2 ; reserve space for LFN
push dword [ebx+8] ; cp866/UNICODE name
mov edx, [ebx+16] ; pointer to buffer
; init header
push eax
mov edi, edx
mov ecx, 32/4
xor eax, eax
rep stosd
pop eax
mov byte [edx], 1 ; version
; mov esi, edi ; esi points to BDFE
mov [ebp+exFAT.points_to_BDFE], edi
; DEBUGF 1, "K : exFAT.points_to_BDFE start EDI: %x\n", edi
mov ecx, [ebx+12] ; number of blocks to read
mov ebx, [ebx+4] ; index of the first block
;------------------------------------------------------------------------------
; DEBUGF 1, "K : exFAT_ReadFolder 1 ECX: %x\n", ecx
cmp [ebp+exFAT.valid_data_length], 0xffffffff
je .num_read_blocks
inc dword [edx+8] ; new file found
test ecx, ecx
jz .num_read_blocks
test ebx, ebx
jnz .dec_offset
; DEBUGF 1, "K : exFAT_ReadFolder create .. dir \n"
inc dword [edx+4] ; new file block copied
push eax esi
mov esi, edi ; [ebp+exFAT.points_to_BDFE]
mov [esi], dword 0x10 ; attributes
xor eax, eax
mov [esi+8], eax ; creation time
mov [esi+12], dword 0x010101 ; eax ; creation date
mov [esi+16], eax ; last access time
mov [esi+20], dword 0x020202 ;eax ; last access date
mov [esi+24], eax ; last write time
mov [esi+28], dword 0x010303 ; eax ; last write date
mov [esi+32], eax ; file size (low dword)
mov [esi+36], eax ; file size (high dword)
push ebp
lea ebp, [esp+4+12]
; DEBUGF 1, "K : exFAT_ReadFolder 1 ESI: %x EBP: %x\n", esi, ebp
; DEBUGF 1, "K : exFAT_ReadFolder old file [EBP-4]: %x [EBP]: %x [EBP+4]: %x [EBP+8]: %x\n", [ebp-4], [ebp], [ebp+4], [ebp+8]
mov eax, [ebp-4]
mov [esi+4], eax ; cp866/UNICODE name
mov [ebp], dword 0x002e002e ; imitate dir '..'
xor eax, eax
mov [ebp+4], eax
call exFAT_entry_to_bdfe2.copy_path
pop ebp
mov [ebp+exFAT.points_to_BDFE], esi
; DEBUGF 1, "K : exFAT_ReadFolder 2 ESI: %x EBP: %x\n", esi, ebp
pop esi eax
dec ecx
jmp .num_read_blocks
.dec_offset:
dec ebx
.num_read_blocks:
; DEBUGF 1, "K : exFAT_ReadFolder 2 ECX: %x\n", ecx
;------------------------------------------------------------------------------
lea esi, [esp+4] ; buffer for UTF-16 name (space for LFN)
mov [ebp+exFAT.LFN_reserve_place], esi
; push eax
; dec eax
; dec eax
; imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
; add eax, [ebp+exFAT.CLUSTER_HEAP_START]
; DEBUGF 1, "K : exFAT ROOT SECTOR: %x\n", eax
; pop eax
mov [ebp+exFAT.secondary_dir_entry], dword 1
.new_cluster:
; DEBUGF 1, "K : exFAT_ReadFolder.new_cluster \n"
mov [ebp+exFAT.cluster_tmp], eax
test eax, eax
; jz .notfound
jnz @f
jmp .notfound
@@:
dec eax
dec eax
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
push [ebp+exFAT.SECTORS_PER_CLUSTER]
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
push ebx
.new_sector:
; DEBUGF 1, "K : exFAT_ReadFolder.new_sector \n"
lea ebx, [ebp+exFAT.buffer]
mov edi, ebx
push eax
; DEBUGF 1, "K : exFAT fs_read32_sys N1 EAX: %x\n", eax
call fs_read32_sys
test eax, eax
pop eax
jnz .notfound2
add ebx, 512
push eax
.l1:
; cmp [edi], dword 0
; je .l1_1
; DEBUGF 1, "K : exFAT_ReadFolder.l1 [EDI]:%x\n", [edi]
;.l1_1:
; push esi
; lea esi, [esp+20]
; DEBUGF 1, "K : exFAT RD need_hash :%x\n", [ebp+exFAT.need_hash]
call exFAT_get_name
; pop esi
jc .l2
; cmp byte [edi], 0xC1 ; File Name Extension Directory Entry of ExFAT
; jnz .do_bdfe
; DEBUGF 1, "K : exFAT_ReadFolder CMP SDE\n"
xor eax, eax
cmp [ebp+exFAT.secondary_dir_entry], eax
jz .do_bdfe
; add edi, 0x20
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe EDI: %x EBX: %x\n", edi, ebx
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe EDI:%x [EDI]:%x NAME:%s\n", edi, [edi], edi
cmp edi, ebx
jb .do_bdfe
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe EDI after\n", edi, ebx
pop eax
inc eax
dec dword [esp+4]
jnz @f
mov eax, [ebp+exFAT.cluster_tmp]
test eax, eax
jz .done
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT_1
inc eax
jmp .continue_1
.get_FAT_1:
; DEBUGF 1, "K : exFAT_ReadFolder N1 exFAT_get_FAT Input EAX: %x\n", eax
call exFAT_get_FAT
; DEBUGF 1, "K : exFAT_ReadFolder N1 exFAT_get_FAT Output EAX: %x\n", eax
jc .notfound2
cmp eax, 2
jb .done
.continue_1:
; DEBUGF 1, "K : exFAT_ReadFolder.continue_1\n"
cmp eax, [ebp+exFAT.fatRESERVED]
jae .done
push eax
mov eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
mov [esp+8], eax
pop eax
mov [ebp+exFAT.cluster_tmp], eax
dec eax
dec eax
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
add eax, [ebp+exFAT.DATA_START]
@@:
; DEBUGF 1, "K : exFAT_ReadFolder.@@ \n"
lea ebx, [ebp+exFAT.buffer]
mov edi, ebx
push eax
; DEBUGF 1, "K : exFAT fs_read32_sys N2 EAX: %x\n", eax
call fs_read32_sys
test eax, eax
pop eax
jnz .notfound2
add ebx, 512
push eax
.do_bdfe:
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe \n"
inc dword [edx+8] ; new file found
dec dword [esp+4]
jns .l2
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe ECX: %x\n", ecx
dec ecx
js .l2
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe 2 \n"
inc dword [edx+4] ; new file block copied
push esi edi
mov esi, [ebp+exFAT.points_to_BDFE]
lea edi, [ebp+exFAT.file_dir_entry]
push ebp
lea ebp, [esp+20+4+4]
; DEBUGF 1, "K : exFAT_ReadFolder ESI: %x EBP: %x\n", esi, ebp
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe EDI:%x [EDI]:%x ESI:%x [ESI]:%x EBP:%x NAME:%s\n", edi, [edi], esi, [esi], ebp, ebp
call exFAT_entry_to_bdfe
pop ebp
mov [ebp+exFAT.points_to_BDFE], esi
pop edi esi
.l2:
; DEBUGF 1, "K : exFAT_ReadFolder.l2 \n"
add edi, 0x20
; DEBUGF 1, "K : exFAT_ReadFolder.do_bdfe EDI: %x EBX: %x\n", edi, ebx
cmp edi, ebx
jb .l1
pop eax
inc eax
dec dword [esp+4]
jnz .new_sector
mov eax, [ebp+exFAT.cluster_tmp]
test eax, eax
jz .done
push eax
mov eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
shl eax, 9
sub [ebp+exFAT.valid_data_length], eax
pop eax
jbe .done
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT
inc eax
jmp .continue
.get_FAT:
; DEBUGF 1, "K : exFAT_ReadFolder N2 exFAT_get_FAT Input EAX: %x\n", eax
call exFAT_get_FAT
; DEBUGF 1, "K : exFAT_ReadFolder N2 exFAT_get_FAT Output EAX: %x\n", eax
jc .notfound2
cmp eax, 2
jb .done
.continue:
; DEBUGF 1, "K : exFAT_ReadFolder.continue \n"
cmp eax, [ebp+exFAT.fatRESERVED]
jae .done
; DEBUGF 1, "K : exFAT_ReadFolder.continue after\n"
push eax
mov eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
mov [esp+8], eax
pop eax
pop ebx
add esp, 4
jmp .new_cluster
;------------------------------------------------------------------------------
.notfound2:
; DEBUGF 1, "K : exFAT_ReadFolder.notfound2 \n"
add esp, 8
.notfound:
; DEBUGF 1, "K : exFAT_ReadFolder.notfound \n"
add esp, 262*2+4
; DEBUGF 1, "K : exFAT_ReadFolder.ERROR_DEVICE \n"
push ERROR_DEVICE
jmp @f
;------------------------------------------------------------------------------
.done:
; DEBUGF 1, "K : exFAT_ReadFolder.done \n"
; DEBUGF 1, "K : exFAT_ReadFolder TotalBloks: %x\n", [edx+8]
; DEBUGF 1, "K : exFAT_ReadFolder Read Bloks: %x\n", [edx+4]
add esp, 262*2+12
pushd 0
; DEBUGF 1, "K : exFAT_ReadFolder.done ECX: %x\n", ecx
dec ecx
js @f
; DEBUGF 1, "K : exFAT_ReadFolder.ERROR_END_OF_FILE \n"
mov byte [esp], ERROR_END_OF_FILE
@@:
mov ebx, [edx+4]
;------------------------------------------------------------------------------
.ret:
; DEBUGF 1, "K : exFAT_ReadFolder.ret \n"
; DEBUGF 1, "K : exFAT_ReadFile Return ESI:%x\n", esi
call exFAT_unlock
pop eax
; DEBUGF 1, "K : exFAT_ReadFile Return EBX:%x\n", ebx
; mov esi, [ebp+exFAT.LFN_reserve_place]
; push eax
; pushfd
; pop eax
; DEBUGF 1, "K : eFlags:%x\n",eax
; pop eax
; DEBUGF 1, "K : EAX:%x EBX:%x ECX:%x EDX:%x\n", eax, ebx, ecx, edx
; DEBUGF 1, "K : EBP:%x ESI:%x EDI:%x\n", ebp, esi, edi
ret
;------------------------------------------------------------------------------
.error:
; DEBUGF 1, "K : exFAT_ReadFolder.error \n"
push eax
xor ebx, ebx
jmp .ret
;------------------------------------------------------------------------------
.accessDenied:
; DEBUGF 1, "K : exFAT_ReadFolder.ERROR_ACCESS_DENIED \n"
push ERROR_ACCESS_DENIED
xor ebx, ebx
jmp .ret
;------------------------------------------------------------------------------
exFAT_GetFileInfo:
; DEBUGF 1, "K : exFAT_GetFileInfo \n"
; DEBUGF 1, "K : exFAT F70 +00: %x\n", [ebx]
; DEBUGF 1, "K : exFAT F70 +04: %x\n", [ebx+4]
; DEBUGF 1, "K : exFAT F70 +08: %x\n", [ebx+8]
; DEBUGF 1, "K : exFAT F70 +12: %x\n", [ebx+12]
; DEBUGF 1, "K : exFAT F70 +16: %x\n", [ebx+16]
; DEBUGF 1, "K : exFAT F70 +20: %x\n", [ebx+20]
; DEBUGF 1, "K : exFAT Path: %s\n", esi
cmp byte [esi], 0
jz .volume
call exFAT_lock
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
call exFAT_hd_find_lfn
jc @f
lea edi, [ebp+exFAT.file_dir_entry]
push ebp
xor ebp, ebp
mov esi, [ebx+16]
mov dword [esi+4], ebp
call exFAT_entry_to_bdfe2
pop ebp
xor eax, eax
@@:
push eax
call exFAT_unlock
pop eax
@@:
ret
.volume:
; DEBUGF 1, "K : exFAT_GetFileInfo.volume \n"
mov eax, dword[ebp+exFAT.Length]
mov edx, dword[ebp+exFAT.Length+4]
mov edi, [ebx+16]
shld edx, eax, 9
shl eax, 9
mov [edi+36], edx
mov [edi+32], eax
mov eax, [ebx+8]
mov byte [edi], 8
mov [edi+4], eax
test eax, eax
jz @b
lea esi, [ebp+exFAT.volumeLabel]
mov ecx, 11
@@:
mov byte [esi+ecx], 0
dec ecx
jz @f
cmp byte [esi+ecx], ' '
jz @b
@@:
mov cl, 12
add edi, 40
cmp eax, 2
jz @f
rep movsb
xor eax, eax
ret
@@:
lodsb
stosw
loop @b
ret
;------------------------------------------------------------------------------
exFAT_SetFileInfo:
; DEBUGF 1, "K : exFAT_SetFileInfo \n"
; DEBUGF 1, "K : exFAT F70 +00: %x\n", [ebx]
; DEBUGF 1, "K : exFAT F70 +04: %x\n", [ebx+4]
; DEBUGF 1, "K : exFAT F70 +08: %x\n", [ebx+8]
; DEBUGF 1, "K : exFAT F70 +12: %x\n", [ebx+12]
; DEBUGF 1, "K : exFAT F70 +16: %x\n", [ebx+16]
; DEBUGF 1, "K : exFAT F70 +20: %x\n", [ebx+20]
; DEBUGF 1, "K : exFAT Path: %s\n", esi
call exFAT_lock
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
call exFAT_hd_find_lfn
jc @f
mov edi, [ebp+exFAT.buff_file_dir_pos]
cmp eax, [ebp+exFAT.buff_file_dirsect]
je .continue
mov eax, [ebp+exFAT.buff_file_dirsect]
mov [ebp+exFAT.buffer_curr_sector], eax
push eax ebx
lea ebx, [ebp+exFAT.buffer]
call fs_read32_sys
test eax, eax
jz .continue_1 ; CF=0
pop ebx
add esp, 4
jmp @f
.continue_1:
pop ebx eax
.continue:
push eax
mov edx, [ebx+16] ; pointer to buffer with attributes (32 bytes)
call exFAT_bdfe_to_fat_entry
pop eax
; copy new File/Folder Directory Entry [0x85] for calculate SetChecksum field
push esi edi
xchg esi, edi
lea edi, [ebp+exFAT.file_dir_entry]
movsd
movsd
movsd
movsd
movsd
movsd
movsd
movsd
pop edi esi
push eax
call calculate_SetChecksum_field
mov [edi+2], ax
pop eax
lea ebx, [ebp+exFAT.buffer]
call fs_write32_sys
call exFAT_update_disk
xor eax, eax
@@:
push eax
call exFAT_unlock
pop eax
ret
;------------------------------------------------------------------------------
exFAT_Delete:
; DEBUGF 1, "K : exFAT_Delete\n"
; DEBUGF 1, "K : exFAT F70 +00: %x\n", [ebx]
; DEBUGF 1, "K : exFAT F70 +04: %x\n", [ebx+4]
; DEBUGF 1, "K : exFAT F70 +08: %x\n", [ebx+8]
; DEBUGF 1, "K : exFAT F70 +12: %x\n", [ebx+12]
; DEBUGF 1, "K : exFAT F70 +16: %x\n", [ebx+16]
; DEBUGF 1, "K : exFAT F70 +20: %x\n", [ebx+20]
; DEBUGF 1, "K : exFAT Path: %s\n", esi
call exFAT_lock
xor eax, eax
mov [ebp+exFAT.need_hash], eax ; dword 0
mov [ebp+exFAT.hash_flag], eax ; dword 0
; and [ebp+exFAT.longname_sec1], 0
; and [ebp+exFAT.longname_sec2], 0
mov [ebp+exFAT.longname_sec1], eax
mov [ebp+exFAT.longname_sec2], eax
call exFAT_hd_find_lfn
jc .notFound
; cmp dword [edi], '. '
; jz .access_denied2
; cmp dword [edi], '.. '
; jz .access_denied2
; test byte [edi+11], 10h
push eax
lea eax, [ebp+exFAT.file_dir_entry]
; DEBUGF 1, "K : exFAT_Delete: File Attributes:%x\n", [eax+4]
test byte [eax+4], 10000b
pop eax
jz .dodel
; we can delete only empty folders!
pushad
; mov esi, [edi+20-2]
; mov si, [edi+26] ; esi=cluster
lea eax, [ebp+exFAT.str_ext_dir_entry]
mov esi, [eax+20] ; cluster
; DEBUGF 1, "K : exFAT_Delete: Cluster1:%x [EDI+20]:%x\n", esi, [edi+20]
xor ecx, ecx
lea eax, [esi-2]
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
add eax, [ebp+exFAT.DATA_START]
; add eax, [ebp+exFAT.CLUSTER_HEAP_START]
lea ebx, [ebp+exFAT.buffer]
call fs_read32_sys
test eax, eax
jnz .err1
lea eax, [ebx+0x200]
; add ebx, 2*0x20
.checkempty:
; DEBUGF 1, "K : exFAT_Delete.checkempty: [EBX]:%x\n", [ebx]
cmp byte [ebx], 0 ; DIR_Name[0] == 0x00, then the directory entry is free
jz .empty
; cmp byte [ebx], 0xE5 ; DIR_Name[0] == 0xE5, then the directory entry is free
; jnz .notempty
cmp byte [ebx], 0x85 ; File/Folder Directory Entry of ExFAT
jz .notempty
cmp byte [ebx], 0xC0 ; Stream Extension Directory Entry of ExFAT
jz .notempty
cmp byte [ebx], 0xC1 ; File Name Extension Directory Entry of ExFAT
jz .notempty
add ebx, 0x20
cmp ebx, eax
jb .checkempty
inc ecx
cmp ecx, [ebp+exFAT.SECTORS_PER_CLUSTER]
jb @f
mov eax, esi
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT
inc eax ; inc cluster
jmp .continue
.get_FAT:
; DEBUGF 1, "K : exFAT_Delete.get_FAT:\n"
call exFAT_get_FAT
jc .err1
cmp eax, 2
jb .error_fat
.continue:
; DEBUGF 1, "K : exFAT_Delete.continue:\n"
cmp eax, [ebp+exFAT.fatRESERVED]
jae .empty
mov esi, eax
xor ecx, ecx
@@:
; DEBUGF 1, "K : exFAT_Delete.@@:\n"
lea eax, [esi-2]
imul eax, [ebp+exFAT.SECTORS_PER_CLUSTER]
add eax, [ebp+exFAT.DATA_START]
; add eax, [ebp+exFAT.CLUSTER_HEAP_START]
add eax, ecx
lea ebx, [ebp+exFAT.buffer]
call fs_read32_sys
test eax, eax
lea eax, [ebx+0x200]
jz .checkempty
.err1:
; DEBUGF 1, "K : exFAT_Delete.err1:\n"
popad
.err2:
; DEBUGF 1, "K : exFAT_Delete.err2:\n"
push ERROR_DEVICE
.ret:
; DEBUGF 1, "K : exFAT_Delete.ret:\n"
call exFAT_unlock
pop eax
ret
.notFound:
; DEBUGF 1, "K : exFAT_Delete.notFound:\n"
push ERROR_FILE_NOT_FOUND
jmp .ret
.error_fat:
; DEBUGF 1, "K : exFAT_Delete.error_fat:\n"
popad
push ERROR_FS_FAIL
jmp .ret
.notempty:
; DEBUGF 1, "K : exFAT_Delete.notempty:\n"
popad
.access_denied2:
; DEBUGF 1, "K : exFAT_Delete.access_denied2:\n"
push ERROR_ACCESS_DENIED
jmp .ret
.empty:
; DEBUGF 1, "K : exFAT_Delete.empty:\n"
popad
push eax ebx
lea ebx, [ebp+exFAT.buffer]
call fs_read32_sys
test eax, eax
pop ebx eax
jnz .err2
.dodel:
; DEBUGF 1, "K : exFAT_Delete.dodel:\n"
push eax
; mov eax, [edi+20-2]
; mov ax, [edi+26] ; eax=cluster
lea eax, [ebp+exFAT.str_ext_dir_entry]
mov eax, [eax+20] ; cluster
; DEBUGF 1, "K : exFAT_Delete: Cluster2:%x [EDI+20]:%x\n", eax, [edi+20]
xchg eax, [esp]
mov edi, [ebp+exFAT.buff_file_dir_pos]
cmp eax, [ebp+exFAT.buff_file_dirsect]
je .continue_2
mov eax, [ebp+exFAT.buff_file_dirsect]
mov [ebp+exFAT.buffer_curr_sector], eax
push eax ebx
lea ebx, [ebp+exFAT.buffer]
call fs_read32_sys
test eax, eax
jz .continue_1 ; CF=0
pop ebx
add esp, 4
jmp .err2
.continue_1:
; DEBUGF 1, "K : exFAT_Delete.continue_1:\n"
pop ebx eax
.continue_2:
; DEBUGF 1, "K : exFAT_Delete.continue_2: EAX:%x\n", eax
push ecx
; delete folder entry
; mov byte [edi], 0xE5 ; for FAT
and byte [edi], 0x7F ; Entry Type is 0x85 is changed to 0x05
movzx ecx, byte [edi+1] ; Number of Secondary directory entries
inc ecx
; delete LFN (if present)
.lfndel:
; DEBUGF 1, "K : exFAT_Delete.lfndel: [EDI]:%x\n", [edi]
add edi, 0x20
; lea edx, [ebp+exFAT.buffer]
lea edx, [ebp+exFAT.buffer+0x200]
; cmp edi, edx
cmp edx, edi
ja @f
; cmp [ebp+exFAT.longname_sec2], 0
; jz .lfndone
; push [ebp+exFAT.longname_sec2]
; push [ebp+exFAT.longname_sec1]
; pop [ebp+exFAT.longname_sec2]
; and [ebp+exFAT.longname_sec1], 0
; DEBUGF 1, "K : exFAT_Delete: lngnm_sec1:%x lngnm_sec2:%x\n", [ebp+exFAT.longname_sector1], [ebp+exFAT.longname_sector2]
cmp [ebp+exFAT.longname_sector1], 0
je .longname_sec2
push eax
mov eax, [ebp+exFAT.buff_file_dirsect]
cmp eax, [ebp+exFAT.longname_sector1]
pop eax
; je .longname_sec2
jne .longname_sec1
and [ebp+exFAT.longname_sector1], 0
jmp .longname_sec2
.longname_sec1:
push [ebp+exFAT.longname_sector1]
and [ebp+exFAT.longname_sector1], 0
jmp .longname_sec3
.longname_sec2:
; DEBUGF 1, "K : exFAT_Delete.longname_sec2:\n"
cmp [ebp+exFAT.longname_sector2], 0
je .lfndone
push eax
mov eax, [ebp+exFAT.buff_file_dirsect]
cmp eax, [ebp+exFAT.longname_sector2]
pop eax
je .lfndone
push [ebp+exFAT.longname_sector2]
and [ebp+exFAT.longname_sector2], 0
.longname_sec3:
; DEBUGF 1, "K : exFAT_Delete.longname_sec3:\n"
push ebx
; mov ebx, edx
lea ebx, [ebp+exFAT.buffer]
call fs_write32_sys
mov eax, [esp+4]
; DEBUGF 1, "K : exFAT_Delete: EAX:%x\n", eax
call fs_read32_sys
pop ebx
pop eax
; lea edi, [ebp+exFAT.buffer+0x200]
lea edi, [ebp+exFAT.buffer]
@@:
; DEBUGF 1, "K : exFAT_Delete.@@: [EDI]:%x\n", [edi]
; sub edi, 0x20
;; add edi, 0x20
; cmp byte [edi], 0xE5
; jz .lfndone
dec ecx
jz .lfndone
cmp byte [edi], 0
jz .lfndone
cmp byte [edi], 0x85
jz .lfndone
; cmp byte [edi+11], 0xF
; jnz .lfndone
; mov byte [edi], 0xE5
and byte [edi], 0x7F ; 0xC0 is changed to 0x40; 0xC1 is changed to 0x41
jmp .lfndel
.lfndone:
; DEBUGF 1, "K : exFAT_Delete.lfndone:\n"
pop ecx
push ebx
lea ebx, [ebp+exFAT.buffer]
call fs_write32_sys
pop ebx
; delete FAT chain
pop eax
call exFAT_clear_Cluster_Heap
call exFAT_clear_cluster_chain
call exFAT_update_disk
call exFAT_unlock
xor eax, eax
ret
;------------------------------------------------------------------------------
calculate_SetChecksum_field:
push ebx ecx edx esi edi
lea esi, [ebp+exFAT.file_dir_entry]
mov ecx, [ebp+exFAT.fname_extdir_offset]
sub ecx, esi
mov edx, esi
mov edi, esi
add edx, 2 ; (Index == 2)
add edi, 3 ; (Index == 3)
; exFAT_calculate_SetChecksum_field
; in:
; esi -> file_dir_entry
; ecx -> NumberOfBytes
; out: ax = Checksum
xor eax, eax
xor ebx, ebx
;--------------------------------------
align 4
.start:
; DEBUGF 1, "Checksum start EAX:%x ECX:%x\n", eax, ecx
cmp esi, edx ; (Index == 2)
je .continue
cmp esi, edi ; (Index == 3)
je .continue
mov bx, ax
; ((Checksum&1) ? 0x8000 : 0)
and ax, 0x1
jz .else
mov ax, 0x8000
jmp @f
;--------------------------------------
.else:
xor ax, ax
;--------------------------------------
@@:
; DEBUGF 1, "(Checksum&1) EAX:%x\n", eax
; (Hash>>1)
shr bx, 1
; DEBUGF 1, "(Checksum>>1) EBX:%x\n", ebx
add ax, bx
; DEBUGF 1, "+ (Checksum>>1) EAX:%x\n", eax
movzx bx, byte [esi]
add ax, bx
; DEBUGF 1, "+ (UInt16)Entries[Index] EAX:%x\n", eax
.continue:
inc esi
dec ecx
jnz .start
;--------------------------------------
lea ebx, [ebp+exFAT.file_dir_entry+2]
mov [ebx], ax
pop edi esi edx ecx ebx
ret
;------------------------------------------------------------------------------
exFAT_clear_Cluster_Heap:
; in: eax = first cluster
;ClstHeap_change db ? ; 1=Cluster Heap has changed
;ClstHeap_in_cache dd ?
;ClstHeap_cache_ptr dd ?
push eax ebx ecx edx esi
mov ebx, [ebp+exFAT.ClstHeap_cache_ptr]
push eax
lea eax, [ebp+exFAT.str_ext_dir_entry]
mov edx, [eax+12] ; high dword of real file size
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap Hdword file size:%x\n", edx
mov eax, [eax+8] ; low dword of real file size
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap Ldword file size:%x\n", eax
mov ecx, [ebp+exFAT.SECTORS_PER_CLUSTER]
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap SECTORS_PER_CLUSTER:%x\n", ecx
shl ecx, 9
div ecx
test edx, edx
jz @f
inc eax
@@:
mov edx, eax
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap number of clusters:%x\n", edx
pop eax
.start:
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap current cluster:%x\n", eax
cmp eax, [ebp+exFAT.LAST_CLUSTER]
ja .exit
cmp eax, 2
jb .exit
cmp eax, [ebp+exFAT.ROOT_CLUSTER]
jz .exit
push eax
dec eax
dec eax
mov ecx, 7
and ecx, eax ; get offset of bits
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap offset of bits:%x\n", ecx
shr eax, 3
mov esi, 511
and esi, eax ; get offset of bytes
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap offset of bytes:%x\n", esi
shr eax, 9 ; get get offset of sectors
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap offset of sectors:%x\n", eax
add eax, [ebp+exFAT.CLUSTER_HEAP_START]
; DEBUGF 1, "K : exFAT_clear_Cluster_Heap general offset:%x\n", eax
cmp eax, [ebp+exFAT.ClstHeap_in_cache]
je .inCache
cmp [ebp+exFAT.ClstHeap_change], 0
je @f
mov [ebp+exFAT.ClstHeap_change], 0
push eax
mov eax, [ebp+exFAT.ClstHeap_in_cache]
call fs_write32_sys
pop eax
@@:
mov [ebp+exFAT.ClstHeap_in_cache], eax
call fs_read32_sys
test eax, eax
jne .error
.inCache:
xor eax, eax
mov al, [ebx+esi] ; get Cluster_Heap old value
; DEBUGF 1, "K : exFAT Cluster_Heap old value:%x\n", eax
ror al, cl
and al, 0xfe ; reset bit
rol al, cl
mov [ebx+esi], al ; save Cluster_Heap new value
; DEBUGF 1, "K : exFAT Cluster_Heap new value:%x\n", eax
mov [ebp+exFAT.ClstHeap_change], 1
pop eax
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
; DEBUGF 1, "K : exFAT General_Sec_Flags %x\n", [ebp+exFAT.General_Sec_Flags]
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT
dec edx ; dec cluster counter
jz .exit
inc eax ; inc cluster
jmp .start
.get_FAT:
call exFAT_get_FAT
jc .ret
jmp .start
.error:
pop eax
stc
jmp .ret
.exit:
clc
.ret:
pop esi edx ecx ebx eax
ret
;------------------------------------------------------------------------------
exFAT_clear_cluster_chain:
; in: eax = first cluster
; DEBUGF 1, "K : exFAT_clear_cluster_chain: GSF:%x\n", [ebp+exFAT.General_Sec_Flags]
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .set_FAT
ret
.set_FAT:
push eax edx
@@:
cmp eax, [ebp+exFAT.LAST_CLUSTER]
ja @f
cmp eax, 2
jb @f
cmp eax, [ebp+exFAT.ROOT_CLUSTER]
jz @f
xor edx, edx
call exFAT_set_FAT
jc .ret
mov eax, edx
jmp @b
@@:
clc
.ret:
pop edx eax
ret
;------------------------------------------------------------------------------
exFAT_update_disk:
cmp [ebp+exFAT.ClstHeap_change], 0
je @f
mov [ebp+exFAT.ClstHeap_change], 0
push eax ebx
mov eax, [ebp+exFAT.ClstHeap_in_cache]
mov ebx, [ebp+exFAT.ClstHeap_cache_ptr]
call fs_write32_sys
pop ebx eax
@@:
cmp [ebp+exFAT.fat_change], 0
jz .noChange
call exFAT_write_fat_sector
.noChange:
mov esi, [ebp+PARTITION.Disk]
call disk_sync
ret
;------------------------------------------------------------------------------
exFAT_write_fat_sector:
push eax ebx ecx
mov [ebp+exFAT.fat_change], 0
mov eax, [ebp+exFAT.fat_in_cache]
cmp eax, -1
jz @f
mov ebx, [ebp+exFAT.fat_cache_ptr]
mov ecx, [ebp+exFAT.NUMBER_OF_FATS]
.write_next_fat:
push eax
call fs_write32_sys
pop eax
add eax, [ebp+exFAT.SECTORS_PER_FAT]
dec ecx
jnz .write_next_fat
@@:
pop ecx ebx eax
ret
;------------------------------------------------------------------------------
exFAT_notroot_next:
; DEBUGF 1, "K : exFAT_notroot_next\n"
push ecx
lea ecx, [ebp+exFAT.buffer+0x200-0x20]
cmp edi, ecx
jae exFAT_notroot_next_sector
add edi, 0x20
@@:
; DEBUGF 1, "K : exFAT_notroot_next.ret\n"
pop ecx
ret
;exFAT_notroot_next_write:
; push ecx
; lea ecx, [ebp+exFAT.buffer+0x200]
; cmp edi, ecx
; jc @b
; push eax
; call exFAT_notroot_end_write
; pop eax
exFAT_notroot_next_sector:
; DEBUGF 1, "K : exFAT_notroot_next_sector\n"
push [ebp+exFAT.longname_sec2]
pop [ebp+exFAT.longname_sec1]
push eax
; DEBUGF 1, "K : exFAT_notroot_next.exFAT_get_sector In EAX:%x\n", eax
call exFAT_get_sector
; DEBUGF 1, "K : exFAT_notroot_next.exFAT_get_sector Out EAX:%x\n", eax
mov [ebp+exFAT.longname_sec2], eax
pop eax
mov ecx, [eax+4]
inc ecx
cmp ecx, [ebp+exFAT.SECTORS_PER_CLUSTER]
jae exFAT_notroot_next_cluster
mov [eax+4], ecx
jmp @f
exFAT_notroot_next_err:
; DEBUGF 1, "K : exFAT_notroot_next_err\n"
; dec ecx
pop ecx
; js .1
movi eax, ERROR_FILE_NOT_FOUND
;.1:
stc
ret
exFAT_notroot_next_cluster:
; DEBUGF 1, "K : exFAT_notroot_next_cluster\n"
push eax
mov eax, [eax]
; push edi
; lea edi, [ebp+exFAT.str_ext_dir_entry]
; Check - General Secondary Flags
; Bit 0 : Allocation possible
; 0 No cluster allocated; 1 cluster allocation is possible
; Bit 1 : No FAT chain
; 0 Yes ; The clusters of this file/directory are NOT contiguous
; 1 No; The Contiguous Cluster are allocated to this file/directory;
; This improves the File read performance
; Bits 2 7 : Reserved
; push eax
; movzx eax, byte [edi+1]
; DEBUGF 1, "K : exFAT_notroot_next_cluster GSF 1:%x\n", eax
; movzx eax, byte [ebp+exFAT.General_Sec_Flags]
; DEBUGF 1, "K : exFAT_notroot_next_cluster GSF 2:%x\n", eax
; pop eax
; test byte [edi+1], 10b ;11b
; pop edi
test byte [ebp+exFAT.General_Sec_Flags], 10b
jz .get_FAT
inc eax
jmp .continue
.get_FAT:
call exFAT_get_FAT
.continue:
mov ecx, eax
pop eax
jc exFAT_notroot_first.deverr
cmp ecx, 2
jb exFAT_notroot_next_err
cmp ecx, [ebp+exFAT.fatRESERVED]
jae exFAT_notroot_next_err
mov [eax], ecx
and dword [eax+4], 0
@@:
pop ecx
exFAT_notroot_first:
; DEBUGF 1, "K : exFAT_notroot_first\n"
; DEBUGF 1, "K : exFAT_notroot_first.exFAT_get_sector In EAX:%x\n", eax
call exFAT_get_sector
; DEBUGF 1, "K : exFAT_notroot_first.exFAT_get_sector Out EAX:%x\n", eax
push ebx
lea edi, [ebp+exFAT.buffer]
mov ebx, edi
sub [ebp+exFAT.valid_data_length], 512
mov [ebp+exFAT.buffer_curr_sector], eax
call fs_read32_sys
pop ebx
test eax, eax
jz .ret ; CF=0
push ecx
.deverr:
; DEBUGF 1, "K : exFAT_notroot_first.deverr\n"
pop ecx
mov eax, ERROR_DEVICE
stc
.ret:
; DEBUGF 1, "K : exFAT_notroot_first.ret\n"
ret
;fat_notroot_begin_write:
; push eax edi
; call fat_notroot_first
; pop edi eax
; ret
;fat_notroot_end_write:
; call fat_get_sector
; push ebx
; lea ebx, [ebp+FAT.buffer]
; call fs_write32_sys
; pop ebx
; ret
;--------------------------------------
exFAT_get_sector:
; DEBUGF 1, "K : exFAT_get_sector\n"
push ecx
mov ecx, [eax]
; DEBUGF 1, "K : exFAT_get_sector In [EAX]:%x [EAX+4]:%x\n", ecx, [eax+4]
dec ecx
dec ecx
imul ecx, [ebp+exFAT.SECTORS_PER_CLUSTER]
; add ecx, [ebp+exFAT.DATA_START]
add ecx, [ebp+exFAT.CLUSTER_HEAP_START]
add ecx, [eax+4]
mov eax, ecx
pop ecx
ret
;------------------------------------------------------------------------------