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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1379 $
 
 
ntfs_test_bootsec:
; in: ebx->buffer, edx=size of partition
; out: CF set <=> invalid
; 1. Name=='NTFS    '
        cmp     dword [ebx+3], 'NTFS'
        jnz     .no
        cmp     dword [ebx+7], '    '
        jnz     .no
; 2. Number of bytes per sector is the same as for physical device
; (that is, 0x200 for hard disk)
        cmp     word [ebx+11], 0x200
        jnz     .no
; 3. Number of sectors per cluster must be power of 2
        movzx   eax, byte [ebx+13]
        dec     eax
        js      .no
        test    al, [ebx+13]
        jnz     .no
; 4. FAT parameters must be zero
        cmp     word [ebx+14], 0
        jnz     .no
        cmp     dword [ebx+16], 0
        jnz     .no
        cmp     byte [ebx+20], 0
        jnz     .no
        cmp     word [ebx+22], 0
        jnz     .no
        cmp     dword [ebx+32], 0
        jnz     .no
; 5. Number of sectors <= partition size
        cmp     dword [ebx+0x2C], 0
        ja      .no
        cmp     [ebx+0x28], edx
        ja      .no
; 6. $MFT and $MFTMirr clusters must be within partition
        cmp     dword [ebx+0x34], 0
        ja      .no
        push    edx
        movzx   eax, byte [ebx+13]
        mul     dword [ebx+0x30]
        test    edx, edx
        pop     edx
        jnz     .no
        cmp     eax, edx
        ja      .no
        cmp     dword [ebx+0x3C], 0
        ja      .no
        push    edx
        movzx   eax, byte [ebx+13]
        mul     dword [ebx+0x38]
        test    edx, edx
        pop     edx
        jnz     .no
        cmp     eax, edx
        ja      .no
; 7. Clusters per FRS must be either negative and in [-31,-9] or positive and power of 2
        movsx   eax, byte [ebx+0x40]
        cmp     al, -31
        jl      .no
        cmp     al, -9
        jle     @f
        dec     eax
        js      .no
        test    [ebx+0x40], al
        jnz     .no
@@:
; 8. Same for clusters per IndexAllocationBuffer
        movsx   eax, byte [ebx+0x44]
        cmp     al, -31
        jl      .no
        cmp     al, -9
        jle     @f
        dec     eax
        js      .no
        test    [ebx+0x44], al
        jnz     .no
@@:
; OK, this is correct NTFS bootsector
        clc
        ret
.no:
; No, this bootsector isn't NTFS
        stc
        ret
 
ntfs_setup:             ; CODE XREF: part_set.inc
; By given bootsector, initialize some NTFS variables
;        call    ntfs_test_bootsec			; checking boot sector was already
;        jc      problem_fat_dec_count
        movzx   eax, byte [ebx+13]
        mov     [ntfs_data.sectors_per_cluster], eax
        mov     eax, [ebx+0x28]
        add     eax, [PARTITION_START]
        dec     eax
        mov     [PARTITION_END], eax
        mov     [fs_type], 1
        mov     eax, [ebx+0x30]
        mov     [ntfs_data.mft_cluster], eax
        mov     eax, [ebx+0x38]
        mov     [ntfs_data.mftmirr_cluster], eax
        movsx   eax, byte [ebx+0x40]
        test    eax, eax
        js      .1
        mul     [ntfs_data.sectors_per_cluster]
        shl     eax, 9
        jmp     .2
.1:
        neg     eax
        mov     ecx, eax
        mov     eax, 1
        shl     eax, cl
.2:
        mov     [ntfs_data.frs_size], eax
        movsx   eax, byte [ebx+0x44]
        test    eax, eax
        js      .3
        mul     [ntfs_data.sectors_per_cluster]
        shl     eax, 9
        jmp     .4
.3:
        neg     eax
        mov     ecx, eax
        mov     eax, 1
        shl     eax, cl
.4:
        mov     [ntfs_data.iab_size], eax
; allocate space for buffers
        add     eax, [ntfs_data.frs_size]
        push    eax
        call    kernel_alloc
        test    eax, eax
        jz      problem_fat_dec_count
        mov     [ntfs_data.frs_buffer], eax
        add     eax, [ntfs_data.frs_size]
        mov     [ntfs_data.iab_buffer], eax
; read $MFT disposition
        mov     eax, [ntfs_data.mft_cluster]
        mul     [ntfs_data.sectors_per_cluster]
        call    ntfs_read_frs_sector
        cmp     [hd_error], 0
        jnz     .usemirr
        cmp     dword [ebx], 'FILE'
        jnz     .usemirr
        call    ntfs_restore_usa_frs
        jnc     .mftok
.usemirr:
        and     [hd_error], 0
        mov     eax, [ntfs_data.mftmirr_cluster]
        mul     [ntfs_data.sectors_per_cluster]
        call    ntfs_read_frs_sector
        cmp     [hd_error], 0
        jnz     @f
        cmp     dword [ebx], 'FILE'
        jnz     @f
        call    ntfs_restore_usa_frs
        jnc     .mftok
@@:
; $MFT and $MFTMirr invalid!
.fail_free_frs:
        push    [ntfs_data.frs_buffer]
        call    kernel_free
        jmp     problem_fat_dec_count
.fail_free_mft:
        push    [ntfs_data.mft_retrieval]
        call    kernel_free
        jmp     .fail_free_frs
.mftok:
; read $MFT table retrieval information
; start with one page, increase if not enough (when MFT too fragmented)
        push    ebx
        push    0x1000
        call    kernel_alloc
        pop     ebx
        test    eax, eax
        jz      .fail_free_frs
        mov     [ntfs_data.mft_retrieval], eax
        and     [ntfs_data.mft_retrieval_size], 0
        mov     [ntfs_data.mft_retrieval_alloc], 0x1000/8
; $MFT base record must contain unnamed non-resident $DATA attribute
        movzx   eax, word [ebx+14h]
        add     eax, ebx
.scandata:
        cmp     dword [eax], -1
        jz      .fail_free_mft
        cmp     dword [eax], 0x80
        jnz     @f
        cmp     byte [eax+9], 0
        jz      .founddata
@@:
        add     eax, [eax+4]
        jmp     .scandata
.founddata:
        cmp     byte [eax+8], 0
        jz      .fail_free_mft
; load first portion of $DATA attribute retrieval information
        mov     edx, [eax+0x18]
        mov     [ntfs_data.mft_retrieval_end], edx
        mov     esi, eax
        movzx   eax, word [eax+0x20]
        add     esi, eax
        sub     esp, 10h
.scanmcb:
        call    ntfs_decode_mcb_entry
        jnc     .scanmcbend
        call    .get_mft_retrieval_ptr
        mov     edx, [esp]      ; block length
        mov     [eax], edx
        mov     edx, [esp+8]    ; block addr (relative)
        mov     [eax+4], edx
        inc     [ntfs_data.mft_retrieval_size]
        jmp     .scanmcb
.scanmcbend:
        add     esp, 10h
; there may be other portions of $DATA attribute in auxiliary records;
; if they will be needed, they will be loaded later
 
        mov     [ntfs_data.cur_index_size], 0x1000/0x200
        push    0x1000
        call    kernel_alloc
        test    eax, eax
        jz      .fail_free_mft
        mov     [ntfs_data.cur_index_buf], eax
 
        popad
        call    free_hd_channel
        and     [hd1_status], 0
        ret
 
.get_mft_retrieval_ptr:
        pushad
        mov     eax, [ntfs_data.mft_retrieval_size]
        cmp     eax, [ntfs_data.mft_retrieval_alloc]
        jnz     .ok
        add     eax, 0x1000/8
        mov     [ntfs_data.mft_retrieval_alloc], eax
        shl     eax, 3
        push    eax
        call    kernel_alloc
        test    eax, eax
        jnz     @f
        popad
        add     esp, 14h
        jmp     .fail_free_mft
@@:
        mov     esi, [ntfs_data.mft_retrieval]
        mov     edi, eax
        mov     ecx, [ntfs_data.mft_retrieval_size]
        add     ecx, ecx
        rep     movsd
        push    [ntfs_data.mft_retrieval]
        mov     [ntfs_data.mft_retrieval], eax
        call    kernel_free
        mov     eax, [ntfs_data.mft_retrieval_size]
.ok:
        shl     eax, 3
        add     eax, [ntfs_data.mft_retrieval]
        mov     [esp+28], eax
        popad
        ret
 
ntfs_read_frs_sector:
        push    eax ecx
        add     eax, [PARTITION_START]
        mov     ecx, [ntfs_data.frs_size]
        shr     ecx, 9
        mov     ebx, [ntfs_data.frs_buffer]
        push    ebx
@@:
        call    hd_read
        cmp     [hd_error], 0
        jnz     .fail
        add     ebx, 0x200
        inc     eax
        loop    @b
.fail:
        pop     ebx
        pop     ecx eax
        ret
 
uglobal
align 4
ntfs_cur_attr   dd      ?
ntfs_cur_iRecord dd     ?
ntfs_cur_offs   dd      ?       ; in sectors
ntfs_cur_size   dd      ?       ; in sectors
ntfs_cur_buf    dd      ?
ntfs_cur_read   dd      ?       ; [output]
ntfs_bCanContinue db    ?
                rb      3
 
ntfs_attrlist_buf       rb      0x400
ntfs_attrlist_mft_buf   rb      0x400
ntfs_bitmap_buf         rb      0x400
 
ntfs_attr_iRecord       dd      ?
ntfs_attr_iBaseRecord   dd      ?
ntfs_attr_offs          dd      ?
ntfs_attr_list          dd      ?
ntfs_attr_size          dq      ?
ntfs_cur_tail           dd      ?
endg
 
ntfs_read_attr:
; in: global variables
; out: [ntfs_cur_read]
        pushad
        and     [ntfs_cur_read], 0
        cmp     [ntfs_cur_iRecord], 0
        jnz     .nomft
        cmp     [ntfs_cur_attr], 0x80
        jnz     .nomft
        mov     eax, [ntfs_data.mft_retrieval_end]
        inc     eax
        mul     [ntfs_data.sectors_per_cluster]
        cmp     eax, [ntfs_cur_offs]
        jbe     .nomft
; precalculated part of $Mft $DATA
        mov     esi, [ntfs_data.mft_retrieval]
        mov     eax, [ntfs_cur_offs]
        xor     edx, edx
        div     [ntfs_data.sectors_per_cluster]
; eax = VCN, edx = offset in sectors from beginning of cluster
        xor     ecx, ecx        ; ecx will contain LCN
