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

 ;;  20.5.2002  Hd status check - VT                                ;;
 ;;  29.6.2002  Improved fat32 verification - VT                    ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 2130 $
+$Revision: 2434 $
 fat_in_cache         dd -1
 endg
 uglobal
+align 4
-align 4
+fat_cache:
-fat_cache:           times 512 db 0
+                     times 512 db 0
+ Sector512:                      ; label for dev_hdcd.inc
- Sector512:                      ; label for dev_hdcd.inc
+  buffer:
+                       times 512 db 0
-  buffer:              times 512 db 0
+  fsinfo_buffer:
-  fsinfo_buffer:       times 512 db 0
+                       times 512 db 0
 endg
 uglobal
   fat16_root           db 0       ; flag for fat16 rootdir
   fat_change           db 0       ; 1=fat has changed
 endg
 reserve_hd1:
-    cli
+        cli
-    cmp   [hd1_status],0
+        cmp     [hd1_status], 0
-    je    reserve_ok1
+        je      reserve_ok1
-    sti
+        sti
-    call  change_task
+        call    change_task
-    jmp   reserve_hd1
+        jmp     reserve_hd1
   reserve_ok1:
-    push  eax
+        push    eax
-    mov   eax,[CURRENT_TASK]
+        mov     eax, [CURRENT_TASK]
-    shl   eax,5
+        shl     eax, 5
-    mov   eax,[eax+CURRENT_TASK+TASKDATA.pid]
+        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
-    mov   [hd1_status],eax
+        mov     [hd1_status], eax
-    pop   eax
+        pop     eax
 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
-    cmp   [hdbase], 0x1F0
+        cmp     [hdbase], 0x1F0
-    jne   .IDE_Channel_2
+        jne     .IDE_Channel_2
 .IDE_Channel_1:
-    cli
+        cli
-    cmp   [IDE_Channel_1],0
+        cmp     [IDE_Channel_1], 0
-    je    .reserve_ok_1
+        je      .reserve_ok_1
-    sti
+        sti
-    call  change_task
+        call    change_task
-    jmp   .IDE_Channel_1
+        jmp     .IDE_Channel_1
 .IDE_Channel_2:
-    cli
+        cli
-    cmp   [IDE_Channel_2],0
+        cmp     [IDE_Channel_2], 0
-    je    .reserve_ok_2
+        je      .reserve_ok_2
-    sti
+        sti
-    call  change_task
+        call    change_task
-    jmp   .IDE_Channel_2
+        jmp     .IDE_Channel_2
 .reserve_ok_1:
         mov     [IDE_Channel_1], 1
         push    eax
         mov     al, 1
         jmp     @f
         cmp     al, [hd_in_cache]
         jz      @f
         mov     [hd_in_cache], al
         call    clear_hd_cache
 @@:
-	pop     eax
+        pop     eax
-	sti
+        sti
 .ret:
         ret
 free_hd_channel:
 ; see comment at reserve_hd_channel
         cmp     [hdpos], 0x80
         jae     .ret
-    cmp   [hdbase], 0x1F0
+        cmp     [hdbase], 0x1F0
-    jne   .IDE_Channel_2
+        jne     .IDE_Channel_2
 .IDE_Channel_1:
-    mov [IDE_Channel_1],0
+        mov     [IDE_Channel_1], 0
 .ret:
-    ret
+        ret
 .IDE_Channel_2:
-    mov [IDE_Channel_2],0
+        mov     [IDE_Channel_2], 0
-    ret
+        ret
 ;********************************************
 problem_partition db 0  ; used for partitions search
 ;--------------------------------
 ; input  : EAX = cluster
 ;          EDX = value to save
 ; output : EDX = old value
 ;--------------------------------
-    push  eax ebx esi
+        push    eax ebx esi
-    cmp   eax,2
+        cmp     eax, 2
-    jb    sfc_error
+        jb      sfc_error
-    cmp   eax,[LAST_CLUSTER]
+        cmp     eax, [LAST_CLUSTER]
-    ja    sfc_error
+        ja      sfc_error
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    je    sfc_1
+        je      sfc_1
-    add   eax,eax
+        add     eax, eax
   sfc_1:
-    add   eax,eax
+        add     eax, eax
-    mov   esi,511
+        mov     esi, 511
-    and   esi,eax               ; esi = position in fat sector
+        and     esi, eax        ; esi = position in fat sector
-    shr   eax,9                 ; eax = fat sector
+        shr     eax, 9          ; eax = fat sector
-    add   eax,[FAT_START]
+        add     eax, [FAT_START]
-    mov   ebx,fat_cache
+        mov     ebx, fat_cache
-    cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
+        cmp     eax, [fat_in_cache]; is fat sector already in memory?
-    je    sfc_in_cache          ; yes
+        je      sfc_in_cache    ; yes
-    cmp   [fat_change],0        ; is fat changed?
+        cmp     [fat_change], 0 ; is fat changed?
-    je    sfc_no_change         ; no
+        je      sfc_no_change   ; no
-    call  write_fat_sector      ; yes. write it into disk
+        call    write_fat_sector; yes. write it into disk
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   sfc_error
+        jne     sfc_error
   sfc_no_change:
-    mov   [fat_in_cache],eax    ; save fat sector
+        mov     [fat_in_cache], eax; save fat sector
-    call  hd_read
+        call    hd_read
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  sfc_error
+        jne     sfc_error
   sfc_in_cache:
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    jne   sfc_test32
+        jne     sfc_test32
   sfc_set16:
-    xchg  [ebx+esi],dx          ; save new value and get old value
+        xchg    [ebx+esi], dx   ; save new value and get old value
-    jmp   sfc_write
+        jmp     sfc_write
   sfc_test32:
-    mov   eax,[fatMASK]
+        mov     eax, [fatMASK]
   sfc_set32:
-    and   edx,eax
+        and     edx, eax
-    xor   eax,-1                ; mask for high bits
+        xor     eax, -1         ; mask for high bits
-    and   eax,[ebx+esi]         ; get high 4 bits
+        and     eax, [ebx+esi]  ; get high 4 bits
-    or    eax,edx
+        or      eax, edx
-    mov   edx,[ebx+esi]         ; get old value
+        mov     edx, [ebx+esi]  ; get old value
-    mov   [ebx+esi],eax         ; save new value
+        mov     [ebx+esi], eax  ; save new value
   sfc_write:
-    mov   [fat_change],1        ; fat has changed
+        mov     [fat_change], 1 ; fat has changed
   sfc_nonzero:
-    and   edx,[fatMASK]
+        and     edx, [fatMASK]
   sfc_error:
-    pop   esi ebx eax
+        pop     esi ebx eax
-    ret
+        ret
 get_FAT:
 ;--------------------------------
 ; input  : EAX = cluster
 ; output : EAX = next cluster
 ;--------------------------------
-    push  ebx esi
+        push    ebx esi
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    je    gfc_1
+        je      gfc_1
-    add   eax,eax
+        add     eax, eax
   gfc_1:
-    add   eax,eax
+        add     eax, eax
-    mov   esi,511
+        mov     esi, 511
-    and   esi,eax               ; esi = position in fat sector
+        and     esi, eax        ; esi = position in fat sector
-    shr   eax,9                 ; eax = fat sector
+        shr     eax, 9          ; eax = fat sector
-    add   eax,[FAT_START]
+        add     eax, [FAT_START]
-    mov   ebx,fat_cache
+        mov     ebx, fat_cache
-    cmp   eax,[fat_in_cache]    ; is fat sector already in memory?
+        cmp     eax, [fat_in_cache]; is fat sector already in memory?
-    je    gfc_in_cache
+        je      gfc_in_cache
-    cmp   [fat_change],0        ; is fat changed?
+        cmp     [fat_change], 0 ; is fat changed?
-    je    gfc_no_change         ; no
+        je      gfc_no_change   ; no
-    call  write_fat_sector      ; yes. write it into disk
+        call    write_fat_sector; yes. write it into disk
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  hd_error_01
+        jne     hd_error_01
   gfc_no_change:
-    mov   [fat_in_cache],eax
+        mov     [fat_in_cache], eax
-    call  hd_read
+        call    hd_read
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  hd_error_01
+        jne     hd_error_01
   gfc_in_cache:
-    mov   eax,[ebx+esi]
+        mov     eax, [ebx+esi]
-    and   eax,[fatMASK]
+        and     eax, [fatMASK]
  hd_error_01:
-    pop   esi ebx
+        pop     esi ebx
-    ret
+        ret
 get_free_FAT:
 ;-----------------------------------------------------------
 ; output : if CARRY=0 EAX = # first cluster found free
 ;          if CARRY=1 disk full
 ; Note   : for more speed need to use fat_cache directly
 ;-----------------------------------------------------------
-    push  ecx
+        push    ecx
-    mov   ecx,[LAST_CLUSTER]    ; counter for full disk
+        mov     ecx, [LAST_CLUSTER]; counter for full disk
-    sub   ecx,2
+        sub     ecx, 2
-    mov   eax,[fatStartScan]
+        mov     eax, [fatStartScan]
-    cmp   eax,2
+        cmp     eax, 2
-    jb    gff_reset
+        jb      gff_reset
   gff_test:
-    cmp   eax,[LAST_CLUSTER]    ; if above last cluster start at cluster 2
+        cmp     eax, [LAST_CLUSTER]; if above last cluster start at cluster 2
-    jbe   gff_in_range
+        jbe     gff_in_range
   gff_reset:
-    mov   eax,2
+        mov     eax, 2
   gff_in_range:
-    push  eax
+        push    eax
-    call  get_FAT               ; get cluster state
+        call    get_FAT         ; get cluster state
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   gff_not_found_1
+        jne     gff_not_found_1
-    test  eax,eax               ; is it free?
+        test    eax, eax        ; is it free?
-    pop   eax
+        pop     eax
-    je    gff_found             ; yes
+        je      gff_found       ; yes
-    inc   eax                   ; next cluster
+        inc     eax             ; next cluster
-    dec   ecx                   ; is all checked?
+        dec     ecx             ; is all checked?
-    jns   gff_test              ; no
+        jns     gff_test        ; no
   gff_not_found_1:
-    add   esp,4
+        add     esp, 4
   gff_not_found:
-    pop   ecx                   ; yes. disk is full
+        pop     ecx             ; yes. disk is full
-    stc
+        stc
-    ret
+        ret
   gff_found:
-    lea   ecx,[eax+1]
+        lea     ecx, [eax+1]
-    mov   [fatStartScan],ecx
+        mov     [fatStartScan], ecx
-    pop   ecx
+        pop     ecx
-    clc
+        clc
-    ret
+        ret
 write_fat_sector:
 ;-----------------------------------------------------------
 ;                     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]
