WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/fs/fat32.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  FAT32.INC                                                      ;;
;;                                                                 ;;
;;  FAT16/32 functions for KolibriOS                               ;;
;;                                                                 ;;
;;  Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it          ;;
;;                                                                 ;;
;;  See file COPYING for details                                   ;;
;;  04.02.2007 LFN create folder - diamond                         ;;
;;  08.10.2006 LFN delete file/folder - diamond                    ;;
;;  20.08.2006 LFN set file size (truncate/extend) - diamond       ;;
;;  17.08.2006 LFN write/append to file - diamond                  ;;
;;  23.06.2006 LFN start application - diamond                     ;;
;;  15.06.2006 LFN get/set file/folder info - diamond              ;;
;;  27.05.2006 LFN create/rewrite file - diamond                   ;;
;;  04.05.2006 LFN read folder - diamond                           ;;
;;  29.04.2006 Elimination of hangup after the                     ;;
;;             expiration hd_wait_timeout -  Mario79               ;;
;;  23.04.2006 LFN read file - diamond                             ;;
;;  28.01.2006 find all Fat16/32 partition in all input point      ;;
;;             to MBR, see file part_set.inc - Mario79             ;;
;;  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                    ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3908 $
 
 
cache_max equ 1919      ; max. is 1919*512+0x610000=0x6ffe00
 
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]
 
; Internal data for every FAT partition.
struct FAT PARTITION
 
fs_type              db ?
fat16_root           db 0       ; flag for fat16 rootdir
fat_change           db 0       ; 1=fat has changed
                     db ?       ; alignment
Lock                 MUTEX ?    ; currently operations with one partition
                                ; can not be executed in parallel since the
                                ; legacy code is not ready; this mutex guards
                                ; all operations
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
 
fatStartScan         dd 2
 
cluster_tmp          dd 0       ; used by analyze_directory
                                ; and analyze_directory_to_write
 
longname_sec1        dd 0       ; used by analyze_directory to save 2 previous
longname_sec2        dd 0       ; directory sectors for delete long filename
 
fat_in_cache         dd -1
 
fat_cache            rb 512
buffer               rb 512
fsinfo_buffer        rb 512
ends
 
uglobal
align 4
partition_count      dd 0       ; partitions found by set_FAT32_variables
 
hd_error             dd 0       ; set by wait_for_sector_buffer
hd_setup             dd 0
hd_wait_timeout      dd 0
 
cache_search_start   dd 0       ; used by find_empty_slot
endg
 
uglobal
align 4
 Sector512:                      ; label for dev_hdcd.inc
  buffer:
                times 512 db 0
endg
 
iglobal
align 4
fat_user_functions:
        dd      free
        dd      (fat_user_functions_end - fat_user_functions - 4) / 4
        dd      fat_Read
        dd      fat_ReadFolder
        dd      fat_Rewrite
        dd      fat_Write
        dd      fat_SetFileEnd
        dd      fat_GetFileInfo
        dd      fat_SetFileInfo
        dd      0
        dd      fat_Delete
        dd      fat_CreateFolder
fat_user_functions_end:
endg
 
; these labels are located before the main function to make
; most of jumps to these be short
fat_create_partition.free_return0:
 
        mov     eax, ebp
        call    free
 
        pop     ebp
fat_create_partition.return0:
        xor     eax, eax
        ret
fat_create_partition:
; bootsector must have been successfully read
        cmp     dword [esp+4], 0
        jnz     .return0
; bootsector signature must be correct
        cmp     word [ebx+0x1fe], 0xaa55
        jnz     .return0
; sectors per cluster must be nonzero
        cmp     byte [ebx+0xd], 0
        jz      .return0
; bytes per sector must be 0x200
        cmp     word [ebx+0xb], 0x200
        jnz     .return0
; number of fats must be nonzero
        cmp     byte [ebx+0x10], 0
        jz      .return0
; The only reason to be invalid partition now is FAT12. Since the test for
; FAT size requires knowledge of some calculated values, which are also used
; in the normal operation, let's hope for the best and allocate data now; if
; it will prove wrong, just deallocate it.
        movi    eax, sizeof.FAT
        call    malloc
        test    eax, eax
        jz      .return0
        mov     ecx, dword [ebp+PARTITION.FirstSector]
        mov     dword [eax+FAT.FirstSector], ecx
        mov     ecx, dword [ebp+PARTITION.FirstSector+4]
        mov     dword [eax+FAT.FirstSector+4], ecx
        mov     ecx, dword [ebp+PARTITION.Length]
        mov     dword [eax+FAT.Length], ecx
        mov     ecx, dword [ebp+PARTITION.Length+4]
        mov     dword [eax+FAT.Length+4], ecx
        mov     ecx, [ebp+PARTITION.Disk]
        mov     [eax+FAT.Disk], ecx
        mov     [eax+FAT.FSUserFunctions], fat_user_functions
        or      [eax+FAT.fat_in_cache], -1
        mov     [eax+FAT.fat_change], 0
        push    ebp
        mov     ebp, eax
 
        lea     ecx, [ebp+FAT.Lock]
        call    mutex_init
 
        movzx   eax, word [ebx+0xe]     ; sectors reserved
        mov     [ebp+FAT.FAT_START], eax
 
        movzx   eax, byte [ebx+0xd]     ; sectors per cluster
        mov     [ebp+FAT.SECTORS_PER_CLUSTER], eax
 
        movzx   ecx, word [ebx+0xb]     ; bytes per sector
        mov     [ebp+FAT.BYTES_PER_SECTOR], ecx
 
        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
 
        movzx   eax, word [ebx+0x16]    ; sectors per fat <65536
        test    eax, eax
        jnz     @f
        mov     eax, [ebx+0x24]         ; sectors per fat
@@:
        mov     [ebp+FAT.SECTORS_PER_FAT], eax
 
        movzx   eax, byte [ebx+0x10]    ; number of fats
        mov     [ebp+FAT.NUMBER_OF_FATS], eax
        imul    eax, [ebp+FAT.SECTORS_PER_FAT]
        add     eax, [ebp+FAT.FAT_START]
        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
        mov     [ebp+FAT.DATA_START], eax       ; data area = rootdir + rootdir_size
 
        movzx   eax, word [ebx+0x13]    ; total sector count <65536
        test    eax, eax
        jnz     @f
        mov     eax, [ebx+0x20]         ; total sector count
@@:
        mov     dword [ebp+FAT.Length], eax
        and     dword [ebp+FAT.Length+4], 0
        sub     eax, [ebp+FAT.DATA_START]       ; eax = count of data sectors
        xor     edx, edx
        div     [ebp+FAT.SECTORS_PER_CLUSTER]
        inc     eax
        mov     [ebp+FAT.LAST_CLUSTER], eax
        dec     eax                     ; cluster count
        mov     [ebp+FAT.fatStartScan], 2
 
        ; limits by Microsoft Hardware White Paper v1.03
        cmp     eax, 4085               ; 0xff5
        jb      .free_return0           ; fat12 not supported
        cmp     eax, 65525              ; 0xfff5
        jb      .fat16
.fat32:
        mov     eax, [ebx+0x2c]         ; rootdir cluster
        mov     [ebp+FAT.ROOT_CLUSTER], 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+FAT.fatStartScan], eax
@@:
        pop     ebx
        mov     [ebp+FAT.fatRESERVED], 0x0FFFFFF6
        mov     [ebp+FAT.fatBAD], 0x0FFFFFF7
        mov     [ebp+FAT.fatEND], 0x0FFFFFF8
        mov     [ebp+FAT.fatMASK], 0x0FFFFFFF
        mov     al, 32
 
        mov     [ebp+FAT.fs_type], al
        mov     eax, ebp
        pop     ebp
        ret
.fat16:
        and     [ebp+FAT.ROOT_CLUSTER], 0
        mov     [ebp+FAT.fatRESERVED], 0x0000FFF6
        mov     [ebp+FAT.fatBAD], 0x0000FFF7
        mov     [ebp+FAT.fatEND], 0x0000FFF8
        mov     [ebp+FAT.fatMASK], 0x0000FFFF
        mov     al, 16
 
        mov     [ebp+FAT.fs_type], al
        mov     eax, ebp
        pop     ebp
        ret
 