.mftscan:
        add     ecx, [esi+4]
        sub     eax, [esi]
        jb      @f
        add     esi, 8
        push    eax
        mov     eax, [ntfs_data.mft_retrieval_end]
        shl     eax, 3
        add     eax, [ntfs_data.mft_retrieval]
        cmp     eax, esi
        pop     eax
        jnz     .mftscan
        jmp     .nomft
@@:
        push    ecx
        add     ecx, eax
        add     ecx, [esi]
        push    eax
        push    edx
        mov     eax, [ntfs_data.sectors_per_cluster]
        mul     ecx
; eax = sector on partition
        add     eax, [PARTITION_START]
        pop     edx
        add     eax, edx
        mov     ebx, [ntfs_cur_buf]
        pop     ecx
        neg     ecx
        imul    ecx, [ntfs_data.sectors_per_cluster]
        sub     ecx, edx
        cmp     ecx, [ntfs_cur_size]
        jb      @f
        mov     ecx, [ntfs_cur_size]
@@:
; ecx = number of sequential sectors to read
        call    hd_read
        cmp     [hd_error], 0
        jnz     .errread
        add     [ntfs_cur_read], 0x200
        dec     [ntfs_cur_size]
        inc     [ntfs_cur_offs]
        add     ebx, 0x200
        mov     [ntfs_cur_buf], ebx
        inc     eax
        loop    @b
        pop     ecx
        xor     eax, eax
        xor     edx, edx
        cmp     [ntfs_cur_size], eax
        jz      @f
        add     esi, 8
        push    eax
        mov     eax, [ntfs_data.mft_retrieval_end]
        shl     eax, 3
        add     eax, [ntfs_data.mft_retrieval]
        cmp     eax, esi
        pop     eax
        jz      .nomft
        jmp     .mftscan
@@:
        popad
        ret
.errread:
        pop     ecx
.errret:
        stc
        popad
        ret
.nomft:
; 1. Read file record.
; N.B. This will do recursive call of read_attr for $MFT::$Data.
        mov     eax, [ntfs_cur_iRecord]
        mov     [ntfs_attr_iRecord], eax
        and     [ntfs_attr_list], 0
        or      dword [ntfs_attr_size], -1
        or      dword [ntfs_attr_size+4], -1
        or      [ntfs_attr_iBaseRecord], -1
        call    ntfs_read_file_record
        test    eax, eax
        jz      .errret
; 2. Find required attribute.
        mov     eax, [ntfs_data.frs_buffer]
; a) For auxiliary records, read base record
; N.B. If base record is present,
;      base iRecord may be 0 (for $Mft), but SequenceNumber is nonzero
        cmp     dword [eax+24h], 0
        jz      @f
        mov     eax, [eax+20h]
;        test    eax, eax
;        jz      @f
.beginfindattr:
        mov     [ntfs_attr_iRecord], eax
        call    ntfs_read_file_record
        test    eax, eax
        jz      .errret
@@:
; b) Scan for required attribute and for $ATTR_LIST
        mov     eax, [ntfs_data.frs_buffer]
        movzx   ecx, word [eax+14h]
        add     eax, ecx
        mov     ecx, [ntfs_cur_attr]
        and     [ntfs_attr_offs], 0
.scanattr:
        cmp     dword [eax], -1
        jz      .scandone
        cmp     dword [eax], ecx
        jz      .okattr
        cmp     [ntfs_attr_iBaseRecord], -1
        jnz     .scancont
        cmp     dword [eax], 0x20       ; $ATTR_LIST
        jnz     .scancont
        mov     [ntfs_attr_list], eax
        jmp     .scancont
.okattr:
; ignore named $DATA attributes (aka NTFS streams)
        cmp     ecx, 0x80
        jnz     @f
        cmp     byte [eax+9], 0
        jnz     .scancont
@@:
        mov     [ntfs_attr_offs], eax
.scancont:
        add     eax, [eax+4]
        jmp     .scanattr
.continue:
        pushad
        and     [ntfs_cur_read], 0
.scandone:
; c) Check for required offset and length
        mov     ecx, [ntfs_attr_offs]
        jecxz   .noattr
        push    [ntfs_cur_size]
        push    [ntfs_cur_read]
        call    .doreadattr
        pop     edx
        pop     eax
        jc      @f
        cmp     [ntfs_bCanContinue], 0
        jz      @f
        sub     edx, [ntfs_cur_read]
        neg     edx
        shr     edx, 9
        sub     eax, edx
        mov     [ntfs_cur_size], eax
        jnz     .not_in_cur
@@:
        popad
        ret
.noattr:
.not_in_cur:
        cmp     [ntfs_cur_attr], 0x20
        jz      @f
        mov     ecx, [ntfs_attr_list]
        test    ecx, ecx
        jnz     .lookattr
.ret_is_attr:
        cmp     [ntfs_attr_offs], 1     ; CF set <=> ntfs_attr_offs == 0
        popad
        ret
.lookattr:
; required attribute or required offset was not found in base record;
; it may be present in auxiliary records;
; scan $ATTR_LIST
        mov     eax, [ntfs_attr_iBaseRecord]
        cmp     eax, -1
        jz      @f
        call    ntfs_read_file_record
        test    eax, eax
        jz      .errret
        or      [ntfs_attr_iBaseRecord], -1
@@:
        push    [ntfs_cur_offs]
        push    [ntfs_cur_size]
        push    [ntfs_cur_read]
        push    [ntfs_cur_buf]
        push    dword [ntfs_attr_size]
        push    dword [ntfs_attr_size+4]
        or      dword [ntfs_attr_size], -1
        or      dword [ntfs_attr_size+4], -1
        and     [ntfs_cur_offs], 0
        mov     [ntfs_cur_size], 2
        and     [ntfs_cur_read], 0
        mov     eax, ntfs_attrlist_buf
        cmp     [ntfs_cur_iRecord], 0
        jnz     @f
        mov     eax, ntfs_attrlist_mft_buf
@@:
        mov     [ntfs_cur_buf], eax
        push    eax
        call    .doreadattr
        pop     esi
        mov     edx, 1
        pop     dword [ntfs_attr_size+4]
        pop     dword [ntfs_attr_size]
        mov     ebp, [ntfs_cur_read]
        pop     [ntfs_cur_buf]
        pop     [ntfs_cur_read]
        pop     [ntfs_cur_size]
        pop     [ntfs_cur_offs]
        jc      .errret
        or      edi, -1
        lea     ebp, [ebp+esi-1Ah]
.scanliststart:
        mov     eax, [ntfs_cur_attr]
.scanlist:
        cmp     esi, ebp
        jae     .scanlistdone
        cmp     eax, [esi]
        jz      @f
.scanlistcont:
        movzx   ecx, word [esi+4]
        add     esi, ecx
        jmp     .scanlist
@@:
; ignore named $DATA attributes (aka NTFS streams)
        cmp     eax, 0x80
        jnz     @f
        cmp     byte [esi+6], 0
        jnz     .scanlistcont
@@:
        push    eax
        mov     eax, [esi+8]
        test    eax, eax
        jnz     .testf
        mov     eax, dword [ntfs_attr_size]
        and     eax, dword [ntfs_attr_size+4]
        cmp     eax, -1
        jnz     .testfz
; if attribute is in auxiliary records, its size is defined only in first
        mov     eax, [esi+10h]
        call    ntfs_read_file_record
        test    eax, eax
        jnz     @f
.errret_pop:
        pop     eax
        jmp     .errret
@@:
        mov     eax, [ntfs_data.frs_buffer]
        movzx   ecx, word [eax+14h]
        add     eax, ecx
        mov     ecx, [ntfs_cur_attr]
@@:
        cmp     dword [eax], -1
        jz      .errret_pop
        cmp     dword [eax], ecx
        jz      @f
.l1:
        add     eax, [eax+4]
        jmp     @b
@@:
        cmp     eax, 0x80
        jnz     @f
        cmp     byte [eax+9], 0
        jnz     .l1
@@:
        cmp     byte [eax+8], 0
        jnz     .sdnores
        mov     eax, [eax+10h]
        mov     dword [ntfs_attr_size], eax
        and     dword [ntfs_attr_size+4], 0
        jmp     .testfz
.sdnores:
        mov     ecx, [eax+30h]
        mov     dword [ntfs_attr_size], ecx
        mov     ecx, [eax+34h]
        mov     dword [ntfs_attr_size+4], ecx
.testfz:
        xor     eax, eax
.testf:
        imul    eax, [ntfs_data.sectors_per_cluster]
        cmp     eax, [ntfs_cur_offs]
        pop     eax
        ja      @f
        mov     edi, [esi+10h]  ; keep previous iRecord
        jmp     .scanlistcont
@@:
.scanlistfound:
        cmp     edi, -1
        jnz     @f
        popad
        ret
@@:
        mov     eax, [ntfs_cur_iRecord]
        mov     [ntfs_attr_iBaseRecord], eax
        mov     eax, edi
        jmp     .beginfindattr
.sde:
        popad
        stc
        ret
.scanlistdone:
        sub     ebp, ntfs_attrlist_buf-1Ah
        cmp     [ntfs_cur_iRecord], 0
        jnz     @f
        sub     ebp, ntfs_attrlist_mft_buf-ntfs_attrlist_buf
@@:
        cmp     ebp, 0x400
        jnz     .scanlistfound
        inc     edx
        push    esi edi
        mov     esi, ntfs_attrlist_buf+0x200
        mov     edi, ntfs_attrlist_buf
        cmp     [ntfs_cur_iRecord], 0
        jnz     @f
        mov     esi, ntfs_attrlist_mft_buf+0x200
        mov     edi, ntfs_attrlist_mft_buf
@@:
        mov     ecx, 0x200/4
        rep     movsd
        mov     eax, edi
        pop     edi esi
        sub     esi, 0x200
        push    [ntfs_cur_offs]
        push    [ntfs_cur_size]
        push    [ntfs_cur_read]
        push    [ntfs_cur_buf]
        push    dword [ntfs_attr_size]
        push    dword [ntfs_attr_size+4]
        or      dword [ntfs_attr_size], -1
        or      dword [ntfs_attr_size+4], -1
        mov     [ntfs_cur_offs], edx
        mov     [ntfs_cur_size], 1
        and     [ntfs_cur_read], 0
        mov     [ntfs_cur_buf], eax
        mov     ecx, [ntfs_attr_list]
        push    esi edx
        call    .doreadattr
        pop     edx esi
        mov     ebp, [ntfs_cur_read]
        pop     dword [ntfs_attr_size+4]
        pop     dword [ntfs_attr_size]
        pop     [ntfs_cur_buf]
        pop     [ntfs_cur_read]
        pop     [ntfs_cur_size]
        pop     [ntfs_cur_offs]
        jc      .errret
        add     ebp, ntfs_attrlist_buf+0x200-0x1A
        cmp     [ntfs_cur_iRecord], 0
        jnz     .scanliststart
        add     ebp, ntfs_attrlist_mft_buf-ntfs_attrlist_buf
        jmp     .scanliststart
 