+        push    ecx edx esi edi ebx; ebx = [esp+0]
-    mov   [longname_sec1],0
+        mov     [longname_sec1], 0
-    mov   [longname_sec2],0
+        mov     [longname_sec2], 0
   adr_new_cluster:
-    mov   [cluster_tmp],eax
+        mov     [cluster_tmp], eax
-    mov   [fat16_root],0
+        mov     [fat16_root], 0
-    cmp   eax,[LAST_CLUSTER]
+        cmp     eax, [LAST_CLUSTER]
-    ja    adr_not_found         ; too big cluster number, something is wrong
+        ja      adr_not_found   ; too big cluster number, something is wrong
-    cmp   eax,2
+        cmp     eax, 2
-    jnb   adr_data_cluster
+        jnb     adr_data_cluster
-    mov   eax,[ROOT_CLUSTER]    ; if cluster < 2 then read rootdir
+        mov     eax, [ROOT_CLUSTER]; if cluster < 2 then read rootdir
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    jne   adr_data_cluster
+        jne     adr_data_cluster
-    mov   eax,[ROOT_START]
+        mov     eax, [ROOT_START]
-    mov   edx,[ROOT_SECTORS]
+        mov     edx, [ROOT_SECTORS]
-    mov   [fat16_root],1        ; flag for fat16 rootdir
+        mov     [fat16_root], 1 ; flag for fat16 rootdir
-    jmp   adr_new_sector
+        jmp     adr_new_sector
   adr_data_cluster:
-    sub   eax,2
+        sub     eax, 2
-    mov   edx,[SECTORS_PER_CLUSTER]
+        mov     edx, [SECTORS_PER_CLUSTER]
-    imul  eax,edx
+        imul    eax, edx
-    add   eax,[DATA_START]
+        add     eax, [DATA_START]
   adr_new_sector:
-    mov   ebx,buffer
+        mov     ebx, buffer
-    call  hd_read
+        call    hd_read
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  adr_not_found
+        jne     adr_not_found
-    mov   ecx,512/32            ; count of dir entrys per sector = 16
+        mov     ecx, 512/32     ; count of dir entrys per sector = 16
   adr_analyze:
-    mov   edi,[ebx+11]          ; file attribute
+        mov     edi, [ebx+11]   ; file attribute
-    and   edi,0xf
+        and     edi, 0xf
-    cmp   edi,0xf
+        cmp     edi, 0xf
-    je    adr_long_filename
+        je      adr_long_filename
-    test  edi,0x8               ; skip over volume label
+        test    edi, 0x8        ; skip over volume label
-    jne   adr_long_filename     ; Note: label can be same name as file/dir
+        jne     adr_long_filename; Note: label can be same name as file/dir
-    mov   esi,[esp+0]           ; filename need to be uppercase
+        mov     esi, [esp+0]    ; filename need to be uppercase
-    mov   edi,ebx
+        mov     edi, ebx
-    push  ecx
+        push    ecx
-    mov   ecx,11
+        mov     ecx, 11
-    cld
+        cld
-    rep   cmpsb                 ; compare 8+3 filename
+        rep cmpsb               ; compare 8+3 filename
-    pop   ecx
+        pop     ecx
-    je    adr_found
+        je      adr_found
   adr_long_filename:
-    add   ebx,32                ; position of next dir entry
+        add     ebx, 32         ; position of next dir entry
-    dec   ecx
+        dec     ecx
-    jnz   adr_analyze
+        jnz     adr_analyze
-    mov   ecx,[longname_sec1]   ; save 2 previous directory sectors
+        mov     ecx, [longname_sec1]; save 2 previous directory sectors
-    mov   [longname_sec1],eax   ; for delete long filename
+        mov     [longname_sec1], eax; for delete long filename
-    mov   [longname_sec2],ecx
+        mov     [longname_sec2], ecx
-    inc   eax                   ; next sector
+        inc     eax             ; next sector
-    dec   edx
+        dec     edx
-    jne   adr_new_sector
+        jne     adr_new_sector
-    cmp   [fat16_root],1        ; end of fat16 rootdir
+        cmp     [fat16_root], 1 ; end of fat16 rootdir
-    je    adr_not_found
+        je      adr_not_found
   adr_next_cluster:
-    mov   eax,[cluster_tmp]
+        mov     eax, [cluster_tmp]
-    call  get_FAT               ; get next cluster
+        call    get_FAT         ; get next cluster
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  adr_not_found
+        jne     adr_not_found
-    cmp   eax,2                 ; incorrect fat chain?
+        cmp     eax, 2          ; incorrect fat chain?
-    jb    adr_not_found         ; yes
+        jb      adr_not_found   ; yes
-    cmp   eax,[fatRESERVED]     ; is it end of directory?
+        cmp     eax, [fatRESERVED]; is it end of directory?
-    jb    adr_new_cluster       ; no. analyse it
+        jb      adr_new_cluster ; no. analyse it
   adr_not_found:
-    pop   edi edi esi edx ecx   ; first edi will remove ebx
+        pop     edi edi esi edx ecx; first edi will remove ebx
-    stc                         ; file not found
+        stc                     ; file not found
 ;          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