set_FAT:
;--------------------------------
; input  : EAX = cluster
;          EDX = value to save
;          EBP = pointer to FAT structure
; output : EDX = old value
;--------------------------------
; out: CF set <=> error
        push    eax ebx esi
 
        cmp     eax, 2
        jb      sfc_error
        cmp     eax, [ebp+FAT.LAST_CLUSTER]
        ja      sfc_error
        cmp     [ebp+FAT.fs_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, [ebp+FAT.FAT_START]
        lea     ebx, [ebp+FAT.fat_cache]
 
        cmp     eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
        je      sfc_in_cache    ; yes
 
        cmp     [ebp+FAT.fat_change], 0; is fat changed?
        je      sfc_no_change   ; no
        call    write_fat_sector; yes. write it into disk
        jc      sfc_error
 
  sfc_no_change:
        mov     [ebp+FAT.fat_in_cache], eax; save fat sector
        call    fs_read32_sys
        test    eax, eax
        jne     sfc_error
 
 
  sfc_in_cache:
        cmp     [ebp+FAT.fs_type], 16
        jne     sfc_test32
 
  sfc_set16:
        xchg    [ebx+esi], dx   ; save new value and get old value
        jmp     sfc_write
 
  sfc_test32:
        mov     eax, [ebp+FAT.fatMASK]
 
  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     [ebp+FAT.fat_change], 1; fat has changed
 
  sfc_nonzero:
        and     edx, [ebp+FAT.fatMASK]
 
  sfc_return:
        pop     esi ebx eax
        ret
  sfc_error:
        stc
        jmp     sfc_return
 
 
get_FAT:
;--------------------------------
; input  : EAX = cluster
;          EBP = pointer to FAT structure
; output : EAX = next cluster
;--------------------------------
; out: CF set <=> error
        push    ebx esi
 
        cmp     [ebp+FAT.fs_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, [ebp+FAT.FAT_START]
        lea     ebx, [ebp+FAT.fat_cache]
 
        cmp     eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
        je      gfc_in_cache
 
        cmp     [ebp+FAT.fat_change], 0; is fat changed?
        je      gfc_no_change   ; no
        call    write_fat_sector; yes. write it into disk
        jc      hd_error_01
 
  gfc_no_change:
        mov     [ebp+FAT.fat_in_cache], eax
        call    fs_read32_sys
        test    eax, eax
        jne     hd_error_01
 
  gfc_in_cache:
        mov     eax, [ebx+esi]
        and     eax, [ebp+FAT.fatMASK]
  gfc_return:
        pop     esi ebx
        ret
 hd_error_01:
        stc
        jmp     gfc_return
 
 
get_free_FAT:
;-----------------------------------------------------------
; 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, [ebp+FAT.LAST_CLUSTER]; counter for full disk
        sub     ecx, 2
        mov     eax, [ebp+FAT.fatStartScan]
        cmp     eax, 2
        jb      gff_reset
 
  gff_test:
        cmp     eax, [ebp+FAT.LAST_CLUSTER]; if above last cluster start at cluster 2
        jbe     gff_in_range
  gff_reset:
        mov     eax, 2
 
  gff_in_range:
        push    eax
        call    get_FAT         ; get cluster state
        jc      gff_not_found_1
 
        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_not_found_1:
        pop     eax
        jmp     gff_not_found
 
  gff_found:
        lea     ecx, [eax+1]
        mov     [ebp+FAT.fatStartScan], ecx
        pop     ecx
        clc
        ret
 
 
write_fat_sector:
;-----------------------------------------------------------
; write changed fat to disk
;-----------------------------------------------------------
        push    eax ebx ecx
 
        mov     [ebp+FAT.fat_change], 0
        mov     eax, [ebp+FAT.fat_in_cache]
        cmp     eax, -1
        jz      write_fat_not_used
        lea     ebx, [ebp+FAT.fat_cache]
        mov     ecx, [ebp+FAT.NUMBER_OF_FATS]
 
  write_next_fat:
        push    eax
        call    fs_write32_sys
        test    eax, eax
        pop     eax
        jnz     write_fat_not_used
 
        add     eax, [ebp+FAT.SECTORS_PER_FAT]
        dec     ecx
        jnz     write_next_fat
 
  write_fat_not_used:
        pop     ecx ebx eax
        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
 
 
 
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     [ebp+FAT.fs_type], 32  ; free disk space only used by fat32
        jne     add_dfs_no
 
        push    eax ebx
        mov     eax, [ebp+FAT.ADR_FSINFO]
        lea     ebx, [ebp+FAT.fsinfo_buffer]
        call    fs_read32_sys
        test    eax, eax
        jnz     add_not_fs
 
        cmp     dword [ebx+0x1fc], 0xaa550000; check sector id
        jne     add_not_fs
 
        add     [ebx+0x1e8], ecx
        push    [ebp+FAT.fatStartScan]
        pop     dword [ebx+0x1ec]
        mov     eax, [ebp+FAT.ADR_FSINFO]
        call    fs_write32_sys
;    jc    add_not_fs
 
  add_not_fs:
        pop     ebx eax
 
  add_dfs_no:
        ret
 
 
 
clear_cluster_chain:
;-----------------------------------------------------
; input  : eax = first cluster
;-----------------------------------------------------
        push    eax ecx edx
        xor     ecx, ecx        ; cluster count
 
  clean_new_chain:
        cmp     eax, [ebp+FAT.LAST_CLUSTER]; end of file
        ja      delete_OK
        cmp     eax, 2          ; unfinished fat chain or zero length file
        jb      delete_OK
        cmp     eax, [ebp+FAT.ROOT_CLUSTER]; don't remove root cluster
        jz      delete_OK
 
        xor     edx, edx
        call    set_FAT         ; clear fat entry
        jc      access_denied_01
 
        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
        clc
  access_denied_01:
        pop     edx ecx eax
        ret
 
 
if 0
get_hd_info:
;-----------------------------------------------------------
; output : eax = 0 - ok
;                3 - unknown FS
;               10 - access denied
;          edx = cluster size in bytes
;          ebx = total clusters on disk
;          ecx = free clusters on disk
;-----------------------------------------------------------
        cmp     [ebp+FAT.fs_type], 16
        jz      info_fat_ok
        cmp     [ebp+FAT.fs_type], 32
        jz      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, [ebp+FAT.LAST_CLUSTER]
 
  info_cluster:
        push    eax
        call    get_FAT         ; get cluster info
        jc      info_access_denied
 
        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, [ebp+FAT.SECTORS_PER_CLUSTER], 512; cluster size in bytes
        xor     eax, eax
        ret
 
  info_access_denied:
        add     esp, 4
        xor     edx, edx
        xor     ebx, ebx
        xor     ecx, ecx
        mov     eax, ERROR_ACCESS_DENIED
        ret
end if
 
update_disk:
;-----------------------------------------------------------
; write changed fat and cache to disk
;-----------------------------------------------------------
        cmp     [ebp+FAT.fat_change], 0 ; is fat changed?
        je      upd_no_change
 
        call    write_fat_sector
        jc      update_disk_acces_denied
 
  upd_no_change:
 
        push    esi
        mov     esi, [ebp+PARTITION.Disk]
        call    disk_sync
        pop     esi
  update_disk_acces_denied:
        ret
 
fat_lock:
        lea     ecx, [ebp+FAT.Lock]
        jmp     mutex_lock
fat_unlock:
        lea     ecx, [ebp+FAT.Lock]
        jmp     mutex_unlock
 
; \begin{diamond}
hd_find_lfn:
; in: ebp -> FAT structure
; in: esi+[esp+4] -> name
; out: CF=1 - file not found, eax=error code
;      else CF=0 and edi->direntry, eax=sector
; destroys eax
        push    esi edi
        push    0
        push    0
        push    fat16_root_first
        push    fat16_root_next
        mov     eax, [ebp+FAT.ROOT_CLUSTER]
        cmp     [ebp+FAT.fs_type], 32
        jz      .fat32
.loop:
        call    fat_find_lfn
        jc      .notfound
        cmp     byte [esi], 0
        jz      .found
.continue:
        test    byte [edi+11], 10h
        jz      .notfound
        and     dword [esp+12], 0
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]    ; cluster
.fat32:
        mov     [esp+8], eax
        mov     dword [esp+4], fat_notroot_first
        mov     dword [esp], fat_notroot_next
        jmp     .loop
.notfound:
        add     esp, 16
        pop     edi esi
        stc
        ret     4
.found:
        lea     eax, [esp+4+24]
        cmp     dword [eax], 0
        jz      @f
        mov     esi, [eax]
        and     dword [eax], 0
        jmp     .continue
@@:
        lea     eax, [esp+8]
        cmp     dword [eax], 0
        jz      .root
        call    fat_get_sector
        jmp     .cmn
.root:
        mov     eax, [eax+4]
        add     eax, [ebp+FAT.ROOT_START]
.cmn:
        add     esp, 20         ; CF=0
        pop     esi
        ret     4
 
;----------------------------------------------------------------
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
; fat_Read - FAT16/32 implementation of reading a file
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_Read:
        call    fat_lock
        push    edi
        cmp     byte [esi], 0
        jnz     @f
.noaccess:
        pop     edi
.noaccess_2:
        call    fat_unlock
        or      ebx, -1
        mov     eax, ERROR_ACCESS_DENIED
        ret
 
@@:
        stdcall hd_find_lfn, [esp+4+4]
        jnc     .found
        pop     edi
        push    eax
        call    fat_unlock
        pop     eax
        or      ebx, -1
        ret
 
.found:
        test    byte [edi+11], 0x10; do not allow read directories
        jnz     .noaccess
        cmp     dword [ebx+8], 0
        jz      @f
        xor     ebx, ebx
.reteof:
        call    fat_unlock
        mov     eax, ERROR_END_OF_FILE
        pop     edi
        ret
@@:
        mov     ecx, [ebx+12]   ; size
        mov     edx, [ebx+16]   ; pointer
        mov     ebx, [ebx+4]    ; file offset
        push    edx
        push    0
        mov     eax, [edi+28]
        sub     eax, ebx
        jb      .eof
        cmp     eax, ecx
        jae     @f
        mov     ecx, eax
        mov     byte [esp], 6
@@:
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
; now eax=cluster, ebx=position, ecx=count, edx=buffer for data
.new_cluster:
        jecxz   .new_sector
        cmp     eax, 2
        jb      .eof
        cmp     eax, [ebp+FAT.fatRESERVED]
        jae     .eof
        mov     [ebp+FAT.cluster_tmp], eax
        dec     eax
        dec     eax
        mov     edi, [ebp+FAT.SECTORS_PER_CLUSTER]
        imul    eax, edi
        add     eax, [ebp+FAT.DATA_START]
.new_sector:
        test    ecx, ecx
        jz      .done
        sub     ebx, 512
        jae     .skip
        add     ebx, 512
        jnz     .force_buf
        cmp     ecx, 512
        jb      .force_buf
; we may read directly to given buffer
        push    eax ebx
        mov     ebx, edx
        call    fs_read32_app
        test    eax, eax
        pop     ebx eax
        jne     .noaccess_1
        add     edx, 512
        sub     ecx, 512
        jmp     .skip
.force_buf:
; we must read sector to temporary buffer and then copy it to destination
        push    eax ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_app
        test    eax, eax
        mov     eax, ebx
        pop     ebx
        jne     .noaccess_3
        add     eax, ebx
        push    ecx
        add     ecx, ebx
        cmp     ecx, 512
        jbe     @f
        mov     ecx, 512
@@:
        sub     ecx, ebx
        mov     ebx, edx
        call    memmove
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        pop     eax
        xor     ebx, ebx
.skip:
        inc     eax
        dec     edi
        jnz     .new_sector
        mov     eax, [ebp+FAT.cluster_tmp]
        call    get_FAT
        jc      .noaccess_1
 
        jmp     .new_cluster
.noaccess_3:
        pop     eax
.noaccess_1:
        pop     eax
        push    ERROR_DEVICE
.done:
        mov     ebx, edx
        call    fat_unlock
        pop     eax edx edi
        sub     ebx, edx
        ret
.eof:
        mov     ebx, edx
        pop     eax edx
        sub     ebx, edx
        jmp     .reteof
 
;----------------------------------------------------------------
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
; fat_ReadFolder - FAT16/32 implementation of reading a folder
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_ReadFolder:
        call    fat_lock
        mov     eax, [ebp+FAT.ROOT_CLUSTER]
        push    edi
        cmp     byte [esi], 0
        jz      .doit
        stdcall hd_find_lfn, [esp+4+4]
        jnc     .found
        pop     edi
        push    eax
        call    fat_unlock
        pop     eax
        or      ebx, -1
        ret
.found:
        test    byte [edi+11], 0x10     ; do not allow read files
        jnz     .found_dir
        pop     edi
        call    fat_unlock
        or      ebx, -1
        mov     eax, ERROR_ACCESS_DENIED
        ret
.found_dir:
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]    ; eax=cluster
.doit:
        push    esi
        sub     esp, 262*2      ; reserve space for LFN
        push    dword [ebx+8]   ; for fat_get_name: read ANSI/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     ecx, [ebx+12]   ; number of blocks to read
        mov     ebx, [ebx+4]    ; index of the first block
.new_cluster:
        mov     [ebp+FAT.cluster_tmp], eax
        test    eax, eax
        jnz     @f
        cmp     [ebp+FAT.fs_type], 32
        jz      .notfound
        mov     eax, [ebp+FAT.ROOT_START]
        push    [ebp+FAT.ROOT_SECTORS]
        push    ebx
        jmp     .new_sector
