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

 ;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
 ;;  Distributed under terms of the GNU General Public License.  ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 6867 $
+$Revision: 6868 $
 ; FAT external functions
 ;   in:
 ; additional memory and additional code for packing/unpacking.
 ; I'm not sure that the economy justifies the cost, but anyway,
 ; there is how work was done before my edits, and I'm just keeping the principle.
 fat_cache_ptr       dd  ?
 fat12_unpacked_ptr  dd  ?
+volumeLabel         rb  12
 buffer              rb  512
 fsinfo_buffer       rb  512
 ends
         inc     eax
         mov     [ebp+FAT.LAST_CLUSTER], eax
         dec     eax                     ; cluster count
         jz      .free_return0
         mov     [ebp+FAT.fatStartScan], 2
-; limits by Microsoft Hardware White Paper v1.03
-        cmp     eax, 0xff5
-        jb      .fat12
         cmp     eax, 0xfff5
         jb      .fat16
 .fat32:
+        pusha
+        lea     esi, [ebx+71]
+        lea     edi, [ebp+FAT.volumeLabel]
+        movsd
+        movsd
+        movsd
+        popa
         mov     eax, [ebx+0x2c]         ; rootdir cluster
         mov     [ebp+FAT.ROOT_CLUSTER], eax
         movzx   eax, word [ebx+0x30]
         mov     [ebp+FAT.ADR_FSINFO], eax
         push    ebx
         mov     eax, ebp
         pop     ebp
         ret
+.fat16:
+        pusha
+        lea     esi, [ebx+43]
+        lea     edi, [ebp+FAT.volumeLabel]
+        movsd
+        movsd
+        movsd
+        popa
+        cmp     eax, 0xff5
-.fat16:
+        jb      .fat12
         and     [ebp+FAT.ROOT_CLUSTER], 0
         mov     [ebp+FAT.fatRESERVED], 0x0000FFF6
         mov     [ebp+FAT.fatBAD], 0x0000FFF7
         mov     [ebp+FAT.fatEND], 0x0000FFF8
 fat_unlock:
         lea     ecx, [ebp+FAT.Lock]
         jmp     mutex_unlock
 fat_get_name:
-; in: edi -> FAT entry
+; in: edi -> FAT entry, esi -> buffer for UTF-16 name
-; out: ebp -> UTF-16 name, CF=1 -> no valid entry
+; out: CF=1 -> no valid entry
         cmp     byte [edi], 0
         jz      .no
         cmp     byte [edi], 0xE5
         jz      .no
         cmp     byte [edi+11], 0xF
         jz      .longname
-        test    byte [edi+11], 8
+        push    edi
-        jnz     .no
+        xchg    esi, edi
-        push    ecx esi edi
+        test    byte [esi+11], 8
+        jnz     .label
-        mov     esi, edi
+        pushd   ecx 8
-        mov     edi, ebp
+        pop     ecx
-        mov     ecx, 8
+        xor     eax, eax
 @@:
-        lodsb
-        call    ansi2uni_char
+        lodsb
         stosw
         loop    @b
         mov     cl, 8
 @@:
         mov     word [edi], '.'
         add     edi, 2
         mov     cl, 3
 @@:
         lodsb
-        call    ansi2uni_char
         stosw
         loop    @b
         mov     cl, 3
 @@:
         cmp     word [edi-2], ' '
         sub     edi, 2
         loop    @b
         sub     edi, 2
 @@:
         and     word [edi], 0   ; CF=0
-        pop     edi esi ecx
+        pop     ecx edi
         ret
+.label:
+        lea     edi, [ebp+FAT.volumeLabel]
+        movsd
+        movsd
+        movsd
         pop     edi
 .no:
         stc
         ret
 .longname:
         mov     al, byte [edi]
         and     eax, 0x3F
         dec     eax
         cmp     al, 20
         jae     .no     ; ignore invalid entries
-        mov     word [ebp+260*2], 0     ; force null-terminating for orphans
+        mov     word [esi+260*2], 0     ; force null-terminating for orphans
         imul    eax, 13*2
         test    byte [edi], 0x40
         jz      @f
