Subversion Repositories Kolibri OS

Rev

Rev 131 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                                 ;;
  3. ;;  FAT32.INC                                                      ;;
  4. ;;                                                                 ;;
  5. ;;  FAT16/32 functions for KolibriOS                               ;;
  6. ;;                                                                 ;;
  7. ;;  Copyright 2002 Paolo Minazzi, paolo.minazzi@inwind.it          ;;
  8. ;;                                                                 ;;
  9. ;;  See file COPYING for details                                   ;;
  10. ;;  17.08.2006 LFN write/append to file - diamond                  ;;
  11. ;;  23.06.2006 LFN start application - diamond                     ;;
  12. ;;  15.06.2006 LFN get/set file/folder info - diamond              ;;
  13. ;;  27.05.2006 LFN create/rewrite file - diamond                   ;;
  14. ;;  04.05.2006 LFN read folder - diamond                           ;;
  15. ;;  29.04.2006 Elimination of hangup after the                     ;;
  16. ;;             expiration hd_wait_timeout -  Mario79               ;;          
  17. ;;  23.04.2006 LFN read file - diamond                             ;;
  18. ;;  28.01.2006 find all Fat16/32 partition in all input point      ;;
  19. ;;             to MBR, see file part_set.inc - Mario79             ;;
  20. ;;  15.01.2005 get file size/attr/date, file_append - ATV          ;;
  21. ;;  04.12.2004 skip volume label, file delete bug fixed - ATV      ;;
  22. ;;  29.11.2004 get_free_FAT changed, append dir bug fixed - ATV    ;;
  23. ;;  23.11.2004 don't allow overwrite dir with file - ATV           ;;
  24. ;;  18.11.2004 get_disk_info and more error codes - ATV            ;;
  25. ;;  17.11.2004 set_FAT/get_FAT and disk cache rewritten - ATV      ;;
  26. ;;  10.11.2004 removedir clear whole directory structure - ATV     ;;
  27. ;;  08.11.2004 rename - ATV                                        ;;
  28. ;;  30.10.2004 file_read return also dirsize in bytes - ATV        ;;
  29. ;;  20.10.2004 Makedir/Removedir - ATV                             ;;
  30. ;;  14.10.2004 Partition chain/Fat16 - ATV (thanks drh3xx)         ;;
  31. ;;  06.9.2004  Fix free space by Mario79 added - MH                ;;
  32. ;;  24.5.2004  Write back buffer for File_write -VT                ;;
  33. ;;  20.5.2004  File_read function to work with syscall 58 - VT     ;;
  34. ;;  30.3.2004  Error parameters at function return - VT            ;;
  35. ;;  01.5.2002  Bugfix in device write - VT                         ;;
  36. ;;  20.5.2002  Hd status check - VT                                ;;
  37. ;;  29.6.2002  Improved fat32 verification - VT                    ;;
  38. ;;                                                                 ;;
  39. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  40.  
  41. cache_max equ 1919      ; max. is 1919*512+0x610000=0x6ffe00
  42.  
  43. ERROR_SUCCESS        = 0
  44. ERROR_DISK_BASE      = 1
  45. ERROR_UNSUPPORTED_FS = 2
  46. ERROR_UNKNOWN_FS     = 3
  47. ERROR_PARTITION      = 4
  48. ERROR_FILE_NOT_FOUND = 5
  49. ERROR_END_OF_FILE    = 6
  50. ERROR_MEMORY_POINTER = 7
  51. ERROR_DISK_FULL      = 8
  52. ERROR_FAT_TABLE      = 9
  53. ERROR_ACCESS_DENIED  = 10
  54.  
  55. PUSHAD_EAX equ [esp+28]
  56. PUSHAD_ECX equ [esp+24]
  57. PUSHAD_EDX equ [esp+20]
  58. PUSHAD_EBX equ [esp+16]
  59. PUSHAD_EBP equ [esp+8]
  60. PUSHAD_ESI equ [esp+4]
  61. PUSHAD_EDI equ [esp+0]
  62.  
  63. cluster              dd 0       ; used by file_write,makedir,append
  64. partition_count      dd 0       ; partitions found by set_FAT32_variables
  65. longname_sec1        dd 0       ; used by analyze_directory to save 2 previous
  66. longname_sec2        dd 0       ; directory sectors for delete long filename
  67.  
  68. hd_error             dd 0       ; set by wait_for_sector_buffer
  69. hd_setup             dd 0
  70. hd_wait_timeout      dd 0
  71.  
  72. cluster_tmp          dd 0       ; used by analyze_directory
  73.                                 ; and analyze_directory_to_write
  74.  
  75. file_size            dd 0       ; used by file_read
  76.  
  77. sector_tmp           dd 0       ; used by rename,append,file_write
  78. entry_pos            dd 0       ; used by rename,append,file_write
  79.  
  80. old_filesize         dd 0       ; used by append
  81. new_filepos          dd 0       ; used by append
  82. bytes2write          dd 0       ; used by append
  83.  
  84. cache_search_start   dd 0       ; used by find_empty_slot
  85.  
  86. fat_in_cache         dd -1
  87. fat_cache:           times 512 db 0
  88.  
  89. uglobal
  90.  Sector512:                      ; label for dev_hdcd.inc
  91.   buffer:              times 512 db 0
  92.   deltree_buffer:      times 512 db 0
  93.   fsinfo_buffer:       times 512 db 0
  94. endg
  95.  
  96. iglobal
  97.   NewDirEntry1         db ".          ",0x10
  98.                      times 20 db 0
  99.   NewDirEntry2         db "..         ",0x10
  100.                      times 20 db 0
  101. endg
  102.  
  103. uglobal
  104.   dir_entry:           times 32 db 0
  105.  
  106.   startpath:           times 255 db 0
  107.  
  108.   fat16_root           db 0       ; flag for fat16 rootdir
  109.   fat_change           db 0       ; 1=fat has changed
  110.  
  111. endg
  112.  
  113. reserve_hd1:
  114.  
  115.     cli
  116.     cmp   [hd1_status],0
  117.     je    reserve_ok1
  118.  
  119.     sti
  120.     call  change_task
  121.     jmp   reserve_hd1
  122.  
  123.   reserve_ok1:
  124.  
  125.     push  eax
  126.     mov   eax,[0x3000]
  127.     shl   eax,5
  128.     mov   eax,[eax+0x3000+TASKDATA.pid]
  129.     mov   [hd1_status],eax
  130.     pop   eax
  131.     sti
  132.     ret
  133. ;********************************************
  134. reserve_hd_channel:
  135.     cmp   [hdbase], 0x1F0
  136.     jne   .IDE_Channel_2
  137. .IDE_Channel_1:
  138.     cli
  139.     cmp   [IDE_Channel_1],0
  140.     je    .reserve_ok_1
  141.     sti
  142.     call  change_task
  143.     jmp   .IDE_Channel_1
  144. .IDE_Channel_2:
  145.     cli
  146.     cmp   [IDE_Channel_2],0
  147.     je    .reserve_ok_2
  148.     sti
  149.     call  change_task
  150.     jmp   .IDE_Channel_1
  151. .reserve_ok_1:
  152.     mov [IDE_Channel_1],1
  153.     ret
  154. .reserve_ok_2:
  155.     mov [IDE_Channel_2],1
  156.     ret
  157.    
  158. free_hd_channel:
  159.     cmp   [hdbase], 0x1F0
  160.     jne   .IDE_Channel_2
  161. .IDE_Channel_1:
  162.     mov [IDE_Channel_1],0
  163.     ret
  164. .IDE_Channel_2:
  165.     mov [IDE_Channel_2],0
  166.     ret
  167. ;********************************************
  168. clear_hd_cache:
  169.  
  170.     push  eax ecx edi
  171.     mov   edi,0x600000
  172.     mov   ecx,16384
  173.     xor   eax,eax
  174.     cld
  175.     rep   stosd                 ; clear hd cache with 0
  176.     mov   [cache_search_start],eax
  177.     mov   [fat_in_cache],-1
  178.     mov   [fat_change],0
  179.     pop   edi ecx eax
  180.     ret
  181.  
  182. problem_partition db 0  ; used for partitions search
  183.  
  184. include  'part_set.inc'
  185.  
  186. set_FAT:
  187. ;--------------------------------
  188. ; input  : EAX = cluster
  189. ;          EDX = value to save
  190. ; output : EDX = old value
  191. ;--------------------------------
  192.     push  eax ebx esi
  193.  
  194.     cmp   eax,2
  195.     jb    sfc_error
  196.     cmp   eax,[LAST_CLUSTER]
  197.     ja    sfc_error
  198.     cmp   [fat_type],16
  199.     je    sfc_1
  200.     add   eax,eax
  201.   sfc_1:
  202.     add   eax,eax
  203.     mov   esi,511
  204.     and   esi,eax               ; esi = position in fat sector
  205.     shr   eax,9                 ; eax = fat sector
  206.     add   eax,[FAT_START]
  207.     mov   ebx,fat_cache
  208.  
  209.     cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
  210.     je    sfc_in_cache          ; yes
  211.  
  212.     cmp   [fat_change],0        ; is fat changed?
  213.     je    sfc_no_change         ; no
  214.     call  write_fat_sector      ; yes. write it into disk
  215.     cmp   [hd_error],0
  216.     jne   sfc_error
  217.  
  218.   sfc_no_change:
  219.     mov   [fat_in_cache],eax    ; save fat sector
  220.     call  hd_read
  221.     cmp  [hd_error],0
  222.     jne  sfc_error
  223.    
  224.  
  225.   sfc_in_cache:
  226.     cmp   [fat_type],16
  227.     jne   sfc_test32
  228.  
  229.   sfc_set16:
  230.     xchg  [ebx+esi],dx          ; save new value and get old value
  231.     jmp   sfc_write
  232.  
  233.   sfc_test32:
  234.     mov   eax,[fatMASK]
  235.  
  236.   sfc_set32:
  237.     and   edx,eax
  238.     xor   eax,-1                ; mask for high bits
  239.     and   eax,[ebx+esi]         ; get high 4 bits
  240.     or    eax,edx
  241.     mov   edx,[ebx+esi]         ; get old value
  242.     mov   [ebx+esi],eax         ; save new value
  243.  
  244.   sfc_write:
  245.     mov   [fat_change],1        ; fat has changed
  246.  
  247.   sfc_nonzero:
  248.     and   edx,[fatMASK]
  249.  
  250.   sfc_error:
  251.     pop   esi ebx eax
  252.     ret
  253.  
  254.  
  255. get_FAT:
  256. ;--------------------------------
  257. ; input  : EAX = cluster
  258. ; output : EAX = next cluster
  259. ;--------------------------------
  260.     push  ebx esi
  261.  
  262.     cmp   [fat_type],16
  263.     je    gfc_1
  264.     add   eax,eax
  265.   gfc_1:
  266.     add   eax,eax
  267.     mov   esi,511
  268.     and   esi,eax               ; esi = position in fat sector
  269.     shr   eax,9                 ; eax = fat sector
  270.     add   eax,[FAT_START]
  271.     mov   ebx,fat_cache
  272.  
  273.     cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
  274.     je    gfc_in_cache
  275.  
  276.     cmp   [fat_change],0        ; is fat changed?
  277.     je    gfc_no_change         ; no
  278.     call  write_fat_sector      ; yes. write it into disk
  279.     cmp  [hd_error],0
  280.     jne  hd_error_01
  281.  
  282.   gfc_no_change:
  283.     mov   [fat_in_cache],eax
  284.     call  hd_read
  285.     cmp  [hd_error],0
  286.     jne  hd_error_01
  287.  
  288.   gfc_in_cache:
  289.     mov   eax,[ebx+esi]
  290.     and   eax,[fatMASK]
  291.  hd_error_01:
  292.     pop   esi ebx
  293.     ret
  294.  
  295.  
  296. get_free_FAT:
  297. ;-----------------------------------------------------------
  298. ; input  : EAX = # cluster for start the searching
  299. ; output : if CARRY=0 EAX = # first cluster found free
  300. ;          if CARRY=1 disk full
  301. ; Note   : for more speed need to use fat_cache directly
  302. ;-----------------------------------------------------------
  303.     push  ecx
  304.     mov   ecx,[LAST_CLUSTER]    ; counter for full disk
  305.     sub   ecx,2
  306.  
  307.   gff_test:
  308.     cmp   eax,[LAST_CLUSTER]    ; if above last cluster start at cluster 2
  309.     jbe   gff_in_range
  310.     mov   eax,2
  311.  
  312.   gff_in_range:
  313.     push  eax
  314.     call  get_FAT               ; get cluster state
  315.     cmp   [hd_error],0
  316.     jne   gff_not_found_1
  317.  
  318.     test  eax,eax               ; is it free?
  319.     pop   eax
  320.     je    gff_found             ; yes
  321.     inc   eax                   ; next cluster
  322.     dec   ecx                   ; is all checked?
  323.     jns   gff_test              ; no
  324.  
  325.   gff_not_found_1:
  326.     add   esp,4
  327.   gff_not_found:
  328.     pop   ecx                   ; yes. disk is full
  329.     stc
  330.     ret
  331.  
  332.   gff_found:
  333.     pop   ecx
  334.     clc
  335.     ret
  336.  
  337.  
  338. write_fat_sector:
  339. ;-----------------------------------------------------------
  340. ; write changed fat to disk
  341. ;-----------------------------------------------------------
  342.     push  eax ebx ecx
  343.  
  344.     mov   [fat_change],0
  345.     mov   eax,[fat_in_cache]
  346.     cmp   eax,-1
  347.     jz    write_fat_not_used
  348.     mov   ebx,fat_cache
  349.     mov   ecx,[NUMBER_OF_FATS]
  350.  
  351.   write_next_fat:
  352.     call  hd_write
  353.     cmp   [hd_error],0
  354.     jne   write_fat_not_used
  355.  
  356.     add   eax,[SECTORS_PER_FAT]
  357.     dec   ecx
  358.     jnz   write_next_fat
  359.  
  360.   write_fat_not_used:
  361.     pop   ecx ebx eax
  362.     ret
  363.  
  364.  
  365. analyze_directory:
  366. ;-----------------------------------------------------------
  367. ; input  : EAX = first cluster of the directory
  368. ;          EBX = pointer to filename
  369. ; output : IF CARRY=0 EAX = sector where th file is found
  370. ;                     EBX = pointer in buffer
  371. ;                     [buffer .. buffer+511]
  372. ;                     ECX,EDX,ESI,EDI not changed
  373. ;          IF CARRY=1 filename not found
  374. ; Note   : if cluster=0 it's changed to read rootdir
  375. ;          save 2 previous directory sectors in longname_sec
  376. ;-----------------------------------------------------------
  377.     push  ecx edx esi edi ebx   ; ebx = [esp+0]
  378.     mov   [longname_sec1],0
  379.     mov   [longname_sec2],0
  380.  
  381.   adr_new_cluster:
  382.     mov   [cluster_tmp],eax
  383.     mov   [fat16_root],0
  384.     cmp   eax,[LAST_CLUSTER]
  385.     ja    adr_not_found         ; too big cluster number, something is wrong
  386.     cmp   eax,2
  387.     jnb   adr_data_cluster
  388.  
  389.     mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
  390.     cmp   [fat_type],16
  391.     jne   adr_data_cluster
  392.     mov   eax,[ROOT_START]
  393.     mov   edx,[ROOT_SECTORS]
  394.     mov   [fat16_root],1        ; flag for fat16 rootdir
  395.     jmp   adr_new_sector
  396.  
  397.   adr_data_cluster:
  398.     sub   eax,2
  399.     mov   edx,[SECTORS_PER_CLUSTER]
  400.     imul  eax,edx
  401.     add   eax,[DATA_START]
  402.  
  403.   adr_new_sector:
  404.     mov   ebx,buffer
  405.     call  hd_read
  406.     cmp  [hd_error],0
  407.     jne  adr_not_found
  408.  
  409.     mov   ecx,512/32            ; count of dir entrys per sector = 16
  410.  
  411.   adr_analyze:
  412.     mov   edi,[ebx+11]          ; file attribute
  413.     and   edi,0xf
  414.     cmp   edi,0xf
  415.     je    adr_long_filename
  416.     test  edi,0x8               ; skip over volume label
  417.     jne   adr_long_filename     ; Note: label can be same name as file/dir
  418.  
  419.     mov   esi,[esp+0]           ; filename need to be uppercase
  420.     mov   edi,ebx
  421.     push  ecx
  422.     mov   ecx,11
  423.     cld
  424.     rep   cmpsb                 ; compare 8+3 filename
  425.     pop   ecx
  426.     je    adr_found
  427.  
  428.   adr_long_filename:
  429.     add   ebx,32                ; position of next dir entry
  430.     dec   ecx
  431.     jnz   adr_analyze
  432.  
  433.     mov   ecx,[longname_sec1]   ; save 2 previous directory sectors
  434.     mov   [longname_sec1],eax   ; for delete long filename
  435.     mov   [longname_sec2],ecx
  436.     inc   eax                   ; next sector
  437.     dec   edx
  438.     jne   adr_new_sector
  439.     cmp   [fat16_root],1        ; end of fat16 rootdir
  440.     je    adr_not_found
  441.  
  442.   adr_next_cluster:
  443.     mov   eax,[cluster_tmp]
  444.     call  get_FAT               ; get next cluster
  445.     cmp  [hd_error],0
  446.     jne  adr_not_found
  447.  
  448.     cmp   eax,2                 ; incorrect fat chain?
  449.     jb    adr_not_found         ; yes
  450.     cmp   eax,[fatRESERVED]     ; is it end of directory?
  451.     jb    adr_new_cluster       ; no. analyse it
  452.  
  453.   adr_not_found:
  454.     pop   edi edi esi edx ecx   ; first edi will remove ebx
  455.     stc                         ; file not found
  456.     ret
  457.  
  458.   adr_found:
  459.     pop   edi edi esi edx ecx   ; first edi will remove ebx
  460.     clc                         ; file found
  461.     ret
  462.  
  463.  
  464. analyze_directory_to_write:
  465. ;-----------------------------------------------------------
  466. ; input  : EAX = first cluster of the directory
  467. ; output : IF CARRY=0 EAX = sector where the empty pos is found
  468. ;                     EBX = pointer in buffer
  469. ;                     [buffer .. buffer+511]
  470. ;                     ECX,EDX,ESI,EDI not changed
  471. ;          IF CARRY=1 disk full or fat corrupted
  472. ; Note   : if cluster=0 it's changed to read rootdir
  473. ;-----------------------------------------------------------
  474.     push  ecx edx edi
  475.  
  476.   adw_new_cluster:
  477.     mov   [cluster_tmp],eax
  478.     mov   [fat16_root],0
  479.     cmp   eax,[LAST_CLUSTER]
  480.     ja    adw_not_found         ; too big cluster number, something is wrong
  481.     cmp   eax,2
  482.     jnb   adw_data_cluster
  483.  
  484.     mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
  485.     cmp   [fat_type],16
  486.     jne   adw_data_cluster
  487.     mov   eax,[ROOT_START]
  488.     mov   edx,[ROOT_SECTORS]
  489.     mov   [fat16_root],1        ; flag for fat16 rootdir
  490.     jmp   adw_new_sector
  491.  
  492.   adw_data_cluster:
  493.     sub   eax,2
  494.     mov   edx,[SECTORS_PER_CLUSTER]
  495.     imul  eax,edx
  496.     add   eax,[DATA_START]
  497.  
  498.   adw_new_sector:
  499.     mov   ebx,buffer
  500.     call  hd_read
  501.     cmp  [hd_error],0
  502.     jne  adw_not_found
  503.  
  504.     mov   ecx,512/32            ; count of dir entrys per sector = 16
  505.  
  506.   adw_analyze:
  507.     cmp   byte [ebx],0x00       ; is free entry?
  508.     je    adw_found             ; yes
  509.     cmp   byte [ebx],0xe5       ; is deleted entry?
  510.     je    adw_found             ; yes
  511.     add   ebx,32                ; position of next dir entry
  512.     dec   ecx
  513.     jnz   adw_analyze
  514.  
  515.     inc   eax                   ; next sector
  516.     dec   edx
  517.     jne   adw_new_sector
  518.     cmp   [fat16_root],1        ; end of fat16 rootdir
  519.     je    adw_not_found
  520.  
  521.     mov   eax,[cluster_tmp]
  522.     call  get_FAT               ; get next cluster
  523.     cmp   [hd_error],0
  524.     jne   adw_not_found
  525.  
  526.     cmp   eax,2                 ; incorrect fat chain?
  527.     jb    adw_not_found         ; yes
  528.     cmp   eax,[fatRESERVED]     ; is it end of directory?
  529.     jb    adw_new_cluster       ; no. analyse it
  530.  
  531.     mov   eax,2                 ; this block of code add a new cluster
  532.     call  get_free_FAT          ; for the directory because the directory
  533.     jc    adw_not_found         ; is full
  534.  
  535.     mov   edx,[fatEND]          ; new end for directory
  536.     call  set_FAT
  537.     cmp  [hd_error],0
  538.     jne  adw_not_found
  539.  
  540.     push  eax                   ; save new cluster
  541.     mov   edx,eax
  542.     mov   eax,[cluster_tmp]     ; change last cluster to point new cluster
  543.     call  set_FAT
  544.     cmp  [hd_error],0
  545.     jne  adw_not_found_1
  546.  
  547.     mov   ecx,-1                ; remove 1 cluster from free disk space
  548.     call  add_disk_free_space
  549.     cmp  [hd_error],0
  550.     jne    adw_not_found_1
  551.  
  552.     mov   ecx,512/4
  553.     xor   eax,eax
  554.     mov   edi,buffer
  555.     cld
  556.     rep   stosd                 ; clear new directory cluster
  557.     pop   eax
  558.  
  559.     sub   eax,2
  560.     mov   ecx,[SECTORS_PER_CLUSTER]
  561.     imul  eax,ecx
  562.     add   eax,[DATA_START]
  563.     mov   ebx,buffer
  564.     push  eax                   ; save sector number
  565.  
  566.   adw_set_empty_directory:
  567.     call  hd_write
  568.     cmp   [hd_error],0
  569.     jne   adw_not_found_1
  570.  
  571.     inc   eax                   ; next sector
  572.     dec   ecx
  573.     jnz   adw_set_empty_directory
  574.  
  575.     pop   eax
  576.  
  577.   adw_found:
  578.     pop   edi edx ecx
  579.     clc                         ; free space found
  580.     ret
  581.   adw_not_found_1:
  582.     add  esp,4
  583.   adw_not_found:
  584.     pop   edi edx ecx
  585.     stc                         ; free space not found
  586.     ret
  587.  
  588.  
  589. get_data_cluster:
  590. ;-----------------------------------------------------------
  591. ; input  : EAX = cluster
  592. ;          EBX = pointer to buffer
  593. ;          EDX = # blocks to read in buffer
  594. ;          ESI = # blocks to skip over
  595. ; output : if CARRY=0 ok EBX/EDX/ESI updated
  596. ;          if CARRY=1 cluster out of range
  597. ; Note   : if cluster=0 it's changed to read rootdir
  598. ;-----------------------------------------------------------
  599.     push  eax ecx
  600.  
  601.     mov   [fat16_root],0
  602.     cmp   eax,[LAST_CLUSTER]
  603.     ja    gdc_error             ; too big cluster number, something is wrong
  604.     cmp   eax,2
  605.     jnb   gdc_cluster
  606.  
  607.     mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
  608.     cmp   [fat_type],16
  609.     jne   gdc_cluster
  610.     mov   eax,[ROOT_START]
  611.     mov   ecx,[ROOT_SECTORS]    ; Note: not cluster size
  612.     mov   [fat16_root],1        ; flag for fat16 rootdir
  613.     jmp   gdc_read
  614.  
  615.   gdc_cluster:
  616.     sub   eax,2
  617.     mov   ecx,[SECTORS_PER_CLUSTER]
  618.     imul  eax,ecx
  619.     add   eax,[DATA_START]
  620.  
  621.   gdc_read:
  622.     test  esi,esi               ; first wanted block
  623.     je    gdcl1                 ; yes, skip count is 0
  624.     dec   esi
  625.     jmp   gdcl2
  626.  
  627.   gdcl1:
  628.     call  hd_read
  629.     cmp  [hd_error],0
  630.     jne  gdc_error    
  631.  
  632.     add   ebx,512               ; update pointer
  633.     dec   edx
  634.  
  635.   gdcl2:
  636.     test  edx,edx               ; is all read?
  637.     je    out_of_read
  638.  
  639.     inc   eax                   ; next sector
  640.     dec   ecx
  641.     jnz   gdc_read
  642.  
  643.   out_of_read:
  644.     pop   ecx eax
  645.     clc
  646.     ret
  647.  
  648.   gdc_error:
  649.     pop   ecx eax
  650.     stc
  651.     ret
  652.  
  653.  
  654. set_data_cluster:
  655. ;-----------------------------------------------------------
  656. ; input  : EAX = cluster
  657. ;          EBX = pointer to buffer
  658. ; output : if CARRY=0 ok
  659. ;          if CARRY=1 cluster out of range
  660. ;-----------------------------------------------------------
  661.     push  eax ebx edx
  662.  
  663.     cmp   eax,[LAST_CLUSTER]
  664.     ja    sdc_error             ; too big cluster number, something is wrong
  665.     sub   eax,2
  666.     jb    sdc_error             ; don't allow rootdir write
  667.  
  668.     mov   edx,[SECTORS_PER_CLUSTER]
  669.     imul  eax,edx
  670.     add   eax,[DATA_START]
  671.  
  672.   sdc_write:
  673.     call  hd_write
  674.     cmp   [hd_error],0
  675.     jne   sdc_error
  676.  
  677.     add   ebx,512               ; update pointer
  678.     inc   eax
  679.     dec   edx
  680.     jnz   sdc_write
  681.     pop   edx ebx eax
  682.     clc
  683.     ret
  684.  
  685.   sdc_error:
  686.     pop   edx ebx eax
  687.     stc
  688.     ret
  689.  
  690.  
  691. get_cluster_of_a_path:
  692. ;---------------------------------------------------------
  693. ; input  : EBX = pointer to a path string
  694. ;          (example: the path "/files/data/document" become
  695. ;                             "files......data.......document...0"
  696. ;          '.' = space char
  697. ;          '0' = char(0) (ASCII=0) !!! )
  698. ; output : if (CARRY=1) -> ERROR in the PATH
  699. ;          if (CARRY=0) -> EAX=cluster
  700. ;---------------------------------------------------------
  701.     push  ebx edx
  702.  
  703.     mov   eax,[ROOT_CLUSTER]
  704.     mov   edx,ebx
  705.  
  706. search_end_of_path:
  707.     cmp   byte [edx],0
  708.     je    found_end_of_path
  709.  
  710.     inc   edx ; '/'
  711.     mov   ebx,edx
  712.     call  analyze_directory
  713.     jc    directory_not_found
  714.  
  715.     mov   eax,[ebx+20-2]        ; read the HIGH 16bit cluster field
  716.     mov   ax,[ebx+26]           ; read the LOW 16bit cluster field
  717.     and   eax,[fatMASK]
  718.     add   edx,11                ; 8+3 (name+extension)
  719.     jmp   search_end_of_path
  720.  
  721. found_end_of_path:
  722.     pop   edx ebx
  723.     clc                         ; no errors
  724.     ret
  725.  
  726. directory_not_found:
  727.     pop   edx ebx
  728.     stc                         ; errors occour
  729.     ret
  730.  
  731.  
  732. bcd2bin:
  733. ;----------------------------------
  734. ; input  : AL=BCD number (eg. 0x11)
  735. ; output : AH=0
  736. ;          AL=decimal number (eg. 11)
  737. ;----------------------------------
  738.     xor   ah,ah
  739.     shl   ax,4
  740.     shr   al,4
  741.     aad
  742.     ret
  743.  
  744.  
  745. get_date_for_file:
  746. ;-----------------------------------------------------
  747. ; Get date from CMOS and pack day,month,year in AX
  748. ; DATE   bits  0..4   : day of month 0..31
  749. ;              5..8   : month of year 1..12
  750. ;              9..15  : count of years from 1980
  751. ;-----------------------------------------------------
  752.     mov   al,0x7        ;day
  753.     out   0x70,al
  754.     in    al,0x71
  755.     call  bcd2bin
  756.     ror   eax,5
  757.  
  758.     mov   al,0x8        ;month
  759.     out   0x70,al
  760.     in    al,0x71
  761.     call  bcd2bin
  762.     ror   eax,4
  763.  
  764.     mov   al,0x9        ;year
  765.     out   0x70,al
  766.     in    al,0x71
  767.     call  bcd2bin
  768.     add   ax,20         ;because CMOS return only the two last
  769.                         ;digit (eg. 2000 -> 00 , 2001 -> 01) and we
  770.     rol   eax,9         ;need the difference with 1980 (eg. 2001-1980)
  771.     ret
  772.  
  773.  
  774. get_time_for_file:
  775. ;-----------------------------------------------------
  776. ; Get time from CMOS and pack hour,minute,second in AX
  777. ; TIME   bits  0..4   : second (the low bit is lost)
  778. ;              5..10  : minute 0..59
  779. ;              11..15 : hour 0..23
  780. ;-----------------------------------------------------
  781.     mov   al,0x0        ;second
  782.     out   0x70,al
  783.     in    al,0x71
  784.     call  bcd2bin
  785.     ror   eax,6
  786.  
  787.     mov   al,0x2        ;minute
  788.     out   0x70,al
  789.     in    al,0x71
  790.     call  bcd2bin
  791.     ror   eax,6
  792.  
  793.     mov   al,0x4        ;hour
  794.     out   0x70,al
  795.     in    al,0x71
  796.     call  bcd2bin
  797.     rol   eax,11
  798.     ret
  799.  
  800.  
  801. set_current_time_for_entry:
  802. ;-----------------------------------------------------
  803. ; Set current time/date for file entry
  804. ; input  : ebx = file entry pointer
  805. ;-----------------------------------------------------
  806.     push  eax
  807.     call  get_time_for_file     ; update files date/time
  808.     mov   [ebx+22],ax
  809.     call  get_date_for_file
  810.     mov   [ebx+24],ax
  811.     pop   eax
  812.     ret
  813.  
  814.  
  815. makedir:
  816. ;-----------------------------------------------------
  817. ; input  : eax = directory name
  818. ;          edx = path
  819. ; output : eax = 0 - ok
  820. ;                3 - unknown FS
  821. ;                5 - file not found
  822. ;                8 - disk full
  823. ;               10 - access denied
  824. ; Note   : can only make one directory at time
  825. ;-----------------------------------------------------
  826.     cmp   [fat_type],0
  827.     jnz   make_dir_fat_ok
  828.     mov   eax,ERROR_UNKNOWN_FS
  829.     ret
  830.  
  831.   make_dir_fat_ok:
  832. ;    call  reserve_hd1
  833.  
  834.     pushad
  835.  
  836.     mov   ebx,edx
  837.     call  get_cluster_of_a_path
  838.     jnc   make_dir_found_path
  839.     cmp   [hd_error],0
  840.     jne   make_dir_error_1
  841.  
  842.   make_dir_path_not_found:
  843.     popad
  844.     call  update_disk           ; write all of cache and fat to hd
  845.     cmp   [hd_error],0
  846.     jne   make_dir_error_2
  847.  
  848.     mov   [hd1_status],0
  849.     mov   eax,ERROR_FILE_NOT_FOUND
  850.     ret
  851.  
  852.   make_dir_disk_full:
  853.     cmp  [hd_error],0
  854.     jne   make_dir_error_1
  855.     popad
  856.     call  update_disk           ; write all of cache and fat to hd
  857.     cmp   [hd_error],0
  858.     jne   make_dir_error_2
  859.  
  860.     mov   [hd1_status],0
  861.     mov   eax,ERROR_DISK_FULL
  862.     ret
  863.  
  864.   make_dir_already_exist:
  865.     cmp  [hd_error],0
  866.     jne   make_dir_error_1    
  867.     mov   eax,[cluster]         ; directory cluster
  868.     xor   edx,edx               ; free
  869.     call  set_FAT
  870.     cmp  [hd_error],0
  871.     jne   make_dir_error_1
  872.  
  873.     popad
  874.     call  update_disk           ; write all of cache and fat to hd
  875.   make_dir_error_2:
  876.     mov   [hd1_status],0
  877.     mov   eax,ERROR_ACCESS_DENIED
  878.     ret
  879.  
  880.   make_dir_error_1:
  881.     popad
  882.     jmp   make_dir_error_2
  883.  
  884.   make_dir_error_3:
  885.     add  esp,4
  886.     jmp   make_dir_error_1
  887.  
  888.   make_dir_found_path:
  889.     cmp   eax,[ROOT_CLUSTER]
  890.     jnz   make_dir_not_root
  891.     xor   eax,eax
  892.  
  893.   make_dir_not_root:
  894.     mov   ecx,eax               ; directorys start cluster
  895.     mov   word [NewDirEntry2+26],cx ; 16 bits low of cluster
  896.     shr   ecx,16
  897.     mov   word [NewDirEntry2+20],cx ; 16 bits high of cluster (=0 fat16)
  898.  
  899.     push  eax                   ; save parent directory cluster
  900.     mov   eax,2
  901.     call  get_free_FAT
  902.     mov   [cluster],eax         ; first free cluster
  903.     pop   eax
  904.     jc    make_dir_disk_full
  905.  
  906.     push  eax
  907.     mov   eax,[cluster]         ; directory cluster
  908.     mov   edx,[fatEND]          ; end for directory
  909.     call  set_FAT
  910.     cmp  [hd_error],0
  911.     jne   make_dir_error_3
  912.     pop   eax
  913.  
  914.     mov   ebx,PUSHAD_EAX        ; dir name
  915.     push  eax
  916.     call  analyze_directory     ; check if directory already exist
  917.     cmp   [hd_error],0
  918.     jne   make_dir_error_1
  919.  
  920.     pop   eax
  921.     jnc   make_dir_already_exist ; need to free allocated cluster!
  922.  
  923.     call  analyze_directory_to_write
  924.     jc    make_dir_already_exist ; need to free allocated cluster!
  925.  
  926.     mov   esi,PUSHAD_EAX        ; dir name
  927.     mov   edi,ebx               ; pointer in buffer
  928.     mov   ecx,11
  929.     cld
  930.     rep   movsb
  931.  
  932.     mov   dword [ebx+28],0      ; dir size is always 0
  933.     mov   ecx,[cluster]
  934.     mov   [ebx+26],cx           ; 16 bits low of cluster
  935.     mov   word [NewDirEntry1+26],cx
  936.     shr   ecx,16
  937.     mov   [ebx+20],cx           ; 16 bits high of cluster (=0 fat16)
  938.     mov   word [NewDirEntry1+20],cx
  939.     mov   byte [ebx+11],0x10    ; attribute = directory
  940.  
  941.     call  set_current_time_for_entry
  942.     mov   ecx,[ebx+22]
  943.     mov   dword [NewDirEntry1+22],ecx
  944.     mov   dword [NewDirEntry2+22],ecx
  945.  
  946.     mov   ebx,buffer            ; save the directory name,length,cluster
  947.     call  hd_write
  948.     cmp   [hd_error],0
  949.     jne   make_dir_error_1
  950.  
  951.     mov   ecx,512/4
  952.     xor   eax,eax
  953.     mov   edi,buffer
  954.     cld
  955.     rep   stosd                 ; clear new directory cluster
  956.  
  957.     mov   eax,[cluster]         ; new directory cluster
  958.     sub   eax,2
  959.     mov   edx,[SECTORS_PER_CLUSTER]
  960.     imul  eax,edx
  961.     add   eax,[DATA_START]
  962.     mov   ebx,buffer
  963.     add   eax,edx               ; start from last sector
  964.  
  965.   dir_set_empty_directory:
  966.     dec   eax                   ; next sector
  967.     cmp   edx,1                 ; is first directory sector?
  968.     jnz   not_first_sector      ; no. write empty sector
  969.     mov   esi,NewDirEntry1
  970.     mov   edi,buffer
  971.     mov   ecx,64/4
  972.     cld
  973.     rep   movsd                 ; copy 2 first directory entrys "." and ".."
  974.  
  975.   not_first_sector:
  976.     call  hd_write
  977.     cmp   [hd_error],0
  978.     jne   make_dir_error_1
  979.  
  980.     dec   edx
  981.     jnz   dir_set_empty_directory
  982.  
  983.     mov   ecx,-1                ; remove 1 cluster from free disk space
  984.     call  add_disk_free_space
  985.     cmp  [hd_error],0
  986.     jne   make_dir_error_1
  987.  
  988.     popad
  989.     call  update_disk           ; write all of cache and fat to hd
  990.     cmp   [hd_error],0
  991.     jne   make_dir_error_2
  992.     mov   [hd1_status],0
  993.     xor   eax,eax
  994.     ret
  995.  
  996.  
  997. removedir:
  998. ;-----------------------------------------------------
  999. ; input  : eax = file/directory name
  1000. ;          edx = path
  1001. ; output : eax = 0 - ok
  1002. ;                3 - unknown FS
  1003. ;                5 - file not found
  1004. ;               10 - access denied
  1005. ;-----------------------------------------------------
  1006.     cmp   [fat_type],0
  1007.     jnz   remove_dir_fat_ok
  1008.     mov   eax,ERROR_UNKNOWN_FS
  1009.     ret
  1010.  
  1011.   remove_dir_fat_ok:
  1012. ;    call  reserve_hd1
  1013.  
  1014.     push  edi
  1015.     mov   edi,1                 ; allow directory remove
  1016.     call  file_delete
  1017.     cmp   [hd_error],0
  1018.     jne   @f
  1019.  
  1020.     pop   edi
  1021.  
  1022.     call  update_disk           ; write all of cache and fat to hd
  1023.   @@:
  1024.     mov   [hd1_status],0
  1025.     ret
  1026.    
  1027.  
  1028. add_disk_free_space:
  1029. ;-----------------------------------------------------
  1030. ; input  : ecx = cluster count
  1031. ; Note   : negative = remove clusters from free space
  1032. ;          positive = add clusters to free space
  1033. ;-----------------------------------------------------
  1034.     test  ecx,ecx               ; no change
  1035.     je    add_dfs_no
  1036.     cmp   [fat_type],32         ; free disk space only used by fat32
  1037.     jne   add_dfs_no
  1038.  
  1039.     push  eax ebx
  1040.     mov   eax,[ADR_FSINFO]
  1041.     mov   ebx,fsinfo_buffer
  1042.     call  hd_read
  1043.     cmp  [hd_error],0
  1044.     jne  add_not_fs
  1045.  
  1046.     cmp   dword [ebx+0x1fc],0xaa550000 ; check sector id
  1047.     jne   add_not_fs
  1048.  
  1049.     add   [ebx+0x1e8],ecx
  1050.     call  hd_write
  1051. ;    cmp   [hd_error],0
  1052. ;    jne   add_not_fs
  1053.  
  1054.   add_not_fs:
  1055.     pop   ebx eax
  1056.  
  1057.   add_dfs_no:
  1058.     ret
  1059.  
  1060.  
  1061. file_write:
  1062. ;--------------------------------------------------------------------------
  1063. ;   INPUT : user-reg  register-in-this  meaning      symbol-in-this-routine
  1064. ;
  1065. ;            EAX        EDI            system call to write    /
  1066. ;            EBX        EAX   (PAR0)   pointer to file-name    PAR0
  1067. ;            EDX        ECX   (PAR1)   pointer to buffer       PAR1
  1068. ;            ECX        EBX   (PAR2)   file size               PAR2
  1069. ;            ESI        EDX   (PAR3)   pointer to path         PAR3
  1070. ;
  1071. ; output : eax = 0 - ok
  1072. ;                3 - unknown FS
  1073. ;                5 - file not found
  1074. ;                8 - disk full
  1075. ;               10 - access denied
  1076. ;--------------------------------------------------------------------------
  1077.     cmp   [fat_type],0
  1078.     jnz   fat_ok_for_writing
  1079.     mov   eax,ERROR_UNKNOWN_FS
  1080.     ret
  1081.  
  1082.   fat_ok_for_writing:
  1083. ;    call  reserve_hd1
  1084.  
  1085.     pushad
  1086.  
  1087.     xor   edi,edi               ; don't allow directory remove
  1088.     call  file_delete           ; try to delete the file first
  1089.     cmp   [hd_error],0
  1090.     jne   exit_write_access_1
  1091.  
  1092.     test  eax,eax
  1093.     jz    old_deleted           ; deleted ok
  1094.     cmp   eax,ERROR_FILE_NOT_FOUND
  1095.     jnz   exit_write_access     ; it exist but can't delete
  1096.  
  1097.   old_deleted:
  1098.     mov   ebx,PUSHAD_EDX
  1099.     call  get_cluster_of_a_path
  1100.     jnc   found_directory_for_writing
  1101.     cmp   [hd_error],0
  1102.     jne   exit_write_access
  1103.  
  1104.   exit_writing_with_error:
  1105.     popad
  1106.     call  update_disk           ; write all of cache and fat to hd
  1107.     cmp   [hd_error],0
  1108.     jne   exit_write_access_2
  1109.  
  1110.     mov   [hd1_status],0
  1111.     mov   eax,ERROR_FILE_NOT_FOUND
  1112.     ret
  1113.  
  1114.   exit_writing_disk_full_clear:
  1115.     cmp  [hd_error],0
  1116.     jne  exit_write_access_1
  1117.     mov   eax,[sector_tmp]
  1118.     mov   ebx,buffer
  1119.     call  hd_read               ; read directory sector
  1120.     cmp  [hd_error],0
  1121.     jne  exit_write_access_1
  1122.  
  1123.     mov   edx,[entry_pos]
  1124.     mov   byte [edx],0xe5       ; mark as deleted
  1125.     call  hd_write
  1126.     cmp   [hd_error],0
  1127.     jne   exit_write_access_1
  1128.  
  1129.     mov   eax,[edx+20-2]        ; FAT entry
  1130.     mov   ax,[edx+26]
  1131.     and   eax,[fatMASK]
  1132.     call  clear_cluster_chain
  1133.  
  1134.   exit_writing_disk_full:
  1135.     cmp  [hd_error],0
  1136.     jne  exit_write_access_1
  1137.     popad
  1138.     call  update_disk           ; write all of cache and fat to hd
  1139.     cmp   [hd_error],0
  1140.     jne   exit_write_access_2
  1141.     mov   [hd1_status],0
  1142.     mov   eax,ERROR_DISK_FULL
  1143.     ret
  1144.  
  1145.   exit_write_access:
  1146.     popad
  1147.     call  update_disk           ; write all of cache and fat to hd
  1148.     mov   [hd1_status],0
  1149.     mov   eax,ERROR_ACCESS_DENIED
  1150.     ret
  1151.  
  1152.   exit_write_access_1:
  1153.     popad
  1154.   exit_write_access_2:
  1155.     mov   [hd1_status],0
  1156.     mov   eax,ERROR_ACCESS_DENIED
  1157.     ret
  1158.  
  1159. found_directory_for_writing:
  1160.     call  analyze_directory_to_write
  1161.     jc    exit_writing_disk_full
  1162.  
  1163.     mov   [sector_tmp],eax
  1164.     mov   [entry_pos],ebx
  1165.     push  eax                   ; save directory sector
  1166.     mov   eax,2
  1167.     call  get_free_FAT
  1168.     mov   [cluster],eax         ; first free cluster
  1169.     pop   eax
  1170.     jc    exit_writing_disk_full
  1171.  
  1172.     mov   esi,PUSHAD_EAX        ; file name
  1173.     mov   edi,ebx               ; pointer in buffer
  1174.     mov   ecx,11
  1175.     cld
  1176.     rep   movsb
  1177.  
  1178.     mov   esi,PUSHAD_EBX        ; file size (bytes left)
  1179.     mov   [ebx+28],esi          ; file size
  1180.     mov   ecx,[cluster]
  1181.     mov   [ebx+26],cx           ; 16 bits low of cluster
  1182.     shr   ecx,16
  1183.     mov   [ebx+20],cx           ; 16 bits high of cluster (=0 fat16)
  1184.     mov   byte [ebx+11],0x20    ; attribute = archive
  1185.  
  1186.     call  set_current_time_for_entry
  1187.  
  1188.     mov   ebx,buffer            ; save the directory name,length,cluster
  1189.     call  hd_write
  1190.     cmp   [hd_error],0
  1191.     jne   exit_write_access_1
  1192.  
  1193.     imul  edi,[SECTORS_PER_CLUSTER],512 ; edi = cluster size in bytes
  1194.     xor   ecx,ecx               ; cluster count
  1195.     mov   ebx,PUSHAD_ECX        ; ebx = buffer
  1196.  
  1197. hd_new_block_write:
  1198.  
  1199.     mov   eax,[cluster]         ; eax = block
  1200.     call  set_data_cluster
  1201.     cmp   [hd_error],0
  1202.     jne   exit_write_access_1
  1203.  
  1204.     sub   esi,edi               ; sub wrote bytes
  1205.     jbe   file_saved_OK         ; end if all done
  1206.     add   ebx,edi               ; update buffer position
  1207.  
  1208.     inc   eax
  1209.     call  get_free_FAT          ; next free in FAT
  1210.     jc    exit_writing_disk_full_clear
  1211.  
  1212.     mov   edx,eax
  1213.     xchg  eax,[cluster]         ; get old cluster and save new cluster
  1214.     call  set_FAT               ; add it in cluster chain
  1215.     cmp  [hd_error],0
  1216.     jne   exit_write_access_1
  1217.  
  1218.     dec   ecx                   ; update cluster count
  1219.     jmp   hd_new_block_write
  1220.  
  1221. file_saved_OK:
  1222.  
  1223.     mov   edx,[fatEND]          ; new end for cluster chain
  1224.     call  set_FAT
  1225.     cmp  [hd_error],0
  1226.     jne   exit_write_access_1
  1227.  
  1228.     dec   ecx                   ; update cluster count
  1229.  
  1230.     call  add_disk_free_space   ; remove clusters from free disk space
  1231.     cmp  [hd_error],0
  1232.     jne   exit_write_access_1
  1233.  
  1234.     popad
  1235.     call  update_disk           ; write all of cache and fat to hd
  1236.     cmp   [hd_error],0
  1237.     jne   exit_write_access_2
  1238.     mov   [hd1_status],0
  1239.     xor   eax,eax
  1240.     ret
  1241.  
  1242.  
  1243. file_read:
  1244. ;--------------------------------------------------------------------------
  1245. ;   INPUT :  user-register register-in-this  meaning         symbol-in-this
  1246. ;
  1247. ;            EAX           EDI               system call to write   /
  1248. ;            EBX           EAX   (PAR0)      pointer to file-name   PAR0
  1249. ;            EDX           ECX   (PAR1)      pointer to buffer      PAR1
  1250. ;            ECX           EBX   (PAR2)   vt file blocks to read    PAR2
  1251. ;            ESI           EDX   (PAR3)      pointer to path        PAR3
  1252. ;            EDI           ESI            vt first 512 block to read
  1253. ;                          EDI               if 0 - read root
  1254. ;
  1255. ; output : eax = 0 - ok
  1256. ;                3 - unknown FS
  1257. ;                5 - file not found
  1258. ;                6 - end of file
  1259. ;                9 - fat table corrupted
  1260. ;               10 - access denied
  1261. ;          ebx = size of file/directory
  1262. ;--------------------------------------------------------------------------
  1263.     cmp   [fat_type],0
  1264.     jnz   fat_ok_for_reading
  1265.     xor   ebx,ebx
  1266.     mov   eax,ERROR_UNKNOWN_FS
  1267.     mov   [hd1_status], ebx
  1268.     ret
  1269.  
  1270.   fat_ok_for_reading:
  1271. ;    call  reserve_hd1
  1272.  
  1273.     pushad
  1274.  
  1275.     mov   ebx,edx
  1276.     call  get_cluster_of_a_path
  1277.     jc    file_to_read_not_found
  1278.  
  1279.     test  edi,edi               ; read rootdir
  1280.     jne   no_read_root
  1281.  
  1282.     xor   eax,eax
  1283.     call  get_dir_size          ; return rootdir size
  1284.     cmp   [hd_error],0
  1285.     jne   file_access_denied
  1286.  
  1287.     mov   [file_size],eax
  1288.     mov   eax,[ROOT_CLUSTER]
  1289.     jmp   file_read_start
  1290.  
  1291.   no_read_root:
  1292.     mov   ebx,PUSHAD_EAX        ; file name
  1293.     call  analyze_directory
  1294.     jc    file_to_read_not_found
  1295.  
  1296.     mov   eax,[ebx+28]          ; file size
  1297.     test  byte [ebx+11],0x10    ; is it directory?
  1298.     jz    read_set_size         ; no
  1299.  
  1300.     mov   eax,[ebx+20-2]        ; FAT entry
  1301.     mov   ax,[ebx+26]
  1302.     and   eax,[fatMASK]
  1303.     call  get_dir_size
  1304.     cmp   [hd_error],0
  1305.     jne   file_access_denied
  1306.  
  1307.   read_set_size:
  1308.     mov   [file_size],eax
  1309.  
  1310.     mov   eax,[ebx+20-2]        ; FAT entry
  1311.     mov   ax,[ebx+26]
  1312.     and   eax,[fatMASK]
  1313.  
  1314.   file_read_start:
  1315.     mov   ebx,PUSHAD_ECX        ; pointer to buffer
  1316.     mov   edx,PUSHAD_EBX        ; file blocks to read
  1317.     mov   esi,PUSHAD_ESI        ; first 512 block to read
  1318.  
  1319.   file_read_new_cluster:
  1320.     call  get_data_cluster
  1321.     jc    file_read_eof         ; end of file or cluster out of range
  1322.  
  1323.     test  edx,edx               ; is all read?
  1324.     je    file_read_OK          ; yes
  1325.  
  1326.     call  get_FAT               ; get next cluster
  1327.     cmp   [hd_error],0
  1328.     jne   file_access_denied
  1329.  
  1330.     cmp   eax,[fatRESERVED]     ; end of file
  1331.     jnb   file_read_eof
  1332.     cmp   eax,2                 ; incorrect fat chain
  1333.     jnb   file_read_new_cluster
  1334.  
  1335.     popad
  1336.     mov   [hd1_status],0
  1337.     mov   ebx,[file_size]
  1338.     mov   eax,ERROR_FAT_TABLE
  1339.     ret
  1340.  
  1341.   file_read_eof:
  1342.     cmp   [hd_error],0
  1343.     jne   file_access_denied
  1344.     popad
  1345.     mov   [hd1_status],0
  1346.     mov   ebx,[file_size]
  1347.     mov   eax,ERROR_END_OF_FILE
  1348.     ret
  1349.  
  1350.   file_read_OK:
  1351.     popad
  1352.     mov   [hd1_status],0
  1353.     mov   ebx,[file_size]
  1354.     xor   eax,eax
  1355.     ret
  1356.  
  1357.   file_to_read_not_found:
  1358.     cmp   [hd_error],0
  1359.     jne   file_access_denied
  1360.     popad
  1361.     mov   [hd1_status],0
  1362.     xor   ebx,ebx
  1363.     mov   eax,ERROR_FILE_NOT_FOUND
  1364.     ret
  1365.  
  1366.   file_access_denied:
  1367.     popad
  1368.     mov   [hd1_status],0
  1369.     xor   ebx,ebx
  1370.     mov   eax,ERROR_ACCESS_DENIED
  1371.     ret
  1372.  
  1373. get_dir_size:
  1374. ;-----------------------------------------------------
  1375. ; input  : eax = first cluster (0=rootdir)
  1376. ; output : eax = directory size in bytes
  1377. ;-----------------------------------------------------
  1378.     push  edx
  1379.     xor   edx,edx               ; count of directory clusters
  1380.     test  eax,eax
  1381.     jnz   dir_size_next
  1382.  
  1383.     mov   eax,[ROOT_SECTORS]
  1384.     shl   eax,9                 ; fat16 rootdir size in bytes
  1385.     cmp   [fat_type],16
  1386.     je    dir_size_ret
  1387.     mov   eax,[ROOT_CLUSTER]
  1388.  
  1389.   dir_size_next:
  1390.     cmp   eax,2                 ; incorrect fat chain
  1391.     jb    dir_size_end
  1392.     cmp   eax,[fatRESERVED]     ; end of directory
  1393.     ja    dir_size_end
  1394.     call  get_FAT               ; get next cluster
  1395.     cmp   [hd_error],0
  1396.     jne   dir_size_ret
  1397.  
  1398.     inc   edx
  1399.     jmp   dir_size_next
  1400.  
  1401.   dir_size_end:
  1402.     imul  eax,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
  1403.     imul  eax,edx
  1404.  
  1405.   dir_size_ret:
  1406.     pop   edx
  1407.     ret
  1408.  
  1409.  
  1410. file_delete:
  1411. ;-----------------------------------------------------
  1412. ; input  : eax = file/directory name
  1413. ;          edx = path
  1414. ;          edi = 1 - allow directory remove else don't remove directory
  1415. ; output : eax = 0 - ok
  1416. ;                3 - unknown FS
  1417. ;                5 - file not found
  1418. ;               10 - access denied
  1419. ;-----------------------------------------------------
  1420.     cmp   [fat_type],0
  1421.     jnz   file_del_fat_ok
  1422.     mov   eax,ERROR_UNKNOWN_FS
  1423.     ret
  1424.  
  1425.   file_del_fat_ok:
  1426.     pushad
  1427.  
  1428.     mov   ebx,edx
  1429.     call  get_cluster_of_a_path
  1430.     jc    file_to_delete_not_found
  1431.  
  1432.     mov   ebx,PUSHAD_EAX        ; file/directory name
  1433.     call  analyze_directory
  1434.     jc    file_to_delete_not_found
  1435.  
  1436.     test  byte [ebx+11],0x10    ; is it directory?
  1437.     jz    delete_notdir         ; no. it's file
  1438.     cmp   edi,1                 ; allow directory remove
  1439.     jnz   delete_no_access      ; no
  1440.  
  1441.     push  eax                   ; save directory sector
  1442.     mov   eax,[ebx+20-2]        ; first cluster of file
  1443.     mov   ax,[ebx+26]           ; 0 length files start cluster = 0
  1444.     and   eax,[fatMASK]
  1445.     xor   ebp,ebp               ; counter for directory deepnes
  1446.     call  clear_directory
  1447.     pop   eax
  1448.     jc    delete_no_access
  1449.  
  1450.     push  ebx                   ; save directory pointer in buffer
  1451.     mov   ebx,buffer
  1452.     call  hd_read               ; read directory sector
  1453.     cmp  [hd_error],0
  1454.     jne  delete_no_access_1
  1455.     pop   ebx
  1456.  
  1457.   delete_notdir:
  1458.     call  delete_entry_name
  1459.     cmp   [hd_error],0
  1460.     jne   delete_no_access
  1461.  
  1462.     mov   eax,ecx               ; first cluster of file
  1463.     call  clear_cluster_chain
  1464.     cmp   [hd_error],0
  1465.     jne   delete_no_access
  1466.  
  1467.     popad
  1468.     xor   eax,eax
  1469.     ret
  1470.  
  1471.   delete_no_access_1:
  1472.      add esp,4
  1473.   delete_no_access:
  1474.     popad
  1475.     mov   eax,ERROR_ACCESS_DENIED
  1476.     ret
  1477.  
  1478.   file_to_delete_not_found:
  1479.     cmp  [hd_error],0
  1480.     jne  delete_no_access
  1481.     popad
  1482.     mov   eax,ERROR_FILE_NOT_FOUND
  1483.     ret
  1484.  
  1485.  
  1486. clear_cluster_chain:
  1487. ;-----------------------------------------------------
  1488. ; input  : eax = first cluster
  1489. ;-----------------------------------------------------
  1490.     push  eax ecx edx
  1491.     xor   ecx,ecx               ; cluster count
  1492.  
  1493.   clean_new_chain:
  1494.     cmp   eax,[LAST_CLUSTER]    ; end of file
  1495.     ja    delete_OK
  1496.     cmp   eax,2                 ; unfinished fat chain or zero length file
  1497.     jb    delete_OK
  1498.     cmp   eax,[ROOT_CLUSTER]    ; don't remove root cluster
  1499.     jz    delete_OK
  1500.  
  1501.     xor   edx,edx
  1502.     call  set_FAT               ; clear fat entry
  1503.     cmp  [hd_error],0
  1504.     jne  access_denied_01
  1505.  
  1506.     inc   ecx                   ; update cluster count
  1507.     mov   eax,edx               ; old cluster
  1508.     jmp   clean_new_chain
  1509.  
  1510.   delete_OK:
  1511.     call  add_disk_free_space   ; add clusters to free disk space
  1512.   access_denied_01:
  1513.     pop   edx ecx eax
  1514.     ret
  1515.  
  1516.  
  1517. clear_directory:
  1518. ;-----------------------------------------------------
  1519. ; input  : eax = directory cluster
  1520. ;          ebp = directory deepnes
  1521. ; Note   : use recursive call
  1522. ;-----------------------------------------------------
  1523.     pushad
  1524.     inc   ebp
  1525.     cmp   ebp,64                ; if over 63 directory deep
  1526.     jnb   clear_error           ; something must be wrong
  1527.  
  1528.   clear_new_cluster:
  1529.     cmp   eax,[LAST_CLUSTER]
  1530.     ja    clear_end
  1531.     cmp   eax,[ROOT_CLUSTER]    ; don't remove root cluster
  1532.     jz    clear_end
  1533.     mov   esi,eax               ; esi = current directory cluster
  1534.     sub   eax,2
  1535.     jb    clear_end
  1536.     mov   ecx,[SECTORS_PER_CLUSTER]
  1537.     imul  eax,ecx
  1538.     add   eax,[DATA_START]
  1539.  
  1540.   clear_new_sector:
  1541.     mov   edi,eax               ; edi = current directory sector
  1542.     mov   ebx,deltree_buffer
  1543.     call  hd_read
  1544.     cmp  [hd_error],0
  1545.     jne  clear_error    
  1546.  
  1547.     mov   edx,512/32            ; count of dir entrys per sector = 16
  1548.  
  1549.   clear_analyze:
  1550.     mov   al,[ebx+11]           ; file attribute
  1551.     and   al,0xf
  1552.     cmp   al,0xf
  1553.     je    clear_long_filename
  1554.  
  1555.     cmp   byte [ebx],'.'        ; parent or current directory
  1556.     je    clear_next_entry
  1557.     cmp   byte [ebx],0xe5       ; deleted
  1558.     je    clear_next_entry
  1559.     cmp   byte [ebx],0          ; empty
  1560.     je    clear_write_last
  1561.     ;je    clear_next_entry
  1562.  
  1563.     mov   eax,[ebx+20-2]        ; first cluster of entry
  1564.     mov   ax,[ebx+26]
  1565.     and   eax,[fatMASK]
  1566.  
  1567.     test  byte [ebx+11],0x10    ; is it directory?
  1568.     jz    clear_file            ; no
  1569.  
  1570.     push  eax ebx
  1571.     mov   eax,edi
  1572.     mov   ebx,deltree_buffer    ; save buffer over recursive call
  1573.     call  hd_write              ; write directory sector to disk
  1574.     cmp   [hd_error],0
  1575.     jne   clear_error    
  1576.  
  1577.     pop   ebx eax
  1578.  
  1579.     call  clear_directory       ; recursive call !!!
  1580.     jc    clear_error           ; exit if error found
  1581.  
  1582.     push  eax ebx
  1583.     mov   eax,edi
  1584.     mov   ebx,deltree_buffer
  1585.     call  hd_read               ; read directory sector again
  1586.     cmp  [hd_error],0
  1587.     jne   clear_error_1
  1588.  
  1589.     pop   ebx eax
  1590.  
  1591.   clear_file:
  1592.     call  clear_cluster_chain
  1593.     cmp  [hd_error],0
  1594.     jne   clear_error
  1595.  
  1596.   clear_long_filename:
  1597.     mov   byte [ebx],0xe5
  1598.  
  1599.   clear_next_entry:
  1600.     add   ebx,32                ; position of next dir entry
  1601.     dec   edx
  1602.     jnz   clear_analyze
  1603.  
  1604.     mov   eax,edi
  1605.     mov   ebx,deltree_buffer
  1606.     call  hd_write              ; write directory sector to disk
  1607.     cmp   [hd_error],0
  1608.     jne   clear_error
  1609.  
  1610.     inc   eax                   ; next sector
  1611.     dec   ecx
  1612.     jnz   clear_new_sector
  1613.  
  1614.     mov   eax,esi
  1615.     call  get_FAT               ; get next cluster
  1616.     cmp   [hd_error],0
  1617.     jne   clear_error
  1618.  
  1619.     jmp   clear_new_cluster     ; clear it
  1620.  
  1621.   clear_write_last:
  1622.     mov   eax,edi
  1623.     mov   ebx,deltree_buffer
  1624.     call  hd_write              ; write directory sector to disk
  1625.     cmp   [hd_error],0
  1626.     jne   clear_error
  1627.  
  1628.   clear_end:
  1629.     popad
  1630.     clc
  1631.     ret
  1632. clear_error_1:
  1633.     add  esp,8
  1634.   clear_error:
  1635.     popad
  1636.     stc
  1637.     ret
  1638.  
  1639.  
  1640. delete_entry_name:
  1641. ;-----------------------------------------------------
  1642. ; input  : eax = directory sector
  1643. ;          ebx = directory pointer in buffer
  1644. ;          longname_sec = 2 previous directory sectors
  1645. ; output : ecx = first cluster
  1646. ; change : eax,ebx,edx
  1647. ;-----------------------------------------------------
  1648.     mov   byte [ebx],0xe5
  1649.     mov   ecx,[ebx+20-2]        ; first cluster of file
  1650.     mov   cx,[ebx+26]           ; 0 length files start cluster = 0
  1651.     and   ecx,[fatMASK]
  1652.  
  1653.   delete_empty:
  1654.     sub   ebx,32
  1655.     cmp   ebx,buffer
  1656.     jnb   delete_test_long
  1657.  
  1658.     mov   ebx,buffer
  1659.     call  hd_write              ; write directory sector back
  1660.     cmp   [hd_error],0
  1661.     jne   delete_name_end
  1662.  
  1663.     xor   eax,eax
  1664.     xchg  eax,[longname_sec2]
  1665.     xchg  eax,[longname_sec1]
  1666.     test  eax,eax               ; is there previous directory sector?
  1667.     jz    delete_name_end       ; no
  1668.  
  1669.     mov   ebx,buffer
  1670.     call  hd_read               ; read previous sector
  1671.     cmp  [hd_error],0
  1672.     jne  delete_name_end    
  1673.  
  1674.     mov   ebx,buffer+0x1e0      ; start from last entry
  1675.  
  1676.   delete_test_long:
  1677.     mov   dh,[ebx+11]           ; file attribute
  1678.     and   dh,0xf
  1679.     cmp   dh,0xf
  1680.     jne   delete_write_buffer
  1681.  
  1682.     cmp   byte [ebx],0x40       ; end of long dir entry?
  1683.     mov   byte [ebx],0xe5
  1684.     jb    delete_empty
  1685.  
  1686.   delete_write_buffer:
  1687.     mov   ebx,buffer
  1688.     call  hd_write              ; write directory sector back
  1689.  
  1690.   delete_name_end:
  1691.     ret
  1692.  
  1693.  
  1694. rename:
  1695. ;-----------------------------------------------------------
  1696. ; input  : eax = source directory name
  1697. ;          edx = source path
  1698. ;          ebx = dest directory name
  1699. ;          edi = dest path
  1700. ; output : eax = 0 - ok
  1701. ;                3 - unknown FS
  1702. ;                5 - file not found
  1703. ;                8 - disk full
  1704. ;               10 - access denied
  1705. ;-----------------------------------------------------------
  1706.     cmp   [fat_type],0
  1707.     jnz   fat_ok_for_rename
  1708.     mov   eax,ERROR_UNKNOWN_FS
  1709.     ret
  1710.  
  1711.   fat_ok_for_rename:
  1712. ;    call  reserve_hd1
  1713.  
  1714.     pushad
  1715.  
  1716.     mov   ebx,edx               ; source path
  1717.     call  get_cluster_of_a_path
  1718.     jc    rename_entry_not_found
  1719.  
  1720.     mov   ebx,PUSHAD_EAX        ; source directory name
  1721.     call  analyze_directory
  1722.     jc    rename_entry_not_found
  1723.  
  1724.     mov   [sector_tmp],eax      ; save source sector
  1725.     mov   [entry_pos],ebx
  1726.     mov   esi,ebx
  1727.     mov   edi,dir_entry
  1728.     mov   ecx,32/4
  1729.     cld
  1730.     rep   movsd                 ; save entry
  1731.  
  1732.     mov   ebx,PUSHAD_EDI        ; dest path
  1733.     call  get_cluster_of_a_path
  1734.     jc    rename_entry_not_found
  1735.  
  1736.     mov   edx,eax               ; save dest directory cluster
  1737.     mov   ebx,PUSHAD_EBX        ; dest directory name
  1738.     push  [longname_sec1]
  1739.     push  [longname_sec2]
  1740.     call  analyze_directory     ; check if entry already exist
  1741.     cmp  [hd_error],0
  1742.     jne  rename_entry_already_exist_1
  1743.  
  1744.     pop   [longname_sec2]
  1745.     pop   [longname_sec1]
  1746.     jnc   rename_entry_already_exist
  1747.  
  1748.     mov   eax,edx
  1749.     call  analyze_directory_to_write
  1750.     jc    rename_disk_full
  1751.  
  1752.     mov   esi,dir_entry
  1753.     mov   edi,ebx
  1754.     mov   ecx,32/4
  1755.     cld
  1756.     rep   movsd                 ; copy entry
  1757.     mov   esi,PUSHAD_EBX        ; dest directory name
  1758.     mov   edi,ebx
  1759.     mov   ecx,11
  1760.     rep   movsb                 ; copy name
  1761.  
  1762.     mov   ebx,buffer            ; save the directory name,length,cluster
  1763.     call  hd_write
  1764.  
  1765.     test  byte [dir_entry+11],0x10 ; is it directory?
  1766.     jz    rename_not_dir           ; no
  1767.     mov   eax,[dir_entry+20-2]     ; FAT entry
  1768.     mov   ax,[dir_entry+26]
  1769.     and   eax,[fatMASK]
  1770.     call  change_2dot_cluster
  1771.     cmp   [hd_error],0
  1772.     jne   rename_entry_already_exist
  1773.  
  1774.   rename_not_dir:
  1775.     cmp   [hd_error],0
  1776.     jne   rename_entry_already_exist
  1777.     mov   eax,[sector_tmp]
  1778.     mov   ebx,buffer
  1779.     call  hd_read               ; read source directory sector
  1780.     cmp  [hd_error],0
  1781.     jne  rename_entry_already_exist
  1782.  
  1783.     mov   ebx,[entry_pos]
  1784.     call  delete_entry_name
  1785.     cmp   [hd_error],0
  1786.     jne   rename_entry_already_exist
  1787.  
  1788.     popad
  1789.     call  update_disk           ; write all of cache and fat to hd
  1790.     cmp   [hd_error],0
  1791.     jne   rename_entry_already_exist_2
  1792.     mov   [hd1_status],0
  1793.     xor   eax,eax
  1794.     ret
  1795.  
  1796.   rename_entry_not_found:
  1797.     cmp  [hd_error],0
  1798.     jne  rename_entry_already_exist
  1799.     popad
  1800.     mov   [hd1_status],0
  1801.     mov   eax,ERROR_FILE_NOT_FOUND
  1802.     ret
  1803.  
  1804.   rename_entry_already_exist_1:
  1805.     add   esp,8
  1806.   rename_entry_already_exist:
  1807.     popad
  1808.   rename_entry_already_exist_2:
  1809.     mov   [hd1_status],0
  1810.     mov   eax,ERROR_ACCESS_DENIED
  1811.     ret
  1812.  
  1813.   rename_disk_full:
  1814.     cmp  [hd_error],0
  1815.     jne  rename_entry_already_exist
  1816.     popad
  1817.     mov   [hd1_status],0
  1818.     mov   eax,ERROR_DISK_FULL
  1819.     ret
  1820.  
  1821.  
  1822. change_2dot_cluster:
  1823. ;-----------------------------------------------------------
  1824. ; input  : eax = directory cluster
  1825. ;          edx = value to save
  1826. ; change : eax,ebx,edx
  1827. ;-----------------------------------------------------------
  1828.     cmp   eax,[LAST_CLUSTER]
  1829.     ja    not_2dot              ; too big cluster number, something is wrong
  1830.     sub   eax,2
  1831.     jb    not_2dot
  1832.  
  1833.     imul  eax,[SECTORS_PER_CLUSTER]
  1834.     add   eax,[DATA_START]
  1835.     mov   ebx,buffer
  1836.     call  hd_read
  1837.     cmp  [hd_error],0
  1838.     jne  not_2dot
  1839.  
  1840.     cmp   dword [ebx+32],'..  '
  1841.     jnz   not_2dot
  1842.  
  1843.     cmp   edx,[ROOT_CLUSTER]    ; is rootdir cluster?
  1844.     jne   not_2dot_root
  1845.     xor   edx,edx               ; yes. set it zero
  1846.  
  1847.   not_2dot_root:
  1848.     mov   [ebx+32+26],dx        ; 16 bits low of cluster
  1849.     shr   edx,16
  1850.     mov   [ebx+32+20],dx        ; 16 bits high of cluster (=0 fat16)
  1851.     call  hd_write
  1852.  
  1853.   not_2dot:
  1854.     ret
  1855.  
  1856.  
  1857. get_hd_info:
  1858. ;-----------------------------------------------------------
  1859. ; output : eax = 0 - ok
  1860. ;                3 - unknown FS
  1861. ;               10 - access denied
  1862. ;          edx = cluster size in bytes
  1863. ;          ebx = total clusters on disk
  1864. ;          ecx = free clusters on disk
  1865. ;-----------------------------------------------------------
  1866.     cmp   [fat_type],0
  1867.     jnz   info_fat_ok
  1868.     xor   edx,edx
  1869.     xor   ebx,ebx
  1870.     xor   ecx,ecx
  1871.     mov   eax,ERROR_UNKNOWN_FS
  1872.     ret
  1873.  
  1874.   info_fat_ok:
  1875. ;    call  reserve_hd1
  1876.  
  1877.     xor   ecx,ecx               ; count of free clusters
  1878.     mov   eax,2
  1879.     mov   ebx,[LAST_CLUSTER]
  1880.  
  1881.   info_cluster:
  1882.     push  eax
  1883.     call  get_FAT               ; get cluster info
  1884.     cmp   [hd_error],0
  1885.     jne   info_access_denied
  1886.  
  1887.     test  eax,eax               ; is it free?
  1888.     jnz   info_used             ; no
  1889.     inc   ecx
  1890.  
  1891.   info_used:
  1892.     pop   eax
  1893.     inc   eax
  1894.     cmp   eax,ebx               ; is above last cluster?
  1895.     jbe   info_cluster          ; no. test next cluster
  1896.  
  1897.     dec   ebx                   ; cluster count
  1898.     imul  edx,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
  1899.     mov   [hd1_status],0
  1900.     xor   eax,eax
  1901.     ret
  1902.  
  1903.   info_access_denied:
  1904.     add   esp,4
  1905.     xor   edx,edx
  1906.     xor   ebx,ebx
  1907.     xor   ecx,ecx
  1908.     mov   eax,ERROR_ACCESS_DENIED
  1909.     ret
  1910.  
  1911. update_disk:
  1912. ;-----------------------------------------------------------
  1913. ; write changed fat and cache to disk
  1914. ;-----------------------------------------------------------
  1915.     cmp   [fat_change],0        ; is fat changed?
  1916.     je    upd_no_change
  1917.  
  1918.     call  write_fat_sector
  1919.     cmp   [hd_error],0
  1920.     jne   update_disk_acces_denied
  1921.  
  1922.   upd_no_change:
  1923.  
  1924.     call  write_cache
  1925.   update_disk_acces_denied:
  1926.     ret
  1927.  
  1928.  
  1929. ;**************************************************************************
  1930. ;
  1931. ;   0x600008  - first entry in cache list
  1932. ;
  1933. ;            +0   - lba sector
  1934. ;            +4   - state of cache sector
  1935. ;                   0 = empty
  1936. ;                   1 = used for read  ( same as in hd )
  1937. ;                   2 = used for write ( differs from hd )
  1938. ;
  1939. ;      +65536 - cache entries
  1940. ;
  1941. ;**************************************************************************
  1942.  
  1943.  
  1944. hd_read:
  1945. ;-----------------------------------------------------------
  1946. ; input  : eax = block to read
  1947. ;          ebx = destination
  1948. ;-----------------------------------------------------------
  1949.     push  ecx esi edi           ; scan cache
  1950.  
  1951.     mov   ecx,cache_max         ; entries in cache
  1952.     mov   esi,0x600000+8
  1953.     mov   edi,1
  1954.  
  1955.   hdreadcache:
  1956.  
  1957.     cmp   dword [esi+4],0       ; empty
  1958.     je    nohdcache
  1959.  
  1960.     cmp   [esi],eax             ; correct sector
  1961.     je    yeshdcache
  1962.  
  1963.   nohdcache:
  1964.  
  1965.     add   esi,8
  1966.     inc   edi
  1967.     dec   ecx
  1968.     jnz   hdreadcache
  1969.  
  1970.     call  find_empty_slot       ; ret in edi
  1971.     cmp   [hd_error],0
  1972.     jne   return_01
  1973.  
  1974.     push  eax edx
  1975.  
  1976.     call  wait_for_hd_idle
  1977.     cmp   [hd_error],0
  1978.     jne   hd_read_error    
  1979.  
  1980.     cli
  1981.     xor   eax,eax
  1982.     mov   edx,[hdbase]
  1983.     inc   edx
  1984.     out   dx,al   ; ATAFeatures регистр "особенностей"
  1985.     inc   edx
  1986.     inc   eax
  1987.     out   dx,al   ; ATASectorCount счетчик секторов
  1988.     inc   edx
  1989.     mov   eax,[esp+4]
  1990.     out   dx,al   ; ATASectorNumber регистр номера сектора
  1991.     shr   eax,8
  1992.     inc   edx
  1993.     out   dx,al   ; ATACylinder номер цилиндра (младший байт)
  1994.     shr   eax,8
  1995.     inc   edx
  1996.     out   dx,al   ; номер цилиндра (старший байт)
  1997.     shr   eax,8
  1998.     inc   edx
  1999.     and   al,1+2+4+8
  2000.     add   al,byte [hdid]
  2001.     add   al,128+64+32
  2002.     out   dx,al   ; номер головки/номер диска
  2003.     inc   edx
  2004.     mov   al,20h
  2005.     out   dx,al   ; ATACommand регистр команд
  2006.     sti
  2007.  
  2008.     call  wait_for_sector_buffer
  2009.  
  2010.     cmp   [hd_error],0
  2011.     jne   hd_read_error
  2012.  
  2013.     cli
  2014.     push  edi
  2015.     shl   edi,9
  2016.     add   edi,0x600000+65536
  2017.     mov   ecx,256
  2018.     mov   edx,[hdbase]
  2019.     cld
  2020.     rep   insw
  2021.     pop   edi
  2022.     sti
  2023.  
  2024.     pop   edx eax
  2025.  blok_read_2:
  2026.     lea   esi,[edi*8+0x600000]
  2027.     mov   [esi],eax             ; sector number
  2028.     mov   dword [esi+4],1       ; hd read - mark as same as in hd
  2029.  
  2030.   yeshdcache:
  2031.  
  2032.     mov   esi,edi
  2033.     shl   esi,9
  2034.     add   esi,0x600000+65536
  2035.     mov   edi,ebx
  2036.     mov   ecx,512/4
  2037.     cld
  2038.     rep   movsd                 ; move data
  2039.  return_01:
  2040.     pop   edi esi ecx
  2041.     ret
  2042.    
  2043.  
  2044. hd_write:
  2045. ;-----------------------------------------------------------
  2046. ; input  : eax = block
  2047. ;          ebx = pointer to memory
  2048. ;-----------------------------------------------------------
  2049.     push  ecx esi edi
  2050.  
  2051.     ; check if the cache already has the sector and overwrite it
  2052.  
  2053.     mov   ecx,cache_max
  2054.     mov   esi,0x600000+8
  2055.     mov   edi,1
  2056.  
  2057.   hdwritecache:
  2058.  
  2059.     cmp   dword [esi+4],0       ; if cache slot is empty
  2060.     je    not_in_cache_write
  2061.  
  2062.     cmp   [esi],eax             ; if the slot has the sector
  2063.     je    yes_in_cache_write
  2064.  
  2065.   not_in_cache_write:
  2066.  
  2067.     add   esi,8
  2068.     inc   edi
  2069.     dec   ecx
  2070.     jnz   hdwritecache
  2071.  
  2072.     ; sector not found in cache
  2073.     ; write the block to a new location
  2074.  
  2075.     call  find_empty_slot       ; ret in edi
  2076.     cmp   [hd_error],0
  2077.     jne   hd_write_access_denied
  2078.  
  2079.     lea   esi,[edi*8+0x600000]
  2080.     mov   [esi],eax             ; sector number
  2081.  
  2082.   yes_in_cache_write:
  2083.  
  2084.     mov   dword [esi+4],2       ; write - differs from hd
  2085.  
  2086.     shl   edi,9
  2087.     add   edi,0x600000+65536
  2088.     mov   esi,ebx
  2089.     mov   ecx,512/4
  2090.     cld
  2091.     rep   movsd                 ; move data
  2092.  hd_write_access_denied:
  2093.     pop   edi esi ecx
  2094.     ret
  2095.  
  2096.  
  2097. write_cache:
  2098. ;-----------------------------------------------------------
  2099. ; write all changed sectors to disk
  2100. ;-----------------------------------------------------------
  2101.     push  eax ecx edx esi edi
  2102.  
  2103.     ; write difference ( 2 ) from cache to hd
  2104.  
  2105.     mov   ecx,cache_max
  2106.     mov   esi,0x600000+8
  2107.     mov   edi,1
  2108.  
  2109.   write_cache_more:
  2110.  
  2111.     cmp   dword [esi+4],2       ; if cache slot is not different
  2112.     jne   does_not_need_writing
  2113.  
  2114.     mov   dword [esi+4],1       ; same as in hd
  2115.     mov   eax,[esi]             ; eax = sector to write
  2116.  
  2117.     cmp   eax,[PARTITION_START]
  2118.     jb    danger
  2119.     cmp   eax,[PARTITION_END]
  2120.     ja    danger
  2121.  
  2122.     call  wait_for_hd_idle
  2123.     cmp   [hd_error],0
  2124.     jne   hd_write_error
  2125.  
  2126.     cli
  2127.     xor   eax,eax
  2128.     mov   edx,[hdbase]
  2129.     inc   edx
  2130.     out   dx,al
  2131.     inc   edx
  2132.     inc   eax
  2133.     out   dx,al
  2134.     inc   edx
  2135.     mov   eax,[esi]             ; eax = sector to write
  2136.     out   dx,al
  2137.     shr   eax,8
  2138.     inc   edx
  2139.     out   dx,al
  2140.     shr   eax,8
  2141.     inc   edx
  2142.     out   dx,al
  2143.     shr   eax,8
  2144.     inc   edx
  2145.     and   al,1+2+4+8
  2146.     add   al,byte [hdid]
  2147.     add   al,128+64+32
  2148.     out   dx,al
  2149.     inc   edx
  2150.     mov   al,30h
  2151.     out   dx,al
  2152.     sti
  2153.  
  2154.     call  wait_for_sector_buffer
  2155.  
  2156.     cmp   [hd_error],0
  2157.     jne   hd_write_error
  2158.  
  2159.     push  ecx esi
  2160.  
  2161.     cli
  2162.     mov   esi,edi
  2163.     shl   esi,9
  2164.     add   esi,0x600000+65536    ; esi = from memory position
  2165.     mov   ecx,256
  2166.     mov   edx,[hdbase]
  2167.     cld
  2168.     rep   outsw
  2169.     sti
  2170.  
  2171.     pop   esi ecx
  2172.  
  2173.   danger:
  2174.   does_not_need_writing:
  2175.  
  2176.     add   esi,8
  2177.     inc   edi
  2178.     dec   ecx
  2179.     jnz   write_cache_more
  2180.  return_02:
  2181.     pop   edi esi edx ecx eax
  2182.     ret
  2183.  
  2184.  
  2185. find_empty_slot:
  2186. ;-----------------------------------------------------------
  2187. ; find empty or read slot, flush cache if next 10% is used by write
  2188. ; output : edi = cache slot
  2189. ;-----------------------------------------------------------
  2190.     push  ecx esi
  2191.  
  2192.   search_again:
  2193.  
  2194.     mov   ecx,cache_max*10/100
  2195.     mov   edi,[cache_search_start]
  2196.  
  2197.   search_for_empty:
  2198.  
  2199.     inc   edi
  2200.     cmp   edi,cache_max
  2201.     jbe   inside_cache
  2202.     mov   edi,1
  2203.  
  2204.   inside_cache:
  2205.  
  2206.     cmp   dword [edi*8+0x600000+4],2    ; get cache slot info
  2207.     jb    found_slot                    ; it's empty or read
  2208.     dec   ecx
  2209.     jnz   search_for_empty
  2210.  
  2211.     call  write_cache                   ; no empty slots found, write all
  2212.     cmp   [hd_error],0
  2213.     jne   found_slot_access_denied
  2214.  
  2215.     jmp   search_again                  ; and start again
  2216.  
  2217.   found_slot:
  2218.  
  2219.     mov   [cache_search_start],edi
  2220.   found_slot_access_denied:
  2221.     pop   esi ecx
  2222.     ret
  2223.  
  2224.  
  2225. save_hd_wait_timeout:
  2226.  
  2227.     push  eax
  2228.     mov   eax,[timer_ticks];[0xfdf0]
  2229.     add   eax,300               ; 3 sec timeout
  2230.     mov   [hd_wait_timeout],eax
  2231.     pop   eax
  2232.     ret
  2233.  
  2234.  
  2235. check_hd_wait_timeout:
  2236.  
  2237.     push  eax
  2238.     mov   eax,[hd_wait_timeout]
  2239.     cmp   [timer_ticks], eax ;[0xfdf0],eax
  2240.     jg    hd_timeout_error
  2241.     pop   eax
  2242.     mov   [hd_error],0
  2243.     ret
  2244.  
  2245. iglobal
  2246.   hd_timeout_str   db 'K : FS - HD timeout',13,10,0
  2247.   hd_read_str      db 'K : FS - HD read error',13,10,0
  2248.   hd_write_str     db 'K : FS - HD write error',13,10,0
  2249.   hd_lba_str       db 'K : FS - HD LBA error',13,10,0
  2250. endg
  2251.  
  2252. hd_timeout_error:
  2253.  
  2254.     call  clear_hd_cache
  2255.     call  clear_application_table_status
  2256.     mov   esi,hd_timeout_str
  2257.     call  sys_msg_board_str
  2258. ;    jmp   $
  2259.     mov   [hd_error],1
  2260.     pop   eax
  2261.     ret
  2262.  
  2263. hd_read_error:
  2264.  
  2265.     call  clear_hd_cache
  2266.     call  clear_application_table_status
  2267.     mov   esi,hd_read_str
  2268.     call  sys_msg_board_str
  2269.     pop   edx eax
  2270.     jmp    return_01
  2271. ;    jmp   $
  2272.  
  2273. hd_write_error:
  2274.  
  2275.     call  clear_hd_cache
  2276.     call  clear_application_table_status
  2277.     mov   esi,hd_write_str
  2278.     call  sys_msg_board_str
  2279.     jmp    return_02
  2280. ;    jmp   $
  2281.  
  2282. hd_lba_error:
  2283.     call  clear_hd_cache
  2284.     call  clear_application_table_status
  2285.     mov   esi,hd_lba_str
  2286.     call  sys_msg_board_str
  2287.     jmp   LBA_read_ret
  2288.  
  2289.  
  2290. wait_for_hd_idle:
  2291.  
  2292.     push  eax edx
  2293.  
  2294.     call  save_hd_wait_timeout
  2295.  
  2296.     mov   edx,[hdbase]
  2297.     add   edx,0x7
  2298.  
  2299.   wfhil1:
  2300.  
  2301.     call  check_hd_wait_timeout
  2302.     cmp   [hd_error],0
  2303.     jne   @f
  2304.  
  2305.     in    al,dx
  2306.     test  al,128
  2307.     jnz   wfhil1
  2308.  
  2309.  @@:
  2310.  
  2311.     pop   edx eax
  2312.     ret
  2313.  
  2314.  
  2315.  
  2316. wait_for_sector_buffer:
  2317.  
  2318.     push  eax edx
  2319.  
  2320.     mov   edx,[hdbase]
  2321.     add   edx,0x7
  2322.  
  2323.     call  save_hd_wait_timeout
  2324.  
  2325.   hdwait_sbuf:                  ; wait for sector buffer to be ready
  2326.  
  2327.     call  check_hd_wait_timeout
  2328.     cmp   [hd_error],0
  2329.     jne   @f
  2330.  
  2331.     in    al,dx
  2332.     test  al,8
  2333.     jz    hdwait_sbuf
  2334.  
  2335.     mov   [hd_error],0
  2336.  
  2337.     cmp   [hd_setup],1          ; do not mark error for setup request
  2338.     je    buf_wait_ok
  2339.  
  2340.     test  al,1                  ; previous command ended up with an error
  2341.     jz    buf_wait_ok
  2342.  @@:
  2343.     mov   [hd_error],1
  2344.  
  2345.   buf_wait_ok:
  2346.  
  2347.     pop   edx eax
  2348.     ret
  2349.  
  2350.  
  2351.  
  2352. read_hd_file:
  2353. ;-----------------------------------------------------------------
  2354. ;
  2355. ; Converting old reading function for hd-application start.
  2356. ;
  2357. ; IN:
  2358. ;
  2359. ; eax - pointer to file (0 = read only first sector of drive: eg 'label')
  2360. ; ebx - file lenght
  2361. ; ecx - start 512 byte block number
  2362. ; edx - number of blocks to read
  2363. ; esi - pointer to return/work area (atleast 20 000 bytes)
  2364. ;
  2365. ; For new read function
  2366. ;
  2367. ; EAX   (PAR0)      pointer to file-name
  2368. ; ECX   (PAR1)      pointer to buffer
  2369. ; EBX   (PAR2)   vt file blocks to read
  2370. ; EDX   (PAR3)      pointer to path
  2371. ; ESI            vt first 512 block to read
  2372. ; EDI               if 0 - return root
  2373. ;--------------------------------------------------------------------------
  2374.  
  2375.     push  ecx esi edi
  2376.     mov   esi,eax
  2377.     mov   edi,startpath
  2378.     mov   ecx,250
  2379.     cld
  2380.     rep   movsb
  2381.     pop   edi esi ecx
  2382.  
  2383.     mov   eax,startpath
  2384.     mov   [eax+ebx-12],byte 0
  2385.  
  2386.     push  eax ebx ecx edx esi
  2387.  
  2388.     pop   ecx ; pointer to buffer
  2389.     add   ecx,1024
  2390.     pop   ebx ; number of blocks to read
  2391.     pop   esi ; first block to read
  2392.     dec   esi
  2393.     pop   eax ; file length
  2394.     pop   edx ; pointer to path
  2395.  
  2396.     mov   edi,12
  2397.     lea   eax,[eax+edx-12+1]
  2398.     call  file_read
  2399.  
  2400.     ret
  2401.  
  2402. ; \begin{diamond}
  2403. hd_find_lfn:
  2404. ; in: esi->name
  2405. ; out: CF=1 - file not found
  2406. ;      else CF=0 and edi->direntry, eax=sector
  2407. ; destroys eax
  2408.         push    esi edi
  2409.         push    0
  2410.         push    0
  2411.         push    fat16_root_first
  2412.         push    fat16_root_next
  2413.         mov     eax, [ROOT_CLUSTER]
  2414.         cmp     [fat_type], 32
  2415.         jz      .fat32
  2416. .loop:
  2417.         call    fat_find_lfn
  2418.         jc      .notfound
  2419.         cmp     byte [esi], 0
  2420.         jz      .found
  2421.         test    byte [edi+11], 10h
  2422.         jz      .notfound
  2423.         and     dword [esp+12], 0
  2424.         mov     eax, [edi+20-2]
  2425.         mov     ax, [edi+26]    ; cluster
  2426. .fat32:
  2427.         mov     [esp+8], eax
  2428.         mov     dword [esp+4], fat_notroot_first
  2429.         mov     dword [esp], fat_notroot_next
  2430.         jmp     .loop
  2431. .notfound:
  2432.         add     esp, 16
  2433.         pop     edi esi
  2434.         stc
  2435.         ret
  2436. .found:
  2437.         lea     eax, [esp+8]
  2438.         cmp     dword [eax], 0
  2439.         jz      .root
  2440.         call    fat_get_sector
  2441.         jmp     .cmn
  2442. .root:
  2443.         mov     eax, [eax+4]
  2444.         add     eax, [ROOT_START]
  2445. .cmn:
  2446.         add     esp, 20         ; CF=0
  2447.         pop     esi
  2448.         ret
  2449.  
  2450. ;----------------------------------------------------------------
  2451. ;
  2452. ;  fs_HdRead - LFN variant for reading hard disk
  2453. ;
  2454. ;  esi  points to filename
  2455. ;  ebx  pointer to 64-bit number = first wanted byte, 0+
  2456. ;       may be ebx=0 - start from first byte
  2457. ;  ecx  number of bytes to read, 0+
  2458. ;  edx  mem location to return data
  2459. ;
  2460. ;  ret ebx = bytes read or 0xffffffff file not found
  2461. ;      eax = 0 ok read or other = errormsg
  2462. ;
  2463. ;--------------------------------------------------------------
  2464. fs_HdRead:
  2465.     cmp    [fat_type], 0
  2466.     jnz    @f
  2467.     or    ebx, -1
  2468.     mov    eax, ERROR_UNKNOWN_FS
  2469.     ret
  2470. @@:
  2471.     push    edi
  2472.     cmp    byte [esi], 0
  2473.     jnz    @f
  2474. .noaccess:
  2475.     pop    edi
  2476. .noaccess_2:
  2477.     or    ebx, -1
  2478.     mov    eax, ERROR_ACCESS_DENIED
  2479.     ret
  2480.  
  2481. .noaccess_3:
  2482.     add esp,4
  2483. .noaccess_1:
  2484.     add esp,4
  2485. .noaccess_4:
  2486.     add esp,4*5
  2487.     jmp  .noaccess_2
  2488.  
  2489. @@:
  2490.     call    hd_find_lfn
  2491.     jnc    .found
  2492.     pop    edi
  2493.     cmp   [hd_error],0
  2494.     jne   .noaccess_2
  2495.     or    ebx, -1
  2496.     mov    eax, ERROR_FILE_NOT_FOUND
  2497.     ret
  2498.  
  2499. .found:
  2500.     test    byte [edi+11], 0x10    ; do not allow read directories
  2501.     jnz    .noaccess
  2502.     test    ebx, ebx
  2503.     jz    .l1
  2504.     cmp    dword [ebx+4], 0
  2505.     jz    @f
  2506.         xor     ebx, ebx
  2507. .reteof:
  2508.     mov    eax, 6
  2509.     pop    edi
  2510.     ret
  2511. @@:
  2512.     mov    ebx, [ebx]
  2513. .l1:
  2514.         push    ecx edx
  2515.         push    0
  2516.         mov     eax, [edi+28]
  2517.         sub     eax, ebx
  2518.         jb      .eof
  2519.         cmp     eax, ecx
  2520.         jae     @f
  2521.         mov     ecx, eax
  2522.         mov     byte [esp], 6
  2523. @@:
  2524.     mov    eax, [edi+20-2]
  2525.     mov    ax, [edi+26]
  2526. ; now eax=cluster, ebx=position, ecx=count, edx=buffer for data
  2527. .new_cluster:
  2528.     jecxz    .new_sector
  2529.     test    eax, eax
  2530.     jz    .eof
  2531.     cmp    eax, [fatRESERVED]
  2532.     jae    .eof
  2533.     mov    [cluster_tmp], eax
  2534.     dec    eax
  2535.     dec    eax
  2536.     mov    edi, [SECTORS_PER_CLUSTER]
  2537.     imul    eax, edi
  2538.     add    eax, [DATA_START]
  2539. .new_sector:
  2540.     test    ecx, ecx
  2541.     jz    .done
  2542.     sub    ebx, 512
  2543.     jae    .skip
  2544.     add    ebx, 512
  2545.     jnz    .force_buf
  2546.     cmp    ecx, 512
  2547.     jb    .force_buf
  2548. ; we may read directly to given buffer
  2549.     push    ebx
  2550.     mov    ebx, edx
  2551.     call    hd_read
  2552.     cmp  [hd_error],0
  2553.     jne  .noaccess_1    
  2554.     pop    ebx
  2555.     add    edx, 512
  2556.     sub    ecx, 512
  2557.     jmp    .skip
  2558. .force_buf:
  2559. ; we must read sector to temporary buffer and then copy it to destination
  2560.     push    eax ebx
  2561.     mov    ebx, buffer
  2562.     call    hd_read
  2563.     cmp  [hd_error],0
  2564.     jne  .noaccess_3
  2565.  
  2566.     mov    eax, ebx
  2567.     pop    ebx
  2568.     add    eax, ebx
  2569.     push    ecx
  2570.     add    ecx, ebx
  2571.     cmp    ecx, 512
  2572.     jbe    @f
  2573.     mov    ecx, 512
  2574. @@:
  2575.     sub    ecx, ebx
  2576.     mov    ebx, edx
  2577.     call    memmove
  2578.     add    edx, ecx
  2579.     sub    [esp], ecx
  2580.     pop    ecx
  2581.     pop    eax
  2582.     xor    ebx, ebx
  2583. .skip:
  2584.     inc    eax
  2585.     dec    edi
  2586.     jnz    .new_sector
  2587.     mov    eax, [cluster_tmp]
  2588.     call    get_FAT
  2589.     cmp   [hd_error],0
  2590.     jne   .noaccess_4
  2591.  
  2592.     jmp    .new_cluster
  2593. .done:
  2594.         mov     ebx, edx
  2595.         pop     eax edx ecx edi
  2596.         sub     ebx, edx
  2597.         ret
  2598. .eof:
  2599.         mov     ebx, edx
  2600.         pop     eax edx ecx
  2601.         sub     ebx, edx
  2602.         jmp     .reteof
  2603.  
  2604. ;----------------------------------------------------------------
  2605. ;
  2606. ;  fs_HdReadFolder - LFN variant for reading hard disk folder
  2607. ;
  2608. ;  esi  points to filename
  2609. ;  ebx  pointer to structure 32-bit number = first wanted block, 0+
  2610. ;                          & flags (bitfields)
  2611. ; flags: bit 0: 0=ANSI names, 1=UNICODE names
  2612. ;  ecx  number of blocks to read, 0+
  2613. ;  edx  mem location to return data
  2614. ;
  2615. ;  ret ebx = blocks read or 0xffffffff folder not found
  2616. ;      eax = 0 ok read or other = errormsg
  2617. ;
  2618. ;--------------------------------------------------------------
  2619. fs_HdReadFolder:
  2620.         mov     eax, [ROOT_CLUSTER]
  2621.         push    edi
  2622.         cmp     byte [esi], 0
  2623.         jz      .doit
  2624.         call    hd_find_lfn
  2625.         jnc     .found
  2626.         pop     edi
  2627.         or      ebx, -1
  2628.         mov     eax, ERROR_FILE_NOT_FOUND
  2629.         ret
  2630. .found:
  2631.         test    byte [edi+11], 0x10     ; do not allow read files
  2632.         jnz     .found_dir
  2633.         pop     edi
  2634.         or      ebx, -1
  2635.         mov     eax, ERROR_ACCESS_DENIED
  2636.         ret
  2637. .found_dir:
  2638.         mov     eax, [edi+20-2]
  2639.         mov     ax, [edi+26]    ; eax=cluster
  2640. .doit:
  2641.         push    esi ecx
  2642.         push    ebp
  2643.         sub     esp, 262*2      ; reserve space for LFN
  2644.         mov     ebp, esp
  2645.         push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE name
  2646.         mov     ebx, [ebx]
  2647. ; init header
  2648.         push    eax ecx
  2649.         mov     edi, edx
  2650.         mov     ecx, 32/4
  2651.         xor     eax, eax
  2652.         rep     stosd
  2653.         pop     ecx eax
  2654.         mov     byte [edx], 1   ; version
  2655.         mov     esi, edi        ; esi points to BDFE
  2656. .new_cluster:
  2657.         mov     [cluster_tmp], eax
  2658.         test    eax, eax
  2659.         jnz     @f
  2660.         cmp     [fat_type], 32
  2661.         jz      .notfound
  2662.         mov     eax, [ROOT_START]
  2663.         push    [ROOT_SECTORS]
  2664.         push    ebx
  2665.         jmp     .new_sector
  2666. @@:
  2667.         dec     eax
  2668.         dec     eax
  2669.         imul    eax, [SECTORS_PER_CLUSTER]
  2670.         push    [SECTORS_PER_CLUSTER]
  2671.         add     eax, [DATA_START]
  2672.         push    ebx
  2673. .new_sector:
  2674.         mov     ebx, buffer
  2675.         mov     edi, ebx
  2676.         call    hd_read
  2677.         cmp     [hd_error], 0
  2678.         jnz     .notfound2
  2679.         add     ebx, 512
  2680.         push    eax
  2681. .l1:
  2682.         call    fat_get_name
  2683.         jc      .l2
  2684.         cmp     byte [edi+11], 0xF
  2685.         jnz     .do_bdfe
  2686.         add     edi, 0x20
  2687.         cmp     edi, ebx
  2688.         jb      .do_bdfe
  2689.         pop     eax
  2690.         inc     eax
  2691.         dec     dword [esp+4]
  2692.         jnz     @f
  2693.         mov     eax, [cluster_tmp]
  2694.         test    eax, eax
  2695.         jz      .done
  2696.         call    get_FAT
  2697.         cmp     [hd_error], 0
  2698.         jnz     .notfound2
  2699.         cmp     eax, 2
  2700.         jb      .done
  2701.         cmp     eax, [fatRESERVED]
  2702.         jae     .done
  2703.         push    eax
  2704.         mov     eax, [SECTORS_PER_CLUSTER]
  2705.         mov     [esp+8], eax
  2706.         pop     eax
  2707.         mov     [cluster_tmp], eax
  2708.         dec     eax
  2709.         dec     eax
  2710.         imul    eax, [SECTORS_PER_CLUSTER]
  2711.         add     eax, [DATA_START]
  2712. @@:
  2713.         mov     ebx, buffer
  2714.         mov     edi, ebx
  2715.         call    hd_read
  2716.         cmp     [hd_error], 0
  2717.         jnz     .notfound2
  2718.         add     ebx, 512
  2719.         push    eax
  2720. .do_bdfe:
  2721.         inc     dword [edx+8]   ; new file found
  2722.         dec     dword [esp+4]
  2723.         jns     .l2
  2724.         dec     ecx
  2725.         js      .l2
  2726.         inc     dword [edx+4]   ; new file block copied
  2727.         call    fat_entry_to_bdfe
  2728. .l2:
  2729.         add     edi, 0x20
  2730.         cmp     edi, ebx
  2731.         jb      .l1
  2732.         pop     eax
  2733.         inc     eax
  2734.         dec     dword [esp+4]
  2735.         jnz     .new_sector
  2736.         mov     eax, [cluster_tmp]
  2737.         test    eax, eax
  2738.         jz      .done
  2739.         call    get_FAT
  2740.         cmp     [hd_error], 0
  2741.         jnz     .notfound2
  2742.         cmp     eax, 2
  2743.         jb      .done
  2744.         cmp     eax, [fatRESERVED]
  2745.         jae     .done
  2746.         push    eax
  2747.         mov     eax, [SECTORS_PER_CLUSTER]
  2748.         mov     [esp+8], eax
  2749.         pop     eax
  2750.         pop     ebx
  2751.         add     esp, 4
  2752.         jmp     .new_cluster
  2753. .notfound2:
  2754.         add     esp, 8
  2755. .notfound:
  2756.         add     esp, 262*2+4
  2757.         pop     ebp ecx esi edi
  2758.         mov     eax, ERROR_FILE_NOT_FOUND
  2759.         or      ebx, -1
  2760.         ret
  2761. .done:
  2762.         add     esp, 262*2+4+8
  2763.         pop     ebp
  2764.         mov     ebx, [edx+4]
  2765.         xor     eax, eax
  2766.         dec     ecx
  2767.         js      @f
  2768.         mov     al, ERROR_END_OF_FILE
  2769. @@:
  2770.         pop     ecx esi edi
  2771.         ret
  2772.  
  2773. fat16_root_next:
  2774.         cmp     edi, buffer+0x200-0x20
  2775.         jae     fat16_root_next_sector
  2776.         add     edi, 0x20
  2777.         ret     ; CF=0
  2778. fat16_root_next_sector:
  2779. ; read next sector
  2780.         push    ecx
  2781.         mov     ecx, [eax+4]
  2782.         inc     ecx
  2783.         mov     [eax+4], ecx
  2784.         cmp     ecx, [ROOT_SECTORS]
  2785.         pop     ecx
  2786.         jae     fat16_root_first.readerr
  2787. fat16_root_first:
  2788.         mov     eax, [eax+4]
  2789.         add     eax, [ROOT_START]
  2790.         push    ebx
  2791.         mov     edi, buffer
  2792.         mov     ebx, edi
  2793.         call    hd_read
  2794.         pop     ebx
  2795.         cmp     [hd_error], 0
  2796.         jnz     .readerr
  2797.         ret     ; CF=0
  2798. .readerr:
  2799.         stc
  2800.         ret
  2801. fat16_root_begin_write:
  2802.         push    edi eax
  2803.         call    fat16_root_first
  2804.         pop     eax edi
  2805.         ret
  2806. fat16_root_end_write:
  2807.         pusha
  2808.         mov     eax, [eax+4]
  2809.         add     eax, [ROOT_START]
  2810.         mov     ebx, buffer
  2811.         call    hd_write
  2812.         popa
  2813.         ret
  2814. fat16_root_next_write:
  2815.         cmp     edi, buffer+0x200
  2816.         jae     @f
  2817.         ret
  2818. @@:
  2819.         call    fat16_root_end_write
  2820.         jmp     fat16_root_next_sector
  2821. fat16_root_extend_dir:
  2822.         stc
  2823.         ret
  2824.  
  2825. fat_notroot_next:
  2826.         cmp     edi, buffer+0x200-0x20
  2827.         jae     fat_notroot_next_sector
  2828.         add     edi, 0x20
  2829.         ret     ; CF=0
  2830. fat_notroot_next_sector:
  2831.         push    ecx
  2832.         mov     ecx, [eax+4]
  2833.         inc     ecx
  2834.         cmp     ecx, [SECTORS_PER_CLUSTER]
  2835.         jae     fat_notroot_next_cluster
  2836.         mov     [eax+4], ecx
  2837.         jmp     @f
  2838. fat_notroot_next_cluster:
  2839.         push    eax
  2840.         mov     eax, [eax]
  2841.         call    get_FAT
  2842.         mov     ecx, eax
  2843.         pop     eax
  2844.         cmp     [hd_error], 0
  2845.         jnz     fat_notroot_next_err
  2846.         cmp     ecx, [fatRESERVED]
  2847.         jae     fat_notroot_next_err
  2848.         mov     [eax], ecx
  2849.         and     dword [eax+4], 0
  2850. @@:
  2851.         pop     ecx
  2852. fat_notroot_first:
  2853.         call    fat_get_sector
  2854.         push    ebx
  2855.         mov     edi, buffer
  2856.         mov     ebx, edi
  2857.         call    hd_read
  2858.         pop     ebx
  2859.         cmp     [hd_error], 0
  2860.         jnz     @f
  2861.         ret     ; CF=0
  2862. fat_notroot_next_err:
  2863.         pop     ecx
  2864. @@:
  2865.         stc
  2866.         ret
  2867. fat_notroot_begin_write:
  2868.         push    eax edi
  2869.         call    fat_notroot_first
  2870.         pop     edi eax
  2871.         ret
  2872. fat_notroot_end_write:
  2873.         call    fat_get_sector
  2874.         push    ebx
  2875.         mov     ebx, buffer
  2876.         call    hd_write
  2877.         pop     ebx
  2878.         ret
  2879. fat_notroot_next_write:
  2880.         cmp     edi, buffer+0x200
  2881.         jae     @f
  2882.         ret
  2883. @@:
  2884.         push    eax
  2885.         call    fat_notroot_end_write
  2886.         pop     eax
  2887.         jmp     fat_notroot_next_sector
  2888. fat_notroot_extend_dir:
  2889.         push    eax
  2890.         mov     eax, [eax]
  2891.         call    get_free_FAT
  2892.         jnc     .found
  2893.         pop     eax
  2894.         ret     ; CF=1
  2895. .found:
  2896.         push    edx
  2897.         mov     edx, [fatEND]
  2898.         call    set_FAT
  2899.         mov     edx, eax
  2900.         mov     eax, [esp+4]
  2901.         mov     eax, [eax]
  2902.         push    edx
  2903.         call    set_FAT
  2904.         pop     edx
  2905.         cmp     [hd_error], 0
  2906.         jz      @f
  2907.         pop     edx
  2908.         pop     eax
  2909.         stc
  2910.         ret
  2911. @@:
  2912.         push    ecx
  2913.         or      ecx, -1
  2914.         call    add_disk_free_space
  2915. ; zero new cluster
  2916.         mov     ecx, 512/4
  2917.         mov     edi, buffer
  2918.         push    edi
  2919.         xor     eax, eax
  2920.         rep     stosd
  2921.         pop     edi
  2922.         pop     ecx
  2923.         mov     eax, [esp+4]
  2924.         mov     [eax], edx
  2925.         and     dword [eax+4], 0
  2926.         pop     edx
  2927.         mov     eax, [eax]
  2928.         dec     eax
  2929.         dec     eax
  2930.         push    ebx ecx
  2931.         mov     ecx, [SECTORS_PER_CLUSTER]
  2932.         imul    eax, ecx
  2933.         add     eax, [DATA_START]
  2934.         mov     ebx, edi
  2935. @@:
  2936.         call    hd_write
  2937.         inc     eax
  2938.         loop    @b
  2939.         pop     ecx ebx eax
  2940.         clc
  2941.         ret
  2942.  
  2943. fat_get_sector:
  2944.         push    ecx
  2945.         mov     ecx, [eax]
  2946.         dec     ecx
  2947.         dec     ecx
  2948.         imul    ecx, [SECTORS_PER_CLUSTER]
  2949.         add     ecx, [DATA_START]
  2950.         add     ecx, [eax+4]
  2951.         mov     eax, ecx
  2952.         pop     ecx
  2953.         ret
  2954.  
  2955. ;----------------------------------------------------------------
  2956. ;
  2957. ;  fs_HdRewrite - LFN variant for writing hard disk
  2958. ;
  2959. ;  esi  points to filename
  2960. ;  ebx  ignored (reserved)
  2961. ;  ecx  number of bytes to write, 0+
  2962. ;  edx  mem location to data
  2963. ;
  2964. ;  ret ebx = number of written bytes
  2965. ;      eax = 0 ok read or other = errormsg
  2966. ;
  2967. ;--------------------------------------------------------------
  2968. fshrad:
  2969.         mov     eax, ERROR_ACCESS_DENIED
  2970.         xor     ebx, ebx
  2971.         ret
  2972. fshrfs:
  2973.         mov     eax, ERROR_UNKNOWN_FS
  2974.         xor     ebx, ebx
  2975.         ret
  2976.  
  2977. fs_HdRewrite:
  2978.         cmp     [fat_type], 0
  2979.         jz      fshrfs
  2980.         cmp     byte [esi], 0
  2981.         jz      fshrad
  2982.         pushad
  2983.         xor     ebp, ebp
  2984.         push    esi
  2985. @@:
  2986.         lodsb
  2987.         test    al, al
  2988.         jz      @f
  2989.         cmp     al, '/'
  2990.         jnz     @b
  2991.         lea     ebp, [esi-1]
  2992.         jmp     @b
  2993. @@:
  2994.         pop     esi
  2995.         test    ebp, ebp
  2996.         jnz     .noroot
  2997.         mov     ebp, [ROOT_CLUSTER]
  2998.         cmp     [fat_type], 32
  2999.         jz      .pushnotroot
  3000.         push    fat16_root_extend_dir
  3001.         push    fat16_root_end_write
  3002.         push    fat16_root_next_write
  3003.         push    fat16_root_begin_write
  3004.         xor     ebp, ebp
  3005.         push    ebp
  3006.         push    ebp
  3007.         push    fat16_root_first
  3008.         push    fat16_root_next
  3009.         jmp     .common1
  3010. .noroot:
  3011. ; check existence
  3012.         mov     byte [ebp], 0<