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

 ;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 6407 $
+$Revision: 6408 $
 ; NTFS driver
 cur_buf             dd  ?
 cur_read            dd  ?   ; bytes readen
 cur_tail            dd  ?
 cur_subnode_size    dd  ?
 LastRead            dd  ?   ; last readen block of sectors
+mftLastRead         dd  ?
 rootLastRead        dd  ?
 nodeLastRead        dd  ?
 indexRoot           dd  ?
 indexPointer        dd  ?
 newRecord           dd  ?
         pop     [ebp+NTFS.attr_iBaseRecord]
         pop     [ebp+NTFS.attr_iRecord]
         jc      .ret
         cmp     edx, [ebp+NTFS.frs_size]
         jnz     .errret
+        mov     eax, [ebp+NTFS.LastRead]
+        mov     [ebp+NTFS.mftLastRead], eax
         mov     eax, [ebp+NTFS.frs_buffer]
         cmp     dword [eax], 'FILE'
         jnz     .errret
         push    ebx
         mov     ebx, eax
         mov     eax, [esi+nodeRealSize]
         add     eax, rootNode
         cmp     [ebp+NTFS.cur_read], eax
         jc      .err
         mov     edi, [esp+4]
-        mov     eax, [ebp+NTFS.LastRead]
+        mov     eax, [ebp+NTFS.mftLastRead]
         mov     [ebp+NTFS.rootLastRead], eax
         mov     eax, [ebp+NTFS.attr_offs]
         mov     [ebp+NTFS.indexRoot], eax
 ; edi -> name, esi -> current index node
 .scanloop:
         mov     [ebp+NTFS.cur_buf], eax
         call    ntfs_read_attr.newAttribute
         jc      ntfsFail
         cmp     [ebp+NTFS.cur_read], 0x20
         jc      ntfsFail
-        pushad
         mov     esi, [ebp+NTFS.cur_index_buf]
         mov     eax, [esi+indexRecordSize]
         shr     eax, 9
         cmp     [ebp+NTFS.cur_index_size], eax
         jc      .realloc
         mov     [ebp+NTFS.cur_subnode_size], eax
         add     esi, rootNode
         mov     eax, [esi+nodeRealSize]
         add     eax, rootNode
         cmp     [ebp+NTFS.cur_read], eax
-        jc      .err
+        jc      ntfsFail
-        mov     edx, [ebx+16]
+        mov     edi, [ebx+16]
-        push    dword [ebx+8]   ; read ANSI/UNICODE name
-; init header
-        mov     edi, edx
-        mov     ecx, 32/4
-        xor     eax, eax
-        rep stosd
-        mov     byte [edx], 1   ; version
         mov     ecx, [ebx+12]
-        mov     ebx, [ebx+4]
+        pushd   [ebx]
+        pushd   [ebx+8]     ; read ANSI/UNICODE name
-        push    edx
+        push    edi
         mov     edx, esp
+        mov     ebx, [ebx+4]
+; init header
+        xor     eax, eax
+        mov     [edi+8], eax
+        mov     [edi+4], eax
+        inc     eax
+        mov     [edi], eax      ; version
+        add     edi, 32
 ; edi -> BDFE, esi -> current index data, ebx = first wanted block,
 ; ecx = number of blocks to read
 ; edx -> parameters block: dd , dd
         cmp     [ebp+NTFS.cur_iRecord], 5
         jz      .skip_specials
         mov     edi, eax
         mov     eax, [esi+indexRecordSize]
         shl     eax, 1
         stdcall kernel_alloc, eax
         test    eax, eax
-        jz      .err
+        jz      ntfsFail
         mov     edx, [ebp+NTFS.cur_index_buf]
         cmp     edx, [ebp+NTFS.secondIndexBuffer]
         jc      @f
         mov     edx, [ebp+NTFS.secondIndexBuffer]
 @@:
         mov     [ebp+NTFS.cur_index_buf], eax
         add     eax, [esi+indexRecordSize]
         mov     [ebp+NTFS.secondIndexBuffer], eax
         mov     [ebp+NTFS.cur_index_size], edi
         stdcall kernel_free, edx
-        popad
         jmp     .doit
-.err:
-        popad
-        jmp     ntfsFail
 .dump_root_done:
 ; now dump all subnodes
         push    ecx edi
         lea     edi, [ebp+NTFS.bitmap_buf]
         push    eax
         jmp     .dumploop
 .done:
         pop     eax
