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

 ;;  20.5.2002  Hd status check - VT                                ;;
 ;;  29.6.2002  Improved fat32 verification - VT                    ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 2455 $
+$Revision: 2643 $
 PUSHAD_EBX equ [esp+16]
 PUSHAD_EBP equ [esp+8]
 PUSHAD_ESI equ [esp+4]
 PUSHAD_EDI equ [esp+0]
+; Internal data for every FAT partition.
+struct FAT
+p       PARTITION       ; must be the first item
+fs_type              db ?
+fat16_root           db 0       ; flag for fat16 rootdir
+fat_change           db 0       ; 1=fat has changed
+                     db ?       ; alignment
+Lock                 MUTEX ?    ; currently operations with one partition
+                                 ; can not be executed in parallel since the
+                                 ; legacy code is not ready; this mutex guards
+                                 ; all operations
+SECTORS_PER_FAT      dd 0x1f3a
+NUMBER_OF_FATS       dd 0x2
+SECTORS_PER_CLUSTER  dd 0x8
+BYTES_PER_SECTOR     dd 0x200   ; Note: if BPS <> 512 need lots of changes
+ROOT_CLUSTER         dd 2       ; first rootdir cluster
+FAT_START            dd 0       ; start of fat table
+ROOT_START           dd 0       ; start of rootdir (only fat16)
+ROOT_SECTORS         dd 0       ; count of rootdir sectors (only fat16)
+DATA_START           dd 0       ; start of data area (=first cluster 2)
+LAST_CLUSTER         dd 0       ; last availabe cluster
+ADR_FSINFO           dd 0       ; used only by fat32
+fatRESERVED          dd 0x0FFFFFF6
+fatBAD               dd 0x0FFFFFF7
+fatEND               dd 0x0FFFFFF8
+fatMASK              dd 0x0FFFFFFF
+fatStartScan         dd 2
+cluster_tmp          dd 0       ; used by analyze_directory
+                                ; and analyze_directory_to_write
+longname_sec1        dd 0       ; used by analyze_directory to save 2 previous
+longname_sec2        dd 0       ; directory sectors for delete long filename
+fat_in_cache         dd -1
+fat_cache            rb 512
+buffer               rb 512
+fsinfo_buffer        rb 512
+ends
 uglobal
 align 4
-partition_count      dd 0       ; partitions found by set_FAT32_variables
-longname_sec1        dd 0       ; used by analyze_directory to save 2 previous
-longname_sec2        dd 0       ; directory sectors for delete long filename
+partition_count      dd 0       ; partitions found by set_FAT32_variables
 hd_error             dd 0       ; set by wait_for_sector_buffer
-hd_setup             dd 0
-hd_wait_timeout      dd 0
-cluster_tmp          dd 0       ; used by analyze_directory
-                                ; and analyze_directory_to_write
 hd_setup             dd 0
-file_size            dd 0       ; used by file_read
+hd_wait_timeout      dd 0
-cache_search_start   dd 0       ; used by find_empty_slot
-endg
 iglobal
-fat_in_cache         dd -1
+cache_search_start   dd 0       ; used by find_empty_slot
-endg
-uglobal
+endg
 align 4
-fat_cache:
+uglobal
-                     times 512 db 0
- Sector512:                      ; label for dev_hdcd.inc
-  buffer:
+align 4
-                       times 512 db 0
+ Sector512:                      ; label for dev_hdcd.inc
+  buffer:
+                times 512 db 0
+endg
-  fsinfo_buffer:
+iglobal
+align 4
+fat_user_functions:
-                       times 512 db 0
+        dd      (fat_user_functions_end - fat_user_functions - 4) / 4
+        dd      fat_Read
+        dd      fat_ReadFolder
+        dd      fat_Rewrite
+        dd      fat_Write
+        dd      fat_SetFileEnd
+        dd      fat_GetFileInfo
-endg
+        dd      fat_SetFileInfo
+        dd      0
+        dd      fat_Delete
+        dd      fat_CreateFolder
+fat_user_functions_end:
+endg
+; these labels are located before the main function to make
+; most of jumps to these be short
+fat_create_partition.free_return0:
+        push    ebx
+        mov     eax, ebp
+        call    free
+        pop     ebx
+        pop     ebp
+fat_create_partition.return0:
+        xor     eax, eax
+        ret
+fat_create_partition:
+; bootsector must have been successfully read
+        cmp     dword [esp+4], 1
+        jnz     .return0
+; bootsector signature must be correct
+        cmp     word [ebx+0x1fe], 0xaa55
+        jnz     .return0
+; sectors per cluster must be nonzero
+        cmp     byte [ebx+0xd], 0
+        jz      .return0
+; bytes per sector must be 0x200
+        cmp     word [ebx+0xb], 0x200
+        jnz     .return0
+; number of fats must be nonzero
+        cmp     byte [ebx+0x10], 0
+        jz      .return0
+; The only reason to be invalid partition now is FAT12. Since the test for
+; FAT size requires knowledge of some calculated values, which are also used
+; in the normal operation, let's hope for the best and allocate data now; if
+; it will prove wrong, just deallocate it.
+        push    ebx
+        push    sizeof.FAT
+        pop     eax
+        call    malloc
+        pop     ebx
+        test    eax, eax
+        jz      .return0
+        mov     ecx, [ebp+8]
+        mov     dword [eax+FAT.p.FirstSector], ecx
+        mov     ecx, [ebp+12]
+        mov     dword [eax+FAT.p.FirstSector+4], ecx
+        mov     ecx, [ebp+16]
+        mov     dword [eax+FAT.p.Length], ecx
+        mov     ecx, [ebp+20]
+        mov     dword [eax+FAT.p.Length+4], ecx
+        mov     [eax+FAT.p.Disk], esi
+        mov     [eax+FAT.p.FSUserFunctions], fat_user_functions
+        or      [eax+FAT.fat_in_cache], -1
-uglobal
-  fat16_root           db 0       ; flag for fat16 rootdir
+        mov     [eax+FAT.fat_change], 0
-  fat_change           db 0       ; 1=fat has changed
+        push    ebp
-endg
+        mov     ebp, eax
-reserve_hd1:
+        lea     ecx, [ebp+FAT.Lock]
+        call    mutex_init
-        cli
-        cmp     [hd1_status], 0
+        movzx   eax, word [ebx+0xe]     ; sectors reserved
-        je      reserve_ok1
+        mov     [ebp+FAT.FAT_START], eax
-        sti
+        movzx   eax, byte [ebx+0xd]     ; sectors per cluster
-        call    change_task
+        mov     [ebp+FAT.SECTORS_PER_CLUSTER], eax
-        jmp     reserve_hd1
-  reserve_ok1:
+        movzx   ecx, word [ebx+0xb]     ; bytes per sector
+        mov     [ebp+FAT.BYTES_PER_SECTOR], ecx
-        push    eax
+        movzx   eax, word [ebx+0x11]    ; count of rootdir entries (=0 fat32)
+        shl     eax, 5                  ; mul 32
-        mov     eax, [CURRENT_TASK]
+        dec     ecx
+        add     eax, ecx                ; round up if not equal count
-        shl     eax, 5
-        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
+        inc     ecx                     ; bytes per sector
-        mov     [hd1_status], eax
-        pop     eax
+        xor     edx, edx
-        sti
-        ret
+        div     ecx
-;********************************************
-uglobal
-hd_in_cache db ?
+        mov     [ebp+FAT.ROOT_SECTORS], eax     ; count of rootdir sectors
-endg
-reserve_hd_channel:
-; BIOS disk accesses are protected with common mutex hd1_status
-; This must be modified when hd1_status will not be valid!
-        cmp     [hdpos], 0x80
-        jae     .ret
+        movzx   eax, word [ebx+0x16]    ; sectors per fat <65536
-        cmp     [hdbase], 0x1F0
+        test    eax, eax
-        jne     .IDE_Channel_2
+        jnz     @f
-.IDE_Channel_1:
-        cli
-        cmp     [IDE_Channel_1], 0
-        je      .reserve_ok_1
+        mov     eax, [ebx+0x24]         ; sectors per fat
-        sti
+@@:
-        call    change_task
-        jmp     .IDE_Channel_1
+        mov     [ebp+FAT.SECTORS_PER_FAT], eax
-.IDE_Channel_2:
-        cli
-        cmp     [IDE_Channel_2], 0
-        je      .reserve_ok_2
-        sti
+        movzx   eax, byte [ebx+0x10]    ; number of fats
+        mov     [ebp+FAT.NUMBER_OF_FATS], eax
+        imul    eax, [ebp+FAT.SECTORS_PER_FAT]
+        add     eax, [ebp+FAT.FAT_START]
-        call    change_task
+        mov     [ebp+FAT.ROOT_START], eax       ; rootdir = fat_start + fat_size * fat_count
+        add     eax, [ebp+FAT.ROOT_SECTORS]     ; rootdir sectors should be 0 on fat32
+        mov     [ebp+FAT.DATA_START], eax       ; data area = rootdir + rootdir_size
+        movzx   eax, word [ebx+0x13]    ; total sector count <65536
+        test    eax, eax
+        jnz     @f
+        mov     eax, [ebx+0x20]         ; total sector count
+@@:
+        mov     dword [ebp+FAT.p.Length], eax
+        and     dword [ebp+FAT.p.Length+4], 0
+        sub     eax, [ebp+FAT.DATA_START]       ; eax = count of data sectors
+        xor     edx, edx
+        div     [ebp+FAT.SECTORS_PER_CLUSTER]
+        inc     eax
+        mov     [ebp+FAT.LAST_CLUSTER], eax
+        dec     eax                     ; cluster count
+        mov     [ebp+FAT.fatStartScan], 2
-        jmp     .IDE_Channel_2
+        ; limits by Microsoft Hardware White Paper v1.03
+        cmp     eax, 4085               ; 0xff5
+        jb      .free_return0           ; fat12 not supported
-.reserve_ok_1:
+        cmp     eax, 65525              ; 0xfff5
+        jb      .fat16
-        mov     [IDE_Channel_1], 1
+.fat32:
-        push    eax
+        mov     eax, [ebx+0x2c]         ; rootdir cluster
-        mov     al, 1
-        jmp     @f
+        mov     [ebp+FAT.ROOT_CLUSTER], eax
-.reserve_ok_2:
+        movzx   eax, word [ebx+0x30]
-        mov     [IDE_Channel_2], 1
+        mov     [ebp+FAT.ADR_FSINFO], eax
-        push    eax
-        mov     al, 3
+        push    ebx
-@@:
-        cmp     [hdid], 1
-        sbb     al, -1
+        add     ebx, 512
-        cmp     al, [hd_in_cache]
+        call    fs_read32_sys
-        jz      @f
+        test    eax, eax
-        mov     [hd_in_cache], al
+        jnz     @f
-        call    clear_hd_cache
+        mov     eax, [ebx+0x1ec]
-@@:
+        cmp     eax, -1
-        pop     eax
+        jz      @f
-        sti
-.ret:
+        mov     [ebp+FAT.fatStartScan], eax
-        ret
+@@:
+        pop     ebx
+        mov     [ebp+FAT.fatRESERVED], 0x0FFFFFF6
+        mov     [ebp+FAT.fatBAD], 0x0FFFFFF7
+        mov     [ebp+FAT.fatEND], 0x0FFFFFF8
+        mov     [ebp+FAT.fatMASK], 0x0FFFFFFF
+        mov     al, 32
+        mov     [fs_type], al
+        mov     [ebp+FAT.fs_type], al
+        mov     eax, ebp
+        pop     ebp
-free_hd_channel:
+        ret
-; see comment at reserve_hd_channel
-        cmp     [hdpos], 0x80
-        jae     .ret
-        cmp     [hdbase], 0x1F0
-        jne     .IDE_Channel_2
+.fat16:
-.IDE_Channel_1:
+        and     [ebp+FAT.ROOT_CLUSTER], 0
-        mov     [IDE_Channel_1], 0
+        mov     [ebp+FAT.fatRESERVED], 0x0000FFF6
-.ret:
+        mov     [ebp+FAT.fatBAD], 0x0000FFF7
+        mov     [ebp+FAT.fatEND], 0x0000FFF8
-        ret
+        mov     [ebp+FAT.fatMASK], 0x0000FFFF
-.IDE_Channel_2:
+        mov     al, 16
+        mov     [fs_type], al
-        mov     [IDE_Channel_2], 0
+        mov     [ebp+FAT.fs_type], al
-        ret
+        mov     eax, ebp
-;********************************************
+        pop     ebp
-problem_partition db 0  ; used for partitions search
+        ret
-include  'part_set.inc'
+set_FAT:
 ;--------------------------------
-set_FAT:
+; input  : EAX = cluster
-;--------------------------------
+;          EDX = value to save
-; input  : EAX = cluster
+;          EBP = pointer to FAT structure
-;          EDX = value to save
+; output : EDX = old value
-; output : EDX = old value
+;--------------------------------
-;--------------------------------
+; out: CF set <=> error
         push    eax ebx esi
         cmp     eax, 2
         jb      sfc_error