+        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   [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
+        mov     eax, [ROOT_CLUSTER]; if cluster < 2 then read rootdir
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    jne   gdc_cluster
+        jne     gdc_cluster
-    mov   eax,[ROOT_START]
+        mov     eax, [ROOT_START]
-    mov   ecx,[ROOT_SECTORS]    ; Note: not cluster size
+        mov     ecx, [ROOT_SECTORS]; Note: not cluster size
-    mov   [fat16_root],1        ; flag for fat16 rootdir
+        mov     [fat16_root], 1 ; flag for fat16 rootdir
-    jmp   gdc_read
+        jmp     gdc_read
   gdc_cluster:
-    sub   eax,2
+        sub     eax, 2
-    mov   ecx,[SECTORS_PER_CLUSTER]
+        mov     ecx, [SECTORS_PER_CLUSTER]
-    imul  eax,ecx
+        imul    eax, ecx
-    add   eax,[DATA_START]
+        add     eax, [DATA_START]
   gdc_read:
-    test  esi,esi               ; first wanted block
+        test    esi, esi        ; first wanted block
-    je    gdcl1                 ; yes, skip count is 0
+        je      gdcl1           ; yes, skip count is 0
-    dec   esi
+        dec     esi
-    jmp   gdcl2
+        jmp     gdcl2
   gdcl1:
-    call  hd_read
+        call    hd_read
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  gdc_error
+        jne     gdc_error
-    add   ebx,512               ; update pointer
+        add     ebx, 512        ; update pointer
-    dec   edx
+        dec     edx
   gdcl2:
-    test  edx,edx               ; is all read?
+        test    edx, edx        ; is all read?
-    je    out_of_read
+        je      out_of_read
-    inc   eax                   ; next sector
+        inc     eax             ; next sector
-    dec   ecx
+        dec     ecx
-    jnz   gdc_read
+        jnz     gdc_read
   out_of_read:
-    pop   ecx eax
+        pop     ecx eax
-    clc
+        clc
 ;          '.' = space char
 ;          '0' = char(0) (ASCII=0) !!! )
 ; output : if (CARRY=1) -> ERROR in the PATH
 ;          if (CARRY=0) -> EAX=cluster
 ;---------------------------------------------------------
-    push  ebx edx
+        push    ebx edx
-    mov   eax,[ROOT_CLUSTER]
+        mov     eax, [ROOT_CLUSTER]
-    mov   edx,ebx
+        mov     edx, ebx
 search_end_of_path:
-    cmp   byte [edx],0
+        cmp     byte [edx], 0
-    je    found_end_of_path
+        je      found_end_of_path
-    inc   edx ; '/'
+        inc     edx; '/'
-    mov   ebx,edx
+        mov     ebx, edx
-    call  analyze_directory
+        call    analyze_directory
-    jc    directory_not_found
+        jc      directory_not_found
-    mov   eax,[ebx+20-2]        ; read the HIGH 16bit cluster field
+        mov     eax, [ebx+20-2] ; read the HIGH 16bit cluster field
-    mov   ax,[ebx+26]           ; read the LOW 16bit cluster field
+        mov     ax, [ebx+26]    ; read the LOW 16bit cluster field
-    and   eax,[fatMASK]
+        and     eax, [fatMASK]
-    add   edx,11                ; 8+3 (name+extension)
+        add     edx, 11         ; 8+3 (name+extension)
-    jmp   search_end_of_path
+        jmp     search_end_of_path
 found_end_of_path:
-    pop   edx ebx
+        pop     edx ebx
-    clc                         ; no errors
+        clc                     ; no errors
-    ret
+        ret
 directory_not_found:
-    pop   edx ebx
+        pop     edx ebx
-    stc                         ; errors occour
+        stc                     ; errors occour
-    ret
+        ret
 bcd2bin:
 ;----------------------------------
 ; input  : AL=BCD number (eg. 0x11)
 ; output : AH=0
 ;          AL=decimal number (eg. 11)
 ;----------------------------------
-    xor   ah,ah
+        xor     ah, ah
-    shl   ax,4
+        shl     ax, 4
-    shr   al,4
+        shr     al, 4
-    aad
+        aad
-    ret
+        ret
 get_date_for_file:
 ;-----------------------------------------------------
 ; Get date from CMOS and pack day,month,year in AX
 ; DATE   bits  0..4   : day of month 0..31
 ;              5..8   : month of year 1..12
 ;              9..15  : count of years from 1980
 ;-----------------------------------------------------
-    mov   al,0x7        ;day
+        mov     al, 0x7 ;day
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    ror   eax,5
+        ror     eax, 5
-    mov   al,0x8        ;month
+        mov     al, 0x8 ;month
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    ror   eax,4
+        ror     eax, 4
-    mov   al,0x9        ;year
+        mov     al, 0x9 ;year
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    add   ax,20         ;because CMOS return only the two last
+        add     ax, 20  ;because CMOS return only the two last
                         ;digit (eg. 2000 -> 00 , 2001 -> 01) and we
-    rol   eax,9         ;need the difference with 1980 (eg. 2001-1980)
+        rol     eax, 9  ;need the difference with 1980 (eg. 2001-1980)
-    ret
+        ret
 get_time_for_file:
 ;-----------------------------------------------------
 ; Get time from CMOS and pack hour,minute,second in AX
 ; TIME   bits  0..4   : second (the low bit is lost)
 ;              5..10  : minute 0..59
 ;              11..15 : hour 0..23
 ;-----------------------------------------------------
-    mov   al,0x0        ;second
+        mov     al, 0x0 ;second
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    ror   eax,6
+        ror     eax, 6
-    mov   al,0x2        ;minute
+        mov     al, 0x2 ;minute
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    ror   eax,6
+        ror     eax, 6
-    mov   al,0x4        ;hour
+        mov     al, 0x4 ;hour
-    out   0x70,al
+        out     0x70, al
-    in    al,0x71
+        in      al, 0x71
-    call  bcd2bin
+        call    bcd2bin
-    rol   eax,11
+        rol     eax, 11
-    ret
+        ret
 set_current_time_for_entry:
 ;-----------------------------------------------------
 ; Set current time/date for file entry
 ; input  : ebx = file entry pointer
 ;-----------------------------------------------------