.doreadattr:
        mov     [ntfs_bCanContinue], 0
        cmp     byte [ecx+8], 0
        jnz     .nonresident
        mov     eax, [ecx+10h]  ; length
        mov     esi, eax
        mov     edx, [ntfs_cur_offs]
        shr     eax, 9
        cmp     eax, edx
        jb      .okret
        shl     edx, 9
        sub     esi, edx
        movzx   eax, word [ecx+14h]
        add     edx, eax
        add     edx, ecx        ; edx -> data
        mov     eax, [ntfs_cur_size]
        cmp     eax, (0xFFFFFFFF shr 9)+1
        jbe     @f
        mov     eax, (0xFFFFFFFF shr 9)+1
@@:
        shl     eax, 9
        cmp     eax, esi
        jbe     @f
        mov     eax, esi
@@:
; eax = length, edx -> data
        mov     [ntfs_cur_read], eax
        mov     ecx, eax
        mov     eax, edx
        mov     ebx, [ntfs_cur_buf]
        call    memmove
        and     [ntfs_cur_size], 0      ; CF=0
        ret
.nonresident:
; Not all auxiliary records contain correct FileSize info
        mov     eax, dword [ntfs_attr_size]
        mov     edx, dword [ntfs_attr_size+4]
        push    eax
        and     eax, edx
        cmp     eax, -1
        pop     eax
        jnz     @f
        mov     eax, [ecx+30h]  ; FileSize
        mov     edx, [ecx+34h]
        mov     dword [ntfs_attr_size], eax
        mov     dword [ntfs_attr_size+4], edx
@@:
        add     eax, 0x1FF
        adc     edx, 0
        shrd    eax, edx, 9
        sub     eax, [ntfs_cur_offs]
        ja      @f
; return with nothing read
        and     [ntfs_cur_size], 0
.okret:
        clc
        ret
@@:
; reduce read length
        and     [ntfs_cur_tail], 0
        cmp     [ntfs_cur_size], eax
        jb      @f
        mov     [ntfs_cur_size], eax
        mov     eax, dword [ntfs_attr_size]
        and     eax, 0x1FF
        mov     [ntfs_cur_tail], eax
@@:
        cmp     [ntfs_cur_size], 0
        jz      .okret
        mov     eax, [ntfs_cur_offs]
        xor     edx, edx
        div     [ntfs_data.sectors_per_cluster]
        sub     eax, [ecx+10h]  ; first_vbo
        jb      .okret
; eax = cluster, edx = starting sector
        sub     esp, 10h
        movzx   esi, word [ecx+20h]     ; mcb_info_ofs
        add     esi, ecx
        xor     ebp, ebp
.readloop:
        call    ntfs_decode_mcb_entry
        jnc     .break
        add     ebp, [esp+8]
        sub     eax, [esp]
        jae     .readloop
        push    ecx
        push    eax
        add     eax, [esp+8]
        add     eax, ebp
        imul    eax, [ntfs_data.sectors_per_cluster]
        add     eax, edx
        add     eax, [PARTITION_START]
        pop     ecx
        neg     ecx
        imul    ecx, [ntfs_data.sectors_per_cluster]
        sub     ecx, edx
        cmp     ecx, [ntfs_cur_size]
        jb      @f
        mov     ecx, [ntfs_cur_size]
@@:
        mov     ebx, [ntfs_cur_buf]
@@:
        call    hd_read
        cmp     [hd_error], 0
        jnz     .errread2
        add     ebx, 0x200
        mov     [ntfs_cur_buf], ebx
        inc     eax
        add     [ntfs_cur_read], 0x200
        dec     [ntfs_cur_size]
        inc     [ntfs_cur_offs]
        loop    @b
        pop     ecx
        xor     eax, eax
        xor     edx, edx
        cmp     [ntfs_cur_size], 0
        jnz     .readloop
        add     esp, 10h
        mov     eax, [ntfs_cur_tail]
        test    eax, eax
        jz      @f
        sub     eax, 0x200
        add     [ntfs_cur_read], eax
@@:
        clc
        ret
.errread2:
        pop     ecx
        add     esp, 10h
        stc
        ret
.break:
        add     esp, 10h        ; CF=0
        mov     [ntfs_bCanContinue], 1
        ret
 
ntfs_read_file_record:
; in: eax=iRecord
; out: [ntfs_data.frs_buffer] contains information
;      eax=0 - failed, eax=1 - success
; Read attr $DATA of $Mft, starting from eax*[ntfs_data.frs_size]
        push    ecx edx
        mov     ecx, [ntfs_data.frs_size]
        mul     ecx
        shrd    eax, edx, 9
        shr     edx, 9
        jnz     .err
        push    [ntfs_attr_iRecord]
        push    [ntfs_attr_iBaseRecord]
        push    [ntfs_attr_offs]
        push    [ntfs_attr_list]
        push    dword [ntfs_attr_size+4]
        push    dword [ntfs_attr_size]
        push    [ntfs_cur_iRecord]
        push    [ntfs_cur_attr]
        push    [ntfs_cur_offs]
        push    [ntfs_cur_size]
        push    [ntfs_cur_buf]
        push    [ntfs_cur_read]
        mov     [ntfs_cur_attr], 0x80   ; $DATA
        and     [ntfs_cur_iRecord], 0   ; $Mft
        mov     [ntfs_cur_offs], eax
        shr     ecx, 9
        mov     [ntfs_cur_size], ecx
        mov     eax, [ntfs_data.frs_buffer]
        mov     [ntfs_cur_buf], eax
        call    ntfs_read_attr
        mov     eax, [ntfs_cur_read]
        pop     [ntfs_cur_read]
        pop     [ntfs_cur_buf]
        pop     [ntfs_cur_size]
        pop     [ntfs_cur_offs]
        pop     [ntfs_cur_attr]
        pop     [ntfs_cur_iRecord]
        pop     dword [ntfs_attr_size]
        pop     dword [ntfs_attr_size+4]
        pop     [ntfs_attr_list]
        pop     [ntfs_attr_offs]
        pop     [ntfs_attr_iBaseRecord]
        pop     [ntfs_attr_iRecord]
        pop     edx ecx
        jc      .errret
        cmp     eax, [ntfs_data.frs_size]
        jnz     .errret
        mov     eax, [ntfs_data.frs_buffer]
        cmp     dword [eax], 'FILE'
        jnz     .errret
        push    ebx
        mov     ebx, eax
        call    ntfs_restore_usa_frs
        pop     ebx
        setnc   al
        movzx   eax, al
.ret:
        ret
.err:
        pop     edx ecx
.errret:
        xor     eax, eax
        ret
 
ntfs_restore_usa_frs:
        mov     eax, [ntfs_data.frs_size]
ntfs_restore_usa:
        pushad
        shr     eax, 9
        mov     ecx, eax
        inc     eax
        cmp     [ebx+6], ax
        jnz     .err
        movzx   eax, word [ebx+4]
        lea     esi, [eax+ebx]
        lodsw
        mov     edx, eax
        lea     edi, [ebx+0x1FE]
@@:
        cmp     [edi], dx
        jnz     .err
        lodsw
        stosw
        add     edi, 0x1FE
        loop    @b
        popad
        clc
        ret
.err:
        popad
        stc
        ret
 
ntfs_decode_mcb_entry:
        push    eax ecx edi
        lea     edi, [esp+16]
        xor     eax, eax
        lodsb
        test    al, al
        jz      .end
        mov     ecx, eax
        and     ecx, 0xF
        cmp     ecx, 8
        ja      .end
        push    ecx
        rep     movsb
        pop     ecx
        sub     ecx, 8
        neg     ecx
        cmp     byte [esi-1], 80h
        jae     .end
        push    eax
        xor     eax, eax
        rep     stosb
        pop     ecx
        shr     ecx, 4
        cmp     ecx, 8
        ja      .end
        push    ecx
        rep     movsb
        pop     ecx
        sub     ecx, 8
        neg     ecx
        cmp     byte [esi-1], 80h
        cmc
        sbb     eax, eax
        rep     stosb
        stc
.end:
        pop     edi ecx eax
        ret
 
ntfs_find_lfn:
; in: esi+ebp -> name
; out: CF=1 - file not found
;      else CF=0, [ntfs_cur_iRecord] valid, eax->record in parent directory
        mov     [ntfs_cur_iRecord], 5   ; start parse from root cluster
.doit2:
        mov     [ntfs_cur_attr], 0x90   ; $INDEX_ROOT
        and     [ntfs_cur_offs], 0
        mov     eax, [ntfs_data.cur_index_size]
        mov     [ntfs_cur_size], eax
        mov     eax, [ntfs_data.cur_index_buf]
        mov     [ntfs_cur_buf], eax
        call    ntfs_read_attr
        jnc     @f
.ret:
        ret
@@:
        cmp     [ntfs_cur_read], 0x20
        jc      .ret
        pushad
        mov     esi, [ntfs_data.cur_index_buf]
        mov     eax, [esi+14h]
        add     eax, 10h
        cmp     [ntfs_cur_read], eax
        jae     .readok1
        add     eax, 1FFh
        shr     eax, 9
        cmp     eax, [ntfs_data.cur_index_size]
        ja      @f
.stc_ret:
        popad
        stc
        ret
@@:
; reallocate
        push    eax
        push    [ntfs_data.cur_index_buf]
        call    kernel_free
        pop     eax
        mov     [ntfs_data.cur_index_size], eax
        push    eax
        call    kernel_alloc
        test    eax, eax
        jnz     @f
        and     [ntfs_data.cur_index_size], 0
        and     [ntfs_data.cur_index_buf], 0
        jmp     .stc_ret
@@:
        mov     [ntfs_data.cur_index_buf], eax
        popad
        jmp     .doit2
.readok1:
        mov     ebp, [esi+8]    ; subnode_size
        shr     ebp, 9
        cmp     ebp, [ntfs_data.cur_index_size]
        jbe     .ok2
        push    esi ebp
        push    ebp
        call    kernel_alloc
        pop     ebp esi
        test    eax, eax
        jz      .stc_ret
        mov     edi, eax
        mov     ecx, [ntfs_data.cur_index_size]
        shl     ecx, 9-2
        rep     movsd
        mov     esi, eax
        mov     [ntfs_data.cur_index_size], ebp
        push    esi ebp
        push    [ntfs_data.cur_index_buf]
        call    kernel_free
        pop     ebp esi
        mov     [ntfs_data.cur_index_buf], esi
.ok2:
        add     esi, 10h
        mov     edi, [esp+4]
; edi -> name, esi -> current index data, ebp = subnode size
.scanloop:
        add     esi, [esi]