-        cmp     eax, [LAST_CLUSTER]
+        cmp     eax, [ebp+FAT.LAST_CLUSTER]
         ja      sfc_error
-        cmp     [fs_type], 16
+        cmp     [ebp+FAT.fs_type], 16
-        je      sfc_1
-        add     eax, eax
+        je      sfc_1
-  sfc_1:
+        add     eax, eax
-        add     eax, eax
+  sfc_1:
-        mov     esi, 511
+        add     eax, eax
-        and     esi, eax        ; esi = position in fat sector
+        mov     esi, 511
-        shr     eax, 9          ; eax = fat sector
+        and     esi, eax        ; esi = position in fat sector
-        add     eax, [FAT_START]
+        shr     eax, 9          ; eax = fat sector
-        mov     ebx, fat_cache
+        add     eax, [ebp+FAT.FAT_START]
         lea     ebx, [ebp+FAT.fat_cache]
         cmp     eax, [fat_in_cache]; is fat sector already in memory?
-        je      sfc_in_cache    ; yes
+        cmp     eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
         je      sfc_in_cache    ; yes
         cmp     [fat_change], 0 ; is fat changed?
-        je      sfc_no_change   ; no
+        cmp     [ebp+FAT.fat_change], 0; is fat changed?
-        call    write_fat_sector; yes. write it into disk
+        je      sfc_no_change   ; no
-        cmp     [hd_error], 0
+        call    write_fat_sector; yes. write it into disk
-        jne     sfc_error
+        jc      sfc_error
   sfc_no_change:
-        mov     [fat_in_cache], eax; save fat sector
+        mov     [ebp+FAT.fat_in_cache], eax; save fat sector
-        call    hd_read
+        call    fs_read32_sys
-        cmp     [hd_error], 0
+        test    eax, eax
         jne     sfc_error
   sfc_in_cache:
-        cmp     [fs_type], 16
+        cmp     [ebp+FAT.fs_type], 16
         jne     sfc_test32
+  sfc_set16:
+        xchg    [ebx+esi], dx   ; save new value and get old value
         jmp     sfc_write
   sfc_set16:
-        xchg    [ebx+esi], dx   ; save new value and get old value
+  sfc_test32:
+        mov     eax, [ebp+FAT.fatMASK]
         jmp     sfc_write
   sfc_set32:
+        and     edx, eax
-  sfc_test32:
+        xor     eax, -1         ; mask for high bits
-        mov     eax, [fatMASK]
+        and     eax, [ebx+esi]  ; get high 4 bits
         or      eax, edx
-  sfc_set32:
+        mov     edx, [ebx+esi]  ; get old value
-        and     edx, eax
+        mov     [ebx+esi], eax  ; save new value
         xor     eax, -1         ; mask for high bits
-        and     eax, [ebx+esi]  ; get high 4 bits
+  sfc_write:
-        or      eax, edx
+        mov     [ebp+FAT.fat_change], 1; fat has changed
         mov     edx, [ebx+esi]  ; get old value
-        mov     [ebx+esi], eax  ; save new value
+  sfc_nonzero:
+        and     edx, [ebp+FAT.fatMASK]
-  sfc_write:
-        mov     [fat_change], 1 ; fat has changed
+  sfc_return:
+        pop     esi ebx eax
-  sfc_nonzero:
+        ret
-        and     edx, [fatMASK]
+  sfc_error:
-  sfc_error:
+        stc
-        pop     esi ebx eax
+        jmp     sfc_return
-        ret
+get_FAT:
-get_FAT:
+;--------------------------------
-;--------------------------------
+; input  : EAX = cluster
-; input  : EAX = cluster
+;          EBP = pointer to FAT structure
 ; output : EAX = next cluster
 ;--------------------------------
-        push    ebx esi
+; out: CF set <=> error
         push    ebx esi
+        cmp     [ebp+FAT.fs_type], 16
+        je      gfc_1
-        cmp     [fs_type], 16
+        add     eax, eax
-        je      gfc_1
+  gfc_1:
         add     eax, eax
-  gfc_1:
+        mov     esi, 511
-        add     eax, eax
+        and     esi, eax        ; esi = position in fat sector
-        mov     esi, 511
+        shr     eax, 9          ; eax = fat sector
-        and     esi, eax        ; esi = position in fat sector
+        add     eax, [ebp+FAT.FAT_START]
-        shr     eax, 9          ; eax = fat sector
+        lea     ebx, [ebp+FAT.fat_cache]
         add     eax, [FAT_START]
-        mov     ebx, fat_cache
+        cmp     eax, [ebp+FAT.fat_in_cache]; is fat sector already in memory?
         je      gfc_in_cache
         cmp     eax, [fat_in_cache]; is fat sector already in memory?
-        je      gfc_in_cache
+        cmp     [ebp+FAT.fat_change], 0; is fat changed?
+        je      gfc_no_change   ; no
-        cmp     [fat_change], 0 ; is fat changed?
+        call    write_fat_sector; yes. write it into disk
-        je      gfc_no_change   ; no
+        jc      hd_error_01
         call    write_fat_sector; yes. write it into disk
-        cmp     [hd_error], 0
+  gfc_no_change:
-        jne     hd_error_01
+        mov     [ebp+FAT.fat_in_cache], eax
         call    fs_read32_sys
-  gfc_no_change:
-        mov     [fat_in_cache], eax
+        test    eax, eax
-        call    hd_read
+        jne     hd_error_01
         cmp     [hd_error], 0
-        jne     hd_error_01
+  gfc_in_cache:
         mov     eax, [ebx+esi]
-  gfc_in_cache:
+        and     eax, [ebp+FAT.fatMASK]
-        mov     eax, [ebx+esi]
+  gfc_return:
-        and     eax, [fatMASK]
- hd_error_01:
         pop     esi ebx
         ret
  hd_error_01:
         stc
+        jmp     gfc_return
+get_free_FAT:
-get_free_FAT:
+;-----------------------------------------------------------
-;-----------------------------------------------------------
+; output : if CARRY=0 EAX = # first cluster found free
-; output : if CARRY=0 EAX = # first cluster found free
+;          if CARRY=1 disk full
-;          if CARRY=1 disk full
+; Note   : for more speed need to use fat_cache directly
-; Note   : for more speed need to use fat_cache directly
+;-----------------------------------------------------------
-;-----------------------------------------------------------
+        push    ecx
 ;-----------------------------------------------------------
 ; write changed fat to disk
 ;-----------------------------------------------------------
         push    eax ebx ecx
-        mov     [fat_change], 0
+        mov     [ebp+FAT.fat_change], 0
-        mov     eax, [fat_in_cache]
+        mov     eax, [ebp+FAT.fat_in_cache]
         cmp     eax, -1
         jz      write_fat_not_used
-        mov     ebx, fat_cache
+        lea     ebx, [ebp+FAT.fat_cache]
-        mov     ecx, [NUMBER_OF_FATS]
+        mov     ecx, [ebp+FAT.NUMBER_OF_FATS]
+  write_next_fat:
+        push    eax
-  write_next_fat:
+        call    fs_write32_sys
-        call    hd_write
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     eax
-        jne     write_fat_not_used
+        jnz     write_fat_not_used
-        add     eax, [SECTORS_PER_FAT]
+        add     eax, [ebp+FAT.SECTORS_PER_FAT]
         dec     ecx
         jnz     write_next_fat
-  write_fat_not_used:
-        pop     ecx ebx eax
-        ret
-analyze_directory:
-;-----------------------------------------------------------
-; input  : EAX = first cluster of the directory
-;          EBX = pointer to filename
-; output : IF CARRY=0 EAX = sector where th file is found
-;                     EBX = pointer in buffer
-;                     [buffer .. buffer+511]
-;                     ECX,EDX,ESI,EDI not changed
-;          IF CARRY=1 filename not found
-; Note   : if cluster=0 it's changed to read rootdir
-;          save 2 previous directory sectors in longname_sec
-;-----------------------------------------------------------
-        push    ecx edx esi edi ebx; ebx = [esp+0]
-        mov     [longname_sec1], 0
-        mov     [longname_sec2], 0
-  adr_new_cluster:
-        mov     [cluster_tmp], eax
-        mov     [fat16_root], 0
-        cmp     eax, [LAST_CLUSTER]
-        ja      adr_not_found   ; too big cluster number, something is wrong
-        cmp     eax, 2
-        jnb     adr_data_cluster
-        mov     eax, [ROOT_CLUSTER]; if cluster < 2 then read rootdir
-        cmp     [fs_type], 16
-        jne     adr_data_cluster
-        mov     eax, [ROOT_START]
-        mov     edx, [ROOT_SECTORS]
-        mov     [fat16_root], 1 ; flag for fat16 rootdir
-        jmp     adr_new_sector
-  adr_data_cluster:
-        sub     eax, 2
-        mov     edx, [SECTORS_PER_CLUSTER]
-        imul    eax, edx
-        add     eax, [DATA_START]
-  adr_new_sector:
-        mov     ebx, buffer
-        call    hd_read
-        cmp     [hd_error], 0
-        jne     adr_not_found
-        mov     ecx, 512/32     ; count of dir entrys per sector = 16
-  adr_analyze:
-        mov     edi, [ebx+11]   ; file attribute
-        and     edi, 0xf
-        cmp     edi, 0xf
-        je      adr_long_filename
-        test    edi, 0x8        ; skip over volume label
-        jne     adr_long_filename; Note: label can be same name as file/dir
-        mov     esi, [esp+0]    ; filename need to be uppercase
-        mov     edi, ebx
-        push    ecx
-        mov     ecx, 11
-        cld
-        rep cmpsb               ; compare 8+3 filename
-        pop     ecx
-        je      adr_found
-  adr_long_filename:
-        add     ebx, 32         ; position of next dir entry
-        dec     ecx
-        jnz     adr_analyze
-        mov     ecx, [longname_sec1]; save 2 previous directory sectors
-        mov     [longname_sec1], eax; for delete long filename
-        mov     [longname_sec2], ecx
-        inc     eax             ; next sector
-        dec     edx
-        jne     adr_new_sector
-        cmp     [fat16_root], 1 ; end of fat16 rootdir
-        je      adr_not_found
-  adr_next_cluster:
-        mov     eax, [cluster_tmp]
-        call    get_FAT         ; get next cluster
-        cmp     [hd_error], 0
-        jne     adr_not_found
-        cmp     eax, 2          ; incorrect fat chain?
-        jb      adr_not_found   ; yes
-        cmp     eax, [fatRESERVED]; is it end of directory?
-        jb      adr_new_cluster ; no. analyse it
-  adr_not_found:
-        pop     edi edi esi edx ecx; first edi will remove ebx
-        stc                     ; file not found
-        ret
-  adr_found:
-        pop     edi edi esi edx ecx; first edi will remove ebx
-        clc                     ; file found
-        ret
-get_data_cluster:
-;-----------------------------------------------------------
-; input  : EAX = cluster
-;          EBX = pointer to buffer
-;          EDX = # blocks to read in buffer
-;          ESI = # blocks to skip over
-; output : if CARRY=0 ok EBX/EDX/ESI updated
-;          if CARRY=1 cluster out of range
-; Note   : if cluster=0 it's changed to read rootdir
-;-----------------------------------------------------------
-        push    eax ecx
-        mov     [fat16_root], 0
-        cmp     eax, [LAST_CLUSTER]
-        ja      gdc_error       ; too big cluster number, something is wrong
-        cmp     eax, 2
-        jnb     gdc_cluster
-        mov     eax, [ROOT_CLUSTER]; if cluster < 2 then read rootdir
-        cmp     [fs_type], 16
-        jne     gdc_cluster
-        mov     eax, [ROOT_START]
-        mov     ecx, [ROOT_SECTORS]; Note: not cluster size
-        mov     [fat16_root], 1 ; flag for fat16 rootdir
-        jmp     gdc_read
-  gdc_cluster:
-        sub     eax, 2
-        mov     ecx, [SECTORS_PER_CLUSTER]
-        imul    eax, ecx
-        add     eax, [DATA_START]
-  gdc_read:
-        test    esi, esi        ; first wanted block
-        je      gdcl1           ; yes, skip count is 0
-        dec     esi
-        jmp     gdcl2
-  gdcl1:
-        call    hd_read
-        cmp     [hd_error], 0
-        jne     gdc_error
-        add     ebx, 512        ; update pointer
-        dec     edx
-  gdcl2:
-        test    edx, edx        ; is all read?
-        je      out_of_read
-        inc     eax             ; next sector
-        dec     ecx
-        jnz     gdc_read
-  out_of_read:
-        pop     ecx eax
-        clc
-        ret
-  gdc_error:
-        pop     ecx eax
-        stc
-        ret
-get_cluster_of_a_path:
-;---------------------------------------------------------
-; input  : EBX = pointer to a path string
-;          (example: the path "/files/data/document" become
-;                             "files......data.......document...0"
-;          '.' = space char
-;          '0' = char(0) (ASCII=0) !!! )
-; output : if (CARRY=1) -> ERROR in the PATH
-;          if (CARRY=0) -> EAX=cluster
-;---------------------------------------------------------
-        push    ebx edx
-        mov     eax, [ROOT_CLUSTER]
-        mov     edx, ebx
-search_end_of_path:
-        cmp     byte [edx], 0
-        je      found_end_of_path
-        inc     edx; '/'
-        mov     ebx, edx
-        call    analyze_directory
-        jc      directory_not_found
-        mov     eax, [ebx+20-2] ; read the HIGH 16bit cluster field
-        mov     ax, [ebx+26]    ; read the LOW 16bit cluster field
-        and     eax, [fatMASK]
-        add     edx, 11         ; 8+3 (name+extension)
-        jmp     search_end_of_path
-found_end_of_path:
-        pop     edx ebx
         clc                     ; no errors