-        mov     word [ebp+eax+13*2], 0
+        mov     word [esi+eax+13*2], 0
+@@: ; copy name (13 chars in UTF-16)
-@@: ; copy name (13 chars in UTF-16)
+        push    edi
-        push    esi edi
+        inc     edi
-        lea     esi, [edi+1]
+        add     esi, eax
-        lea     edi, [ebp+eax]
+        xchg    esi, edi
         movsd
-        movsd
         movsd
-        inc     esi
+        movsw
-        sub     edi, 2
+        add     esi, 3
         movsd
         movsd
         movsd
         add     esi, 2
         movsd
-        pop     edi esi
+        pop     edi
         test    eax, eax
         jnz     .no ; if this is not first entry, more processing required
+        ret
-        ret
+fat_find_lfn:
 ;   in:
+; esi -> path in UTF-8
+; parameters in the stack
-fat_compare_name:
+;   out:
+; esi -> next name in the path
-; in: esi -> name in UTF-8, ebp -> name in UTF-16
+; edi -> direntry
+; CF=1 -> file not found, eax = error code
+        lea     eax, [esp+12]
+        call    dword [eax-4]
+        jc      .reterr
+        sub     esp, 262*2      ; reserve place for LFN
+.l1:
+        push    esi
+        lea     esi, [esp+4]
-;   out:
+        call    fat_get_name
+        pop     esi
-; ZF=1 -> names match, esi -> next component of name
+        jc      .no
-; ZF=0 -> esi is not changed
+        push    edi esi
-        push    ebp esi
+        lea     edi, [esp+8]
 @@:
         call    utf8to16
         call    utf16toUpper
         mov     edx, eax
-        mov     ax, [ebp]
+        mov     ax, [edi]
         call    utf16toUpper
         cmp     ax, dx
         jnz     .done
-        add     ebp, 2
+        add     edi, 2
         test    ax, ax
+        jnz     @b
+        dec     esi
+        pop     eax edi
+.found:
+        add     esp, 262*2
+; if this is LFN entry, advance to true entry
+        cmp     byte [edi+11], 0xF
+        jnz     @f
+        lea     eax, [esp+12]
-        jnz     @b
+        call    dword[eax-8]
-        dec     esi
+        jc      .reterr
-        pop     eax ebp
+@@:
-        xor     eax, eax    ; set ZF
+        xor     eax, eax
         ret
 .done:
         cmp     dx, '/'
         jnz     @f
         test    ax, ax
-        jnz     @f
-        mov     [esp], esi
-@@:
-        pop     esi ebp
-        ret
-fat_find_lfn:
-; in: esi -> name in UTF-8
-;     [esp+4] = next
-;     [esp+8] = first
-;     [esp+C]... - possibly parameters for first and next
-; out: CF=1 - file not found, eax=error code
-;      else CF=0, esi->next name component, edi->direntry
-        pusha
-        lea     eax, [esp+0Ch+20h]
-        call    dword [eax-4]
-        jc      .reterr
-        sub     esp, 262*2      ; reserve place for LFN
-.l1:
-        lea     ebp, [esp]
+        jnz     @f
-        call    fat_get_name
+        mov     [esp], esi
-        jc      .l2
-        call    fat_compare_name
+@@:
-        jz      .found
+        pop     esi edi
-.l2:
+        jz      .found
-        mov     ebp, [esp+8+262*2]
+.no:
-        lea     eax, [esp+0Ch+20h+262*2]
+        lea     eax, [esp+262*2+12]
-        call    dword [eax-8]
-        jnc     .l1
+        call    dword[eax-8]
-        add     esp, 262*2
-.reterr:
-        mov     [esp+28], eax
-        stc
-        popa
-        ret
-.found:
-        add     esp, 262*2
-        mov     ebp, [esp+8]
-; if this is LFN entry, advance to true entry
-        cmp     byte [edi+11], 0xF
-        jnz     @f
-        lea     eax, [esp+0Ch+20h]
-        call    dword [eax-8]
-        jc      .reterr
-@@:
-        add     esp, 8  ; CF=0
+        jnc     .l1
-        push    esi
+        add     esp, 262*2
-        push    edi
+.reterr:
-        popa
+        stc
         test    byte [edi+11], 0x10     ; do not allow read files
         jz      .accessDenied
         mov     eax, [edi+20-2]
         mov     ax, [edi+26]    ; eax=cluster
 .doit:
-        push    esi
         sub     esp, 262*2      ; reserve space for LFN
         push    dword [ebx+8]   ; cp866/UNICODE name
         mov     edx, [ebx+16]   ; pointer to buffer
 ; init header
         push    eax
         pop     eax
         jnz     .notfound2
         add     ebx, 512
         push    eax
 .l1:
-        push    ebp
+        push    esi
-        lea     ebp, [esp+20]
+        lea     esi, [esp+20]
         call    fat_get_name
-        pop     ebp
+        pop     esi
         jc      .l2
         cmp     byte [edi+11], 0xF
         jnz     .do_bdfe
         add     edi, 0x20
         cmp     edi, ebx
         jmp     .new_cluster
 .notfound2:
         add     esp, 8
 .notfound:
-        add     esp, 262*2+8
+        add     esp, 262*2+4
         push    ERROR_DEVICE
         jmp     @f
 .done:
-        add     esp, 262*2+16
+        add     esp, 262*2+12
         pushd   0
         dec     ecx
         js      @f
         test    eax, eax
         jz      .done1
 @@:
         cmp     eax, [ebp+FAT.fatRESERVED]
         jae     .done1
-        push    edx
         xor     edx, edx
         call    set_FAT
         mov     eax, edx
-        pop     edx
         jc      .done1
         inc     ecx
         jmp     @b
         shr     eax, 16
         mov     [edi+20], ax
         lea     eax, [esp+16+8]
         call    dword [eax+16]  ; flush directory
         pop     eax
-        push    edx
         mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
-        pop     edx
 .write_cluster:
         push    eax
         dec     eax
         dec     eax
         imul    eax, [ebp+FAT.SECTORS_PER_CLUSTER]
 ; allocate new cluster
         pop     eax
         mov     ecx, eax
         call    get_free_FAT
         jc      .diskfull
-        push    edx
         mov     edx, [ebp+FAT.fatEND]
         call    set_FAT
         xchg    eax, ecx
         mov     edx, ecx
         call    set_FAT
-        pop     edx
         xchg    eax, ecx
         jmp     .write_cluster
 .diskfull:
         ret
 ;----------------------------------------------------------------
 fat_GetFileInfo:
         cmp     byte [esi], 0
-        jnz     @f
-        mov     eax, 2
-        ret
-@@:
+        jz      .volume
         call    fat_lock
         call    hd_find_lfn
         jc      @f
         push    ebp
         push    eax
         call    fat_unlock
         pop     eax
         ret
+.volume:
+        mov     eax, dword[ebp+FAT.Length]
+        mov     edx, dword[ebp+FAT.Length+4]
+        mov     edi, [ebx+16]
+        shld    edx, eax, 9
+        shl     eax, 9
+        mov     [edi+36], edx
+        mov     [edi+32], eax
+        mov     eax, [ebx+8]
+        mov     byte [edi], 8
+        mov     [edi+4], eax
+        lea     esi, [ebp+FAT.volumeLabel]
+        mov     ecx, 11
+@@:
+        mov     byte [esi+ecx], 0
+        dec     ecx
+        jz      @f
+        cmp     byte [esi+ecx], ' '
+        jz      @b
+@@:
+        mov     cl, 12
+        add     edi, 40
+        cmp     eax, 2
+        jz      @f
+        rep movsb
+        xor     eax, eax
+        ret
+@@:
+        lodsb
+        stosw
+        loop    @b
+        ret
 ;----------------------------------------------------------------
 fat_SetFileInfo:
         call    fat_lock
         call    hd_find_lfn

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/fat.inc – Rev 6867 → 6868