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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;;  FAT32.INC                                                      ;;
;;                                                                 ;;
;;  FAT16/32 functions for MenuetOS                                ;;
;;                                                                 ;;
;;  Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it          ;;
;;                                                                 ;;
;;  See file COPYING for details                                   ;;
;;  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                    ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
cache_max equ 1919      ; max. is 1919*512+0x610000=0x6ffe00
 
ERROR_SUCCESS        = 0
ERROR_DISK_BASE      = 1
ERROR_UNSUPPORTED_FS = 2
ERROR_UNKNOWN_FS     = 3
ERROR_PARTITION      = 4
ERROR_FILE_NOT_FOUND = 5
ERROR_END_OF_FILE    = 6
ERROR_MEMORY_POINTER = 7
ERROR_DISK_FULL      = 8
ERROR_FAT_TABLE      = 9
ERROR_ACCESS_DENIED  = 10
 
PUSHAD_EAX equ [esp+28]
PUSHAD_ECX equ [esp+24]
PUSHAD_EDX equ [esp+20]
PUSHAD_EBX equ [esp+16]
PUSHAD_EBP equ [esp+8]
PUSHAD_ESI equ [esp+4]
PUSHAD_EDI equ [esp+0]
 
cluster              dd 0       ; used by file_write,makedir,append
partition_count      dd 0       ; partitions found by set_FAT32_variables
longname_sec1        dd 0       ; used by analyze_directory to save 2 previous
longname_sec2        dd 0       ; directory sectors for delete long filename
 
hd_error             dd 0       ; set by wait_for_sector_buffer
hd_setup             dd 0
hd_wait_timeout      dd 0
 
cluster_tmp          dd 0       ; used by analyze_directory
                                ; and analyze_directory_to_write
 
file_size            dd 0       ; used by file_read
 
sector_tmp           dd 0       ; used by rename,append,file_write
entry_pos            dd 0       ; used by rename,append,file_write
 
old_filesize         dd 0       ; used by append
new_filepos          dd 0       ; used by append
bytes2write          dd 0       ; used by append
 
cache_search_start   dd 0       ; used by find_empty_slot
 
fat_in_cache         dd -1
fat_cache:           times 512 db 0
 
uglobal
 Sector512:                      ; label for dev_hdcd.inc
  buffer:              times 512 db 0
  deltree_buffer:      times 512 db 0
endg
 
iglobal
  NewDirEntry1         db ".          ",0x10
                     times 20 db 0
  NewDirEntry2         db "..         ",0x10
                     times 20 db 0
endg
 
uglobal
  dir_entry:           times 32 db 0
 
  startpath:           times 255 db 0
 
  fat16_root           db 0       ; flag for fat16 rootdir
  f_del                db 0       ; 1=overwrite fat entry
  fat_change           db 0       ; 1=fat has changed
 
endg
 
reserve_hd1:
 
    cli
    cmp   [hd1_status],0
    je    reserve_ok1
 
    sti
    call  change_task
    jmp   reserve_hd1
 
  reserve_ok1:
 
    push  eax
    mov   eax,[0x3000]
    shl   eax,5
    mov   eax,[eax+0x3000+4]
    mov   [hd1_status],eax
    pop   eax
    sti
    ret
 
 
clear_hd_cache:
 
    push  eax ecx edi
    mov   edi,0x600000
    mov   ecx,16384
    xor   eax,eax
    cld
    rep   stosd                 ; clear hd cache with 0
    mov   [cache_search_start],eax
    mov   [fat_in_cache],-1
    mov   [fat_change],0
    pop   edi ecx eax
    ret
 
problem_partition db 0  ; used for partitions search 
 
include  'part_set.inc'
 
set_FAT:
;--------------------------------
; input  : EAX = cluster
;          EDX = value to save
; output : EDX = old value
;--------------------------------
    push  eax ebx esi
 
    cmp   eax,2
    jb    sfc_error
    cmp   eax,[LAST_CLUSTER]
    ja    sfc_error
    cmp   [fat_type],16
    je    sfc_1
    add   eax,eax
  sfc_1:
    add   eax,eax
    mov   esi,511
    and   esi,eax               ; esi = position in fat sector
    shr   eax,9                 ; eax = fat sector
    add   eax,[FAT_START]
    mov   ebx,fat_cache
 
    cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
    je    sfc_in_cache          ; yes
 
    cmp   [fat_change],0        ; is fat changed?
    je    sfc_no_change         ; no
    call  write_fat_sector      ; yes. write it into disk
    cmp   [hd_error],0
    jne   sfc_error
 
  sfc_no_change:
    mov   [fat_in_cache],eax    ; save fat sector
    call  hd_read
    cmp  [hd_error],0
    jne  sfc_error
    
 
  sfc_in_cache:
    cmp   [fat_type],16
    jne   sfc_test32
 
    cmp   [f_del],1             ; overwrite previous value?
    je    sfc_set16             ; yes
    cmp   word [ebx+esi],0      ; is cluster free?
    je    sfc_set16             ; yes
    mov   dword [8*0x100000],0xffffff
    mov   edx,[ebx+esi]         ; get old value
    jmp   sfc_nonzero
 
  sfc_set16:
    xchg  [ebx+esi],dx          ; save new value and get old value
    jmp   sfc_write
 
  sfc_test32:
    mov   eax,[fatMASK]
    cmp   [f_del],1             ; overwrite previous value?
    je    sfc_set32             ; yes
    test  eax,[ebx+esi]         ; is cluster free?
    je    sfc_set32             ; yes
    mov   dword [8*0x100000],0xffffff
    mov   edx,[ebx+esi]         ; get old value
    jmp   sfc_nonzero
 
  sfc_set32:
    and   edx,eax
    xor   eax,-1                ; mask for high bits
    and   eax,[ebx+esi]         ; get high 4 bits
    or    eax,edx
    mov   edx,[ebx+esi]         ; get old value
    mov   [ebx+esi],eax         ; save new value
 
  sfc_write:
    mov   [fat_change],1        ; fat has changed
 
  sfc_nonzero:
    and   edx,[fatMASK]
 
  sfc_error:
    pop   esi ebx eax
    ret
 
 
get_FAT:
;--------------------------------
; input  : EAX = cluster
; output : EAX = next cluster
;--------------------------------
    push  ebx esi
 
    cmp   [fat_type],16
    je    gfc_1
    add   eax,eax
  gfc_1:
    add   eax,eax
    mov   esi,511
    and   esi,eax               ; esi = position in fat sector
    shr   eax,9                 ; eax = fat sector
    add   eax,[FAT_START]
    mov   ebx,fat_cache
 
    cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
    je    gfc_in_cache
 
    cmp   [fat_change],0        ; is fat changed?
    je    gfc_no_change         ; no
    call  write_fat_sector      ; yes. write it into disk
    cmp  [hd_error],0
    jne  hd_error_01
 
  gfc_no_change:
    mov   [fat_in_cache],eax
    call  hd_read
    cmp  [hd_error],0
    jne  hd_error_01
 
  gfc_in_cache:
    mov   eax,[ebx+esi]
    and   eax,[fatMASK]
 hd_error_01:
    pop   esi ebx
    ret
 
 
get_free_FAT:
;-----------------------------------------------------------
; input  : EAX = # cluster for start the searching
; output : if CARRY=0 EAX = # first cluster found free
;          if CARRY=1 disk full
; Note   : for more speed need to use fat_cache directly
;-----------------------------------------------------------
    push  ecx
    mov   ecx,[LAST_CLUSTER]    ; counter for full disk
    sub   ecx,2
 
  gff_test:
    cmp   eax,[LAST_CLUSTER]    ; if above last cluster start at cluster 2
    jbe   gff_in_range
    mov   eax,2
 
  gff_in_range:
    push  eax
    call  get_FAT               ; get cluster state
    cmp   [hd_error],0
    jne   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_1:
    add   esp,4
  gff_not_found:
    pop   ecx                   ; yes. disk is full
    stc
    ret
 
  gff_found:
    pop   ecx
    clc
    ret
 
 
write_fat_sector:
;-----------------------------------------------------------
; write changed fat to disk
;-----------------------------------------------------------
    push  eax ebx ecx
 
    mov   [fat_change],0
    mov   eax,[fat_in_cache]
    cmp   eax,-1
    jz    write_fat_not_used
    mov   ebx,fat_cache
    mov   ecx,[NUMBER_OF_FATS]
 
  write_next_fat:
    call  hd_write
    cmp   [hd_error],0
    jne   write_fat_not_used
 
    add   eax,[SECTORS_PER_FAT]
    dec   ecx
    jnz   write_next_fat
 
  write_fat_not_used:
    pop   ecx ebx eax
    ret
 
 
analyze_directory:
;-----------------------------------------------------------
; input  : EAX = first cluster of the directory
;          EBX = pointer to filename
; output : IF CARRY=0 EAX = sector where th file is found
;                     EBX = pointer in buffer
;                     [buffer .. buffer+511]
;                     ECX,EDX,ESI,EDI not changed
;          IF CARRY=1 filename not found
; Note   : if cluster=0 it's changed to read rootdir
;          save 2 previous directory sectors in longname_sec
;-----------------------------------------------------------
    push  ecx edx esi edi ebx   ; ebx = [esp+0]
    mov   [longname_sec1],0
    mov   [longname_sec2],0
 
  adr_new_cluster:
    mov   [cluster_tmp],eax
    mov   [fat16_root],0
    cmp   eax,[LAST_CLUSTER]
    ja    adr_not_found         ; too big cluster number, something is wrong
    cmp   eax,2
    jnb   adr_data_cluster
 
    mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
    cmp   [fat_type],16
    jne   adr_data_cluster
    mov   eax,[ROOT_START]
    mov   edx,[ROOT_SECTORS]
    mov   [fat16_root],1        ; flag for fat16 rootdir
    jmp   adr_new_sector
 
  adr_data_cluster:
    sub   eax,2
    mov   edx,[SECTORS_PER_CLUSTER]
    imul  eax,edx
    add   eax,[DATA_START]
 
  adr_new_sector:
    mov   ebx,buffer
    call  hd_read
    cmp  [hd_error],0
    jne  adr_not_found
 
    mov   ecx,512/32            ; count of dir entrys per sector = 16
 
  adr_analyze:
    mov   edi,[ebx+11]          ; file attribute
    and   edi,0xf
    cmp   edi,0xf
    je    adr_long_filename
    test  edi,0x8               ; skip over volume label
    jne   adr_long_filename     ; Note: label can be same name as file/dir
 
    mov   esi,[esp+0]           ; filename need to be uppercase
    mov   edi,ebx
    push  ecx
    mov   ecx,11
    cld
    rep   cmpsb                 ; compare 8+3 filename
    pop   ecx
    je    adr_found
 
  adr_long_filename:
    add   ebx,32                ; position of next dir entry
    dec   ecx
    jnz   adr_analyze
 
    mov   ecx,[longname_sec1]   ; save 2 previous directory sectors
    mov   [longname_sec1],eax   ; for delete long filename
    mov   [longname_sec2],ecx
    inc   eax                   ; next sector
    dec   edx
    jne   adr_new_sector
    cmp   [fat16_root],1        ; end of fat16 rootdir
    je    adr_not_found
 
  adr_next_cluster:
    mov   eax,[cluster_tmp]
    call  get_FAT               ; get next cluster
    cmp  [hd_error],0
    jne  adr_not_found
 
    cmp   eax,2                 ; incorrect fat chain?
    jb    adr_not_found         ; yes
    cmp   eax,[fatRESERVED]     ; is it end of directory?
    jb    adr_new_cluster       ; no. analyse it
 
  adr_not_found:
    pop   edi edi esi edx ecx   ; first edi will remove ebx
    stc                         ; file not found
    ret
 
  adr_found:
    pop   edi edi esi edx ecx   ; first edi will remove ebx
    clc                         ; file found
    ret
 
 
analyze_directory_to_write:
;-----------------------------------------------------------
; input  : EAX = first cluster of the directory
; output : IF CARRY=0 EAX = sector where the empty pos is found
;                     EBX = pointer in buffer
;                     [buffer .. buffer+511]
;                     ECX,EDX,ESI,EDI not changed
;          IF CARRY=1 disk full or fat corrupted
; Note   : if cluster=0 it's changed to read rootdir
;-----------------------------------------------------------
    push  ecx edx edi
 
  adw_new_cluster:
    mov   [cluster_tmp],eax
    mov   [fat16_root],0
    cmp   eax,[LAST_CLUSTER]
    ja    adw_not_found         ; too big cluster number, something is wrong
    cmp   eax,2
    jnb   adw_data_cluster
 
    mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
    cmp   [fat_type],16
    jne   adw_data_cluster
    mov   eax,[ROOT_START]
    mov   edx,[ROOT_SECTORS]
    mov   [fat16_root],1        ; flag for fat16 rootdir
    jmp   adw_new_sector
 
  adw_data_cluster:
    sub   eax,2
    mov   edx,[SECTORS_PER_CLUSTER]
    imul  eax,edx
    add   eax,[DATA_START]
 
  adw_new_sector:
    mov   ebx,buffer
    call  hd_read
    cmp  [hd_error],0
    jne  adw_not_found
 
    mov   ecx,512/32            ; count of dir entrys per sector = 16
 
  adw_analyze:
    cmp   byte [ebx],0x00       ; is free entry?
    je    adw_found             ; yes
    cmp   byte [ebx],0xe5       ; is deleted entry?
    je    adw_found             ; yes
    add   ebx,32                ; position of next dir entry
    dec   ecx
    jnz   adw_analyze
 
    inc   eax                   ; next sector
    dec   edx
    jne   adw_new_sector
    cmp   [fat16_root],1        ; end of fat16 rootdir
    je    adw_not_found
 
    mov   eax,[cluster_tmp]
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   adw_not_found
 
    cmp   eax,2                 ; incorrect fat chain?
    jb    adw_not_found         ; yes
    cmp   eax,[fatRESERVED]     ; is it end of directory?
    jb    adw_new_cluster       ; no. analyse it
 
    mov   eax,2                 ; this block of code add a new cluster
    call  get_free_FAT          ; for the directory because the directory
    jc    adw_not_found         ; is full
 
    mov   edx,[fatEND]          ; new end for directory
    call  set_FAT
    cmp  [hd_error],0
    jne  adw_not_found
 
    push  eax                   ; save new cluster
    mov   edx,eax
    mov   eax,[cluster_tmp]     ; change last cluster to point new cluster
    mov   [f_del],1
    call  set_FAT
    cmp  [hd_error],0
    jne  adw_not_found_1
 
    mov   [f_del],0
 
    mov   ecx,-1                ; remove 1 cluster from free disk space
    call  add_disk_free_space
    cmp  [hd_error],0
    jne    adw_not_found_1
 
    mov   ecx,512/4
    xor   eax,eax
    mov   edi,buffer
    cld
    rep   stosd                 ; clear new directory cluster
    pop   eax
 
    sub   eax,2
    mov   ecx,[SECTORS_PER_CLUSTER]
    imul  eax,ecx
    add   eax,[DATA_START]
    mov   ebx,buffer
    push  eax                   ; save sector number
 
  adw_set_empty_directory:
    call  hd_write
    cmp   [hd_error],0
    jne   adw_not_found_1
 
    inc   eax                   ; next sector
    dec   ecx
    jnz   adw_set_empty_directory
 
    pop   eax
 
  adw_found:
    pop   edi edx ecx
    clc                         ; free space found
    ret
  adw_not_found_1:
    add  esp,4
  adw_not_found:
    pop   edi edx ecx
    stc                         ; free space not found
    ret
 
 