-        pop     edx
+        pop     eax
+        mov     ebx, [eax+4]
-        mov     ebx, [edx+4]
+        pop     eax
+        pop     eax
+        test    eax, eax
-        pop     edx
+        jz      .ret
         xor     eax, eax
         dec     ecx
         js      @f
         mov     al, ERROR_END_OF_FILE
 @@:
-        mov     [esp+1Ch], eax
-        mov     [esp+10h], ebx
+        push    eax
         call    ntfs_unlock
-        popad
+        pop     eax
         ret
 .add_special_entry:
         add     edi, 30h
         sub     edi, esi
         mov     [esi+recordRealSize], edi
         mov     eax, [ebp+NTFS.fileDataStart]
         mul     [ebp+NTFS.sectors_per_cluster]
-        mov     [ebp+NTFS.LastRead], eax
+        mov     edx, eax
         jmp     @f
 .refresh:
-        mov     [ebp+NTFS.cur_size], 0
-        mov     dword [ebp+NTFS.attr_size+4], -1
+        mov     [ebp+NTFS.cur_size], 0
         call    ntfs_read_attr.continue
         movi    eax, ERROR_FS_FAIL
+        jc      ntfsErrorPop3
-        jc      ntfsErrorPop3
+        mov     edx, [ebp+NTFS.LastRead]
 @@:
-        mov     eax, [ebp+NTFS.cur_index_buf]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     ebx, [ebp+NTFS.cur_index_buf]
-        call    writeRecord
-        mov     eax, [ebp+NTFS.rootLastRead]
-        mov     [ebp+NTFS.LastRead], eax
+        call    writeRecord
-        mov     eax, [ebp+NTFS.frs_buffer]
+        mov     ebx, [ebp+NTFS.frs_buffer]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.rootLastRead]
         call    writeRecord
         mov     esi, [esp+4]
         stdcall ntfs_find_lfn.doit2, 0
         test    eax, eax
         mov     eax, [ebp+NTFS.newRecord]
         mov     [esi+recordVCN], eax
         add     esi, recordNode
         sub     edi, esi
         mov     [esi+nodeRealSize], edi
-        mov     eax, [ebp+NTFS.secondIndexBuffer]
+        mov     ebx, [ebp+NTFS.secondIndexBuffer]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.LastRead]
         call    writeRecord
         jmp     .refresh
 .common:
         adc     edx, 0
         push    [ebp+NTFS.fileDataStart]
         push    [ebp+NTFS.fileDataSize]
         call    resizeAttribute
         jc      ntfsErrorPop2
-        mov     eax, [ebp+NTFS.frs_buffer]
+        mov     ebx, [ebp+NTFS.frs_buffer]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.LastRead]
         call    writeRecord     ; $MFT
         mov     eax, [ebp+NTFS.mftmirr_cluster]
         mul     [ebp+NTFS.sectors_per_cluster]
-        mov     ebx, [ebp+NTFS.frs_buffer]
+        mov     ecx, [ebp+NTFS.frs_size]
-        movzx   ecx, word [ebx+updateSequenceSize]
-        dec     ecx
+        shr     ecx, 9
         call    fs_write64_sys  ; $MFTMirr
 ; update $MFT retrieval information
         mov     edi, [ebp+NTFS.mft_retrieval_end]
         mov     eax, [edi-4]
         add     eax, [edi-8]
         mov     byte [edi+40h+indexAllocatedSize], 16
         mov     byte [edi+40h+indexFlags], 2
         add     edi, 50h
         mov     al, 3
 .end:
-        mov     esi, [ebp+NTFS.frs_buffer]
+        mov     ebx, [ebp+NTFS.frs_buffer]
         mov     dword [edi], -1
         mov     dword [edi+4], 0
         add     edi, 8
-        sub     edi, esi
+        sub     edi, ebx
-        mov     [ebp+NTFS.cur_buf], esi
+        mov     [ebx+recordFlags], al
-        mov     [esi+recordFlags], al
+        mov     [ebx+recordRealSize], edi
-        mov     [esi+recordRealSize], edi
+        mov     edx, [ebp+NTFS.LastRead]
         call    writeRecord
 ; write MFT bitmap
         mov     eax, [ebp+NTFS.newRecord]
         shr     eax, 3+9
         mov     ebx, eax
         call    fs_write64_sys
         mov     edi, [ebp+NTFS.indexPointer]
         mov     eax, [ebp+NTFS.newRecord]
         mov     [edi+fileRecordReference], eax
 ; 5. Write directory node