-    push  eax
+        push    eax
-    call  get_time_for_file     ; update files date/time
+        call    get_time_for_file; update files date/time
-    mov   [ebx+22],ax
+        mov     [ebx+22], ax
-    call  get_date_for_file
+        call    get_date_for_file
-    mov   [ebx+24],ax
+        mov     [ebx+24], ax
-    pop   eax
+        pop     eax
-    ret
+        ret
 add_disk_free_space:
 ;-----------------------------------------------------
 ; input  : ecx = cluster count
 ; Note   : negative = remove clusters from free space
 ;          positive = add clusters to free space
 ;-----------------------------------------------------
-    test  ecx,ecx               ; no change
+        test    ecx, ecx        ; no change
-    je    add_dfs_no
+        je      add_dfs_no
-    cmp   [fs_type],32         ; free disk space only used by fat32
+        cmp     [fs_type], 32  ; free disk space only used by fat32
-    jne   add_dfs_no
+        jne     add_dfs_no
-    push  eax ebx
+        push    eax ebx
-    mov   eax,[ADR_FSINFO]
+        mov     eax, [ADR_FSINFO]
-    mov   ebx,fsinfo_buffer
+        mov     ebx, fsinfo_buffer
-    call  hd_read
+        call    hd_read
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  add_not_fs
+        jne     add_not_fs
 ;--------------------------------------------------------------------------
         cmp     [fs_type], 16
         jz      fat_ok_for_reading
         cmp     [fs_type], 32
         jz      fat_ok_for_reading
-    xor   ebx,ebx
+        xor     ebx, ebx
-    mov   eax,ERROR_UNKNOWN_FS
+        mov     eax, ERROR_UNKNOWN_FS
-    mov   [hd1_status], ebx
+        mov     [hd1_status], ebx
-    ret
+        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
-    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
+        cmp     [hd_error], 0
-    jne   file_access_denied
+        jne     file_access_denied
-    mov   [file_size],eax
+        mov     [file_size], eax
-    mov   eax,[ROOT_CLUSTER]
+        mov     eax, [ROOT_CLUSTER]
-    jmp   file_read_start
+        jmp     file_read_start
   no_read_root:
-    mov   ebx,PUSHAD_EAX        ; file name
+        mov     ebx, PUSHAD_EAX ; file name
-    call  analyze_directory
+        call    analyze_directory
-    jc    file_to_read_not_found
+        jc      file_to_read_not_found
-    mov   eax,[ebx+28]          ; file size
+        mov     eax, [ebx+28]   ; file size
-    test  byte [ebx+11],0x10    ; is it directory?
+        test    byte [ebx+11], 0x10; is it directory?
-    jz    read_set_size         ; no
+        jz      read_set_size   ; no
-    mov   eax,[ebx+20-2]        ; FAT entry
+        mov     eax, [ebx+20-2] ; FAT entry
-    mov   ax,[ebx+26]
+        mov     ax, [ebx+26]
-    and   eax,[fatMASK]
+        and     eax, [fatMASK]
-    call  get_dir_size
+        call    get_dir_size
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   file_access_denied
+        jne     file_access_denied
   read_set_size:
-    mov   [file_size],eax
+        mov     [file_size], eax
-    mov   eax,[ebx+20-2]        ; FAT entry
+        mov     eax, [ebx+20-2] ; FAT entry
-    mov   ax,[ebx+26]
+        mov     ax, [ebx+26]
-    and   eax,[fatMASK]
+        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
-  file_read_start:
+        test    edx, edx        ; is all read?
-    mov   ebx,PUSHAD_ECX        ; pointer to buffer
+        je      file_read_OK    ; yes
-    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
+        call    get_FAT         ; get next cluster
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   file_access_denied
+        jne     file_access_denied
-    cmp   eax,[fatRESERVED]     ; end of file
+        cmp     eax, [fatRESERVED]; end of file
-    jnb   file_read_eof
+        jnb     file_read_eof
-    cmp   eax,2                 ; incorrect fat chain
+        cmp     eax, 2          ; incorrect fat chain
-    jnb   file_read_new_cluster
+        jnb     file_read_new_cluster
-    popad
+        popad
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    mov   ebx,[file_size]
+        mov     ebx, [file_size]
-    mov   eax,ERROR_FAT_TABLE
+        mov     eax, ERROR_FAT_TABLE
-    ret
+        ret
   file_read_eof:
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   file_access_denied
+        jne     file_access_denied
-    popad
+        popad
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    mov   ebx,[file_size]
+        mov     ebx, [file_size]
-    mov   eax,ERROR_END_OF_FILE
+        mov     eax, ERROR_END_OF_FILE
-    ret
+        ret
   file_read_OK:
-    popad
+        popad
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    mov   ebx,[file_size]
+        mov     ebx, [file_size]
-    xor   eax,eax
+        xor     eax, eax
-    ret
+        ret
   file_to_read_not_found:
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   file_access_denied
+        jne     file_access_denied
-    popad
+        popad
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    xor   ebx,ebx
+        xor     ebx, ebx
-    mov   eax,ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-    ret
+        ret
   file_access_denied:
-    popad
+        popad
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    xor   ebx,ebx
+        xor     ebx, ebx
-    mov   eax,ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-    ret
+        ret
 get_dir_size:
 ;-----------------------------------------------------
 ; input  : eax = first cluster (0=rootdir)
 ; output : eax = directory size in bytes
 ;-----------------------------------------------------
-    push  edx
+        push    edx
-    xor   edx,edx               ; count of directory clusters
+        xor     edx, edx        ; count of directory clusters
-    test  eax,eax
+        test    eax, eax
-    jnz   dir_size_next
+        jnz     dir_size_next
-    mov   eax,[ROOT_SECTORS]
+        mov     eax, [ROOT_SECTORS]
-    shl   eax,9                 ; fat16 rootdir size in bytes
+        shl     eax, 9          ; fat16 rootdir size in bytes
-    cmp   [fs_type],16
+        cmp     [fs_type], 16
-    je    dir_size_ret
+        je      dir_size_ret
-    mov   eax,[ROOT_CLUSTER]
+        mov     eax, [ROOT_CLUSTER]
   dir_size_next:
-    cmp   eax,2                 ; incorrect fat chain
+        cmp     eax, 2          ; incorrect fat chain
-    jb    dir_size_end
+        jb      dir_size_end
-    cmp   eax,[fatRESERVED]     ; end of directory
+        cmp     eax, [fatRESERVED]; end of directory
-    ja    dir_size_end
+        ja      dir_size_end
-    call  get_FAT               ; get next cluster
+        call    get_FAT         ; get next cluster
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   dir_size_ret
+        jne     dir_size_ret
-    inc   edx
+        inc     edx
-    jmp   dir_size_next
+        jmp     dir_size_next
   dir_size_end:
-    imul  eax,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
+        imul    eax, [SECTORS_PER_CLUSTER], 512; cluster size in bytes
-    imul  eax,edx
+        imul    eax, edx
   dir_size_ret:
-    pop   edx
+        pop     edx
-    ret
+        ret
 clear_cluster_chain:
 ;-----------------------------------------------------
 ; input  : eax = first cluster
 ;-----------------------------------------------------
-    push  eax ecx edx
+        push    eax ecx edx
-    xor   ecx,ecx               ; cluster count
+        xor     ecx, ecx        ; cluster count
   clean_new_chain:
-    cmp   eax,[LAST_CLUSTER]    ; end of file
+        cmp     eax, [LAST_CLUSTER]; end of file
 ;-----------------------------------------------------------
         cmp     [fs_type], 16
         jz      info_fat_ok
         cmp     [fs_type], 32
         jz      info_fat_ok
-    xor   edx,edx
+        xor     edx, edx
-    xor   ebx,ebx
+        xor     ebx, ebx
-    xor   ecx,ecx
+        xor     ecx, ecx
-    mov   eax,ERROR_UNKNOWN_FS
+        mov     eax, ERROR_UNKNOWN_FS
-    ret
+        ret
   info_fat_ok:
 ;    call  reserve_hd1
-    xor   ecx,ecx               ; count of free clusters
+        xor     ecx, ecx        ; count of free clusters
-    mov   eax,2
+        mov     eax, 2
-    mov   ebx,[LAST_CLUSTER]
+        mov     ebx, [LAST_CLUSTER]
   info_cluster:
-    push  eax
+        push    eax
-    call  get_FAT               ; get cluster info
+        call    get_FAT         ; get cluster info
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   info_access_denied
+        jne     info_access_denied
-    test  eax,eax               ; is it free?
+        test    eax, eax        ; is it free?
-    jnz   info_used             ; no
+        jnz     info_used       ; no
-    inc   ecx
+        inc     ecx
   info_used:
-    pop   eax
+        pop     eax
-    inc   eax
+        inc     eax
-    cmp   eax,ebx               ; is above last cluster?
+        cmp     eax, ebx        ; is above last cluster?
-    jbe   info_cluster          ; no. test next cluster
+        jbe     info_cluster    ; no. test next cluster
-    dec   ebx                   ; cluster count
+        dec     ebx             ; cluster count
-    imul  edx,[SECTORS_PER_CLUSTER],512 ; cluster size in bytes
+        imul    edx, [SECTORS_PER_CLUSTER], 512; cluster size in bytes
-    mov   [hd1_status],0
+        mov     [hd1_status], 0
-    xor   eax,eax
+        xor     eax, eax
-    ret
+        ret
   info_access_denied:
-    add   esp,4
+        add     esp, 4
-    xor   edx,edx
+        xor     edx, edx
-    xor   ebx,ebx
+        xor     ebx, ebx
-    xor   ecx,ecx
+        xor     ecx, ecx
-    mov   eax,ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-    ret
+        ret
 update_disk:
 ;-----------------------------------------------------------
 ; write changed fat and cache to disk
 ;-----------------------------------------------------------
-    cmp   [fat_change],0        ; is fat changed?
+        cmp     [fat_change], 0 ; is fat changed?
-    je    upd_no_change
+        je      upd_no_change
-    call  write_fat_sector
+        call    write_fat_sector
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   update_disk_acces_denied
+        jne     update_disk_acces_denied
         jz      ext2_HdRead
         or      ebx, -1
         mov     eax, ERROR_UNKNOWN_FS
         ret
 @@:
-    push    edi
+        push    edi
-    cmp    byte [esi], 0
+        cmp     byte [esi], 0
-    jnz    @f
+        jnz     @f
 .noaccess:
-    pop    edi
+        pop     edi
 .noaccess_2:
-    or    ebx, -1
+        or      ebx, -1
-    mov    eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-    ret
+        ret
 @@:
-    call    hd_find_lfn
+        call    hd_find_lfn
-    jnc    .found
+        jnc     .found
-    pop    edi
+        pop     edi
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   .noaccess_2
+        jne     .noaccess_2
-    or    ebx, -1
+        or      ebx, -1
-    mov    eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-    ret
+        ret
 .found:
-    test    byte [edi+11], 0x10    ; do not allow read directories
+        test    byte [edi+11], 0x10; do not allow read directories
-    jnz    .noaccess
+        jnz     .noaccess
-    test    ebx, ebx
+        test    ebx, ebx
-    jz    .l1
+        jz      .l1
-    cmp    dword [ebx+4], 0
+        cmp     dword [ebx+4], 0
-    jz    @f
+        jz      @f
         xor     ebx, ebx
 .reteof:
-    mov    eax, 6
+        mov     eax, 6
-    pop    edi
+        pop     edi
-    ret
+        ret
 @@:
-    mov    ebx, [ebx]
+        mov     ebx, [ebx]
 .l1:
         push    ecx edx
         push    0
         cmp     eax, ecx
         jae     @f
         mov     ecx, eax
         mov     byte [esp], 6
 @@:
-    mov    eax, [edi+20-2]
+        mov     eax, [edi+20-2]
-    mov    ax, [edi+26]
+        mov     ax, [edi+26]
 ; now eax=cluster, ebx=position, ecx=count, edx=buffer for data
 .new_cluster:
-    jecxz    .new_sector
+        jecxz   .new_sector
-    test    eax, eax
+        test    eax, eax
-    jz    .eof
+        jz      .eof
-    cmp    eax, [fatRESERVED]
+        cmp     eax, [fatRESERVED]
-    jae    .eof
+        jae     .eof
-    mov    [cluster_tmp], eax
+        mov     [cluster_tmp], eax
-    dec    eax
+        dec     eax
-    dec    eax
+        dec     eax
-    mov    edi, [SECTORS_PER_CLUSTER]
+        mov     edi, [SECTORS_PER_CLUSTER]
-    imul    eax, edi
+        imul    eax, edi
-    add    eax, [DATA_START]
+        add     eax, [DATA_START]
 .new_sector:
-    test    ecx, ecx
+        test    ecx, ecx
-    jz    .done
+        jz      .done
-    sub    ebx, 512
+        sub     ebx, 512
-    jae    .skip
+        jae     .skip
-    add    ebx, 512
+        add     ebx, 512
-    jnz    .force_buf
+        jnz     .force_buf
-    cmp    ecx, 512
+        cmp     ecx, 512
-    jb    .force_buf
+        jb      .force_buf
 ; we may read directly to given buffer
-    push    ebx
+        push    ebx
-    mov    ebx, edx
+        mov     ebx, edx
-    call    hd_read
+        call    hd_read
-    pop    ebx
+        pop     ebx
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  .noaccess_1
+        jne     .noaccess_1
-    add    edx, 512
+        add     edx, 512
-    sub    ecx, 512
+        sub     ecx, 512
-    jmp    .skip
+        jmp     .skip
 .force_buf:
 ; we must read sector to temporary buffer and then copy it to destination
-    push    eax ebx
+        push    eax ebx
-    mov    ebx, buffer
+        mov     ebx, buffer
-    call    hd_read
+        call    hd_read
-    mov    eax, ebx
+        mov     eax, ebx
-    pop    ebx
+        pop     ebx
-    cmp  [hd_error],0
+        cmp     [hd_error], 0
-    jne  .noaccess_3
+        jne     .noaccess_3
-    add    eax, ebx
+        add     eax, ebx
-    push    ecx
+        push    ecx
-    add    ecx, ebx
+        add     ecx, ebx
-    cmp    ecx, 512
+        cmp     ecx, 512
-    jbe    @f
+        jbe     @f
-    mov    ecx, 512
+        mov     ecx, 512
 @@:
-    sub    ecx, ebx
+        sub     ecx, ebx
-    mov    ebx, edx
+        mov     ebx, edx
-    call    memmove
+        call    memmove
-    add    edx, ecx
+        add     edx, ecx
-    sub    [esp], ecx
+        sub     [esp], ecx
-    pop    ecx
+        pop     ecx
-    pop    eax
+        pop     eax
-    xor    ebx, ebx
+        xor     ebx, ebx
 .skip:
-    inc    eax
+        inc     eax
-    dec    edi
+        dec     edi
-    jnz    .new_sector
+        jnz     .new_sector
-    mov    eax, [cluster_tmp]
+        mov     eax, [cluster_tmp]
-    call    get_FAT
+        call    get_FAT
-    cmp   [hd_error],0
+        cmp     [hd_error], 0
-    jne   .noaccess_1
+        jne     .noaccess_1
-    jmp    .new_cluster
+        jmp     .new_cluster
 .noaccess_3:
         pop     eax
 .noaccess_1:
         pop     eax
 ; init header
         push    eax ecx
         mov     edi, edx
         mov     ecx, 32/4
         xor     eax, eax
-        rep     stosd
+        rep stosd
         pop     ecx eax
         mov     byte [edx], 1   ; version
         mov     esi, edi        ; esi points to BDFE
 .new_cluster:
         mov     [cluster_tmp], eax
 ; zero new cluster
         mov     ecx, 512/4
         mov     edi, buffer
         push    edi
         xor     eax, eax