get_data_cluster:
;-----------------------------------------------------------
; input  : EAX = cluster
;          EBX = pointer to buffer
;          EDX = # blocks to read in buffer
;          ESI = # blocks to skip over
; output : if CARRY=0 ok EBX/EDX/ESI updated
;          if CARRY=1 cluster out of range
; Note   : if cluster=0 it's changed to read rootdir
;-----------------------------------------------------------
    push  eax ecx
 
    mov   [fat16_root],0
    cmp   eax,[LAST_CLUSTER]
    ja    gdc_error             ; too big cluster number, something is wrong
    cmp   eax,2
    jnb   gdc_cluster
 
    mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
    cmp   [fat_type],16
    jne   gdc_cluster
    mov   eax,[ROOT_START]
    mov   ecx,[ROOT_SECTORS]    ; Note: not cluster size
    mov   [fat16_root],1        ; flag for fat16 rootdir
    jmp   gdc_read
 
  gdc_cluster:
    sub   eax,2
    mov   ecx,[SECTORS_PER_CLUSTER]
    imul  eax,ecx
    add   eax,[DATA_START]
 
  gdc_read:
    test  esi,esi               ; first wanted block
    je    gdcl1                 ; yes, skip count is 0
    dec   esi
    jmp   gdcl2
 
  gdcl1:
    call  hd_read
    cmp  [hd_error],0
    jne  gdc_error    
 
    add   ebx,512               ; update pointer
    dec   edx
 
  gdcl2:
    test  edx,edx               ; is all read?
    je    out_of_read
 
    inc   eax                   ; next sector
    dec   ecx
    jnz   gdc_read
 
  out_of_read:
    pop   ecx eax
    clc
    ret
 
  gdc_error:
    pop   ecx eax
    stc
    ret
 
 
set_data_cluster:
;-----------------------------------------------------------
; input  : EAX = cluster
;          EBX = pointer to buffer
; output : if CARRY=0 ok
;          if CARRY=1 cluster out of range
;-----------------------------------------------------------
    push  eax ebx edx
 
    cmp   eax,[LAST_CLUSTER]
    ja    sdc_error             ; too big cluster number, something is wrong
    sub   eax,2
    jb    sdc_error             ; don't allow rootdir write
 
    mov   edx,[SECTORS_PER_CLUSTER]
    imul  eax,edx
    add   eax,[DATA_START]
 
  sdc_write:
    call  hd_write
    cmp   [hd_error],0
    jne   sdc_error
 
    add   ebx,512               ; update pointer
    inc   eax
    dec   edx
    jnz   sdc_write
    pop   edx ebx eax
    clc
    ret
 
  sdc_error:
    pop   edx ebx eax
    stc
    ret
 
 
get_cluster_of_a_path:
;---------------------------------------------------------
; input  : EBX = pointer to a path string
;          (example: the path "/files/data/document" become
;                             "files......data.......document...0"
;          '.' = space char
;          '0' = char(0) (ASCII=0) !!! )
; output : if (CARRY=1) -> ERROR in the PATH
;          if (CARRY=0) -> EAX=cluster
;---------------------------------------------------------
    push  ebx edx
 
    mov   eax,[ROOT_CLUSTER]
    mov   edx,ebx
 
search_end_of_path:
    cmp   byte [edx],0
    je    found_end_of_path
 
    inc   edx ; '/'
    mov   ebx,edx
    call  analyze_directory
    jc    directory_not_found
 
    mov   eax,[ebx+20-2]        ; read the HIGH 16bit cluster field
    mov   ax,[ebx+26]           ; read the LOW 16bit cluster field
    and   eax,[fatMASK]
    add   edx,11                ; 8+3 (name+extension)
    jmp   search_end_of_path
 
found_end_of_path:
    pop   edx ebx
    clc                         ; no errors
    ret
 
directory_not_found:
    pop   edx ebx
    stc                         ; errors occour
    ret
 
 
bcd2bin:
;----------------------------------
; input  : AL=BCD number (eg. 0x11)
; output : AH=0
;          AL=decimal number (eg. 11)
;----------------------------------
    xor   ah,ah
    shl   ax,4
    shr   al,4
    aad
    ret
 
 
get_date_for_file:
;-----------------------------------------------------
; Get date from CMOS and pack day,month,year in AX
; DATE   bits  0..4   : day of month 0..31
;              5..8   : month of year 1..12
;              9..15  : count of years from 1980
;-----------------------------------------------------
    mov   al,0x7        ;day
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    ror   eax,5
 
    mov   al,0x8        ;month
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    ror   eax,4
 
    mov   al,0x9        ;year
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    add   ax,20         ;because CMOS return only the two last
                        ;digit (eg. 2000 -> 00 , 2001 -> 01) and we
    rol   eax,9         ;need the difference with 1980 (eg. 2001-1980)
    ret
 
 
get_time_for_file:
;-----------------------------------------------------
; Get time from CMOS and pack hour,minute,second in AX
; TIME   bits  0..4   : second (the low bit is lost)
;              5..10  : minute 0..59
;              11..15 : hour 0..23
;-----------------------------------------------------
    mov   al,0x0        ;second
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    ror   eax,6
 
    mov   al,0x2        ;minute
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    ror   eax,6
 
    mov   al,0x4        ;hour
    out   0x70,al
    in    al,0x71
    call  bcd2bin
    rol   eax,11
    ret
 
 
set_current_time_for_entry:
;-----------------------------------------------------
; Set current time/date for file entry
; input  : ebx = file entry pointer
;-----------------------------------------------------
    push  eax
    call  get_time_for_file     ; update files date/time
    mov   [ebx+22],ax
    call  get_date_for_file
    mov   [ebx+24],ax
    pop   eax
    ret
 
 
makedir:
;-----------------------------------------------------
; input  : eax = directory name
;          edx = path
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;                8 - disk full
;               10 - access denied
; Note   : can only make one directory at time
;-----------------------------------------------------
    cmp   [fat_type],0
    jnz   make_dir_fat_ok
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  make_dir_fat_ok:
;    call  reserve_hd1
 
    pushad
 
    mov   ebx,edx
    call  get_cluster_of_a_path
    jnc   make_dir_found_path
    cmp   [hd_error],0
    jne   make_dir_error_1
 
  make_dir_path_not_found:
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   make_dir_error_2
 
    mov   [hd1_status],0
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  make_dir_disk_full:
    cmp  [hd_error],0
    jne   make_dir_error_1
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   make_dir_error_2
 
    mov   [hd1_status],0
    mov   eax,ERROR_DISK_FULL
    ret
 
  make_dir_already_exist:
    cmp  [hd_error],0
    jne   make_dir_error_1    
    mov   eax,[cluster]         ; directory cluster
    xor   edx,edx               ; free
    mov   [f_del],1
    call  set_FAT
    cmp  [hd_error],0
    jne   make_dir_error_1
 
    mov   [f_del],0
 
    popad
    call  update_disk           ; write all of cache and fat to hd
  make_dir_error_2:
    mov   [hd1_status],0
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
  make_dir_error_1:
    popad
    jmp   make_dir_error_2
 
  make_dir_error_3:
    add  esp,4
    jmp   make_dir_error_1
 
  make_dir_found_path:
    cmp   eax,[ROOT_CLUSTER]
    jnz   make_dir_not_root
    xor   eax,eax
 
  make_dir_not_root:
    mov   ecx,eax               ; directorys start cluster
    mov   word [NewDirEntry2+26],cx ; 16 bits low of cluster
    shr   ecx,16
    mov   word [NewDirEntry2+20],cx ; 16 bits high of cluster (=0 fat16)
 
    push  eax                   ; save parent directory cluster
    mov   eax,2
    call  get_free_FAT
    mov   [cluster],eax         ; first free cluster
    pop   eax
    jc    make_dir_disk_full
 
    push  eax
    mov   eax,[cluster]         ; directory cluster
    mov   edx,[fatEND]          ; end for directory
    call  set_FAT
    cmp  [hd_error],0
    jne   make_dir_error_3
    pop   eax
 
    mov   ebx,PUSHAD_EAX        ; dir name
    push  eax
    call  analyze_directory     ; check if directory already exist
    cmp   [hd_error],0
    jne   make_dir_error_1
 
    pop   eax
    jnc   make_dir_already_exist ; need to free allocated cluster!
 
    call  analyze_directory_to_write
    jc    make_dir_already_exist ; need to free allocated cluster!
 
    mov   esi,PUSHAD_EAX        ; dir name
    mov   edi,ebx               ; pointer in buffer
    mov   ecx,11
    cld
    rep   movsb
 
    mov   dword [ebx+28],0      ; dir size is always 0
    mov   ecx,[cluster]
    mov   [ebx+26],cx           ; 16 bits low of cluster
    mov   word [NewDirEntry1+26],cx
    shr   ecx,16
    mov   [ebx+20],cx           ; 16 bits high of cluster (=0 fat16)
    mov   word [NewDirEntry1+20],cx
    mov   byte [ebx+11],0x10    ; attribute = directory
 
    call  set_current_time_for_entry
    mov   ecx,[ebx+22]
    mov   dword [NewDirEntry1+22],ecx
    mov   dword [NewDirEntry2+22],ecx
 
    mov   ebx,buffer            ; save the directory name,length,cluster
    call  hd_write
    cmp   [hd_error],0
    jne   make_dir_error_1
 
    mov   ecx,512/4
    xor   eax,eax
    mov   edi,buffer
    cld
    rep   stosd                 ; clear new directory cluster
 
    mov   eax,[cluster]         ; new directory cluster
    sub   eax,2
    mov   edx,[SECTORS_PER_CLUSTER]
    imul  eax,edx
    add   eax,[DATA_START]
    mov   ebx,buffer
    add   eax,edx               ; start from last sector
 
  dir_set_empty_directory:
    dec   eax                   ; next sector
    cmp   edx,1                 ; is first directory sector?
    jnz   not_first_sector      ; no. write empty sector
    mov   esi,NewDirEntry1
    mov   edi,buffer
    mov   ecx,64/4
    cld
    rep   movsd                 ; copy 2 first directory entrys "." and ".."
 
  not_first_sector:
    call  hd_write
    cmp   [hd_error],0
    jne   make_dir_error_1
  
    dec   edx
    jnz   dir_set_empty_directory
 
    mov   ecx,-1                ; remove 1 cluster from free disk space
    call  add_disk_free_space
    cmp  [hd_error],0
    jne   make_dir_error_1
 
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   make_dir_error_2
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
 
removedir:
;-----------------------------------------------------
; input  : eax = file/directory name
;          edx = path
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;               10 - access denied
;-----------------------------------------------------
    cmp   [fat_type],0
    jnz   remove_dir_fat_ok
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  remove_dir_fat_ok:
;    call  reserve_hd1
 
    push  edi
    mov   edi,1                 ; allow directory remove
    call  file_delete
    cmp   [hd_error],0
    jne   @f
 
    pop   edi
 
    call  update_disk           ; write all of cache and fat to hd
  @@:
    mov   [hd1_status],0
    ret
   
 
add_disk_free_space:
;-----------------------------------------------------
; input  : ecx = cluster count
; Note   : negative = remove clusters from free space
;          positive = add clusters to free space
;-----------------------------------------------------
    test  ecx,ecx               ; no change
    je    add_dfs_no
    cmp   [fat_type],32         ; free disk space only used by fat32
    jne   add_dfs_no
 
    push  eax ebx
    mov   eax,[ADR_FSINFO]
    mov   ebx,buffer
    call  hd_read
    cmp  [hd_error],0
    jne  add_not_fs
 
    cmp   dword [ebx+0x1fc],0xaa550000 ; check sector id
    jne   add_not_fs
 
    add   [ebx+0x1e8],ecx
    call  hd_write
    cmp   [hd_error],0
    jne   add_not_fs
 
  add_not_fs:
    pop   ebx eax
 
  add_dfs_no:
    ret
 
 