-        ret
+  write_fat_not_used:
         pop     ecx ebx eax
 ; Note   : negative = remove clusters from free space
 ;          positive = add clusters to free space
 ;-----------------------------------------------------
         test    ecx, ecx        ; no change
         je      add_dfs_no
-        cmp     [fs_type], 32  ; free disk space only used by fat32
+        cmp     [ebp+FAT.fs_type], 32  ; free disk space only used by fat32
         jne     add_dfs_no
         push    eax ebx
-        mov     eax, [ADR_FSINFO]
+        mov     eax, [ebp+FAT.ADR_FSINFO]
-        mov     ebx, fsinfo_buffer
+        lea     ebx, [ebp+FAT.fsinfo_buffer]
-        call    hd_read
+        call    fs_read32_sys
-        cmp     [hd_error], 0
+        test    eax, eax
-        jne     add_not_fs
+        jnz     add_not_fs
         cmp     dword [ebx+0x1fc], 0xaa550000; check sector id
         jne     add_not_fs
         add     [ebx+0x1e8], ecx
-        push    [fatStartScan]
+        push    [ebp+FAT.fatStartScan]
         pop     dword [ebx+0x1ec]
-        call    hd_write
+        mov     eax, [ebp+FAT.ADR_FSINFO]
-;    cmp   [hd_error],0
+        call    fs_write32_sys
-;    jne   add_not_fs
+;    jc    add_not_fs
-  add_not_fs:
-        pop     ebx eax
-  add_dfs_no:
-        ret
-file_read:
-;--------------------------------------------------------------------------
-;   INPUT :  user-register register-in-this  meaning         symbol-in-this
-;
-;            EAX           EDI               system call to write   /
-;            EBX           EAX   (PAR0)      pointer to file-name   PAR0
-;            EDX           ECX   (PAR1)      pointer to buffer      PAR1
-;            ECX           EBX   (PAR2)   vt file blocks to read    PAR2
-;            ESI           EDX   (PAR3)      pointer to path        PAR3
-;            EDI           ESI            vt first 512 block to read
-;                          EDI               if 0 - read root
-;
-; output : eax = 0 - ok
-;                3 - unknown FS
-;                5 - file not found
-;                6 - end of file
-;                9 - fat table corrupted
-;               10 - access denied
-;          ebx = size of file/directory
-;--------------------------------------------------------------------------
-        cmp     [fs_type], 16
-        jz      fat_ok_for_reading
-        cmp     [fs_type], 32
-        jz      fat_ok_for_reading
-        xor     ebx, ebx
-        mov     eax, ERROR_UNKNOWN_FS
-        mov     [hd1_status], ebx
-        ret
-  fat_ok_for_reading:
-;    call  reserve_hd1
-        pushad
-        mov     ebx, edx
-        call    get_cluster_of_a_path
-        jc      file_to_read_not_found
-        test    edi, edi        ; read rootdir
-        jne     no_read_root
-        xor     eax, eax
-        call    get_dir_size    ; return rootdir size
-        cmp     [hd_error], 0
-        jne     file_access_denied
-        mov     [file_size], eax
-        mov     eax, [ROOT_CLUSTER]
-        jmp     file_read_start
-  no_read_root:
-        mov     ebx, PUSHAD_EAX ; file name
-        call    analyze_directory
-        jc      file_to_read_not_found
-        mov     eax, [ebx+28]   ; file size
-        test    byte [ebx+11], 0x10; is it directory?
-        jz      read_set_size   ; no
-        mov     eax, [ebx+20-2] ; FAT entry
-        mov     ax, [ebx+26]
-        and     eax, [fatMASK]
-        call    get_dir_size
-        cmp     [hd_error], 0
-        jne     file_access_denied
-  read_set_size:
-        mov     [file_size], eax
-        mov     eax, [ebx+20-2] ; FAT entry
-        mov     ax, [ebx+26]
-        and     eax, [fatMASK]
-  file_read_start:
-        mov     ebx, PUSHAD_ECX ; pointer to buffer
-        mov     edx, PUSHAD_EBX ; file blocks to read
-        mov     esi, PUSHAD_ESI ; first 512 block to read
-  file_read_new_cluster:
-        call    get_data_cluster
-        jc      file_read_eof   ; end of file or cluster out of range
-        test    edx, edx        ; is all read?
-        je      file_read_OK    ; yes
-        call    get_FAT         ; get next cluster
-        cmp     [hd_error], 0
-        jne     file_access_denied
-        cmp     eax, [fatRESERVED]; end of file
-        jnb     file_read_eof
-        cmp     eax, 2          ; incorrect fat chain
-        jnb     file_read_new_cluster
-        popad
-        mov     [hd1_status], 0
-        mov     ebx, [file_size]
-        mov     eax, ERROR_FAT_TABLE
-        ret
-  file_read_eof:
-        cmp     [hd_error], 0
-        jne     file_access_denied
-        popad
-        mov     [hd1_status], 0
-        mov     ebx, [file_size]
-        mov     eax, ERROR_END_OF_FILE
-        ret
-  file_read_OK:
-        popad
-        mov     [hd1_status], 0
-        mov     ebx, [file_size]
-        xor     eax, eax
-        ret
-  file_to_read_not_found:
-        cmp     [hd_error], 0
-        jne     file_access_denied
-        popad
-        mov     [hd1_status], 0
-        xor     ebx, ebx
-        mov     eax, ERROR_FILE_NOT_FOUND
-        ret
-  file_access_denied:
-        popad
-        mov     [hd1_status], 0
-        xor     ebx, ebx
-        mov     eax, ERROR_ACCESS_DENIED
-        ret
-get_dir_size:
-;-----------------------------------------------------
-; input  : eax = first cluster (0=rootdir)
-; output : eax = directory size in bytes
-;-----------------------------------------------------
-        push    edx
-        xor     edx, edx        ; count of directory clusters
-        test    eax, eax
-        jnz     dir_size_next
-        mov     eax, [ROOT_SECTORS]
-        shl     eax, 9          ; fat16 rootdir size in bytes
-        cmp     [fs_type], 16
-        je      dir_size_ret
-        mov     eax, [ROOT_CLUSTER]
-  dir_size_next:
-        cmp     eax, 2          ; incorrect fat chain
-        jb      dir_size_end
-        cmp     eax, [fatRESERVED]; end of directory
-        ja      dir_size_end
-        call    get_FAT         ; get next cluster
-        cmp     [hd_error], 0
-        jne     dir_size_ret
-        inc     edx
-        jmp     dir_size_next
-  dir_size_end:
-        imul    eax, [SECTORS_PER_CLUSTER], 512; cluster size in bytes
+  add_not_fs:
-        imul    eax, edx
+        pop     ebx eax
-  dir_size_ret:
+  add_dfs_no:
-        pop     edx
+        ret
         ret
 clear_cluster_chain:
 ;-----------------------------------------------------
 ; input  : eax = first cluster
 ;-----------------------------------------------------
         push    eax ecx edx
         xor     ecx, ecx        ; cluster count
-  clean_new_chain:
-        cmp     eax, [LAST_CLUSTER]; end of file
+  clean_new_chain:
-        ja      delete_OK
+        cmp     eax, [ebp+FAT.LAST_CLUSTER]; end of file
-        cmp     eax, 2          ; unfinished fat chain or zero length file
+        ja      delete_OK
-        jb      delete_OK
+        cmp     eax, 2          ; unfinished fat chain or zero length file
-        cmp     eax, [ROOT_CLUSTER]; don't remove root cluster
+        jb      delete_OK
-        jz      delete_OK
+        cmp     eax, [ebp+FAT.ROOT_CLUSTER]; don't remove root cluster
+        jz      delete_OK
         xor     edx, edx
         call    set_FAT         ; clear fat entry
+        jc      access_denied_01
         cmp     [hd_error], 0
-        jne     access_denied_01
+        inc     ecx             ; update cluster count
         mov     eax, edx        ; old cluster
-        inc     ecx             ; update cluster count
+        jmp     clean_new_chain
         mov     eax, edx        ; old cluster
-        jmp     clean_new_chain
+  delete_OK:
         call    add_disk_free_space; add clusters to free disk space
-  delete_OK:
+        clc
-        call    add_disk_free_space; add clusters to free disk space
+  access_denied_01:
-  access_denied_01:
+        pop     edx ecx eax
-        pop     edx ecx eax
+        ret
-        ret
 if 0
 get_hd_info:
 ;-----------------------------------------------------------
 ; output : eax = 0 - ok
   info_fat_ok:
 ;    call  reserve_hd1
         xor     ecx, ecx        ; count of free clusters
         mov     eax, 2
-        mov     ebx, [LAST_CLUSTER]
+        mov     ebx, [ebp+FAT.LAST_CLUSTER]
   info_cluster:
-        push    eax
-        call    get_FAT         ; get cluster info
+        push    eax
-        cmp     [hd_error], 0
+        call    get_FAT         ; get cluster info
-        jne     info_access_denied
+        jc      info_access_denied
         inc     eax
         cmp     eax, ebx        ; is above last cluster?
         jbe     info_cluster    ; no. test next cluster
         dec     ebx             ; cluster count
-        imul    edx, [SECTORS_PER_CLUSTER], 512; cluster size in bytes
-        mov     [hd1_status], 0
+        imul    edx, [ebp+FAT.SECTORS_PER_CLUSTER], 512; cluster size in bytes
         xor     eax, eax
         ret
   info_access_denied:
         add     esp, 4
         xor     edx, edx
         xor     ebx, ebx
         xor     ecx, ecx
+        mov     eax, ERROR_ACCESS_DENIED
-        mov     eax, ERROR_ACCESS_DENIED
+        ret
-        ret
+end if
 update_disk:
 ;-----------------------------------------------------------
 ; write changed fat and cache to disk
 ;-----------------------------------------------------------
-        cmp     [fat_change], 0 ; is fat changed?
-        je      upd_no_change
+        cmp     [ebp+FAT.fat_change], 0 ; is fat changed?
         je      upd_no_change
+        call    write_fat_sector
-        call    write_fat_sector
+        jc      update_disk_acces_denied
-        cmp     [hd_error], 0
+  upd_no_change:
         jne     update_disk_acces_denied
+        push    esi
+        mov     esi, [ebp+PARTITION.Disk]
+        call    disk_sync
+        pop     esi
+  update_disk_acces_denied:
+        ret
-  upd_no_change:
+fat_lock:
+        lea     ecx, [ebp+FAT.Lock]
+        jmp     mutex_lock
-        call    write_cache
+fat_unlock:
-  update_disk_acces_denied:
+        lea     ecx, [ebp+FAT.Lock]
-        ret
+        jmp     mutex_unlock
 ; \begin{diamond}
-; \begin{diamond}
+hd_find_lfn:
-hd_find_lfn:
+; in: ebp -> FAT structure
-; in: esi+ebp -> name
+; in: esi+[esp+4] -> name
-; out: CF=1 - file not found
+; out: CF=1 - file not found, eax=error code
 ;      else CF=0 and edi->direntry, eax=sector
 ; destroys eax
         push    esi edi
         push    0
         push    0
         push    fat16_root_first
         jmp     .loop
 .notfound:
         add     esp, 16
         pop     edi esi
         stc
-        ret
+        ret     4
 .found:
-        test    ebp, ebp
+        lea     eax, [esp+4+24]
+        cmp     dword [eax], 0
         jz      @f
-        mov     esi, ebp
+        mov     esi, [eax]
-        xor     ebp, ebp
+        and     dword [eax], 0
         jmp     .continue
 @@:
         lea     eax, [esp+8]
         cmp     dword [eax], 0
         jz      .root
         call    fat_get_sector
         jmp     .cmn
 .root:
         mov     eax, [eax+4]
-        add     eax, [ROOT_START]
+        add     eax, [ebp+FAT.ROOT_START]
 .cmn:
         add     esp, 20         ; CF=0
         pop     esi
-        ret
+        ret     4
 ;----------------------------------------------------------------