@@:
        dec     eax
        dec     eax
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        push    [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        push    ebx
.new_sector:
        lea     ebx, [ebp+FAT.buffer]
        mov     edi, ebx
        push    eax
        call    fs_read32_sys
        test    eax, eax
        pop     eax
        jnz     .notfound2
        add     ebx, 512
        push    eax
.l1:
        push    ebp
        lea     ebp, [esp+20]
        call    fat_get_name
        pop     ebp
        jc      .l2
        cmp     byte [edi+11], 0xF
        jnz     .do_bdfe
        add     edi, 0x20
        cmp     edi, ebx
        jb      .do_bdfe
        pop     eax
        inc     eax
        dec     dword [esp+4]
        jnz     @f
        mov     eax, [ebp+FAT.cluster_tmp]
        test    eax, eax
        jz      .done
        call    get_FAT
        jc      .notfound2
        cmp     eax, 2
        jb      .done
        cmp     eax, [ebp+FAT.fatRESERVED]
        jae     .done
        push    eax
        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        mov     [esp+8], eax
        pop     eax
        mov     [ebp+FAT.cluster_tmp], eax
        dec     eax
        dec     eax
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
@@:
        lea     ebx, [ebp+FAT.buffer]
        mov     edi, ebx
        push    eax
        call    fs_read32_sys
        test    eax, eax
        pop     eax
        jnz     .notfound2
        add     ebx, 512
        push    eax
.do_bdfe:
        inc     dword [edx+8]   ; new file found
        dec     dword [esp+4]
        jns     .l2
        dec     ecx
        js      .l2
        inc     dword [edx+4]   ; new file block copied
        push    ebp
        lea     ebp, [esp+20]
        call    fat_entry_to_bdfe
        pop     ebp
.l2:
        add     edi, 0x20
        cmp     edi, ebx
        jb      .l1
        pop     eax
        inc     eax
        dec     dword [esp+4]
        jnz     .new_sector
        mov     eax, [ebp+FAT.cluster_tmp]
        test    eax, eax
        jz      .done
        call    get_FAT
        jc      .notfound2
        cmp     eax, 2
        jb      .done
        cmp     eax, [ebp+FAT.fatRESERVED]
        jae     .done
        push    eax
        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        mov     [esp+8], eax
        pop     eax
        pop     ebx
        add     esp, 4
        jmp     .new_cluster
.notfound2:
        add     esp, 8
.notfound:
        add     esp, 262*2+4
        pop     esi edi
        mov     ebx, [edx+4]
        call    fat_unlock
        mov     eax, ERROR_DEVICE
        ret
.done:
        add     esp, 262*2+4+8
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ecx
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        push    eax
        call    fat_unlock
        pop     eax
        pop     esi edi
        ret
 
fat16_root_next:
        push    ecx
        lea     ecx, [ebp+FAT.buffer+0x200-0x20]
        cmp     edi, ecx
        jae     fat16_root_next_sector
        pop     ecx
        add     edi, 0x20
        ret     ; CF=0
fat16_root_next_sector:
; read next sector
        push    [ebp+FAT.longname_sec2]
        pop     [ebp+FAT.longname_sec1]
        mov     ecx, [eax+4]
        push    ecx
        add     ecx, [ebp+FAT.ROOT_START]
        mov     [ebp+FAT.longname_sec2], ecx
        pop     ecx
        inc     ecx
        mov     [eax+4], ecx
        cmp     ecx, [ebp+FAT.ROOT_SECTORS]
        pop     ecx
        jb      fat16_root_first
        mov     eax, ERROR_FILE_NOT_FOUND
        stc
        ret
fat16_root_first:
        mov     eax, [eax+4]
        add     eax, [ebp+FAT.ROOT_START]
        push    ebx
        lea     edi, [ebp+FAT.buffer]
        mov     ebx, edi
        call    fs_read32_sys
        pop     ebx
        test    eax, eax
        jnz     .readerr
        ret     ; CF=0
.readerr:
        mov     eax, ERROR_DEVICE
        stc
        ret
.notfound:
        mov     eax, ERROR_FILE_NOT_FOUND
        stc
        ret
fat16_root_begin_write:
        push    edi eax
        call    fat16_root_first
        pop     eax edi
        ret
fat16_root_end_write:
        pusha
        mov     eax, [eax+4]
        add     eax, [ebp+FAT.ROOT_START]
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        popa
        ret
fat16_root_next_write:
        push    ecx
        lea     ecx, [ebp+FAT.buffer+0x200]
        cmp     edi, ecx
        jae     @f
        pop     ecx
        ret
@@:
        call    fat16_root_end_write
        jmp     fat16_root_next_sector
fat16_root_extend_dir:
        stc
        ret
 
fat_notroot_next:
        push    ecx
        lea     ecx, [ebp+FAT.buffer+0x200-0x20]
        cmp     edi, ecx
        jae     fat_notroot_next_sector
        pop     ecx
        add     edi, 0x20
        ret     ; CF=0
fat_notroot_next_sector:
        push    [ebp+FAT.longname_sec2]
        pop     [ebp+FAT.longname_sec1]
        push    eax
        call    fat_get_sector
        mov     [ebp+FAT.longname_sec2], eax
        pop     eax
        mov     ecx, [eax+4]
        inc     ecx
        cmp     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        jae     fat_notroot_next_cluster
        mov     [eax+4], ecx
        jmp     @f
fat_notroot_next_cluster:
        push    eax
        mov     eax, [eax]
        call    get_FAT
        mov     ecx, eax
        pop     eax
        jc      fat_notroot_first.deverr
        cmp     ecx, 2
        jb      fat_notroot_next_err
        cmp     ecx, [ebp+FAT.fatRESERVED]
        jae     fat_notroot_next_err
        mov     [eax], ecx
        and     dword [eax+4], 0
@@:
        pop     ecx
fat_notroot_first:
        call    fat_get_sector
        push    ebx
        lea     edi, [ebp+FAT.buffer]
        mov     ebx, edi
        call    fs_read32_sys
        pop     ebx
        test    eax, eax
        jz      .ret ; CF=0
        push    ecx
.deverr:
        pop     ecx
        mov     eax, ERROR_DEVICE
        stc
.ret:
        ret
fat_notroot_next_err:
        pop     ecx
        mov     eax, ERROR_FILE_NOT_FOUND
        stc
        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
fat_notroot_next_write:
        push    ecx
        lea     ecx, [ebp+FAT.buffer+0x200]
        cmp     edi, ecx
        jae     @f
        pop     ecx
        ret
@@:
        push    eax
        call    fat_notroot_end_write
        pop     eax
        jmp     fat_notroot_next_sector
fat_notroot_extend_dir:
        push    eax
        call    get_free_FAT
        jnc     .found
        pop     eax
        ret     ; CF=1
.found:
        push    edx
        mov     edx, [ebp+FAT.fatEND]
        call    set_FAT
        jc      .writeerr
        mov     edx, eax
        mov     eax, [esp+4]
        mov     eax, [eax]
        push    edx
        call    set_FAT
        pop     edx
        jnc     @f
.writeerr:
        pop     edx
        pop     eax
        stc
        ret
@@:
        push    ecx
        or      ecx, -1
        call    add_disk_free_space
; zero new cluster
        mov     ecx, 512/4
        lea     edi, [ebp+FAT.buffer]
        push    edi
        xor     eax, eax
        rep stosd
        pop     edi
        pop     ecx
        mov     eax, [esp+4]
        mov     [eax], edx
        and     dword [eax+4], 0
        pop     edx
        mov     eax, [eax]
        dec     eax
        dec     eax
        push    ebx ecx
        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        imul    eax, ecx
        add     eax, [ebp+FAT.DATA_START]
        mov     ebx, edi
@@:
        push    eax
        call    fs_write32_sys
        pop     eax
        inc     eax
        loop    @b
        pop     ecx ebx eax
        clc
        ret
 
fat_get_sector:
        push    ecx
        mov     ecx, [eax]
        dec     ecx
        dec     ecx
        imul    ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     ecx, [ebp+FAT.DATA_START]
        add     ecx, [eax+4]
        mov     eax, ecx
        pop     ecx
        ret
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fshrad:
        call    fat_unlock
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
 
;----------------------------------------------------------------
; fat_CreateFolder - FAT16/32 implementation of creating a folder
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_CreateFolder:
        push    1
        jmp     fat_Rewrite.common
 
;----------------------------------------------------------------
; fat_Rewrite - FAT16/32 implementation of creating a new file
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_Rewrite:
        push    0
.common:
        call    fat_lock
        pop     eax
        cmp     byte [esi], 0
        jz      fshrad
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        pushad
        xor     edi, edi
        mov     edx, [esp+4+20h]
        push    esi
        test    edx, edx
        jz      @f
        mov     esi, edx
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
        lea     edi, [esi-1]
        jmp     @b
@@:
        pop     esi
        test    edi, edi
        jnz     .noroot
        test    edx, edx
        jnz     .hasebp
        mov     edx, [ebp+FAT.ROOT_CLUSTER]
        cmp     [ebp+FAT.fs_type], 32
        jz      .pushnotroot
        xor     edx, edx
        push    edx
        push    fat16_root_extend_dir
        push    fat16_root_end_write
        push    fat16_root_next_write
        push    fat16_root_begin_write
        push    edx
        push    edx
        push    fat16_root_first
        push    fat16_root_next
        jmp     .common1
.hasebp:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [edx], 0
        jz      .ret1
        stdcall hd_find_lfn, 0
        mov     esi, [esp+4+20h]
        jc      .ret1
        jmp     .common0
.noroot:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [edi+1], 0
        jz      .ret1
; check existence
        mov     byte [edi], 0
        push    edi
        stdcall hd_find_lfn, [esp+4+24h]
        pop     esi
        mov     byte [esi], '/'
        jnc     @f
.notfound0:
        mov     eax, ERROR_FILE_NOT_FOUND
.ret1:
        mov     [esp+28], eax
        call    fat_unlock
        popad
        xor     ebx, ebx
        ret
@@:
        inc     esi
.common0:
        test    byte [edi+11], 0x10     ; must be directory
        mov     eax, ERROR_ACCESS_DENIED
        jz      .ret1
        mov     edx, [edi+20-2]
        mov     dx, [edi+26]            ; ebp=cluster
        mov     eax, ERROR_FAT_TABLE
        cmp     edx, 2
        jb      .ret1
.pushnotroot:
        push    edx
        push    fat_notroot_extend_dir
        push    fat_notroot_end_write
        push    fat_notroot_next_write
        push    fat_notroot_begin_write
        push    0
        push    edx
        push    fat_notroot_first
        push    fat_notroot_next
.common1:
        call    fat_find_lfn
        jc      .notfound
; found
        test    byte [edi+11], 10h
        jz      .exists_file
; found directory; if we are creating directory, return OK,
;                  if we are creating file, say "access denied"
        add     esp, 36
        call    fat_unlock
        popad
        test    al, al
        mov     eax, ERROR_ACCESS_DENIED
        jz      @f
        mov     al, 0
@@:
        xor     ebx, ebx
        ret
.exists_file:
; found file; if we are creating directory, return "access denied",
;             if we are creating file, delete existing file and continue
        cmp     byte [esp+36+28], 0
        jz      @f
        add     esp, 36
        call    fat_unlock
        popad
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
@@:
; delete FAT chain
        push    edi
        xor     eax, eax
        mov     dword [edi+28], eax     ; zero size
        xor     ecx, ecx
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
        mov     word [edi+20], cx
        mov     word [edi+26], cx
        test    eax, eax
        jz      .done1
@@:
        cmp     eax, [ebp+FAT.fatRESERVED]
        jae     .done1
        push    edx
        xor     edx, edx
        call    set_FAT
        mov     eax, edx
        pop     edx
        jc      .done1
        inc     ecx
        jmp     @b
.done1:
        pop     edi
        call    get_time_for_file
        mov     [edi+22], ax
        call    get_date_for_file
        mov     [edi+24], ax
        mov     [edi+18], ax
        or      byte [edi+11], 20h      ; set 'archive' attribute
        jmp     .doit
.notfound:
; file is not found; generate short name
        call    fat_name_is_legal
        jc      @f
        add     esp, 36
        call    fat_unlock
        popad
        mov     eax, ERROR_FILE_NOT_FOUND
        xor     ebx, ebx
        ret
@@:
        sub     esp, 12
        mov     edi, esp
        call    fat_gen_short_name
.test_short_name_loop:
        push    esi edi ecx
        mov     esi, edi
        lea     eax, [esp+12+12+8]
        mov     edx, [eax+24]
        mov     [eax], edx
        and     dword [eax+4], 0
        call    dword [eax-4]
        jc      .found
.test_short_name_entry:
        cmp     byte [edi+11], 0xF
        jz      .test_short_name_cont
        mov     ecx, 11
        push    esi edi
        repz cmpsb
        pop     edi esi
        jz      .short_name_found
.test_short_name_cont:
        lea     eax, [esp+12+12+8]
        call    dword [eax-8]
        jnc     .test_short_name_entry
        jmp     .found
.short_name_found:
        pop     ecx edi esi
        call    fat_next_short_name
        jnc     .test_short_name_loop
.disk_full:
        add     esp, 12+36
        call    fat_unlock
        popa
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.found:
        pop     ecx edi esi
; now find space in directory
; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
        mov     al, '~'
        push    ecx edi
        mov     ecx, 8
        repnz scasb
        movi    eax, 1     ; 1 entry
        jnz     .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
        xor     eax, eax
@@:
        cmp     byte [esi], 0
        jz      @f
        inc     esi
        inc     eax
        jmp     @b
@@:
        sub     esi, eax
        add     eax, 12+13
        mov     ecx, 13
        push    edx
        cdq
        div     ecx
        pop     edx
.notilde:
        push    -1
        push    -1
        push    -1
; find  successive entries in directory
        xor     ecx, ecx
        push    eax
        lea     eax, [esp+16+8+12+8]
        mov     edx, [eax+24]
        mov     [eax], edx
        and     dword [eax+4], 0
        call    dword [eax-4]
        pop     eax
        jnc     .scan_dir
.fsfrfe3:
        add     esp, 12+8+12+36
        call    fat_unlock
        popad
        mov     eax, ERROR_DEVICE
        xor     ebx, ebx
        ret
.scan_dir:
        cmp     byte [edi], 0
        jz      .free
        cmp     byte [edi], 0xE5
        jz      .free
        xor     ecx, ecx
.scan_cont:
        push    eax
        lea     eax, [esp+16+8+12+8]
        call    dword [eax-8]
        mov     edx, eax
        pop     eax
        jnc     .scan_dir
        cmp     edx, ERROR_DEVICE
        jz      .fsfrfe3
        push    eax
        lea     eax, [esp+16+8+12+8]
        call    dword [eax+20]          ; extend directory
        pop     eax
        jnc     .scan_dir
        add     esp, 12+8+12+36
        call    fat_unlock
        popad
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.free:
        test    ecx, ecx
        jnz     @f
        mov     [esp], edi
        mov     ecx, [esp+12+8+12+8]
        mov     [esp+4], ecx
        mov     ecx, [esp+12+8+12+12]
        mov     [esp+8], ecx
        xor     ecx, ecx
@@:
        inc     ecx
        cmp     ecx, eax
        jb      .scan_cont
; found!
        push    esi ecx
; If creating a directory, allocate one data cluster now and fail immediately
; if this is impossible. This prevents from creating an invalid directory entry
; on a full disk.
; yup, the argument is quite non-intuitive... but what should I do if
; the entire function uses such arguments? BTW, it refers to al from pushad,
; which in turn is filled with 0 in fat_Rewrite and 1 in fat_CreateFolder.
        cmp     byte [esp+8+12+8+12+36+28], 0
        jz      .no.preallocate.folder.data
        call    get_free_FAT
        jnc     @f
        add     esp, 8+12+8
        jmp     .disk_full
@@:
        mov     [esp+8+12+8+12+36+20], eax ; store the cluster somewhere
.no.preallocate.folder.data:
; calculate name checksum
        mov     esi, [esp+8+12]
        mov     ecx, 11
        xor     eax, eax
@@:
        ror     al, 1
        add     al, [esi]
        inc     esi
        loop    @b
        pop     ecx esi
        pop     edi
        pop     dword [esp+8+12+12]
        pop     dword [esp+8+12+12]
; edi points to first entry in free chunk
        dec     ecx
        jz      .nolfn
        push    esi
        push    eax
        lea     eax, [esp+8+8+12+8]
        call    dword [eax+8]         ; begin write
        mov     al, 40h
.writelfn:
        or      al, cl
        mov     esi, [esp+4]
        push    ecx
        dec     ecx
        imul    ecx, 13
        add     esi, ecx
        stosb
        mov     cl, 5
        call    fs_RamdiskRewrite.read_symbols
        mov     ax, 0xF
        stosw
        mov     al, [esp+4]
        stosb
        mov     cl, 6
        call    fs_RamdiskRewrite.read_symbols
        xor     eax, eax
        stosw
        mov     cl, 2
        call    fs_RamdiskRewrite.read_symbols
        pop     ecx
        lea     eax, [esp+8+8+12+8]
        call    dword [eax+12]         ; next write
        xor     eax, eax
        loop    .writelfn
        pop     eax
        pop     esi
;        lea     eax, [esp+8+12+8]
;        call    dword [eax+16]          ; end write
.nolfn:
        xchg    esi, [esp]
        mov     ecx, 11
        rep movsb
        mov     word [edi], 20h         ; attributes
        sub     edi, 11
        pop     esi ecx
        add     esp, 12
        mov     byte [edi+13], 0        ; tenths of a second at file creation time
        call    get_time_for_file
        mov     [edi+14], ax            ; creation time
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+16], ax            ; creation date
        mov     [edi+24], ax            ; last write date
        mov     [edi+18], ax            ; last access date
        xor     ecx, ecx
        mov     word [edi+20], cx       ; high word of cluster
        mov     word [edi+26], cx       ; low word of cluster - to be filled
        mov     dword [edi+28], ecx     ; file size - to be filled
        cmp     byte [esp+36+28], cl
        jz      .doit