file_append:
;-----------------------------------------------------
; input  : eax = file name
;          edx = path
;          ecx = pointer to buffer
;          ebx = bytes to write (0 = truncate file)
;          esi = start position (-1 = end of file)
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;                6 - end of file
;                8 - disk full
;                9 - fat table corrupted
;               10 - access denied
;          ebx = bytes written
;-----------------------------------------------------
    cmp   [fat_type],0
    jnz   append_fat_ok
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  append_fat_ok:
;    call  reserve_hd1
 
    pushad
 
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    append_not_found
 
    mov   ebx,PUSHAD_EAX        ; file name
    call  analyze_directory
    jc    append_not_found
 
    mov   [sector_tmp],eax
    mov   [entry_pos],ebx
 
    test  byte [ebx+11],0x10    ; is it directory?
    jnz   append_access         ; yes
 
    mov   ecx,[ebx+28]          ; file size
    mov   edi,PUSHAD_ESI        ; write position
    cmp   edi,-1                ; -1 = eof
    jnz   append_inside_file
    mov   edi,ecx               ; file size
 
  append_inside_file:
    cmp   edi,ecx               ; start above old file size?
    ja    append_eof            ; yes
 
    mov   [old_filesize],ecx
    mov   [new_filepos],edi
 
    mov   ecx,PUSHAD_EBX        ; bytes to write
    test  ecx,ecx               ; truncate?
    jz    append_truncate       ; yes
 
    mov   [bytes2write],ecx     ; bytes to write
    mov   esi,PUSHAD_ECX        ; pointer to buffer
    mov   eax,[ebx+20-2]        ; FAT entry
    mov   ax,[ebx+26]
    and   eax,[fatMASK]
    jnz   append_find_pos       ; first cluster <> 0
 
    mov   eax,2
    call  get_free_FAT
    jc    append_disk_full
    mov   ecx,eax               ; set files first cluster
    mov   [ebx+26],cx           ; 16 bits low of cluster
    shr   ecx,16
    mov   [ebx+20],cx           ; 16 bits high of cluster (=0 fat16)
    mov   edx,[fatEND]          ; new end for cluster chain
    call  set_FAT
    cmp  [hd_error],0
    jne   append_access
 
    push  eax                   ; save first cluster
    mov   eax,[sector_tmp]
    mov   ebx,buffer
    call  hd_write              ; write new file entry back to disk
    cmp   [hd_error],0
    jne   append_access_1
 
    pop   eax
 
  append_remove_free:
    mov   ecx,-1                ; remove 1 cluster from free disk space
    call  add_disk_free_space   ; Note: uses buffer
    cmp  [hd_error],0
    jne   append_access
 
  append_found_cluster:
    mov   [cluster],eax
    sub   eax,2
    mov   ecx,[SECTORS_PER_CLUSTER]
    imul  eax,ecx
    add   eax,[DATA_START]
    xor   edi,edi
 
  append_new_sector:
    cmp   [hd_error],0
    jne   append_access    
    push  ecx
    mov   ecx,[bytes2write]     ; bytes left in buffer
    mov   ebx,512
    sub   ebx,edi               ; bytes left in sector
    cmp   ecx,ebx
    jb    append_bytes_ok
    mov   ecx,ebx
 
  append_bytes_ok:
    cmp   ecx,512               ; overwrite full sector?
    jz    append_full_sector    ; yes
    mov   ebx,buffer            ; overwrite part of sector
    call  hd_read               ; read old sector
    cmp  [hd_error],0
    jne  append_access_1
 
  append_full_sector:
    sub   [bytes2write],ecx
    add   [new_filepos],ecx
    add   edi,buffer
    cld
    rep   movsb
    pop   ecx
 
    mov   ebx,buffer
    call  hd_write
    cmp   [hd_error],0
    jne   append_access
 
    cmp   [bytes2write],0       ; is all done?
    jz    append_done
    xor   edi,edi
    inc   eax
    dec   ecx
    jnz   append_new_sector
 
    mov   eax,[cluster]
    call  get_FAT
    cmp   [hd_error],0
    jne   append_access
 
    cmp   eax,2
    jb    append_fat
    cmp   eax,[LAST_CLUSTER]
    jbe   append_found_cluster
 
  append_alloc_cluster:
    mov   eax,2                 ; ToDo: use temp array to keep track
    call  get_free_FAT          ;       of last free cluster
    jc    append_disk_full
    push  eax                   ; save new cluster
    mov   edx,[fatEND]          ; new end for cluster chain
    call  set_FAT
    cmp  [hd_error],0
    jne  append_access_1
      
    mov   edx,eax
    mov   eax,[cluster]
    mov   [f_del],1
    call  set_FAT               ; update previous cluster
    cmp  [hd_error],0
    jne  append_access_1
 
    mov   [f_del],0
    pop   eax
    jmp   append_remove_free
 
  append_find_pos:
    call  find_filepos
    mov   [cluster],ebx
    jnc   append_new_sector
    test  edi,edi
    jz    append_alloc_cluster
 
  append_fat:
    mov   eax,ERROR_FAT_TABLE
    jmp   append_ret_code
                        
  append_disk_full:
    cmp  [hd_error],0
    jne  append_access
    mov   eax,ERROR_DISK_FULL
    jmp   append_ret_code
 
  append_done:
    xor   eax,eax
 
  append_ret_code:
    mov   PUSHAD_EAX,eax        ; return code
 
    mov   eax,[sector_tmp]      ; update directory entry
    mov   ebx,buffer
    call  hd_read
    cmp  [hd_error],0
    jne  append_access
     
    mov   ebx,[entry_pos]
    mov   ecx,[new_filepos]
    cmp   ecx,[old_filesize]    ; is file pos above old size?
    jbe   append_size_ok        ; no
    mov   [ebx+28],ecx          ; new file size
 
  append_size_ok:
    call  set_current_time_for_entry
    mov   ebx,buffer
    call  hd_write              ; write new file entry back to disk
    cmp   [hd_error],0
    jne   append_access
 
    sub   ecx,PUSHAD_ESI        ; start position
    mov   PUSHAD_EBX,ecx        ; bytes written
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   append_access_2
 
    mov   [hd1_status],0
    ret
 
  append_eof:
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_END_OF_FILE
    ret
 
  append_not_found:
    cmp  [hd_error],0
    jne   append_access
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_FILE_NOT_FOUND
    ret        
  append_access_1:
    add   esp,4
  append_access:
    popad
  append_access_2:
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
  append_truncate:
    mov   edx,[ebx+20-2]        ; FAT entry
    mov   dx,[ebx+26]
    and   edx,[fatMASK]
    mov   [ebx+28],edi          ; set new file size
    test  edi,edi               ; 0 length file?
    jnz   truncate_save_size    ; no
    mov   [ebx+20],di           ; FAT entry = 0
    mov   [ebx+26],di
 
  truncate_save_size:
    call  set_current_time_for_entry
    mov   ebx,buffer
    call  hd_write
    cmp   [hd_error],0
    jne   append_access
 
    mov   eax,edx               ; first cluster
    test  edi,edi               ; 0 length file?
    jz    truncate_clear_chain
 
    imul  esi,[SECTORS_PER_CLUSTER],512 ; esi = cluster size in bytes
 
  truncate_new_cluster:
    cmp   eax,2                 ; incorrect fat chain?
    jb    truncate_eof          ; yes
    cmp   eax,[fatRESERVED]     ; is it end of file?
    jnb   truncate_eof          ; yes
    sub   edi,esi
    jbe   truncate_pos_found
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   append_access
 
    jmp   truncate_new_cluster
 
  truncate_pos_found:
    mov   edx,[fatEND]          ; new end for cluster chain
    mov   [f_del],1
    call  set_FAT
    cmp  [hd_error],0
    jne  append_access
 
    mov   [f_del],0
    mov   eax,edx               ; clear rest of chain
 
  truncate_clear_chain:
    call  clear_cluster_chain
    cmp  [hd_error],0
    jne  append_access
 
  truncate_eof:
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   append_access_2
 
    mov   [hd1_status],0
    xor   ebx,ebx
    xor   eax,eax
    ret
 
 
find_filepos:
;-----------------------------------------------------
; input  : eax = first cluster
;          edi = bytes to skip over (start position)
; output : if CARRY=0 file position found
;          if CARRY=1 end of file found
;          eax = current file sector
;          ebx = last cluster
;          ecx = sector count in last cluster
;          edi = bytes to skip over (sector position)
;-----------------------------------------------------
    push  esi
    mov   ecx,[SECTORS_PER_CLUSTER]
    imul  esi,ecx,512           ; esi = cluster size in bytes
    mov   ebx,eax
 
  filepos_new_cluster:
    cmp   eax,2                 ; incorrect fat chain?
    jb    filepos_eof           ; yes
    cmp   eax,[fatRESERVED]     ; is it end of file?
    jnb   filepos_eof           ; yes
 
    mov   ebx,eax
    cmp   edi,esi               ; skip over full cluster?
    jb    filepos_cluster_ok    ; no
 
    sub   edi,esi
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   filepos_eof
 
    jmp   filepos_new_cluster
 
  filepos_cluster_ok:
    sub   eax,2
    imul  eax,ecx
    add   eax,[DATA_START]
 
  filepos_new_sector:
    cmp   edi,512               ; skip over full sector?
    jb    filepos_sector_ok     ; no
    sub   edi,512
    inc   eax
    dec   ecx
    jnz   filepos_new_sector
 
  filepos_eof:
    pop   esi
    stc
    ret
 
  filepos_sector_ok:
    pop   esi
    clc
    ret
 
 
file_write:
;--------------------------------------------------------------------------
;   INPUT : user-reg  register-in-this  meaning      symbol-in-this-routine
;
;            EAX        EDI            system call to write    /
;            EBX        EAX   (PAR0)   pointer to file-name    PAR0
;            EDX        ECX   (PAR1)   pointer to buffer       PAR1
;            ECX        EBX   (PAR2)   file size               PAR2
;            ESI        EDX   (PAR3)   pointer to path         PAR3
;
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;                8 - disk full
;               10 - access denied
;--------------------------------------------------------------------------
    cmp   [fat_type],0
    jnz   fat_ok_for_writing
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  fat_ok_for_writing:
;    call  reserve_hd1
 
    pushad
 
    xor   edi,edi               ; don't allow directory remove
    call  file_delete           ; try to delete the file first
    cmp   [hd_error],0
    jne   exit_write_access_1
 
    test  eax,eax
    jz    old_deleted           ; deleted ok
    cmp   eax,ERROR_FILE_NOT_FOUND
    jnz   exit_write_access     ; it exist but can't delete
 
  old_deleted:
    mov   ebx,PUSHAD_EDX
    call  get_cluster_of_a_path
    jnc   found_directory_for_writing
    cmp   [hd_error],0
    jne   exit_write_access
 
  exit_writing_with_error:
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   exit_write_access_2
 
    mov   [hd1_status],0
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  exit_writing_disk_full_clear:
    cmp  [hd_error],0
    jne  exit_write_access_1
    mov   eax,[sector_tmp]
    mov   ebx,buffer
    call  hd_read               ; read directory sector
    cmp  [hd_error],0
    jne  exit_write_access_1
 
    mov   edx,[entry_pos]
    mov   byte [edx],0xe5       ; mark as deleted
    call  hd_write
    cmp   [hd_error],0
    jne   exit_write_access_1
 
    mov   eax,[edx+20-2]        ; FAT entry
    mov   ax,[edx+26]
    and   eax,[fatMASK]
    call  clear_cluster_chain
 
  exit_writing_disk_full:
    cmp  [hd_error],0
    jne  exit_write_access_1
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   exit_write_access_2
    mov   [hd1_status],0
    mov   eax,ERROR_DISK_FULL
    ret
 
  exit_write_access:
    popad
    call  update_disk           ; write all of cache and fat to hd
    mov   [hd1_status],0
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
  exit_write_access_1:
    popad
  exit_write_access_2:
    mov   [hd1_status],0
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
found_directory_for_writing:
    call  analyze_directory_to_write
    jc    exit_writing_disk_full
 
    mov   [sector_tmp],eax
    mov   [entry_pos],ebx
    push  eax                   ; save directory sector
    mov   eax,2
    call  get_free_FAT
    mov   [cluster],eax         ; first free cluster
    pop   eax
    jc    exit_writing_disk_full
 
    mov   esi,PUSHAD_EAX        ; file name
    mov   edi,ebx               ; pointer in buffer
    mov   ecx,11
    cld
    rep   movsb
 
    mov   esi,PUSHAD_EBX        ; file size (bytes left)
    mov   [ebx+28],esi          ; file size
    mov   ecx,[cluster]
    mov   [ebx+26],cx           ; 16 bits low of cluster
    shr   ecx,16
    mov   [ebx+20],cx           ; 16 bits high of cluster (=0 fat16)
    mov   byte [ebx+11],0x20    ; attribute = archive
 
    call  set_current_time_for_entry
 
    mov   ebx,buffer            ; save the directory name,length,cluster
    call  hd_write
    cmp   [hd_error],0
    jne   exit_write_access_1
 
    imul  edi,[SECTORS_PER_CLUSTER],512 ; edi = cluster size in bytes
    xor   ecx,ecx               ; cluster count
    mov   ebx,PUSHAD_ECX        ; ebx = buffer
 
hd_new_block_write:
 
    mov   eax,[cluster]         ; eax = block
    call  set_data_cluster
    cmp   [hd_error],0
    jne   exit_write_access_1
 
    sub   esi,edi               ; sub wrote bytes
    jbe   file_saved_OK         ; end if all done
    add   ebx,edi               ; update buffer position
 
    inc   eax
    call  get_free_FAT          ; next free in FAT
    jc    exit_writing_disk_full_clear
 
    mov   edx,eax
    xchg  eax,[cluster]         ; get old cluster and save new cluster
    call  set_FAT               ; add it in cluster chain
    cmp  [hd_error],0
    jne   exit_write_access_1
 
    dec   ecx                   ; update cluster count
    jmp   hd_new_block_write
 
file_saved_OK:
 
    mov   edx,[fatEND]          ; new end for cluster chain
    call  set_FAT
    cmp  [hd_error],0
    jne   exit_write_access_1
 
    dec   ecx                   ; update cluster count
 
    call  add_disk_free_space   ; remove clusters from free disk space
    cmp  [hd_error],0
    jne   exit_write_access_1
 
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   exit_write_access_2
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
 
file_read:
;--------------------------------------------------------------------------
;   INPUT :  user-register register-in-this  meaning         symbol-in-this
;
;            EAX           EDI               system call to write   /
;            EBX           EAX   (PAR0)      pointer to file-name   PAR0
;            EDX           ECX   (PAR1)      pointer to buffer      PAR1
;            ECX           EBX   (PAR2)   vt file blocks to read    PAR2
;            ESI           EDX   (PAR3)      pointer to path        PAR3
;            EDI           ESI            vt first 512 block to read
;                          EDI               if 0 - read root
;
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;                6 - end of file
;                9 - fat table corrupted
;               10 - access denied
;          ebx = size of file/directory
;--------------------------------------------------------------------------
    cmp   [fat_type],0
    jnz   fat_ok_for_reading
    xor   ebx,ebx
    mov   eax,ERROR_UNKNOWN_FS
    mov   [hd1_status], ebx
    ret
 
  fat_ok_for_reading:
;    call  reserve_hd1
 
    pushad
 
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    file_to_read_not_found
 
    test  edi,edi               ; read rootdir
    jne   no_read_root
 
    xor   eax,eax
    call  get_dir_size          ; return rootdir size
    cmp   [hd_error],0
    jne   file_access_denied
 
    mov   [file_size],eax
    mov   eax,[ROOT_CLUSTER]
    jmp   file_read_start
 
  no_read_root:
    mov   ebx,PUSHAD_EAX        ; file name
    call  analyze_directory
    jc    file_to_read_not_found
 
    mov   eax,[ebx+28]          ; file size
    test  byte [ebx+11],0x10    ; is it directory?
    jz    read_set_size         ; no
 
    mov   eax,[ebx+20-2]        ; FAT entry
    mov   ax,[ebx+26]
    and   eax,[fatMASK]
    call  get_dir_size
    cmp   [hd_error],0
    jne   file_access_denied
 
  read_set_size:
    mov   [file_size],eax
 
    mov   eax,[ebx+20-2]        ; FAT entry
    mov   ax,[ebx+26]
    and   eax,[fatMASK]
 
  file_read_start:
    mov   ebx,PUSHAD_ECX        ; pointer to buffer
    mov   edx,PUSHAD_EBX        ; file blocks to read
    mov   esi,PUSHAD_ESI        ; first 512 block to read
 
  file_read_new_cluster:
    call  get_data_cluster
    jc    file_read_eof         ; end of file or cluster out of range
 
    test  edx,edx               ; is all read?
    je    file_read_OK          ; yes
 
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   file_access_denied
 
    cmp   eax,[fatRESERVED]     ; end of file
    jnb   file_read_eof
    cmp   eax,2                 ; incorrect fat chain
    jnb   file_read_new_cluster
 
    popad
    mov   [hd1_status],0
    mov   ebx,[file_size]
    mov   eax,ERROR_FAT_TABLE
    ret
 
  file_read_eof:
    cmp   [hd_error],0
    jne   file_access_denied
    popad
    mov   [hd1_status],0
    mov   ebx,[file_size]
    mov   eax,ERROR_END_OF_FILE
    ret
 
  file_read_OK:
    popad
    mov   [hd1_status],0
    mov   ebx,[file_size]
    xor   eax,eax
    ret
 
  file_to_read_not_found:
    cmp   [hd_error],0
    jne   file_access_denied
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  file_access_denied:
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
get_dir_size:
;-----------------------------------------------------
; input  : eax = first cluster (0=rootdir)
; output : eax = directory size in bytes
;-----------------------------------------------------
    push  edx
    xor   edx,edx               ; count of directory clusters
    test  eax,eax
    jnz   dir_size_next
 
    mov   eax,[ROOT_SECTORS]
    shl   eax,9                 ; fat16 rootdir size in bytes
    cmp   [fat_type],16
    je    dir_size_ret
    mov   eax,[ROOT_CLUSTER]
 
  dir_size_next:
    cmp   eax,2                 ; incorrect fat chain
    jb    dir_size_end
    cmp   eax,[fatRESERVED]     ; end of directory
    ja    dir_size_end
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   dir_size_ret
 
    inc   edx
    jmp   dir_size_next
 
  dir_size_end:
    imul  eax,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
    imul  eax,edx
 
  dir_size_ret:
    pop   edx
    ret
 
 