+;
 ;  fs_HdRead - LFN variant for reading hard disk
+;
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
 ;  ebx  pointer to 64-bit number = first wanted byte, 0+
 ;       may be ebx=0 - start from first byte
 ;  ecx  number of bytes to read, 0+
         jz      ext2_HdRead
         or      ebx, -1
         mov     eax, ERROR_UNKNOWN_FS
         ret
 @@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_Read
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_Read - FAT16/32 implementation of reading a file
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
+fat_Read:
+        call    fat_lock
         push    edi
         cmp     byte [esi], 0
         jnz     @f
 .noaccess:
         pop     edi
 .noaccess_2:
+        call    fat_unlock
         or      ebx, -1
         mov     eax, ERROR_ACCESS_DENIED
         ret
 @@:
-        call    hd_find_lfn
+        stdcall hd_find_lfn, [esp+4+4]
         jnc     .found
+        pop     edi
-        pop     edi
+        push    eax
-        cmp     [hd_error], 0
+        call    fat_unlock
-        jne     .noaccess_2
+        pop     eax
-        or      ebx, -1
-        mov     eax, ERROR_FILE_NOT_FOUND
+        or      ebx, -1
         ret
 .found:
-        test    byte [edi+11], 0x10; do not allow read directories
-        jnz     .noaccess
-        test    ebx, ebx
+        test    byte [edi+11], 0x10; do not allow read directories
-        jz      .l1
+        jnz     .noaccess
-        cmp     dword [ebx+4], 0
+        cmp     dword [ebx+8], 0
         jz      @f
         xor     ebx, ebx
+.reteof:
-.reteof:
+        call    fat_unlock
-        mov     eax, 6
+        mov     eax, ERROR_END_OF_FILE
         pop     edi
         ret
-@@:
+@@:
+        mov     ecx, [ebx+12]   ; size
-        mov     ebx, [ebx]
+        mov     edx, [ebx+16]   ; pointer
-.l1:
+        mov     ebx, [ebx+4]    ; file offset
-        push    ecx edx
+        push    edx
         push    0
         mov     eax, [edi+28]
         sub     eax, ebx
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]
 ; now eax=cluster, ebx=position, ecx=count, edx=buffer for data
 .new_cluster:
         jecxz   .new_sector
-        test    eax, eax
+        cmp     eax, 2
-        jz      .eof
+        jb      .eof
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         jae     .eof
-        mov     [cluster_tmp], eax
+        mov     [ebp+FAT.cluster_tmp], eax
         dec     eax
         dec     eax
-        mov     edi, [SECTORS_PER_CLUSTER]
+        mov     edi, [ebp+FAT.SECTORS_PER_CLUSTER]
         imul    eax, edi
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
 .new_sector:
         test    ecx, ecx
         jz      .done
         sub     ebx, 512
         jae     .skip
         add     ebx, 512
         jnz     .force_buf
         cmp     ecx, 512
         jb      .force_buf
 ; we may read directly to given buffer
-        push    ebx
+        push    eax ebx
         mov     ebx, edx
-        call    hd_read
+        call    fs_read32_app
-        pop     ebx
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     ebx eax
         jne     .noaccess_1
         add     edx, 512
         sub     ecx, 512
         jmp     .skip
 .force_buf:
 ; we must read sector to temporary buffer and then copy it to destination
         push    eax ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_app
+        test    eax, eax
         mov     eax, ebx
         pop     ebx
-        cmp     [hd_error], 0
         jne     .noaccess_3
         add     eax, ebx
         push    ecx
         add     ecx, ebx
         cmp     ecx, 512
         xor     ebx, ebx
 .skip:
         inc     eax
         dec     edi
         jnz     .new_sector
-        mov     eax, [cluster_tmp]
+        mov     eax, [ebp+FAT.cluster_tmp]
         call    get_FAT
-        cmp     [hd_error], 0
-        jne     .noaccess_1
+        jc      .noaccess_1
         jmp     .new_cluster
 .noaccess_3:
         pop     eax
 .noaccess_1:
         pop     eax
-        push    11
+        push    ERROR_DEVICE
 .done:
+        mov     ebx, edx
-        mov     ebx, edx
+        call    fat_unlock
-        pop     eax edx ecx edi
+        pop     eax edx edi
         sub     ebx, edx
         ret
 .eof:
         mov     ebx, edx
-        pop     eax edx ecx
+        pop     eax edx
         sub     ebx, edx
         jmp     .reteof
 ;----------------------------------------------------------------
+;
+;  fs_HdReadFolder - LFN variant for reading hard disk folder
+;
-;  fs_HdReadFolder - LFN variant for reading hard disk folder
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
 ;  ebx  pointer to structure 32-bit number = first wanted block, 0+
 ;                          & flags (bitfields)
 ;  ret ebx = blocks read or 0xffffffff folder not found
 ;      eax = 0 ok read or other = errormsg
+;
 ;--------------------------------------------------------------
 fs_HdReadFolder:
-        cmp     [fs_type], 1
-        jz      ntfs_HdReadFolder
-        cmp     [fs_type], 2
-        jz      ext2_HdReadFolder
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
         jz      @f
+        cmp     [fs_type], 1
+        jz      ntfs_HdReadFolder
+        cmp     [fs_type], 2
+        jz      ext2_HdReadFolder
         push    ERROR_UNSUPPORTED_FS
         pop     eax
         or      ebx, -1
         ret
 @@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_ReadFolder
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_ReadFolder - FAT16/32 implementation of reading a folder
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
+fat_ReadFolder:
+        call    fat_lock
-        mov     eax, [ROOT_CLUSTER]
+        mov     eax, [ebp+FAT.ROOT_CLUSTER]
         push    edi
         cmp     byte [esi], 0
         jz      .doit
-        call    hd_find_lfn
+        stdcall hd_find_lfn, [esp+4+4]
         jnc     .found
         pop     edi
+        push    eax
+        call    fat_unlock
+        pop     eax
         or      ebx, -1
-        mov     eax, ERROR_FILE_NOT_FOUND
         ret
 .found:
         test    byte [edi+11], 0x10     ; do not allow read files
         jnz     .found_dir
         pop     edi
+        call    fat_unlock
         or      ebx, -1
         mov     eax, ERROR_ACCESS_DENIED
         ret
 .found_dir:
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]    ; eax=cluster
 .doit:
-        push    esi ecx
-        push    ebp
+        push    esi
         sub     esp, 262*2      ; reserve space for LFN
-        mov     ebp, esp
-        push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE name
+        push    dword [ebx+8]   ; for fat_get_name: read ANSI/UNICODE name
-        mov     ebx, [ebx]
+        mov     edx, [ebx+16]   ; pointer to buffer
 ; init header
-        push    eax ecx
+        push    eax
         mov     edi, edx
         mov     ecx, 32/4
         xor     eax, eax
         rep stosd
-        pop     ecx eax
+        pop     eax
         mov     byte [edx], 1   ; version
         mov     esi, edi        ; esi points to BDFE
+        mov     ecx, [ebx+12]   ; number of blocks to read
+        mov     ebx, [ebx+4]    ; index of the first block
 .new_cluster:
-        mov     [cluster_tmp], eax
+        mov     [ebp+FAT.cluster_tmp], eax
         test    eax, eax
         jnz     @f
-        cmp     [fs_type], 32
+        cmp     [ebp+FAT.fs_type], 32
         jz      .notfound