; create directory
        mov     byte [edi+11], 10h      ; attributes: folder
        mov     esi, edi
        lea     eax, [esp+8]
        call    dword [eax+16]  ; flush directory
        mov     eax, [esp+36+20] ; extract saved cluster
        mov     [esp+36+20], edi ; this is needed for calculating arg of add_disk_free_space!
        push    ecx
        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        shl     ecx, 9
        push    ecx
        push    edi
        jmp     .doit2
.doit:
        mov     esi, [esp+36+20]
        lea     eax, [esp+8]
        call    dword [eax+16]  ; flush directory
        push    ecx
        mov     ecx, [esp+4+36+24]
        push    ecx
        push    edi
        test    ecx, ecx
        jz      .done
        call    get_free_FAT
        jc      .diskfull
.doit2:
        push    eax
        mov     [edi+26], ax
        shr     eax, 16
        mov     [edi+20], ax
        lea     eax, [esp+16+8]
        call    dword [eax+16]  ; flush directory
        pop     eax
        push    edx
        mov     edx, [ebp+FAT.fatEND]
        call    set_FAT
        pop     edx
.write_cluster:
        push    eax
        dec     eax
        dec     eax
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        push    [ebp+FAT.SECTORS_PER_CLUSTER]
; write data
.write_sector:
        cmp     byte [esp+20+36+28], 0
        jnz     .writedir
        mov     ecx, 512
        cmp     dword [esp+12], ecx
        jb      .writeshort
; we can write directly from given buffer
        mov     ebx, esi
        add     esi, ecx
        jmp     .writecommon
.writeshort:
        mov     ecx, [esp+12]
        push    ecx
        lea     edi, [ebp+FAT.buffer]
        mov     ebx, edi
        rep movsb
.writedircont:
        lea     ecx, [ebp+FAT.buffer+0x200]
        sub     ecx, edi
        push    eax
        xor     eax, eax
        rep stosb
        pop     eax
        pop     ecx
.writecommon:
        push    eax
        call    fs_write32_app
        test    eax, eax
        pop     eax
        jnz     .writeerr
        inc     eax
        sub     dword [esp+12], ecx
        jz      .writedone
        dec     dword [esp]
        jnz     .write_sector
        pop     eax
; allocate new cluster
        pop     eax
        mov     ecx, eax
        call    get_free_FAT
        jc      .diskfull
        push    edx
        mov     edx, [ebp+FAT.fatEND]
        call    set_FAT
        xchg    eax, ecx
        mov     edx, ecx
        call    set_FAT
        pop     edx
        xchg    eax, ecx
        jmp     .write_cluster
.diskfull:
        mov     eax, ERROR_DISK_FULL
        jmp     .ret
.writeerr:
        pop     eax eax
        sub     esi, ecx
        mov     eax, ERROR_DEVICE
        jmp     .ret
.writedone:
        pop     eax eax
.done:
        xor     eax, eax
.ret:
        pop     edi ecx
        sub     esi, [esp+4+36+20]
        mov     [esp+4+36+28], eax
        mov     [esp+4+36+16], esi
        lea     eax, [esp+12]
        call    dword [eax+8]
        mov     [edi+28], esi
        call    dword [eax+16]
        mov     [esp+36+16], ebx
        lea     eax, [esi+511]
        shr     eax, 9
        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        lea     eax, [eax+ecx-1]
        xor     edx, edx
        div     ecx
        pop     ecx
        sub     ecx, eax
        call    add_disk_free_space
        add     esp, 36
        call    update_disk
        call    fat_unlock
        popad
        ret
.writedir:
        push    512
        lea     edi, [ebp+FAT.buffer]
        mov     ebx, edi
        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        shl     ecx, 9
        cmp     ecx, [esp+16]
        jnz     .writedircont
        dec     dword [esp+20]
        push    esi
        mov     ecx, 32/4
        rep movsd
        pop     esi
        mov     dword [edi-32], '.   '
        mov     dword [edi-32+4], '    '
        mov     dword [edi-32+8], '    '
        mov     byte [edi-32+11], 10h
        push    esi
        mov     ecx, 32/4
        rep movsd
        pop     esi
        mov     dword [edi-32], '..  '
        mov     dword [edi-32+4], '    '
        mov     dword [edi-32+8], '    '
        mov     byte [edi-32+11], 10h
        mov     ecx, [esp+20+36]
        cmp     ecx, [ebp+FAT.ROOT_CLUSTER]
        jnz     @f
        xor     ecx, ecx
@@:
        mov     word [edi-32+26], cx
        shr     ecx, 16
        mov     [edi-32+20], cx
        jmp     .writedircont
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fat_Write.access_denied:
        push    ERROR_ACCESS_DENIED
fat_Write.ret0:
        pop     eax
        xor     ebx, ebx
        ret
 
fat_Write.ret11:
        push    ERROR_DEVICE
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        jmp     fat_Write.ret0
 
;----------------------------------------------------------------
; fat_Write - FAT16/32 implementation of writing to file
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_Write:
        cmp     byte [esi], 0
        jz      .access_denied
        call    fat_lock
        push    edi
        stdcall hd_find_lfn, [esp+4+4]
        jnc     .found
        pop     edi
        push    eax
        call    fat_unlock
        jmp     .ret0
.found:
; FAT does not support files larger than 4GB
        cmp     dword [ebx+8], 0
        jz      @f
.eof:
        pop     edi
        push    ERROR_END_OF_FILE
        call    fat_unlock
        jmp     .ret0
@@:
        mov     ecx, [ebx+12]
        mov     edx, [ebx+16]
        mov     ebx, [ebx+4]
; now edi points to direntry, ebx=start byte to write,
; ecx=number of bytes to write, edx=data pointer
 
; extend file if needed
        add     ecx, ebx
        jc      .eof    ; FAT does not support files larger than 4GB
        push    edx
        push    eax     ; save directory sector
        push    0       ; return value=0
 
        call    get_time_for_file
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+24], ax            ; last write date
        mov     [edi+18], ax            ; last access date
 
        push    dword [edi+28]          ; save current file size
        cmp     ecx, [edi+28]
        jbe     .length_ok
        cmp     ecx, ebx
        jz      .length_ok
        call    hd_extend_file
        jnc     .length_ok
        mov     [esp+4], eax
; hd_extend_file can return three error codes: FAT table error, device error or disk full.
; First two cases are fatal errors, in third case we may write some data
        cmp     al, ERROR_DISK_FULL
        jz      .disk_full
        call    fat_unlock
        pop     eax
        pop     eax
        pop     ecx
        pop     edx
        pop     edi
        xor     ebx, ebx
        ret
.disk_full:
; correct number of bytes to write
        mov     ecx, [edi+28]
        cmp     ecx, ebx
        ja      .length_ok
        push    0
.ret:
        pop     eax
        sub     edx, [esp+12]
        mov     ebx, edx        ; ebx=number of written bytes
        call    update_disk
        test    eax, eax
        jz      @f
        mov     byte [esp+4], ERROR_DEVICE
@@:
        call    fat_unlock
        pop     eax
        pop     eax
        pop     ecx
        pop     edx
        pop     edi
        ret
.length_ok:
        mov     esi, [edi+28]
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
        mov     edi, eax        ; edi=current cluster
        push    0               ; current sector in cluster
; save directory
        mov     eax, [esp+12]
        push    ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        pop     ebx
        test    eax, eax
        jz      @f
.device_err:
        mov     byte [esp+8], ERROR_DEVICE
        jmp     .ret
.fat_err:
        mov     byte [esp+8], ERROR_FAT_TABLE
        jmp     .ret
@@:
 
; now ebx=start pos, ecx=end pos, both lie inside file
        sub     ecx, ebx
        jz      .ret
.write_loop:
; skip unmodified sectors
        cmp     dword [esp+4], 0x200
        jb      .modify
        sub     ebx, 0x200
        jae     .skip
        add     ebx, 0x200
.modify:
; get length of data in current sector
        push    ecx
        sub     ebx, 0x200
        jb      .hasdata
        neg     ebx
        xor     ecx, ecx
        jmp     @f
.hasdata:
        neg     ebx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
; get current sector number
        mov     eax, edi
        dec     eax
        dec     eax
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        add     eax, [esp+4]
; load sector if needed
        cmp     dword [esp+8], 0        ; we don't need to read uninitialized data
        jz      .noread
        cmp     ecx, 0x200      ; we don't need to read sector if it is fully rewritten
        jz      .noread
        cmp     ecx, esi        ; (same for the last sector)
        jz      .noread
        push    eax ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_app
        test    eax, eax
        pop     ebx eax
        jz      @f
.device_err2:
        pop     ecx
        jmp     .device_err
@@:
.noread:
; zero uninitialized data if file was extended (because hd_extend_file does not this)
        push    eax ecx edi
        xor     eax, eax
        mov     ecx, 0x200
        sub     ecx, [esp+8+12]
        jbe     @f
        lea     edi, [ebp+FAT.buffer]
        add     edi, [esp+8+12]
        rep stosb
@@:
; zero uninitialized data in the last sector
        mov     ecx, 0x200
        sub     ecx, esi
        jbe     @f
        lea     edi, [ebp+FAT.buffer+esi]
        rep stosb
@@:
        pop     edi ecx
; copy new data
        mov     eax, edx
        neg     ebx
        jecxz   @f
        lea     ebx, [ebp+FAT.buffer+0x200+ebx]
        call    memmove
        xor     ebx, ebx
@@:
        pop     eax
; save sector
        push    ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_app
        pop     ebx
        test    eax, eax
        jnz     .device_err2
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        jz      .ret
.skip:
; next sector
        pop     eax
        inc     eax
        push    eax
        cmp     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        jb      @f
        and     dword [esp], 0
        mov     eax, edi
        call    get_FAT
        mov     edi, eax
        jc      .device_err
        cmp     edi, 2
        jb      .fat_err
        cmp     edi, [ebp+FAT.fatRESERVED]
        jae     .fat_err
