1 /**
2 * bootsect.c - Boot sector handling code. Originated from the Linux-NTFS project.
3 *
4 * Copyright (c) 2000-2006 Anton Altaparmakov
5 * Copyright (c) 2003-2008 Szabolcs Szakacsits
6 * Copyright (c) 2005 Yura Pakhuchiy
7 *
8 * This program/include file is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program/include file is distributed in the hope that it will be
14 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program (in the main directory of the NTFS-3G
20 * distribution in the file COPYING); if not, write to the Free Software
21 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #ifdef HAVE_STDIO_H
29 #include <stdio.h>
30 #endif
31 #ifdef HAVE_STDLIB_H
32 #include <stdlib.h>
33 #endif
34 #ifdef HAVE_STRING_H
35 #include <string.h>
36 #endif
37 #ifdef HAVE_ERRNO_H
38 #include <errno.h>
39 #endif
40
41 #include "param.h"
42 #include "compat.h"
43 #include "bootsect.h"
44 #include "debug.h"
45 #include "logging.h"
46
47 /**
48 * ntfs_boot_sector_is_ntfs - check if buffer contains a valid ntfs boot sector
49 * @b: buffer containing putative boot sector to analyze
50 * @silent: if zero, output progress messages to stderr
51 *
52 * Check if the buffer @b contains a valid ntfs boot sector. The buffer @b
53 * must be at least 512 bytes in size.
54 *
55 * If @silent is zero, output progress messages to stderr. Otherwise, do not
56 * output any messages (except when configured with --enable-debug in which
57 * case warning/debug messages may be displayed).
58 *
59 * Return TRUE if @b contains a valid ntfs boot sector and FALSE if not.
60 */
ntfs_boot_sector_is_ntfs(NTFS_BOOT_SECTOR * b)61 BOOL ntfs_boot_sector_is_ntfs(NTFS_BOOT_SECTOR *b)
62 {
63 u32 i;
64 BOOL ret = FALSE;
65 u16 sectors_per_cluster;
66
67 ntfs_log_debug("Beginning bootsector check.\n");
68
69 ntfs_log_debug("Checking OEMid, NTFS signature.\n");
70 if (b->oem_id != const_cpu_to_le64(0x202020205346544eULL)) { /* "NTFS " */
71 ntfs_log_error("NTFS signature is missing.\n");
72 goto not_ntfs;
73 }
74
75 ntfs_log_debug("Checking bytes per sector.\n");
76 if (le16_to_cpu(b->bpb.bytes_per_sector) < 256 ||
77 le16_to_cpu(b->bpb.bytes_per_sector) > 4096) {
78 ntfs_log_error("Unexpected bytes per sector value (%d).\n",
79 le16_to_cpu(b->bpb.bytes_per_sector));
80 goto not_ntfs;
81 }
82
83 ntfs_log_debug("Checking sectors per cluster.\n");
84 switch (b->bpb.sectors_per_cluster) {
85 case 1: case 2: case 4: case 8: case 16: case 32: case 64: case 128:
86 break;
87 default:
88 if ((b->bpb.sectors_per_cluster < 240)
89 || (b->bpb.sectors_per_cluster > 253)) {
90 if (b->bpb.sectors_per_cluster > 128)
91 ntfs_log_error("Unexpected sectors"
92 " per cluster value (code 0x%x)\n",
93 b->bpb.sectors_per_cluster);
94 else
95 ntfs_log_error("Unexpected sectors"
96 " per cluster value (%d).\n",
97 b->bpb.sectors_per_cluster);
98 goto not_ntfs;
99 }
100 }
101
102 ntfs_log_debug("Checking cluster size.\n");
103 if (b->bpb.sectors_per_cluster > 128)
104 sectors_per_cluster = 1 << (256 - b->bpb.sectors_per_cluster);
105 else
106 sectors_per_cluster = b->bpb.sectors_per_cluster;
107 i = (u32)le16_to_cpu(b->bpb.bytes_per_sector) * sectors_per_cluster;
108 if (i > NTFS_MAX_CLUSTER_SIZE) {
109 ntfs_log_error("Unexpected cluster size (%d).\n", i);
110 goto not_ntfs;
111 }
112
113 ntfs_log_debug("Checking reserved fields are zero.\n");
114 if (le16_to_cpu(b->bpb.reserved_sectors) ||
115 le16_to_cpu(b->bpb.root_entries) ||
116 le16_to_cpu(b->bpb.sectors) ||
117 le16_to_cpu(b->bpb.sectors_per_fat) ||
118 le32_to_cpu(b->bpb.large_sectors) ||
119 b->bpb.fats) {
120 ntfs_log_error("Reserved fields aren't zero "
121 "(%d, %d, %d, %d, %d, %d).\n",
122 le16_to_cpu(b->bpb.reserved_sectors),
123 le16_to_cpu(b->bpb.root_entries),
124 le16_to_cpu(b->bpb.sectors),
125 le16_to_cpu(b->bpb.sectors_per_fat),
126 le32_to_cpu(b->bpb.large_sectors),
127 b->bpb.fats);
128 goto not_ntfs;
129 }
130
131 ntfs_log_debug("Checking clusters per mft record.\n");
132 if ((u8)b->clusters_per_mft_record < 0xe1 ||
133 (u8)b->clusters_per_mft_record > 0xf7) {
134 switch (b->clusters_per_mft_record) {
135 case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40:
136 break;
137 default:
138 ntfs_log_error("Unexpected clusters per mft record "
139 "(%d).\n", b->clusters_per_mft_record);
140 goto not_ntfs;
141 }
142 }
143
144 ntfs_log_debug("Checking clusters per index block.\n");
145 if ((u8)b->clusters_per_index_record < 0xe1 ||
146 (u8)b->clusters_per_index_record > 0xf7) {
147 switch (b->clusters_per_index_record) {
148 case 1: case 2: case 4: case 8: case 0x10: case 0x20: case 0x40:
149 break;
150 default:
151 ntfs_log_error("Unexpected clusters per index record "
152 "(%d).\n", b->clusters_per_index_record);
153 goto not_ntfs;
154 }
155 }
156
157 /* MFT and MFTMirr may not overlap the boot sector or be the same */
158 if (((s64)sle64_to_cpu(b->mft_lcn) <= 0)
159 || ((s64)sle64_to_cpu(b->mftmirr_lcn) <= 0)
160 || (b->mft_lcn == b->mftmirr_lcn)) {
161 ntfs_log_error("Invalid location of MFT or MFTMirr.\n");
162 goto not_ntfs;
163 }
164
165 if (b->end_of_sector_marker != const_cpu_to_le16(0xaa55))
166 ntfs_log_debug("Warning: Bootsector has invalid end of sector "
167 "marker.\n");
168
169 ntfs_log_debug("Bootsector check completed successfully.\n");
170
171 ret = TRUE;
172 not_ntfs:
173 return ret;
174 }
175
176 static const char *last_sector_error =
177 "HINTS: Either the volume is a RAID/LDM but it wasn't setup yet,\n"
178 " or it was not setup correctly (e.g. by not using mdadm --build ...),\n"
179 " or a wrong device is tried to be mounted,\n"
180 " or the partition table is corrupt (partition is smaller than NTFS),\n"
181 " or the NTFS boot sector is corrupt (NTFS size is not valid).\n";
182
183 /**
184 * ntfs_boot_sector_parse - setup an ntfs volume from an ntfs boot sector
185 * @vol: ntfs_volume to setup
186 * @bs: buffer containing ntfs boot sector to parse
187 *
188 * Parse the ntfs bootsector @bs and setup the ntfs volume @vol with the
189 * obtained values.
190 *
191 * Return 0 on success or -1 on error with errno set to the error code EINVAL.
192 */
ntfs_boot_sector_parse(ntfs_volume * vol,const NTFS_BOOT_SECTOR * bs)193 int ntfs_boot_sector_parse(ntfs_volume *vol, const NTFS_BOOT_SECTOR *bs)
194 {
195 s64 sectors;
196 u16 sectors_per_cluster;
197 s8 c;
198
199 /* We return -1 with errno = EINVAL on error. */
200 errno = EINVAL;
201
202 vol->sector_size = le16_to_cpu(bs->bpb.bytes_per_sector);
203 vol->sector_size_bits = ffs(vol->sector_size) - 1;
204 ntfs_log_debug("SectorSize = 0x%x\n", vol->sector_size);
205 ntfs_log_debug("SectorSizeBits = %u\n", vol->sector_size_bits);
206 /*
207 * The bounds checks on mft_lcn and mft_mirr_lcn (i.e. them being
208 * below or equal the number_of_clusters) really belong in the
209 * ntfs_boot_sector_is_ntfs but in this way we can just do this once.
210 */
211 if (bs->bpb.sectors_per_cluster > 128)
212 sectors_per_cluster = 1 << (256 - bs->bpb.sectors_per_cluster);
213 else
214 sectors_per_cluster = bs->bpb.sectors_per_cluster;
215 ntfs_log_debug("SectorsPerCluster = 0x%x\n", sectors_per_cluster);
216 if (sectors_per_cluster & (sectors_per_cluster - 1)) {
217 ntfs_log_error("sectors_per_cluster (%d) is not a power of 2."
218 "\n", sectors_per_cluster);
219 return -1;
220 }
221
222 sectors = sle64_to_cpu(bs->number_of_sectors);
223 ntfs_log_debug("NumberOfSectors = %lld\n", (long long)sectors);
224 if (!sectors) {
225 ntfs_log_error("Volume size is set to zero.\n");
226 return -1;
227 }
228 if (vol->dev->d_ops->seek(vol->dev,
229 (sectors - 1) << vol->sector_size_bits,
230 SEEK_SET) == -1) {
231 ntfs_log_perror("Failed to read last sector (%lld)",
232 (long long)(sectors - 1));
233 ntfs_log_error("%s", last_sector_error);
234 return -1;
235 }
236
237 vol->nr_clusters = sectors >> (ffs(sectors_per_cluster) - 1);
238
239 vol->mft_lcn = sle64_to_cpu(bs->mft_lcn);
240 vol->mftmirr_lcn = sle64_to_cpu(bs->mftmirr_lcn);
241 ntfs_log_debug("MFT LCN = %lld\n", (long long)vol->mft_lcn);
242 ntfs_log_debug("MFTMirr LCN = %lld\n", (long long)vol->mftmirr_lcn);
243 if ((vol->mft_lcn < 0 || vol->mft_lcn > vol->nr_clusters) ||
244 (vol->mftmirr_lcn < 0 || vol->mftmirr_lcn > vol->nr_clusters)) {
245 ntfs_log_error("$MFT LCN (%lld) or $MFTMirr LCN (%lld) is "
246 "greater than the number of clusters (%lld).\n",
247 (long long)vol->mft_lcn, (long long)vol->mftmirr_lcn,
248 (long long)vol->nr_clusters);
249 return -1;
250 }
251
252 vol->cluster_size = sectors_per_cluster * vol->sector_size;
253 if (vol->cluster_size & (vol->cluster_size - 1)) {
254 ntfs_log_error("cluster_size (%d) is not a power of 2.\n",
255 vol->cluster_size);
256 return -1;
257 }
258 vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
259 /*
260 * Need to get the clusters per mft record and handle it if it is
261 * negative. Then calculate the mft_record_size. A value of 0x80 is
262 * illegal, thus signed char is actually ok!
263 */
264 c = bs->clusters_per_mft_record;
265 ntfs_log_debug("ClusterSize = 0x%x\n", (unsigned)vol->cluster_size);
266 ntfs_log_debug("ClusterSizeBits = %u\n", vol->cluster_size_bits);
267 ntfs_log_debug("ClustersPerMftRecord = 0x%x\n", c);
268 /*
269 * When clusters_per_mft_record is negative, it means that it is to
270 * be taken to be the negative base 2 logarithm of the mft_record_size
271 * min bytes. Then:
272 * mft_record_size = 2^(-clusters_per_mft_record) bytes.
273 */
274 if (c < 0)
275 vol->mft_record_size = 1 << -c;
276 else
277 vol->mft_record_size = c << vol->cluster_size_bits;
278 if (vol->mft_record_size & (vol->mft_record_size - 1)) {
279 ntfs_log_error("mft_record_size (%d) is not a power of 2.\n",
280 vol->mft_record_size);
281 return -1;
282 }
283 vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
284 ntfs_log_debug("MftRecordSize = 0x%x\n", (unsigned)vol->mft_record_size);
285 ntfs_log_debug("MftRecordSizeBits = %u\n", vol->mft_record_size_bits);
286 /* Same as above for INDX record. */
287 c = bs->clusters_per_index_record;
288 ntfs_log_debug("ClustersPerINDXRecord = 0x%x\n", c);
289 if (c < 0)
290 vol->indx_record_size = 1 << -c;
291 else
292 vol->indx_record_size = c << vol->cluster_size_bits;
293 vol->indx_record_size_bits = ffs(vol->indx_record_size) - 1;
294 ntfs_log_debug("INDXRecordSize = 0x%x\n", (unsigned)vol->indx_record_size);
295 ntfs_log_debug("INDXRecordSizeBits = %u\n", vol->indx_record_size_bits);
296 /*
297 * Work out the size of the MFT mirror in number of mft records. If the
298 * cluster size is less than or equal to the size taken by four mft
299 * records, the mft mirror stores the first four mft records. If the
300 * cluster size is bigger than the size taken by four mft records, the
301 * mft mirror contains as many mft records as will fit into one
302 * cluster.
303 */
304 if (vol->cluster_size <= 4 * vol->mft_record_size)
305 vol->mftmirr_size = 4;
306 else
307 vol->mftmirr_size = vol->cluster_size / vol->mft_record_size;
308 return 0;
309 }
310
311