-        mov     eax, [ROOT_START]
+        mov     eax, [ebp+FAT.ROOT_START]
-        push    [ROOT_SECTORS]
+        push    [ebp+FAT.ROOT_SECTORS]
         push    ebx
         jmp     .new_sector
 @@:
         dec     eax
         dec     eax
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        push    [SECTORS_PER_CLUSTER]
+        push    [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
         push    ebx
 .new_sector:
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
         mov     edi, ebx
+        push    eax
-        call    hd_read
+        call    fs_read32_sys
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     eax
         jnz     .notfound2
         add     ebx, 512
         push    eax
 .l1:
+        push    ebp
+        lea     ebp, [esp+20]
         call    fat_get_name
+        pop     ebp
         jc      .l2
         cmp     byte [edi+11], 0xF
         jnz     .do_bdfe
         add     edi, 0x20
         cmp     edi, ebx
         jb      .do_bdfe
         pop     eax
         inc     eax
         dec     dword [esp+4]
         jnz     @f
-        mov     eax, [cluster_tmp]
+        mov     eax, [ebp+FAT.cluster_tmp]
         test    eax, eax
         jz      .done
         call    get_FAT
-        cmp     [hd_error], 0
-        jnz     .notfound2
+        jc      .notfound2
         cmp     eax, 2
         jb      .done
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         jae     .done
         push    eax
-        mov     eax, [SECTORS_PER_CLUSTER]
+        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
         mov     [esp+8], eax
         pop     eax
-        mov     [cluster_tmp], eax
+        mov     [ebp+FAT.cluster_tmp], eax
         dec     eax
         dec     eax
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
 @@:
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
         mov     edi, ebx
+        push    eax
-        call    hd_read
+        call    fs_read32_sys
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     eax
         jnz     .notfound2
         add     ebx, 512
         push    eax
 .do_bdfe:
         inc     dword [edx+8]   ; new file found
         dec     dword [esp+4]
         jns     .l2
         dec     ecx
         js      .l2
         inc     dword [edx+4]   ; new file block copied
+        push    ebp
+        lea     ebp, [esp+20]
         call    fat_entry_to_bdfe
+        pop     ebp
 .l2:
         add     edi, 0x20
         cmp     edi, ebx
         jb      .l1
         pop     eax
         inc     eax
         dec     dword [esp+4]
         jnz     .new_sector
-        mov     eax, [cluster_tmp]
+        mov     eax, [ebp+FAT.cluster_tmp]
         test    eax, eax
         jz      .done
         call    get_FAT
-        cmp     [hd_error], 0
-        jnz     .notfound2
+        jc      .notfound2
         cmp     eax, 2
         jb      .done
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         jae     .done
         push    eax
-        mov     eax, [SECTORS_PER_CLUSTER]
+        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
         mov     [esp+8], eax
         pop     eax
         pop     ebx
         add     esp, 4
         jmp     .new_cluster
 .notfound2:
         add     esp, 8
 .notfound:
         add     esp, 262*2+4
-        pop     ebp ecx esi edi
+        pop     esi edi
-        mov     eax, ERROR_FILE_NOT_FOUND
+        mov     ebx, [edx+4]
-        or      ebx, -1
+        call    fat_unlock
+        mov     eax, ERROR_DEVICE
         ret
 .done:
         add     esp, 262*2+4+8
-        pop     ebp
         mov     ebx, [edx+4]
         xor     eax, eax
         dec     ecx
         js      @f
         mov     al, ERROR_END_OF_FILE
 @@:
+        push    eax
+        call    fat_unlock
+        pop     eax
-        pop     ecx esi edi
+        pop     esi edi
         ret
+fat16_root_next:
-fat16_root_next:
+        push    ecx
+        lea     ecx, [ebp+FAT.buffer+0x200-0x20]
-        cmp     edi, buffer+0x200-0x20
+        cmp     edi, ecx
+        jae     fat16_root_next_sector
-        jae     fat16_root_next_sector
+        pop     ecx
         add     edi, 0x20
         ret     ; CF=0
 fat16_root_next_sector:
 ; read next sector
-        push    [longname_sec2]
+        push    [ebp+FAT.longname_sec2]
-        pop     [longname_sec1]
-        push    ecx
+        pop     [ebp+FAT.longname_sec1]
         mov     ecx, [eax+4]
         push    ecx
-        add     ecx, [ROOT_START]
+        add     ecx, [ebp+FAT.ROOT_START]
-        mov     [longname_sec2], ecx
+        mov     [ebp+FAT.longname_sec2], ecx
         pop     ecx
         inc     ecx
         mov     [eax+4], ecx
-        cmp     ecx, [ROOT_SECTORS]
+        cmp     ecx, [ebp+FAT.ROOT_SECTORS]
         pop     ecx
+        jb      fat16_root_first
+        mov     eax, ERROR_FILE_NOT_FOUND
+        stc
-        jae     fat16_root_first.readerr
+        ret
 fat16_root_first:
         mov     eax, [eax+4]
-        add     eax, [ROOT_START]
+        add     eax, [ebp+FAT.ROOT_START]
         push    ebx
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
         mov     ebx, edi
-        call    hd_read
+        call    fs_read32_sys
         pop     ebx
-        cmp     [hd_error], 0
+        test    eax, eax
         jnz     .readerr
         ret     ; CF=0
+.readerr:
+        mov     eax, ERROR_DEVICE
+        stc
+        ret
+.notfound:
-.readerr:
+        mov     eax, ERROR_FILE_NOT_FOUND
         stc
         ret
 fat16_root_begin_write:
         push    edi eax
         call    fat16_root_first
         pop     eax edi
         ret
 fat16_root_end_write:
         pusha
         mov     eax, [eax+4]
-        add     eax, [ROOT_START]
+        add     eax, [ebp+FAT.ROOT_START]
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         popa
         ret
+fat16_root_next_write:
+        push    ecx
-fat16_root_next_write:
+        lea     ecx, [ebp+FAT.buffer+0x200]
-        cmp     edi, buffer+0x200
+        cmp     edi, ecx
+        jae     @f
-        jae     @f
+        pop     ecx
         ret
 @@:
         call    fat16_root_end_write
         jmp     fat16_root_next_sector
 fat16_root_extend_dir:
         stc
         ret
+fat_notroot_next:
+        push    ecx
-fat_notroot_next:
+        lea     ecx, [ebp+FAT.buffer+0x200-0x20]
+        cmp     edi, ecx
-        cmp     edi, buffer+0x200-0x20
+        jae     fat_notroot_next_sector
-        jae     fat_notroot_next_sector
+        pop     ecx
         add     edi, 0x20
         ret     ; CF=0
 fat_notroot_next_sector:
-        push    [longname_sec2]
+        push    [ebp+FAT.longname_sec2]
-        pop     [longname_sec1]
+        pop     [ebp+FAT.longname_sec1]
         push    eax
         call    fat_get_sector
-        mov     [longname_sec2], eax
-        pop     eax
+        mov     [ebp+FAT.longname_sec2], eax
-        push    ecx
+        pop     eax
         mov     ecx, [eax+4]
         inc     ecx
-        cmp     ecx, [SECTORS_PER_CLUSTER]
+        cmp     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         jae     fat_notroot_next_cluster
         mov     [eax+4], ecx
         jmp     @f
 fat_notroot_next_cluster:
         push    eax
         mov     eax, [eax]
         call    get_FAT
+        mov     ecx, eax
-        mov     ecx, eax
+        pop     eax
-        pop     eax
+        jc      fat_notroot_first.deverr
-        cmp     [hd_error], 0
+        cmp     ecx, 2
-        jnz     fat_notroot_next_err
+        jb      fat_notroot_next_err
-        cmp     ecx, [fatRESERVED]
+        cmp     ecx, [ebp+FAT.fatRESERVED]
         jae     fat_notroot_next_err
         mov     [eax], ecx
         and     dword [eax+4], 0
 @@:
         pop     ecx
 fat_notroot_first:
         call    fat_get_sector
         push    ebx
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
         mov     ebx, edi
+        call    fs_read32_sys
-        call    hd_read
+        pop     ebx
-        pop     ebx
+        test    eax, eax
+        jz      .ret ; CF=0
-        cmp     [hd_error], 0
+        push    ecx
+.deverr:
+        pop     ecx
+        mov     eax, ERROR_DEVICE
+        stc
-        jnz     @f
+.ret:
-        ret     ; CF=0
+        ret
-fat_notroot_next_err:
+fat_notroot_next_err:
         pop     ecx
-@@:
+        mov     eax, ERROR_FILE_NOT_FOUND
         stc
         ret
 fat_notroot_begin_write:
         push    eax edi
         call    fat_notroot_first
         pop     edi eax
         ret
 fat_notroot_end_write:
         call    fat_get_sector
         push    ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         pop     ebx
+        ret
+fat_notroot_next_write:
-        ret
+        push    ecx
-fat_notroot_next_write:
+        lea     ecx, [ebp+FAT.buffer+0x200]
+        cmp     edi, ecx
-        cmp     edi, buffer+0x200
+        jae     @f
-        jae     @f
+        pop     ecx
         ret
 @@:
         push    eax
         jnc     .found
         pop     eax
         ret     ; CF=1
 .found:
         push    edx
-        mov     edx, [fatEND]
+        mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
+        jc      .writeerr
         mov     edx, eax
         mov     eax, [esp+4]
         mov     eax, [eax]
         push    edx
         call    set_FAT
         pop     edx
-        cmp     [hd_error], 0
-        jz      @f
+        jnc     @f
+.writeerr:
         pop     edx
         pop     eax
         stc
         ret
 @@:
         push    ecx
         or      ecx, -1
         call    add_disk_free_space
 ; zero new cluster
         mov     ecx, 512/4
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
         push    edi
         xor     eax, eax
         rep stosd
         pop     edi
         pop     ecx
         pop     edx
         mov     eax, [eax]
         dec     eax
         dec     eax
         push    ebx ecx
-        mov     ecx, [SECTORS_PER_CLUSTER]
+        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         imul    eax, ecx
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
         mov     ebx, edi
 @@:
+        push    eax
-        call    hd_write
+        call    fs_write32_sys
+        pop     eax
         inc     eax
         loop    @b
         pop     ecx ebx eax
         clc
         ret
 fat_get_sector:
         push    ecx
         mov     ecx, [eax]
         dec     ecx
         dec     ecx
-        imul    ecx, [SECTORS_PER_CLUSTER]
+        imul    ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     ecx, [DATA_START]
+        add     ecx, [ebp+FAT.DATA_START]
         add     ecx, [eax+4]
         mov     eax, ecx
         pop     ecx
         ret
 ;----------------------------------------------------------------
+;
 ;  fs_HdRewrite - LFN variant for writing hard disk
+;
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
 ;  ebx  ignored (reserved)
 ;  ecx  number of bytes to write, 0+
 ;  edx  mem location to data
+;
 ;  ret ebx = number of written bytes
 ;      eax = 0 ok read or other = errormsg
+;
-;--------------------------------------------------------------
-fshrad:
-        mov     eax, ERROR_ACCESS_DENIED
-        xor     ebx, ebx
-        ret
-fshrfs:
-        mov     eax, ERROR_UNKNOWN_FS
-        xor     ebx, ebx
-        ret
 ;--------------------------------------------------------------
 fs_HdCreateFolder:
         mov     al, 1
         jmp     fs_HdRewrite.common
 fs_HdRewrite:
+        xor     eax, eax
+.common:
+        cmp     [fs_type], 16
+        jz      @f
-        xor     eax, eax
+        cmp     [fs_type], 32
-.common:
+        jz      @f
         cmp     [fs_type], 1
         jz      ntfs_HdRewrite
         cmp     [fs_type], 2
         jz      ext2_HdRewrite
-        cmp     [fs_type], 16
-        jz      @f
+        mov     eax, ERROR_UNKNOWN_FS
-        cmp     [fs_type], 32
+        xor     ebx, ebx
+        ret
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        test    eax, eax
+        mov     eax, fat_CreateFolder
+        jnz     @f
+        mov     eax, fat_Rewrite
+@@:
+        call    eax
+        pop     ebp
+        ret
+fshrad:
+        call    fat_unlock
+        mov     eax, ERROR_ACCESS_DENIED
+        xor     ebx, ebx
+        ret
+;----------------------------------------------------------------
+; fat_CreateFolder - FAT16/32 implementation of creating a folder
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
+fat_CreateFolder:
+        push    1
+        jmp     fat_Rewrite.common
+;----------------------------------------------------------------
+; fat_HdRewrite - FAT16/32 implementation of creating a new file
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
+fat_Rewrite:
+        push    0
+.common:
-        jnz     fshrfs
+        call    fat_lock
-@@:
+        pop     eax
+        cmp     byte [esi], 0
+        jz      fshrad
-        cmp     byte [esi], 0
+        mov     ecx, [ebx+12]
-        jz      fshrad
+        mov     edx, [ebx+16]
+        pushad
-        pushad
+        xor     edi, edi
-        xor     edi, edi
+        mov     edx, [esp+4+20h]
         push    esi
-        test    ebp, ebp
+        test    edx, edx
         jz      @f
-        mov     esi, ebp
+        mov     esi, edx
 @@:
         lodsb
         test    al, al
         jmp     @b
 @@:
         pop     esi
         test    edi, edi
         jnz     .noroot
-        test    ebp, ebp
+        test    edx, edx
         jnz     .hasebp
-        mov     ebp, [ROOT_CLUSTER]
+        mov     edx, [ebp+FAT.ROOT_CLUSTER]
-        cmp     [fs_type], 32
+        cmp     [ebp+FAT.fs_type], 32
         jz      .pushnotroot
+        xor     edx, edx
+        push    edx
         push    fat16_root_extend_dir
         push    fat16_root_end_write
         push    fat16_root_next_write
         push    fat16_root_begin_write
-        xor     ebp, ebp
-        push    ebp
+        push    edx
-        push    ebp
+        push    edx
         push    fat16_root_first
         push    fat16_root_next
         jmp     .common1
 .hasebp:
         mov     eax, ERROR_ACCESS_DENIED
-        cmp     byte [ebp], 0
+        cmp     byte [edx], 0
         jz      .ret1
-        push    ebp
-        xor     ebp, ebp
-        call    hd_find_lfn
+        stdcall hd_find_lfn, 0
-        pop     esi
+        mov     esi, [esp+4+20h]
-        jc      .notfound0
+        jc      .ret1
         jmp     .common0
 .noroot:
         mov     eax, ERROR_ACCESS_DENIED
         cmp     byte [edi+1], 0
         jz      .ret1
 ; check existence
         mov     byte [edi], 0
         push    edi
-        call    hd_find_lfn
+        stdcall hd_find_lfn, [esp+4+24h]
         pop     esi
         mov     byte [esi], '/'
         jnc     @f
 .notfound0:
         mov     eax, ERROR_FILE_NOT_FOUND
 .ret1:
         mov     [esp+28], eax
+        call    fat_unlock
         popad
         xor     ebx, ebx
         ret
 @@:
         inc     esi
 .common0:
         test    byte [edi+11], 0x10     ; must be directory
         mov     eax, ERROR_ACCESS_DENIED
         jz      .ret1
-        mov     ebp, [edi+20-2]
+        mov     edx, [edi+20-2]
-        mov     bp, [edi+26]            ; ebp=cluster
+        mov     dx, [edi+26]            ; ebp=cluster
         mov     eax, ERROR_FAT_TABLE
-        cmp     ebp, 2
+        cmp     edx, 2
         jb      .ret1
 .pushnotroot:
+        push    edx
         push    fat_notroot_extend_dir
         push    fat_notroot_end_write
         push    fat_notroot_next_write
         push    fat_notroot_begin_write
         push    0
-        push    ebp
+        push    edx
         push    fat_notroot_first
         push    fat_notroot_next
 .common1:
         call    fat_find_lfn
         jc      .notfound
 ; found
         test    byte [edi+11], 10h
         jz      .exists_file
 ; found directory; if we are creating directory, return OK,
 ;                  if we are creating file, say "access denied"
-        add     esp, 32
+        add     esp, 36
+        call    fat_unlock
         popad
         test    al, al
         mov     eax, ERROR_ACCESS_DENIED
         jz      @f
         mov     al, 0
         xor     ebx, ebx
         ret
 .exists_file:
 ; found file; if we are creating directory, return "access denied",
 ;             if we are creating file, delete existing file and continue
-        cmp     byte [esp+32+28], 0
+        cmp     byte [esp+36+28], 0
         jz      @f
-        add     esp, 32
+        add     esp, 36
+        call    fat_unlock
         popad
         mov     eax, ERROR_ACCESS_DENIED
         xor     ebx, ebx
         ret
 @@:
         mov     word [edi+20], cx
         mov     word [edi+26], cx
         test    eax, eax
         jz      .done1
 @@:
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         jae     .done1
         push    edx
         xor     edx, edx
         call    set_FAT
         mov     eax, edx
         pop     edx
+        jc      .done1
         inc     ecx
         jmp     @b
 .done1:
         pop     edi
         call    get_time_for_file
         jmp     .doit
 .notfound:
 ; file is not found; generate short name
         call    fat_name_is_legal
         jc      @f
-        add     esp, 32
+        add     esp, 36
+        call    fat_unlock
         popad
         mov     eax, ERROR_FILE_NOT_FOUND
         xor     ebx, ebx
         ret
 @@:
         call    fat_gen_short_name
 .test_short_name_loop:
         push    esi edi ecx
         mov     esi, edi
         lea     eax, [esp+12+12+8]
+        mov     edx, [eax+24]
-        mov     [eax], ebp
+        mov     [eax], edx
         and     dword [eax+4], 0
         call    dword [eax-4]
         jc      .found
 .test_short_name_entry:
         cmp     byte [edi+11], 0xF
 .short_name_found:
         pop     ecx edi esi
         call    fat_next_short_name
         jnc     .test_short_name_loop
 .disk_full:
-        add     esp, 12+32
+        add     esp, 12+36
+        call    fat_unlock
         popa
         mov     eax, ERROR_DISK_FULL
         xor     ebx, ebx
         ret
 .found:
         push    -1
 ; find  successive entries in directory
         xor     ecx, ecx
         push    eax
         lea     eax, [esp+16+8+12+8]
+        mov     edx, [eax+24]
-        mov     [eax], ebp
+        mov     [eax], edx
         and     dword [eax+4], 0
         call    dword [eax-4]
         pop     eax
         jnc     .scan_dir
 .fsfrfe3:
-        add     esp, 12+8+12+32
+        add     esp, 12+8+12+36
+        call    fat_unlock
         popad
-        mov     eax, 11
+        mov     eax, ERROR_DEVICE
         xor     ebx, ebx
         ret
 .scan_dir:
         cmp     byte [edi], 0
         jz      .free
         xor     ecx, ecx
 .scan_cont:
         push    eax
         lea     eax, [esp+16+8+12+8]
         call    dword [eax-8]
+        mov     edx, eax
         pop     eax
         jnc     .scan_dir
-        cmp     [hd_error], 0
+        cmp     edx, ERROR_DEVICE
-        jnz     .fsfrfe3
+        jz      .fsfrfe3
         push    eax
         lea     eax, [esp+16+8+12+8]
         call    dword [eax+20]          ; extend directory
         pop     eax
         jnc     .scan_dir
-        add     esp, 12+8+12+32
+        add     esp, 12+8+12+36
+        call    fat_unlock
         popad
         mov     eax, ERROR_DISK_FULL
         xor     ebx, ebx
         ret
 .free:
 @@:
         inc     ecx
         cmp     ecx, eax
         jb      .scan_cont
 ; found!
-; calculate name checksum
         push    esi ecx
+; If creating a directory, allocate one data cluster now and fail immediately
+; if this is impossible. This prevents from creating an invalid directory entry
+; on a full disk.
+; yup, the argument is quite non-intuitive... but what should I do if
+; the entire function uses such arguments? BTW, it refers to al from pushad,
+; which in turn is filled with 0 in fat_Rewrite and 1 in fat_CreateFolder.
+        cmp     byte [esp+8+12+8+12+36+28], 0
+        jz      .no.preallocate.folder.data
+        call    get_free_FAT
+        jnc     @f
+        add     esp, 8+12+8
+        jmp     .disk_full
+@@:
+        mov     [esp+8+12+8+12+36+20], eax ; store the cluster somewhere
+.no.preallocate.folder.data:
+; calculate name checksum
         mov     esi, [esp+8+12]
         mov     ecx, 11
         xor     eax, eax
 @@:
         ror     al, 1
         mov     [edi+18], ax            ; last access date
         xor     ecx, ecx
         mov     word [edi+20], cx       ; high word of cluster
         mov     word [edi+26], cx       ; low word of cluster - to be filled
         mov     dword [edi+28], ecx     ; file size - to be filled
-        cmp     byte [esp+32+28], cl
+        cmp     byte [esp+36+28], cl
         jz      .doit
 ; create directory
         mov     byte [edi+11], 10h      ; attributes: folder
-        mov     edx, edi
+        mov     esi, edi
         lea     eax, [esp+8]
         call    dword [eax+16]  ; flush directory
+        mov     eax, [esp+36+20] ; extract saved cluster
+        mov     [esp+36+20], edi ; this is needed for calculating arg of add_disk_free_space!
         push    ecx
-        mov     ecx, [SECTORS_PER_CLUSTER]
+        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         shl     ecx, 9
+        push    ecx
+        push    edi
         jmp     .doit2
 .doit:
+        mov     esi, [esp+36+20]
         lea     eax, [esp+8]
         call    dword [eax+16]  ; flush directory
         push    ecx
-        mov     ecx, [esp+4+32+24]
+        mov     ecx, [esp+4+36+24]
-.doit2:
         push    ecx
         push    edi
-        mov     esi, edx
         test    ecx, ecx
         jz      .done
         call    get_free_FAT
         jc      .diskfull
+.doit2:
         push    eax
         mov     [edi+26], ax
         shr     eax, 16
         mov     [edi+20], ax
         lea     eax, [esp+16+8]
         call    dword [eax+16]  ; flush directory
         pop     eax
         push    edx
-        mov     edx, [fatEND]
+        mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
         pop     edx
 .write_cluster:
         push    eax
         dec     eax
         dec     eax
-        mov     ebp, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        imul    eax, ebp
+        add     eax, [ebp+FAT.DATA_START]
-        add     eax, [DATA_START]
+        push    [ebp+FAT.SECTORS_PER_CLUSTER]
 ; write data
 .write_sector:
-        cmp     byte [esp+16+32+28], 0
+        cmp     byte [esp+20+36+28], 0
         jnz     .writedir
         mov     ecx, 512
-        cmp     dword [esp+8], ecx
+        cmp     dword [esp+12], ecx
         jb      .writeshort
 ; we can write directly from given buffer
         mov     ebx, esi
         add     esi, ecx
         jmp     .writecommon
 .writeshort:
-        mov     ecx, [esp+8]
+        mov     ecx, [esp+12]
         push    ecx
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
         mov     ebx, edi
         rep movsb
 .writedircont:
-        mov     ecx, buffer+0x200
+        lea     ecx, [ebp+FAT.buffer+0x200]
         sub     ecx, edi
         push    eax
         xor     eax, eax
         rep stosb
         pop     eax
         pop     ecx
 .writecommon:
+        push    eax
-        call    hd_write
+        call    fs_write32_app
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     eax
         jnz     .writeerr
         inc     eax
-        sub     dword [esp+8], ecx
+        sub     dword [esp+12], ecx
         jz      .writedone
-        dec     ebp
+        dec     dword [esp]
         jnz     .write_sector
+        pop     eax
 ; allocate new cluster
         pop     eax
         mov     ecx, eax
         call    get_free_FAT
         jc      .diskfull
         push    edx
-        mov     edx, [fatEND]
+        mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
         xchg    eax, ecx
         mov     edx, ecx
         call    set_FAT
         pop     edx
         jmp     .write_cluster
 .diskfull:
         mov     eax, ERROR_DISK_FULL
         jmp     .ret
 .writeerr:
-        pop     eax
+        pop     eax eax
         sub     esi, ecx
-        mov     eax, 11
+        mov     eax, ERROR_DEVICE
         jmp     .ret
 .writedone:
-        pop     eax
+        pop     eax eax
 .done:
         xor     eax, eax
 .ret:
         pop     edi ecx
-        mov     ebx, esi
+        sub     esi, [esp+4+36+20]
-        sub     ebx, edx
+        mov     [esp+4+36+28], eax
-        pop     ebp
-        mov     [esp+32+28], eax
+        mov     [esp+4+36+16], esi
-        lea     eax, [esp+8]
+        lea     eax, [esp+12]
         call    dword [eax+8]
-        mov     [edi+28], ebx
+        mov     [edi+28], esi
         call    dword [eax+16]
-        mov     [esp+32+16], ebx
+        mov     [esp+36+16], ebx
-        lea     eax, [ebx+511]
+        lea     eax, [esi+511]
         shr     eax, 9
-        mov     ecx, [SECTORS_PER_CLUSTER]
+        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         lea     eax, [eax+ecx-1]
         xor     edx, edx
         div     ecx
-        mov     ecx, ebp
+        pop     ecx
         sub     ecx, eax
         call    add_disk_free_space
-        add     esp, 32
+        add     esp, 36
         call    update_disk
+        call    fat_unlock
         popad
         ret
 .writedir:
         push    512
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
         mov     ebx, edi
-        mov     ecx, [SECTORS_PER_CLUSTER]
+        mov     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         shl     ecx, 9
-        cmp     ecx, [esp+12]
+        cmp     ecx, [esp+16]
         jnz     .writedircont
-        dec     dword [esp+16]
+        dec     dword [esp+20]
         push    esi
         mov     ecx, 32/4
         rep movsd
         pop     esi
         mov     dword [edi-32], '.   '
         pop     esi
         mov     dword [edi-32], '..  '
         mov     dword [edi-32+4], '    '
         mov     dword [edi-32+8], '    '
         mov     byte [edi-32+11], 10h
-        mov     ecx, [esp+20+8]
+        mov     ecx, [esp+20+36]
-        cmp     ecx, [ROOT_CLUSTER]
+        cmp     ecx, [ebp+FAT.ROOT_CLUSTER]
         jnz     @f
         xor     ecx, ecx
 @@:
         mov     word [edi-32+26], cx
         shr     ecx, 16
 ;----------------------------------------------------------------
+;
 ;  fs_HdWrite - LFN variant for writing to hard disk
+;
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
 ;  ebx  pointer to 64-bit number = first wanted byte, 0+
 ;       may be ebx=0 - start from first byte
 ;  ecx  number of bytes to write, 0+
 ;  edx  mem location to data
+;
 ;  ret ebx = bytes written (maybe 0)
 ;      eax = 0 ok write or other = errormsg
+;
 ;--------------------------------------------------------------
-fs_HdWrite.access_denied:
+fat_Write.access_denied:
         push    ERROR_ACCESS_DENIED
 fs_HdWrite.ret0:
         pop     eax
         xor     ebx, ebx
         ret
 fs_HdWrite.ret11:
-        push    11
+        push    ERROR_DEVICE
-        jmp     fs_HdWrite.ret0
-fs_HdWrite:
-        cmp     [fs_type], 1
-        jz      ntfs_HdWrite
+        jmp     fs_HdWrite.ret0
         cmp     [fs_type], 2
-        jz      ext2_HdWrite
+fs_HdWrite:
         cmp     [fs_type], 16
+        jz      @f
+        cmp     [fs_type], 32
+        jz      @f
+        cmp     [fs_type], 1
-        jz      @f
+        jz      ntfs_HdWrite
-        cmp     [fs_type], 32
+        cmp     [fs_type], 2
-        jz      @f
+        jz      ext2_HdWrite
+        push    ERROR_UNKNOWN_FS
+        jmp     .ret0
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_Write
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_Write - FAT16/32 implementation of writing to file
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
-        push    ERROR_UNKNOWN_FS
+; out: eax, ebx = return values for sysfunc 70
-        jmp     .ret0
+;----------------------------------------------------------------
-@@:
-        cmp     byte [esi], 0
+fat_Write:
-        jz      .access_denied
+        cmp     byte [esi], 0
-        pushad
+        jz      .access_denied
-        call    hd_find_lfn
-        pushfd
-        cmp     [hd_error], 0
-        jz      @f
-        popfd
-        popad
-        push    11
-        jmp     .ret0
+        call    fat_lock
-@@:
+        push    edi
-        popfd
+        stdcall hd_find_lfn, [esp+4+4]
+        jnc     .found
-        jnc     .found
+        pop     edi
-        popad
+        push    eax
-        push    ERROR_FILE_NOT_FOUND
+        call    fat_unlock
-        jmp     .ret0
-.found:
-; FAT does not support files larger than 4GB
+        jmp     fs_HdWrite.ret0
-        test    ebx, ebx
+.found:
-        jz      .l1
+; FAT does not support files larger than 4GB
-        cmp     dword [ebx+4], 0
+        cmp     dword [ebx+8], 0
         jz      @f
+.eof:
-.eof:
+        pop     edi
-        popad
+        push    ERROR_END_OF_FILE
-        push    ERROR_END_OF_FILE
+        call    fat_unlock
-        jmp     .ret0
+        jmp     fs_HdWrite.ret0
+@@:
-@@:
+        mov     ecx, [ebx+12]
-        mov     ebx, [ebx]
+        mov     edx, [ebx+16]
-.l1:
+        mov     ebx, [ebx+4]
 ; now edi points to direntry, ebx=start byte to write,
 ; ecx=number of bytes to write, edx=data pointer
 ; extend file if needed
-; extend file if needed
+        add     ecx, ebx
-        add     ecx, ebx
+        jc      .eof    ; FAT does not support files larger than 4GB
-        jc      .eof    ; FAT does not support files larger than 4GB
+        push    edx
         mov     [esp+4], eax
 ; hd_extend_file can return three error codes: FAT table error, device error or disk full.
 ; First two cases are fatal errors, in third case we may write some data
         cmp     al, ERROR_DISK_FULL
         jz      .disk_full
+        call    fat_unlock
         pop     eax
         pop     eax
-        mov     [esp+4+28], eax
+        pop     ecx
-        pop     eax
+        pop     edx
-        popad
+        pop     edi
         xor     ebx, ebx
         ret
 .disk_full:
 ; correct number of bytes to write
         mov     ecx, [edi+28]
         cmp     ecx, ebx
         ja      .length_ok
+        push    0
 .ret:
+        pop     eax
+        sub     edx, [esp+12]
+        mov     ebx, edx        ; ebx=number of written bytes
         call    update_disk
-        cmp     [hd_error], 0
+        test    eax, eax
         jz      @f
-        mov     byte [esp+4], 11
+        mov     byte [esp+4], ERROR_DEVICE
 @@:
+        call    fat_unlock
         pop     eax
         pop     eax
-        mov     [esp+4+28], eax ; eax=return value
-        pop     eax
+        pop     ecx
-        sub     edx, [esp+20]
+        pop     edx
-        mov     [esp+16], edx   ; ebx=number of written bytes
-        popad
+        pop     edi
         ret
 .length_ok:
         mov     esi, [edi+28]
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]
         mov     edi, eax        ; edi=current cluster