-        mov     eax, [ebp+NTFS.nodeLastRead]
-        mov     [ebp+NTFS.LastRead], eax
-        mov     eax, [ebp+NTFS.cur_index_buf]
+        mov     ebx, [ebp+NTFS.cur_index_buf]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.nodeLastRead]
         call    writeRecord
         mov     ebx, [ebp+NTFS.fileRealSize]
 ntfsDone:
         mov     esi, [ebp+PARTITION.Disk]
         call    disk_sync
         ret
 writeRecord:
 ; make updateSequence and write to disk
 ;   in:
-; [ebp+NTFS.cur_buf] -> record
+; ebx -> record
-; [ebp+NTFS.LastRead] = partition sector
+; edx = partition sector
-        mov     esi, [ebp+NTFS.cur_buf]
+        mov     esi, ebx
-        mov     edi, esi
+        mov     edi, ebx
         movzx   ecx, word [esi+updateSequenceOffset]
         add     edi, ecx
         mov     ax, [edi]
         inc     ax
         add     esi, 510
         movsw
         mov     [esi-2], ax
         dec     ecx
         jnz     @b
-        mov     eax, [ebp+NTFS.LastRead]
-        mov     ebx, [ebp+NTFS.cur_buf]
-        pop     ecx
+        mov     eax, edx
         xor     edx, edx
+        pop     ecx
         jmp     fs_write64_sys
 createMcbEntry:
 ;   in:
         add     edi, [ebx+4]
         mov     ecx, [ebx+12]
         mov     esi, [ebx+16]
         rep movsb
 @@:
-        mov     eax, [ebp+NTFS.frs_buffer]
-        mov     [ebp+NTFS.cur_buf], eax
-        call    writeRecord     ; file
         mov     ebx, [ebp+NTFS.frs_buffer]
+        mov     edx, [ebp+NTFS.mftLastRead]
+        call    writeRecord     ; file
         call    ntfs_restore_usa_frs
 .writeNode:
-        mov     eax, [ebp+NTFS.nodeLastRead]
-        mov     [ebp+NTFS.LastRead], eax
-        mov     eax, [ebp+NTFS.cur_index_buf]
+        mov     ebx, [ebp+NTFS.cur_index_buf]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.nodeLastRead]
         call    writeRecord     ; directory
         pop     ebx
         mov     ecx, [ebp+NTFS.attr_offs]
         cmp     byte [ecx+nonResidentFlag], 0
         jz      .done
         mov     [ebp+NTFS.rootLastRead], eax
         mov     eax, ebx
         xor     ebx, ebx
         jmp     .indexRecord
+.ret:
+        ret
 @@:         ; examine file record
-        mov     [ebp+NTFS.cur_attr], 0x80
+        mov     [ebp+NTFS.cur_attr], 0x80   ; file?
         mov     [ebp+NTFS.cur_offs], 0
         mov     [ebp+NTFS.cur_size], 0
+        call    ntfs_read_attr
+        jnc     @f
+        mov     eax, [ebp+NTFS.cur_index_size]
+        shl     eax, 9
+        stdcall kernel_alloc, eax
+        test    eax, eax
+        jz      ntfsFail
+        push    [ebp+NTFS.cur_index_buf]
+        push    [ebp+NTFS.secondIndexBuffer]
+        push    [ebp+NTFS.cur_index_size]
+        mov     [ebp+NTFS.cur_index_buf], eax
+        mov     [ebp+NTFS.secondIndexBuffer], eax
+        xor     eax, eax
+        push    eax eax eax eax
+        mov     [esp+12], esp
+        push    eax
+        mov     ebx, esp
+        mov     [ebp+NTFS.cur_attr], 0x90   ; folder?
+        call    ntfs_ReadFolder.doit
+        push    eax
+        stdcall kernel_free, [ebp+NTFS.cur_index_buf]
+        pop     eax
+        mov     edx, [esp+12]
+        add     esp, 20
+        pop     [ebp+NTFS.cur_index_size]
+        pop     [ebp+NTFS.secondIndexBuffer]
+        pop     [ebp+NTFS.cur_index_buf]
-        call    ntfs_read_attr
+        test    eax, eax
+        jnz     .ret
+        cmp     edx, 2
+        jnz     ntfsDenied      ; folder is not empty
+        mov     [ebp+NTFS.cur_attr], 0xA0
+        mov     [ebp+NTFS.cur_offs], 0
+        mov     [ebp+NTFS.cur_size], 0
+        call    ntfs_read_attr.newAttribute
+        jc      .writeBitmapMFT
-        jc      .folder
+@@:
         mov     esi, [ebp+NTFS.frs_buffer]
         cmp     word [esi+baseRecordReuse], 0
         jnz     ntfsUnsupported     ; auxiliary record
         mov     esi, [ebp+NTFS.attr_offs]
         cmp     byte [esi+nonResidentFlag], 0
         jz      .writeBitmapMFT
         movzx   eax, byte [esi+dataRunsOffset]
         add     esi, eax
         xor     edi, edi
         sub     esp, 16