@@:
        sub     esi, 0x200
        jae     @f
        xor     esi, esi
@@:
        sub     dword [esp+4], 0x200
        jae     @f
        and     dword [esp+4], 0
@@:
        jmp     .write_loop
 
hd_extend_file.zero_size:
        xor     eax, eax
        jmp     hd_extend_file.start_extend
 
; extends file on hd to given size (new data area is undefined)
; in: edi->direntry, ecx=new size
; out: CF=0 => OK, eax=0
;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL or ERROR_DEVICE)
hd_extend_file:
        push    esi
        mov     esi, [ebp+FAT.SECTORS_PER_CLUSTER]
        imul    esi, [ebp+FAT.BYTES_PER_SECTOR]
        push    ecx
; find the last cluster of file
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
        mov     ecx, [edi+28]
        jecxz   .zero_size
.last_loop:
        sub     ecx, esi
        jbe     .last_found
        call    get_FAT
        jnc     @f
.device_err:
        pop     ecx
.device_err2:
        pop     esi
        push    ERROR_DEVICE
.ret_err:
        pop     eax
        stc
        ret
@@:
        cmp     eax, 2
        jb      .fat_err
        cmp     eax, [ebp+FAT.fatRESERVED]
        jb      .last_loop
.fat_err:
        pop     ecx esi
        push    ERROR_FAT_TABLE
        jmp     .ret_err
.last_found:
        push    eax
        call    get_FAT
        jnc     @f
        pop     eax
        jmp     .device_err
@@:
        cmp     eax, [ebp+FAT.fatRESERVED]
        pop     eax
        jb      .fat_err
; set length to full number of clusters
        sub     [edi+28], ecx
.start_extend:
        pop     ecx
; now do extend
        push    edx
        mov     edx, 2          ; start scan from cluster 2
.extend_loop:
        cmp     [edi+28], ecx
        jae     .extend_done
; add new cluster
        push    eax
        call    get_free_FAT
        jc      .disk_full
        mov     edx, [ebp+FAT.fatEND]
        call    set_FAT
        mov     edx, eax
        pop     eax
        test    eax, eax
        jz      .first_cluster
        push    edx
        call    set_FAT
        pop     edx
        jmp     @f
.first_cluster:
        ror     edx, 16
        mov     [edi+20], dx
        ror     edx, 16
        mov     [edi+26], dx
@@:
        push    ecx
        mov     ecx, -1
        call    add_disk_free_space
        pop     ecx
        mov     eax, edx
        add     [edi+28], esi
        jmp     .extend_loop
.extend_done:
        mov     [edi+28], ecx
        pop     edx esi
        xor     eax, eax        ; CF=0
        ret
.device_err3:
        pop     edx
        jmp     .device_err2
.disk_full:
        pop     eax edx esi
        movi    eax, ERROR_DISK_FULL
        stc
        ret
 
;----------------------------------------------------------------
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
; fat_SetFileEnd - FAT16/32 implementation of setting end-of-file
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_SetFileEnd:
        call    fat_lock
        push    edi
        cmp     byte [esi], 0
        jnz     @f
.access_denied:
        push    ERROR_ACCESS_DENIED
.ret:
        call    fat_unlock
        pop     eax
        pop     edi
        ret
@@:
        stdcall hd_find_lfn, [esp+4+4]
        jnc     @f
.reteax:
        push    eax
        jmp     .ret
@@:
; must not be directory
        test    byte [edi+11], 10h
        jnz     .access_denied
; file size must not exceed 4 Gb
        cmp     dword [ebx+8], 0
        jz      @f
        push    ERROR_END_OF_FILE
        jmp     .ret
@@:
        push    eax     ; save directory sector
; set file modification date/time to current
        call    fat_update_datetime
        mov     eax, [ebx+4]
        cmp     eax, [edi+28]
        jb      .truncate
        ja      .expand
        pop     eax
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        test    eax, eax
        jz      @f
        push    ERROR_DEVICE
        jmp     .ret
@@:
        push    0
        jmp     .ret
.expand:
        push    ebx ebp ecx
        push    dword [edi+28]  ; save old size
        mov     ecx, eax
        call    hd_extend_file
        push    eax             ; return code
        jnc     .expand_ok
        cmp     al, ERROR_DISK_FULL
        jz      .disk_full
.pop_ret:
        call    update_disk
        pop     eax ecx ecx ebp ebx ecx
        jmp     .reteax
.expand_ok:
.disk_full:
; save directory
        mov     eax, [edi+28]
        xchg    eax, [esp+20]
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        test    eax, eax
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
        mov     edi, eax
        jz      @f
.pop_ret11:
        mov     byte [esp], ERROR_DEVICE
        jmp     .pop_ret
@@:
        test    edi, edi
        jz      .pop_ret
; now zero new data
        push    0
; edi=current cluster, [esp]=sector in cluster
; [esp+24]=new size, [esp+8]=old size, [esp+4]=return code
.zero_loop:
        cmp     edi, 2
        jb      .error_fat
        cmp     edi, [ebp+FAT.fatRESERVED]
        jae     .error_fat
        sub     dword [esp+8], 0x200
        jae     .next_cluster
        lea     eax, [edi-2]
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        add     eax, [esp]
        cmp     dword [esp+8], -0x200
        jz      .noread
        push    eax
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_app
        test    eax, eax
        pop     eax
        jnz     .err_next
.noread:
        mov     ecx, [esp+8]
        neg     ecx
        push    edi
        lea     edi, [ebp+FAT.buffer+0x200]
        add     edi, [esp+12]
        push    eax
        xor     eax, eax
        mov     [esp+16], eax
        rep stosb
        pop     eax
        pop     edi
        call    fs_write32_app
        test    eax, eax
        jz      .next_cluster
.err_next:
        mov     byte [esp+4], ERROR_DEVICE
.next_cluster:
        pop     eax
        sub     dword [esp+20], 0x200
        jbe     .pop_ret
        inc     eax
        push    eax
        cmp     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        jb      .zero_loop
        and     dword [esp], 0
        mov     eax, edi
        call    get_FAT
        mov     edi, eax
        jnc     .zero_loop
        pop     eax
        jmp     .pop_ret11
.truncate:
        mov     [edi+28], eax
        push    ecx
        mov     ecx, [edi+20-2]
        mov     cx, [edi+26]
        push    eax
        test    eax, eax
        jz      .zero_size
; find new last cluster
@@:
        cmp     ecx, 2
        jb      .error_fat2
        cmp     ecx, [ebp+FAT.fatRESERVED]
        jae     .error_fat2
        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        shl     eax, 9
        sub     [esp], eax
        jbe     @f
        mov     eax, ecx
        call    get_FAT
        mov     ecx, eax
        jnc     @b
.device_err3:
        pop     eax ecx eax edi
        call    update_disk
        call    fat_unlock
        movi    eax, ERROR_DEVICE
        ret
@@:
; we will zero data at the end of last sector - remember it
        push    ecx
; terminate FAT chain
        push    edx
        mov     eax, ecx
        mov     edx, [ebp+FAT.fatEND]
        call    set_FAT
        mov     eax, edx
        pop     edx
        jnc     @f
.device_err4:
        pop     ecx
        jmp     .device_err3
.zero_size:
        and     word [edi+20], 0
        and     word [edi+26], 0
        push    0
        mov     eax, ecx
@@:
; delete FAT chain
        call    clear_cluster_chain
        jc      .device_err4
; save directory
        mov     eax, [esp+12]
        push    ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        pop     ebx
        test    eax, eax
        jnz     .device_err4
; zero last sector, ignore errors
        pop     ecx
        pop     eax
        dec     ecx
        imul    ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     ecx, [ebp+FAT.DATA_START]
        push    eax
        sar     eax, 9
        add     ecx, eax
        pop     eax
        and     eax, 0x1FF
        jz      .truncate_done
        push    ebx eax
        mov     eax, ecx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_app
        pop     eax
        lea     edi, [ebp+FAT.buffer+eax]
        push    ecx
        mov     ecx, 0x200
        sub     ecx, eax
        xor     eax, eax
        rep stosb
        pop     eax
        call    fs_write32_app
        pop     ebx
.truncate_done:
        pop     ecx eax edi
        call    update_disk
        call    fat_unlock
        xor     eax, eax
        ret
.error_fat:
        pop     eax
        mov     byte [esp], ERROR_FAT_TABLE
        jmp     .pop_ret
.error_fat2:
        pop     eax ecx eax edi
        call    update_disk
        call    fat_unlock
        movi    eax, ERROR_FAT_TABLE
        ret
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;----------------------------------------------------------------
; fat_GetFileInfo - FAT16/32 implementation of getting file info
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_GetFileInfo:
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2
        ret
@@:
        push    edi
        call    fat_lock
        stdcall hd_find_lfn, [esp+4+4]
        jc      .error
        push    ebp
        xor     ebp, ebp
        mov     esi, [ebx+16]
        mov     dword [esi+4], ebp
        call    fat_entry_to_bdfe2
        pop     ebp
        call    fat_unlock
        xor     eax, eax
        pop     edi
        ret
.error:
        push    eax
        call    fat_unlock
        pop     eax
        pop     edi
        ret
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;----------------------------------------------------------------
; fat_SetFileInfo - FAT16/32 implementation of setting file info
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_SetFileInfo:
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2
        ret
@@:
        push    edi
        call    fat_lock
        stdcall hd_find_lfn, [esp+4+4]
        jc      .error
        push    eax
        mov     edx, [ebx+16]
        call    bdfe_to_fat_entry
        pop     eax
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        call    update_disk
        call    fat_unlock
        pop     edi
        xor     eax, eax
        ret
.error:
        push    eax
        call    fat_unlock
        pop     eax
        pop     edi
        ret
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
;----------------------------------------------------------------
; fat_Delete - FAT16/32 implementation of deleting a file/folder
; in:  ebp = pointer to FAT structure
; in:  esi+[esp+4] = name
; in:  ebx = pointer to parameters from sysfunc 70
; out: eax, ebx = return values for sysfunc 70
;----------------------------------------------------------------
fat_Delete:
        call    fat_lock
        cmp     byte [esi], 0
        jnz     @f
; cannot delete root!
.access_denied:
        push    ERROR_ACCESS_DENIED
.pop_ret:
        call    fat_unlock
        pop     eax
        xor     ebx, ebx
        ret
@@:
        and     [ebp+FAT.longname_sec1], 0
        and     [ebp+FAT.longname_sec2], 0
        push    edi
        stdcall hd_find_lfn, [esp+4+4]
        jnc     .found
        pop     edi
        push    ERROR_FILE_NOT_FOUND
        jmp     .pop_ret
.found:
        cmp     dword [edi], '.   '
        jz      .access_denied2
        cmp     dword [edi], '..  '
        jz      .access_denied2
        test    byte [edi+11], 10h
        jz      .dodel
; we can delete only empty folders!
        pushad
        mov     esi, [edi+20-2]
        mov     si, [edi+26]
        xor     ecx, ecx
        lea     eax, [esi-2]
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_sys
        test    eax, eax
        jnz     .err1
        lea     eax, [ebx+0x200]
        add     ebx, 2*0x20
.checkempty:
        cmp     byte [ebx], 0
        jz      .empty
        cmp     byte [ebx], 0xE5
        jnz     .notempty
        add     ebx, 0x20
        cmp     ebx, eax
        jb      .checkempty
        inc     ecx
        cmp     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
        jb      @f
        mov     eax, esi
        call    get_FAT
        jc      .err1
        cmp     eax, 2
        jb      .error_fat
        cmp     eax, [ebp+FAT.fatRESERVED]
        jae     .empty
        mov     esi, eax
        xor     ecx, ecx
@@:
        lea     eax, [esi-2]
        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
        add     eax, [ebp+FAT.DATA_START]
        add     eax, ecx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_sys
        test    eax, eax
        lea     eax, [ebx+0x200]
        jz      .checkempty
.err1:
        popad
.err2:
        pop     edi
        call    fat_unlock
        movi    eax, ERROR_DEVICE
        ret
.error_fat:
        popad
        pop     edi
        call    fat_unlock
        movi    eax, ERROR_FAT_TABLE
        ret
.notempty:
        popad
.access_denied2:
        pop     edi
        call    fat_unlock
        movi    eax, ERROR_ACCESS_DENIED
        ret