-        xor     ebp, ebp        ; ebp=current sector in cluster
+        push    0               ; current sector in cluster
 ; save directory
-        mov     eax, [esp+8]
+        mov     eax, [esp+12]
         push    ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         pop     ebx
-        cmp     [hd_error], 0
+        test    eax, eax
         jz      @f
 .device_err:
-        mov     byte [esp+4], 11
+        mov     byte [esp+8], ERROR_DEVICE
+        jmp     .ret
+.fat_err:
+        mov     byte [esp+8], ERROR_FAT_TABLE
         jmp     .ret
 @@:
 ; now ebx=start pos, ecx=end pos, both lie inside file
         sub     ecx, ebx
         jz      .ret
 .write_loop:
 ; skip unmodified sectors
-        cmp     dword [esp], 0x200
+        cmp     dword [esp+4], 0x200
         jb      .modify
         sub     ebx, 0x200
         jae     .skip
         add     ebx, 0x200
 @@:
 ; get current sector number
         mov     eax, edi
         dec     eax
         dec     eax
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
-        add     eax, ebp
+        add     eax, [esp+4]
 ; load sector if needed
-        cmp     dword [esp+4], 0        ; we don't need to read uninitialized data
+        cmp     dword [esp+8], 0        ; we don't need to read uninitialized data
         jz      .noread
         cmp     ecx, 0x200      ; we don't need to read sector if it is fully rewritten
         jz      .noread
         cmp     ecx, esi        ; (same for the last sector)
         jz      .noread