file_delete:
;-----------------------------------------------------
; input  : eax = file/directory name
;          edx = path
;          edi = 1 - allow directory remove else don't remove directory
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;               10 - access denied
;-----------------------------------------------------
    cmp   [fat_type],0
    jnz   file_del_fat_ok
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  file_del_fat_ok:
    pushad
 
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    file_to_delete_not_found
 
    mov   ebx,PUSHAD_EAX        ; file/directory name
    call  analyze_directory
    jc    file_to_delete_not_found
 
    test  byte [ebx+11],0x10    ; is it directory?
    jz    delete_notdir         ; no. it's file
    cmp   edi,1                 ; allow directory remove
    jnz   delete_no_access      ; no
 
    push  eax                   ; save directory sector
    mov   eax,[ebx+20-2]        ; first cluster of file
    mov   ax,[ebx+26]           ; 0 length files start cluster = 0
    and   eax,[fatMASK]
    xor   ebp,ebp               ; counter for directory deepnes
    call  clear_directory
    pop   eax
    jc    delete_no_access
 
    push  ebx                   ; save directory pointer in buffer
    mov   ebx,buffer
    call  hd_read               ; read directory sector
    cmp  [hd_error],0
    jne  delete_no_access_1
    pop   ebx
 
  delete_notdir:
    call  delete_entry_name
    cmp   [hd_error],0
    jne   delete_no_access
 
    mov   eax,ecx               ; first cluster of file
    call  clear_cluster_chain
    cmp   [hd_error],0
    jne   delete_no_access
 
    popad
    xor   eax,eax
    ret
 
  delete_no_access_1:
     add esp,4
  delete_no_access:
    popad
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
  file_to_delete_not_found:
    cmp  [hd_error],0
    jne  delete_no_access
    popad
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
 
clear_cluster_chain:
;-----------------------------------------------------
; input  : eax = first cluster
;-----------------------------------------------------
    push  eax ecx edx
    xor   ecx,ecx               ; cluster count
    mov   [f_del],1             ; delete on
 
  clean_new_chain:
    cmp   eax,[LAST_CLUSTER]    ; end of file
    ja    delete_OK
    cmp   eax,2                 ; unfinished fat chain or zero length file
    jb    delete_OK
    cmp   eax,[ROOT_CLUSTER]    ; don't remove root cluster
    jz    delete_OK
 
    xor   edx,edx
    call  set_FAT               ; clear fat entry
    cmp  [hd_error],0
    jne  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
  access_denied_01:
    mov   [f_del],0
    pop   edx ecx eax
    ret
 
 
clear_directory:
;-----------------------------------------------------
; input  : eax = directory cluster
;          ebp = directory deepnes
; Note   : use recursive call
;-----------------------------------------------------
    pushad
    inc   ebp
    cmp   ebp,64                ; if over 63 directory deep
    jnb   clear_error           ; something must be wrong
 
  clear_new_cluster:
    cmp   eax,[LAST_CLUSTER]
    ja    clear_end
    cmp   eax,[ROOT_CLUSTER]    ; don't remove root cluster
    jz    clear_end
    mov   esi,eax               ; esi = current directory cluster
    sub   eax,2
    jb    clear_end
    mov   ecx,[SECTORS_PER_CLUSTER]
    imul  eax,ecx
    add   eax,[DATA_START]
 
  clear_new_sector:
    mov   edi,eax               ; edi = current directory sector
    mov   ebx,deltree_buffer
    call  hd_read
    cmp  [hd_error],0
    jne  clear_error    
 
    mov   edx,512/32            ; count of dir entrys per sector = 16
 
  clear_analyze:
    mov   al,[ebx+11]           ; file attribute
    and   al,0xf
    cmp   al,0xf
    je    clear_long_filename
 
    cmp   byte [ebx],'.'        ; parent or current directory
    je    clear_next_entry
    cmp   byte [ebx],0xe5       ; deleted
    je    clear_next_entry
    cmp   byte [ebx],0          ; empty
    je    clear_write_last
    ;je    clear_next_entry
 
    mov   eax,[ebx+20-2]        ; first cluster of entry
    mov   ax,[ebx+26]
    and   eax,[fatMASK]
 
    test  byte [ebx+11],0x10    ; is it directory?
    jz    clear_file            ; no
 
    push  eax ebx
    mov   eax,edi
    mov   ebx,deltree_buffer    ; save buffer over recursive call
    call  hd_write              ; write directory sector to disk
    cmp   [hd_error],0
    jne   clear_error    
 
    pop   ebx eax
 
    call  clear_directory       ; recursive call !!!
    jc    clear_error           ; exit if error found
 
    push  eax ebx
    mov   eax,edi
    mov   ebx,deltree_buffer
    call  hd_read               ; read directory sector again
    cmp  [hd_error],0
    jne   clear_error_1
 
    pop   ebx eax
 
  clear_file:
    call  clear_cluster_chain
    cmp  [hd_error],0
    jne   clear_error
 
  clear_long_filename:
    mov   byte [ebx],0xe5
 
  clear_next_entry:
    add   ebx,32                ; position of next dir entry
    dec   edx
    jnz   clear_analyze
 
    mov   eax,edi
    mov   ebx,deltree_buffer
    call  hd_write              ; write directory sector to disk
    cmp   [hd_error],0
    jne   clear_error
 
    inc   eax                   ; next sector
    dec   ecx
    jnz   clear_new_sector
 
    mov   eax,esi
    call  get_FAT               ; get next cluster
    cmp   [hd_error],0
    jne   clear_error
 
    jmp   clear_new_cluster     ; clear it
 
  clear_write_last:
    mov   eax,edi
    mov   ebx,deltree_buffer
    call  hd_write              ; write directory sector to disk
    cmp   [hd_error],0
    jne   clear_error
 
  clear_end:
    popad
    clc
    ret
clear_error_1:
    add  esp,8
  clear_error:
    popad
    stc
    ret
 
 
delete_entry_name:
;-----------------------------------------------------
; input  : eax = directory sector
;          ebx = directory pointer in buffer
;          longname_sec = 2 previous directory sectors
; output : ecx = first cluster
; change : eax,ebx,edx
;-----------------------------------------------------
    mov   byte [ebx],0xe5
    mov   ecx,[ebx+20-2]        ; first cluster of file
    mov   cx,[ebx+26]           ; 0 length files start cluster = 0
    and   ecx,[fatMASK]
 
  delete_empty:
    sub   ebx,32
    cmp   ebx,buffer
    jnb   delete_test_long
 
    mov   ebx,buffer
    call  hd_write              ; write directory sector back
    cmp   [hd_error],0
    jne   delete_name_end
 
    xor   eax,eax
    xchg  eax,[longname_sec2]
    xchg  eax,[longname_sec1]
    test  eax,eax               ; is there previous directory sector?
    jz    delete_name_end       ; no
 
    mov   ebx,buffer
    call  hd_read               ; read previous sector
    cmp  [hd_error],0
    jne  delete_name_end    
 
    mov   ebx,buffer+0x1e0      ; start from last entry
 
  delete_test_long:
    mov   dh,[ebx+11]           ; file attribute
    and   dh,0xf
    cmp   dh,0xf
    jne   delete_write_buffer
 
    cmp   byte [ebx],0x40       ; end of long dir entry?
    mov   byte [ebx],0xe5
    jb    delete_empty
 
  delete_write_buffer:
    mov   ebx,buffer
    call  hd_write              ; write directory sector back
 
  delete_name_end:
    ret
 
 
rename:
;-----------------------------------------------------------
; input  : eax = source directory name
;          edx = source path
;          ebx = dest directory name
;          edi = dest path
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;                8 - disk full
;               10 - access denied
;-----------------------------------------------------------
    cmp   [fat_type],0
    jnz   fat_ok_for_rename
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  fat_ok_for_rename:
;    call  reserve_hd1
 
    pushad
 
    mov   ebx,edx               ; source path
    call  get_cluster_of_a_path
    jc    rename_entry_not_found
 
    mov   ebx,PUSHAD_EAX        ; source directory name
    call  analyze_directory
    jc    rename_entry_not_found
 
    mov   [sector_tmp],eax      ; save source sector
    mov   [entry_pos],ebx
    mov   esi,ebx
    mov   edi,dir_entry
    mov   ecx,32/4
    cld
    rep   movsd                 ; save entry
 
    mov   ebx,PUSHAD_EDI        ; dest path
    call  get_cluster_of_a_path
    jc    rename_entry_not_found
 
    mov   edx,eax               ; save dest directory cluster
    mov   ebx,PUSHAD_EBX        ; dest directory name
    push  [longname_sec1]
    push  [longname_sec2]
    call  analyze_directory     ; check if entry already exist
    cmp  [hd_error],0
    jne  rename_entry_already_exist_1
 
    pop   [longname_sec2]
    pop   [longname_sec1]
    jnc   rename_entry_already_exist
 
    mov   eax,edx
    call  analyze_directory_to_write
    jc    rename_disk_full
 
    mov   esi,dir_entry
    mov   edi,ebx
    mov   ecx,32/4
    cld
    rep   movsd                 ; copy entry
    mov   esi,PUSHAD_EBX        ; dest directory name
    mov   edi,ebx
    mov   ecx,11
    rep   movsb                 ; copy name
 
    mov   ebx,buffer            ; save the directory name,length,cluster
    call  hd_write
 
    test  byte [dir_entry+11],0x10 ; is it directory?
    jz    rename_not_dir           ; no
    mov   eax,[dir_entry+20-2]     ; FAT entry
    mov   ax,[dir_entry+26]
    and   eax,[fatMASK]
    call  change_2dot_cluster
    cmp   [hd_error],0
    jne   rename_entry_already_exist
 
  rename_not_dir:
    cmp   [hd_error],0
    jne   rename_entry_already_exist
    mov   eax,[sector_tmp]
    mov   ebx,buffer
    call  hd_read               ; read source directory sector
    cmp  [hd_error],0
    jne  rename_entry_already_exist
 
    mov   ebx,[entry_pos]
    call  delete_entry_name
    cmp   [hd_error],0
    jne   rename_entry_already_exist
 
    popad
    call  update_disk           ; write all of cache and fat to hd
    cmp   [hd_error],0
    jne   rename_entry_already_exist_2
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
  rename_entry_not_found:
    cmp  [hd_error],0
    jne  rename_entry_already_exist
    popad
    mov   [hd1_status],0
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  rename_entry_already_exist_1:
    add   esp,8
  rename_entry_already_exist:
    popad
  rename_entry_already_exist_2:
    mov   [hd1_status],0
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
  rename_disk_full:
    cmp  [hd_error],0
    jne  rename_entry_already_exist
    popad
    mov   [hd1_status],0
    mov   eax,ERROR_DISK_FULL
    ret
 
 
change_2dot_cluster:
;-----------------------------------------------------------
; input  : eax = directory cluster
;          edx = value to save
; change : eax,ebx,edx
;-----------------------------------------------------------
    cmp   eax,[LAST_CLUSTER]
    ja    not_2dot              ; too big cluster number, something is wrong
    sub   eax,2
    jb    not_2dot
 
    imul  eax,[SECTORS_PER_CLUSTER]
    add   eax,[DATA_START]
    mov   ebx,buffer
    call  hd_read
    cmp  [hd_error],0
    jne  not_2dot
 
    cmp   dword [ebx+32],'..  '
    jnz   not_2dot
 
    cmp   edx,[ROOT_CLUSTER]    ; is rootdir cluster?
    jne   not_2dot_root
    xor   edx,edx               ; yes. set it zero
 
  not_2dot_root:
    mov   [ebx+32+26],dx        ; 16 bits low of cluster
    shr   edx,16
    mov   [ebx+32+20],dx        ; 16 bits high of cluster (=0 fat16)
    call  hd_write
 
  not_2dot:
    ret
 
 
get_filesize:
;-----------------------------------------------------------
; input  : eax = file name
;          edx = path
;          edi = if 0 - read rootdir else normal dir/file size
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;               10 - access denied
;          ebx = file size
;-----------------------------------------------------------
    cmp   [fat_type],0
    jnz   get_filesize_fat_ok
    xor   ebx,ebx
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  get_filesize_fat_ok:
;    call  reserve_hd1
 
    pushad
    xor   eax,eax
    test  edi,edi               ; is read rootdir?
    je    get_filesize_dirsize  ; yes
 
  get_filesize_no_root:
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    get_filesize_not_found
 
    mov   ebx,PUSHAD_EAX        ; file name
    call  analyze_directory
    jc    get_filesize_not_found
 
    mov   eax,[ebx+28]          ; file size
    test  byte [ebx+11],0x10    ; is it directory?
    jz    get_filesize_set_size ; no
 
    mov   eax,[ebx+20-2]        ; FAT entry
    mov   ax,[ebx+26]
    and   eax,[fatMASK]
 
  get_filesize_dirsize:
    call  get_dir_size
    cmp   [hd_error],0
    jne   get_filesize_access_denied
 
  get_filesize_set_size:
    mov   PUSHAD_EBX,eax
    popad
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
  get_filesize_not_found:
    cmp   [hd_error],0
    jne   get_filesize_access_denied
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  get_filesize_access_denied:
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
get_fileattr:
;-----------------------------------------------------------
; input  : eax = file name
;          edx = path
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;               10 - access denied
;          ebx = file attribute
;-----------------------------------------------------------
    cmp   [fat_type],0
    jnz   get_fileattr_fat_ok
    xor   ebx,ebx
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  get_fileattr_fat_ok:
;    call  reserve_hd1
 
    pushad
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    get_fileattr_not_found
 
    mov   ebx,PUSHAD_EAX        ; file name
    call  analyze_directory
    jc    get_fileattr_not_found
 
    movzx eax,byte [ebx+11]     ; file attribute
    mov   PUSHAD_EBX,eax
    popad
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
  get_fileattr_not_found:
    cmp   [hd_error],0
    jne   get_fileattr_access_denied
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  get_fileattr_access_denied:
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
get_filedate:
;-----------------------------------------------------------
; input  : eax = file name
;          edx = path
; output : eax = 0 - ok
;                3 - unknown FS
;                5 - file not found
;               10 - access denied
;          ebx = file date/time
;                bits 31..25 = year-1980
;                bits 24..21 = month
;                bits 20..16 = day
;                bits 15..11 = hour
;                bits 10..5  = minute
;                bits 4..0   = second/2
;-----------------------------------------------------------
    cmp   [fat_type],0
    jnz   get_filedate_fat_ok
    xor   ebx,ebx
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  get_filedate_fat_ok:
;    call  reserve_hd1
 
    pushad
    mov   ebx,edx
    call  get_cluster_of_a_path
    jc    get_filedate_not_found
 
    mov   ebx,PUSHAD_EAX        ; file name
    call  analyze_directory
    jc    get_filedate_not_found
 
    mov   eax,[ebx+22]          ; file date/time
    mov   PUSHAD_EBX,eax
    popad
    mov   [hd1_status],0
    xor   eax,eax
    ret
 
  get_filedate_not_found:
    cmp   [hd_error],0
    jne   get_filedate_access_denied
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_FILE_NOT_FOUND
    ret
 
  get_filedate_access_denied:
    popad
    mov   [hd1_status],0
    xor   ebx,ebx
    mov   eax,ERROR_ACCESS_DENIED
    ret
 
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   [fat_type],0
    jnz   info_fat_ok
    xor   edx,edx
    xor   ebx,ebx
    xor   ecx,ecx
    mov   eax,ERROR_UNKNOWN_FS
    ret
 
  info_fat_ok:
;    call  reserve_hd1
 
    xor   ecx,ecx               ; count of free clusters
    mov   eax,2
    mov   ebx,[LAST_CLUSTER]
 
  info_cluster:
    push  eax
    call  get_FAT               ; get cluster info
    cmp   [hd_error],0
    jne   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,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
    mov   [hd1_status],0
    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
 
update_disk:
;-----------------------------------------------------------
; write changed fat and cache to disk
;-----------------------------------------------------------
    cmp   [fat_change],0        ; is fat changed?
    je    upd_no_change
 
    call  write_fat_sector
    cmp   [hd_error],0
    jne   update_disk_acces_denied
 
  upd_no_change:
 
    call  write_cache
  update_disk_acces_denied:
    ret
 
 
;**************************************************************************
;
;   0x600008  - first entry in cache list
;
;            +0   - lba sector
;            +4   - state of cache sector
;                   0 = empty
;                   1 = used for read  ( same as in hd )
;                   2 = used for write ( differs from hd )
;
;      +65536 - cache entries
;
;**************************************************************************
 
 
hd_read:
;-----------------------------------------------------------
; input  : eax = block to read
;          ebx = destination
;-----------------------------------------------------------
    push  ecx esi edi           ; scan cache
 
    mov   ecx,cache_max         ; entries in cache
    mov   esi,0x600000+8
    mov   edi,1
 
  hdreadcache:
 
    cmp   dword [esi+4],0       ; empty
    je    nohdcache
 
    cmp   [esi],eax             ; correct sector
    je    yeshdcache
 
  nohdcache:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   hdreadcache
 
    call  find_empty_slot       ; ret in edi
    cmp   [hd_error],0
    jne   return_01
 
    push  eax edx
 
    call  wait_for_hd_idle
    cmp   [hd_error],0
    jne   hd_read_error    
 
    cli
    xor   eax,eax
    mov   edx,[hdbase]
    inc   edx
    out   dx,al   ; ATAFeatures  ¥£ð¡¢  "®¡®¡¥­­®¡¢¥©"
    inc   edx
    inc   eax
    out   dx,al   ; ATASectorCount ¡§¥¢§ðª ¡¥ª¢® ®¢
    inc   edx
    mov   eax,[esp+4]
    out   dx,al   ; ATASectorNumber  ¥£ð¡¢  ­®¬¥   ¡¥ª¢®  
    shr   eax,8
    inc   edx
    out   dx,al   ; ATACylinder ­®¬¥  ¦ð«ð­¤   (¬« ¤¨ð© ¡ ©¢)
    shr   eax,8
    inc   edx
    out   dx,al   ; ­®¬¥  ¦ð«ð­¤   (¡¢  ¨ð© ¡ ©¢)
    shr   eax,8
    inc   edx
    and   al,1+2+4+8
    add   al,byte [hdid]
    add   al,128+64+32
    out   dx,al   ; ­®¬¥  £®«®¢ªð/­®¬¥  ¤ð¡ª 
    inc   edx
    mov   al,20h
    out   dx,al   ; ATACommand  ¥£ð¡¢  ª®¬ ­¤
    sti
 
    call  wait_for_sector_buffer
 
    cmp   [hd_error],0
    jne   hd_read_error
 
    cli
    push  edi
    shl   edi,9
    add   edi,0x600000+65536
    mov   ecx,256
    mov   edx,[hdbase]
    cld
    rep   insw
    pop   edi
    sti
 
    pop   edx eax
 blok_read_2:
    lea   esi,[edi*8+0x600000]
    mov   [esi],eax             ; sector number
    mov   dword [esi+4],1       ; hd read - mark as same as in hd
 
  yeshdcache:
 
    mov   esi,edi
    shl   esi,9
    add   esi,0x600000+65536
    mov   edi,ebx
    mov   ecx,512/4
    cld
    rep   movsd                 ; move data
 return_01:
    pop   edi esi ecx
    ret
    
 
hd_write:
;-----------------------------------------------------------
; input  : eax = block
;          ebx = pointer to memory
;-----------------------------------------------------------
    push  ecx esi edi
 
    ; check if the cache already has the sector and overwrite it
 
    mov   ecx,cache_max
    mov   esi,0x600000+8
    mov   edi,1
 
  hdwritecache:
 
    cmp   dword [esi+4],0       ; if cache slot is empty
    je    not_in_cache_write
 
    cmp   [esi],eax             ; if the slot has the sector
    je    yes_in_cache_write
 
  not_in_cache_write:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   hdwritecache
 
    ; sector not found in cache
    ; write the block to a new location
 
    call  find_empty_slot       ; ret in edi
    cmp   [hd_error],0
    jne   hd_write_access_denied
 
    lea   esi,[edi*8+0x600000]
    mov   [esi],eax             ; sector number
 
  yes_in_cache_write:
 
    mov   dword [esi+4],2       ; write - differs from hd
 
    shl   edi,9
    add   edi,0x600000+65536
    mov   esi,ebx
    mov   ecx,512/4
    cld
    rep   movsd                 ; move data
 hd_write_access_denied:
    pop   edi esi ecx
    ret
 
 
write_cache:
;-----------------------------------------------------------
; write all changed sectors to disk
;-----------------------------------------------------------
    push  eax ecx edx esi edi
 
    ; write difference ( 2 ) from cache to hd
 
    mov   ecx,cache_max
    mov   esi,0x600000+8
    mov   edi,1
 
  write_cache_more:
 
    cmp   dword [esi+4],2       ; if cache slot is not different
    jne   does_not_need_writing
 
    mov   dword [esi+4],1       ; same as in hd
    mov   eax,[esi]             ; eax = sector to write
 
    cmp   eax,[PARTITION_START]
    jb    danger
    cmp   eax,[PARTITION_END]
    ja    danger
 
    call  wait_for_hd_idle
    cmp   [hd_error],0
    jne   hd_write_error
 
    cli
    xor   eax,eax
    mov   edx,[hdbase]
    inc   edx
    out   dx,al
    inc   edx
    inc   eax
    out   dx,al
    inc   edx
    mov   eax,[esi]             ; eax = sector to write
    out   dx,al
    shr   eax,8
    inc   edx
    out   dx,al
    shr   eax,8
    inc   edx
    out   dx,al
    shr   eax,8
    inc   edx
    and   al,1+2+4+8
    add   al,byte [hdid]
    add   al,128+64+32
    out   dx,al
    inc   edx
    mov   al,30h
    out   dx,al
    sti
 
    call  wait_for_sector_buffer
 
    cmp   [hd_error],0
    jne   hd_write_error
 
    push  ecx esi
 
    cli
    mov   esi,edi
    shl   esi,9
    add   esi,0x600000+65536    ; esi = from memory position
    mov   ecx,256
    mov   edx,[hdbase]
    cld
    rep   outsw
    sti
 
    pop   esi ecx
 
  danger:
  does_not_need_writing:
 
    add   esi,8
    inc   edi
    dec   ecx
    jnz   write_cache_more
 return_02:
    pop   edi esi edx ecx eax
    ret
 
 
find_empty_slot:
;-----------------------------------------------------------
; find empty or read slot, flush cache if next 10% is used by write
; output : edi = cache slot
;-----------------------------------------------------------
    push  ecx esi
 
  search_again:
 
    mov   ecx,cache_max*10/100
    mov   edi,[cache_search_start]
 
  search_for_empty:
 
    inc   edi
    cmp   edi,cache_max
    jbe   inside_cache
    mov   edi,1
 
  inside_cache:
 
    cmp   dword [edi*8+0x600000+4],2    ; get cache slot info
    jb    found_slot                    ; it's empty or read
    dec   ecx
    jnz   search_for_empty
 
    call  write_cache                   ; no empty slots found, write all
    cmp   [hd_error],0
    jne   found_slot_access_denied
 
    jmp   search_again                  ; and start again
 
  found_slot:
 
    mov   [cache_search_start],edi
  found_slot_access_denied:
    pop   esi ecx
    ret
 
 
save_hd_wait_timeout:
 
    push  eax
    mov   eax,[timer_ticks];[0xfdf0]
    add   eax,300               ; 3 sec timeout
    mov   [hd_wait_timeout],eax
    pop   eax
    ret
 
 
check_hd_wait_timeout:
 
    push  eax
    mov   eax,[hd_wait_timeout]
    cmp   [timer_ticks], eax ;[0xfdf0],eax
    jg    hd_timeout_error
    pop   eax
    mov   [hd_error],0
    ret
 
iglobal
  hd_timeout_str   db 'K : FS - HD timeout',13,10,0
  hd_read_str      db 'K : FS - HD read error',13,10,0
  hd_write_str     db 'K : FS - HD write error',13,10,0
  hd_lba_str       db 'K : FS - HD LBA error',13,10,0
endg
 
hd_timeout_error:
 
    call  clear_hd_cache
    call  clear_application_table_status
    mov   esi,hd_timeout_str
    call  sys_msg_board_str
;    jmp   $
    mov   [hd_error],1
    pop   eax
    ret
 
hd_read_error:
 
    call  clear_hd_cache
    call  clear_application_table_status
    mov   esi,hd_read_str
    call  sys_msg_board_str
    pop   edx eax
    jmp    return_01
;    jmp   $
 
hd_write_error:
 
    call  clear_hd_cache
    call  clear_application_table_status
    mov   esi,hd_write_str
    call  sys_msg_board_str
    jmp    return_02
;    jmp   $
 
hd_lba_error:
    call  clear_hd_cache
    call  clear_application_table_status
    mov   esi,hd_lba_str
    call  sys_msg_board_str
    jmp   LBA_read_ret
 
 
wait_for_hd_idle:
 
    push  eax edx
 
    call  save_hd_wait_timeout
 
    mov   edx,[hdbase]
    add   edx,0x7
 
  wfhil1:
 
    call  check_hd_wait_timeout
    cmp   [hd_error],0
    jne   @f
 
    in    al,dx
    test  al,128
    jnz   wfhil1
  
 @@:
 
    pop   edx eax
    ret
 
 
 
wait_for_sector_buffer:
 
    push  eax edx
 
    mov   edx,[hdbase]
    add   edx,0x7
 
    call  save_hd_wait_timeout
 
  hdwait_sbuf:                  ; wait for sector buffer to be ready
 
    call  check_hd_wait_timeout
    cmp   [hd_error],0
    jne   @f
 
    in    al,dx
    test  al,8
    jz    hdwait_sbuf
 
    mov   [hd_error],0
 
    cmp   [hd_setup],1          ; do not mark error for setup request
    je    buf_wait_ok
 
    test  al,1                  ; previous command ended up with an error
    jz    buf_wait_ok
 @@:
    mov   [hd_error],1
 
  buf_wait_ok:
 
    pop   edx eax
    ret
 
 
 
read_hd_file:
;-----------------------------------------------------------------
;
; Converting old reading function for hd-application start.
;
; IN:
;
; eax - pointer to file (0 = read only first sector of drive: eg 'label')
; ebx - file lenght
; ecx - start 512 byte block number
; edx - number of blocks to read
; esi - pointer to return/work area (atleast 20 000 bytes)
;
; For new read function
;
; EAX   (PAR0)      pointer to file-name
; ECX   (PAR1)      pointer to buffer
; EBX   (PAR2)   vt file blocks to read
; EDX   (PAR3)      pointer to path
; ESI            vt first 512 block to read
; EDI               if 0 - return root
;--------------------------------------------------------------------------
 
    push  ecx esi edi
    mov   esi,eax
    mov   edi,startpath
    mov   ecx,250
    cld
    rep   movsb
    pop   edi esi ecx
 
    mov   eax,startpath
    mov   [eax+ebx-12],byte 0
 
    push  eax ebx ecx edx esi
 
    pop   ecx ; pointer to buffer
    add   ecx,1024
    pop   ebx ; number of blocks to read
    pop   esi ; first block to read
    dec   esi
    pop   eax ; file length
    pop   edx ; pointer to path
 
    mov   edi,12
    lea   eax,[eax+edx-12+1]
    call  file_read
 
    ret
 
; \begin{diamond}
hd_find_lfn:
; in: esi->name
; out: CF=1 - file not found
;      else CF=0 and edi->direntry
; destroys eax
 
        push    esi edi
 
 
 
 
 
 
 
        push    0
        push    0
        push    fat16_root_first
        push    fat16_root_next
 
        mov     eax, [ROOT_CLUSTER]
 
        cmp     [fat_type], 32
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        jz      .fat32
 