.scanloopint:
        test    byte [esi+0Ch], 2
        jnz     .subnode
        push    esi
        add     esi, 0x52
        movzx   ecx, byte [esi-2]
        push    edi
@@:
        lodsw
        call    uni2ansi_char
        call    char_toupper
        push    eax
        mov     al, [edi]
        inc     edi
        cmp     al, '/'
        jz      .slash
        call    char_toupper
        cmp     al, [esp]
        pop     eax
        loopz   @b
        jz      .found
        pop     edi
        pop     esi
        jb      .subnode
.scanloopcont:
        movzx   eax, word [esi+8]
        add     esi, eax
        jmp     .scanloopint
.slash:
        pop     eax
        pop     edi
        pop     esi
.subnode:
        test    byte [esi+0Ch], 1
        jz      .notfound
        movzx   eax, word [esi+8]
        mov     eax, [esi+eax-8]
        mul     [ntfs_data.sectors_per_cluster]
        mov     [ntfs_cur_offs], eax
        mov     [ntfs_cur_attr], 0xA0   ; $INDEX_ALLOCATION
        mov     [ntfs_cur_size], ebp
        mov     eax, [ntfs_data.cur_index_buf]
        mov     esi, eax
        mov     [ntfs_cur_buf], eax
        call    ntfs_read_attr
        mov     eax, ebp
        shl     eax, 9
        cmp     [ntfs_cur_read], eax
        jnz     .notfound
        cmp     dword [esi], 'INDX'
        jnz     .notfound
        mov     ebx, esi
        call    ntfs_restore_usa
        jc      .notfound
        add     esi, 0x18
        jmp     .scanloop
.notfound:
        popad
        stc
        ret
.found:
        cmp     byte [edi], 0
        jz      .done
        cmp     byte [edi], '/'
        jz      .next
        pop     edi
        pop     esi
        jmp     .scanloopcont
.done:
.next:
        pop     esi
        pop     esi
        mov     eax, [esi]
        mov     [ntfs_cur_iRecord], eax
        mov     [esp+1Ch], esi
        mov     [esp+4], edi
        popad
        inc     esi
        cmp     byte [esi-1], 0
        jnz     .doit2
        test    ebp, ebp
        jz      @f
        mov     esi, ebp
        xor     ebp, ebp
        jmp     .doit2
@@:
        ret
 
;----------------------------------------------------------------
;
;  ntfs_HdRead - read NTFS hard disk
;
;  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+
;  edx  mem location to return data
;
;  ret ebx = bytes read or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
ntfs_HdRead:
        cmp     byte [esi], 0
        jnz     @f
        or      ebx, -1
        push    ERROR_ACCESS_DENIED
        pop     eax
        ret
@@:
        call    ntfs_find_lfn
        jnc     .found
        or      ebx, -1
        push    ERROR_FILE_NOT_FOUND
        pop     eax
        ret
.found:
        mov     [ntfs_cur_attr], 0x80   ; $DATA
        and     [ntfs_cur_offs], 0
        and     [ntfs_cur_size], 0
        call    ntfs_read_attr
        jnc     @f
        or      ebx, -1
        push    ERROR_ACCESS_DENIED
        pop     eax
        ret
@@:
        pushad
        and     dword [esp+10h], 0
        xor     eax, eax
        test    ebx, ebx
        jz      .zero1
        cmp     dword [ebx+4], 0x200
        jb      @f
.eof0:
        popad
        xor     ebx, ebx
.eof:
        push    ERROR_END_OF_FILE
        pop     eax
        ret
@@:
        mov     eax, [ebx]
        test    eax, 0x1FF
        jz      .alignedstart
        push    edx
        mov     edx, [ebx+4]
        shrd    eax, edx, 9
        pop     edx
        mov     [ntfs_cur_offs], eax
        mov     [ntfs_cur_size], 1
        mov     [ntfs_cur_buf], ntfs_bitmap_buf
        call    ntfs_read_attr.continue
        mov     eax, [ebx]
        and     eax, 0x1FF
        lea     esi, [ntfs_bitmap_buf+eax]
        sub     eax, [ntfs_cur_read]
        jae     .eof0
        neg     eax
        push    ecx
        cmp     ecx, eax
        jb      @f
        mov     ecx, eax
@@:
        mov     [esp+10h+4], ecx
        mov     edi, edx
        rep     movsb
        mov     edx, edi
        pop     ecx
        sub     ecx, [esp+10h]
        jnz     @f
.retok:
        popad
        xor     eax, eax
        ret
@@:
        cmp     [ntfs_cur_read], 0x200
        jz      .alignedstart
.eof_ebx:
        popad
        jmp     .eof
.alignedstart:
        mov     eax, [ebx]
        push    edx
        mov     edx, [ebx+4]
        add     eax, 511
        adc     edx, 0
        shrd    eax, edx, 9
        pop     edx
.zero1:
        mov     [ntfs_cur_offs], eax
        mov     [ntfs_cur_buf], edx
        mov     eax, ecx
        shr     eax, 9
        mov     [ntfs_cur_size], eax
        add     eax, [ntfs_cur_offs]
        push    eax
        call    ntfs_read_attr.continue
        pop     [ntfs_cur_offs]
        mov     eax, [ntfs_cur_read]
        add     [esp+10h], eax
        mov     eax, ecx
        and     eax, not 0x1FF
        cmp     [ntfs_cur_read], eax
        jnz     .eof_ebx
        and     ecx, 0x1FF
        jz      .retok
        add     edx, [ntfs_cur_read]
        mov     [ntfs_cur_size], 1
        mov     [ntfs_cur_buf], ntfs_bitmap_buf
        call    ntfs_read_attr.continue
        cmp     [ntfs_cur_read], ecx
        jb      @f
        mov     [ntfs_cur_read], ecx
@@:
        xchg    ecx, [ntfs_cur_read]
        push    ecx
        mov     edi, edx
        mov     esi, ntfs_bitmap_buf
        add     [esp+10h+4], ecx
        rep     movsb
        pop     ecx
        xor     eax, eax
        cmp     ecx, [ntfs_cur_read]
        jz      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [esp+1Ch], eax
        popad
        ret
 
;----------------------------------------------------------------
;
;  ntfs_HdReadFolder - read NTFS hard disk folder
;
;  esi  points to filename
;  ebx  pointer to structure 32-bit number = first wanted block, 0+
;                          & flags (bitfields)
; flags: bit 0: 0=ANSI names, 1=UNICODE names
;  ecx  number of blocks to read, 0+
;  edx  mem location to return data
;
;  ret ebx = blocks read or 0xffffffff folder not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
ntfs_HdReadFolder:
 
        mov     eax, 5          ; root cluster
        cmp     byte [esi], 0
        jz      .doit
        call    ntfs_find_lfn
        jnc     .doit2
.notfound:
        or      ebx, -1
        push    ERROR_FILE_NOT_FOUND
.pop_ret:
        pop     eax
        ret
.doit:
        mov     [ntfs_cur_iRecord], eax
.doit2:
        mov     [ntfs_cur_attr], 0x10   ; $STANDARD_INFORMATION
        and     [ntfs_cur_offs], 0
        mov     [ntfs_cur_size], 1
        mov     [ntfs_cur_buf], ntfs_bitmap_buf
        call    ntfs_read_attr
        jc      .notfound
        mov     [ntfs_cur_attr], 0x90   ; $INDEX_ROOT
        and     [ntfs_cur_offs], 0
        mov     eax, [ntfs_data.cur_index_size]
        mov     [ntfs_cur_size], eax
        mov     eax, [ntfs_data.cur_index_buf]
        mov     [ntfs_cur_buf], eax
        call    ntfs_read_attr
        jnc     .ok
        cmp     [hd_error], 0
        jz      .notfound
        or      ebx, -1
        push    11
        jmp     .pop_ret
.ok:
        cmp     [ntfs_cur_read], 0x20
        jae     @f
        or      ebx, -1
.fserr:
        push    ERROR_FAT_TABLE
        jmp     .pop_ret
@@:
        pushad
        mov     esi, [ntfs_data.cur_index_buf]
        mov     eax, [esi+14h]
        add     eax, 10h
        cmp     [ntfs_cur_read], eax
        jae     .readok1
        add     eax, 1FFh
        shr     eax, 9
        cmp     eax, [ntfs_data.cur_index_size]
        ja      @f
        popad
        jmp     .fserr
@@:
; reallocate
        push    eax
        push    [ntfs_data.cur_index_buf]
        call    kernel_free
        pop     eax
        mov     [ntfs_data.cur_index_size], eax
        push    eax
        call    kernel_alloc
        test    eax, eax
        jnz     @f
        and     [ntfs_data.cur_index_size], 0
        and     [ntfs_data.cur_index_buf], 0
.nomem:
        popad
        or      ebx, -1
        push    12
        pop     eax
        ret
@@:
        mov     [ntfs_data.cur_index_buf], eax
        popad
        jmp     .doit2
.readok1:
        mov     ebp, [esi+8]    ; subnode_size
        shr     ebp, 9
        cmp     ebp, [ntfs_data.cur_index_size]
        jbe     .ok2
        push    esi ebp
        push    ebp
        call    kernel_alloc
        pop     ebp esi
        test    eax, eax
        jz      .nomem
        mov     edi, eax
        mov     ecx, [ntfs_data.cur_index_size]
        shl     ecx, 9-2
        rep     movsd
        mov     esi, eax
        mov     [ntfs_data.cur_index_size], ebp
        push    esi ebp
        push    [ntfs_data.cur_index_buf]
        call    kernel_free
        pop     ebp esi
        mov     [ntfs_data.cur_index_buf], esi
.ok2:
        add     esi, 10h
        mov     ebx, [esp+10h]
        mov     edx, [esp+14h]
        push    dword [ebx+4]   ; read ANSI/UNICODE name
        mov     ebx, [ebx]
; init header
        mov     edi, edx
        mov     ecx, 32/4
        xor     eax, eax
        rep     stosd
        mov     byte [edx], 1   ; version
        mov     ecx, [esp+4+18h]
        push    edx
        mov     edx, esp
; edi -> BDFE, esi -> current index data, ebp = subnode size, ebx = first wanted block,
; ecx = number of blocks to read
; edx -> parameters block: dd , dd 
        cmp     [ntfs_cur_iRecord], 5
        jz      .skip_specials
; dot and dotdot entries
        push    esi
        xor     esi, esi
        call    .add_special_entry
        inc     esi
        call    .add_special_entry
        pop     esi
.skip_specials:
; at first, dump index root
        add     esi, [esi]
.dump_root:
        test    byte [esi+0Ch], 2
        jnz     .dump_root_done
        call    .add_entry
        movzx   eax, word [esi+8]
        add     esi, eax
        jmp     .dump_root