-@@:         ; "delete" file data
+@@:
         call    ntfs_decode_mcb_entry
         jnc     @f
         cmp     dword[esp+8], 0
         jz      @b
         add     edi, [esp+8]
         mov     ebx, [esp]
         call    ntfsSpaceFree
         jnc     @b
 @@:
-        add     esp, 16
-        jmp     .writeBitmapMFT
-.folder:    ; empty?
-        lea     esi, [ebp+NTFS.bitmap_buf]
-        mov     [ebp+NTFS.cur_buf], esi
-        mov     [ebp+NTFS.cur_attr], 0x90
-        mov     [ebp+NTFS.cur_offs], 0
-        mov     [ebp+NTFS.cur_size], 1
-        call    ntfs_read_attr
-        cmp     [ebp+NTFS.cur_read], 48
-        jnz     ntfsDenied
-        test    byte [esi+32+indexFlags], 1
-        jnz     ntfsDenied
+        add     esp, 16
 .writeBitmapMFT:    ; "delete" file record
         mov     eax, [ebp+NTFS.cur_iRecord]
         mov     ecx, eax
         shr     eax, 3
         add     eax, [ebp+NTFS.mftBitmapLocation]
         add     ebx, edi
         mov     ecx, 1
         xor     edx, edx
         call    fs_write64_sys
-        mov     esi, [ebp+NTFS.frs_buffer]
+        mov     ebx, [ebp+NTFS.frs_buffer]
-        mov     [ebp+NTFS.cur_buf], esi
+        mov     byte [ebx+recordFlags], 0
-        mov     byte [esi+recordFlags], 0
+        mov     edx, [ebp+NTFS.mftLastRead]
         call    writeRecord
 ; write directory node
-        mov     eax, [ebp+NTFS.cur_index_buf]
+        mov     ebx, [ebp+NTFS.cur_index_buf]
-        mov     [ebp+NTFS.cur_buf], eax
-        mov     eax, [ebp+NTFS.nodeLastRead]
+        mov     edx, [ebp+NTFS.nodeLastRead]
-        mov     [ebp+NTFS.LastRead], eax
         call    writeRecord
-        mov     eax, [ebp+NTFS.secondIndexBuffer]
+        mov     ebx, [ebp+NTFS.secondIndexBuffer]
-        cmp     byte [eax], 0
+        cmp     byte [ebx], 0
         jz      ntfsDone
-        mov     [ebp+NTFS.cur_buf], eax
-        mov     eax, [ebp+NTFS.rootLastRead]
+        mov     edx, [ebp+NTFS.rootLastRead]
-        mov     [ebp+NTFS.LastRead], eax
         call    writeRecord
         jmp     ntfsDone
 ;----------------------------------------------------------------
         pop     edi
         mov     esi, eax
         sub     ecx, edi
         add     edi, eax
         mov     [ebp+NTFS.cur_buf], eax
-        push    [ebp+NTFS.LastRead]
         call    ntfs_read_attr.continue
         jc      @f
         xor     eax, eax
         rep stosb
         push    ebx
         mov     ecx, [ebp+NTFS.sectors_per_cluster]
         xor     edx, edx
         call    fs_write64_app
         pop     ebx
 @@:
-        pop     [ebp+NTFS.LastRead]
         stdcall kernel_free, esi
 .aligned:
         mov     eax, [ebx+4]
         mov     edx, [ebx+8]
 .resizeAttribute:
         call    resizeAttribute
         jc      ntfsError
-        mov     eax, [ebp+NTFS.frs_buffer]
+        mov     ebx, [ebp+NTFS.frs_buffer]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.mftLastRead]
         call    writeRecord     ; file
-        mov     eax, [ebp+NTFS.nodeLastRead]
-        mov     [ebp+NTFS.LastRead], eax
-        mov     eax, [ebp+NTFS.cur_index_buf]
+        mov     ebx, [ebp+NTFS.cur_index_buf]
-        mov     [ebp+NTFS.cur_buf], eax
+        mov     edx, [ebp+NTFS.nodeLastRead]
         call    writeRecord     ; directory
         call    ntfsSpaceClean
         jmp     ntfsDone

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ntfs.inc – Rev 6407 → 6408