-        rep     stosd
+        rep stosd
         pop     edi
         pop     ecx
         mov     eax, [esp+4]
         mov     [eax], edx
         and     dword [eax+4], 0
 fs_HdRewrite:
         xor     eax, eax
 .common:
         cmp     [fs_type], 1
         jz      ntfs_HdRewrite
-        cmp		[fs_type], 2
+        cmp     [fs_type], 2
-        jz		ext2_HdRewrite
+        jz      ext2_HdRewrite
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
         jnz     fshrfs
 @@:
 .test_short_name_entry:
         cmp     byte [edi+11], 0xF
         jz      .test_short_name_cont
         mov     ecx, 11
         push    esi edi
-        repz    cmpsb
+        repz cmpsb
         pop     edi esi
         jz      .short_name_found
 .test_short_name_cont:
         lea     eax, [esp+12+12+8]
         call    dword [eax-8]
 ; now find space in directory
 ; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
         mov     al, '~'
         push    ecx edi
         mov     ecx, 8
-        repnz   scasb
+        repnz scasb
         push    1
         pop     eax     ; 1 entry
         jnz     .notilde
 ; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
         xor     eax, eax
 ;        lea     eax, [esp+8+12+8]
 ;        call    dword [eax+16]          ; end write
 .nolfn:
         xchg    esi, [esp]
         mov     ecx, 11
-        rep     movsb
+        rep movsb
         mov     word [edi], 20h         ; attributes
         sub     edi, 11
         pop     esi ecx
         add     esp, 12
         mov     byte [edi+13], 0        ; tenths of a second at file creation time
 .writeshort:
         mov     ecx, [esp+8]
         push    ecx
         mov     edi, buffer
         mov     ebx, edi
-        rep     movsb
+        rep movsb
 .writedircont:
         mov     ecx, buffer+0x200
         sub     ecx, edi
         push    eax
         xor     eax, eax
-        rep     stosb
+        rep stosb
         pop     eax
         pop     ecx
 .writecommon:
         call    hd_write
         cmp     [hd_error], 0
         cmp     ecx, [esp+12]
         jnz     .writedircont
         dec     dword [esp+16]
         push    esi
         mov     ecx, 32/4
-        rep     movsd
+        rep movsd
         pop     esi
         mov     dword [edi-32], '.   '
         mov     dword [edi-32+4], '    '
         mov     dword [edi-32+8], '    '
         mov     byte [edi-32+11], 10h
         push    esi
         mov     ecx, 32/4
-        rep     movsd
+        rep movsd
         pop     esi
         mov     dword [edi-32], '..  '
         mov     dword [edi-32+4], '    '
         mov     dword [edi-32+8], '    '
         mov     byte [edi-32+11], 10h
         jmp     fs_HdWrite.ret0
 fs_HdWrite:
         cmp     [fs_type], 1
         jz      ntfs_HdWrite
-        cmp		[fs_type], 2
+        cmp     [fs_type], 2
-        jz		ext2_HdWrite
+        jz      ext2_HdWrite
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
         jz      @f
         mov     ecx, 0x200
         sub     ecx, [esp+4+12]
         jbe     @f
         mov     edi, buffer
         add     edi, [esp+4+12]
-        rep     stosb
+        rep stosb
 @@:
 ; zero uninitialized data in the last sector
         mov     ecx, 0x200
         sub     ecx, esi
         jbe     @f
         mov     edi, buffer
         add     edi, esi
-        rep     stosb
+        rep stosb
 @@:
         pop     edi ecx
 ; copy new data
         mov     eax, edx
         neg     ebx
         xor     esi, esi
 @@:
         sub     dword [esp], 0x200
         jae     @f
         and     dword [esp], 0
+@@:
-@@:     jmp     .write_loop
+        jmp     .write_loop
 hd_extend_file.zero_size:
         xor     eax, eax
         push    ERROR_DISK_FULL
         pop     eax
         cmp     [hd_error], 0
         jz      @f
         mov     al, 11
+@@:
-@@:     stc
+        stc
         ret
 ;----------------------------------------------------------------
+;
+;
 ;--------------------------------------------------------------
 fs_HdSetFileEnd:
         cmp     [fs_type], 1
         jz      ntfs_HdSetFileEnd
-        cmp		[fs_type], 2
+        cmp     [fs_type], 2
-        jz		ext2_HdSetFileEnd
+        jz      ext2_HdSetFileEnd
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
         jz      @f
         push    ERROR_UNKNOWN_FS
         mov     edi, buffer+0x200
         add     edi, [esp+8]
         push    eax
         xor     eax, eax
         mov     [esp+12], eax
-        rep     stosb
+        rep stosb
         pop     eax
         pop     edi
         call    hd_write
         cmp     [hd_error], 0
         jz      .next_cluster
         lea     edi, [buffer+eax]
         push    ecx
         mov     ecx, 0x200
         sub     ecx, eax
         xor     eax, eax
-        rep     stosb
+        rep stosb
         pop     eax
         call    hd_write
         pop     ebx
 .truncate_done:
         pop     ecx eax edi
         ret
 fs_HdGetFileInfo:
         cmp     [fs_type], 1
         jz      ntfs_HdGetFileInfo
-        cmp		[fs_type], 2
+        cmp     [fs_type], 2
-        jz		ext2_HdGetFileInfo
+        jz      ext2_HdGetFileInfo
         cmp     [fs_type], 16
         jz      @f
         cmp     [fs_type], 32
         jz      @f

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/fs/fat32.inc @ 2434 – Rev 2130 → 2434