.dump_root_done:
; now dump all subnodes
        push    ecx edi
        mov     edi, ntfs_bitmap_buf
        mov     [ntfs_cur_buf], edi
        mov     ecx, 0x400/4
        xor     eax, eax
        rep     stosd
        mov     [ntfs_cur_attr], 0xB0   ; $BITMAP
        and     [ntfs_cur_offs], 0
        mov     [ntfs_cur_size], 2
        call    ntfs_read_attr
        pop     edi ecx
        push    0       ; save offset in $BITMAP attribute
        and     [ntfs_cur_offs], 0
.dumploop:
        mov     [ntfs_cur_attr], 0xA0
        mov     [ntfs_cur_size], ebp
        mov     eax, [ntfs_data.cur_index_buf]
        mov     esi, eax
        mov     [ntfs_cur_buf], eax
        push    [ntfs_cur_offs]
        mov     eax, [ntfs_cur_offs]
        imul    eax, ebp
        mov     [ntfs_cur_offs], eax
        call    ntfs_read_attr
        pop     [ntfs_cur_offs]
        mov     eax, ebp
        shl     eax, 9
        cmp     [ntfs_cur_read], eax
        jnz     .done
        push    eax
        mov     eax, [ntfs_cur_offs]
        and     eax, 0x400*8-1
        bt      dword [ntfs_bitmap_buf], eax
        pop     eax
        jnc     .dump_subnode_done
        cmp     dword [esi], 'INDX'
        jnz     .dump_subnode_done
        push    ebx
        mov     ebx, esi
        call    ntfs_restore_usa
        pop     ebx
        jc      .dump_subnode_done
        add     esi, 0x18
        add     esi, [esi]
.dump_subnode:
        test    byte [esi+0Ch], 2
        jnz     .dump_subnode_done
        call    .add_entry
        movzx   eax, word [esi+8]
        add     esi, eax
        jmp     .dump_subnode
.dump_subnode_done:
        inc     [ntfs_cur_offs]
        test    [ntfs_cur_offs], 0x400*8-1
        jnz     .dumploop
        mov     [ntfs_cur_attr], 0xB0
        push    ecx edi
        mov     edi, ntfs_bitmap_buf
        mov     [ntfs_cur_buf], edi
        mov     ecx, 0x400/4
        xor     eax, eax
        rep     stosd
        pop     edi ecx
        pop     eax
        push    [ntfs_cur_offs]
        inc     eax
        mov     [ntfs_cur_offs], eax
        mov     [ntfs_cur_size], 2
        push    eax
        call    ntfs_read_attr
        pop     eax
        pop     [ntfs_cur_offs]
        push    eax
        jmp     .dumploop
.done:
        pop     eax
        pop     edx
        mov     ebx, [edx+4]
        pop     edx
        xor     eax, eax
        dec     ecx
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        mov     [esp+1Ch], eax
        mov     [esp+10h], ebx
        popad
        ret
 
.add_special_entry:
        mov     eax, [edx]
        inc     dword [eax+8]   ; new file found
        dec     ebx
        jns     .ret
        dec     ecx
        js      .ret
        inc     dword [eax+4]   ; new file block copied
        mov     eax, [edx+4]
        mov     [edi+4], eax
;        mov     eax, dword [ntfs_bitmap_buf+0x20]
;        or      al, 0x10
        mov     eax, 0x10
        stosd
        scasd
        push    edx
        mov     eax, dword [ntfs_bitmap_buf]
        mov     edx, dword [ntfs_bitmap_buf+4]
        call    ntfs_datetime_to_bdfe
        mov     eax, dword [ntfs_bitmap_buf+0x18]
        mov     edx, dword [ntfs_bitmap_buf+0x1C]
        call    ntfs_datetime_to_bdfe
        mov     eax, dword [ntfs_bitmap_buf+8]
        mov     edx, dword [ntfs_bitmap_buf+0xC]
        call    ntfs_datetime_to_bdfe
        pop     edx
        xor     eax, eax
        stosd
        stosd
        mov     al, '.'
        push    edi ecx
        lea     ecx, [esi+1]
        test    byte [edi-0x24], 1
        jz      @f
        rep     stosw
        pop     ecx
        xor     eax, eax
        stosw
        pop     edi
        add     edi, 520
        ret
@@:
        rep     stosb
        pop     ecx
        xor     eax, eax
        stosb
        pop     edi
        add     edi, 264
.ret:
        ret
 
.add_entry:
; do not return DOS 8.3 names
        cmp     byte [esi+0x51], 2
        jz      .ret
; do not return system files
; ... note that there will be no bad effects if system files also were reported ...
        cmp     dword [esi], 0x10
        jb      .ret
        mov     eax, [edx]
        inc     dword [eax+8]   ; new file found
        dec     ebx
        jns     .ret
        dec     ecx
        js      .ret
        inc     dword [eax+4]   ; new file block copied
        mov     eax, [edx+4]    ; flags
        call    ntfs_direntry_to_bdfe
        push    ecx esi edi
        movzx   ecx, byte [esi+0x50]
        add     esi, 0x52
        test    byte [edi-0x24], 1
        jz      .ansi
        shr     ecx, 1
        rep     movsd
        adc     ecx, ecx
        rep     movsw
        and     word [edi], 0
        pop     edi
        add     edi, 520
        pop     esi ecx
        ret
.ansi:
        jecxz   .skip
@@:
        lodsw
        call    uni2ansi_char
        stosb
        loop    @b
.skip:
        xor     al, al
        stosb
        pop     edi
        add     edi, 264
        pop     esi ecx
        ret
 
ntfs_direntry_to_bdfe:
        mov     [edi+4], eax    ; ANSI/UNICODE name
        mov     eax, [esi+48h]
        test    eax, 0x10000000
        jz      @f
        and     eax, not 0x10000000
        or      al, 0x10
@@:
        stosd
        scasd
        push    edx
        mov     eax, [esi+0x18]
        mov     edx, [esi+0x1C]
        call    ntfs_datetime_to_bdfe
        mov     eax, [esi+0x30]
        mov     edx, [esi+0x34]
        call    ntfs_datetime_to_bdfe
        mov     eax, [esi+0x20]
        mov     edx, [esi+0x24]
        call    ntfs_datetime_to_bdfe
        pop     edx
        mov     eax, [esi+0x40]
        stosd
        mov     eax, [esi+0x44]
        stosd
        ret
 
iglobal
_24             dd      24
_60             dd      60
_10000000       dd      10000000
days400year     dd      365*400+100-4+1
days100year     dd      365*100+25-1
days4year       dd      365*4+1
days1year       dd      365
months  dd      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
months2 dd      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
_400            dd      400
_100            dd      100
endg
 
ntfs_datetime_to_bdfe:
; edx:eax = number of 100-nanosecond intervals since January 1, 1601, in UTC
        push    eax
        mov     eax, edx
        xor     edx, edx
        div     [_10000000]
        xchg    eax, [esp]
        div     [_10000000]
        pop     edx
; edx:eax = number of seconds since January 1, 1601
        push    eax
        mov     eax, edx
        xor     edx, edx
        div     [_60]
        xchg    eax, [esp]
        div     [_60]
        mov     [edi], dl
        pop     edx
; edx:eax = number of minutes
        div     [_60]
        mov     [edi+1], dl
; eax = number of hours (note that 2^64/(10^7*60*60) < 2^32)
        xor     edx, edx
        div     [_24]
        mov     [edi+2], dl
        mov     [edi+3], byte 0
; eax = number of days since January 1, 1601
        xor     edx, edx
        div     [days400year]
        imul    eax, 400
        add     eax, 1601
        mov     [edi+6], ax
        mov     eax, edx
        xor     edx, edx
        div     [days100year]
        cmp     al, 4
        jnz     @f
        dec     eax
        add     edx, [days100year]
@@:
        imul    eax, 100
        add     [edi+6], ax
        mov     eax, edx
        xor     edx, edx
        div     [days4year]
        shl     eax, 2
        add     [edi+6], ax
        mov     eax, edx
        xor     edx, edx
        div     [days1year]
        cmp     al, 4
        jnz     @f
        dec     eax
        add     edx, [days1year]
@@:
        add     [edi+6], ax
        push    esi edx
        mov     esi, months
        movzx   eax, word [edi+6]
        test    al, 3
        jnz     .noleap
        xor     edx, edx
        push    eax
        div     [_400]
        pop     eax
        test    edx, edx
        jz      .leap
        xor     edx, edx
        div     [_100]
        test    edx, edx
        jz      .noleap
.leap:
        mov     esi, months2
.noleap:
        pop     edx
        xor     eax, eax
        inc     eax
@@:
        sub     edx, [esi]
        jb      @f
        add     esi, 4
        inc     eax
        jmp     @b
@@:
        add     edx, [esi]
        pop     esi
        inc     edx
        mov     [edi+4], dl
        mov     [edi+5], al
        add     edi, 8
        ret
 
;----------------------------------------------------------------
;
;  ntfs_HdRewrite - write to NTFS hard disk
;
;  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
;
;--------------------------------------------------------------
ntfs_HdRewrite:
        xor     ebx, ebx
        mov     eax, ERROR_UNSUPPORTED_FS
        ret
 
;----------------------------------------------------------------
;
;  ntfs_HdWrite - write to NTFS hard disk
;
;  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
;
;--------------------------------------------------------------
ntfs_HdWrite:
        xor     ebx, ebx
        mov     eax, ERROR_UNSUPPORTED_FS
        ret
 
;----------------------------------------------------------------
;
;  ntfs_HdSetFileEnd - set end of file on NTFS hard disk
;
;  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
;
;--------------------------------------------------------------
ntfs_HdSetFileEnd:
ntfs_HdSetFileInfo:
;----------------------------------------------------------------
;
;  ntfs_HdDelete - delete file or empty folder from NTFS hard disk
;
;  esi  points to filename
;
;  ret  eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
ntfs_HdDelete:
        mov     eax, ERROR_UNSUPPORTED_FS
        ret
 
ntfs_HdGetFileInfo:
        cmp     byte [esi], 0
        jnz     @f
        push    2
        pop     eax
        ret
@@:
        call    ntfs_find_lfn
        jnc     .doit
        push    ERROR_FILE_NOT_FOUND
        pop     eax
        cmp     [hd_error], 0
        jz      @f
        mov     al, 11
@@:
        ret
.doit:
        push    esi edi
        mov     esi, eax
        mov     edi, edx
        xor     eax, eax
        call    ntfs_direntry_to_bdfe
        pop     edi esi
        xor     eax, eax
        ret
 