.empty:
        popad
        push    eax ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_read32_sys
        test    eax, eax
        pop     ebx eax
        jnz     .err2
.dodel:
        push    eax
        mov     eax, [edi+20-2]
        mov     ax, [edi+26]
        xchg    eax, [esp]
; delete folder entry
        mov     byte [edi], 0xE5
; delete LFN (if present)
.lfndel:
        lea     edx, [ebp+FAT.buffer]
        cmp     edi, edx
        ja      @f
        cmp     [ebp+FAT.longname_sec2], 0
        jz      .lfndone
        push    [ebp+FAT.longname_sec2]
        push    [ebp+FAT.longname_sec1]
        pop     [ebp+FAT.longname_sec2]
        and     [ebp+FAT.longname_sec1], 0
        push    ebx
        mov     ebx, edx
        call    fs_write32_sys
        mov     eax, [esp+4]
        call    fs_read32_sys
        pop     ebx
        pop     eax
        lea     edi, [ebp+FAT.buffer+0x200]
@@:
        sub     edi, 0x20
        cmp     byte [edi], 0xE5
        jz      .lfndone
        cmp     byte [edi+11], 0xF
        jnz     .lfndone
        mov     byte [edi], 0xE5
        jmp     .lfndel
.lfndone:
        push    ebx
        lea     ebx, [ebp+FAT.buffer]
        call    fs_write32_sys
        pop     ebx
; delete FAT chain
        pop     eax
        call    clear_cluster_chain
        call    update_disk
        call    fat_unlock
        pop     edi
        xor     eax, eax
        ret
 
; \end{diamond}
>
>

