/** * bootsect.c - Boot sector handling code. Originated from the Linux-NTFS project. * * Copyright (c) 2000-2006 Anton Altaparmakov * Copyright (c) 2003-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_STDIO_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #include "compat.h" #include "bootsect.h" #include "debug.h" #include "logging.h" /** * ntfs_boot_sector_is_ntfs - check if buffer contains a valid ntfs boot sector * @b: buffer containing putative boot sector to analyze * @silent: if zero, output progress messages to stderr * * Check if the buffer @b contains a valid ntfs boot sector. The buffer @b * must be at least 512 bytes in size. * * If @silent is zero, output progress messages to stderr. Otherwise, do not * output any messages (except when configured with --enable-debug in which * case warning/debug messages may be displayed). * * Return TRUE if @b contains a valid ntfs boot sector and FALSE if not. */ BOOL ntfs_boot_sector_is_ntfs( NTFS_BOOT_SECTOR *b ) { u32 i; BOOL ret = FALSE; ntfs_log_debug( "Beginning bootsector check.\n" ); ntfs_log_debug( "Checking OEMid, NTFS signature.\n" ); if ( b->oem_id != cpu_to_le64( 0x202020205346544eULL ) ) /* "NTFS " */ { ntfs_log_error( "NTFS signature is missing.\n" ); goto not_ntfs; } ntfs_log_debug( "Checking bytes per sector.\n" ); if ( le16_to_cpu( b->bpb.bytes_per_sector ) < 256 || le16_to_cpu( b->bpb.bytes_per_sector ) > 4096 ) { ntfs_log_error( "Unexpected bytes per sector value (%d).\n", le16_to_cpu( b->bpb.bytes_per_sector ) ); goto not_ntfs; } ntfs_log_debug( "Checking sectors per cluster.\n" ); switch ( b->bpb.sectors_per_cluster ) { case 1: case 2: case 4: case 8: case 16: case 32: case 64: case 128: break; default: ntfs_log_error( "Unexpected sectors per cluster value (%d).\n", b->bpb.sectors_per_cluster ); goto not_ntfs; } ntfs_log_debug( "Checking cluster size.\n" ); i = ( u32 )le16_to_cpu( b->bpb.bytes_per_sector ) * b->bpb.sectors_per_cluster; if ( i > 65536 ) { ntfs_log_error( "Unexpected cluster size (%d).\n", i ); goto not_ntfs; } ntfs_log_debug( "Checking reserved fields are zero.\n" ); if ( le16_to_cpu( b->bpb.reserved_sectors ) || le16_to_cpu( b->bpb.root_entries ) || le16_to_cpu( b->bpb.sectors ) || le16_to_cpu( b->bpb.sectors_per_fat ) || le32_to_cpu( b->bpb.large_sectors ) || b->bpb.fats ) { ntfs_log_error( "Reserved fields aren't zero " "(%d, %d, %d, %d, %d, %d).\n", le16_to_cpu( b->bpb.reserved_sectors ), le16_to_cpu( b->bpb.root_entries ), le16_to_cpu( b->bpb.sectors ), le16_to_cpu( b->bpb.sectors_per_fat ), le32_to_cpu( b->bpb.large_sectors ), b->bpb.fats ); goto not_ntfs; } ntfs_log_debug( "Checking clusters per mft record.\n" ); if ( ( u8 )b->clusters_per_mft_record < 0xe1 || ( u8 )b->clusters_per_mft_record > 0xf7 ) { switch ( b->clusters_per_mft_record ) { case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40: break; default: ntfs_log_error( "Unexpected clusters per mft record " "(%d).\n", b->clusters_per_mft_record ); goto not_ntfs; } } ntfs_log_debug( "Checking clusters per index block.\n" ); if ( ( u8 )b->clusters_per_index_record < 0xe1 || ( u8 )b->clusters_per_index_record > 0xf7 ) { switch ( b->clusters_per_index_record ) { case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40: break; default: ntfs_log_error( "Unexpected clusters per index record " "(%d).\n", b->clusters_per_index_record ); goto not_ntfs; } } if ( b->end_of_sector_marker != cpu_to_le16( 0xaa55 ) ) ntfs_log_debug( "Warning: Bootsector has invalid end of sector " "marker.\n" ); ntfs_log_debug( "Bootsector check completed successfully.\n" ); ret = TRUE; not_ntfs: return ret; } static const char *last_sector_error = "HINTS: Either the volume is a RAID/LDM but it wasn't setup yet,\n" " or it was not setup correctly (e.g. by not using mdadm --build ...),\n" " or a wrong device is tried to be mounted,\n" " or the partition table is corrupt (partition is smaller than NTFS),\n" " or the NTFS boot sector is corrupt (NTFS size is not valid).\n"; /** * ntfs_boot_sector_parse - setup an ntfs volume from an ntfs boot sector * @vol: ntfs_volume to setup * @bs: buffer containing ntfs boot sector to parse * * Parse the ntfs bootsector @bs and setup the ntfs volume @vol with the * obtained values. * * Return 0 on success or -1 on error with errno set to the error code EINVAL. */ int ntfs_boot_sector_parse( ntfs_volume *vol, const NTFS_BOOT_SECTOR *bs ) { s64 sectors; u8 sectors_per_cluster; s8 c; /* We return -1 with errno = EINVAL on error. */ errno = EINVAL; vol->sector_size = le16_to_cpu( bs->bpb.bytes_per_sector ); vol->sector_size_bits = ffs( vol->sector_size ) - 1; ntfs_log_debug( "SectorSize = 0x%x\n", vol->sector_size ); ntfs_log_debug( "SectorSizeBits = %u\n", vol->sector_size_bits ); /* * The bounds checks on mft_lcn and mft_mirr_lcn (i.e. them being * below or equal the number_of_clusters) really belong in the * ntfs_boot_sector_is_ntfs but in this way we can just do this once. */ sectors_per_cluster = bs->bpb.sectors_per_cluster; ntfs_log_debug( "SectorsPerCluster = 0x%x\n", sectors_per_cluster ); if ( sectors_per_cluster & ( sectors_per_cluster - 1 ) ) { ntfs_log_error( "sectors_per_cluster (%d) is not a power of 2." "\n", sectors_per_cluster ); return -1; } sectors = sle64_to_cpu( bs->number_of_sectors ); ntfs_log_debug( "NumberOfSectors = %lld\n", ( long long )sectors ); if ( !sectors ) { ntfs_log_error( "Volume size is set to zero.\n" ); return -1; } if ( vol->dev->d_ops->seek( vol->dev, ( sectors - 1 ) << vol->sector_size_bits, SEEK_SET ) == -1 ) { ntfs_log_perror( "Failed to read last sector (%lld)", ( long long )sectors ); ntfs_log_error( "%s", last_sector_error ); return -1; } vol->nr_clusters = sectors >> ( ffs( sectors_per_cluster ) - 1 ); vol->mft_lcn = sle64_to_cpu( bs->mft_lcn ); vol->mftmirr_lcn = sle64_to_cpu( bs->mftmirr_lcn ); ntfs_log_debug( "MFT LCN = %lld\n", ( long long )vol->mft_lcn ); ntfs_log_debug( "MFTMirr LCN = %lld\n", ( long long )vol->mftmirr_lcn ); if ( vol->mft_lcn > vol->nr_clusters || vol->mftmirr_lcn > vol->nr_clusters ) { ntfs_log_error( "$MFT LCN (%lld) or $MFTMirr LCN (%lld) is " "greater than the number of clusters (%lld).\n", ( long long )vol->mft_lcn, ( long long )vol->mftmirr_lcn, ( long long )vol->nr_clusters ); return -1; } vol->cluster_size = sectors_per_cluster * vol->sector_size; if ( vol->cluster_size & ( vol->cluster_size - 1 ) ) { ntfs_log_error( "cluster_size (%d) is not a power of 2.\n", vol->cluster_size ); return -1; } vol->cluster_size_bits = ffs( vol->cluster_size ) - 1; /* * Need to get the clusters per mft record and handle it if it is * negative. Then calculate the mft_record_size. A value of 0x80 is * illegal, thus signed char is actually ok! */ c = bs->clusters_per_mft_record; ntfs_log_debug( "ClusterSize = 0x%x\n", ( unsigned )vol->cluster_size ); ntfs_log_debug( "ClusterSizeBits = %u\n", vol->cluster_size_bits ); ntfs_log_debug( "ClustersPerMftRecord = 0x%x\n", c ); /* * When clusters_per_mft_record is negative, it means that it is to * be taken to be the negative base 2 logarithm of the mft_record_size * min bytes. Then: * mft_record_size = 2^(-clusters_per_mft_record) bytes. */ if ( c < 0 ) vol->mft_record_size = 1 << -c; else vol->mft_record_size = c << vol->cluster_size_bits; if ( vol->mft_record_size & ( vol->mft_record_size - 1 ) ) { ntfs_log_error( "mft_record_size (%d) is not a power of 2.\n", vol->mft_record_size ); return -1; } vol->mft_record_size_bits = ffs( vol->mft_record_size ) - 1; ntfs_log_debug( "MftRecordSize = 0x%x\n", ( unsigned )vol->mft_record_size ); ntfs_log_debug( "MftRecordSizeBits = %u\n", vol->mft_record_size_bits ); /* Same as above for INDX record. */ c = bs->clusters_per_index_record; ntfs_log_debug( "ClustersPerINDXRecord = 0x%x\n", c ); if ( c < 0 ) vol->indx_record_size = 1 << -c; else vol->indx_record_size = c << vol->cluster_size_bits; vol->indx_record_size_bits = ffs( vol->indx_record_size ) - 1; ntfs_log_debug( "INDXRecordSize = 0x%x\n", ( unsigned )vol->indx_record_size ); ntfs_log_debug( "INDXRecordSizeBits = %u\n", vol->indx_record_size_bits ); /* * Work out the size of the MFT mirror in number of mft records. If the * cluster size is less than or equal to the size taken by four mft * records, the mft mirror stores the first four mft records. If the * cluster size is bigger than the size taken by four mft records, the * mft mirror contains as many mft records as will fit into one * cluster. */ if ( vol->cluster_size <= 4 * vol->mft_record_size ) vol->mftmirr_size = 4; else vol->mftmirr_size = vol->cluster_size / vol->mft_record_size; return 0; }