-        push    ebx
+        push    eax ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_app
-        pop     ebx
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     ebx eax
         jz      @f
 .device_err2:
         pop     ecx
         jmp     .device_err
 @@:
 .noread:
 ; zero uninitialized data if file was extended (because hd_extend_file does not this)
         push    eax ecx edi
         xor     eax, eax
         mov     ecx, 0x200
-        sub     ecx, [esp+4+12]
+        sub     ecx, [esp+8+12]
         jbe     @f
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer]
-        add     edi, [esp+4+12]
+        add     edi, [esp+8+12]
         rep stosb
 @@:
 ; zero uninitialized data in the last sector
         mov     ecx, 0x200
         sub     ecx, esi
         jbe     @f
-        mov     edi, buffer
+        lea     edi, [ebp+FAT.buffer+esi]
-        add     edi, esi
         rep stosb
 @@:
         pop     edi ecx
 ; copy new data
         mov     eax, edx
         neg     ebx
         jecxz   @f
-        add     ebx, buffer+0x200
+        lea     ebx, [ebp+FAT.buffer+0x200+ebx]
         call    memmove
         xor     ebx, ebx
 @@:
         pop     eax
 ; save sector
         push    ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_app
         pop     ebx
-        cmp     [hd_error], 0
+        test    eax, eax
         jnz     .device_err2
         add     edx, ecx
         sub     [esp], ecx
         pop     ecx
         jz      .ret
 .skip:
 ; next sector
+        pop     eax
-        inc     ebp
+        inc     eax
+        push    eax
-        cmp     ebp, [SECTORS_PER_CLUSTER]
+        cmp     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
         jb      @f
-        xor     ebp, ebp
+        and     dword [esp], 0
         mov     eax, edi
         call    get_FAT
         mov     edi, eax
+        jc      .device_err
-        cmp     [hd_error], 0
+        cmp     edi, 2
+        jb      .fat_err
+        cmp     edi, [ebp+FAT.fatRESERVED]
-        jnz     .device_err
+        jae     .fat_err
 @@:
         sub     esi, 0x200
         jae     @f
         xor     esi, esi
 @@:
-        sub     dword [esp], 0x200
+        sub     dword [esp+4], 0x200
         jae     @f
-        and     dword [esp], 0
+        and     dword [esp+4], 0
 @@:
         jmp     .write_loop
 hd_extend_file.zero_size:
         xor     eax, eax
         jmp     hd_extend_file.start_extend
 ; extends file on hd to given size (new data area is undefined)
 ; in: edi->direntry, ecx=new size
 ; out: CF=0 => OK, eax=0
-;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL or 11)
+;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL or ERROR_DEVICE)
 hd_extend_file:
-        push    ebp
+        push    esi
-        mov     ebp, [SECTORS_PER_CLUSTER]
+        mov     esi, [ebp+FAT.SECTORS_PER_CLUSTER]
-        imul    ebp, [BYTES_PER_SECTOR]
+        imul    esi, [ebp+FAT.BYTES_PER_SECTOR]
         push    ecx
 ; find the last cluster of file
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]
         mov     ecx, [edi+28]
         jecxz   .zero_size
 .last_loop:
-        sub     ecx, ebp
+        sub     ecx, esi
-        jbe     .last_found
-        call    get_FAT
+        jbe     .last_found
-        cmp     [hd_error], 0
+        call    get_FAT
-        jz      @f
+        jnc     @f
 .device_err:
         pop     ecx
 .device_err2:
-        pop     ebp
+        pop     esi
-        push    11
+        push    ERROR_DEVICE
 .ret_err:
         pop     eax
         stc
         ret
 @@:
         cmp     eax, 2
         jb      .fat_err
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         jb      .last_loop
 .fat_err:
-        pop     ecx ebp
+        pop     ecx esi
         push    ERROR_FAT_TABLE
         jmp     .ret_err
 .last_found:
-        push    eax
-        call    get_FAT
+        push    eax
-        cmp     [hd_error], 0
+        call    get_FAT
-        jz      @f
+        jnc     @f
         pop     eax
         jmp     .device_err
 @@:
-        cmp     eax, [fatRESERVED]
+        cmp     eax, [ebp+FAT.fatRESERVED]
         pop     eax
         jb      .fat_err
 ; set length to full number of clusters
         jae     .extend_done
 ; add new cluster
         push    eax
         call    get_free_FAT
         jc      .disk_full
-        mov     edx, [fatEND]
+        mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
         mov     edx, eax
         pop     eax
         test    eax, eax
         jz      .first_cluster
         push    ecx
         mov     ecx, -1
         call    add_disk_free_space
         pop     ecx
         mov     eax, edx
-        cmp     [hd_error], 0
-        jnz     .device_err3
-        add     [edi+28], ebp
+        add     [edi+28], esi
         jmp     .extend_loop
 .extend_done:
         mov     [edi+28], ecx
-        pop     edx ebp
+        pop     edx esi
         xor     eax, eax        ; CF=0
         ret
 .device_err3:
         pop     edx
         jmp     .device_err2
 .disk_full:
-        pop     eax edx ebp
+        pop     eax edx esi
         push    ERROR_DISK_FULL
         pop     eax
-        cmp     [hd_error], 0
-        jz      @f
-        mov     al, 11
-@@:
         stc
         ret
 ;----------------------------------------------------------------
+;
 ;  fs_HdSetFileEnd - set end of file on hard disk
+;
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
 ;  ebx  points to 64-bit number = new file size
 ;  ecx  ignored (reserved)
 ;  edx  ignored (reserved)
+;
 ;  ret eax = 0 ok or other = errormsg
+;
 ;--------------------------------------------------------------
-fs_HdSetFileEnd:
-        cmp     [fs_type], 1
-        jz      ntfs_HdSetFileEnd
-        cmp     [fs_type], 2
-        jz      ext2_HdSetFileEnd
+fs_HdSetFileEnd:
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
+        jz      @f
+        cmp     [fs_type], 1
+        jz      ntfs_HdSetFileEnd
+        cmp     [fs_type], 2
-        jz      @f
+        jz      ext2_HdSetFileEnd
-        push    ERROR_UNKNOWN_FS
-.ret:
+        push    ERROR_UNKNOWN_FS
         pop     eax
         ret
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_SetFileEnd
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_SetFileEnd - FAT16/32 implementation of setting end-of-file
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
+fat_SetFileEnd:
+        call    fat_lock
-@@:
+        push    edi
         cmp     byte [esi], 0
         jnz     @f
 .access_denied:
-        push    ERROR_ACCESS_DENIED
-        jmp     .ret
+        push    ERROR_ACCESS_DENIED
-@@:
-        push    edi
+.ret:
-        call    hd_find_lfn
-        pushfd
-        cmp     [hd_error], 0
+        call    fat_unlock
-        jz      @f
-        popfd
+        pop     eax
-        push    11
+        pop     edi
-        jmp     .ret
+        ret
 @@:
-        popfd
+        stdcall hd_find_lfn, [esp+4+4]
+        jnc     @f
-        jnc     @f
+.reteax:
-        pop     edi
-        push    ERROR_FILE_NOT_FOUND
+        push    eax
         jmp     .ret
 @@:
 ; must not be directory
-        test    byte [edi+11], 10h
-        jz      @f
-        pop     edi
+        test    byte [edi+11], 10h
-        jmp     .access_denied
-@@:
+        jnz     .access_denied
 ; file size must not exceed 4 Gb
-        cmp     dword [ebx+4], 0
+        cmp     dword [ebx+8], 0
-        jz      @f
-        pop     edi
+        jz      @f
         push    ERROR_END_OF_FILE
         jmp     .ret
 @@:
         push    eax     ; save directory sector
 ; set file modification date/time to current
         call    fat_update_datetime
-        mov     eax, [ebx]
+        mov     eax, [ebx+4]
         cmp     eax, [edi+28]
         jb      .truncate
         ja      .expand
         pop     eax
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         pop     edi
-        xor     eax, eax
-        cmp     [hd_error], 0
+        test    eax, eax
+        jz      @f
-        jz      @f
+        push    ERROR_DEVICE
-        mov     al, 11
+        jmp     .ret
+@@:
-@@:
+        push    0
-        ret
+        jmp     .ret
 .expand:
         push    ebx ebp ecx
         push    dword [edi+28]  ; save old size
         mov     ecx, eax
         jnc     .expand_ok
         cmp     al, ERROR_DISK_FULL
         jz      .disk_full
 .pop_ret:
         call    update_disk
-        pop     eax ecx ebp ebx ecx edi edi
+        pop     eax ecx ecx ebp ebx ecx
-        ret
+        jmp     .reteax
 .expand_ok:
 .disk_full:
 ; save directory
         mov     eax, [edi+28]
         xchg    eax, [esp+20]
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
+        test    eax, eax
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]
         mov     edi, eax
-        cmp     [hd_error], 0
         jz      @f
 .pop_ret11:
-        mov     byte [esp], 11
+        mov     byte [esp], ERROR_DEVICE
         jmp     .pop_ret
 @@:
+        test    edi, edi
+        jz      .pop_ret
 ; now zero new data
-        xor     ebp, ebp
+        push    0
-; edi=current cluster, ebp=sector in cluster
+; edi=current cluster, [esp]=sector in cluster
-; [esp+20]=new size, [esp+4]=old size, [esp]=return code
+; [esp+24]=new size, [esp+8]=old size, [esp+4]=return code
 .zero_loop:
+        cmp     edi, 2
+        jb      .error_fat
+        cmp     edi, [ebp+FAT.fatRESERVED]
+        jae     .error_fat
-        sub     dword [esp+4], 0x200
+        sub     dword [esp+8], 0x200
         jae     .next_cluster
         lea     eax, [edi-2]
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
-        add     eax, ebp
+        add     eax, [esp]
-        cmp     dword [esp+4], -0x200
+        cmp     dword [esp+8], -0x200
         jz      .noread
+        push    eax
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_app
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     eax
         jnz     .err_next
 .noread:
-        mov     ecx, [esp+4]
+        mov     ecx, [esp+8]
         neg     ecx
         push    edi
-        mov     edi, buffer+0x200
+        lea     edi, [ebp+FAT.buffer+0x200]
-        add     edi, [esp+8]
+        add     edi, [esp+12]
         push    eax
         xor     eax, eax
-        mov     [esp+12], eax
+        mov     [esp+16], eax
         rep stosb
         pop     eax
         pop     edi
-        call    hd_write
+        call    fs_write32_app
-        cmp     [hd_error], 0
+        test    eax, eax
         jz      .next_cluster
 .err_next:
-        mov     byte [esp], 11
+        mov     byte [esp+4], ERROR_DEVICE
 .next_cluster:
+        pop     eax
         sub     dword [esp+20], 0x200
         jbe     .pop_ret
-        inc     ebp
+        inc     eax
+        push    eax
-        cmp     ebp, [SECTORS_PER_CLUSTER]
+        cmp     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
         jb      .zero_loop
-        xor     ebp, ebp
+        and     dword [esp], 0
         mov     eax, edi
         call    get_FAT
         mov     edi, eax
-        cmp     [hd_error], 0
+        jnc     .zero_loop
-        jnz     .pop_ret11
+        pop     eax
-        jmp     .zero_loop
+        jmp     .pop_ret11
 .truncate:
         mov     [edi+28], eax
         push    ecx
         mov     ecx, [edi+20-2]
         mov     cx, [edi+26]
         push    eax
         test    eax, eax
         jz      .zero_size
 ; find new last cluster
 @@:
+        cmp     ecx, 2
+        jb      .error_fat2
+        cmp     ecx, [ebp+FAT.fatRESERVED]
+        jae     .error_fat2
-        mov     eax, [SECTORS_PER_CLUSTER]
+        mov     eax, [ebp+FAT.SECTORS_PER_CLUSTER]
         shl     eax, 9
         sub     [esp], eax
         jbe     @f
         mov     eax, ecx
         call    get_FAT
         mov     ecx, eax
-        cmp     [hd_error], 0
-        jz      @b
+        jnc     @b
 .device_err3:
         pop     eax ecx eax edi
+        call    update_disk
+        call    fat_unlock
-        push    11
+        push    ERROR_DEVICE
         pop     eax
         ret
 @@:
 ; we will zero data at the end of last sector - remember it
         push    ecx
 ; terminate FAT chain
         push    edx
         mov     eax, ecx
-        mov     edx, [fatEND]
+        mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
         mov     eax, edx
         pop     edx
-        cmp     [hd_error], 0
-        jz      @f
+        jnc     @f
 .device_err4:
         pop     ecx
         jmp     .device_err3
 .zero_size:
         and     word [edi+20], 0
         push    0
         mov     eax, ecx
 @@:
 ; delete FAT chain
         call    clear_cluster_chain
-        cmp     [hd_error], 0
-        jnz     .device_err4
+        jc      .device_err4
 ; save directory
         mov     eax, [esp+12]
         push    ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         pop     ebx
-        cmp     [hd_error], 0
+        test    eax, eax
         jnz     .device_err4
 ; zero last sector, ignore errors
         pop     ecx
         pop     eax
         dec     ecx
-        imul    ecx, [SECTORS_PER_CLUSTER]
+        imul    ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     ecx, [DATA_START]
+        add     ecx, [ebp+FAT.DATA_START]
         push    eax
         sar     eax, 9
         add     ecx, eax
         pop     eax
         and     eax, 0x1FF
         jz      .truncate_done
         push    ebx eax
         mov     eax, ecx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_app
         pop     eax
-        lea     edi, [buffer+eax]
+        lea     edi, [ebp+FAT.buffer+eax]
         push    ecx
         mov     ecx, 0x200
         sub     ecx, eax
         xor     eax, eax
         rep stosb
         pop     eax
-        call    hd_write
+        call    fs_write32_app
         pop     ebx
 .truncate_done:
         pop     ecx eax edi
         call    update_disk
+        call    fat_unlock
         xor     eax, eax
-        cmp     [hd_error], 0
+        ret
+.error_fat:
-        jz      @f
+        pop     eax
+        mov     byte [esp], ERROR_FAT_TABLE
-        mov     al, 11
+        jmp     .pop_ret
-@@:
+.error_fat2:
+        pop     eax ecx eax edi
+        call    update_disk
+        call    fat_unlock
+        push    ERROR_FAT_TABLE
+        pop     eax
         ret
-fs_HdGetFileInfo:
-        cmp     [fs_type], 1
-        jz      ntfs_HdGetFileInfo
-        cmp     [fs_type], 2
-        jz      ext2_HdGetFileInfo
+fs_HdGetFileInfo:
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
+        jz      @f
+        cmp     [fs_type], 1
+        jz      ntfs_HdGetFileInfo
+        cmp     [fs_type], 2
-        jz      @f
+        jz      ext2_HdGetFileInfo
         mov     eax, ERROR_UNKNOWN_FS
         ret
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_GetFileInfo
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_GetFileInfo - FAT16/32 implementation of getting file info
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
+;----------------------------------------------------------------
-@@:
+fat_GetFileInfo:
         cmp     byte [esi], 0
         jnz     @f
         mov     eax, 2
         ret
 @@:
         push    edi
+        call    fat_lock
+        stdcall hd_find_lfn, [esp+4+4]
-        call    hd_find_lfn
+        jc      .error
+        push    ebp
+        xor     ebp, ebp
+        mov     esi, [ebx+16]
+        mov     dword [esi+4], ebp
+        call    fat_entry_to_bdfe2
-        pushfd
+        pop     ebp
+        call    fat_unlock
-        cmp     [hd_error], 0
+        xor     eax, eax
-        jz      @f
+        pop     edi
+        ret
+.error:
+        push    eax
+        call    fat_unlock
-        popfd
+        pop     eax
-        pop     edi
-        mov     eax, 11
+        pop     edi
-        ret
-@@:
-        popfd
-        jmp     fs_GetFileInfo_finish
+        ret
-fs_HdSetFileInfo:
-        cmp     [fs_type], 1
-        jz      ntfs_HdSetFileInfo
         cmp     [fs_type], 2
-        jz      ext2_HdSetFileInfo
+fs_HdSetFileInfo:
         cmp     [fs_type], 16
         jz      @f
+        cmp     [fs_type], 32
+        jz      @f
+        cmp     [fs_type], 1
+        jz      ntfs_HdSetFileInfo
-        cmp     [fs_type], 32
+        cmp     [fs_type], 2
-        jz      @f
+        jz      ext2_HdSetFileInfo
         mov     eax, ERROR_UNKNOWN_FS
+        ret
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_SetFileInfo
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_SetFileInfo - FAT16/32 implementation of setting file info
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
-        ret
+;----------------------------------------------------------------
-@@:
+fat_SetFileInfo:
         cmp     byte [esi], 0
         jnz     @f
         mov     eax, 2
         ret
 @@:
-        push    edi
-        call    hd_find_lfn
+        push    edi
-        pushfd
+        call    fat_lock
-        cmp     [hd_error], 0
-        jz      @f
-        popfd
-        pop     edi
-        mov     eax, 11
-        ret
-@@:
-        popfd
-        jnc     @f
-        pop     edi
-        mov     eax, ERROR_FILE_NOT_FOUND
-        ret
+        stdcall hd_find_lfn, [esp+4+4]
+        jc      .error
-@@:
+        push    eax
-        push    eax
+        mov     edx, [ebx+16]
         call    bdfe_to_fat_entry
         pop     eax
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
+        call    fs_write32_sys
-        call    hd_write
+        call    update_disk
-        call    update_disk
+        call    fat_unlock
         pop     edi
+        xor     eax, eax
+        ret
+.error:
+        push    eax
+        call    fat_unlock
+        pop     eax
-        xor     eax, eax
+        pop     edi
         ret
 ;----------------------------------------------------------------
+;
+;  fs_HdDelete - delete file or empty folder from hard disk
+;
-;  fs_HdDelete - delete file or empty folder from hard disk
+;  Obsolete, will be replaced with filesystem-specific functions.
+;
 ;  esi  points to filename
+;
 ;  ret  eax = 0 ok or other = errormsg
-;
-;--------------------------------------------------------------
-fs_HdDelete:
-        cmp     [fs_type], 1
         jz      ntfs_HdDelete
-        cmp     [fs_type], 2
+;--------------------------------------------------------------
-        jz      ext2_HdDelete
+fs_HdDelete:
         cmp     [fs_type], 16
+        jz      @f
+        cmp     [fs_type], 32
+        jz      @f
+        cmp     [fs_type], 1
-        jz      @f
+        jz      ntfs_HdDelete
-        cmp     [fs_type], 32
-        jz      @f
+        cmp     [fs_type], 2
-        push    ERROR_UNKNOWN_FS
+        jz      ext2_HdDelete
-.pop_ret:
+        push    ERROR_UNKNOWN_FS
+        pop     eax
+        ret
+@@:
+        sub     ebx, 4
+        push    ebp
+        mov     ebp, [fs_dependent_data_start.partition]
+        call    fat_Delete
+        pop     ebp
+        ret
+;----------------------------------------------------------------
+; fat_Delete - FAT16/32 implementation of deleting a file/folder
+; in:  ebp = pointer to FAT structure
+; in:  esi+[esp+4] = name
+; in:  ebx = pointer to parameters from sysfunc 70
+; out: eax, ebx = return values for sysfunc 70
-        pop     eax
+;----------------------------------------------------------------
-        ret
+fat_Delete:
-@@:
+        call    fat_lock
         cmp     byte [esi], 0
         jnz     @f
+; cannot delete root!
+.access_denied:
+        push    ERROR_ACCESS_DENIED
-; cannot delete root!
+.pop_ret:
+        call    fat_unlock
-.access_denied:
+        pop     eax
-        push    ERROR_ACCESS_DENIED
+        xor     ebx, ebx
-        jmp     .pop_ret
+        ret
 @@:
-        and     [longname_sec1], 0
+        and     [ebp+FAT.longname_sec1], 0
-        and     [longname_sec2], 0
+        and     [ebp+FAT.longname_sec2], 0
         push    edi
-        call    hd_find_lfn
+        stdcall hd_find_lfn, [esp+4+4]
         jnc     .found
         pop     edi
         jz      .access_denied2
         test    byte [edi+11], 10h
         jz      .dodel
 ; we can delete only empty folders!
         pushad
-        mov     ebp, [edi+20-2]
+        mov     esi, [edi+20-2]
-        mov     bp, [edi+26]
+        mov     si, [edi+26]
         xor     ecx, ecx
-        lea     eax, [ebp-2]
+        lea     eax, [esi-2]
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_sys
-        cmp     [hd_error], 0
+        test    eax, eax
         jnz     .err1
+        lea     eax, [ebx+0x200]
         add     ebx, 2*0x20
 .checkempty:
         cmp     byte [ebx], 0
         jz      .empty
         cmp     byte [ebx], 0xE5
         jnz     .notempty
         add     ebx, 0x20
-        cmp     ebx, buffer+0x200
+        cmp     ebx, eax
         jb      .checkempty
         inc     ecx
-        cmp     ecx, [SECTORS_PER_CLUSTER]
+        cmp     ecx, [ebp+FAT.SECTORS_PER_CLUSTER]
         jb      @f
-        mov     eax, ebp
+        mov     eax, esi
         call    get_FAT
-        cmp     [hd_error], 0
-        jnz     .err1
+        jc      .err1
-        mov     ebp, eax
+        mov     esi, eax
         xor     ecx, ecx
 @@:
-        lea     eax, [ebp-2]
+        lea     eax, [esi-2]
-        imul    eax, [SECTORS_PER_CLUSTER]
+        imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
-        add     eax, [DATA_START]
+        add     eax, [ebp+FAT.DATA_START]
         add     eax, ecx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_sys
+        test    eax, eax
-        cmp     [hd_error], 0
+        lea     eax, [ebx+0x200]
         jz      .checkempty
 .err1:
         popad
 .err2:
         pop     edi
+        call    fat_unlock
-        push    11
+        push    ERROR_DEVICE
         pop     eax
         ret
 .notempty:
         popad
 .access_denied2:
         pop     edi
+        call    fat_unlock
         push    ERROR_ACCESS_DENIED
         pop     eax
         ret
 .empty:
         popad
-        push    ebx
+        push    eax ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_read
+        call    fs_read32_sys
-        pop     ebx
+        test    eax, eax
-        cmp     [hd_error], 0
+        pop     ebx eax
         jnz     .err2
 .dodel:
         push    eax
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]
         xchg    eax, [esp]
 ; delete folder entry
         mov     byte [edi], 0xE5
 ; delete LFN (if present)
 .lfndel:
+        lea     edx, [ebp+FAT.buffer]
-        cmp     edi, buffer
+        cmp     edi, edx
         ja      @f
-        cmp     [longname_sec2], 0
+        cmp     [ebp+FAT.longname_sec2], 0
         jz      .lfndone
-        push    [longname_sec2]
+        push    [ebp+FAT.longname_sec2]
-        push    [longname_sec1]
+        push    [ebp+FAT.longname_sec1]
-        pop     [longname_sec2]
+        pop     [ebp+FAT.longname_sec2]
-        and     [longname_sec1], 0
+        and     [ebp+FAT.longname_sec1], 0
         push    ebx
-        mov     ebx, buffer
+        mov     ebx, edx
-        call    hd_write
+        call    fs_write32_sys
         mov     eax, [esp+4]
-        call    hd_read
+        call    fs_read32_sys
         pop     ebx
         pop     eax
-        mov     edi, buffer+0x200
+        lea     edi, [ebp+FAT.buffer+0x200]
 @@:
         sub     edi, 0x20
         cmp     byte [edi], 0xE5
         jz      .lfndone
         cmp     byte [edi+11], 0xF
         jnz     .lfndone
         mov     byte [edi], 0xE5
         jmp     .lfndel
 .lfndone:
         push    ebx
-        mov     ebx, buffer
+        lea     ebx, [ebp+FAT.buffer]
-        call    hd_write
+        call    fs_write32_sys
         pop     ebx
 ; delete FAT chain
         pop     eax
         call    clear_cluster_chain
         call    update_disk
+        call    fat_unlock
         pop     edi
         xor     eax, eax
-        cmp     [hd_error], 0
-        jz      @f
-        mov     al, 11
-@@:
         ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fat32.inc – Rev 2455 → 2643