.loop:
        call    fat_find_lfn
        jc      .notfound
        cmp     byte [esi], 0
        jz      .found
 
 
 
 
 
 
 
        test    byte [edi+11], 10h
        jz      .notfound
        and     dword [esp+12], 0
 
        movzx   eax, word [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
.found:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        add     esp, 20         ; CF=0
        pop     esi
 
        ret
 
;----------------------------------------------------------------
;
;  fs_HdRead - LFN variant for reading hard disk
;
;  esi  points to filename
;  ebx  pointer to 64-bit number = first wanted byte, 0+
;       may be ebx=0 - start from first byte
;  ecx  number of bytes to read, 0+
;  edx  mem location to return data
;
;  ret ebx = bytes read or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_HdRead:
    cmp    [fat_type], 0
    jnz    @f
    or    ebx, -1
    mov    eax, ERROR_UNKNOWN_FS
    ret
@@:
    push    edi
    cmp    byte [esi], 0
    jnz    @f
.noaccess:
    pop    edi
.noaccess_2:
    or    ebx, -1
    mov    eax, ERROR_ACCESS_DENIED
    ret
 
.noaccess_3:
    add esp,4
.noaccess_1:
    add esp,4
.noaccess_4:
    add esp,4*5
    jmp  .noaccess_2
 
@@:
    call    hd_find_lfn
    jnc    .found
    pop    edi
    cmp   [hd_error],0
    jne   .noaccess_2
    or    ebx, -1
    mov    eax, ERROR_FILE_NOT_FOUND
    ret
 
.found:
    test    byte [edi+11], 0x10    ; do not allow read directories
    jnz    .noaccess
    test    ebx, ebx
    jz    .l1
    cmp    dword [ebx+4], 0
    jz    @f
        xor     ebx, ebx
.reteof:
    mov    eax, 6
    pop    edi
    ret
@@:
    mov    ebx, [ebx]
.l1:
        push    ecx 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
    test    eax, eax
    jz    .eof
    cmp    eax, [fatRESERVED]
    jae    .eof
    mov    [cluster_tmp], eax
    dec    eax
    dec    eax
    mov    edi, [SECTORS_PER_CLUSTER]
    imul    eax, edi
    add    eax, [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    ebx
    mov    ebx, edx
    call    hd_read
    cmp  [hd_error],0
    jne  .noaccess_1    
    pop    ebx
    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
    mov    ebx, buffer
    call    hd_read
    cmp  [hd_error],0
    jne  .noaccess_3
 
    mov    eax, ebx
    pop    ebx
    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, [cluster_tmp]
    call    get_FAT
    cmp   [hd_error],0
    jne   .noaccess_4
 
    jmp    .new_cluster
.done:
        mov     ebx, edx
        pop     eax edx ecx edi
        sub     ebx, edx
        ret
.eof:
        mov     ebx, edx
        pop     eax edx ecx
        sub     ebx, edx
        jmp     .reteof
 
;----------------------------------------------------------------
;
;  fs_HdReadFolder - LFN variant for reading hard disk folder
;
;  esi  points to filename
;  ebx  pointer to structure 32-bit number = first wanted block, 0+
;                          & flags (bitfields)
; flags: bit 0: 0=ANSI names, 1=UNICODE names
;  ecx  number of blocks to read, 0+
;  edx  mem location to return data
;
;  ret ebx = blocks read or 0xffffffff folder not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_HdReadFolder:
        mov     eax, [ROOT_CLUSTER]
        push    edi
        cmp     byte [esi], 0
        jz      .doit
        call    hd_find_lfn
        jnc     .found
        pop     edi
        or      ebx, -1
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
.found:
        test    byte [edi+11], 0x10     ; do not allow read files
        jnz     .found_dir
        pop     edi
        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 ecx
        push    ebp
        sub     esp, 262*2      ; reserve space for LFN
        mov     ebp, esp
        push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE name
        mov     ebx, [ebx]
; init header
        push    eax ecx
        mov     edi, edx
        mov     ecx, 32/4
        xor     eax, eax
        rep     stosd
        pop     ecx eax
        mov     byte [edx], 1   ; version
        mov     esi, edi        ; esi points to BDFE
.new_cluster:
        mov     [cluster_tmp], eax
        test    eax, eax
        jnz     @f
        cmp     [fat_type], 32
        jz      .notfound
        mov     eax, [ROOT_START]
        push    [ROOT_SECTORS]
        push    ebx
        jmp     .new_sector
@@:
        dec     eax
        dec     eax
        imul    eax, [SECTORS_PER_CLUSTER]
        push    [SECTORS_PER_CLUSTER]
        add     eax, [DATA_START]
        push    ebx
.new_sector:
        mov     ebx, buffer
        mov     edi, ebx
        call    hd_read
        cmp     [hd_error], 0
        jnz     .notfound2
        add     ebx, 512
        push    eax
.l1:
        call    fat_get_name
        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, [cluster_tmp]
        test    eax, eax
        jz      .done
        call    get_FAT
        cmp     [hd_error], 0
        jnz     .notfound2
        cmp     eax, 2
        jb      .done
        cmp     eax, [fatRESERVED]
        jae     .done
        push    eax
        mov     eax, [SECTORS_PER_CLUSTER]
        mov     [esp+8], eax
        pop     eax
        mov     [cluster_tmp], eax
        dec     eax
        dec     eax
        imul    eax, [SECTORS_PER_CLUSTER]
        add     eax, [DATA_START]
@@:
        mov     ebx, buffer
        mov     edi, ebx
        call    hd_read
        cmp     [hd_error], 0
        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
        call    fat_entry_to_bdfe
.l2:
        add     edi, 0x20
        cmp     edi, ebx
        jb      .l1
        pop     eax
        inc     eax
        dec     dword [esp+4]
        jnz     .new_sector
        mov     eax, [cluster_tmp]
        test    eax, eax
        jz      .done
        call    get_FAT
        cmp     [hd_error], 0
        jnz     .notfound2
        cmp     eax, 2
        jb      .done
        cmp     eax, [fatRESERVED]
        jae     .done
        push    eax
        mov     eax, [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     ebp ecx esi edi
        mov     eax, ERROR_FILE_NOT_FOUND
        or      ebx, -1
        ret
.done:
        add     esp, 262*2+4+8
        pop     ebp
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ecx
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        pop     ecx esi edi
        ret
 
fat16_root_next:
        cmp     edi, buffer+0x200-0x20
        jae     fat16_root_next_sector
        add     edi, 0x20
        ret     ; CF=0
fat16_root_next_sector:
; read next sector
        push    ecx
        mov     ecx, [eax+4]
        inc     ecx
        mov     [eax+4], ecx
        cmp     ecx, [ROOT_SECTORS]
        pop     ecx
        jae     fat16_root_first.readerr
fat16_root_first:
        mov     eax, [eax+4]
        add     eax, [ROOT_START]
        push    ebx
        mov     edi, buffer
        mov     ebx, edi
        call    hd_read
        pop     ebx
        cmp     [hd_error], 0
        jnz     .readerr
        ret     ; CF=0
.readerr:
        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, [ROOT_START]
        mov     ebx, buffer
        call    hd_write
        popa
        ret
fat16_root_next_write:
        cmp     edi, buffer+0x200
        jae     @f
        ret
@@:
        call    fat16_root_end_write
        jmp     fat16_root_next_sector
fat16_root_extend_dir:
        stc
        ret
 
fat_notroot_next:
        cmp     edi, buffer+0x200-0x20
        jae     fat_notroot_next_sector
        add     edi, 0x20
        ret     ; CF=0
fat_notroot_next_sector:
        push    ecx
        mov     ecx, [eax+4]
        inc     ecx
        cmp     ecx, [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
        cmp     [hd_error], 0
        jnz     fat_notroot_next_err
        cmp     ecx, [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
        mov     edi, buffer
        mov     ebx, edi
        call    hd_read
        pop     ebx
        cmp     [hd_error], 0
        jnz     @f
        ret     ; CF=0
fat_notroot_next_err:
        pop     ecx
@@:
        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
        mov     ebx, buffer
        call    hd_write
        pop     ebx
        ret
fat_notroot_next_write:
        cmp     edi, buffer+0x200
        jae     @f
        ret
@@:
        push    eax
        call    fat_notroot_end_write
        pop     eax
        jmp     fat_notroot_next_sector
fat_notroot_extend_dir:
        push    eax
        mov     eax, [eax]
        call    get_free_FAT
        jnc     .found
        pop     eax
        ret     ; CF=1
.found:
        push    edx
        mov     edx, [fatEND]
        call    set_FAT
        mov     edx, eax
        mov     eax, [esp+4]
        mov     eax, [eax]
        push    edx
        mov     [f_del], 1
        call    set_FAT
        pop     edx
        cmp     [hd_error], 0
        jz      @f
        pop     edx
        pop     eax
        stc
        ret
@@:
        push    ecx
        or      ecx, -1
        call    add_disk_free_space
; zero new cluster
        mov     ecx, 512/4
        mov     edi, 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, [SECTORS_PER_CLUSTER]
        imul    eax, ecx
        add     eax, [DATA_START]
        mov     ebx, edi
@@:
        call    hd_write
        inc     eax
        loop    @b
        pop     ecx ebx eax
        clc
        ret
 
fat_get_sector:
        push    ecx
        mov     ecx, [eax]
        dec     ecx
        dec     ecx
        imul    ecx, [SECTORS_PER_CLUSTER]
        add     ecx, [DATA_START]
        add     ecx, [eax+4]
        mov     eax, ecx
        pop     ecx
        ret
 
;----------------------------------------------------------------
;
;  fs_HdRewrite - LFN variant for writing hard disk
;
;  esi  points to filename
;  ebx  ignored (reserved)
;  ecx  number of bytes to write, 0+
;  edx  mem location to data
;
;  ret ebx = number of written bytes
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fshrad:
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
fshrfs:
        mov     eax, ERROR_UNKNOWN_FS
        xor     ebx, ebx
        ret
 
fs_HdRewrite:
        cmp     [fat_type], 0
        jz      fshrfs
        cmp     byte [esi], 0
        jz      fshrad
        pushad
        xor     ebp, ebp
        push    esi
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
        lea     ebp, [esi-1]
        jmp     @b
@@:
        pop     esi
        test    ebp, ebp
        jnz     .noroot
        mov     ebp, [ROOT_CLUSTER]
        cmp     [fat_type], 32
        jz      .pushnotroot
        push    fat16_root_extend_dir
        push    fat16_root_end_write
        push    fat16_root_next_write
        push    fat16_root_begin_write
        xor     ebp, ebp
        push    ebp
        push    ebp
        push    fat16_root_first
        push    fat16_root_next
        jmp     .common1
.noroot:
; check existence
        mov     byte [ebp], 0
        call    hd_find_lfn
        mov     byte [ebp], '/'
        lea     esi, [ebp+1]
        jnc     @f
        mov     eax, ERROR_FILE_NOT_FOUND
.ret1:
        mov     [esp+28], eax
        popad
        xor     ebx, ebx
        ret
@@:
        test    byte [edi+11], 0x10     ; must be directory
        mov     eax, ERROR_ACCESS_DENIED
        jz      .ret1
        mov     ebp, [edi+20-2]
        mov     bp, [edi+26]            ; ebp=cluster
        mov     eax, ERROR_FAT_TABLE
        cmp     ebp, 2
        jb      .ret1
.pushnotroot:
        push    fat_notroot_extend_dir
        push    fat_notroot_end_write
        push    fat_notroot_next_write
        push    fat_notroot_begin_write
        push    0
        push    ebp
        push    fat_notroot_first
        push    fat_notroot_next
.common1:
        call    fat_find_lfn
        jc      .notfound
; found, 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
        mov     [f_del], 1
@@:
        cmp     eax, [fatRESERVED]
        jae     .done1
        push    edx
        xor     edx, edx
        call    set_FAT
        mov     eax, edx
        pop     edx
        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, 32
        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     [eax], ebp
        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+32
        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
        push    1
        pop     eax     ; 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     [eax], ebp
        and     dword [eax+4], 0
        call    dword [eax-4]
        pop     eax
        jnc     .scan_dir
.fsfrfe3:
        add     esp, 12+8+12+32
        popad
        mov     eax, 11
        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]
        pop     eax
        jnc     .scan_dir
        cmp     [hd_error], 0
        jnz     .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+32
        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!
; calculate name checksum
        push    esi ecx
        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
.doit:
        lea     eax, [esp+8]
        call    dword [eax+16]  ; flush directory
        push    ecx
        mov     ecx, [esp+4+32+24]
        push    ecx
        push    edi
        mov     esi, edx
        test    ecx, ecx
        jz      .done
        mov     eax, 2
        call    get_free_FAT
        jc      .diskfull
        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, [fatEND]
        call    set_FAT
        pop     edx
.write_cluster:
        push    eax
        dec     eax
        dec     eax
        mov     ebp, [SECTORS_PER_CLUSTER]
        imul    eax, ebp
        add     eax, [DATA_START]
; write data
.write_sector:
        mov     ecx, 512
        cmp     dword [esp+8], ecx
        jb      .writeshort
; we can write directly from given buffer
        mov     ebx, esi
        add     esi, ecx
        jmp     .writecommon
.writeshort:
        mov     ecx, [esp+8]
        push    ecx
        mov     edi, buffer
        mov     ebx, edi
        rep     movsb
        mov     ecx, buffer+0x200
        sub     ecx, edi
        push    eax
        xor     eax, eax
        rep     stosb
        pop     eax
        pop     ecx
.writecommon:
        call    hd_write
        cmp     [hd_error], 0
        jnz     .writeerr
        inc     eax
        sub     dword [esp+8], ecx
        jz      .writedone
        dec     ebp
        jnz     .write_sector
; allocate new cluster
        pop     eax
        mov     ecx, eax
        call    get_free_FAT
        jc      .diskfull
        mov     [f_del], 1
        push    edx
        mov     edx, [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
        sub     esi, ecx
        mov     eax, 11
        jmp     .ret
.writedone:
        pop     eax
.done:
        xor     eax, eax
.ret:
        pop     edi ecx
        mov     ebx, esi
        sub     ebx, edx
        pop     ebp
        mov     [esp+32+28], eax
        lea     eax, [esp+8]
        call    dword [eax+8]
        mov     [edi+28], ebx
        call    dword [eax+16]
        mov     [esp+32+16], ebx
        lea     eax, [ebx+511]
        shr     eax, 9
        mov     ecx, [SECTORS_PER_CLUSTER]
        lea     eax, [eax+ecx-1]
        xor     edx, edx
        div     ecx
        mov     ecx, ebp
        sub     ecx, eax
        call    add_disk_free_space
        add     esp, 32
        call    update_disk
        popad
        ret
 
; \end{diamond}

Rev 78	Rev 83
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; FAT32.INC ;;	3	;; FAT32.INC ;;
4	;; ;;	4	;; ;;
5	;; FAT16/32 functions for MenuetOS ;;	5	;; FAT16/32 functions for MenuetOS ;;
6	;; ;;	6	;; ;;
7	;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;;	7	;; Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it ;;
8	;; ;;	8	;; ;;
9	;; See file COPYING for details ;;	9	;; See file COPYING for details ;;
-		10	;; 27.05.2006 LFN create/rewrite file - diamond ;;
10	;; 04.05.2006 LFN read folder - diamond ;;	11	;; 04.05.2006 LFN read folder - diamond ;;
11	;; 29.04.2006 Elimination of hangup after the ;;	12	;; 29.04.2006 Elimination of hangup after the ;;
12	;; expiration hd_wait_timeout - Mario79 ;;	13	;; expiration hd_wait_timeout - Mario79 ;;
13	;; 23.04.2006 LFN read file - diamond ;;	14	;; 23.04.2006 LFN read file - diamond ;;
14	;; 28.01.2006 find all Fat16/32 partition in all input point ;;	15	;; 28.01.2006 find all Fat16/32 partition in all input point ;;
15	;; to MBR, see file part_set.inc - Mario79 ;;	16	;; to MBR, see file part_set.inc - Mario79 ;;
16	;; 15.01.2005 get file size/attr/date, file_append - ATV ;;	17	;; 15.01.2005 get file size/attr/date, file_append - ATV ;;
17	;; 04.12.2004 skip volume label, file delete bug fixed - ATV ;;	18	;; 04.12.2004 skip volume label, file delete bug fixed - ATV ;;
18	;; 29.11.2004 get_free_FAT changed, append dir bug fixed - ATV ;;	19	;; 29.11.2004 get_free_FAT changed, append dir bug fixed - ATV ;;
19	;; 23.11.2004 don't allow overwrite dir with file - ATV ;;	20	;; 23.11.2004 don't allow overwrite dir with file - ATV ;;
20	;; 18.11.2004 get_disk_info and more error codes - ATV ;;	21	;; 18.11.2004 get_disk_info and more error codes - ATV ;;
21	;; 17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV ;;	22	;; 17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV ;;
22	;; 10.11.2004 removedir clear whole directory structure - ATV ;;	23	;; 10.11.2004 removedir clear whole directory structure - ATV ;;
23	;; 08.11.2004 rename - ATV ;;	24	;; 08.11.2004 rename - ATV ;;
24	;; 30.10.2004 file_read return also dirsize in bytes - ATV ;;	25	;; 30.10.2004 file_read return also dirsize in bytes - ATV ;;
25	;; 20.10.2004 Makedir/Removedir - ATV ;;	26	;; 20.10.2004 Makedir/Removedir - ATV ;;
26	;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;;	27	;; 14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx) ;;
27	;; 06.9.2004 Fix free space by Mario79 added - MH ;;	28	;; 06.9.2004 Fix free space by Mario79 added - MH ;;
28	;; 24.5.2004 Write back buffer for File_write -VT ;;	29	;; 24.5.2004 Write back buffer for File_write -VT ;;
29	;; 20.5.2004 File_read function to work with syscall 58 - VT ;;	30	;; 20.5.2004 File_read function to work with syscall 58 - VT ;;
30	;; 30.3.2004 Error parameters at function return - VT ;;	31	;; 30.3.2004 Error parameters at function return - VT ;;
31	;; 01.5.2002 Bugfix in device write - VT ;;	32	;; 01.5.2002 Bugfix in device write - VT ;;
32	;; 20.5.2002 Hd status check - VT ;;	33	;; 20.5.2002 Hd status check - VT ;;
33	;; 29.6.2002 Improved fat32 verification - VT ;;	34	;; 29.6.2002 Improved fat32 verification - VT ;;
34	;; ;;	35	;; ;;
35	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	36	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
36		37
37	cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00	38	cache_max equ 1919 ; max. is 1919*512+0x610000=0x6ffe00
38		39
39	ERROR_SUCCESS = 0	40	ERROR_SUCCESS = 0
40	ERROR_DISK_BASE = 1	41	ERROR_DISK_BASE = 1
41	ERROR_UNSUPPORTED_FS = 2	42	ERROR_UNSUPPORTED_FS = 2
42	ERROR_UNKNOWN_FS = 3	43	ERROR_UNKNOWN_FS = 3
43	ERROR_PARTITION = 4	44	ERROR_PARTITION = 4
44	ERROR_FILE_NOT_FOUND = 5	45	ERROR_FILE_NOT_FOUND = 5
45	ERROR_END_OF_FILE = 6	46	ERROR_END_OF_FILE = 6
46	ERROR_MEMORY_POINTER = 7	47	ERROR_MEMORY_POINTER = 7
47	ERROR_DISK_FULL = 8	48	ERROR_DISK_FULL = 8
48	ERROR_FAT_TABLE = 9	49	ERROR_FAT_TABLE = 9
49	ERROR_ACCESS_DENIED = 10	50	ERROR_ACCESS_DENIED = 10
50		51
51	PUSHAD_EAX equ [esp+28]	52	PUSHAD_EAX equ [esp+28]
52	PUSHAD_ECX equ [esp+24]	53	PUSHAD_ECX equ [esp+24]
53	PUSHAD_EDX equ [esp+20]	54	PUSHAD_EDX equ [esp+20]
54	PUSHAD_EBX equ [esp+16]	55	PUSHAD_EBX equ [esp+16]
55	PUSHAD_EBP equ [esp+8]	56	PUSHAD_EBP equ [esp+8]
56	PUSHAD_ESI equ [esp+4]	57	PUSHAD_ESI equ [esp+4]
57	PUSHAD_EDI equ [esp+0]	58	PUSHAD_EDI equ [esp+0]
58		59
59	cluster dd 0 ; used by file_write,makedir,append	60	cluster dd 0 ; used by file_write,makedir,append
60	partition_count dd 0 ; partitions found by set_FAT32_variables	61	partition_count dd 0 ; partitions found by set_FAT32_variables
61	longname_sec1 dd 0 ; used by analyze_directory to save 2 previous	62	longname_sec1 dd 0 ; used by analyze_directory to save 2 previous
62	longname_sec2 dd 0 ; directory sectors for delete long filename	63	longname_sec2 dd 0 ; directory sectors for delete long filename
63		64
64	hd_error dd 0 ; set by wait_for_sector_buffer	65	hd_error dd 0 ; set by wait_for_sector_buffer
65	hd_setup dd 0	66	hd_setup dd 0
66	hd_wait_timeout dd 0	67	hd_wait_timeout dd 0
67		68
68	cluster_tmp dd 0 ; used by analyze_directory	69	cluster_tmp dd 0 ; used by analyze_directory
69	; and analyze_directory_to_write	70	; and analyze_directory_to_write
70		71
71	file_size dd 0 ; used by file_read	72	file_size dd 0 ; used by file_read
72		73
73	sector_tmp dd 0 ; used by rename,append,file_write	74	sector_tmp dd 0 ; used by rename,append,file_write
74	entry_pos dd 0 ; used by rename,append,file_write	75	entry_pos dd 0 ; used by rename,append,file_write
75		76
76	old_filesize dd 0 ; used by append	77	old_filesize dd 0 ; used by append
77	new_filepos dd 0 ; used by append	78	new_filepos dd 0 ; used by append
78	bytes2write dd 0 ; used by append	79	bytes2write dd 0 ; used by append
79		80
80	cache_search_start dd 0 ; used by find_empty_slot	81	cache_search_start dd 0 ; used by find_empty_slot
81		82
82	fat_in_cache dd -1	83	fat_in_cache dd -1
83	fat_cache: times 512 db 0	84	fat_cache: times 512 db 0
84		85
85	uglobal	86	uglobal
86	Sector512: ; label for dev_hdcd.inc	87	Sector512: ; label for dev_hdcd.inc
87	buffer: times 512 db 0	88	buffer: times 512 db 0
88	deltree_buffer: times 512 db 0	89	deltree_buffer: times 512 db 0
89	endg	90	endg
90		91
91	iglobal	92	iglobal
92	NewDirEntry1 db ". ",0x10	93	NewDirEntry1 db ". ",0x10
93	times 20 db 0	94	times 20 db 0
94	NewDirEntry2 db ".. ",0x10	95	NewDirEntry2 db ".. ",0x10
95	times 20 db 0	96	times 20 db 0
96	endg	97	endg
97		98
98	uglobal	99	uglobal
99	dir_entry: times 32 db 0	100	dir_entry: times 32 db 0
100		101
101	startpath: times 255 db 0	102	startpath: times 255 db 0
102		103
103	fat16_root db 0 ; flag for fat16 rootdir	104	fat16_root db 0 ; flag for fat16 rootdir
104	f_del db 0 ; 1=overwrite fat entry	105	f_del db 0 ; 1=overwrite fat entry
105	fat_change db 0 ; 1=fat has changed	106	fat_change db 0 ; 1=fat has changed
106		107
107	endg	108	endg
108		109
109	reserve_hd1:	110	reserve_hd1:
110		111
111	cli	112	cli
112	cmp [hd1_status],0	113	cmp [hd1_status],0
113	je reserve_ok1	114	je reserve_ok1
114		115
115	sti	116	sti
116	call change_task	117	call change_task
117	jmp reserve_hd1	118	jmp reserve_hd1
118		119
119	reserve_ok1:	120	reserve_ok1:
120		121
121	push eax	122	push eax
122	mov eax,[0x3000]	123	mov eax,[0x3000]
123	shl eax,5	124	shl eax,5
124	mov eax,[eax+0x3000+4]	125	mov eax,[eax+0x3000+4]
125	mov [hd1_status],eax	126	mov [hd1_status],eax
126	pop eax	127	pop eax
127	sti	128	sti
128	ret	129	ret
129		130
130		131
131	clear_hd_cache:	132	clear_hd_cache:
132		133
133	push eax ecx edi	134	push eax ecx edi
134	mov edi,0x600000	135	mov edi,0x600000
135	mov ecx,16384	136	mov ecx,16384
136	xor eax,eax	137	xor eax,eax
137	cld	138	cld
138	rep stosd ; clear hd cache with 0	139	rep stosd ; clear hd cache with 0
139	mov [cache_search_start],eax	140	mov [cache_search_start],eax
140	mov [fat_in_cache],-1	141	mov [fat_in_cache],-1
141	mov [fat_change],0	142	mov [fat_change],0
142	pop edi ecx eax	143	pop edi ecx eax
143	ret	144	ret
144		145
145	problem_partition db 0 ; used for partitions search	146	problem_partition db 0 ; used for partitions search
146		147
147	include 'part_set.inc'	148	include 'part_set.inc'
148		149
149	set_FAT:	150	set_FAT:
150	;--------------------------------	151	;--------------------------------
151	; input : EAX = cluster	152	; input : EAX = cluster
152	; EDX = value to save	153	; EDX = value to save
153	; output : EDX = old value	154	; output : EDX = old value
154	;--------------------------------	155	;--------------------------------
155	push eax ebx esi	156	push eax ebx esi
156		157
157	cmp eax,2	158	cmp eax,2
158	jb sfc_error	159	jb sfc_error
159	cmp eax,[LAST_CLUSTER]	160	cmp eax,[LAST_CLUSTER]
160	ja sfc_error	161	ja sfc_error
161	cmp [fat_type],16	162	cmp [fat_type],16
162	je sfc_1	163	je sfc_1
163	add eax,eax	164	add eax,eax
164	sfc_1:	165	sfc_1:
165	add eax,eax	166	add eax,eax
166	mov esi,511	167	mov esi,511
167	and esi,eax ; esi = position in fat sector	168	and esi,eax ; esi = position in fat sector
168	shr eax,9 ; eax = fat sector	169	shr eax,9 ; eax = fat sector
169	add eax,[FAT_START]	170	add eax,[FAT_START]
170	mov ebx,fat_cache	171	mov ebx,fat_cache
171		172
172	cmp eax,[fat_in_cache] ; is fat sector already in memory?	173	cmp eax,[fat_in_cache] ; is fat sector already in memory?
173	je sfc_in_cache ; yes	174	je sfc_in_cache ; yes
174		175
175	cmp [fat_change],0 ; is fat changed?	176	cmp [fat_change],0 ; is fat changed?
176	je sfc_no_change ; no	177	je sfc_no_change ; no
177	call write_fat_sector ; yes. write it into disk	178	call write_fat_sector ; yes. write it into disk
178	cmp [hd_error],0	179	cmp [hd_error],0
179	jne sfc_error	180	jne sfc_error
180		181
181	sfc_no_change:	182	sfc_no_change:
182	mov [fat_in_cache],eax ; save fat sector	183	mov [fat_in_cache],eax ; save fat sector
183	call hd_read	184	call hd_read
184	cmp [hd_error],0	185	cmp [hd_error],0
185	jne sfc_error	186	jne sfc_error
186		187
187		188
188	sfc_in_cache:	189	sfc_in_cache:
189	cmp [fat_type],16	190	cmp [fat_type],16
190	jne sfc_test32	191	jne sfc_test32
191		192
192	cmp [f_del],1 ; overwrite previous value?	193	cmp [f_del],1 ; overwrite previous value?
193	je sfc_set16 ; yes	194	je sfc_set16 ; yes
194	cmp word [ebx+esi],0 ; is cluster free?	195	cmp word [ebx+esi],0 ; is cluster free?
195	je sfc_set16 ; yes	196	je sfc_set16 ; yes
196	mov dword [8*0x100000],0xffffff	197	mov dword [8*0x100000],0xffffff
197	mov edx,[ebx+esi] ; get old value	198	mov edx,[ebx+esi] ; get old value
198	jmp sfc_nonzero	199	jmp sfc_nonzero
199		200
200	sfc_set16:	201	sfc_set16:
201	xchg [ebx+esi],dx ; save new value and get old value	202	xchg [ebx+esi],dx ; save new value and get old value
202	jmp sfc_write	203	jmp sfc_write
203		204
204	sfc_test32:	205	sfc_test32:
205	mov eax,[fatMASK]	206	mov eax,[fatMASK]
206	cmp [f_del],1 ; overwrite previous value?	207	cmp [f_del],1 ; overwrite previous value?
207	je sfc_set32 ; yes	208	je sfc_set32 ; yes
208	test eax,[ebx+esi] ; is cluster free?	209	test eax,[ebx+esi] ; is cluster free?
209	je sfc_set32 ; yes	210	je sfc_set32 ; yes
210	mov dword [8*0x100000],0xffffff	211	mov dword [8*0x100000],0xffffff
211	mov edx,[ebx+esi] ; get old value	212	mov edx,[ebx+esi] ; get old value
212	jmp sfc_nonzero	213	jmp sfc_nonzero
213		214
214	sfc_set32:	215	sfc_set32:
215	and edx,eax	216	and edx,eax
216	xor eax,-1 ; mask for high bits	217	xor eax,-1 ; mask for high bits
217	and eax,[ebx+esi] ; get high 4 bits	218	and eax,[ebx+esi] ; get high 4 bits
218	or eax,edx	219	or eax,edx
219	mov edx,[ebx+esi] ; get old value	220	mov edx,[ebx+esi] ; get old value
220	mov [ebx+esi],eax ; save new value	221	mov [ebx+esi],eax ; save new value
221		222
222	sfc_write:	223	sfc_write:
223	mov [fat_change],1 ; fat has changed	224	mov [fat_change],1 ; fat has changed
224		225
225	sfc_nonzero:	226	sfc_nonzero:
226	and edx,[fatMASK]	227	and edx,[fatMASK]
227		228
228	sfc_error:	229	sfc_error:
229	pop esi ebx eax	230	pop esi ebx eax
230	ret	231	ret
231		232
232		233
233	get_FAT:	234	get_FAT:
234	;--------------------------------	235	;--------------------------------
235	; input : EAX = cluster	236	; input : EAX = cluster
236	; output : EAX = next cluster	237	; output : EAX = next cluster
237	;--------------------------------	238	;--------------------------------
238	push ebx esi	239	push ebx esi
239		240
240	cmp [fat_type],16	241	cmp [fat_type],16
241	je gfc_1	242	je gfc_1
242	add eax,eax	243	add eax,eax
243	gfc_1:	244	gfc_1:
244	add eax,eax	245	add eax,eax
245	mov esi,511	246	mov esi,511
246	and esi,eax ; esi = position in fat sector	247	and esi,eax ; esi = position in fat sector
247	shr eax,9 ; eax = fat sector	248	shr eax,9 ; eax = fat sector
248	add eax,[FAT_START]	249	add eax,[FAT_START]
249	mov ebx,fat_cache	250	mov ebx,fat_cache
250		251
251	cmp eax,[fat_in_cache] ; is fat sector already in memory?	252	cmp eax,[fat_in_cache] ; is fat sector already in memory?
252	je gfc_in_cache	253	je gfc_in_cache
253		254
254	cmp [fat_change],0 ; is fat changed?	255	cmp [fat_change],0 ; is fat changed?
255	je gfc_no_change ; no	256	je gfc_no_change ; no
256	call write_fat_sector ; yes. write it into disk	257	call write_fat_sector ; yes. write it into disk
257	cmp [hd_error],0	258	cmp [hd_error],0
258	jne hd_error_01	259	jne hd_error_01
259		260
260	gfc_no_change:	261	gfc_no_change:
261	mov [fat_in_cache],eax	262	mov [fat_in_cache],eax
262	call hd_read	263	call hd_read
263	cmp [hd_error],0	264	cmp [hd_error],0
264	jne hd_error_01	265	jne hd_error_01
265		266
266	gfc_in_cache:	267	gfc_in_cache:
267	mov eax,[ebx+esi]	268	mov eax,[ebx+esi]
268	and eax,[fatMASK]	269	and eax,[fatMASK]
269	hd_error_01:	270	hd_error_01:
270	pop esi ebx	271	pop esi ebx
271	ret	272	ret
272		273
273		274
274	get_free_FAT:	275	get_free_FAT:
275	;-----------------------------------------------------------	276	;-----------------------------------------------------------
276	; input : EAX = # cluster for start the searching	277	; input : EAX = # cluster for start the searching
277	; output : if CARRY=0 EAX = # first cluster found free	278	; output : if CARRY=0 EAX = # first cluster found free
278	; if CARRY=1 disk full	279	; if CARRY=1 disk full
279	; Note : for more speed need to use fat_cache directly	280	; Note : for more speed need to use fat_cache directly
280	;-----------------------------------------------------------	281	;-----------------------------------------------------------
281	push ecx	282	push ecx
282	mov ecx,[LAST_CLUSTER] ; counter for full disk	283	mov ecx,[LAST_CLUSTER] ; counter for full disk
283	sub ecx,2	284	sub ecx,2
284		285
285	gff_test:	286	gff_test:
286	cmp eax,[LAST_CLUSTER] ; if above last cluster start at cluster 2	287	cmp eax,[LAST_CLUSTER] ; if above last cluster start at cluster 2
287	jbe gff_in_range	288	jbe gff_in_range
288	mov eax,2	289	mov eax,2
289		290
290	gff_in_range:	291	gff_in_range:
291	push eax	292	push eax
292	call get_FAT ; get cluster state	293	call get_FAT ; get cluster state
293	cmp [hd_error],0	294	cmp [hd_error],0
294	jne gff_not_found_1	295	jne gff_not_found_1
295		296
296	test eax,eax ; is it free?	297	test eax,eax ; is it free?
297	pop eax	298	pop eax
298	je gff_found ; yes	299	je gff_found ; yes
299	inc eax ; next cluster	300	inc eax ; next cluster
300	dec ecx ; is all checked?	301	dec ecx ; is all checked?
301	jns gff_test ; no	302	jns gff_test ; no
302		303
303	gff_not_found_1:	304	gff_not_found_1:
304	add esp,4	305	add esp,4
305	gff_not_found:	306	gff_not_found:
306	pop ecx ; yes. disk is full	307	pop ecx ; yes. disk is full
307	stc	308	stc
308	ret	309	ret
309		310
310	gff_found:	311	gff_found:
311	pop ecx	312	pop ecx
312	clc	313	clc
313	ret	314	ret
314		315
315		316
316	write_fat_sector:	317	write_fat_sector:
317	;-----------------------------------------------------------	318	;-----------------------------------------------------------
318	; write changed fat to disk	319	; write changed fat to disk
319	;-----------------------------------------------------------	320	;-----------------------------------------------------------
320	push eax ebx ecx	321	push eax ebx ecx
321		322
322	mov [fat_change],0	323	mov [fat_change],0
323	mov eax,[fat_in_cache]	324	mov eax,[fat_in_cache]
324	cmp eax,-1	325	cmp eax,-1
325	jz write_fat_not_used	326	jz write_fat_not_used
326	mov ebx,fat_cache	327	mov ebx,fat_cache
327	mov ecx,[NUMBER_OF_FATS]	328	mov ecx,[NUMBER_OF_FATS]
328		329
329	write_next_fat:	330	write_next_fat:
330	call hd_write	331	call hd_write
331	cmp [hd_error],0	332	cmp [hd_error],0
332	jne write_fat_not_used	333	jne write_fat_not_used
333		334
334	add eax,[SECTORS_PER_FAT]	335	add eax,[SECTORS_PER_FAT]
335	dec ecx	336	dec ecx
336	jnz write_next_fat	337	jnz write_next_fat
337		338
338	write_fat_not_used:	339	write_fat_not_used:
339	pop ecx ebx eax	340	pop ecx ebx eax
340	ret	341	ret
341		342
342		343
343	analyze_directory:	344	analyze_directory:
344	;-----------------------------------------------------------	345	;-----------------------------------------------------------
345	; input : EAX = first cluster of the directory	346	; input : EAX = first cluster of the directory
346	; EBX = pointer to filename	347	; EBX = pointer to filename
347	; output : IF CARRY=0 EAX = sector where th file is found	348	; output : IF CARRY=0 EAX = sector where th file is found
348	; EBX = pointer in buffer	349	; EBX = pointer in buffer
349	; [buffer .. buffer+511]	350	; [buffer .. buffer+511]
350	; ECX,EDX,ESI,EDI not changed	351	; ECX,EDX,ESI,EDI not changed
351	; IF CARRY=1 filename not found	352	; IF CARRY=1 filename not found
352	; Note : if cluster=0 it's changed to read rootdir	353	; Note : if cluster=0 it's changed to read rootdir
353	; save 2 previous directory sectors in longname_sec	354	; save 2 previous directory sectors in longname_sec
354	;-----------------------------------------------------------	355	;-----------------------------------------------------------
355	push ecx edx esi edi ebx ; ebx = [esp+0]	356	push ecx edx esi edi ebx ; ebx = [esp+0]
356	mov [longname_sec1],0	357	mov [longname_sec1],0
357	mov [longname_sec2],0	358	mov [longname_sec2],0
358		359
359	adr_new_cluster:	360	adr_new_cluster:
360	mov [cluster_tmp],eax	361	mov [cluster_tmp],eax
361	mov [fat16_root],0	362	mov [fat16_root],0
362	cmp eax,[LAST_CLUSTER]	363	cmp eax,[LAST_CLUSTER]
363	ja adr_not_found ; too big cluster number, something is wrong	364	ja adr_not_found ; too big cluster number, something is wrong
364	cmp eax,2	365	cmp eax,2
365	jnb adr_data_cluster	366	jnb adr_data_cluster
366		367
367	mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir	368	mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir
368	cmp [fat_type],16	369	cmp [fat_type],16
369	jne adr_data_cluster	370	jne adr_data_cluster
370	mov eax,[ROOT_START]	371	mov eax,[ROOT_START]
371	mov edx,[ROOT_SECTORS]	372	mov edx,[ROOT_SECTORS]
372	mov [fat16_root],1 ; flag for fat16 rootdir	373	mov [fat16_root],1 ; flag for fat16 rootdir
373	jmp adr_new_sector	374	jmp adr_new_sector
374		375
375	adr_data_cluster:	376	adr_data_cluster:
376	sub eax,2	377	sub eax,2
377	mov edx,[SECTORS_PER_CLUSTER]	378	mov edx,[SECTORS_PER_CLUSTER]
378	imul eax,edx	379	imul eax,edx
379	add eax,[DATA_START]	380	add eax,[DATA_START]
380		381
381	adr_new_sector:	382	adr_new_sector:
382	mov ebx,buffer	383	mov ebx,buffer
383	call hd_read	384	call hd_read
384	cmp [hd_error],0	385	cmp [hd_error],0
385	jne adr_not_found	386	jne adr_not_found
386		387
387	mov ecx,512/32 ; count of dir entrys per sector = 16	388	mov ecx,512/32 ; count of dir entrys per sector = 16
388		389
389	adr_analyze:	390	adr_analyze:
390	mov edi,[ebx+11] ; file attribute	391	mov edi,[ebx+11] ; file attribute
391	and edi,0xf	392	and edi,0xf
392	cmp edi,0xf	393	cmp edi,0xf
393	je adr_long_filename	394	je adr_long_filename
394	test edi,0x8 ; skip over volume label	395	test edi,0x8 ; skip over volume label
395	jne adr_long_filename ; Note: label can be same name as file/dir	396	jne adr_long_filename ; Note: label can be same name as file/dir
396		397
397	mov esi,[esp+0] ; filename need to be uppercase	398	mov esi,[esp+0] ; filename need to be uppercase
398	mov edi,ebx	399	mov edi,ebx
399	push ecx	400	push ecx
400	mov ecx,11	401	mov ecx,11
401	cld	402	cld
402	rep cmpsb ; compare 8+3 filename	403	rep cmpsb ; compare 8+3 filename
403	pop ecx	404	pop ecx
404	je adr_found	405	je adr_found
405		406
406	adr_long_filename:	407	adr_long_filename:
407	add ebx,32 ; position of next dir entry	408	add ebx,32 ; position of next dir entry
408	dec ecx	409	dec ecx
409	jnz adr_analyze	410	jnz adr_analyze
410		411
411	mov ecx,[longname_sec1] ; save 2 previous directory sectors	412	mov ecx,[longname_sec1] ; save 2 previous directory sectors
412	mov [longname_sec1],eax ; for delete long filename	413	mov [longname_sec1],eax ; for delete long filename
413	mov [longname_sec2],ecx	414	mov [longname_sec2],ecx
414	inc eax ; next sector	415	inc eax ; next sector
415	dec edx	416	dec edx
416	jne adr_new_sector	417	jne adr_new_sector
417	cmp [fat16_root],1 ; end of fat16 rootdir	418	cmp [fat16_root],1 ; end of fat16 rootdir
418	je adr_not_found	419	je adr_not_found
419		420
420	adr_next_cluster:	421	adr_next_cluster:
421	mov eax,[cluster_tmp]	422	mov eax,[cluster_tmp]
422	call get_FAT ; get next cluster	423	call get_FAT ; get next cluster
423	cmp [hd_error],0	424	cmp [hd_error],0
424	jne adr_not_found	425	jne adr_not_found
425		426
426	cmp eax,2 ; incorrect fat chain?	427	cmp eax,2 ; incorrect fat chain?
427	jb adr_not_found ; yes	428	jb adr_not_found ; yes
428	cmp eax,[fatRESERVED] ; is it end of directory?	429	cmp eax,[fatRESERVED] ; is it end of directory?
429	jb adr_new_cluster ; no. analyse it	430	jb adr_new_cluster ; no. analyse it
430		431
431	adr_not_found:	432	adr_not_found:
432	pop edi edi esi edx ecx ; first edi will remove ebx	433	pop edi edi esi edx ecx ; first edi will remove ebx
433	stc ; file not found	434	stc ; file not found
434	ret	435	ret
435		436
436	adr_found:	437	adr_found:
437	pop edi edi esi edx ecx ; first edi will remove ebx	438	pop edi edi esi edx ecx ; first edi will remove ebx
438	clc ; file found	439	clc ; file found
439	ret	440	ret
440		441
441		442
442	analyze_directory_to_write:	443	analyze_directory_to_write:
443	;-----------------------------------------------------------	444	;-----------------------------------------------------------
444	; input : EAX = first cluster of the directory	445	; input : EAX = first cluster of the directory
445	; output : IF CARRY=0 EAX = sector where the empty pos is found	446	; output : IF CARRY=0 EAX = sector where the empty pos is found
446	; EBX = pointer in buffer	447	; EBX = pointer in buffer
447	; [buffer .. buffer+511]	448	; [buffer .. buffer+511]
448	; ECX,EDX,ESI,EDI not changed	449	; ECX,EDX,ESI,EDI not changed
449	; IF CARRY=1 disk full or fat corrupted	450	; IF CARRY=1 disk full or fat corrupted
450	; Note : if cluster=0 it's changed to read rootdir	451	; Note : if cluster=0 it's changed to read rootdir
451	;-----------------------------------------------------------	452	;-----------------------------------------------------------
452	push ecx edx edi	453	push ecx edx edi
453		454
454	adw_new_cluster:	455	adw_new_cluster:
455	mov [cluster_tmp],eax	456	mov [cluster_tmp],eax
456	mov [fat16_root],0	457	mov [fat16_root],0
457	cmp eax,[LAST_CLUSTER]	458	cmp eax,[LAST_CLUSTER]
458	ja adw_not_found ; too big cluster number, something is wrong	459	ja adw_not_found ; too big cluster number, something is wrong
459	cmp eax,2	460	cmp eax,2
460	jnb adw_data_cluster	461	jnb adw_data_cluster
461		462
462	mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir	463	mov eax,[ROOT_CLUSTER] ; if cluster < 2 then read rootdir
463	cmp [fat_type],16	464	cmp [fat_type],16
464	jne adw_data_cluster	465	jne adw_data_cluster
465	mov eax,[ROOT_START]	466	mov eax,[ROOT_START]
466	mov edx,[ROOT_SECTORS]	467	mov edx,[ROOT_SECTORS]
467	mov [fat16_root],1 ; flag for fat16 rootdir	468	mov [fat16_root],1 ; flag for fat16 rootdir
468	jmp adw_new_sector	469	jmp adw_new_sector
469		470
470	adw_data_cluster:	471	adw_data_cluster:
471	sub eax,2	472	sub eax,2
472	mov edx,[SECTORS_PER_CLUSTER]	473	mov edx,[SECTORS_PER_CLUSTER]
473	imul eax,edx	474	imul eax,edx
474	add eax,[DATA_START]	475	add eax,[DATA_START]
475		476
476	adw_new_sector:	477	adw_new_sector:
477	mov ebx,buffer	478	mov ebx,buffer
478	call hd_read	479	call hd_read
479	cmp [hd_error],0	480	cmp [hd_error],0
480	jne adw_not_found	481	jne adw_not_found
481		482
482	mov ecx,512/32 ; count of dir entrys per sector = 16	483	mov ecx,512/32 ; count of dir entrys per sector = 16
483		484
484	adw_analyze:	485	adw_analyze:
485	cmp byte [ebx],0x00 ; is free entry?	486	cmp byte [ebx],0x00 ; is free entry?
486	je adw_found ; yes	487	je adw_found ; yes
487	cmp byte [ebx],0xe5 ; is deleted entry?	488	cmp byte [ebx],0xe5 ; is deleted entry?
488	je adw_found ; yes	489	je adw_found ; yes
489	add ebx,32 ; position of next dir entry	490	add ebx,32 ; position of next dir entry
490	dec ecx	491	dec ecx
491	jnz adw_analyze	492	jnz adw_analyze
492		493
493	inc eax ; next sector	494	inc eax ; next sector
494	dec edx	495	dec edx
495	jne adw_new_sector	496	jne adw_new_sector
496	cmp [fat16_root],1 ; end of fat16 rootdir	497	cmp [fat16_root],1 ; end of fat16 rootdir
497	je adw_not_found	498	je adw_not_found
498		499
499	mov eax,[cluster_tmp]	500	mov eax,[cluster_tmp]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fat32.inc – Rev 78 → 83