mirror of
https://git.code.sf.net/p/ntfs-3g/ntfs-3g.git
synced 2024-11-23 18:14:24 +08:00
2c6472ee5a
Since Windows 10, the cluster size may be greater than 128 sectors, and it has to be recorded as a power of 2 in the boot sector. Hence there are two possible ways of cluster size. Accept both ways leading to valid values.
303 lines
10 KiB
C
303 lines
10 KiB
C
/**
|
|
* 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 <stdio.h>
|
|
#endif
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#ifdef HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
#include "param.h"
|
|
#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;
|
|
u16 sectors_per_cluster;
|
|
|
|
ntfs_log_debug("Beginning bootsector check.\n");
|
|
|
|
ntfs_log_debug("Checking OEMid, NTFS signature.\n");
|
|
if (b->oem_id != const_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:
|
|
if ((b->bpb.sectors_per_cluster < 240)
|
|
|| (b->bpb.sectors_per_cluster > 253)) {
|
|
if (b->bpb.sectors_per_cluster > 128)
|
|
ntfs_log_error("Unexpected sectors"
|
|
" per cluster value (code 0x%x)\n",
|
|
b->bpb.sectors_per_cluster);
|
|
else
|
|
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");
|
|
if (b->bpb.sectors_per_cluster > 128)
|
|
sectors_per_cluster = 1 << (256 - b->bpb.sectors_per_cluster);
|
|
else
|
|
sectors_per_cluster = b->bpb.sectors_per_cluster;
|
|
i = (u32)le16_to_cpu(b->bpb.bytes_per_sector) * sectors_per_cluster;
|
|
if (i > NTFS_MAX_CLUSTER_SIZE) {
|
|
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 != const_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;
|
|
u16 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.
|
|
*/
|
|
if (bs->bpb.sectors_per_cluster > 128)
|
|
sectors_per_cluster = 1 << (256 - bs->bpb.sectors_per_cluster);
|
|
else
|
|
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 - 1));
|
|
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 < 0 || vol->mft_lcn > vol->nr_clusters) ||
|
|
(vol->mftmirr_lcn < 0 || 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;
|
|
}
|
|
|