Rev 1378	Rev 1379
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 1378 $	8	$Revision: 1379 $
9		9
10		10
11	ntfs_test_bootsec:	11	ntfs_test_bootsec:
12	; in: ebx->buffer, edx=size of partition	12	; in: ebx->buffer, edx=size of partition
13	; out: CF set <=> invalid	13	; out: CF set <=> invalid
14	; 1. Name=='NTFS '	14	; 1. Name=='NTFS '
15	cmp dword [ebx+3], 'NTFS'	15	cmp dword [ebx+3], 'NTFS'
16	jnz .no	16	jnz .no
17	cmp dword [ebx+7], ' '	17	cmp dword [ebx+7], ' '
18	jnz .no	18	jnz .no
19	; 2. Number of bytes per sector is the same as for physical device	19	; 2. Number of bytes per sector is the same as for physical device
20	; (that is, 0x200 for hard disk)	20	; (that is, 0x200 for hard disk)
21	cmp word [ebx+11], 0x200	21	cmp word [ebx+11], 0x200
22	jnz .no	22	jnz .no
23	; 3. Number of sectors per cluster must be power of 2	23	; 3. Number of sectors per cluster must be power of 2
24	movzx eax, byte [ebx+13]	24	movzx eax, byte [ebx+13]
25	dec eax	25	dec eax
26	js .no	26	js .no
27	test al, [ebx+13]	27	test al, [ebx+13]
28	jnz .no	28	jnz .no
29	; 4. FAT parameters must be zero	29	; 4. FAT parameters must be zero
30	cmp word [ebx+14], 0	30	cmp word [ebx+14], 0
31	jnz .no	31	jnz .no
32	cmp dword [ebx+16], 0	32	cmp dword [ebx+16], 0
33	jnz .no	33	jnz .no
34	cmp byte [ebx+20], 0	34	cmp byte [ebx+20], 0
35	jnz .no	35	jnz .no
36	cmp word [ebx+22], 0	36	cmp word [ebx+22], 0
37	jnz .no	37	jnz .no
38	cmp dword [ebx+32], 0	38	cmp dword [ebx+32], 0
39	jnz .no	39	jnz .no
40	; 5. Number of sectors <= partition size	40	; 5. Number of sectors <= partition size
41	cmp dword [ebx+0x2C], 0	41	cmp dword [ebx+0x2C], 0
42	ja .no	42	ja .no
43	cmp [ebx+0x28], edx	43	cmp [ebx+0x28], edx
44	ja .no	44	ja .no
45	; 6. $MFT and $MFTMirr clusters must be within partition	45	; 6. $MFT and $MFTMirr clusters must be within partition
46	cmp dword [ebx+0x34], 0	46	cmp dword [ebx+0x34], 0
47	ja .no	47	ja .no
48	push edx	48	push edx
49	movzx eax, byte [ebx+13]	49	movzx eax, byte [ebx+13]
50	mul dword [ebx+0x30]	50	mul dword [ebx+0x30]
51	test edx, edx	51	test edx, edx
52	pop edx	52	pop edx
53	jnz .no	53	jnz .no
54	cmp eax, edx	54	cmp eax, edx
55	ja .no	55	ja .no
56	cmp dword [ebx+0x3C], 0	56	cmp dword [ebx+0x3C], 0
57	ja .no	57	ja .no
58	push edx	58	push edx
59	movzx eax, byte [ebx+13]	59	movzx eax, byte [ebx+13]
60	mul dword [ebx+0x38]	60	mul dword [ebx+0x38]
61	test edx, edx	61	test edx, edx
62	pop edx	62	pop edx
63	jnz .no	63	jnz .no
64	cmp eax, edx	64	cmp eax, edx
65	ja .no	65	ja .no
66	; 7. Clusters per FRS must be either negative and in [-31,-9] or positive and power of 2	66	; 7. Clusters per FRS must be either negative and in [-31,-9] or positive and power of 2
67	movsx eax, byte [ebx+0x40]	67	movsx eax, byte [ebx+0x40]
68	cmp al, -31	68	cmp al, -31
69	jl .no	69	jl .no
70	cmp al, -9	70	cmp al, -9
71	jle @f	71	jle @f
72	dec eax	72	dec eax
73	js .no	73	js .no
74	test [ebx+0x40], al	74	test [ebx+0x40], al
75	jnz .no	75	jnz .no
76	@@:	76	@@:
77	; 8. Same for clusters per IndexAllocationBuffer	77	; 8. Same for clusters per IndexAllocationBuffer
78	movsx eax, byte [ebx+0x44]	78	movsx eax, byte [ebx+0x44]
79	cmp al, -31	79	cmp al, -31
80	jl .no	80	jl .no
81	cmp al, -9	81	cmp al, -9
82	jle @f	82	jle @f
83	dec eax	83	dec eax
84	js .no	84	js .no
85	test [ebx+0x44], al	85	test [ebx+0x44], al
86	jnz .no	86	jnz .no
87	@@:	87	@@:
88	; OK, this is correct NTFS bootsector	88	; OK, this is correct NTFS bootsector
89	clc	89	clc
90	ret	90	ret
91	.no:	91	.no:
92	; No, this bootsector isn't NTFS	92	; No, this bootsector isn't NTFS
93	stc	93	stc
94	ret	94	ret
95		95
96	ntfs_setup: ; CODE XREF: part_set.inc	96	ntfs_setup: ; CODE XREF: part_set.inc
97	; By given bootsector, initialize some NTFS variables	97	; By given bootsector, initialize some NTFS variables
98	; call ntfs_test_bootsec	98	; call ntfs_test_bootsec ; checking boot sector was already
99	; jc problem_fat_dec_count	99	; jc problem_fat_dec_count
100	movzx eax, byte [ebx+13]	100	movzx eax, byte [ebx+13]
101	mov [ntfs_data.sectors_per_cluster], eax	101	mov [ntfs_data.sectors_per_cluster], eax
102	mov eax, [ebx+0x28]	102	mov eax, [ebx+0x28]
103	add eax, [PARTITION_START]	103	add eax, [PARTITION_START]
104	dec eax	104	dec eax
105	mov [PARTITION_END], eax	105	mov [PARTITION_END], eax
106	mov [fs_type], 1	106	mov [fs_type], 1
107	mov eax, [ebx+0x30]	107	mov eax, [ebx+0x30]
108	mov [ntfs_data.mft_cluster], eax	108	mov [ntfs_data.mft_cluster], eax
109	mov eax, [ebx+0x38]	109	mov eax, [ebx+0x38]
110	mov [ntfs_data.mftmirr_cluster], eax	110	mov [ntfs_data.mftmirr_cluster], eax
111	movsx eax, byte [ebx+0x40]	111	movsx eax, byte [ebx+0x40]
112	test eax, eax	112	test eax, eax
113	js .1	113	js .1
114	mul [ntfs_data.sectors_per_cluster]	114	mul [ntfs_data.sectors_per_cluster]
115	shl eax, 9	115	shl eax, 9
116	jmp .2	116	jmp .2
117	.1:	117	.1:
118	neg eax	118	neg eax
119	mov ecx, eax	119	mov ecx, eax
120	mov eax, 1	120	mov eax, 1
121	shl eax, cl	121	shl eax, cl
122	.2:	122	.2:
123	mov [ntfs_data.frs_size], eax	123	mov [ntfs_data.frs_size], eax
124	movsx eax, byte [ebx+0x44]	124	movsx eax, byte [ebx+0x44]
125	test eax, eax	125	test eax, eax
126	js .3	126	js .3
127	mul [ntfs_data.sectors_per_cluster]	127	mul [ntfs_data.sectors_per_cluster]
128	shl eax, 9	128	shl eax, 9
129	jmp .4	129	jmp .4
130	.3:	130	.3:
131	neg eax	131	neg eax
132	mov ecx, eax	132	mov ecx, eax
133	mov eax, 1	133	mov eax, 1
134	shl eax, cl	134	shl eax, cl
135	.4:	135	.4:
136	mov [ntfs_data.iab_size], eax	136	mov [ntfs_data.iab_size], eax
137	; allocate space for buffers	137	; allocate space for buffers
138	add eax, [ntfs_data.frs_size]	138	add eax, [ntfs_data.frs_size]
139	push eax	139	push eax
140	call kernel_alloc	140	call kernel_alloc
141	test eax, eax	141	test eax, eax
142	jz problem_fat_dec_count	142	jz problem_fat_dec_count
143	mov [ntfs_data.frs_buffer], eax	143	mov [ntfs_data.frs_buffer], eax
144	add eax, [ntfs_data.frs_size]	144	add eax, [ntfs_data.frs_size]
145	mov [ntfs_data.iab_buffer], eax	145	mov [ntfs_data.iab_buffer], eax
146	; read $MFT disposition	146	; read $MFT disposition
147	mov eax, [ntfs_data.mft_cluster]	147	mov eax, [ntfs_data.mft_cluster]
148	mul [ntfs_data.sectors_per_cluster]	148	mul [ntfs_data.sectors_per_cluster]
149	call ntfs_read_frs_sector	149	call ntfs_read_frs_sector
150	cmp [hd_error], 0	150	cmp [hd_error], 0
151	jnz .usemirr	151	jnz .usemirr
152	cmp dword [ebx], 'FILE'	152	cmp dword [ebx], 'FILE'
153	jnz .usemirr	153	jnz .usemirr
154	call ntfs_restore_usa_frs	154	call ntfs_restore_usa_frs
155	jnc .mftok	155	jnc .mftok
156	.usemirr:	156	.usemirr:
157	and [hd_error], 0	157	and [hd_error], 0
158	mov eax, [ntfs_data.mftmirr_cluster]	158	mov eax, [ntfs_data.mftmirr_cluster]
159	mul [ntfs_data.sectors_per_cluster]	159	mul [ntfs_data.sectors_per_cluster]
160	call ntfs_read_frs_sector	160	call ntfs_read_frs_sector
161	cmp [hd_error], 0	161	cmp [hd_error], 0
162	jnz @f	162	jnz @f
163	cmp dword [ebx], 'FILE'	163	cmp dword [ebx], 'FILE'
164	jnz @f	164	jnz @f
165	call ntfs_restore_usa_frs	165	call ntfs_restore_usa_frs
166	jnc .mftok	166	jnc .mftok
167	@@:	167	@@:
168	; $MFT and $MFTMirr invalid!	168	; $MFT and $MFTMirr invalid!
169	.fail_free_frs:	169	.fail_free_frs:
170	push [ntfs_data.frs_buffer]	170	push [ntfs_data.frs_buffer]
171	call kernel_free	171	call kernel_free
172	jmp problem_fat_dec_count	172	jmp problem_fat_dec_count
173	.fail_free_mft:	173	.fail_free_mft:
174	push [ntfs_data.mft_retrieval]	174	push [ntfs_data.mft_retrieval]
175	call kernel_free	175	call kernel_free
176	jmp .fail_free_frs	176	jmp .fail_free_frs
177	.mftok:	177	.mftok:
178	; read $MFT table retrieval information	178	; read $MFT table retrieval information
179	; start with one page, increase if not enough (when MFT too fragmented)	179	; start with one page, increase if not enough (when MFT too fragmented)
180	push ebx	180	push ebx
181	push 0x1000	181	push 0x1000
182	call kernel_alloc	182	call kernel_alloc
183	pop ebx	183	pop ebx
184	test eax, eax	184	test eax, eax
185	jz .fail_free_frs	185	jz .fail_free_frs
186	mov [ntfs_data.mft_retrieval], eax	186	mov [ntfs_data.mft_retrieval], eax
187	and [ntfs_data.mft_retrieval_size], 0	187	and [ntfs_data.mft_retrieval_size], 0
188	mov [ntfs_data.mft_retrieval_alloc], 0x1000/8	188	mov [ntfs_data.mft_retrieval_alloc], 0x1000/8
189	; $MFT base record must contain unnamed non-resident $DATA attribute	189	; $MFT base record must contain unnamed non-resident $DATA attribute
190	movzx eax, word [ebx+14h]	190	movzx eax, word [ebx+14h]
191	add eax, ebx	191	add eax, ebx
192	.scandata:	192	.scandata:
193	cmp dword [eax], -1	193	cmp dword [eax], -1
194	jz .fail_free_mft	194	jz .fail_free_mft
195	cmp dword [eax], 0x80	195	cmp dword [eax], 0x80
196	jnz @f	196	jnz @f
197	cmp byte [eax+9], 0	197	cmp byte [eax+9], 0
198	jz .founddata	198	jz .founddata
199	@@:	199	@@:
200	add eax, [eax+4]	200	add eax, [eax+4]
201	jmp .scandata	201	jmp .scandata
202	.founddata:	202	.founddata:
203	cmp byte [eax+8], 0	203	cmp byte [eax+8], 0
204	jz .fail_free_mft	204	jz .fail_free_mft
205	; load first portion of $DATA attribute retrieval information	205	; load first portion of $DATA attribute retrieval information
206	mov edx, [eax+0x18]	206	mov edx, [eax+0x18]
207	mov [ntfs_data.mft_retrieval_end], edx	207	mov [ntfs_data.mft_retrieval_end], edx
208	mov esi, eax	208	mov esi, eax
209	movzx eax, word [eax+0x20]	209	movzx eax, word [eax+0x20]
210	add esi, eax	210	add esi, eax
211	sub esp, 10h	211	sub esp, 10h
212	.scanmcb:	212	.scanmcb:
213	call ntfs_decode_mcb_entry	213	call ntfs_decode_mcb_entry
214	jnc .scanmcbend	214	jnc .scanmcbend
215	call .get_mft_retrieval_ptr	215	call .get_mft_retrieval_ptr
216	mov edx, [esp] ; block length	216	mov edx, [esp] ; block length
217	mov [eax], edx	217	mov [eax], edx
218	mov edx, [esp+8] ; block addr (relative)	218	mov edx, [esp+8] ; block addr (relative)
219	mov [eax+4], edx	219	mov [eax+4], edx
220	inc [ntfs_data.mft_retrieval_size]	220	inc [ntfs_data.mft_retrieval_size]
221	jmp .scanmcb	221	jmp .scanmcb
222	.scanmcbend:	222	.scanmcbend:
223	add esp, 10h	223	add esp, 10h
224	; there may be other portions of $DATA attribute in auxiliary records;	224	; there may be other portions of $DATA attribute in auxiliary records;
225	; if they will be needed, they will be loaded later	225	; if they will be needed, they will be loaded later
226		226
227	mov [ntfs_data.cur_index_size], 0x1000/0x200	227	mov [ntfs_data.cur_index_size], 0x1000/0x200
228	push 0x1000	228	push 0x1000
229	call kernel_alloc	229	call kernel_alloc
230	test eax, eax	230	test eax, eax
231	jz .fail_free_mft	231	jz .fail_free_mft
232	mov [ntfs_data.cur_index_buf], eax	232	mov [ntfs_data.cur_index_buf], eax
233		233
234	popad	234	popad
235	call free_hd_channel	235	call free_hd_channel
236	and [hd1_status], 0	236	and [hd1_status], 0
237	ret	237	ret
238		238
239	.get_mft_retrieval_ptr:	239	.get_mft_retrieval_ptr:
240	pushad	240	pushad
241	mov eax, [ntfs_data.mft_retrieval_size]	241	mov eax, [ntfs_data.mft_retrieval_size]
242	cmp eax, [ntfs_data.mft_retrieval_alloc]	242	cmp eax, [ntfs_data.mft_retrieval_alloc]
243	jnz .ok	243	jnz .ok
244	add eax, 0x1000/8	244	add eax, 0x1000/8
245	mov [ntfs_data.mft_retrieval_alloc], eax	245	mov [ntfs_data.mft_retrieval_alloc], eax
246	shl eax, 3	246	shl eax, 3
247	push eax	247	push eax
248	call kernel_alloc	248	call kernel_alloc
249	test eax, eax	249	test eax, eax
250	jnz @f	250	jnz @f
251	popad	251	popad
252	add esp, 14h	252	add esp, 14h
253	jmp .fail_free_mft	253	jmp .fail_free_mft
254	@@:	254	@@:
255	mov esi, [ntfs_data.mft_retrieval]	255	mov esi, [ntfs_data.mft_retrieval]
256	mov edi, eax	256	mov edi, eax
257	mov ecx, [ntfs_data.mft_retrieval_size]	257	mov ecx, [ntfs_data.mft_retrieval_size]
258	add ecx, ecx	258	add ecx, ecx
259	rep movsd	259	rep movsd
260	push [ntfs_data.mft_retrieval]	260	push [ntfs_data.mft_retrieval]
261	mov [ntfs_data.mft_retrieval], eax	261	mov [ntfs_data.mft_retrieval], eax
262	call kernel_free	262	call kernel_free
263	mov eax, [ntfs_data.mft_retrieval_size]	263	mov eax, [ntfs_data.mft_retrieval_size]
264	.ok:	264	.ok:
265	shl eax, 3	265	shl eax, 3
266	add eax, [ntfs_data.mft_retrieval]	266	add eax, [ntfs_data.mft_retrieval]
267	mov [esp+28], eax	267	mov [esp+28], eax
268	popad	268	popad
269	ret	269	ret
270		270
271	ntfs_read_frs_sector:	271	ntfs_read_frs_sector:
272	push eax ecx	272	push eax ecx
273	add eax, [PARTITION_START]	273	add eax, [PARTITION_START]
274	mov ecx, [ntfs_data.frs_size]	274	mov ecx, [ntfs_data.frs_size]
275	shr ecx, 9	275	shr ecx, 9
276	mov ebx, [ntfs_data.frs_buffer]	276	mov ebx, [ntfs_data.frs_buffer]
277	push ebx	277	push ebx
278	@@:	278	@@:
279	call hd_read	279	call hd_read
280	cmp [hd_error], 0	280	cmp [hd_error], 0
281	jnz .fail	281	jnz .fail
282	add ebx, 0x200	282	add ebx, 0x200
283	inc eax	283	inc eax
284	loop @b	284	loop @b
285	.fail:	285	.fail:
286	pop ebx	286	pop ebx
287	pop ecx eax	287	pop ecx eax
288	ret	288	ret
289		289
290	uglobal	290	uglobal
291	align 4	291	align 4
292	ntfs_cur_attr dd ?	292	ntfs_cur_attr dd ?
293	ntfs_cur_iRecord dd ?	293	ntfs_cur_iRecord dd ?
294	ntfs_cur_offs dd ? ; in sectors	294	ntfs_cur_offs dd ? ; in sectors
295	ntfs_cur_size dd ? ; in sectors	295	ntfs_cur_size dd ? ; in sectors
296	ntfs_cur_buf dd ?	296	ntfs_cur_buf dd ?
297	ntfs_cur_read dd ? ; [output]	297	ntfs_cur_read dd ? ; [output]
298	ntfs_bCanContinue db ?	298	ntfs_bCanContinue db ?
299	rb 3	299	rb 3
300		300
301	ntfs_attrlist_buf rb 0x400	301	ntfs_attrlist_buf rb 0x400
302	ntfs_attrlist_mft_buf rb 0x400	302	ntfs_attrlist_mft_buf rb 0x400
303	ntfs_bitmap_buf rb 0x400	303	ntfs_bitmap_buf rb 0x400
304		304
305	ntfs_attr_iRecord dd ?	305	ntfs_attr_iRecord dd ?
306	ntfs_attr_iBaseRecord dd ?	306	ntfs_attr_iBaseRecord dd ?
307	ntfs_attr_offs dd ?	307	ntfs_attr_offs dd ?
308	ntfs_attr_list dd ?	308	ntfs_attr_list dd ?
309	ntfs_attr_size dq ?	309	ntfs_attr_size dq ?
310	ntfs_cur_tail dd ?	310	ntfs_cur_tail dd ?
311	endg	311	endg
312		312
313	ntfs_read_attr:	313	ntfs_read_attr:
314	; in: global variables	314	; in: global variables
315	; out: [ntfs_cur_read]	315	; out: [ntfs_cur_read]
316	pushad	316	pushad
317	and [ntfs_cur_read], 0	317	and [ntfs_cur_read], 0
318	cmp [ntfs_cur_iRecord], 0	318	cmp [ntfs_cur_iRecord], 0
319	jnz .nomft	319	jnz .nomft
320	cmp [ntfs_cur_attr], 0x80	320	cmp [ntfs_cur_attr], 0x80
321	jnz .nomft	321	jnz .nomft
322	mov eax, [ntfs_data.mft_retrieval_end]	322	mov eax, [ntfs_data.mft_retrieval_end]
323	inc eax	323	inc eax
324	mul [ntfs_data.sectors_per_cluster]	324	mul [ntfs_data.sectors_per_cluster]
325	cmp eax, [ntfs_cur_offs]	325	cmp eax, [ntfs_cur_offs]
326	jbe .nomft	326	jbe .nomft
327	; precalculated part of $Mft $DATA	327	; precalculated part of $Mft $DATA
328	mov esi, [ntfs_data.mft_retrieval]	328	mov esi, [ntfs_data.mft_retrieval]
329	mov eax, [ntfs_cur_offs]	329	mov eax, [ntfs_cur_offs]
330	xor edx, edx	330	xor edx, edx
331	div [ntfs_data.sectors_per_cluster]	331	div [ntfs_data.sectors_per_cluster]
332	; eax = VCN, edx = offset in sectors from beginning of cluster	332	; eax = VCN, edx = offset in sectors from beginning of cluster
333	xor ecx, ecx ; ecx will contain LCN	333	xor ecx, ecx ; ecx will contain LCN
334	.mftscan:	334	.mftscan:
335	add ecx, [esi+4]	335	add ecx, [esi+4]
336	sub eax, [esi]	336	sub eax, [esi]
337	jb @f	337	jb @f
338	add esi, 8	338	add esi, 8
339	push eax	339	push eax
340	mov eax, [ntfs_data.mft_retrieval_end]	340	mov eax, [ntfs_data.mft_retrieval_end]
341	shl eax, 3	341	shl eax, 3
342	add eax, [ntfs_data.mft_retrieval]	342	add eax, [ntfs_data.mft_retrieval]
343	cmp eax, esi	343	cmp eax, esi
344	pop eax	344	pop eax
345	jnz .mftscan	345	jnz .mftscan
346	jmp .nomft	346	jmp .nomft
347	@@:	347	@@:
348	push ecx	348	push ecx
349	add ecx, eax	349	add ecx, eax
350	add ecx, [esi]	350	add ecx, [esi]
351	push eax	351	push eax
352	push edx	352	push edx
353	mov eax, [ntfs_data.sectors_per_cluster]	353	mov eax, [ntfs_data.sectors_per_cluster]
354	mul ecx	354	mul ecx
355	; eax = sector on partition	355	; eax = sector on partition
356	add eax, [PARTITION_START]	356	add eax, [PARTITION_START]
357	pop edx	357	pop edx
358	add eax, edx	358	add eax, edx
359	mov ebx, [ntfs_cur_buf]	359	mov ebx, [ntfs_cur_buf]
360	pop ecx	360	pop ecx
361	neg ecx	361	neg ecx
362	imul ecx, [ntfs_data.sectors_per_cluster]	362	imul ecx, [ntfs_data.sectors_per_cluster]
363	sub ecx, edx	363	sub ecx, edx
364	cmp ecx, [ntfs_cur_size]	364	cmp ecx, [ntfs_cur_size]
365	jb @f	365	jb @f
366	mov ecx, [ntfs_cur_size]	366	mov ecx, [ntfs_cur_size]
367	@@:	367	@@:
368	; ecx = number of sequential sectors to read	368	; ecx = number of sequential sectors to read
369	call hd_read	369	call hd_read
370	cmp [hd_error], 0	370	cmp [hd_error], 0
371	jnz .errread	371	jnz .errread
372	add [ntfs_cur_read], 0x200	372	add [ntfs_cur_read], 0x200
373	dec [ntfs_cur_size]	373	dec [ntfs_cur_size]
374	inc [ntfs_cur_offs]	374	inc [ntfs_cur_offs]
375	add ebx, 0x200	375	add ebx, 0x200
376	mov [ntfs_cur_buf], ebx	376	mov [ntfs_cur_buf], ebx
377	inc eax	377	inc eax
378	loop @b	378	loop @b
379	pop ecx	379	pop ecx
380	xor eax, eax	380	xor eax, eax
381	xor edx, edx	381	xor edx, edx
382	cmp [ntfs_cur_size], eax	382	cmp [ntfs_cur_size], eax
383	jz @f	383	jz @f
384	add esi, 8	384	add esi, 8
385	push eax	385	push eax
386	mov eax, [ntfs_data.mft_retrieval_end]	386	mov eax, [ntfs_data.mft_retrieval_end]
387	shl eax, 3	387	shl eax, 3
388	add eax, [ntfs_data.mft_retrieval]	388	add eax, [ntfs_data.mft_retrieval]
389	cmp eax, esi	389	cmp eax, esi
390	pop eax	390	pop eax
391	jz .nomft	391	jz .nomft
392	jmp .mftscan	392	jmp .mftscan
393	@@:	393	@@:
394	popad	394	popad
395	ret	395	ret
396	.errread:	396	.errread:
397	pop ecx	397	pop ecx
398	.errret:	398	.errret:
399	stc	399	stc
400	popad	400	popad
401	ret	401	ret
402	.nomft:	402	.nomft:
403	; 1. Read file record.	403	; 1. Read file record.
404	; N.B. This will do recursive call of read_attr for $MFT::$Data.	404	; N.B. This will do recursive call of read_attr for $MFT::$Data.
405	mov eax, [ntfs_cur_iRecord]	405	mov eax, [ntfs_cur_iRecord]
406	mov [ntfs_attr_iRecord], eax	406	mov [ntfs_attr_iRecord], eax
407	and [ntfs_attr_list], 0	407	and [ntfs_attr_list], 0
408	or dword [ntfs_attr_size], -1	408	or dword [ntfs_attr_size], -1
409	or dword [ntfs_attr_size+4], -1	409	or dword [ntfs_attr_size+4], -1
410	or [ntfs_attr_iBaseRecord], -1	410	or [ntfs_attr_iBaseRecord], -1
411	call ntfs_read_file_record	411	call ntfs_read_file_record
412	test eax, eax	412	test eax, eax
413	jz .errret	413	jz .errret
414	; 2. Find required attribute.	414	; 2. Find required attribute.
415	mov eax, [ntfs_data.frs_buffer]	415	mov eax, [ntfs_data.frs_buffer]
416	; a) For auxiliary records, read base record	416	; a) For auxiliary records, read base record
417	; N.B. If base record is present,	417	; N.B. If base record is present,
418	; base iRecord may be 0 (for $Mft), but SequenceNumber is nonzero	418	; base iRecord may be 0 (for $Mft), but SequenceNumber is nonzero
419	cmp dword [eax+24h], 0	419	cmp dword [eax+24h], 0
420	jz @f	420	jz @f
421	mov eax, [eax+20h]	421	mov eax, [eax+20h]
422	; test eax, eax	422	; test eax, eax
423	; jz @f	423	; jz @f
424	.beginfindattr:	424	.beginfindattr:
425	mov [ntfs_attr_iRecord], eax	425	mov [ntfs_attr_iRecord], eax
426	call ntfs_read_file_record	426	call ntfs_read_file_record
427	test eax, eax	427	test eax, eax
428	jz .errret	428	jz .errret
429	@@:	429	@@:
430	; b) Scan for required attribute and for $ATTR_LIST	430	; b) Scan for required attribute and for $ATTR_LIST
431	mov eax, [ntfs_data.frs_buffer]	431	mov eax, [ntfs_data.frs_buffer]
432	movzx ecx, word [eax+14h]	432	movzx ecx, word [eax+14h]
433	add eax, ecx	433	add eax, ecx
434	mov ecx, [ntfs_cur_attr]	434	mov ecx, [ntfs_cur_attr]
435	and [ntfs_attr_offs], 0	435	and [ntfs_attr_offs], 0
436	.scanattr:	436	.scanattr:
437	cmp dword [eax], -1	437	cmp dword [eax], -1
438	jz .scandone	438	jz .scandone
439	cmp dword [eax], ecx	439	cmp dword [eax], ecx
440	jz .okattr	440	jz .okattr
441	cmp [ntfs_attr_iBaseRecord], -1	441	cmp [ntfs_attr_iBaseRecord], -1
442	jnz .scancont	442	jnz .scancont
443	cmp dword [eax], 0x20 ; $ATTR_LIST	443	cmp dword [eax], 0x20 ; $ATTR_LIST
444	jnz .scancont	444	jnz .scancont
445	mov [ntfs_attr_list], eax	445	mov [ntfs_attr_list], eax
446	jmp .scancont	446	jmp .scancont
447	.okattr:	447	.okattr:
448	; ignore named $DATA attributes (aka NTFS streams)	448	; ignore named $DATA attributes (aka NTFS streams)
449	cmp ecx, 0x80	449	cmp ecx, 0x80
450	jnz @f	450	jnz @f
451	cmp byte [eax+9], 0	451	cmp byte [eax+9], 0
452	jnz .scancont	452	jnz .scancont
453	@@:	453	@@:
454	mov [ntfs_attr_offs], eax	454	mov [ntfs_attr_offs], eax
455	.scancont:	455	.scancont:
456	add eax, [eax+4]	456	add eax, [eax+4]
457	jmp .scanattr	457	jmp .scanattr
458	.continue:	458	.continue:
459	pushad	459	pushad
460	and [ntfs_cur_read], 0	460	and [ntfs_cur_read], 0
461	.scandone:	461	.scandone:
462	; c) Check for required offset and length	462	; c) Check for required offset and length
463	mov ecx, [ntfs_attr_offs]	463	mov ecx, [ntfs_attr_offs]
464	jecxz .noattr	464	jecxz .noattr
465	push [ntfs_cur_size]	465	push [ntfs_cur_size]
466	push [ntfs_cur_read]	466	push [ntfs_cur_read]
467	call .doreadattr	467	call .doreadattr
468	pop edx	468	pop edx
469	pop eax	469	pop eax
470	jc @f	470	jc @f
471	cmp [ntfs_bCanContinue], 0	471	cmp [ntfs_bCanContinue], 0
472	jz @f	472	jz @f
473	sub edx, [ntfs_cur_read]	473	sub edx, [ntfs_cur_read]
474	neg edx	474	neg edx
475	shr edx, 9	475	shr edx, 9
476	sub eax, edx	476	sub eax, edx
477	mov [ntfs_cur_size], eax	477	mov [ntfs_cur_size], eax
478	jnz .not_in_cur	478	jnz .not_in_cur
479	@@:	479	@@:
480	popad	480	popad
481	ret	481	ret
482	.noattr:	482	.noattr:
483	.not_in_cur:	483	.not_in_cur:
484	cmp [ntfs_cur_attr], 0x20	484	cmp [ntfs_cur_attr], 0x20
485	jz @f	485	jz @f
486	mov ecx, [ntfs_attr_list]	486	mov ecx, [ntfs_attr_list]
487	test ecx, ecx	487	test ecx, ecx
488	jnz .lookattr	488	jnz .lookattr
489	.ret_is_attr:	489	.ret_is_attr:
490	cmp [ntfs_attr_offs], 1 ; CF set <=> ntfs_attr_offs == 0	490	cmp [ntfs_attr_offs], 1 ; CF set <=> ntfs_attr_offs == 0
491	popad	491	popad
492	ret	492	ret
493	.lookattr:	493	.lookattr:
494	; required attribute or required offset was not found in base record;	494	; required attribute or required offset was not found in base record;
495	; it may be present in auxiliary records;	495	; it may be present in auxiliary records;
496	; scan $ATTR_LIST	496	; scan $ATTR_LIST
497	mov eax, [ntfs_attr_iBaseRecord]	497	mov eax, [ntfs_attr_iBaseRecord]
498	cmp eax, -1	498	cmp eax, -1
499	jz @f	499	jz @f
500	call ntfs_read_file_record	500	call ntfs_read_file_record

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ntfs.inc – Rev 1378 → 1379