Rev 3725	Rev 3908
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; FAT32.INC ;;	6	;; FAT32.INC ;;
7	;; ;;	7	;; ;;
8	;; FAT16/32 functions for KolibriOS ;;	8	;; FAT16/32 functions for KolibriOS ;;
9	;; ;;	9	;; ;;
10	;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;;	10	;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;;
11	;; ;;	11	;; ;;
12	;; See file COPYING for details ;;	12	;; See file COPYING for details ;;
13	;; 04.02.2007 LFN create folder - diamond ;;	13	;; 04.02.2007 LFN create folder - diamond ;;
14	;; 08.10.2006 LFN delete file/folder - diamond ;;	14	;; 08.10.2006 LFN delete file/folder - diamond ;;
15	;; 20.08.2006 LFN set file size (truncate/extend) - diamond ;;	15	;; 20.08.2006 LFN set file size (truncate/extend) - diamond ;;
16	;; 17.08.2006 LFN write/append to file - diamond ;;	16	;; 17.08.2006 LFN write/append to file - diamond ;;
17	;; 23.06.2006 LFN start application - diamond ;;	17	;; 23.06.2006 LFN start application - diamond ;;
18	;; 15.06.2006 LFN get/set file/folder info - diamond ;;	18	;; 15.06.2006 LFN get/set file/folder info - diamond ;;
19	;; 27.05.2006 LFN create/rewrite file - diamond ;;	19	;; 27.05.2006 LFN create/rewrite file - diamond ;;
20	;; 04.05.2006 LFN read folder - diamond ;;	20	;; 04.05.2006 LFN read folder - diamond ;;
21	;; 29.04.2006 Elimination of hangup after the ;;	21	;; 29.04.2006 Elimination of hangup after the ;;
22	;; expiration hd_wait_timeout - Mario79 ;;	22	;; expiration hd_wait_timeout - Mario79 ;;
23	;; 23.04.2006 LFN read file - diamond ;;	23	;; 23.04.2006 LFN read file - diamond ;;
24	;; 28.01.2006 find all Fat16/32 partition in all input point ;;	24	;; 28.01.2006 find all Fat16/32 partition in all input point ;;
25	;; to MBR, see file part_set.inc - Mario79 ;;	25	;; to MBR, see file part_set.inc - Mario79 ;;
26	;; 15.01.2005 get file size/attr/date, file_append - ATV ;;	26	;; 15.01.2005 get file size/attr/date, file_append - ATV ;;
27	;; 04.12.2004 skip volume label, file delete bug fixed - ATV ;;	27	;; 04.12.2004 skip volume label, file delete bug fixed - ATV ;;
28	;; 29.11.2004 get_free_FAT changed, append dir bug fixed - ATV ;;	28	;; 29.11.2004 get_free_FAT changed, append dir bug fixed - ATV ;;
29	;; 23.11.2004 don't allow overwrite dir with file - ATV ;;	29	;; 23.11.2004 don't allow overwrite dir with file - ATV ;;
30	;; 18.11.2004 get_disk_info and more error codes - ATV ;;	30	;; 18.11.2004 get_disk_info and more error codes - ATV ;;
31	;; 17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV ;;	31	;; 17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV ;;
32	;; 10.11.2004 removedir clear whole directory structure - ATV ;;	32	;; 10.11.2004 removedir clear whole directory structure - ATV ;;
33	;; 08.11.2004 rename - ATV ;;	33	;; 08.11.2004 rename - ATV ;;
34	;; 30.10.2004 file_read return also dirsize in bytes - ATV ;;	34	;; 30.10.2004 file_read return also dirsize in bytes - ATV ;;
35	;; 20.10.2004 Makedir/Removedir - ATV ;;	35	;; 20.10.2004 Makedir/Removedir - ATV ;;
36	;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;;	36	;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;;
37	;; 06.9.2004 Fix free space by Mario79 added - MH ;;	37	;; 06.9.2004 Fix free space by Mario79 added - MH ;;
38	;; 24.5.2004 Write back buffer for File_write -VT ;;	38	;; 24.5.2004 Write back buffer for File_write -VT ;;
39	;; 20.5.2004 File_read function to work with syscall 58 - VT ;;	39	;; 20.5.2004 File_read function to work with syscall 58 - VT ;;
40	;; 30.3.2004 Error parameters at function return - VT ;;	40	;; 30.3.2004 Error parameters at function return - VT ;;
41	;; 01.5.2002 Bugfix in device write - VT ;;	41	;; 01.5.2002 Bugfix in device write - VT ;;
42	;; 20.5.2002 Hd status check - VT ;;	42	;; 20.5.2002 Hd status check - VT ;;
43	;; 29.6.2002 Improved fat32 verification - VT ;;	43	;; 29.6.2002 Improved fat32 verification - VT ;;
44	;; ;;	44	;; ;;
45	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	45	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
46		46
47	$Revision: 3725 $	47	$Revision: 3908 $
48		48
49		49
50	cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00	50	cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00
51		51
52	PUSHAD_EAX equ [esp+28]	52	PUSHAD_EAX equ [esp+28]
53	PUSHAD_ECX equ [esp+24]	53	PUSHAD_ECX equ [esp+24]
54	PUSHAD_EDX equ [esp+20]	54	PUSHAD_EDX equ [esp+20]
55	PUSHAD_EBX equ [esp+16]	55	PUSHAD_EBX equ [esp+16]
56	PUSHAD_EBP equ [esp+8]	56	PUSHAD_EBP equ [esp+8]
57	PUSHAD_ESI equ [esp+4]	57	PUSHAD_ESI equ [esp+4]
58	PUSHAD_EDI equ [esp+0]	58	PUSHAD_EDI equ [esp+0]
59		59
60	; Internal data for every FAT partition.	60	; Internal data for every FAT partition.
61	struct FAT	61	struct FAT PARTITION
62	p PARTITION ; must be the first item	-
63	fs_type db ?	62	fs_type db ?
64	fat16_root db 0 ; flag for fat16 rootdir	63	fat16_root db 0 ; flag for fat16 rootdir
65	fat_change db 0 ; 1=fat has changed	64	fat_change db 0 ; 1=fat has changed
66	db ? ; alignment	65	db ? ; alignment
67	Lock MUTEX ? ; currently operations with one partition	66	Lock MUTEX ? ; currently operations with one partition
68	; can not be executed in parallel since the	67	; can not be executed in parallel since the
69	; legacy code is not ready; this mutex guards	68	; legacy code is not ready; this mutex guards
70	; all operations	69	; all operations
71	SECTORS_PER_FAT dd 0x1f3a	70	SECTORS_PER_FAT dd 0x1f3a
72	NUMBER_OF_FATS dd 0x2	71	NUMBER_OF_FATS dd 0x2
73	SECTORS_PER_CLUSTER dd 0x8	72	SECTORS_PER_CLUSTER dd 0x8
74	BYTES_PER_SECTOR dd 0x200 ; Note: if BPS <> 512 need lots of changes	73	BYTES_PER_SECTOR dd 0x200 ; Note: if BPS <> 512 need lots of changes
75	ROOT_CLUSTER dd 2 ; first rootdir cluster	74	ROOT_CLUSTER dd 2 ; first rootdir cluster
76	FAT_START dd 0 ; start of fat table	75	FAT_START dd 0 ; start of fat table
77	ROOT_START dd 0 ; start of rootdir (only fat16)	76	ROOT_START dd 0 ; start of rootdir (only fat16)
78	ROOT_SECTORS dd 0 ; count of rootdir sectors (only fat16)	77	ROOT_SECTORS dd 0 ; count of rootdir sectors (only fat16)
79	DATA_START dd 0 ; start of data area (=first cluster 2)	78	DATA_START dd 0 ; start of data area (=first cluster 2)
80	LAST_CLUSTER dd 0 ; last availabe cluster	79	LAST_CLUSTER dd 0 ; last availabe cluster
81	ADR_FSINFO dd 0 ; used only by fat32	80	ADR_FSINFO dd 0 ; used only by fat32
82		81
83	fatRESERVED dd 0x0FFFFFF6	82	fatRESERVED dd 0x0FFFFFF6
84	fatBAD dd 0x0FFFFFF7	83	fatBAD dd 0x0FFFFFF7
85	fatEND dd 0x0FFFFFF8	84	fatEND dd 0x0FFFFFF8
86	fatMASK dd 0x0FFFFFFF	85	fatMASK dd 0x0FFFFFFF
87		86
88	fatStartScan dd 2	87	fatStartScan dd 2
89		88
90	cluster_tmp dd 0 ; used by analyze_directory	89	cluster_tmp dd 0 ; used by analyze_directory
91	; and analyze_directory_to_write	90	; and analyze_directory_to_write
92		91
93	longname_sec1 dd 0 ; used by analyze_directory to save 2 previous	92	longname_sec1 dd 0 ; used by analyze_directory to save 2 previous
94	longname_sec2 dd 0 ; directory sectors for delete long filename	93	longname_sec2 dd 0 ; directory sectors for delete long filename
95		94
96	fat_in_cache dd -1	95	fat_in_cache dd -1
97		96
98	fat_cache rb 512	97	fat_cache rb 512
99	buffer rb 512	98	buffer rb 512
100	fsinfo_buffer rb 512	99	fsinfo_buffer rb 512
101	ends	100	ends
102		101
103	uglobal	102	uglobal
104	align 4	103	align 4
105	partition_count dd 0 ; partitions found by set_FAT32_variables	104	partition_count dd 0 ; partitions found by set_FAT32_variables
106		105
107	hd_error dd 0 ; set by wait_for_sector_buffer	106	hd_error dd 0 ; set by wait_for_sector_buffer
108	hd_setup dd 0	107	hd_setup dd 0
109	hd_wait_timeout dd 0	108	hd_wait_timeout dd 0
110		109
111	cache_search_start dd 0 ; used by find_empty_slot	110	cache_search_start dd 0 ; used by find_empty_slot
112	endg	111	endg
113		112
114	uglobal	113	uglobal
115	align 4	114	align 4
116	Sector512: ; label for dev_hdcd.inc	115	Sector512: ; label for dev_hdcd.inc
117	buffer:	116	buffer:
118	times 512 db 0	117	times 512 db 0
119	endg	118	endg
120		119
121	iglobal	120	iglobal
122	align 4	121	align 4
123	fat_user_functions:	122	fat_user_functions:
-		123	dd free
124	dd (fat_user_functions_end - fat_user_functions - 4) / 4	124	dd (fat_user_functions_end - fat_user_functions - 4) / 4
125	dd fat_Read	125	dd fat_Read
126	dd fat_ReadFolder	126	dd fat_ReadFolder
127	dd fat_Rewrite	127	dd fat_Rewrite
128	dd fat_Write	128	dd fat_Write
129	dd fat_SetFileEnd	129	dd fat_SetFileEnd
130	dd fat_GetFileInfo	130	dd fat_GetFileInfo
131	dd fat_SetFileInfo	131	dd fat_SetFileInfo
132	dd 0	132	dd 0
133	dd fat_Delete	133	dd fat_Delete
134	dd fat_CreateFolder	134	dd fat_CreateFolder
135	fat_user_functions_end:	135	fat_user_functions_end:
136	endg	136	endg
137		137
138	; these labels are located before the main function to make	138	; these labels are located before the main function to make
139	; most of jumps to these be short	139	; most of jumps to these be short
140	fat_create_partition.free_return0:	140	fat_create_partition.free_return0:
141	push ebx	-
142	mov eax, ebp	141	mov eax, ebp
143	call free	142	call free
144	pop ebx	-
145	pop ebp	143	pop ebp
146	fat_create_partition.return0:	144	fat_create_partition.return0:
147	xor eax, eax	145	xor eax, eax
148	ret	146	ret
149	fat_create_partition:	147	fat_create_partition:
150	; bootsector must have been successfully read	148	; bootsector must have been successfully read
151	cmp dword [esp+4], 1	149	cmp dword [esp+4], 0
152	jnz .return0	150	jnz .return0
153	; bootsector signature must be correct	151	; bootsector signature must be correct
154	cmp word [ebx+0x1fe], 0xaa55	152	cmp word [ebx+0x1fe], 0xaa55
155	jnz .return0	153	jnz .return0
156	; sectors per cluster must be nonzero	154	; sectors per cluster must be nonzero
157	cmp byte [ebx+0xd], 0	155	cmp byte [ebx+0xd], 0
158	jz .return0	156	jz .return0
159	; bytes per sector must be 0x200	157	; bytes per sector must be 0x200
160	cmp word [ebx+0xb], 0x200	158	cmp word [ebx+0xb], 0x200
161	jnz .return0	159	jnz .return0
162	; number of fats must be nonzero	160	; number of fats must be nonzero
163	cmp byte [ebx+0x10], 0	161	cmp byte [ebx+0x10], 0
164	jz .return0	162	jz .return0
165	; The only reason to be invalid partition now is FAT12. Since the test for	163	; The only reason to be invalid partition now is FAT12. Since the test for
166	; FAT size requires knowledge of some calculated values, which are also used	164	; FAT size requires knowledge of some calculated values, which are also used
167	; in the normal operation, let's hope for the best and allocate data now; if	165	; in the normal operation, let's hope for the best and allocate data now; if
168	; it will prove wrong, just deallocate it.	166	; it will prove wrong, just deallocate it.
169	movi eax, sizeof.FAT	167	movi eax, sizeof.FAT
170	call malloc	168	call malloc
171	test eax, eax	169	test eax, eax
172	jz .return0	170	jz .return0
173	mov ecx, [ebp+8]	171	mov ecx, dword [ebp+PARTITION.FirstSector]
174	mov dword [eax+FAT.p.FirstSector], ecx	172	mov dword [eax+FAT.FirstSector], ecx
175	mov ecx, [ebp+12]	173	mov ecx, dword [ebp+PARTITION.FirstSector+4]
176	mov dword [eax+FAT.p.FirstSector+4], ecx	174	mov dword [eax+FAT.FirstSector+4], ecx
177	mov ecx, [ebp+16]	175	mov ecx, dword [ebp+PARTITION.Length]
178	mov dword [eax+FAT.p.Length], ecx	176	mov dword [eax+FAT.Length], ecx
179	mov ecx, [ebp+20]	177	mov ecx, dword [ebp+PARTITION.Length+4]
180	mov dword [eax+FAT.p.Length+4], ecx	178	mov dword [eax+FAT.Length+4], ecx
-		179	mov ecx, [ebp+PARTITION.Disk]
181	mov [eax+FAT.p.Disk], esi	180	mov [eax+FAT.Disk], ecx
182	mov [eax+FAT.p.FSUserFunctions], fat_user_functions	181	mov [eax+FAT.FSUserFunctions], fat_user_functions
183	or [eax+FAT.fat_in_cache], -1	182	or [eax+FAT.fat_in_cache], -1
184	mov [eax+FAT.fat_change], 0	183	mov [eax+FAT.fat_change], 0
185	push ebp	184	push ebp
186	mov ebp, eax	185	mov ebp, eax
187		186
188	lea ecx, [ebp+FAT.Lock]	187	lea ecx, [ebp+FAT.Lock]
189	call mutex_init	188	call mutex_init
190		189
191	movzx eax, word [ebx+0xe] ; sectors reserved	190	movzx eax, word [ebx+0xe] ; sectors reserved
192	mov [ebp+FAT.FAT_START], eax	191	mov [ebp+FAT.FAT_START], eax
193		192
194	movzx eax, byte [ebx+0xd] ; sectors per cluster	193	movzx eax, byte [ebx+0xd] ; sectors per cluster
195	mov [ebp+FAT.SECTORS_PER_CLUSTER], eax	194	mov [ebp+FAT.SECTORS_PER_CLUSTER], eax
196		195
197	movzx ecx, word [ebx+0xb] ; bytes per sector	196	movzx ecx, word [ebx+0xb] ; bytes per sector
198	mov [ebp+FAT.BYTES_PER_SECTOR], ecx	197	mov [ebp+FAT.BYTES_PER_SECTOR], ecx
199		198
200	movzx eax, word [ebx+0x11] ; count of rootdir entries (=0 fat32)	199	movzx eax, word [ebx+0x11] ; count of rootdir entries (=0 fat32)
201	shl eax, 5 ; mul 32	200	shl eax, 5 ; mul 32
202	dec ecx	201	dec ecx
203	add eax, ecx ; round up if not equal count	202	add eax, ecx ; round up if not equal count
204	inc ecx ; bytes per sector	203	inc ecx ; bytes per sector
205	xor edx, edx	204	xor edx, edx
206	div ecx	205	div ecx
207	mov [ebp+FAT.ROOT_SECTORS], eax ; count of rootdir sectors	206	mov [ebp+FAT.ROOT_SECTORS], eax ; count of rootdir sectors
208		207
209	movzx eax, word [ebx+0x16] ; sectors per fat <65536	208	movzx eax, word [ebx+0x16] ; sectors per fat <65536
210	test eax, eax	209	test eax, eax
211	jnz @f	210	jnz @f
212	mov eax, [ebx+0x24] ; sectors per fat	211	mov eax, [ebx+0x24] ; sectors per fat
213	@@:	212	@@:
214	mov [ebp+FAT.SECTORS_PER_FAT], eax	213	mov [ebp+FAT.SECTORS_PER_FAT], eax
215		214
216	movzx eax, byte [ebx+0x10] ; number of fats	215	movzx eax, byte [ebx+0x10] ; number of fats
217	mov [ebp+FAT.NUMBER_OF_FATS], eax	216	mov [ebp+FAT.NUMBER_OF_FATS], eax
218	imul eax, [ebp+FAT.SECTORS_PER_FAT]	217	imul eax, [ebp+FAT.SECTORS_PER_FAT]
219	add eax, [ebp+FAT.FAT_START]	218	add eax, [ebp+FAT.FAT_START]
220	mov [ebp+FAT.ROOT_START], eax ; rootdir = fat_start + fat_size * fat_count	219	mov [ebp+FAT.ROOT_START], eax ; rootdir = fat_start + fat_size * fat_count
221	add eax, [ebp+FAT.ROOT_SECTORS] ; rootdir sectors should be 0 on fat32	220	add eax, [ebp+FAT.ROOT_SECTORS] ; rootdir sectors should be 0 on fat32
222	mov [ebp+FAT.DATA_START], eax ; data area = rootdir + rootdir_size	221	mov [ebp+FAT.DATA_START], eax ; data area = rootdir + rootdir_size
223		222
224	movzx eax, word [ebx+0x13] ; total sector count <65536	223	movzx eax, word [ebx+0x13] ; total sector count <65536
225	test eax, eax	224	test eax, eax
226	jnz @f	225	jnz @f
227	mov eax, [ebx+0x20] ; total sector count	226	mov eax, [ebx+0x20] ; total sector count
228	@@:	227	@@:
229	mov dword [ebp+FAT.p.Length], eax	228	mov dword [ebp+FAT.Length], eax
230	and dword [ebp+FAT.p.Length+4], 0	229	and dword [ebp+FAT.Length+4], 0
231	sub eax, [ebp+FAT.DATA_START] ; eax = count of data sectors	230	sub eax, [ebp+FAT.DATA_START] ; eax = count of data sectors
232	xor edx, edx	231	xor edx, edx
233	div [ebp+FAT.SECTORS_PER_CLUSTER]	232	div [ebp+FAT.SECTORS_PER_CLUSTER]
234	inc eax	233	inc eax
235	mov [ebp+FAT.LAST_CLUSTER], eax	234	mov [ebp+FAT.LAST_CLUSTER], eax
236	dec eax ; cluster count	235	dec eax ; cluster count
237	mov [ebp+FAT.fatStartScan], 2	236	mov [ebp+FAT.fatStartScan], 2
238		237
239	; limits by Microsoft Hardware White Paper v1.03	238	; limits by Microsoft Hardware White Paper v1.03
240	cmp eax, 4085 ; 0xff5	239	cmp eax, 4085 ; 0xff5
241	jb .free_return0 ; fat12 not supported	240	jb .free_return0 ; fat12 not supported
242	cmp eax, 65525 ; 0xfff5	241	cmp eax, 65525 ; 0xfff5
243	jb .fat16	242	jb .fat16
244	.fat32:	243	.fat32:
245	mov eax, [ebx+0x2c] ; rootdir cluster	244	mov eax, [ebx+0x2c] ; rootdir cluster
246	mov [ebp+FAT.ROOT_CLUSTER], eax	245	mov [ebp+FAT.ROOT_CLUSTER], eax
247	movzx eax, word [ebx+0x30]	246	movzx eax, word [ebx+0x30]
248	mov [ebp+FAT.ADR_FSINFO], eax	247	mov [ebp+FAT.ADR_FSINFO], eax
249	push ebx	248	push ebx
250	add ebx, 512	249	add ebx, 512
251	call fs_read32_sys	250	call fs_read32_sys
252	test eax, eax	251	test eax, eax
253	jnz @f	252	jnz @f
254	mov eax, [ebx+0x1ec]	253	mov eax, [ebx+0x1ec]
255	cmp eax, -1	254	cmp eax, -1
256	jz @f	255	jz @f
257	mov [ebp+FAT.fatStartScan], eax	256	mov [ebp+FAT.fatStartScan], eax
258	@@:	257	@@:
259	pop ebx	258	pop ebx
260	mov [ebp+FAT.fatRESERVED], 0x0FFFFFF6	259	mov [ebp+FAT.fatRESERVED], 0x0FFFFFF6
261	mov [ebp+FAT.fatBAD], 0x0FFFFFF7	260	mov [ebp+FAT.fatBAD], 0x0FFFFFF7
262	mov [ebp+FAT.fatEND], 0x0FFFFFF8	261	mov [ebp+FAT.fatEND], 0x0FFFFFF8
263	mov [ebp+FAT.fatMASK], 0x0FFFFFFF	262	mov [ebp+FAT.fatMASK], 0x0FFFFFFF
264	mov al, 32	263	mov al, 32
265	mov [fs_type], al	-
266	mov [ebp+FAT.fs_type], al	264	mov [ebp+FAT.fs_type], al
267	mov eax, ebp	265	mov eax, ebp
268	pop ebp	266	pop ebp
269	ret	267	ret
270	.fat16:	268	.fat16:
271	and [ebp+FAT.ROOT_CLUSTER], 0	269	and [ebp+FAT.ROOT_CLUSTER], 0
272	mov [ebp+FAT.fatRESERVED], 0x0000FFF6	270	mov [ebp+FAT.fatRESERVED], 0x0000FFF6
273	mov [ebp+FAT.fatBAD], 0x0000FFF7	271	mov [ebp+FAT.fatBAD], 0x0000FFF7
274	mov [ebp+FAT.fatEND], 0x0000FFF8	272	mov [ebp+FAT.fatEND], 0x0000FFF8
275	mov [ebp+FAT.fatMASK], 0x0000FFFF	273	mov [ebp+FAT.fatMASK], 0x0000FFFF
276	mov al, 16	274	mov al, 16
277	mov [fs_type], al	-
278	mov [ebp+FAT.fs_type], al	275	mov [ebp+FAT.fs_type], al
279	mov eax, ebp	276	mov eax, ebp
280	pop ebp	277	pop ebp
281	ret	278	ret
282		279
283	set_FAT:	280	set_FAT:
284	;--------------------------------	281	;--------------------------------
285	; input : EAX = cluster	282	; input : EAX = cluster
286	; EDX = value to save	283	; EDX = value to save
287	; EBP = pointer to FAT structure	284	; EBP = pointer to FAT structure
288	; output : EDX = old value	285	; output : EDX = old value
289	;--------------------------------	286	;--------------------------------
290	; out: CF set <=> error	287	; out: CF set <=> error
291	push eax ebx esi	288	push eax ebx esi
292		289
293	cmp eax, 2	290	cmp eax, 2
294	jb sfc_error	291	jb sfc_error
295	cmp eax, [ebp+FAT.LAST_CLUSTER]	292	cmp eax, [ebp+FAT.LAST_CLUSTER]
296	ja sfc_error	293	ja sfc_error
297	cmp [ebp+FAT.fs_type], 16	294	cmp [ebp+FAT.fs_type], 16
298	je sfc_1	295	je sfc_1
299	add eax, eax	296	add eax, eax
300	sfc_1:	297	sfc_1:
301	add eax, eax	298	add eax, eax
302	mov esi, 511	299	mov esi, 511
303	and esi, eax ; esi = position in fat sector	300	and esi, eax ; esi = position in fat sector
304	shr eax, 9 ; eax = fat sector	301	shr eax, 9 ; eax = fat sector
305	add eax, [ebp+FAT.FAT_START]	302	add eax, [ebp+FAT.FAT_START]
306	lea ebx, [ebp+FAT.fat_cache]	303	lea ebx, [ebp+FAT.fat_cache]
307		304
308	cmp eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?	305	cmp eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
309	je sfc_in_cache ; yes	306	je sfc_in_cache ; yes
310		307
311	cmp [ebp+FAT.fat_change], 0; is fat changed?	308	cmp [ebp+FAT.fat_change], 0; is fat changed?
312	je sfc_no_change ; no	309	je sfc_no_change ; no
313	call write_fat_sector; yes. write it into disk	310	call write_fat_sector; yes. write it into disk
314	jc sfc_error	311	jc sfc_error
315		312
316	sfc_no_change:	313	sfc_no_change:
317	mov [ebp+FAT.fat_in_cache], eax; save fat sector	314	mov [ebp+FAT.fat_in_cache], eax; save fat sector
318	call fs_read32_sys	315	call fs_read32_sys
319	test eax, eax	316	test eax, eax
320	jne sfc_error	317	jne sfc_error
321		318
322		319
323	sfc_in_cache:	320	sfc_in_cache:
324	cmp [ebp+FAT.fs_type], 16	321	cmp [ebp+FAT.fs_type], 16
325	jne sfc_test32	322	jne sfc_test32
326		323
327	sfc_set16:	324	sfc_set16:
328	xchg [ebx+esi], dx ; save new value and get old value	325	xchg [ebx+esi], dx ; save new value and get old value
329	jmp sfc_write	326	jmp sfc_write
330		327
331	sfc_test32:	328	sfc_test32:
332	mov eax, [ebp+FAT.fatMASK]	329	mov eax, [ebp+FAT.fatMASK]
333		330
334	sfc_set32:	331	sfc_set32:
335	and edx, eax	332	and edx, eax
336	xor eax, -1 ; mask for high bits	333	xor eax, -1 ; mask for high bits
337	and eax, [ebx+esi] ; get high 4 bits	334	and eax, [ebx+esi] ; get high 4 bits
338	or eax, edx	335	or eax, edx
339	mov edx, [ebx+esi] ; get old value	336	mov edx, [ebx+esi] ; get old value
340	mov [ebx+esi], eax ; save new value	337	mov [ebx+esi], eax ; save new value
341		338
342	sfc_write:	339	sfc_write:
343	mov [ebp+FAT.fat_change], 1; fat has changed	340	mov [ebp+FAT.fat_change], 1; fat has changed
344		341
345	sfc_nonzero:	342	sfc_nonzero:
346	and edx, [ebp+FAT.fatMASK]	343	and edx, [ebp+FAT.fatMASK]
347		344
348	sfc_return:	345	sfc_return:
349	pop esi ebx eax	346	pop esi ebx eax
350	ret	347	ret
351	sfc_error:	348	sfc_error:
352	stc	349	stc
353	jmp sfc_return	350	jmp sfc_return
354		351
355		352
356	get_FAT:	353	get_FAT:
357	;--------------------------------	354	;--------------------------------
358	; input : EAX = cluster	355	; input : EAX = cluster
359	; EBP = pointer to FAT structure	356	; EBP = pointer to FAT structure
360	; output : EAX = next cluster	357	; output : EAX = next cluster
361	;--------------------------------	358	;--------------------------------
362	; out: CF set <=> error	359	; out: CF set <=> error
363	push ebx esi	360	push ebx esi
364		361
365	cmp [ebp+FAT.fs_type], 16	362	cmp [ebp+FAT.fs_type], 16
366	je gfc_1	363	je gfc_1
367	add eax, eax	364	add eax, eax
368	gfc_1:	365	gfc_1:
369	add eax, eax	366	add eax, eax
370	mov esi, 511	367	mov esi, 511
371	and esi, eax ; esi = position in fat sector	368	and esi, eax ; esi = position in fat sector
372	shr eax, 9 ; eax = fat sector	369	shr eax, 9 ; eax = fat sector
373	add eax, [ebp+FAT.FAT_START]	370	add eax, [ebp+FAT.FAT_START]
374	lea ebx, [ebp+FAT.fat_cache]	371	lea ebx, [ebp+FAT.fat_cache]
375		372
376	cmp eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?	373	cmp eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
377	je gfc_in_cache	374	je gfc_in_cache
378		375
379	cmp [ebp+FAT.fat_change], 0; is fat changed?	376	cmp [ebp+FAT.fat_change], 0; is fat changed?
380	je gfc_no_change ; no	377	je gfc_no_change ; no
381	call write_fat_sector; yes. write it into disk	378	call write_fat_sector; yes. write it into disk
382	jc hd_error_01	379	jc hd_error_01
383		380
384	gfc_no_change:	381	gfc_no_change:
385	mov [ebp+FAT.fat_in_cache], eax	382	mov [ebp+FAT.fat_in_cache], eax
386	call fs_read32_sys	383	call fs_read32_sys
387	test eax, eax	384	test eax, eax
388	jne hd_error_01	385	jne hd_error_01
389		386
390	gfc_in_cache:	387	gfc_in_cache:
391	mov eax, [ebx+esi]	388	mov eax, [ebx+esi]
392	and eax, [ebp+FAT.fatMASK]	389	and eax, [ebp+FAT.fatMASK]
393	gfc_return:	390	gfc_return:
394	pop esi ebx	391	pop esi ebx
395	ret	392	ret
396	hd_error_01:	393	hd_error_01:
397	stc	394	stc
398	jmp gfc_return	395	jmp gfc_return
399		396
400		397
401	get_free_FAT:	398	get_free_FAT:
402	;-----------------------------------------------------------	399	;-----------------------------------------------------------
403	; output : if CARRY=0 EAX = # first cluster found free	400	; output : if CARRY=0 EAX = # first cluster found free
404	; if CARRY=1 disk full	401	; if CARRY=1 disk full
405	; Note : for more speed need to use fat_cache directly	402	; Note : for more speed need to use fat_cache directly
406	;-----------------------------------------------------------	403	;-----------------------------------------------------------
407	push ecx	404	push ecx
408	mov ecx, [ebp+FAT.LAST_CLUSTER]; counter for full disk	405	mov ecx, [ebp+FAT.LAST_CLUSTER]; counter for full disk
409	sub ecx, 2	406	sub ecx, 2
410	mov eax, [ebp+FAT.fatStartScan]	407	mov eax, [ebp+FAT.fatStartScan]
411	cmp eax, 2	408	cmp eax, 2
412	jb gff_reset	409	jb gff_reset
413		410
414	gff_test:	411	gff_test:
415	cmp eax, [ebp+FAT.LAST_CLUSTER]; if above last cluster start at cluster 2	412	cmp eax, [ebp+FAT.LAST_CLUSTER]; if above last cluster start at cluster 2
416	jbe gff_in_range	413	jbe gff_in_range
417	gff_reset:	414	gff_reset:
418	mov eax, 2	415	mov eax, 2
419		416
420	gff_in_range:	417	gff_in_range:
421	push eax	418	push eax
422	call get_FAT ; get cluster state	419	call get_FAT ; get cluster state
423	jc gff_not_found_1	420	jc gff_not_found_1
424		421
425	test eax, eax ; is it free?	422	test eax, eax ; is it free?
426	pop eax	423	pop eax
427	je gff_found ; yes	424	je gff_found ; yes
428	inc eax ; next cluster	425	inc eax ; next cluster
429	dec ecx ; is all checked?	426	dec ecx ; is all checked?
430	jns gff_test ; no	427	jns gff_test ; no
431		428
432	gff_not_found:	429	gff_not_found:
433	pop ecx ; yes. disk is full	430	pop ecx ; yes. disk is full
434	stc	431	stc
435	ret	432	ret
436		433
437	gff_not_found_1:	434	gff_not_found_1:
438	pop eax	435	pop eax
439	jmp gff_not_found	436	jmp gff_not_found
440		437
441	gff_found:	438	gff_found:
442	lea ecx, [eax+1]	439	lea ecx, [eax+1]
443	mov [ebp+FAT.fatStartScan], ecx	440	mov [ebp+FAT.fatStartScan], ecx
444	pop ecx	441	pop ecx
445	clc	442	clc
446	ret	443	ret
447		444
448		445
449	write_fat_sector:	446	write_fat_sector:
450	;-----------------------------------------------------------	447	;-----------------------------------------------------------
451	; write changed fat to disk	448	; write changed fat to disk
452	;-----------------------------------------------------------	449	;-----------------------------------------------------------
453	push eax ebx ecx	450	push eax ebx ecx
454		451
455	mov [ebp+FAT.fat_change], 0	452	mov [ebp+FAT.fat_change], 0
456	mov eax, [ebp+FAT.fat_in_cache]	453	mov eax, [ebp+FAT.fat_in_cache]
457	cmp eax, -1	454	cmp eax, -1
458	jz write_fat_not_used	455	jz write_fat_not_used
459	lea ebx, [ebp+FAT.fat_cache]	456	lea ebx, [ebp+FAT.fat_cache]
460	mov ecx, [ebp+FAT.NUMBER_OF_FATS]	457	mov ecx, [ebp+FAT.NUMBER_OF_FATS]
461		458
462	write_next_fat:	459	write_next_fat:
463	push eax	460	push eax
464	call fs_write32_sys	461	call fs_write32_sys
465	test eax, eax	462	test eax, eax
466	pop eax	463	pop eax
467	jnz write_fat_not_used	464	jnz write_fat_not_used
468		465
469	add eax, [ebp+FAT.SECTORS_PER_FAT]	466	add eax, [ebp+FAT.SECTORS_PER_FAT]
470	dec ecx	467	dec ecx
471	jnz write_next_fat	468	jnz write_next_fat
472		469
473	write_fat_not_used:	470	write_fat_not_used:
474	pop ecx ebx eax	471	pop ecx ebx eax
475	ret	472	ret
476		473
477		474
478		475
479		476
480		477
481	bcd2bin:	478	bcd2bin:
482	;----------------------------------	479	;----------------------------------
483	; input : AL=BCD number (eg. 0x11)	480	; input : AL=BCD number (eg. 0x11)
484	; output : AH=0	481	; output : AH=0
485	; AL=decimal number (eg. 11)	482	; AL=decimal number (eg. 11)
486	;----------------------------------	483	;----------------------------------
487	xor ah, ah	484	xor ah, ah
488	shl ax, 4	485	shl ax, 4
489	shr al, 4	486	shr al, 4
490	aad	487	aad
491	ret	488	ret
492		489
493		490
494	get_date_for_file:	491	get_date_for_file:
495	;-----------------------------------------------------	492	;-----------------------------------------------------
496	; Get date from CMOS and pack day,month,year in AX	493	; Get date from CMOS and pack day,month,year in AX
497	; DATE bits 0..4 : day of month 0..31	494	; DATE bits 0..4 : day of month 0..31
498	; 5..8 : month of year 1..12	495	; 5..8 : month of year 1..12

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/fs/fat32.inc – Rev 3725 → 3908