/** * mft.c - Mft record handling code. Originated from the Linux-NTFS project. * * Copyright (c) 2000-2004 Anton Altaparmakov * Copyright (c) 2004-2005 Richard Russon * Copyright (c) 2004-2008 Szabolcs Szakacsits * Copyright (c) 2005 Yura Pakhuchiy * * This program/include file is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as published * by the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program/include file is distributed in the hope that it will be * useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program (in the main directory of the NTFS-3G * distribution in the file COPYING); if not, write to the Free Software * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STDIO_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_LIMITS_H #include #endif #include #include "compat.h" #include "types.h" #include "device.h" #include "debug.h" #include "bitmap.h" #include "attrib.h" #include "inode.h" #include "volume.h" #include "layout.h" #include "lcnalloc.h" #include "mft.h" #include "logging.h" #include "misc.h" /** * ntfs_mft_records_read - read records from the mft from disk * @vol: volume to read from * @mref: starting mft record number to read * @count: number of mft records to read * @b: output data buffer * * Read @count mft records starting at @mref from volume @vol into buffer * @b. Return 0 on success or -1 on error, with errno set to the error * code. * * If any of the records exceed the initialized size of the $MFT/$DATA * attribute, i.e. they cannot possibly be allocated mft records, assume this * is a bug and return error code ESPIPE. * * The read mft records are mst deprotected and are hence ready to use. The * caller should check each record with is_baad_record() in case mst * deprotection failed. * * NOTE: @b has to be at least of size @count * vol->mft_record_size. */ int ntfs_mft_records_read( const ntfs_volume *vol, const MFT_REF mref, const s64 count, MFT_RECORD *b ) { s64 br; VCN m; ntfs_log_trace( "inode %llu\n", ( unsigned long long )MREF( mref ) ); if ( !vol || !vol->mft_na || !b || count < 0 ) { errno = EINVAL; ntfs_log_perror( "%s: b=%p count=%lld mft=%llu", __FUNCTION__, b, ( long long )count, ( unsigned long long )MREF( mref ) ); return -1; } m = MREF( mref ); /* Refuse to read non-allocated mft records. */ if ( m + count > vol->mft_na->initialized_size >> vol->mft_record_size_bits ) { errno = ESPIPE; ntfs_log_perror( "Trying to read non-allocated mft records " "(%lld > %lld)", ( long long )m + count, ( long long )vol->mft_na->initialized_size >> vol->mft_record_size_bits ); return -1; } br = ntfs_attr_mst_pread( vol->mft_na, m << vol->mft_record_size_bits, count, vol->mft_record_size, b ); if ( br != count ) { if ( br != -1 ) errno = EIO; ntfs_log_perror( "Failed to read of MFT, mft=%llu count=%lld " "br=%lld", ( long long )m, ( long long )count, ( long long )br ); return -1; } return 0; } /** * ntfs_mft_records_write - write mft records to disk * @vol: volume to write to * @mref: starting mft record number to write * @count: number of mft records to write * @b: data buffer containing the mft records to write * * Write @count mft records starting at @mref from data buffer @b to volume * @vol. Return 0 on success or -1 on error, with errno set to the error code. * * If any of the records exceed the initialized size of the $MFT/$DATA * attribute, i.e. they cannot possibly be allocated mft records, assume this * is a bug and return error code ESPIPE. * * Before the mft records are written, they are mst protected. After the write, * they are deprotected again, thus resulting in an increase in the update * sequence number inside the data buffer @b. * * If any mft records are written which are also represented in the mft mirror * $MFTMirr, we make a copy of the relevant parts of the data buffer @b into a * temporary buffer before we do the actual write. Then if at least one mft * record was successfully written, we write the appropriate mft records from * the copied buffer to the mft mirror, too. */ int ntfs_mft_records_write( const ntfs_volume *vol, const MFT_REF mref, const s64 count, MFT_RECORD *b ) { s64 bw; VCN m; void *bmirr = NULL; int cnt = 0, res = 0; if ( !vol || !vol->mft_na || vol->mftmirr_size <= 0 || !b || count < 0 ) { errno = EINVAL; return -1; } m = MREF( mref ); /* Refuse to write non-allocated mft records. */ if ( m + count > vol->mft_na->initialized_size >> vol->mft_record_size_bits ) { errno = ESPIPE; ntfs_log_perror( "Trying to write non-allocated mft records " "(%lld > %lld)", ( long long )m + count, ( long long )vol->mft_na->initialized_size >> vol->mft_record_size_bits ); return -1; } if ( m < vol->mftmirr_size ) { if ( !vol->mftmirr_na ) { errno = EINVAL; return -1; } cnt = vol->mftmirr_size - m; if ( cnt > count ) cnt = count; bmirr = ntfs_malloc( cnt * vol->mft_record_size ); if ( !bmirr ) return -1; memcpy( bmirr, b, cnt * vol->mft_record_size ); } bw = ntfs_attr_mst_pwrite( vol->mft_na, m << vol->mft_record_size_bits, count, vol->mft_record_size, b ); if ( bw != count ) { if ( bw != -1 ) errno = EIO; if ( bw >= 0 ) ntfs_log_debug( "Error: partial write while writing $Mft " "record(s)!\n" ); else ntfs_log_perror( "Error writing $Mft record(s)" ); res = errno; } if ( bmirr && bw > 0 ) { if ( bw < cnt ) cnt = bw; bw = ntfs_attr_mst_pwrite( vol->mftmirr_na, m << vol->mft_record_size_bits, cnt, vol->mft_record_size, bmirr ); if ( bw != cnt ) { if ( bw != -1 ) errno = EIO; ntfs_log_debug( "Error: failed to sync $MFTMirr! Run " "chkdsk.\n" ); res = errno; } } free( bmirr ); if ( !res ) return res; errno = res; return -1; } int ntfs_mft_record_check( const ntfs_volume *vol, const MFT_REF mref, MFT_RECORD *m ) { ATTR_RECORD *a; int ret = -1; if ( !ntfs_is_file_record( m->magic ) ) { ntfs_log_error( "Record %llu has no FILE magic (0x%x)\n", ( unsigned long long )MREF( mref ), *( le32 * )m ); goto err_out; } if ( le32_to_cpu( m->bytes_allocated ) != vol->mft_record_size ) { ntfs_log_error( "Record %llu has corrupt allocation size " "(%u <> %u)\n", ( unsigned long long )MREF( mref ), vol->mft_record_size, le32_to_cpu( m->bytes_allocated ) ); goto err_out; } a = ( ATTR_RECORD * )( ( char * )m + le16_to_cpu( m->attrs_offset ) ); if ( p2n( a ) < p2n( m ) || ( char * )a > ( char * )m + vol->mft_record_size ) { ntfs_log_error( "Record %llu is corrupt\n", ( unsigned long long )MREF( mref ) ); goto err_out; } ret = 0; err_out: if ( ret ) errno = EIO; return ret; } /** * ntfs_file_record_read - read a FILE record from the mft from disk * @vol: volume to read from * @mref: mft reference specifying mft record to read * @mrec: address of pointer in which to return the mft record * @attr: address of pointer in which to return the first attribute * * Read a FILE record from the mft of @vol from the storage medium. @mref * specifies the mft record to read, including the sequence number, which can * be 0 if no sequence number checking is to be performed. * * The function allocates a buffer large enough to hold the mft record and * reads the record into the buffer (mst deprotecting it in the process). * *@mrec is then set to point to the buffer. * * If @attr is not NULL, *@attr is set to point to the first attribute in the * mft record, i.e. *@attr is a pointer into *@mrec. * * Return 0 on success, or -1 on error, with errno set to the error code. * * The read mft record is checked for having the magic FILE, * and for having a matching sequence number (if MSEQNO(*@mref) != 0). * If either of these fails, -1 is returned and errno is set to EIO. If you get * this, but you still want to read the mft record (e.g. in order to correct * it), use ntfs_mft_record_read() directly. * * Note: Caller has to free *@mrec when finished. * * Note: We do not check if the mft record is flagged in use. The caller can * check if desired. */ int ntfs_file_record_read( const ntfs_volume *vol, const MFT_REF mref, MFT_RECORD **mrec, ATTR_RECORD **attr ) { MFT_RECORD *m; if ( !vol || !mrec ) { errno = EINVAL; ntfs_log_perror( "%s: mrec=%p", __FUNCTION__, mrec ); return -1; } m = *mrec; if ( !m ) { m = ntfs_malloc( vol->mft_record_size ); if ( !m ) return -1; } if ( ntfs_mft_record_read( vol, mref, m ) ) goto err_out; if ( ntfs_mft_record_check( vol, mref, m ) ) goto err_out; if ( MSEQNO( mref ) && MSEQNO( mref ) != le16_to_cpu( m->sequence_number ) ) { ntfs_log_error( "Record %llu has wrong SeqNo (%d <> %d)\n", ( unsigned long long )MREF( mref ), MSEQNO( mref ), le16_to_cpu( m->sequence_number ) ); errno = EIO; goto err_out; } *mrec = m; if ( attr ) *attr = ( ATTR_RECORD* )( ( char* )m + le16_to_cpu( m->attrs_offset ) ); return 0; err_out: if ( m != *mrec ) free( m ); return -1; } /** * ntfs_mft_record_layout - layout an mft record into a memory buffer * @vol: volume to which the mft record will belong * @mref: mft reference specifying the mft record number * @mrec: destination buffer of size >= @vol->mft_record_size bytes * * Layout an empty, unused mft record with the mft reference @mref into the * buffer @m. The volume @vol is needed because the mft record structure was * modified in NTFS 3.1 so we need to know which volume version this mft record * will be used on. * * On success return 0 and on error return -1 with errno set to the error code. */ int ntfs_mft_record_layout( const ntfs_volume *vol, const MFT_REF mref, MFT_RECORD *mrec ) { ATTR_RECORD *a; if ( !vol || !mrec ) { errno = EINVAL; ntfs_log_perror( "%s: mrec=%p", __FUNCTION__, mrec ); return -1; } /* Aligned to 2-byte boundary. */ if ( vol->major_ver < 3 || ( vol->major_ver == 3 && !vol->minor_ver ) ) mrec->usa_ofs = cpu_to_le16( ( sizeof( MFT_RECORD_OLD ) + 1 ) & ~1 ); else { /* Abort if mref is > 32 bits. */ if ( MREF( mref ) & 0x0000ffff00000000ull ) { errno = ERANGE; ntfs_log_perror( "Mft reference exceeds 32 bits" ); return -1; } mrec->usa_ofs = cpu_to_le16( ( sizeof( MFT_RECORD ) + 1 ) & ~1 ); /* * Set the NTFS 3.1+ specific fields while we know that the * volume version is 3.1+. */ mrec->reserved = cpu_to_le16( 0 ); mrec->mft_record_number = cpu_to_le32( MREF( mref ) ); } mrec->magic = magic_FILE; if ( vol->mft_record_size >= NTFS_BLOCK_SIZE ) mrec->usa_count = cpu_to_le16( vol->mft_record_size / NTFS_BLOCK_SIZE + 1 ); else { mrec->usa_count = cpu_to_le16( 1 ); ntfs_log_error( "Sector size is bigger than MFT record size. " "Setting usa_count to 1. If Windows chkdsk " "reports this as corruption, please email %s " "stating that you saw this message and that " "the file system created was corrupt. " "Thank you.\n", NTFS_DEV_LIST ); } /* Set the update sequence number to 1. */ *( u16* )( ( u8* )mrec + le16_to_cpu( mrec->usa_ofs ) ) = cpu_to_le16( 1 ); mrec->lsn = cpu_to_le64( 0ull ); mrec->sequence_number = cpu_to_le16( 1 ); mrec->link_count = cpu_to_le16( 0 ); /* Aligned to 8-byte boundary. */ mrec->attrs_offset = cpu_to_le16( ( le16_to_cpu( mrec->usa_ofs ) + ( le16_to_cpu( mrec->usa_count ) << 1 ) + 7 ) & ~7 ); mrec->flags = cpu_to_le16( 0 ); /* * Using attrs_offset plus eight bytes (for the termination attribute), * aligned to 8-byte boundary. */ mrec->bytes_in_use = cpu_to_le32( ( le16_to_cpu( mrec->attrs_offset ) + 8 + 7 ) & ~7 ); mrec->bytes_allocated = cpu_to_le32( vol->mft_record_size ); mrec->base_mft_record = cpu_to_le64( ( MFT_REF )0 ); mrec->next_attr_instance = cpu_to_le16( 0 ); a = ( ATTR_RECORD* )( ( u8* )mrec + le16_to_cpu( mrec->attrs_offset ) ); a->type = AT_END; a->length = cpu_to_le32( 0 ); /* Finally, clear the unused part of the mft record. */ memset( ( u8* )a + 8, 0, vol->mft_record_size - ( ( u8* )a + 8 - ( u8* )mrec ) ); return 0; } /** * ntfs_mft_record_format - format an mft record on an ntfs volume * @vol: volume on which to format the mft record * @mref: mft reference specifying mft record to format * * Format the mft record with the mft reference @mref in $MFT/$DATA, i.e. lay * out an empty, unused mft record in memory and write it to the volume @vol. * * On success return 0 and on error return -1 with errno set to the error code. */ int ntfs_mft_record_format( const ntfs_volume *vol, const MFT_REF mref ) { MFT_RECORD *m; int ret = -1; ntfs_log_enter( "Entering\n" ); m = ntfs_calloc( vol->mft_record_size ); if ( !m ) goto out; if ( ntfs_mft_record_layout( vol, mref, m ) ) goto free_m; if ( ntfs_mft_record_write( vol, mref, m ) ) goto free_m; ret = 0; free_m: free( m ); out: ntfs_log_leave( "\n" ); return ret; } static const char *es = " Leaving inconsistent metadata. Run chkdsk."; /** * ntfs_ffz - Find the first unset (zero) bit in a word * @word: * * Description... * * Returns: */ static inline unsigned int ntfs_ffz( unsigned int word ) { return ffs( ~word ) - 1; } static int ntfs_is_mft( ntfs_inode *ni ) { if ( ni && ni->mft_no == FILE_MFT ) return 1; return 0; } #ifndef PAGE_SIZE #define PAGE_SIZE 4096 #endif #define RESERVED_MFT_RECORDS 64 /** * ntfs_mft_bitmap_find_free_rec - find a free mft record in the mft bitmap * @vol: volume on which to search for a free mft record * @base_ni: open base inode if allocating an extent mft record or NULL * * Search for a free mft record in the mft bitmap attribute on the ntfs volume * @vol. * * If @base_ni is NULL start the search at the default allocator position. * * If @base_ni is not NULL start the search at the mft record after the base * mft record @base_ni. * * Return the free mft record on success and -1 on error with errno set to the * error code. An error code of ENOSPC means that there are no free mft * records in the currently initialized mft bitmap. */ static int ntfs_mft_bitmap_find_free_rec( ntfs_volume *vol, ntfs_inode *base_ni ) { s64 pass_end, ll, data_pos, pass_start, ofs, bit; ntfs_attr *mftbmp_na; u8 *buf, *byte; unsigned int size; u8 pass, b; int ret = -1; ntfs_log_enter( "Entering\n" ); mftbmp_na = vol->mftbmp_na; /* * Set the end of the pass making sure we do not overflow the mft * bitmap. */ size = PAGE_SIZE; pass_end = vol->mft_na->allocated_size >> vol->mft_record_size_bits; ll = mftbmp_na->initialized_size << 3; if ( pass_end > ll ) pass_end = ll; pass = 1; if ( !base_ni ) data_pos = vol->mft_data_pos; else data_pos = base_ni->mft_no + 1; if ( data_pos < RESERVED_MFT_RECORDS ) data_pos = RESERVED_MFT_RECORDS; if ( data_pos >= pass_end ) { data_pos = RESERVED_MFT_RECORDS; pass = 2; /* This happens on a freshly formatted volume. */ if ( data_pos >= pass_end ) { errno = ENOSPC; goto leave; } } if ( ntfs_is_mft( base_ni ) ) { data_pos = 0; pass = 2; } pass_start = data_pos; buf = ntfs_malloc( PAGE_SIZE ); if ( !buf ) goto leave; ntfs_log_debug( "Starting bitmap search: pass %u, pass_start 0x%llx, " "pass_end 0x%llx, data_pos 0x%llx.\n", pass, ( long long )pass_start, ( long long )pass_end, ( long long )data_pos ); #ifdef DEBUG byte = NULL; b = 0; #endif /* Loop until a free mft record is found. */ for ( ; pass <= 2; size = PAGE_SIZE ) { /* Cap size to pass_end. */ ofs = data_pos >> 3; ll = ( ( pass_end + 7 ) >> 3 ) - ofs; if ( size > ll ) size = ll; ll = ntfs_attr_pread( mftbmp_na, ofs, size, buf ); if ( ll < 0 ) { ntfs_log_perror( "Failed to read $MFT bitmap" ); free( buf ); goto leave; } ntfs_log_debug( "Read 0x%llx bytes.\n", ( long long )ll ); /* If we read at least one byte, search @buf for a zero bit. */ if ( ll ) { size = ll << 3; bit = data_pos & 7; data_pos &= ~7ull; ntfs_log_debug( "Before inner for loop: size 0x%x, " "data_pos 0x%llx, bit 0x%llx, " "*byte 0x%hhx, b %u.\n", size, ( long long )data_pos, ( long long )bit, byte ? *byte : -1, b ); for ( ; bit < size && data_pos + bit < pass_end; bit &= ~7ull, bit += 8 ) { /* * If we're extending $MFT and running out of the first * mft record (base record) then give up searching since * no guarantee that the found record will be accessible. */ if ( ntfs_is_mft( base_ni ) && bit > 400 ) goto out; byte = buf + ( bit >> 3 ); if ( *byte == 0xff ) continue; /* Note: ffz() result must be zero based. */ b = ntfs_ffz( ( unsigned long ) * byte ); if ( b < 8 && b >= ( bit & 7 ) ) { free( buf ); ret = data_pos + ( bit & ~7ull ) + b; goto leave; } } ntfs_log_debug( "After inner for loop: size 0x%x, " "data_pos 0x%llx, bit 0x%llx, " "*byte 0x%hhx, b %u.\n", size, ( long long )data_pos, ( long long )bit, byte ? *byte : -1, b ); data_pos += size; /* * If the end of the pass has not been reached yet, * continue searching the mft bitmap for a zero bit. */ if ( data_pos < pass_end ) continue; } /* Do the next pass. */ pass++; if ( pass == 2 ) { /* * Starting the second pass, in which we scan the first * part of the zone which we omitted earlier. */ pass_end = pass_start; data_pos = pass_start = RESERVED_MFT_RECORDS; ntfs_log_debug( "pass %i, pass_start 0x%llx, pass_end " "0x%llx.\n", pass, ( long long )pass_start, ( long long )pass_end ); if ( data_pos >= pass_end ) break; } } /* No free mft records in currently initialized mft bitmap. */ out: free( buf ); errno = ENOSPC; leave: ntfs_log_leave( "\n" ); return ret; } static int ntfs_mft_attr_extend( ntfs_attr *na ) { int ret = STATUS_ERROR; ntfs_log_enter( "Entering\n" ); if ( !NInoAttrList( na->ni ) ) { if ( ntfs_inode_add_attrlist( na->ni ) ) { ntfs_log_perror( "%s: Can not add attrlist #3", __FUNCTION__ ); goto out; } /* We can't sync the $MFT inode since its runlist is bogus. */ ret = STATUS_KEEP_SEARCHING; goto out; } if ( ntfs_attr_update_mapping_pairs( na, 0 ) ) { ntfs_log_perror( "%s: MP update failed", __FUNCTION__ ); goto out; } ret = STATUS_OK; out: ntfs_log_leave( "\n" ); return ret; } /** * ntfs_mft_bitmap_extend_allocation_i - see ntfs_mft_bitmap_extend_allocation */ static int ntfs_mft_bitmap_extend_allocation_i( ntfs_volume *vol ) { LCN lcn; s64 ll = 0; /* silence compiler warning */ ntfs_attr *mftbmp_na; runlist_element *rl, *rl2 = NULL; /* silence compiler warning */ ntfs_attr_search_ctx *ctx; MFT_RECORD *m = NULL; /* silence compiler warning */ ATTR_RECORD *a = NULL; /* silence compiler warning */ int err, mp_size; int ret = STATUS_ERROR; u32 old_alen = 0; /* silence compiler warning */ BOOL mp_rebuilt = FALSE; BOOL update_mp = FALSE; mftbmp_na = vol->mftbmp_na; /* * Determine the last lcn of the mft bitmap. The allocated size of the * mft bitmap cannot be zero so we are ok to do this. */ rl = ntfs_attr_find_vcn( mftbmp_na, ( mftbmp_na->allocated_size - 1 ) >> vol->cluster_size_bits ); if ( !rl || !rl->length || rl->lcn < 0 ) { ntfs_log_error( "Failed to determine last allocated " "cluster of mft bitmap attribute.\n" ); if ( rl ) errno = EIO; return STATUS_ERROR; } lcn = rl->lcn + rl->length; rl2 = ntfs_cluster_alloc( vol, rl[1].vcn, 1, lcn, DATA_ZONE ); if ( !rl2 ) { ntfs_log_error( "Failed to allocate a cluster for " "the mft bitmap.\n" ); return STATUS_ERROR; } rl = ntfs_runlists_merge( mftbmp_na->rl, rl2 ); if ( !rl ) { err = errno; ntfs_log_error( "Failed to merge runlists for mft " "bitmap.\n" ); if ( ntfs_cluster_free_from_rl( vol, rl2 ) ) ntfs_log_error( "Failed to deallocate " "cluster.%s\n", es ); free( rl2 ); errno = err; return STATUS_ERROR; } mftbmp_na->rl = rl; ntfs_log_debug( "Adding one run to mft bitmap.\n" ); /* Find the last run in the new runlist. */ for ( ; rl[1].length; rl++ ) ; /* * Update the attribute record as well. Note: @rl is the last * (non-terminator) runlist element of mft bitmap. */ ctx = ntfs_attr_get_search_ctx( mftbmp_na->ni, NULL ); if ( !ctx ) goto undo_alloc; if ( ntfs_attr_lookup( mftbmp_na->type, mftbmp_na->name, mftbmp_na->name_len, 0, rl[1].vcn, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find last attribute extent of " "mft bitmap attribute.\n" ); goto undo_alloc; } m = ctx->mrec; a = ctx->attr; ll = sle64_to_cpu( a->lowest_vcn ); rl2 = ntfs_attr_find_vcn( mftbmp_na, ll ); if ( !rl2 || !rl2->length ) { ntfs_log_error( "Failed to determine previous last " "allocated cluster of mft bitmap attribute.\n" ); if ( rl2 ) errno = EIO; goto undo_alloc; } /* Get the size for the new mapping pairs array for this extent. */ mp_size = ntfs_get_size_for_mapping_pairs( vol, rl2, ll, INT_MAX ); if ( mp_size <= 0 ) { ntfs_log_error( "Get size for mapping pairs failed for " "mft bitmap attribute extent.\n" ); goto undo_alloc; } /* Expand the attribute record if necessary. */ old_alen = le32_to_cpu( a->length ); if ( ntfs_attr_record_resize( m, a, mp_size + le16_to_cpu( a->mapping_pairs_offset ) ) ) { ntfs_log_info( "extending $MFT bitmap\n" ); ret = ntfs_mft_attr_extend( vol->mftbmp_na ); if ( ret == STATUS_OK ) goto ok; if ( ret == STATUS_ERROR ) { ntfs_log_perror( "%s: ntfs_mft_attr_extend failed", __FUNCTION__ ); update_mp = TRUE; } goto undo_alloc; } mp_rebuilt = TRUE; /* Generate the mapping pairs array directly into the attr record. */ if ( ntfs_mapping_pairs_build( vol, ( u8* )a + le16_to_cpu( a->mapping_pairs_offset ), mp_size, rl2, ll, NULL ) ) { ntfs_log_error( "Failed to build mapping pairs array for " "mft bitmap attribute.\n" ); errno = EIO; goto undo_alloc; } /* Update the highest_vcn. */ a->highest_vcn = cpu_to_sle64( rl[1].vcn - 1 ); /* * We now have extended the mft bitmap allocated_size by one cluster. * Reflect this in the ntfs_attr structure and the attribute record. */ if ( a->lowest_vcn ) { /* * We are not in the first attribute extent, switch to it, but * first ensure the changes will make it to disk later. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_reinit_search_ctx( ctx ); if ( ntfs_attr_lookup( mftbmp_na->type, mftbmp_na->name, mftbmp_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute " "extent of mft bitmap attribute.\n" ); goto restore_undo_alloc; } a = ctx->attr; } ok: mftbmp_na->allocated_size += vol->cluster_size; a->allocated_size = cpu_to_sle64( mftbmp_na->allocated_size ); /* Ensure the changes make it to disk. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); return STATUS_OK; restore_undo_alloc: err = errno; ntfs_attr_reinit_search_ctx( ctx ); if ( ntfs_attr_lookup( mftbmp_na->type, mftbmp_na->name, mftbmp_na->name_len, 0, rl[1].vcn, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find last attribute extent of " "mft bitmap attribute.%s\n", es ); ntfs_attr_put_search_ctx( ctx ); mftbmp_na->allocated_size += vol->cluster_size; /* * The only thing that is now wrong is ->allocated_size of the * base attribute extent which chkdsk should be able to fix. */ errno = err; return STATUS_ERROR; } m = ctx->mrec; a = ctx->attr; a->highest_vcn = cpu_to_sle64( rl[1].vcn - 2 ); errno = err; undo_alloc: err = errno; /* Remove the last run from the runlist. */ lcn = rl->lcn; rl->lcn = rl[1].lcn; rl->length = 0; /* FIXME: use an ntfs_cluster_free_* function */ if ( ntfs_bitmap_clear_bit( vol->lcnbmp_na, lcn ) ) ntfs_log_error( "Failed to free cluster.%s\n", es ); else vol->free_clusters++; if ( mp_rebuilt ) { if ( ntfs_mapping_pairs_build( vol, ( u8* )a + le16_to_cpu( a->mapping_pairs_offset ), old_alen - le16_to_cpu( a->mapping_pairs_offset ), rl2, ll, NULL ) ) ntfs_log_error( "Failed to restore mapping " "pairs array.%s\n", es ); if ( ntfs_attr_record_resize( m, a, old_alen ) ) ntfs_log_error( "Failed to restore attribute " "record.%s\n", es ); ntfs_inode_mark_dirty( ctx->ntfs_ino ); } if ( update_mp ) { if ( ntfs_attr_update_mapping_pairs( vol->mftbmp_na, 0 ) ) ntfs_log_perror( "%s: MP update failed", __FUNCTION__ ); } if ( ctx ) ntfs_attr_put_search_ctx( ctx ); errno = err; return ret; } /** * ntfs_mft_bitmap_extend_allocation - extend mft bitmap attribute by a cluster * @vol: volume on which to extend the mft bitmap attribute * * Extend the mft bitmap attribute on the ntfs volume @vol by one cluster. * * Note: Only changes allocated_size, i.e. does not touch initialized_size or * data_size. * * Return 0 on success and -1 on error with errno set to the error code. */ static int ntfs_mft_bitmap_extend_allocation( ntfs_volume *vol ) { int ret; ntfs_log_enter( "Entering\n" ); ret = ntfs_mft_bitmap_extend_allocation_i( vol ); ntfs_log_leave( "\n" ); return ret; } /** * ntfs_mft_bitmap_extend_initialized - extend mft bitmap initialized data * @vol: volume on which to extend the mft bitmap attribute * * Extend the initialized portion of the mft bitmap attribute on the ntfs * volume @vol by 8 bytes. * * Note: Only changes initialized_size and data_size, i.e. requires that * allocated_size is big enough to fit the new initialized_size. * * Return 0 on success and -1 on error with errno set to the error code. */ static int ntfs_mft_bitmap_extend_initialized( ntfs_volume *vol ) { s64 old_data_size, old_initialized_size, ll; ntfs_attr *mftbmp_na; ntfs_attr_search_ctx *ctx; ATTR_RECORD *a; int err; int ret = -1; ntfs_log_enter( "Entering\n" ); mftbmp_na = vol->mftbmp_na; ctx = ntfs_attr_get_search_ctx( mftbmp_na->ni, NULL ); if ( !ctx ) goto out; if ( ntfs_attr_lookup( mftbmp_na->type, mftbmp_na->name, mftbmp_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute extent of " "mft bitmap attribute.\n" ); err = errno; goto put_err_out; } a = ctx->attr; old_data_size = mftbmp_na->data_size; old_initialized_size = mftbmp_na->initialized_size; mftbmp_na->initialized_size += 8; a->initialized_size = cpu_to_sle64( mftbmp_na->initialized_size ); if ( mftbmp_na->initialized_size > mftbmp_na->data_size ) { mftbmp_na->data_size = mftbmp_na->initialized_size; a->data_size = cpu_to_sle64( mftbmp_na->data_size ); } /* Ensure the changes make it to disk. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); /* Initialize the mft bitmap attribute value with zeroes. */ ll = 0; ll = ntfs_attr_pwrite( mftbmp_na, old_initialized_size, 8, &ll ); if ( ll == 8 ) { ntfs_log_debug( "Wrote eight initialized bytes to mft bitmap.\n" ); vol->free_mft_records += ( 8 * 8 ); ret = 0; goto out; } ntfs_log_error( "Failed to write to mft bitmap.\n" ); err = errno; if ( ll >= 0 ) err = EIO; /* Try to recover from the error. */ ctx = ntfs_attr_get_search_ctx( mftbmp_na->ni, NULL ); if ( !ctx ) goto err_out; if ( ntfs_attr_lookup( mftbmp_na->type, mftbmp_na->name, mftbmp_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute extent of " "mft bitmap attribute.%s\n", es ); put_err_out: ntfs_attr_put_search_ctx( ctx ); goto err_out; } a = ctx->attr; mftbmp_na->initialized_size = old_initialized_size; a->initialized_size = cpu_to_sle64( old_initialized_size ); if ( mftbmp_na->data_size != old_data_size ) { mftbmp_na->data_size = old_data_size; a->data_size = cpu_to_sle64( old_data_size ); } ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); ntfs_log_debug( "Restored status of mftbmp: allocated_size 0x%llx, " "data_size 0x%llx, initialized_size 0x%llx.\n", ( long long )mftbmp_na->allocated_size, ( long long )mftbmp_na->data_size, ( long long )mftbmp_na->initialized_size ); err_out: errno = err; out: ntfs_log_leave( "\n" ); return ret; } /** * ntfs_mft_data_extend_allocation - extend mft data attribute * @vol: volume on which to extend the mft data attribute * * Extend the mft data attribute on the ntfs volume @vol by 16 mft records * worth of clusters or if not enough space for this by one mft record worth * of clusters. * * Note: Only changes allocated_size, i.e. does not touch initialized_size or * data_size. * * Return 0 on success and -1 on error with errno set to the error code. */ static int ntfs_mft_data_extend_allocation( ntfs_volume *vol ) { LCN lcn; VCN old_last_vcn; s64 min_nr, nr, ll = 0; /* silence compiler warning */ ntfs_attr *mft_na; runlist_element *rl, *rl2; ntfs_attr_search_ctx *ctx; MFT_RECORD *m = NULL; /* silence compiler warning */ ATTR_RECORD *a = NULL; /* silence compiler warning */ int err, mp_size; int ret = STATUS_ERROR; u32 old_alen = 0; /* silence compiler warning */ BOOL mp_rebuilt = FALSE; BOOL update_mp = FALSE; ntfs_log_enter( "Extending mft data allocation.\n" ); mft_na = vol->mft_na; /* * Determine the preferred allocation location, i.e. the last lcn of * the mft data attribute. The allocated size of the mft data * attribute cannot be zero so we are ok to do this. */ rl = ntfs_attr_find_vcn( mft_na, ( mft_na->allocated_size - 1 ) >> vol->cluster_size_bits ); if ( !rl || !rl->length || rl->lcn < 0 ) { ntfs_log_error( "Failed to determine last allocated " "cluster of mft data attribute.\n" ); if ( rl ) errno = EIO; goto out; } lcn = rl->lcn + rl->length; ntfs_log_debug( "Last lcn of mft data attribute is 0x%llx.\n", ( long long )lcn ); /* Minimum allocation is one mft record worth of clusters. */ min_nr = vol->mft_record_size >> vol->cluster_size_bits; if ( !min_nr ) min_nr = 1; /* Want to allocate 16 mft records worth of clusters. */ nr = vol->mft_record_size << 4 >> vol->cluster_size_bits; if ( !nr ) nr = min_nr; old_last_vcn = rl[1].vcn; do { rl2 = ntfs_cluster_alloc( vol, old_last_vcn, nr, lcn, MFT_ZONE ); if ( rl2 ) break; if ( errno != ENOSPC || nr == min_nr ) { ntfs_log_perror( "Failed to allocate (%lld) clusters " "for $MFT", ( long long )nr ); goto out; } /* * There is not enough space to do the allocation, but there * might be enough space to do a minimal allocation so try that * before failing. */ nr = min_nr; ntfs_log_debug( "Retrying mft data allocation with minimal cluster " "count %lli.\n", ( long long )nr ); } while ( 1 ); ntfs_log_debug( "Allocated %lld clusters.\n", ( long long )nr ); rl = ntfs_runlists_merge( mft_na->rl, rl2 ); if ( !rl ) { err = errno; ntfs_log_error( "Failed to merge runlists for mft data " "attribute.\n" ); if ( ntfs_cluster_free_from_rl( vol, rl2 ) ) ntfs_log_error( "Failed to deallocate clusters " "from the mft data attribute.%s\n", es ); free( rl2 ); errno = err; goto out; } mft_na->rl = rl; /* Find the last run in the new runlist. */ for ( ; rl[1].length; rl++ ) ; /* Update the attribute record as well. */ ctx = ntfs_attr_get_search_ctx( mft_na->ni, NULL ); if ( !ctx ) goto undo_alloc; if ( ntfs_attr_lookup( mft_na->type, mft_na->name, mft_na->name_len, 0, rl[1].vcn, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find last attribute extent of " "mft data attribute.\n" ); goto undo_alloc; } m = ctx->mrec; a = ctx->attr; ll = sle64_to_cpu( a->lowest_vcn ); rl2 = ntfs_attr_find_vcn( mft_na, ll ); if ( !rl2 || !rl2->length ) { ntfs_log_error( "Failed to determine previous last " "allocated cluster of mft data attribute.\n" ); if ( rl2 ) errno = EIO; goto undo_alloc; } /* Get the size for the new mapping pairs array for this extent. */ mp_size = ntfs_get_size_for_mapping_pairs( vol, rl2, ll, INT_MAX ); if ( mp_size <= 0 ) { ntfs_log_error( "Get size for mapping pairs failed for " "mft data attribute extent.\n" ); goto undo_alloc; } /* Expand the attribute record if necessary. */ old_alen = le32_to_cpu( a->length ); if ( ntfs_attr_record_resize( m, a, mp_size + le16_to_cpu( a->mapping_pairs_offset ) ) ) { ret = ntfs_mft_attr_extend( vol->mft_na ); if ( ret == STATUS_OK ) goto ok; if ( ret == STATUS_ERROR ) { ntfs_log_perror( "%s: ntfs_mft_attr_extend failed", __FUNCTION__ ); update_mp = TRUE; } goto undo_alloc; } mp_rebuilt = TRUE; /* * Generate the mapping pairs array directly into the attribute record. */ if ( ntfs_mapping_pairs_build( vol, ( u8* )a + le16_to_cpu( a->mapping_pairs_offset ), mp_size, rl2, ll, NULL ) ) { ntfs_log_error( "Failed to build mapping pairs array of " "mft data attribute.\n" ); errno = EIO; goto undo_alloc; } /* Update the highest_vcn. */ a->highest_vcn = cpu_to_sle64( rl[1].vcn - 1 ); /* * We now have extended the mft data allocated_size by nr clusters. * Reflect this in the ntfs_attr structure and the attribute record. * @rl is the last (non-terminator) runlist element of mft data * attribute. */ if ( a->lowest_vcn ) { /* * We are not in the first attribute extent, switch to it, but * first ensure the changes will make it to disk later. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_reinit_search_ctx( ctx ); if ( ntfs_attr_lookup( mft_na->type, mft_na->name, mft_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute " "extent of mft data attribute.\n" ); goto restore_undo_alloc; } a = ctx->attr; } ok: mft_na->allocated_size += nr << vol->cluster_size_bits; a->allocated_size = cpu_to_sle64( mft_na->allocated_size ); /* Ensure the changes make it to disk. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); ret = STATUS_OK; out: ntfs_log_leave( "\n" ); return ret; restore_undo_alloc: err = errno; ntfs_attr_reinit_search_ctx( ctx ); if ( ntfs_attr_lookup( mft_na->type, mft_na->name, mft_na->name_len, 0, rl[1].vcn, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find last attribute extent of " "mft data attribute.%s\n", es ); ntfs_attr_put_search_ctx( ctx ); mft_na->allocated_size += nr << vol->cluster_size_bits; /* * The only thing that is now wrong is ->allocated_size of the * base attribute extent which chkdsk should be able to fix. */ errno = err; ret = STATUS_ERROR; goto out; } m = ctx->mrec; a = ctx->attr; a->highest_vcn = cpu_to_sle64( old_last_vcn - 1 ); errno = err; undo_alloc: err = errno; if ( ntfs_cluster_free( vol, mft_na, old_last_vcn, -1 ) < 0 ) ntfs_log_error( "Failed to free clusters from mft data " "attribute.%s\n", es ); if ( ntfs_rl_truncate( &mft_na->rl, old_last_vcn ) ) ntfs_log_error( "Failed to truncate mft data attribute " "runlist.%s\n", es ); if ( mp_rebuilt ) { if ( ntfs_mapping_pairs_build( vol, ( u8* )a + le16_to_cpu( a->mapping_pairs_offset ), old_alen - le16_to_cpu( a->mapping_pairs_offset ), rl2, ll, NULL ) ) ntfs_log_error( "Failed to restore mapping pairs " "array.%s\n", es ); if ( ntfs_attr_record_resize( m, a, old_alen ) ) ntfs_log_error( "Failed to restore attribute " "record.%s\n", es ); ntfs_inode_mark_dirty( ctx->ntfs_ino ); } if ( update_mp ) { if ( ntfs_attr_update_mapping_pairs( vol->mft_na, 0 ) ) ntfs_log_perror( "%s: MP update failed", __FUNCTION__ ); } if ( ctx ) ntfs_attr_put_search_ctx( ctx ); errno = err; goto out; } static int ntfs_mft_record_init( ntfs_volume *vol, s64 size ) { int ret = -1; ntfs_attr *mft_na, *mftbmp_na; s64 old_data_initialized, old_data_size; ntfs_attr_search_ctx *ctx; ntfs_log_enter( "Entering\n" ); /* NOTE: Caller must sanity check vol, vol->mft_na and vol->mftbmp_na */ mft_na = vol->mft_na; mftbmp_na = vol->mftbmp_na; /* * The mft record is outside the initialized data. Extend the mft data * attribute until it covers the allocated record. The loop is only * actually traversed more than once when a freshly formatted volume * is first written to so it optimizes away nicely in the common case. */ ntfs_log_debug( "Status of mft data before extension: " "allocated_size 0x%llx, data_size 0x%llx, " "initialized_size 0x%llx.\n", ( long long )mft_na->allocated_size, ( long long )mft_na->data_size, ( long long )mft_na->initialized_size ); while ( size > mft_na->allocated_size ) { if ( ntfs_mft_data_extend_allocation( vol ) == STATUS_ERROR ) goto out; ntfs_log_debug( "Status of mft data after allocation extension: " "allocated_size 0x%llx, data_size 0x%llx, " "initialized_size 0x%llx.\n", ( long long )mft_na->allocated_size, ( long long )mft_na->data_size, ( long long )mft_na->initialized_size ); } old_data_initialized = mft_na->initialized_size; old_data_size = mft_na->data_size; /* * Extend mft data initialized size (and data size of course) to reach * the allocated mft record, formatting the mft records along the way. * Note: We only modify the ntfs_attr structure as that is all that is * needed by ntfs_mft_record_format(). We will update the attribute * record itself in one fell swoop later on. */ while ( size > mft_na->initialized_size ) { s64 ll2 = mft_na->initialized_size >> vol->mft_record_size_bits; mft_na->initialized_size += vol->mft_record_size; if ( mft_na->initialized_size > mft_na->data_size ) mft_na->data_size = mft_na->initialized_size; ntfs_log_debug( "Initializing mft record 0x%llx.\n", ( long long )ll2 ); if ( ntfs_mft_record_format( vol, ll2 ) < 0 ) { ntfs_log_perror( "Failed to format mft record" ); goto undo_data_init; } } /* Update the mft data attribute record to reflect the new sizes. */ ctx = ntfs_attr_get_search_ctx( mft_na->ni, NULL ); if ( !ctx ) goto undo_data_init; if ( ntfs_attr_lookup( mft_na->type, mft_na->name, mft_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute extent of " "mft data attribute.\n" ); ntfs_attr_put_search_ctx( ctx ); goto undo_data_init; } ctx->attr->initialized_size = cpu_to_sle64( mft_na->initialized_size ); ctx->attr->data_size = cpu_to_sle64( mft_na->data_size ); ctx->attr->allocated_size = cpu_to_sle64( mft_na->allocated_size ); /* Ensure the changes make it to disk. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); ntfs_log_debug( "Status of mft data after mft record initialization: " "allocated_size 0x%llx, data_size 0x%llx, " "initialized_size 0x%llx.\n", ( long long )mft_na->allocated_size, ( long long )mft_na->data_size, ( long long )mft_na->initialized_size ); /* Sanity checks. */ if ( mft_na->data_size > mft_na->allocated_size || mft_na->initialized_size > mft_na->data_size ) NTFS_BUG( "mft_na sanity checks failed" ); /* Sync MFT to minimize data loss if there won't be clean unmount. */ if ( ntfs_inode_sync( mft_na->ni ) ) goto undo_data_init; ret = 0; out: ntfs_log_leave( "\n" ); return ret; undo_data_init: mft_na->initialized_size = old_data_initialized; mft_na->data_size = old_data_size; goto out; } static int ntfs_mft_rec_init( ntfs_volume *vol, s64 size ) { int ret = -1; ntfs_attr *mft_na, *mftbmp_na; s64 old_data_initialized, old_data_size; ntfs_attr_search_ctx *ctx; ntfs_log_enter( "Entering\n" ); mft_na = vol->mft_na; mftbmp_na = vol->mftbmp_na; if ( size > mft_na->allocated_size || size > mft_na->initialized_size ) { errno = EIO; ntfs_log_perror( "%s: unexpected $MFT sizes, see below", __FUNCTION__ ); ntfs_log_error( "$MFT: size=%lld allocated_size=%lld " "data_size=%lld initialized_size=%lld\n", ( long long )size, ( long long )mft_na->allocated_size, ( long long )mft_na->data_size, ( long long )mft_na->initialized_size ); goto out; } old_data_initialized = mft_na->initialized_size; old_data_size = mft_na->data_size; /* Update the mft data attribute record to reflect the new sizes. */ ctx = ntfs_attr_get_search_ctx( mft_na->ni, NULL ); if ( !ctx ) goto undo_data_init; if ( ntfs_attr_lookup( mft_na->type, mft_na->name, mft_na->name_len, 0, 0, NULL, 0, ctx ) ) { ntfs_log_error( "Failed to find first attribute extent of " "mft data attribute.\n" ); ntfs_attr_put_search_ctx( ctx ); goto undo_data_init; } ctx->attr->initialized_size = cpu_to_sle64( mft_na->initialized_size ); ctx->attr->data_size = cpu_to_sle64( mft_na->data_size ); /* CHECKME: ctx->attr->allocation_size is already ok? */ /* Ensure the changes make it to disk. */ ntfs_inode_mark_dirty( ctx->ntfs_ino ); ntfs_attr_put_search_ctx( ctx ); /* Sanity checks. */ if ( mft_na->data_size > mft_na->allocated_size || mft_na->initialized_size > mft_na->data_size ) NTFS_BUG( "mft_na sanity checks failed" ); out: ntfs_log_leave( "\n" ); return ret; undo_data_init: mft_na->initialized_size = old_data_initialized; mft_na->data_size = old_data_size; goto out; } static ntfs_inode *ntfs_mft_rec_alloc( ntfs_volume *vol ) { s64 ll, bit; ntfs_attr *mft_na, *mftbmp_na; MFT_RECORD *m; ntfs_inode *ni = NULL; ntfs_inode *base_ni; int err; le16 seq_no, usn; ntfs_log_enter( "Entering\n" ); mft_na = vol->mft_na; mftbmp_na = vol->mftbmp_na; base_ni = mft_na->ni; bit = ntfs_mft_bitmap_find_free_rec( vol, base_ni ); if ( bit >= 0 ) goto found_free_rec; if ( errno != ENOSPC ) goto out; errno = ENOSPC; /* strerror() is intentionally used below, we want to log this error. */ ntfs_log_error( "No free mft record for $MFT: %s\n", strerror( errno ) ); goto err_out; found_free_rec: if ( ntfs_bitmap_set_bit( mftbmp_na, bit ) ) { ntfs_log_error( "Failed to allocate bit in mft bitmap #2\n" ); goto err_out; } ll = ( bit + 1 ) << vol->mft_record_size_bits; if ( ll > mft_na->initialized_size ) if ( ntfs_mft_rec_init( vol, ll ) < 0 ) goto undo_mftbmp_alloc; /* * We now have allocated and initialized the mft record. Need to read * it from disk and re-format it, preserving the sequence number if it * is not zero as well as the update sequence number if it is not zero * or -1 (0xffff). */ m = ntfs_malloc( vol->mft_record_size ); if ( !m ) goto undo_mftbmp_alloc; if ( ntfs_mft_record_read( vol, bit, m ) ) { free( m ); goto undo_mftbmp_alloc; } /* Sanity check that the mft record is really not in use. */ if ( ntfs_is_file_record( m->magic ) && ( m->flags & MFT_RECORD_IN_USE ) ) { ntfs_log_error( "Inode %lld is used but it wasn't marked in " "$MFT bitmap. Fixed.\n", ( long long )bit ); free( m ); goto undo_mftbmp_alloc; } seq_no = m->sequence_number; usn = *( le16* )( ( u8* )m + le16_to_cpu( m->usa_ofs ) ); if ( ntfs_mft_record_layout( vol, bit, m ) ) { ntfs_log_error( "Failed to re-format mft record.\n" ); free( m ); goto undo_mftbmp_alloc; } if ( seq_no ) m->sequence_number = seq_no; seq_no = usn; if ( seq_no && seq_no != const_cpu_to_le16( 0xffff ) ) *( le16* )( ( u8* )m + le16_to_cpu( m->usa_ofs ) ) = usn; /* Set the mft record itself in use. */ m->flags |= MFT_RECORD_IN_USE; /* Now need to open an ntfs inode for the mft record. */ ni = ntfs_inode_allocate( vol ); if ( !ni ) { ntfs_log_error( "Failed to allocate buffer for inode.\n" ); free( m ); goto undo_mftbmp_alloc; } ni->mft_no = bit; ni->mrec = m; /* * If we are allocating an extent mft record, make the opened inode an * extent inode and attach it to the base inode. Also, set the base * mft record reference in the extent inode. */ ni->nr_extents = -1; ni->base_ni = base_ni; m->base_mft_record = MK_LE_MREF( base_ni->mft_no, le16_to_cpu( base_ni->mrec->sequence_number ) ); /* * Attach the extent inode to the base inode, reallocating * memory if needed. */ if ( !( base_ni->nr_extents & 3 ) ) { ntfs_inode **extent_nis; int i; i = ( base_ni->nr_extents + 4 ) * sizeof( ntfs_inode * ); extent_nis = ntfs_malloc( i ); if ( !extent_nis ) { free( m ); free( ni ); goto undo_mftbmp_alloc; } if ( base_ni->nr_extents ) { memcpy( extent_nis, base_ni->extent_nis, i - 4 * sizeof( ntfs_inode * ) ); free( base_ni->extent_nis ); } base_ni->extent_nis = extent_nis; } base_ni->extent_nis[base_ni->nr_extents++] = ni; /* Make sure the allocated inode is written out to disk later. */ ntfs_inode_mark_dirty( ni ); /* Initialize time, allocated and data size in ntfs_inode struct. */ ni->data_size = ni->allocated_size = 0; ni->flags = 0; ni->creation_time = ni->last_data_change_time = ni->last_mft_change_time = ni->last_access_time = ntfs_current_time(); /* Update the default mft allocation position if it was used. */ if ( !base_ni ) vol->mft_data_pos = bit + 1; /* Return the opened, allocated inode of the allocated mft record. */ ntfs_log_error( "allocated %sinode %lld\n", base_ni ? "extent " : "", ( long long )bit ); out: ntfs_log_leave( "\n" ); return ni; undo_mftbmp_alloc: err = errno; if ( ntfs_bitmap_clear_bit( mftbmp_na, bit ) ) ntfs_log_error( "Failed to clear bit in mft bitmap.%s\n", es ); errno = err; err_out: if ( !errno ) errno = EIO; ni = NULL; goto out; } /** * ntfs_mft_record_alloc - allocate an mft record on an ntfs volume * @vol: volume on which to allocate the mft record * @base_ni: open base inode if allocating an extent mft record or NULL * * Allocate an mft record in $MFT/$DATA of an open ntfs volume @vol. * * If @base_ni is NULL make the mft record a base mft record and allocate it at * the default allocator position. * * If @base_ni is not NULL make the allocated mft record an extent record, * allocate it starting at the mft record after the base mft record and attach * the allocated and opened ntfs inode to the base inode @base_ni. * * On success return the now opened ntfs (extent) inode of the mft record. * * On error return NULL with errno set to the error code. * * To find a free mft record, we scan the mft bitmap for a zero bit. To * optimize this we start scanning at the place specified by @base_ni or if * @base_ni is NULL we start where we last stopped and we perform wrap around * when we reach the end. Note, we do not try to allocate mft records below * number 24 because numbers 0 to 15 are the defined system files anyway and 16 * to 24 are special in that they are used for storing extension mft records * for the $DATA attribute of $MFT. This is required to avoid the possibility * of creating a run list with a circular dependence which once written to disk * can never be read in again. Windows will only use records 16 to 24 for * normal files if the volume is completely out of space. We never use them * which means that when the volume is really out of space we cannot create any * more files while Windows can still create up to 8 small files. We can start * doing this at some later time, it does not matter much for now. * * When scanning the mft bitmap, we only search up to the last allocated mft * record. If there are no free records left in the range 24 to number of * allocated mft records, then we extend the $MFT/$DATA attribute in order to * create free mft records. We extend the allocated size of $MFT/$DATA by 16 * records at a time or one cluster, if cluster size is above 16kiB. If there * is not sufficient space to do this, we try to extend by a single mft record * or one cluster, if cluster size is above the mft record size, but we only do * this if there is enough free space, which we know from the values returned * by the failed cluster allocation function when we tried to do the first * allocation. * * No matter how many mft records we allocate, we initialize only the first * allocated mft record, incrementing mft data size and initialized size * accordingly, open an ntfs_inode for it and return it to the caller, unless * there are less than 24 mft records, in which case we allocate and initialize * mft records until we reach record 24 which we consider as the first free mft * record for use by normal files. * * If during any stage we overflow the initialized data in the mft bitmap, we * extend the initialized size (and data size) by 8 bytes, allocating another * cluster if required. The bitmap data size has to be at least equal to the * number of mft records in the mft, but it can be bigger, in which case the * superfluous bits are padded with zeroes. * * Thus, when we return successfully (return value non-zero), we will have: * - initialized / extended the mft bitmap if necessary, * - initialized / extended the mft data if necessary, * - set the bit corresponding to the mft record being allocated in the * mft bitmap, * - open an ntfs_inode for the allocated mft record, and we will * - return the ntfs_inode. * * On error (return value zero), nothing will have changed. If we had changed * anything before the error occurred, we will have reverted back to the * starting state before returning to the caller. Thus, except for bugs, we * should always leave the volume in a consistent state when returning from * this function. * * Note, this function cannot make use of most of the normal functions, like * for example for attribute resizing, etc, because when the run list overflows * the base mft record and an attribute list is used, it is very important that * the extension mft records used to store the $DATA attribute of $MFT can be * reached without having to read the information contained inside them, as * this would make it impossible to find them in the first place after the * volume is dismounted. $MFT/$BITMAP probably does not need to follow this * rule because the bitmap is not essential for finding the mft records, but on * the other hand, handling the bitmap in this special way would make life * easier because otherwise there might be circular invocations of functions * when reading the bitmap but if we are careful, we should be able to avoid * all problems. */ ntfs_inode *ntfs_mft_record_alloc( ntfs_volume *vol, ntfs_inode *base_ni ) { s64 ll, bit; ntfs_attr *mft_na, *mftbmp_na; MFT_RECORD *m; ntfs_inode *ni = NULL; int err; le16 seq_no, usn; if ( base_ni ) ntfs_log_enter( "Entering (allocating an extent mft record for " "base mft record %lld).\n", ( long long )base_ni->mft_no ); else ntfs_log_enter( "Entering (allocating a base mft record)\n" ); if ( !vol || !vol->mft_na || !vol->mftbmp_na ) { errno = EINVAL; goto out; } if ( ntfs_is_mft( base_ni ) ) { ni = ntfs_mft_rec_alloc( vol ); goto out; } mft_na = vol->mft_na; mftbmp_na = vol->mftbmp_na; retry: bit = ntfs_mft_bitmap_find_free_rec( vol, base_ni ); if ( bit >= 0 ) { ntfs_log_debug( "found free record (#1) at %lld\n", ( long long )bit ); goto found_free_rec; } if ( errno != ENOSPC ) goto out; /* * No free mft records left. If the mft bitmap already covers more * than the currently used mft records, the next records are all free, * so we can simply allocate the first unused mft record. * Note: We also have to make sure that the mft bitmap at least covers * the first 24 mft records as they are special and whilst they may not * be in use, we do not allocate from them. */ ll = mft_na->initialized_size >> vol->mft_record_size_bits; if ( mftbmp_na->initialized_size << 3 > ll && mftbmp_na->initialized_size > RESERVED_MFT_RECORDS / 8 ) { bit = ll; if ( bit < RESERVED_MFT_RECORDS ) bit = RESERVED_MFT_RECORDS; ntfs_log_debug( "found free record (#2) at %lld\n", ( long long )bit ); goto found_free_rec; } /* * The mft bitmap needs to be expanded until it covers the first unused * mft record that we can allocate. * Note: The smallest mft record we allocate is mft record 24. */ ntfs_log_debug( "Status of mftbmp before extension: allocated_size 0x%llx, " "data_size 0x%llx, initialized_size 0x%llx.\n", ( long long )mftbmp_na->allocated_size, ( long long )mftbmp_na->data_size, ( long long )mftbmp_na->initialized_size ); if ( mftbmp_na->initialized_size + 8 > mftbmp_na->allocated_size ) { int ret = ntfs_mft_bitmap_extend_allocation( vol ); if ( ret == STATUS_ERROR ) goto err_out; if ( ret == STATUS_KEEP_SEARCHING ) { ret = ntfs_mft_bitmap_extend_allocation( vol ); if ( ret != STATUS_OK ) goto err_out; } ntfs_log_debug( "Status of mftbmp after allocation extension: " "allocated_size 0x%llx, data_size 0x%llx, " "initialized_size 0x%llx.\n", ( long long )mftbmp_na->allocated_size, ( long long )mftbmp_na->data_size, ( long long )mftbmp_na->initialized_size ); } /* * We now have sufficient allocated space, extend the initialized_size * as well as the data_size if necessary and fill the new space with * zeroes. */ bit = mftbmp_na->initialized_size << 3; if ( ntfs_mft_bitmap_extend_initialized( vol ) ) goto err_out; ntfs_log_debug( "Status of mftbmp after initialized extension: " "allocated_size 0x%llx, data_size 0x%llx, " "initialized_size 0x%llx.\n", ( long long )mftbmp_na->allocated_size, ( long long )mftbmp_na->data_size, ( long long )mftbmp_na->initialized_size ); ntfs_log_debug( "found free record (#3) at %lld\n", ( long long )bit ); found_free_rec: /* @bit is the found free mft record, allocate it in the mft bitmap. */ if ( ntfs_bitmap_set_bit( mftbmp_na, bit ) ) { ntfs_log_error( "Failed to allocate bit in mft bitmap.\n" ); goto err_out; } /* The mft bitmap is now uptodate. Deal with mft data attribute now. */ ll = ( bit + 1 ) << vol->mft_record_size_bits; if ( ll > mft_na->initialized_size ) if ( ntfs_mft_record_init( vol, ll ) < 0 ) goto undo_mftbmp_alloc; /* * We now have allocated and initialized the mft record. Need to read * it from disk and re-format it, preserving the sequence number if it * is not zero as well as the update sequence number if it is not zero * or -1 (0xffff). */ m = ntfs_malloc( vol->mft_record_size ); if ( !m ) goto undo_mftbmp_alloc; if ( ntfs_mft_record_read( vol, bit, m ) ) { free( m ); goto undo_mftbmp_alloc; } /* Sanity check that the mft record is really not in use. */ if ( ntfs_is_file_record( m->magic ) && ( m->flags & MFT_RECORD_IN_USE ) ) { ntfs_log_error( "Inode %lld is used but it wasn't marked in " "$MFT bitmap. Fixed.\n", ( long long )bit ); free( m ); goto retry; } seq_no = m->sequence_number; usn = *( le16* )( ( u8* )m + le16_to_cpu( m->usa_ofs ) ); if ( ntfs_mft_record_layout( vol, bit, m ) ) { ntfs_log_error( "Failed to re-format mft record.\n" ); free( m ); goto undo_mftbmp_alloc; } if ( seq_no ) m->sequence_number = seq_no; seq_no = usn; if ( seq_no && seq_no != const_cpu_to_le16( 0xffff ) ) *( le16* )( ( u8* )m + le16_to_cpu( m->usa_ofs ) ) = usn; /* Set the mft record itself in use. */ m->flags |= MFT_RECORD_IN_USE; /* Now need to open an ntfs inode for the mft record. */ ni = ntfs_inode_allocate( vol ); if ( !ni ) { ntfs_log_error( "Failed to allocate buffer for inode.\n" ); free( m ); goto undo_mftbmp_alloc; } ni->mft_no = bit; ni->mrec = m; /* * If we are allocating an extent mft record, make the opened inode an * extent inode and attach it to the base inode. Also, set the base * mft record reference in the extent inode. */ if ( base_ni ) { ni->nr_extents = -1; ni->base_ni = base_ni; m->base_mft_record = MK_LE_MREF( base_ni->mft_no, le16_to_cpu( base_ni->mrec->sequence_number ) ); /* * Attach the extent inode to the base inode, reallocating * memory if needed. */ if ( !( base_ni->nr_extents & 3 ) ) { ntfs_inode **extent_nis; int i; i = ( base_ni->nr_extents + 4 ) * sizeof( ntfs_inode * ); extent_nis = ntfs_malloc( i ); if ( !extent_nis ) { free( m ); free( ni ); goto undo_mftbmp_alloc; } if ( base_ni->nr_extents ) { memcpy( extent_nis, base_ni->extent_nis, i - 4 * sizeof( ntfs_inode * ) ); free( base_ni->extent_nis ); } base_ni->extent_nis = extent_nis; } base_ni->extent_nis[base_ni->nr_extents++] = ni; } /* Make sure the allocated inode is written out to disk later. */ ntfs_inode_mark_dirty( ni ); /* Initialize time, allocated and data size in ntfs_inode struct. */ ni->data_size = ni->allocated_size = 0; ni->flags = 0; ni->creation_time = ni->last_data_change_time = ni->last_mft_change_time = ni->last_access_time = ntfs_current_time(); /* Update the default mft allocation position if it was used. */ if ( !base_ni ) vol->mft_data_pos = bit + 1; /* Return the opened, allocated inode of the allocated mft record. */ ntfs_log_debug( "allocated %sinode 0x%llx.\n", base_ni ? "extent " : "", ( long long )bit ); vol->free_mft_records--; out: ntfs_log_leave( "\n" ); return ni; undo_mftbmp_alloc: err = errno; if ( ntfs_bitmap_clear_bit( mftbmp_na, bit ) ) ntfs_log_error( "Failed to clear bit in mft bitmap.%s\n", es ); errno = err; err_out: if ( !errno ) errno = EIO; ni = NULL; goto out; } /** * ntfs_mft_record_free - free an mft record on an ntfs volume * @vol: volume on which to free the mft record * @ni: open ntfs inode of the mft record to free * * Free the mft record of the open inode @ni on the mounted ntfs volume @vol. * Note that this function calls ntfs_inode_close() internally and hence you * cannot use the pointer @ni any more after this function returns success. * * On success return 0 and on error return -1 with errno set to the error code. */ int ntfs_mft_record_free( ntfs_volume *vol, ntfs_inode *ni ) { u64 mft_no; int err; u16 seq_no; le16 old_seq_no; ntfs_log_trace( "Entering for inode 0x%llx.\n", ( long long ) ni->mft_no ); if ( !vol || !vol->mftbmp_na || !ni ) { errno = EINVAL; return -1; } /* Cache the mft reference for later. */ mft_no = ni->mft_no; /* Mark the mft record as not in use. */ ni->mrec->flags &= ~MFT_RECORD_IN_USE; /* Increment the sequence number, skipping zero, if it is not zero. */ old_seq_no = ni->mrec->sequence_number; seq_no = le16_to_cpu( old_seq_no ); if ( seq_no == 0xffff ) seq_no = 1; else if ( seq_no ) seq_no++; ni->mrec->sequence_number = cpu_to_le16( seq_no ); /* Set the inode dirty and write it out. */ ntfs_inode_mark_dirty( ni ); if ( ntfs_inode_sync( ni ) ) { err = errno; goto sync_rollback; } /* Clear the bit in the $MFT/$BITMAP corresponding to this record. */ if ( ntfs_bitmap_clear_bit( vol->mftbmp_na, mft_no ) ) { err = errno; // FIXME: If ntfs_bitmap_clear_run() guarantees rollback on // error, this could be changed to goto sync_rollback; goto bitmap_rollback; } /* Throw away the now freed inode. */ #if CACHE_NIDATA_SIZE if ( !ntfs_inode_real_close( ni ) ) { #else if ( !ntfs_inode_close( ni ) ) { #endif vol->free_mft_records++; return 0; } err = errno; /* Rollback what we did... */ bitmap_rollback: if ( ntfs_bitmap_set_bit( vol->mftbmp_na, mft_no ) ) ntfs_log_debug( "Eeek! Rollback failed in ntfs_mft_record_free(). " "Leaving inconsistent metadata!\n" ); sync_rollback: ni->mrec->flags |= MFT_RECORD_IN_USE; ni->mrec->sequence_number = old_seq_no; ntfs_inode_mark_dirty( ni ); errno = err; return -1; } /** * ntfs_mft_usn_dec - Decrement USN by one * @mrec: pointer to an mft record * * On success return 0 and on error return -1 with errno set. */ int ntfs_mft_usn_dec( MFT_RECORD *mrec ) { u16 usn; le16 *usnp; if ( !mrec ) { errno = EINVAL; return -1; } usnp = ( le16* )( ( char* )mrec + le16_to_cpu( mrec->usa_ofs ) ); usn = le16_to_cpup( usnp ); if ( usn-- <= 1 ) usn = 0xfffe; *usnp = cpu_to_le16( usn ); return 0; }