Kernel

Kernel Git Source Tree

Root/fs/ntfs/super.c

1	/*
2	* super.c - NTFS kernel super block handling. Part of the Linux-NTFS project.
3	*
4	* Copyright (c) 2001-2011 Anton Altaparmakov and Tuxera Inc.
5	* Copyright (c) 2001,2002 Richard Russon
6	*
7	* This program/include file is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU General Public License as published
9	* by the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program/include file is distributed in the hope that it will be
13	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
14	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program (in the main directory of the Linux-NTFS
19	* distribution in the file COPYING); if not, write to the Free Software
20	* Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21	*/
22
23	#include <linux/stddef.h>
24	#include <linux/init.h>
25	#include <linux/slab.h>
26	#include <linux/string.h>
27	#include <linux/spinlock.h>
28	#include <linux/blkdev.h> /* For bdev_logical_block_size(). */
29	#include <linux/backing-dev.h>
30	#include <linux/buffer_head.h>
31	#include <linux/vfs.h>
32	#include <linux/moduleparam.h>
33	#include <linux/bitmap.h>
34
35	#include "sysctl.h"
36	#include "logfile.h"
37	#include "quota.h"
38	#include "usnjrnl.h"
39	#include "dir.h"
40	#include "debug.h"
41	#include "index.h"
42	#include "inode.h"
43	#include "aops.h"
44	#include "layout.h"
45	#include "malloc.h"
46	#include "ntfs.h"
47
48	/* Number of mounted filesystems which have compression enabled. */
49	static unsigned long ntfs_nr_compression_users;
50
51	/* A global default upcase table and a corresponding reference count. */
52	static ntfschar *default_upcase = NULL;
53	static unsigned long ntfs_nr_upcase_users = 0;
54
55	/* Error constants/strings used in inode.c::ntfs_show_options(). */
56	typedef enum {
57	/* One of these must be present, default is ON_ERRORS_CONTINUE. */
58	ON_ERRORS_PANIC = 0x01,
59	ON_ERRORS_REMOUNT_RO = 0x02,
60	ON_ERRORS_CONTINUE = 0x04,
61	/* Optional, can be combined with any of the above. */
62	ON_ERRORS_RECOVER = 0x10,
63	} ON_ERRORS_ACTIONS;
64
65	const option_t on_errors_arr[] = {
66	{ ON_ERRORS_PANIC, "panic" },
67	{ ON_ERRORS_REMOUNT_RO, "remount-ro", },
68	{ ON_ERRORS_CONTINUE, "continue", },
69	{ ON_ERRORS_RECOVER, "recover" },
70	{ 0, NULL }
71	};
72
73	/**
74	* simple_getbool -
75	*
76	* Copied from old ntfs driver (which copied from vfat driver).
77	*/
78	static int simple_getbool(char s, bool setval)
79	{
80	if (s) {
81	if (!strcmp(s, "1") \|\| !strcmp(s, "yes") \|\| !strcmp(s, "true"))
82	*setval = true;
83	else if (!strcmp(s, "0") \|\| !strcmp(s, "no") \|\|
84	!strcmp(s, "false"))
85	*setval = false;
86	else
87	return 0;
88	} else
89	*setval = true;
90	return 1;
91	}
92
93	/**
94	* parse_options - parse the (re)mount options
95	* @vol: ntfs volume
96	* @opt: string containing the (re)mount options
97	*
98	* Parse the recognized options in @opt for the ntfs volume described by @vol.
99	*/
100	static bool parse_options(ntfs_volume vol, char opt)
101	{
102	char p, v, *ov;
103	static char *utf8 = "utf8";
104	int errors = 0, sloppy = 0;
105	uid_t uid = (uid_t)-1;
106	gid_t gid = (gid_t)-1;
107	mode_t fmask = (mode_t)-1, dmask = (mode_t)-1;
108	int mft_zone_multiplier = -1, on_errors = -1;
109	int show_sys_files = -1, case_sensitive = -1, disable_sparse = -1;
110	struct nls_table nls_map = NULL, old_nls;
111
112	/* I am lazy... (-8 */
113	#define NTFS_GETOPT_WITH_DEFAULT(option, variable, default_value) \
114	if (!strcmp(p, option)) { \
115	if (!v \|\| !*v) \
116	variable = default_value; \
117	else { \
118	variable = simple_strtoul(ov = v, &v, 0); \
119	if (*v) \
120	goto needs_val; \
121	} \
122	}
123	#define NTFS_GETOPT(option, variable) \
124	if (!strcmp(p, option)) { \
125	if (!v \|\| !*v) \
126	goto needs_arg; \
127	variable = simple_strtoul(ov = v, &v, 0); \
128	if (*v) \
129	goto needs_val; \
130	}
131	#define NTFS_GETOPT_OCTAL(option, variable) \
132	if (!strcmp(p, option)) { \
133	if (!v \|\| !*v) \
134	goto needs_arg; \
135	variable = simple_strtoul(ov = v, &v, 8); \
136	if (*v) \
137	goto needs_val; \
138	}
139	#define NTFS_GETOPT_BOOL(option, variable) \
140	if (!strcmp(p, option)) { \
141	bool val; \
142	if (!simple_getbool(v, &val)) \
143	goto needs_bool; \
144	variable = val; \
145	}
146	#define NTFS_GETOPT_OPTIONS_ARRAY(option, variable, opt_array) \
147	if (!strcmp(p, option)) { \
148	int _i; \
149	if (!v \|\| !*v) \
150	goto needs_arg; \
151	ov = v; \
152	if (variable == -1) \
153	variable = 0; \
154	for (_i = 0; opt_array[_i].str && *opt_array[_i].str; _i++) \
155	if (!strcmp(opt_array[_i].str, v)) { \
156	variable \|= opt_array[_i].val; \
157	break; \
158	} \
159	if (!opt_array[_i].str \|\| !*opt_array[_i].str) \
160	goto needs_val; \
161	}
162	if (!opt \|\| !*opt)
163	goto no_mount_options;
164	ntfs_debug("Entering with mount options string: %s", opt);
165	while ((p = strsep(&opt, ","))) {
166	if ((v = strchr(p, '=')))
167	*v++ = 0;
168	NTFS_GETOPT("uid", uid)
169	else NTFS_GETOPT("gid", gid)
170	else NTFS_GETOPT_OCTAL("umask", fmask = dmask)
171	else NTFS_GETOPT_OCTAL("fmask", fmask)
172	else NTFS_GETOPT_OCTAL("dmask", dmask)
173	else NTFS_GETOPT("mft_zone_multiplier", mft_zone_multiplier)
174	else NTFS_GETOPT_WITH_DEFAULT("sloppy", sloppy, true)
175	else NTFS_GETOPT_BOOL("show_sys_files", show_sys_files)
176	else NTFS_GETOPT_BOOL("case_sensitive", case_sensitive)
177	else NTFS_GETOPT_BOOL("disable_sparse", disable_sparse)
178	else NTFS_GETOPT_OPTIONS_ARRAY("errors", on_errors,
179	on_errors_arr)
180	else if (!strcmp(p, "posix") \|\| !strcmp(p, "show_inodes"))
181	ntfs_warning(vol->sb, "Ignoring obsolete option %s.",
182	p);
183	else if (!strcmp(p, "nls") \|\| !strcmp(p, "iocharset")) {
184	if (!strcmp(p, "iocharset"))
185	ntfs_warning(vol->sb, "Option iocharset is "
186	"deprecated. Please use "
187	"option nls=<charsetname> in "
188	"the future.");
189	if (!v \|\| !*v)
190	goto needs_arg;
191	use_utf8:
192	old_nls = nls_map;
193	nls_map = load_nls(v);
194	if (!nls_map) {
195	if (!old_nls) {
196	ntfs_error(vol->sb, "NLS character set "
197	"%s not found.", v);
198	return false;
199	}
200	ntfs_error(vol->sb, "NLS character set %s not "
201	"found. Using previous one %s.",
202	v, old_nls->charset);
203	nls_map = old_nls;
204	} else /* nls_map */ {
205	unload_nls(old_nls);
206	}
207	} else if (!strcmp(p, "utf8")) {
208	bool val = false;
209	ntfs_warning(vol->sb, "Option utf8 is no longer "
210	"supported, using option nls=utf8. Please "
211	"use option nls=utf8 in the future and "
212	"make sure utf8 is compiled either as a "
213	"module or into the kernel.");
214	if (!v \|\| !*v)
215	val = true;
216	else if (!simple_getbool(v, &val))
217	goto needs_bool;
218	if (val) {
219	v = utf8;
220	goto use_utf8;
221	}
222	} else {
223	ntfs_error(vol->sb, "Unrecognized mount option %s.", p);
224	if (errors < INT_MAX)
225	errors++;
226	}
227	#undef NTFS_GETOPT_OPTIONS_ARRAY
228	#undef NTFS_GETOPT_BOOL
229	#undef NTFS_GETOPT
230	#undef NTFS_GETOPT_WITH_DEFAULT
231	}
232	no_mount_options:
233	if (errors && !sloppy)
234	return false;
235	if (sloppy)
236	ntfs_warning(vol->sb, "Sloppy option given. Ignoring "
237	"unrecognized mount option(s) and continuing.");
238	/* Keep this first! */
239	if (on_errors != -1) {
240	if (!on_errors) {
241	ntfs_error(vol->sb, "Invalid errors option argument "
242	"or bug in options parser.");
243	return false;
244	}
245	}
246	if (nls_map) {
247	if (vol->nls_map && vol->nls_map != nls_map) {
248	ntfs_error(vol->sb, "Cannot change NLS character set "
249	"on remount.");
250	return false;
251	} /* else (!vol->nls_map) */
252	ntfs_debug("Using NLS character set %s.", nls_map->charset);
253	vol->nls_map = nls_map;
254	} else /* (!nls_map) */ {
255	if (!vol->nls_map) {
256	vol->nls_map = load_nls_default();
257	if (!vol->nls_map) {
258	ntfs_error(vol->sb, "Failed to load default "
259	"NLS character set.");
260	return false;
261	}
262	ntfs_debug("Using default NLS character set (%s).",
263	vol->nls_map->charset);
264	}
265	}
266	if (mft_zone_multiplier != -1) {
267	if (vol->mft_zone_multiplier && vol->mft_zone_multiplier !=
268	mft_zone_multiplier) {
269	ntfs_error(vol->sb, "Cannot change mft_zone_multiplier "
270	"on remount.");
271	return false;
272	}
273	if (mft_zone_multiplier < 1 \|\| mft_zone_multiplier > 4) {
274	ntfs_error(vol->sb, "Invalid mft_zone_multiplier. "
275	"Using default value, i.e. 1.");
276	mft_zone_multiplier = 1;
277	}
278	vol->mft_zone_multiplier = mft_zone_multiplier;
279	}
280	if (!vol->mft_zone_multiplier)
281	vol->mft_zone_multiplier = 1;
282	if (on_errors != -1)
283	vol->on_errors = on_errors;
284	if (!vol->on_errors \|\| vol->on_errors == ON_ERRORS_RECOVER)
285	vol->on_errors \|= ON_ERRORS_CONTINUE;
286	if (uid != (uid_t)-1)
287	vol->uid = uid;
288	if (gid != (gid_t)-1)
289	vol->gid = gid;
290	if (fmask != (mode_t)-1)
291	vol->fmask = fmask;
292	if (dmask != (mode_t)-1)
293	vol->dmask = dmask;
294	if (show_sys_files != -1) {
295	if (show_sys_files)
296	NVolSetShowSystemFiles(vol);
297	else
298	NVolClearShowSystemFiles(vol);
299	}
300	if (case_sensitive != -1) {
301	if (case_sensitive)
302	NVolSetCaseSensitive(vol);
303	else
304	NVolClearCaseSensitive(vol);
305	}
306	if (disable_sparse != -1) {
307	if (disable_sparse)
308	NVolClearSparseEnabled(vol);
309	else {
310	if (!NVolSparseEnabled(vol) &&
311	vol->major_ver && vol->major_ver < 3)
312	ntfs_warning(vol->sb, "Not enabling sparse "
313	"support due to NTFS volume "
314	"version %i.%i (need at least "
315	"version 3.0).", vol->major_ver,
316	vol->minor_ver);
317	else
318	NVolSetSparseEnabled(vol);
319	}
320	}
321	return true;
322	needs_arg:
323	ntfs_error(vol->sb, "The %s option requires an argument.", p);
324	return false;
325	needs_bool:
326	ntfs_error(vol->sb, "The %s option requires a boolean argument.", p);
327	return false;
328	needs_val:
329	ntfs_error(vol->sb, "Invalid %s option argument: %s", p, ov);
330	return false;
331	}
332
333	#ifdef NTFS_RW
334
335	/**
336	* ntfs_write_volume_flags - write new flags to the volume information flags
337	* @vol: ntfs volume on which to modify the flags
338	* @flags: new flags value for the volume information flags
339	*
340	* Internal function. You probably want to use ntfs_{set,clear}_volume_flags()
341	* instead (see below).
342	*
343	* Replace the volume information flags on the volume @vol with the value
344	* supplied in @flags. Note, this overwrites the volume information flags, so
345	* make sure to combine the flags you want to modify with the old flags and use
346	* the result when calling ntfs_write_volume_flags().
347	*
348	* Return 0 on success and -errno on error.
349	*/
350	static int ntfs_write_volume_flags(ntfs_volume *vol, const VOLUME_FLAGS flags)
351	{
352	ntfs_inode *ni = NTFS_I(vol->vol_ino);
353	MFT_RECORD *m;
354	VOLUME_INFORMATION *vi;
355	ntfs_attr_search_ctx *ctx;
356	int err;
357
358	ntfs_debug("Entering, old flags = 0x%x, new flags = 0x%x.",
359	le16_to_cpu(vol->vol_flags), le16_to_cpu(flags));
360	if (vol->vol_flags == flags)
361	goto done;
362	BUG_ON(!ni);
363	m = map_mft_record(ni);
364	if (IS_ERR(m)) {
365	err = PTR_ERR(m);
366	goto err_out;
367	}
368	ctx = ntfs_attr_get_search_ctx(ni, m);
369	if (!ctx) {
370	err = -ENOMEM;
371	goto put_unm_err_out;
372	}
373	err = ntfs_attr_lookup(AT_VOLUME_INFORMATION, NULL, 0, 0, 0, NULL, 0,
374	ctx);
375	if (err)
376	goto put_unm_err_out;
377	vi = (VOLUME_INFORMATION)((u8)ctx->attr +
378	le16_to_cpu(ctx->attr->data.resident.value_offset));
379	vol->vol_flags = vi->flags = flags;
380	flush_dcache_mft_record_page(ctx->ntfs_ino);
381	mark_mft_record_dirty(ctx->ntfs_ino);
382	ntfs_attr_put_search_ctx(ctx);
383	unmap_mft_record(ni);
384	done:
385	ntfs_debug("Done.");
386	return 0;
387	put_unm_err_out:
388	if (ctx)
389	ntfs_attr_put_search_ctx(ctx);
390	unmap_mft_record(ni);
391	err_out:
392	ntfs_error(vol->sb, "Failed with error code %i.", -err);
393	return err;
394	}
395
396	/**
397	* ntfs_set_volume_flags - set bits in the volume information flags
398	* @vol: ntfs volume on which to modify the flags
399	* @flags: flags to set on the volume
400	*
401	* Set the bits in @flags in the volume information flags on the volume @vol.
402	*
403	* Return 0 on success and -errno on error.
404	*/
405	static inline int ntfs_set_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
406	{
407	flags &= VOLUME_FLAGS_MASK;
408	return ntfs_write_volume_flags(vol, vol->vol_flags \| flags);
409	}
410
411	/**
412	* ntfs_clear_volume_flags - clear bits in the volume information flags
413	* @vol: ntfs volume on which to modify the flags
414	* @flags: flags to clear on the volume
415	*
416	* Clear the bits in @flags in the volume information flags on the volume @vol.
417	*
418	* Return 0 on success and -errno on error.
419	*/
420	static inline int ntfs_clear_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
421	{
422	flags &= VOLUME_FLAGS_MASK;
423	flags = vol->vol_flags & cpu_to_le16(~le16_to_cpu(flags));
424	return ntfs_write_volume_flags(vol, flags);
425	}
426
427	#endif /* NTFS_RW */
428
429	/**
430	* ntfs_remount - change the mount options of a mounted ntfs filesystem
431	* @sb: superblock of mounted ntfs filesystem
432	* @flags: remount flags
433	* @opt: remount options string
434	*
435	* Change the mount options of an already mounted ntfs filesystem.
436	*
437	* NOTE: The VFS sets the @sb->s_flags remount flags to @flags after
438	* ntfs_remount() returns successfully (i.e. returns 0). Otherwise,
439	* @sb->s_flags are not changed.
440	*/
441	static int ntfs_remount(struct super_block sb, int flags, char *opt)
442	{
443	ntfs_volume *vol = NTFS_SB(sb);
444
445	ntfs_debug("Entering with remount options string: %s", opt);
446
447	#ifndef NTFS_RW
448	/* For read-only compiled driver, enforce read-only flag. */
449	*flags \|= MS_RDONLY;
450	#else /* NTFS_RW */
451	/*
452	* For the read-write compiled driver, if we are remounting read-write,
453	* make sure there are no volume errors and that no unsupported volume
454	* flags are set. Also, empty the logfile journal as it would become
455	* stale as soon as something is written to the volume and mark the
456	* volume dirty so that chkdsk is run if the volume is not umounted
457	* cleanly. Finally, mark the quotas out of date so Windows rescans
458	* the volume on boot and updates them.
459	*
460	* When remounting read-only, mark the volume clean if no volume errors
461	* have occurred.
462	*/
463	if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
464	static const char *es = ". Cannot remount read-write.";
465
466	/* Remounting read-write. */
467	if (NVolErrors(vol)) {
468	ntfs_error(sb, "Volume has errors and is read-only%s",
469	es);
470	return -EROFS;
471	}
472	if (vol->vol_flags & VOLUME_IS_DIRTY) {
473	ntfs_error(sb, "Volume is dirty and read-only%s", es);
474	return -EROFS;
475	}
476	if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
477	ntfs_error(sb, "Volume has been modified by chkdsk "
478	"and is read-only%s", es);
479	return -EROFS;
480	}
481	if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
482	ntfs_error(sb, "Volume has unsupported flags set "
483	"(0x%x) and is read-only%s",
484	(unsigned)le16_to_cpu(vol->vol_flags),
485	es);
486	return -EROFS;
487	}
488	if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
489	ntfs_error(sb, "Failed to set dirty bit in volume "
490	"information flags%s", es);
491	return -EROFS;
492	}
493	#if 0
494	// TODO: Enable this code once we start modifying anything that
495	// is different between NTFS 1.2 and 3.x...
496	/* Set NT4 compatibility flag on newer NTFS version volumes. */
497	if ((vol->major_ver > 1)) {
498	if (ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
499	ntfs_error(sb, "Failed to set NT4 "
500	"compatibility flag%s", es);
501	NVolSetErrors(vol);
502	return -EROFS;
503	}
504	}
505	#endif
506	if (!ntfs_empty_logfile(vol->logfile_ino)) {
507	ntfs_error(sb, "Failed to empty journal $LogFile%s",
508	es);
509	NVolSetErrors(vol);
510	return -EROFS;
511	}
512	if (!ntfs_mark_quotas_out_of_date(vol)) {
513	ntfs_error(sb, "Failed to mark quotas out of date%s",
514	es);
515	NVolSetErrors(vol);
516	return -EROFS;
517	}
518	if (!ntfs_stamp_usnjrnl(vol)) {
519	ntfs_error(sb, "Failed to stamp transation log "
520	"($UsnJrnl)%s", es);
521	NVolSetErrors(vol);
522	return -EROFS;
523	}
524	} else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) {
525	/* Remounting read-only. */
526	if (!NVolErrors(vol)) {
527	if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
528	ntfs_warning(sb, "Failed to clear dirty bit "
529	"in volume information "
530	"flags. Run chkdsk.");
531	}
532	}
533	#endif /* NTFS_RW */
534
535	// TODO: Deal with *flags.
536
537	if (!parse_options(vol, opt))
538	return -EINVAL;
539
540	ntfs_debug("Done.");
541	return 0;
542	}
543
544	/**
545	* is_boot_sector_ntfs - check whether a boot sector is a valid NTFS boot sector
546	* @sb: Super block of the device to which @b belongs.
547	* @b: Boot sector of device @sb to check.
548	* @silent: If 'true', all output will be silenced.
549	*
550	* is_boot_sector_ntfs() checks whether the boot sector @b is a valid NTFS boot
551	* sector. Returns 'true' if it is valid and 'false' if not.
552	*
553	* @sb is only needed for warning/error output, i.e. it can be NULL when silent
554	* is 'true'.
555	*/
556	static bool is_boot_sector_ntfs(const struct super_block *sb,
557	const NTFS_BOOT_SECTOR *b, const bool silent)
558	{
559	/*
560	* Check that checksum == sum of u32 values from b to the checksum
561	* field. If checksum is zero, no checking is done. We will work when
562	* the checksum test fails, since some utilities update the boot sector
563	* ignoring the checksum which leaves the checksum out-of-date. We
564	* report a warning if this is the case.
565	*/
566	if ((void)b < (void)&b->checksum && b->checksum && !silent) {
567	le32 *u;
568	u32 i;
569
570	for (i = 0, u = (le32)b; u < (le32)(&b->checksum); ++u)
571	i += le32_to_cpup(u);
572	if (le32_to_cpu(b->checksum) != i)
573	ntfs_warning(sb, "Invalid boot sector checksum.");
574	}
575	/* Check OEMidentifier is "NTFS " */
576	if (b->oem_id != magicNTFS)
577	goto not_ntfs;
578	/* Check bytes per sector value is between 256 and 4096. */
579	if (le16_to_cpu(b->bpb.bytes_per_sector) < 0x100 \|\|
580	le16_to_cpu(b->bpb.bytes_per_sector) > 0x1000)
581	goto not_ntfs;
582	/* Check sectors per cluster value is valid. */
583	switch (b->bpb.sectors_per_cluster) {
584	case 1: case 2: case 4: case 8: case 16: case 32: case 64: case 128:
585	break;
586	default:
587	goto not_ntfs;
588	}
589	/* Check the cluster size is not above the maximum (64kiB). */
590	if ((u32)le16_to_cpu(b->bpb.bytes_per_sector) *
591	b->bpb.sectors_per_cluster > NTFS_MAX_CLUSTER_SIZE)
592	goto not_ntfs;
593	/* Check reserved/unused fields are really zero. */
594	if (le16_to_cpu(b->bpb.reserved_sectors) \|\|
595	le16_to_cpu(b->bpb.root_entries) \|\|
596	le16_to_cpu(b->bpb.sectors) \|\|
597	le16_to_cpu(b->bpb.sectors_per_fat) \|\|
598	le32_to_cpu(b->bpb.large_sectors) \|\| b->bpb.fats)
599	goto not_ntfs;
600	/* Check clusters per file mft record value is valid. */
601	if ((u8)b->clusters_per_mft_record < 0xe1 \|\|
602	(u8)b->clusters_per_mft_record > 0xf7)
603	switch (b->clusters_per_mft_record) {
604	case 1: case 2: case 4: case 8: case 16: case 32: case 64:
605	break;
606	default:
607	goto not_ntfs;
608	}
609	/* Check clusters per index block value is valid. */
610	if ((u8)b->clusters_per_index_record < 0xe1 \|\|
611	(u8)b->clusters_per_index_record > 0xf7)
612	switch (b->clusters_per_index_record) {
613	case 1: case 2: case 4: case 8: case 16: case 32: case 64:
614	break;
615	default:
616	goto not_ntfs;
617	}
618	/*
619	* Check for valid end of sector marker. We will work without it, but
620	* many BIOSes will refuse to boot from a bootsector if the magic is
621	* incorrect, so we emit a warning.
622	*/
623	if (!silent && b->end_of_sector_marker != cpu_to_le16(0xaa55))
624	ntfs_warning(sb, "Invalid end of sector marker.");
625	return true;
626	not_ntfs:
627	return false;
628	}
629
630	/**
631	* read_ntfs_boot_sector - read the NTFS boot sector of a device
632	* @sb: super block of device to read the boot sector from
633	* @silent: if true, suppress all output
634	*
635	* Reads the boot sector from the device and validates it. If that fails, tries
636	* to read the backup boot sector, first from the end of the device a-la NT4 and
637	* later and then from the middle of the device a-la NT3.51 and before.
638	*
639	* If a valid boot sector is found but it is not the primary boot sector, we
640	* repair the primary boot sector silently (unless the device is read-only or
641	* the primary boot sector is not accessible).
642	*
643	* NOTE: To call this function, @sb must have the fields s_dev, the ntfs super
644	* block (u.ntfs_sb), nr_blocks and the device flags (s_flags) initialized
645	* to their respective values.
646	*
647	* Return the unlocked buffer head containing the boot sector or NULL on error.
648	*/
649	static struct buffer_head read_ntfs_boot_sector(struct super_block sb,
650	const int silent)
651	{
652	const char *read_err_str = "Unable to read %s boot sector.";
653	struct buffer_head bh_primary, bh_backup;
654	sector_t nr_blocks = NTFS_SB(sb)->nr_blocks;
655
656	/* Try to read primary boot sector. */
657	if ((bh_primary = sb_bread(sb, 0))) {
658	if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
659	bh_primary->b_data, silent))
660	return bh_primary;
661	if (!silent)
662	ntfs_error(sb, "Primary boot sector is invalid.");
663	} else if (!silent)
664	ntfs_error(sb, read_err_str, "primary");
665	if (!(NTFS_SB(sb)->on_errors & ON_ERRORS_RECOVER)) {
666	if (bh_primary)
667	brelse(bh_primary);
668	if (!silent)
669	ntfs_error(sb, "Mount option errors=recover not used. "
670	"Aborting without trying to recover.");
671	return NULL;
672	}
673	/* Try to read NT4+ backup boot sector. */
674	if ((bh_backup = sb_bread(sb, nr_blocks - 1))) {
675	if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
676	bh_backup->b_data, silent))
677	goto hotfix_primary_boot_sector;
678	brelse(bh_backup);
679	} else if (!silent)
680	ntfs_error(sb, read_err_str, "backup");
681	/* Try to read NT3.51- backup boot sector. */
682	if ((bh_backup = sb_bread(sb, nr_blocks >> 1))) {
683	if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
684	bh_backup->b_data, silent))
685	goto hotfix_primary_boot_sector;
686	if (!silent)
687	ntfs_error(sb, "Could not find a valid backup boot "
688	"sector.");
689	brelse(bh_backup);
690	} else if (!silent)
691	ntfs_error(sb, read_err_str, "backup");
692	/* We failed. Cleanup and return. */
693	if (bh_primary)
694	brelse(bh_primary);
695	return NULL;
696	hotfix_primary_boot_sector:
697	if (bh_primary) {
698	/*
699	* If we managed to read sector zero and the volume is not
700	* read-only, copy the found, valid backup boot sector to the
701	* primary boot sector. Note we only copy the actual boot
702	* sector structure, not the actual whole device sector as that
703	* may be bigger and would potentially damage the $Boot system
704	* file (FIXME: Would be nice to know if the backup boot sector
705	* on a large sector device contains the whole boot loader or
706	* just the first 512 bytes).
707	*/
708	if (!(sb->s_flags & MS_RDONLY)) {
709	ntfs_warning(sb, "Hot-fix: Recovering invalid primary "
710	"boot sector from backup copy.");
711	memcpy(bh_primary->b_data, bh_backup->b_data,
712	NTFS_BLOCK_SIZE);
713	mark_buffer_dirty(bh_primary);
714	sync_dirty_buffer(bh_primary);
715	if (buffer_uptodate(bh_primary)) {
716	brelse(bh_backup);
717	return bh_primary;
718	}
719	ntfs_error(sb, "Hot-fix: Device write error while "
720	"recovering primary boot sector.");
721	} else {
722	ntfs_warning(sb, "Hot-fix: Recovery of primary boot "
723	"sector failed: Read-only mount.");
724	}
725	brelse(bh_primary);
726	}
727	ntfs_warning(sb, "Using backup boot sector.");
728	return bh_backup;
729	}
730
731	/**
732	* parse_ntfs_boot_sector - parse the boot sector and store the data in @vol
733	* @vol: volume structure to initialise with data from boot sector
734	* @b: boot sector to parse
735	*
736	* Parse the ntfs boot sector @b and store all imporant information therein in
737	* the ntfs super block @vol. Return 'true' on success and 'false' on error.
738	*/
739	static bool parse_ntfs_boot_sector(ntfs_volume vol, const NTFS_BOOT_SECTOR b)
740	{
741	unsigned int sectors_per_cluster_bits, nr_hidden_sects;
742	int clusters_per_mft_record, clusters_per_index_record;
743	s64 ll;
744
745	vol->sector_size = le16_to_cpu(b->bpb.bytes_per_sector);
746	vol->sector_size_bits = ffs(vol->sector_size) - 1;
747	ntfs_debug("vol->sector_size = %i (0x%x)", vol->sector_size,
748	vol->sector_size);
749	ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
750	vol->sector_size_bits);
751	if (vol->sector_size < vol->sb->s_blocksize) {
752	ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
753	"device block size (%lu). This is not "
754	"supported. Sorry.", vol->sector_size,
755	vol->sb->s_blocksize);
756	return false;
757	}
758	ntfs_debug("sectors_per_cluster = 0x%x", b->bpb.sectors_per_cluster);
759	sectors_per_cluster_bits = ffs(b->bpb.sectors_per_cluster) - 1;
760	ntfs_debug("sectors_per_cluster_bits = 0x%x",
761	sectors_per_cluster_bits);
762	nr_hidden_sects = le32_to_cpu(b->bpb.hidden_sectors);
763	ntfs_debug("number of hidden sectors = 0x%x", nr_hidden_sects);
764	vol->cluster_size = vol->sector_size << sectors_per_cluster_bits;
765	vol->cluster_size_mask = vol->cluster_size - 1;
766	vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
767	ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
768	vol->cluster_size);
769	ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
770	ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
771	if (vol->cluster_size < vol->sector_size) {
772	ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
773	"sector size (%i). This is not supported. "
774	"Sorry.", vol->cluster_size, vol->sector_size);
775	return false;
776	}
777	clusters_per_mft_record = b->clusters_per_mft_record;
778	ntfs_debug("clusters_per_mft_record = %i (0x%x)",
779	clusters_per_mft_record, clusters_per_mft_record);
780	if (clusters_per_mft_record > 0)
781	vol->mft_record_size = vol->cluster_size <<
782	(ffs(clusters_per_mft_record) - 1);
783	else
784	/*
785	* When mft_record_size < cluster_size, clusters_per_mft_record
786	* = -log2(mft_record_size) bytes. mft_record_size normaly is
787	* 1024 bytes, which is encoded as 0xF6 (-10 in decimal).
788	*/
789	vol->mft_record_size = 1 << -clusters_per_mft_record;
790	vol->mft_record_size_mask = vol->mft_record_size - 1;
791	vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
792	ntfs_debug("vol->mft_record_size = %i (0x%x)", vol->mft_record_size,
793	vol->mft_record_size);
794	ntfs_debug("vol->mft_record_size_mask = 0x%x",
795	vol->mft_record_size_mask);
796	ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
797	vol->mft_record_size_bits, vol->mft_record_size_bits);
798	/*
799	* We cannot support mft record sizes above the PAGE_CACHE_SIZE since
800	* we store $MFT/$DATA, the table of mft records in the page cache.
801	*/
802	if (vol->mft_record_size > PAGE_CACHE_SIZE) {
803	ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
804	"PAGE_CACHE_SIZE on your system (%lu). "
805	"This is not supported. Sorry.",
806	vol->mft_record_size, PAGE_CACHE_SIZE);
807	return false;
808	}
809	/* We cannot support mft record sizes below the sector size. */
810	if (vol->mft_record_size < vol->sector_size) {
811	ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
812	"sector size (%i). This is not supported. "
813	"Sorry.", vol->mft_record_size,
814	vol->sector_size);
815	return false;
816	}
817	clusters_per_index_record = b->clusters_per_index_record;
818	ntfs_debug("clusters_per_index_record = %i (0x%x)",
819	clusters_per_index_record, clusters_per_index_record);
820	if (clusters_per_index_record > 0)
821	vol->index_record_size = vol->cluster_size <<
822	(ffs(clusters_per_index_record) - 1);
823	else
824	/*
825	* When index_record_size < cluster_size,
826	* clusters_per_index_record = -log2(index_record_size) bytes.
827	* index_record_size normaly equals 4096 bytes, which is
828	* encoded as 0xF4 (-12 in decimal).
829	*/
830	vol->index_record_size = 1 << -clusters_per_index_record;
831	vol->index_record_size_mask = vol->index_record_size - 1;
832	vol->index_record_size_bits = ffs(vol->index_record_size) - 1;
833	ntfs_debug("vol->index_record_size = %i (0x%x)",
834	vol->index_record_size, vol->index_record_size);
835	ntfs_debug("vol->index_record_size_mask = 0x%x",
836	vol->index_record_size_mask);
837	ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
838	vol->index_record_size_bits,
839	vol->index_record_size_bits);
840	/* We cannot support index record sizes below the sector size. */
841	if (vol->index_record_size < vol->sector_size) {
842	ntfs_error(vol->sb, "Index record size (%i) is smaller than "
843	"the sector size (%i). This is not "
844	"supported. Sorry.", vol->index_record_size,
845	vol->sector_size);
846	return false;
847	}
848	/*
849	* Get the size of the volume in clusters and check for 64-bit-ness.
850	* Windows currently only uses 32 bits to save the clusters so we do
851	* the same as it is much faster on 32-bit CPUs.
852	*/
853	ll = sle64_to_cpu(b->number_of_sectors) >> sectors_per_cluster_bits;
854	if ((u64)ll >= 1ULL << 32) {
855	ntfs_error(vol->sb, "Cannot handle 64-bit clusters. Sorry.");
856	return false;
857	}
858	vol->nr_clusters = ll;
859	ntfs_debug("vol->nr_clusters = 0x%llx", (long long)vol->nr_clusters);
860	/*
861	* On an architecture where unsigned long is 32-bits, we restrict the
862	* volume size to 2TiB (2^41). On a 64-bit architecture, the compiler
863	* will hopefully optimize the whole check away.
864	*/
865	if (sizeof(unsigned long) < 8) {
866	if ((ll << vol->cluster_size_bits) >= (1ULL << 41)) {
867	ntfs_error(vol->sb, "Volume size (%lluTiB) is too "
868	"large for this architecture. "
869	"Maximum supported is 2TiB. Sorry.",
870	(unsigned long long)ll >> (40 -
871	vol->cluster_size_bits));
872	return false;
873	}
874	}
875	ll = sle64_to_cpu(b->mft_lcn);
876	if (ll >= vol->nr_clusters) {
877	ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
878	"volume. Weird.", (unsigned long long)ll,
879	(unsigned long long)ll);
880	return false;
881	}
882	vol->mft_lcn = ll;
883	ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
884	ll = sle64_to_cpu(b->mftmirr_lcn);
885	if (ll >= vol->nr_clusters) {
886	ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
887	"of volume. Weird.", (unsigned long long)ll,
888	(unsigned long long)ll);
889	return false;
890	}
891	vol->mftmirr_lcn = ll;
892	ntfs_debug("vol->mftmirr_lcn = 0x%llx", (long long)vol->mftmirr_lcn);
893	#ifdef NTFS_RW
894	/*
895	* Work out the size of the mft mirror in number of mft records. If the
896	* cluster size is less than or equal to the size taken by four mft
897	* records, the mft mirror stores the first four mft records. If the
898	* cluster size is bigger than the size taken by four mft records, the
899	* mft mirror contains as many mft records as will fit into one
900	* cluster.
901	*/
902	if (vol->cluster_size <= (4 << vol->mft_record_size_bits))
903	vol->mftmirr_size = 4;
904	else
905	vol->mftmirr_size = vol->cluster_size >>
906	vol->mft_record_size_bits;
907	ntfs_debug("vol->mftmirr_size = %i", vol->mftmirr_size);
908	#endif /* NTFS_RW */
909	vol->serial_no = le64_to_cpu(b->volume_serial_number);
910	ntfs_debug("vol->serial_no = 0x%llx",
911	(unsigned long long)vol->serial_no);
912	return true;
913	}
914
915	/**
916	* ntfs_setup_allocators - initialize the cluster and mft allocators
917	* @vol: volume structure for which to setup the allocators
918	*
919	* Setup the cluster (lcn) and mft allocators to the starting values.
920	*/
921	static void ntfs_setup_allocators(ntfs_volume *vol)
922	{
923	#ifdef NTFS_RW
924	LCN mft_zone_size, mft_lcn;
925	#endif /* NTFS_RW */
926
927	ntfs_debug("vol->mft_zone_multiplier = 0x%x",
928	vol->mft_zone_multiplier);
929	#ifdef NTFS_RW
930	/* Determine the size of the MFT zone. */
931	mft_zone_size = vol->nr_clusters;
932	switch (vol->mft_zone_multiplier) { /* % of volume size in clusters */
933	case 4:
934	mft_zone_size >>= 1; /* 50% */
935	break;
936	case 3:
937	mft_zone_size = (mft_zone_size +
938	(mft_zone_size >> 1)) >> 2; /* 37.5% */
939	break;
940	case 2:
941	mft_zone_size >>= 2; /* 25% */
942	break;
943	/* case 1: */
944	default:
945	mft_zone_size >>= 3; /* 12.5% */
946	break;
947	}
948	/* Setup the mft zone. */
949	vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
950	ntfs_debug("vol->mft_zone_pos = 0x%llx",
951	(unsigned long long)vol->mft_zone_pos);
952	/*
953	* Calculate the mft_lcn for an unmodified NTFS volume (see mkntfs
954	* source) and if the actual mft_lcn is in the expected place or even
955	* further to the front of the volume, extend the mft_zone to cover the
956	* beginning of the volume as well. This is in order to protect the
957	* area reserved for the mft bitmap as well within the mft_zone itself.
958	* On non-standard volumes we do not protect it as the overhead would
959	* be higher than the speed increase we would get by doing it.
960	*/
961	mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
962	if (mft_lcn * vol->cluster_size < 16 * 1024)
963	mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
964	vol->cluster_size;
965	if (vol->mft_zone_start <= mft_lcn)
966	vol->mft_zone_start = 0;
967	ntfs_debug("vol->mft_zone_start = 0x%llx",
968	(unsigned long long)vol->mft_zone_start);
969	/*
970	* Need to cap the mft zone on non-standard volumes so that it does
971	* not point outside the boundaries of the volume. We do this by
972	* halving the zone size until we are inside the volume.
973	*/
974	vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
975	while (vol->mft_zone_end >= vol->nr_clusters) {
976	mft_zone_size >>= 1;
977	vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
978	}
979	ntfs_debug("vol->mft_zone_end = 0x%llx",
980	(unsigned long long)vol->mft_zone_end);
981	/*
982	* Set the current position within each data zone to the start of the
983	* respective zone.
984	*/
985	vol->data1_zone_pos = vol->mft_zone_end;
986	ntfs_debug("vol->data1_zone_pos = 0x%llx",
987	(unsigned long long)vol->data1_zone_pos);
988	vol->data2_zone_pos = 0;
989	ntfs_debug("vol->data2_zone_pos = 0x%llx",
990	(unsigned long long)vol->data2_zone_pos);
991
992	/* Set the mft data allocation position to mft record 24. */
993	vol->mft_data_pos = 24;
994	ntfs_debug("vol->mft_data_pos = 0x%llx",
995	(unsigned long long)vol->mft_data_pos);
996	#endif /* NTFS_RW */
997	}
998
999	#ifdef NTFS_RW
1000
1001	/**
1002	* load_and_init_mft_mirror - load and setup the mft mirror inode for a volume
1003	* @vol: ntfs super block describing device whose mft mirror to load
1004	*
1005	* Return 'true' on success or 'false' on error.
1006	*/
1007	static bool load_and_init_mft_mirror(ntfs_volume *vol)
1008	{
1009	struct inode *tmp_ino;
1010	ntfs_inode *tmp_ni;
1011
1012	ntfs_debug("Entering.");
1013	/* Get mft mirror inode. */
1014	tmp_ino = ntfs_iget(vol->sb, FILE_MFTMirr);
1015	if (IS_ERR(tmp_ino) \|\| is_bad_inode(tmp_ino)) {
1016	if (!IS_ERR(tmp_ino))
1017	iput(tmp_ino);
1018	/* Caller will display error message. */
1019	return false;
1020	}
1021	/*
1022	* Re-initialize some specifics about $MFTMirr's inode as
1023	* ntfs_read_inode() will have set up the default ones.
1024	*/
1025	/* Set uid and gid to root. */
1026	tmp_ino->i_uid = tmp_ino->i_gid = 0;
1027	/* Regular file. No access for anyone. */
1028	tmp_ino->i_mode = S_IFREG;
1029	/* No VFS initiated operations allowed for $MFTMirr. */
1030	tmp_ino->i_op = &ntfs_empty_inode_ops;
1031	tmp_ino->i_fop = &ntfs_empty_file_ops;
1032	/* Put in our special address space operations. */
1033	tmp_ino->i_mapping->a_ops = &ntfs_mst_aops;
1034	tmp_ni = NTFS_I(tmp_ino);
1035	/* The $MFTMirr, like the $MFT is multi sector transfer protected. */
1036	NInoSetMstProtected(tmp_ni);
1037	NInoSetSparseDisabled(tmp_ni);
1038	/*
1039	* Set up our little cheat allowing us to reuse the async read io
1040	* completion handler for directories.
1041	*/
1042	tmp_ni->itype.index.block_size = vol->mft_record_size;
1043	tmp_ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1044	vol->mftmirr_ino = tmp_ino;
1045	ntfs_debug("Done.");
1046	return true;
1047	}
1048
1049	/**
1050	* check_mft_mirror - compare contents of the mft mirror with the mft
1051	* @vol: ntfs super block describing device whose mft mirror to check
1052	*
1053	* Return 'true' on success or 'false' on error.
1054	*
1055	* Note, this function also results in the mft mirror runlist being completely
1056	* mapped into memory. The mft mirror write code requires this and will BUG()
1057	* should it find an unmapped runlist element.
1058	*/
1059	static bool check_mft_mirror(ntfs_volume *vol)
1060	{
1061	struct super_block *sb = vol->sb;
1062	ntfs_inode *mirr_ni;
1063	struct page mft_page, mirr_page;
1064	u8 kmft, kmirr;
1065	runlist_element *rl, rl2[2];
1066	pgoff_t index;
1067	int mrecs_per_page, i;
1068
1069	ntfs_debug("Entering.");
1070	/* Compare contents of $MFT and $MFTMirr. */
1071	mrecs_per_page = PAGE_CACHE_SIZE / vol->mft_record_size;
1072	BUG_ON(!mrecs_per_page);
1073	BUG_ON(!vol->mftmirr_size);
1074	mft_page = mirr_page = NULL;
1075	kmft = kmirr = NULL;
1076	index = i = 0;
1077	do {
1078	u32 bytes;
1079
1080	/* Switch pages if necessary. */
1081	if (!(i % mrecs_per_page)) {
1082	if (index) {
1083	ntfs_unmap_page(mft_page);
1084	ntfs_unmap_page(mirr_page);
1085	}
1086	/* Get the $MFT page. */
1087	mft_page = ntfs_map_page(vol->mft_ino->i_mapping,
1088	index);
1089	if (IS_ERR(mft_page)) {
1090	ntfs_error(sb, "Failed to read $MFT.");
1091	return false;
1092	}
1093	kmft = page_address(mft_page);
1094	/* Get the $MFTMirr page. */
1095	mirr_page = ntfs_map_page(vol->mftmirr_ino->i_mapping,
1096	index);
1097	if (IS_ERR(mirr_page)) {
1098	ntfs_error(sb, "Failed to read $MFTMirr.");
1099	goto mft_unmap_out;
1100	}
1101	kmirr = page_address(mirr_page);
1102	++index;
1103	}
1104	/* Do not check the record if it is not in use. */
1105	if (((MFT_RECORD*)kmft)->flags & MFT_RECORD_IN_USE) {
1106	/* Make sure the record is ok. */
1107	if (ntfs_is_baad_recordp((le32*)kmft)) {
1108	ntfs_error(sb, "Incomplete multi sector "
1109	"transfer detected in mft "
1110	"record %i.", i);
1111	mm_unmap_out:
1112	ntfs_unmap_page(mirr_page);
1113	mft_unmap_out:
1114	ntfs_unmap_page(mft_page);
1115	return false;
1116	}
1117	}
1118	/* Do not check the mirror record if it is not in use. */
1119	if (((MFT_RECORD*)kmirr)->flags & MFT_RECORD_IN_USE) {
1120	if (ntfs_is_baad_recordp((le32*)kmirr)) {
1121	ntfs_error(sb, "Incomplete multi sector "
1122	"transfer detected in mft "
1123	"mirror record %i.", i);
1124	goto mm_unmap_out;
1125	}
1126	}
1127	/* Get the amount of data in the current record. */
1128	bytes = le32_to_cpu(((MFT_RECORD*)kmft)->bytes_in_use);
1129	if (bytes < sizeof(MFT_RECORD_OLD) \|\|
1130	bytes > vol->mft_record_size \|\|
1131	ntfs_is_baad_recordp((le32*)kmft)) {
1132	bytes = le32_to_cpu(((MFT_RECORD*)kmirr)->bytes_in_use);
1133	if (bytes < sizeof(MFT_RECORD_OLD) \|\|
1134	bytes > vol->mft_record_size \|\|
1135	ntfs_is_baad_recordp((le32*)kmirr))
1136	bytes = vol->mft_record_size;
1137	}
1138	/* Compare the two records. */
1139	if (memcmp(kmft, kmirr, bytes)) {
1140	ntfs_error(sb, "$MFT and $MFTMirr (record %i) do not "
1141	"match. Run ntfsfix or chkdsk.", i);
1142	goto mm_unmap_out;
1143	}
1144	kmft += vol->mft_record_size;
1145	kmirr += vol->mft_record_size;
1146	} while (++i < vol->mftmirr_size);
1147	/* Release the last pages. */
1148	ntfs_unmap_page(mft_page);
1149	ntfs_unmap_page(mirr_page);
1150
1151	/* Construct the mft mirror runlist by hand. */
1152	rl2[0].vcn = 0;
1153	rl2[0].lcn = vol->mftmirr_lcn;
1154	rl2[0].length = (vol->mftmirr_size * vol->mft_record_size +
1155	vol->cluster_size - 1) / vol->cluster_size;
1156	rl2[1].vcn = rl2[0].length;
1157	rl2[1].lcn = LCN_ENOENT;
1158	rl2[1].length = 0;
1159	/*
1160	* Because we have just read all of the mft mirror, we know we have
1161	* mapped the full runlist for it.
1162	*/
1163	mirr_ni = NTFS_I(vol->mftmirr_ino);
1164	down_read(&mirr_ni->runlist.lock);
1165	rl = mirr_ni->runlist.rl;
1166	/* Compare the two runlists. They must be identical. */
1167	i = 0;
1168	do {
1169	if (rl2[i].vcn != rl[i].vcn \|\| rl2[i].lcn != rl[i].lcn \|\|
1170	rl2[i].length != rl[i].length) {
1171	ntfs_error(sb, "$MFTMirr location mismatch. "
1172	"Run chkdsk.");
1173	up_read(&mirr_ni->runlist.lock);
1174	return false;
1175	}
1176	} while (rl2[i++].length);
1177	up_read(&mirr_ni->runlist.lock);
1178	ntfs_debug("Done.");
1179	return true;
1180	}
1181
1182	/**
1183	* load_and_check_logfile - load and check the logfile inode for a volume
1184	* @vol: ntfs super block describing device whose logfile to load
1185	*
1186	* Return 'true' on success or 'false' on error.
1187	*/
1188	static bool load_and_check_logfile(ntfs_volume *vol,
1189	RESTART_PAGE_HEADER **rp)
1190	{
1191	struct inode *tmp_ino;
1192
1193	ntfs_debug("Entering.");
1194	tmp_ino = ntfs_iget(vol->sb, FILE_LogFile);
1195	if (IS_ERR(tmp_ino) \|\| is_bad_inode(tmp_ino)) {
1196	if (!IS_ERR(tmp_ino))
1197	iput(tmp_ino);
1198	/* Caller will display error message. */
1199	return false;
1200	}
1201	if (!ntfs_check_logfile(tmp_ino, rp)) {
1202	iput(tmp_ino);
1203	/* ntfs_check_logfile() will have displayed error output. */
1204	return false;
1205	}
1206	NInoSetSparseDisabled(NTFS_I(tmp_ino));
1207	vol->logfile_ino = tmp_ino;
1208	ntfs_debug("Done.");
1209	return true;
1210	}
1211
1212	#define NTFS_HIBERFIL_HEADER_SIZE 4096
1213
1214	/**
1215	* check_windows_hibernation_status - check if Windows is suspended on a volume
1216	* @vol: ntfs super block of device to check
1217	*
1218	* Check if Windows is hibernated on the ntfs volume @vol. This is done by
1219	* looking for the file hiberfil.sys in the root directory of the volume. If
1220	* the file is not present Windows is definitely not suspended.
1221	*
1222	* If hiberfil.sys exists and is less than 4kiB in size it means Windows is
1223	* definitely suspended (this volume is not the system volume). Caveat: on a
1224	* system with many volumes it is possible that the < 4kiB check is bogus but
1225	* for now this should do fine.
1226	*
1227	* If hiberfil.sys exists and is larger than 4kiB in size, we need to read the
1228	* hiberfil header (which is the first 4kiB). If this begins with "hibr",
1229	* Windows is definitely suspended. If it is completely full of zeroes,
1230	* Windows is definitely not hibernated. Any other case is treated as if
1231	* Windows is suspended. This caters for the above mentioned caveat of a
1232	* system with many volumes where no "hibr" magic would be present and there is
1233	* no zero header.
1234	*
1235	* Return 0 if Windows is not hibernated on the volume, >0 if Windows is
1236	* hibernated on the volume, and -errno on error.
1237	*/
1238	static int check_windows_hibernation_status(ntfs_volume *vol)
1239	{
1240	MFT_REF mref;
1241	struct inode *vi;
1242	ntfs_inode *ni;
1243	struct page *page;
1244	u32 kaddr, kend;
1245	ntfs_name *name = NULL;
1246	int ret = 1;
1247	static const ntfschar hiberfil[13] = { cpu_to_le16('h'),
1248	cpu_to_le16('i'), cpu_to_le16('b'),
1249	cpu_to_le16('e'), cpu_to_le16('r'),
1250	cpu_to_le16('f'), cpu_to_le16('i'),
1251	cpu_to_le16('l'), cpu_to_le16('.'),
1252	cpu_to_le16('s'), cpu_to_le16('y'),
1253	cpu_to_le16('s'), 0 };
1254
1255	ntfs_debug("Entering.");
1256	/*
1257	* Find the inode number for the hibernation file by looking up the
1258	* filename hiberfil.sys in the root directory.
1259	*/
1260	mutex_lock(&vol->root_ino->i_mutex);
1261	mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
1262	&name);
1263	mutex_unlock(&vol->root_ino->i_mutex);
1264	if (IS_ERR_MREF(mref)) {
1265	ret = MREF_ERR(mref);
1266	/* If the file does not exist, Windows is not hibernated. */
1267	if (ret == -ENOENT) {
1268	ntfs_debug("hiberfil.sys not present. Windows is not "
1269	"hibernated on the volume.");
1270	return 0;
1271	}
1272	/* A real error occurred. */
1273	ntfs_error(vol->sb, "Failed to find inode number for "
1274	"hiberfil.sys.");
1275	return ret;
1276	}
1277	/* We do not care for the type of match that was found. */
1278	kfree(name);
1279	/* Get the inode. */
1280	vi = ntfs_iget(vol->sb, MREF(mref));
1281	if (IS_ERR(vi) \|\| is_bad_inode(vi)) {
1282	if (!IS_ERR(vi))
1283	iput(vi);
1284	ntfs_error(vol->sb, "Failed to load hiberfil.sys.");
1285	return IS_ERR(vi) ? PTR_ERR(vi) : -EIO;
1286	}
1287	if (unlikely(i_size_read(vi) < NTFS_HIBERFIL_HEADER_SIZE)) {
1288	ntfs_debug("hiberfil.sys is smaller than 4kiB (0x%llx). "
1289	"Windows is hibernated on the volume. This "
1290	"is not the system volume.", i_size_read(vi));
1291	goto iput_out;
1292	}
1293	ni = NTFS_I(vi);
1294	page = ntfs_map_page(vi->i_mapping, 0);
1295	if (IS_ERR(page)) {
1296	ntfs_error(vol->sb, "Failed to read from hiberfil.sys.");
1297	ret = PTR_ERR(page);
1298	goto iput_out;
1299	}
1300	kaddr = (u32*)page_address(page);
1301	if ((le32)kaddr == cpu_to_le32(0x72626968)/'hibr'/) {
1302	ntfs_debug("Magic \"hibr\" found in hiberfil.sys. Windows is "
1303	"hibernated on the volume. This is the "
1304	"system volume.");
1305	goto unm_iput_out;
1306	}
1307	kend = kaddr + NTFS_HIBERFIL_HEADER_SIZE/sizeof(*kaddr);
1308	do {
1309	if (unlikely(*kaddr)) {
1310	ntfs_debug("hiberfil.sys is larger than 4kiB "
1311	"(0x%llx), does not contain the "
1312	"\"hibr\" magic, and does not have a "
1313	"zero header. Windows is hibernated "
1314	"on the volume. This is not the "
1315	"system volume.", i_size_read(vi));
1316	goto unm_iput_out;
1317	}
1318	} while (++kaddr < kend);
1319	ntfs_debug("hiberfil.sys contains a zero header. Windows is not "
1320	"hibernated on the volume. This is the system "
1321	"volume.");
1322	ret = 0;
1323	unm_iput_out:
1324	ntfs_unmap_page(page);
1325	iput_out:
1326	iput(vi);
1327	return ret;
1328	}
1329
1330	/**
1331	* load_and_init_quota - load and setup the quota file for a volume if present
1332	* @vol: ntfs super block describing device whose quota file to load
1333	*
1334	* Return 'true' on success or 'false' on error. If $Quota is not present, we
1335	* leave vol->quota_ino as NULL and return success.
1336	*/
1337	static bool load_and_init_quota(ntfs_volume *vol)
1338	{
1339	MFT_REF mref;
1340	struct inode *tmp_ino;
1341	ntfs_name *name = NULL;
1342	static const ntfschar Quota[7] = { cpu_to_le16('$'),
1343	cpu_to_le16('Q'), cpu_to_le16('u'),
1344	cpu_to_le16('o'), cpu_to_le16('t'),
1345	cpu_to_le16('a'), 0 };
1346	static ntfschar Q[3] = { cpu_to_le16('$'),
1347	cpu_to_le16('Q'), 0 };
1348
1349	ntfs_debug("Entering.");
1350	/*
1351	* Find the inode number for the quota file by looking up the filename
1352	* $Quota in the extended system files directory $Extend.
1353	*/
1354	mutex_lock(&vol->extend_ino->i_mutex);
1355	mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
1356	&name);
1357	mutex_unlock(&vol->extend_ino->i_mutex);
1358	if (IS_ERR_MREF(mref)) {
1359	/*
1360	* If the file does not exist, quotas are disabled and have
1361	* never been enabled on this volume, just return success.
1362	*/
1363	if (MREF_ERR(mref) == -ENOENT) {
1364	ntfs_debug("$Quota not present. Volume does not have "
1365	"quotas enabled.");
1366	/*
1367	* No need to try to set quotas out of date if they are
1368	* not enabled.
1369	*/
1370	NVolSetQuotaOutOfDate(vol);
1371	return true;
1372	}
1373	/* A real error occurred. */
1374	ntfs_error(vol->sb, "Failed to find inode number for $Quota.");
1375	return false;
1376	}
1377	/* We do not care for the type of match that was found. */
1378	kfree(name);
1379	/* Get the inode. */
1380	tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1381	if (IS_ERR(tmp_ino) \|\| is_bad_inode(tmp_ino)) {
1382	if (!IS_ERR(tmp_ino))
1383	iput(tmp_ino);
1384	ntfs_error(vol->sb, "Failed to load $Quota.");
1385	return false;
1386	}
1387	vol->quota_ino = tmp_ino;
1388	/* Get the $Q index allocation attribute. */
1389	tmp_ino = ntfs_index_iget(vol->quota_ino, Q, 2);
1390	if (IS_ERR(tmp_ino)) {
1391	ntfs_error(vol->sb, "Failed to load $Quota/$Q index.");
1392	return false;
1393	}
1394	vol->quota_q_ino = tmp_ino;
1395	ntfs_debug("Done.");
1396	return true;
1397	}
1398
1399	/**
1400	* load_and_init_usnjrnl - load and setup the transaction log if present
1401	* @vol: ntfs super block describing device whose usnjrnl file to load
1402	*
1403	* Return 'true' on success or 'false' on error.
1404	*
1405	* If $UsnJrnl is not present or in the process of being disabled, we set
1406	* NVolUsnJrnlStamped() and return success.
1407	*
1408	* If the $UsnJrnl $DATA/$J attribute has a size equal to the lowest valid usn,
1409	* i.e. transaction logging has only just been enabled or the journal has been
1410	* stamped and nothing has been logged since, we also set NVolUsnJrnlStamped()
1411	* and return success.
1412	*/
1413	static bool load_and_init_usnjrnl(ntfs_volume *vol)
1414	{
1415	MFT_REF mref;
1416	struct inode *tmp_ino;
1417	ntfs_inode *tmp_ni;
1418	struct page *page;
1419	ntfs_name *name = NULL;
1420	USN_HEADER *uh;
1421	static const ntfschar UsnJrnl[9] = { cpu_to_le16('$'),
1422	cpu_to_le16('U'), cpu_to_le16('s'),
1423	cpu_to_le16('n'), cpu_to_le16('J'),
1424	cpu_to_le16('r'), cpu_to_le16('n'),
1425	cpu_to_le16('l'), 0 };
1426	static ntfschar Max[5] = { cpu_to_le16('$'),
1427	cpu_to_le16('M'), cpu_to_le16('a'),
1428	cpu_to_le16('x'), 0 };
1429	static ntfschar J[3] = { cpu_to_le16('$'),
1430	cpu_to_le16('J'), 0 };
1431
1432	ntfs_debug("Entering.");
1433	/*
1434	* Find the inode number for the transaction log file by looking up the
1435	* filename $UsnJrnl in the extended system files directory $Extend.
1436	*/
1437	mutex_lock(&vol->extend_ino->i_mutex);
1438	mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
1439	&name);
1440	mutex_unlock(&vol->extend_ino->i_mutex);
1441	if (IS_ERR_MREF(mref)) {
1442	/*
1443	* If the file does not exist, transaction logging is disabled,
1444	* just return success.
1445	*/
1446	if (MREF_ERR(mref) == -ENOENT) {
1447	ntfs_debug("$UsnJrnl not present. Volume does not "
1448	"have transaction logging enabled.");
1449	not_enabled:
1450	/*
1451	* No need to try to stamp the transaction log if
1452	* transaction logging is not enabled.
1453	*/
1454	NVolSetUsnJrnlStamped(vol);
1455	return true;
1456	}
1457	/* A real error occurred. */
1458	ntfs_error(vol->sb, "Failed to find inode number for "
1459	"$UsnJrnl.");
1460	return false;
1461	}
1462	/* We do not care for the type of match that was found. */
1463	kfree(name);
1464	/* Get the inode. */
1465	tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1466	if (unlikely(IS_ERR(tmp_ino) \|\| is_bad_inode(tmp_ino))) {
1467	if (!IS_ERR(tmp_ino))
1468	iput(tmp_ino);
1469	ntfs_error(vol->sb, "Failed to load $UsnJrnl.");
1470	return false;
1471	}
1472	vol->usnjrnl_ino = tmp_ino;
1473	/*
1474	* If the transaction log is in the process of being deleted, we can
1475	* ignore it.
1476	*/
1477	if (unlikely(vol->vol_flags & VOLUME_DELETE_USN_UNDERWAY)) {
1478	ntfs_debug("$UsnJrnl in the process of being disabled. "
1479	"Volume does not have transaction logging "
1480	"enabled.");
1481	goto not_enabled;
1482	}
1483	/* Get the $DATA/$Max attribute. */
1484	tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, Max, 4);
1485	if (IS_ERR(tmp_ino)) {
1486	ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$Max "
1487	"attribute.");
1488	return false;
1489	}
1490	vol->usnjrnl_max_ino = tmp_ino;
1491	if (unlikely(i_size_read(tmp_ino) < sizeof(USN_HEADER))) {
1492	ntfs_error(vol->sb, "Found corrupt $UsnJrnl/$DATA/$Max "
1493	"attribute (size is 0x%llx but should be at "
1494	"least 0x%zx bytes).", i_size_read(tmp_ino),
1495	sizeof(USN_HEADER));
1496	return false;
1497	}
1498	/* Get the $DATA/$J attribute. */
1499	tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, J, 2);
1500	if (IS_ERR(tmp_ino)) {
1501	ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$J "
1502	"attribute.");
1503	return false;
1504	}
1505	vol->usnjrnl_j_ino = tmp_ino;
1506	/* Verify $J is non-resident and sparse. */
1507	tmp_ni = NTFS_I(vol->usnjrnl_j_ino);
1508	if (unlikely(!NInoNonResident(tmp_ni) \|\| !NInoSparse(tmp_ni))) {
1509	ntfs_error(vol->sb, "$UsnJrnl/$DATA/$J attribute is resident "
1510	"and/or not sparse.");
1511	return false;
1512	}
1513	/* Read the USN_HEADER from $DATA/$Max. */
1514	page = ntfs_map_page(vol->usnjrnl_max_ino->i_mapping, 0);
1515	if (IS_ERR(page)) {
1516	ntfs_error(vol->sb, "Failed to read from $UsnJrnl/$DATA/$Max "
1517	"attribute.");
1518	return false;
1519	}
1520	uh = (USN_HEADER*)page_address(page);
1521	/* Sanity check the $Max. */
1522	if (unlikely(sle64_to_cpu(uh->allocation_delta) >
1523	sle64_to_cpu(uh->maximum_size))) {
1524	ntfs_error(vol->sb, "Allocation delta (0x%llx) exceeds "
1525	"maximum size (0x%llx). $UsnJrnl is corrupt.",
1526	(long long)sle64_to_cpu(uh->allocation_delta),
1527	(long long)sle64_to_cpu(uh->maximum_size));
1528	ntfs_unmap_page(page);
1529	return false;
1530	}
1531	/*
1532	* If the transaction log has been stamped and nothing has been written
1533	* to it since, we do not need to stamp it.
1534	*/
1535	if (unlikely(sle64_to_cpu(uh->lowest_valid_usn) >=
1536	i_size_read(vol->usnjrnl_j_ino))) {
1537	if (likely(sle64_to_cpu(uh->lowest_valid_usn) ==
1538	i_size_read(vol->usnjrnl_j_ino))) {
1539	ntfs_unmap_page(page);
1540	ntfs_debug("$UsnJrnl is enabled but nothing has been "
1541	"logged since it was last stamped. "
1542	"Treating this as if the volume does "
1543	"not have transaction logging "
1544	"enabled.");
1545	goto not_enabled;
1546	}
1547	ntfs_error(vol->sb, "$UsnJrnl has lowest valid usn (0x%llx) "
1548	"which is out of bounds (0x%llx). $UsnJrnl "
1549	"is corrupt.",
1550	(long long)sle64_to_cpu(uh->lowest_valid_usn),
1551	i_size_read(vol->usnjrnl_j_ino));
1552	ntfs_unmap_page(page);
1553	return false;
1554	}
1555	ntfs_unmap_page(page);
1556	ntfs_debug("Done.");
1557	return true;
1558	}
1559
1560	/**
1561	* load_and_init_attrdef - load the attribute definitions table for a volume
1562	* @vol: ntfs super block describing device whose attrdef to load
1563	*
1564	* Return 'true' on success or 'false' on error.
1565	*/
1566	static bool load_and_init_attrdef(ntfs_volume *vol)
1567	{
1568	loff_t i_size;
1569	struct super_block *sb = vol->sb;
1570	struct inode *ino;
1571	struct page *page;
1572	pgoff_t index, max_index;
1573	unsigned int size;
1574
1575	ntfs_debug("Entering.");
1576	/* Read attrdef table and setup vol->attrdef and vol->attrdef_size. */
1577	ino = ntfs_iget(sb, FILE_AttrDef);
1578	if (IS_ERR(ino) \|\| is_bad_inode(ino)) {
1579	if (!IS_ERR(ino))
1580	iput(ino);
1581	goto failed;
1582	}
1583	NInoSetSparseDisabled(NTFS_I(ino));
1584	/* The size of FILE_AttrDef must be above 0 and fit inside 31 bits. */
1585	i_size = i_size_read(ino);
1586	if (i_size <= 0 \|\| i_size > 0x7fffffff)
1587	goto iput_failed;
1588	vol->attrdef = (ATTR_DEF*)ntfs_malloc_nofs(i_size);
1589	if (!vol->attrdef)
1590	goto iput_failed;
1591	index = 0;
1592	max_index = i_size >> PAGE_CACHE_SHIFT;
1593	size = PAGE_CACHE_SIZE;
1594	while (index < max_index) {
1595	/* Read the attrdef table and copy it into the linear buffer. */
1596	read_partial_attrdef_page:
1597	page = ntfs_map_page(ino->i_mapping, index);
1598	if (IS_ERR(page))
1599	goto free_iput_failed;
1600	memcpy((u8*)vol->attrdef + (index++ << PAGE_CACHE_SHIFT),
1601	page_address(page), size);
1602	ntfs_unmap_page(page);
1603	};
1604	if (size == PAGE_CACHE_SIZE) {
1605	size = i_size & ~PAGE_CACHE_MASK;
1606	if (size)
1607	goto read_partial_attrdef_page;
1608	}
1609	vol->attrdef_size = i_size;
1610	ntfs_debug("Read %llu bytes from $AttrDef.", i_size);
1611	iput(ino);
1612	return true;
1613	free_iput_failed:
1614	ntfs_free(vol->attrdef);
1615	vol->attrdef = NULL;
1616	iput_failed:
1617	iput(ino);
1618	failed:
1619	ntfs_error(sb, "Failed to initialize attribute definition table.");
1620	return false;
1621	}
1622
1623	#endif /* NTFS_RW */
1624
1625	/**
1626	* load_and_init_upcase - load the upcase table for an ntfs volume
1627	* @vol: ntfs super block describing device whose upcase to load
1628	*
1629	* Return 'true' on success or 'false' on error.
1630	*/
1631	static bool load_and_init_upcase(ntfs_volume *vol)
1632	{
1633	loff_t i_size;
1634	struct super_block *sb = vol->sb;
1635	struct inode *ino;
1636	struct page *page;
1637	pgoff_t index, max_index;
1638	unsigned int size;
1639	int i, max;
1640
1641	ntfs_debug("Entering.");
1642	/* Read upcase table and setup vol->upcase and vol->upcase_len. */
1643	ino = ntfs_iget(sb, FILE_UpCase);
1644	if (IS_ERR(ino) \|\| is_bad_inode(ino)) {
1645	if (!IS_ERR(ino))
1646	iput(ino);
1647	goto upcase_failed;
1648	}
1649	/*
1650	* The upcase size must not be above 64k Unicode characters, must not
1651	* be zero and must be a multiple of sizeof(ntfschar).
1652	*/
1653	i_size = i_size_read(ino);
1654	if (!i_size \|\| i_size & (sizeof(ntfschar) - 1) \|\|
1655	i_size > 64ULL * 1024 * sizeof(ntfschar))
1656	goto iput_upcase_failed;
1657	vol->upcase = (ntfschar*)ntfs_malloc_nofs(i_size);
1658	if (!vol->upcase)
1659	goto iput_upcase_failed;
1660	index = 0;
1661	max_index = i_size >> PAGE_CACHE_SHIFT;
1662	size = PAGE_CACHE_SIZE;
1663	while (index < max_index) {
1664	/* Read the upcase table and copy it into the linear buffer. */
1665	read_partial_upcase_page:
1666	page = ntfs_map_page(ino->i_mapping, index);
1667	if (IS_ERR(page))
1668	goto iput_upcase_failed;
1669	memcpy((char*)vol->upcase + (index++ << PAGE_CACHE_SHIFT),
1670	page_address(page), size);
1671	ntfs_unmap_page(page);
1672	};
1673	if (size == PAGE_CACHE_SIZE) {
1674	size = i_size & ~PAGE_CACHE_MASK;
1675	if (size)
1676	goto read_partial_upcase_page;
1677	}
1678	vol->upcase_len = i_size >> UCHAR_T_SIZE_BITS;
1679	ntfs_debug("Read %llu bytes from $UpCase (expected %zu bytes).",
1680	i_size, 64 * 1024 * sizeof(ntfschar));
1681	iput(ino);
1682	mutex_lock(&ntfs_lock);
1683	if (!default_upcase) {
1684	ntfs_debug("Using volume specified $UpCase since default is "
1685	"not present.");
1686	mutex_unlock(&ntfs_lock);
1687	return true;
1688	}
1689	max = default_upcase_len;
1690	if (max > vol->upcase_len)
1691	max = vol->upcase_len;
1692	for (i = 0; i < max; i++)
1693	if (vol->upcase[i] != default_upcase[i])
1694	break;
1695	if (i == max) {
1696	ntfs_free(vol->upcase);
1697	vol->upcase = default_upcase;
1698	vol->upcase_len = max;
1699	ntfs_nr_upcase_users++;
1700	mutex_unlock(&ntfs_lock);
1701	ntfs_debug("Volume specified $UpCase matches default. Using "
1702	"default.");
1703	return true;
1704	}
1705	mutex_unlock(&ntfs_lock);
1706	ntfs_debug("Using volume specified $UpCase since it does not match "
1707	"the default.");
1708	return true;
1709	iput_upcase_failed:
1710	iput(ino);
1711	ntfs_free(vol->upcase);
1712	vol->upcase = NULL;
1713	upcase_failed:
1714	mutex_lock(&ntfs_lock);
1715	if (default_upcase) {
1716	vol->upcase = default_upcase;
1717	vol->upcase_len = default_upcase_len;
1718	ntfs_nr_upcase_users++;
1719	mutex_unlock(&ntfs_lock);
1720	ntfs_error(sb, "Failed to load $UpCase from the volume. Using "
1721	"default.");
1722	return true;
1723	}
1724	mutex_unlock(&ntfs_lock);
1725	ntfs_error(sb, "Failed to initialize upcase table.");
1726	return false;
1727	}
1728
1729	/*
1730	* The lcn and mft bitmap inodes are NTFS-internal inodes with
1731	* their own special locking rules:
1732	*/
1733	static struct lock_class_key
1734	lcnbmp_runlist_lock_key, lcnbmp_mrec_lock_key,
1735	mftbmp_runlist_lock_key, mftbmp_mrec_lock_key;
1736
1737	/**
1738	* load_system_files - open the system files using normal functions
1739	* @vol: ntfs super block describing device whose system files to load
1740	*
1741	* Open the system files with normal access functions and complete setting up
1742	* the ntfs super block @vol.
1743	*
1744	* Return 'true' on success or 'false' on error.
1745	*/
1746	static bool load_system_files(ntfs_volume *vol)
1747	{
1748	struct super_block *sb = vol->sb;
1749	MFT_RECORD *m;
1750	VOLUME_INFORMATION *vi;
1751	ntfs_attr_search_ctx *ctx;
1752	#ifdef NTFS_RW
1753	RESTART_PAGE_HEADER *rp;
1754	int err;
1755	#endif /* NTFS_RW */
1756
1757	ntfs_debug("Entering.");
1758	#ifdef NTFS_RW
1759	/* Get mft mirror inode compare the contents of $MFT and $MFTMirr. */
1760	if (!load_and_init_mft_mirror(vol) \|\| !check_mft_mirror(vol)) {
1761	static const char *es1 = "Failed to load $MFTMirr";
1762	static const char *es2 = "$MFTMirr does not match $MFT";
1763	static const char *es3 = ". Run ntfsfix and/or chkdsk.";
1764
1765	/* If a read-write mount, convert it to a read-only mount. */
1766	if (!(sb->s_flags & MS_RDONLY)) {
1767	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
1768	ON_ERRORS_CONTINUE))) {
1769	ntfs_error(sb, "%s and neither on_errors="
1770	"continue nor on_errors="
1771	"remount-ro was specified%s",
1772	!vol->mftmirr_ino ? es1 : es2,
1773	es3);
1774	goto iput_mirr_err_out;
1775	}
1776	sb->s_flags \|= MS_RDONLY;
1777	ntfs_error(sb, "%s. Mounting read-only%s",
1778	!vol->mftmirr_ino ? es1 : es2, es3);
1779	} else
1780	ntfs_warning(sb, "%s. Will not be able to remount "
1781	"read-write%s",
1782	!vol->mftmirr_ino ? es1 : es2, es3);
1783	/* This will prevent a read-write remount. */
1784	NVolSetErrors(vol);
1785	}
1786	#endif /* NTFS_RW */
1787	/* Get mft bitmap attribute inode. */
1788	vol->mftbmp_ino = ntfs_attr_iget(vol->mft_ino, AT_BITMAP, NULL, 0);
1789	if (IS_ERR(vol->mftbmp_ino)) {
1790	ntfs_error(sb, "Failed to load $MFT/$BITMAP attribute.");
1791	goto iput_mirr_err_out;
1792	}
1793	lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
1794	&mftbmp_runlist_lock_key);
1795	lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
1796	&mftbmp_mrec_lock_key);
1797	/* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
1798	if (!load_and_init_upcase(vol))
1799	goto iput_mftbmp_err_out;
1800	#ifdef NTFS_RW
1801	/*
1802	* Read attribute definitions table and setup @vol->attrdef and
1803	* @vol->attrdef_size.
1804	*/
1805	if (!load_and_init_attrdef(vol))
1806	goto iput_upcase_err_out;
1807	#endif /* NTFS_RW */
1808	/*
1809	* Get the cluster allocation bitmap inode and verify the size, no
1810	* need for any locking at this stage as we are already running
1811	* exclusively as we are mount in progress task.
1812	*/
1813	vol->lcnbmp_ino = ntfs_iget(sb, FILE_Bitmap);
1814	if (IS_ERR(vol->lcnbmp_ino) \|\| is_bad_inode(vol->lcnbmp_ino)) {
1815	if (!IS_ERR(vol->lcnbmp_ino))
1816	iput(vol->lcnbmp_ino);
1817	goto bitmap_failed;
1818	}
1819	lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
1820	&lcnbmp_runlist_lock_key);
1821	lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
1822	&lcnbmp_mrec_lock_key);
1823
1824	NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
1825	if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
1826	iput(vol->lcnbmp_ino);
1827	bitmap_failed:
1828	ntfs_error(sb, "Failed to load $Bitmap.");
1829	goto iput_attrdef_err_out;
1830	}
1831	/*
1832	* Get the volume inode and setup our cache of the volume flags and
1833	* version.
1834	*/
1835	vol->vol_ino = ntfs_iget(sb, FILE_Volume);
1836	if (IS_ERR(vol->vol_ino) \|\| is_bad_inode(vol->vol_ino)) {
1837	if (!IS_ERR(vol->vol_ino))
1838	iput(vol->vol_ino);
1839	volume_failed:
1840	ntfs_error(sb, "Failed to load $Volume.");
1841	goto iput_lcnbmp_err_out;
1842	}
1843	m = map_mft_record(NTFS_I(vol->vol_ino));
1844	if (IS_ERR(m)) {
1845	iput_volume_failed:
1846	iput(vol->vol_ino);
1847	goto volume_failed;
1848	}
1849	if (!(ctx = ntfs_attr_get_search_ctx(NTFS_I(vol->vol_ino), m))) {
1850	ntfs_error(sb, "Failed to get attribute search context.");
1851	goto get_ctx_vol_failed;
1852	}
1853	if (ntfs_attr_lookup(AT_VOLUME_INFORMATION, NULL, 0, 0, 0, NULL, 0,
1854	ctx) \|\| ctx->attr->non_resident \|\| ctx->attr->flags) {
1855	err_put_vol:
1856	ntfs_attr_put_search_ctx(ctx);
1857	get_ctx_vol_failed:
1858	unmap_mft_record(NTFS_I(vol->vol_ino));
1859	goto iput_volume_failed;
1860	}
1861	vi = (VOLUME_INFORMATION)((char)ctx->attr +
1862	le16_to_cpu(ctx->attr->data.resident.value_offset));
1863	/* Some bounds checks. */
1864	if ((u8)vi < (u8)ctx->attr \|\| (u8*)vi +
1865	le32_to_cpu(ctx->attr->data.resident.value_length) >
1866	(u8*)ctx->attr + le32_to_cpu(ctx->attr->length))
1867	goto err_put_vol;
1868	/* Copy the volume flags and version to the ntfs_volume structure. */
1869	vol->vol_flags = vi->flags;
1870	vol->major_ver = vi->major_ver;
1871	vol->minor_ver = vi->minor_ver;
1872	ntfs_attr_put_search_ctx(ctx);
1873	unmap_mft_record(NTFS_I(vol->vol_ino));
1874	printk(KERN_INFO "NTFS volume version %i.%i.\n", vol->major_ver,
1875	vol->minor_ver);
1876	if (vol->major_ver < 3 && NVolSparseEnabled(vol)) {
1877	ntfs_warning(vol->sb, "Disabling sparse support due to NTFS "
1878	"volume version %i.%i (need at least version "
1879	"3.0).", vol->major_ver, vol->minor_ver);
1880	NVolClearSparseEnabled(vol);
1881	}
1882	#ifdef NTFS_RW
1883	/* Make sure that no unsupported volume flags are set. */
1884	if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
1885	static const char *es1a = "Volume is dirty";
1886	static const char *es1b = "Volume has been modified by chkdsk";
1887	static const char *es1c = "Volume has unsupported flags set";
1888	static const char *es2a = ". Run chkdsk and mount in Windows.";
1889	static const char *es2b = ". Mount in Windows.";
1890	const char es1, es2;
1891
1892	es2 = es2a;
1893	if (vol->vol_flags & VOLUME_IS_DIRTY)
1894	es1 = es1a;
1895	else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
1896	es1 = es1b;
1897	es2 = es2b;
1898	} else {
1899	es1 = es1c;
1900	ntfs_warning(sb, "Unsupported volume flags 0x%x "
1901	"encountered.",
1902	(unsigned)le16_to_cpu(vol->vol_flags));
1903	}
1904	/* If a read-write mount, convert it to a read-only mount. */
1905	if (!(sb->s_flags & MS_RDONLY)) {
1906	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
1907	ON_ERRORS_CONTINUE))) {
1908	ntfs_error(sb, "%s and neither on_errors="
1909	"continue nor on_errors="
1910	"remount-ro was specified%s",
1911	es1, es2);
1912	goto iput_vol_err_out;
1913	}
1914	sb->s_flags \|= MS_RDONLY;
1915	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
1916	} else
1917	ntfs_warning(sb, "%s. Will not be able to remount "
1918	"read-write%s", es1, es2);
1919	/*
1920	* Do not set NVolErrors() because ntfs_remount() re-checks the
1921	* flags which we need to do in case any flags have changed.
1922	*/
1923	}
1924	/*
1925	* Get the inode for the logfile, check it and determine if the volume
1926	* was shutdown cleanly.
1927	*/
1928	rp = NULL;
1929	if (!load_and_check_logfile(vol, &rp) \|\|
1930	!ntfs_is_logfile_clean(vol->logfile_ino, rp)) {
1931	static const char *es1a = "Failed to load $LogFile";
1932	static const char *es1b = "$LogFile is not clean";
1933	static const char *es2 = ". Mount in Windows.";
1934	const char *es1;
1935
1936	es1 = !vol->logfile_ino ? es1a : es1b;
1937	/* If a read-write mount, convert it to a read-only mount. */
1938	if (!(sb->s_flags & MS_RDONLY)) {
1939	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
1940	ON_ERRORS_CONTINUE))) {
1941	ntfs_error(sb, "%s and neither on_errors="
1942	"continue nor on_errors="
1943	"remount-ro was specified%s",
1944	es1, es2);
1945	if (vol->logfile_ino) {
1946	BUG_ON(!rp);
1947	ntfs_free(rp);
1948	}
1949	goto iput_logfile_err_out;
1950	}
1951	sb->s_flags \|= MS_RDONLY;
1952	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
1953	} else
1954	ntfs_warning(sb, "%s. Will not be able to remount "
1955	"read-write%s", es1, es2);
1956	/* This will prevent a read-write remount. */
1957	NVolSetErrors(vol);
1958	}
1959	ntfs_free(rp);
1960	#endif /* NTFS_RW */
1961	/* Get the root directory inode so we can do path lookups. */
1962	vol->root_ino = ntfs_iget(sb, FILE_root);
1963	if (IS_ERR(vol->root_ino) \|\| is_bad_inode(vol->root_ino)) {
1964	if (!IS_ERR(vol->root_ino))
1965	iput(vol->root_ino);
1966	ntfs_error(sb, "Failed to load root directory.");
1967	goto iput_logfile_err_out;
1968	}
1969	#ifdef NTFS_RW
1970	/*
1971	* Check if Windows is suspended to disk on the target volume. If it
1972	* is hibernated, we must not write anything to the disk so set
1973	* NVolErrors() without setting the dirty volume flag and mount
1974	* read-only. This will prevent read-write remounting and it will also
1975	* prevent all writes.
1976	*/
1977	err = check_windows_hibernation_status(vol);
1978	if (unlikely(err)) {
1979	static const char *es1a = "Failed to determine if Windows is "
1980	"hibernated";
1981	static const char *es1b = "Windows is hibernated";
1982	static const char *es2 = ". Run chkdsk.";
1983	const char *es1;
1984
1985	es1 = err < 0 ? es1a : es1b;
1986	/* If a read-write mount, convert it to a read-only mount. */
1987	if (!(sb->s_flags & MS_RDONLY)) {
1988	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
1989	ON_ERRORS_CONTINUE))) {
1990	ntfs_error(sb, "%s and neither on_errors="
1991	"continue nor on_errors="
1992	"remount-ro was specified%s",
1993	es1, es2);
1994	goto iput_root_err_out;
1995	}
1996	sb->s_flags \|= MS_RDONLY;
1997	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
1998	} else
1999	ntfs_warning(sb, "%s. Will not be able to remount "
2000	"read-write%s", es1, es2);
2001	/* This will prevent a read-write remount. */
2002	NVolSetErrors(vol);
2003	}
2004	/* If (still) a read-write mount, mark the volume dirty. */
2005	if (!(sb->s_flags & MS_RDONLY) &&
2006	ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
2007	static const char *es1 = "Failed to set dirty bit in volume "
2008	"information flags";
2009	static const char *es2 = ". Run chkdsk.";
2010
2011	/* Convert to a read-only mount. */
2012	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2013	ON_ERRORS_CONTINUE))) {
2014	ntfs_error(sb, "%s and neither on_errors=continue nor "
2015	"on_errors=remount-ro was specified%s",
2016	es1, es2);
2017	goto iput_root_err_out;
2018	}
2019	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2020	sb->s_flags \|= MS_RDONLY;
2021	/*
2022	* Do not set NVolErrors() because ntfs_remount() might manage
2023	* to set the dirty flag in which case all would be well.
2024	*/
2025	}
2026	#if 0
2027	// TODO: Enable this code once we start modifying anything that is
2028	// different between NTFS 1.2 and 3.x...
2029	/*
2030	* If (still) a read-write mount, set the NT4 compatibility flag on
2031	* newer NTFS version volumes.
2032	*/
2033	if (!(sb->s_flags & MS_RDONLY) && (vol->major_ver > 1) &&
2034	ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
2035	static const char *es1 = "Failed to set NT4 compatibility flag";
2036	static const char *es2 = ". Run chkdsk.";
2037
2038	/* Convert to a read-only mount. */
2039	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2040	ON_ERRORS_CONTINUE))) {
2041	ntfs_error(sb, "%s and neither on_errors=continue nor "
2042	"on_errors=remount-ro was specified%s",
2043	es1, es2);
2044	goto iput_root_err_out;
2045	}
2046	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2047	sb->s_flags \|= MS_RDONLY;
2048	NVolSetErrors(vol);
2049	}
2050	#endif
2051	/* If (still) a read-write mount, empty the logfile. */
2052	if (!(sb->s_flags & MS_RDONLY) &&
2053	!ntfs_empty_logfile(vol->logfile_ino)) {
2054	static const char *es1 = "Failed to empty $LogFile";
2055	static const char *es2 = ". Mount in Windows.";
2056
2057	/* Convert to a read-only mount. */
2058	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2059	ON_ERRORS_CONTINUE))) {
2060	ntfs_error(sb, "%s and neither on_errors=continue nor "
2061	"on_errors=remount-ro was specified%s",
2062	es1, es2);
2063	goto iput_root_err_out;
2064	}
2065	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2066	sb->s_flags \|= MS_RDONLY;
2067	NVolSetErrors(vol);
2068	}
2069	#endif /* NTFS_RW */
2070	/* If on NTFS versions before 3.0, we are done. */
2071	if (unlikely(vol->major_ver < 3))
2072	return true;
2073	/* NTFS 3.0+ specific initialization. */
2074	/* Get the security descriptors inode. */
2075	vol->secure_ino = ntfs_iget(sb, FILE_Secure);
2076	if (IS_ERR(vol->secure_ino) \|\| is_bad_inode(vol->secure_ino)) {
2077	if (!IS_ERR(vol->secure_ino))
2078	iput(vol->secure_ino);
2079	ntfs_error(sb, "Failed to load $Secure.");
2080	goto iput_root_err_out;
2081	}
2082	// TODO: Initialize security.
2083	/* Get the extended system files' directory inode. */
2084	vol->extend_ino = ntfs_iget(sb, FILE_Extend);
2085	if (IS_ERR(vol->extend_ino) \|\| is_bad_inode(vol->extend_ino)) {
2086	if (!IS_ERR(vol->extend_ino))
2087	iput(vol->extend_ino);
2088	ntfs_error(sb, "Failed to load $Extend.");
2089	goto iput_sec_err_out;
2090	}
2091	#ifdef NTFS_RW
2092	/* Find the quota file, load it if present, and set it up. */
2093	if (!load_and_init_quota(vol)) {
2094	static const char *es1 = "Failed to load $Quota";
2095	static const char *es2 = ". Run chkdsk.";
2096
2097	/* If a read-write mount, convert it to a read-only mount. */
2098	if (!(sb->s_flags & MS_RDONLY)) {
2099	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2100	ON_ERRORS_CONTINUE))) {
2101	ntfs_error(sb, "%s and neither on_errors="
2102	"continue nor on_errors="
2103	"remount-ro was specified%s",
2104	es1, es2);
2105	goto iput_quota_err_out;
2106	}
2107	sb->s_flags \|= MS_RDONLY;
2108	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2109	} else
2110	ntfs_warning(sb, "%s. Will not be able to remount "
2111	"read-write%s", es1, es2);
2112	/* This will prevent a read-write remount. */
2113	NVolSetErrors(vol);
2114	}
2115	/* If (still) a read-write mount, mark the quotas out of date. */
2116	if (!(sb->s_flags & MS_RDONLY) &&
2117	!ntfs_mark_quotas_out_of_date(vol)) {
2118	static const char *es1 = "Failed to mark quotas out of date";
2119	static const char *es2 = ". Run chkdsk.";
2120
2121	/* Convert to a read-only mount. */
2122	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2123	ON_ERRORS_CONTINUE))) {
2124	ntfs_error(sb, "%s and neither on_errors=continue nor "
2125	"on_errors=remount-ro was specified%s",
2126	es1, es2);
2127	goto iput_quota_err_out;
2128	}
2129	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2130	sb->s_flags \|= MS_RDONLY;
2131	NVolSetErrors(vol);
2132	}
2133	/*
2134	* Find the transaction log file ($UsnJrnl), load it if present, check
2135	* it, and set it up.
2136	*/
2137	if (!load_and_init_usnjrnl(vol)) {
2138	static const char *es1 = "Failed to load $UsnJrnl";
2139	static const char *es2 = ". Run chkdsk.";
2140
2141	/* If a read-write mount, convert it to a read-only mount. */
2142	if (!(sb->s_flags & MS_RDONLY)) {
2143	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2144	ON_ERRORS_CONTINUE))) {
2145	ntfs_error(sb, "%s and neither on_errors="
2146	"continue nor on_errors="
2147	"remount-ro was specified%s",
2148	es1, es2);
2149	goto iput_usnjrnl_err_out;
2150	}
2151	sb->s_flags \|= MS_RDONLY;
2152	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2153	} else
2154	ntfs_warning(sb, "%s. Will not be able to remount "
2155	"read-write%s", es1, es2);
2156	/* This will prevent a read-write remount. */
2157	NVolSetErrors(vol);
2158	}
2159	/* If (still) a read-write mount, stamp the transaction log. */
2160	if (!(sb->s_flags & MS_RDONLY) && !ntfs_stamp_usnjrnl(vol)) {
2161	static const char *es1 = "Failed to stamp transaction log "
2162	"($UsnJrnl)";
2163	static const char *es2 = ". Run chkdsk.";
2164
2165	/* Convert to a read-only mount. */
2166	if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO \|
2167	ON_ERRORS_CONTINUE))) {
2168	ntfs_error(sb, "%s and neither on_errors=continue nor "
2169	"on_errors=remount-ro was specified%s",
2170	es1, es2);
2171	goto iput_usnjrnl_err_out;
2172	}
2173	ntfs_error(sb, "%s. Mounting read-only%s", es1, es2);
2174	sb->s_flags \|= MS_RDONLY;
2175	NVolSetErrors(vol);
2176	}
2177	#endif /* NTFS_RW */
2178	return true;
2179	#ifdef NTFS_RW
2180	iput_usnjrnl_err_out:
2181	if (vol->usnjrnl_j_ino)
2182	iput(vol->usnjrnl_j_ino);
2183	if (vol->usnjrnl_max_ino)
2184	iput(vol->usnjrnl_max_ino);
2185	if (vol->usnjrnl_ino)
2186	iput(vol->usnjrnl_ino);
2187	iput_quota_err_out:
2188	if (vol->quota_q_ino)
2189	iput(vol->quota_q_ino);
2190	if (vol->quota_ino)
2191	iput(vol->quota_ino);
2192	iput(vol->extend_ino);
2193	#endif /* NTFS_RW */
2194	iput_sec_err_out:
2195	iput(vol->secure_ino);
2196	iput_root_err_out:
2197	iput(vol->root_ino);
2198	iput_logfile_err_out:
2199	#ifdef NTFS_RW
2200	if (vol->logfile_ino)
2201	iput(vol->logfile_ino);
2202	iput_vol_err_out:
2203	#endif /* NTFS_RW */
2204	iput(vol->vol_ino);
2205	iput_lcnbmp_err_out:
2206	iput(vol->lcnbmp_ino);
2207	iput_attrdef_err_out:
2208	vol->attrdef_size = 0;
2209	if (vol->attrdef) {
2210	ntfs_free(vol->attrdef);
2211	vol->attrdef = NULL;
2212	}
2213	#ifdef NTFS_RW
2214	iput_upcase_err_out:
2215	#endif /* NTFS_RW */
2216	vol->upcase_len = 0;
2217	mutex_lock(&ntfs_lock);
2218	if (vol->upcase == default_upcase) {
2219	ntfs_nr_upcase_users--;
2220	vol->upcase = NULL;
2221	}
2222	mutex_unlock(&ntfs_lock);
2223	if (vol->upcase) {
2224	ntfs_free(vol->upcase);
2225	vol->upcase = NULL;
2226	}
2227	iput_mftbmp_err_out:
2228	iput(vol->mftbmp_ino);
2229	iput_mirr_err_out:
2230	#ifdef NTFS_RW
2231	if (vol->mftmirr_ino)
2232	iput(vol->mftmirr_ino);
2233	#endif /* NTFS_RW */
2234	return false;
2235	}
2236
2237	/**
2238	* ntfs_put_super - called by the vfs to unmount a volume
2239	* @sb: vfs superblock of volume to unmount
2240	*
2241	* ntfs_put_super() is called by the VFS (from fs/super.c::do_umount()) when
2242	* the volume is being unmounted (umount system call has been invoked) and it
2243	* releases all inodes and memory belonging to the NTFS specific part of the
2244	* super block.
2245	*/
2246	static void ntfs_put_super(struct super_block *sb)
2247	{
2248	ntfs_volume *vol = NTFS_SB(sb);
2249
2250	ntfs_debug("Entering.");
2251
2252	#ifdef NTFS_RW
2253	/*
2254	* Commit all inodes while they are still open in case some of them
2255	* cause others to be dirtied.
2256	*/
2257	ntfs_commit_inode(vol->vol_ino);
2258
2259	/* NTFS 3.0+ specific. */
2260	if (vol->major_ver >= 3) {
2261	if (vol->usnjrnl_j_ino)
2262	ntfs_commit_inode(vol->usnjrnl_j_ino);
2263	if (vol->usnjrnl_max_ino)
2264	ntfs_commit_inode(vol->usnjrnl_max_ino);
2265	if (vol->usnjrnl_ino)
2266	ntfs_commit_inode(vol->usnjrnl_ino);
2267	if (vol->quota_q_ino)
2268	ntfs_commit_inode(vol->quota_q_ino);
2269	if (vol->quota_ino)
2270	ntfs_commit_inode(vol->quota_ino);
2271	if (vol->extend_ino)
2272	ntfs_commit_inode(vol->extend_ino);
2273	if (vol->secure_ino)
2274	ntfs_commit_inode(vol->secure_ino);
2275	}
2276
2277	ntfs_commit_inode(vol->root_ino);
2278
2279	down_write(&vol->lcnbmp_lock);
2280	ntfs_commit_inode(vol->lcnbmp_ino);
2281	up_write(&vol->lcnbmp_lock);
2282
2283	down_write(&vol->mftbmp_lock);
2284	ntfs_commit_inode(vol->mftbmp_ino);
2285	up_write(&vol->mftbmp_lock);
2286
2287	if (vol->logfile_ino)
2288	ntfs_commit_inode(vol->logfile_ino);
2289
2290	if (vol->mftmirr_ino)
2291	ntfs_commit_inode(vol->mftmirr_ino);
2292	ntfs_commit_inode(vol->mft_ino);
2293
2294	/*
2295	* If a read-write mount and no volume errors have occurred, mark the
2296	* volume clean. Also, re-commit all affected inodes.
2297	*/
2298	if (!(sb->s_flags & MS_RDONLY)) {
2299	if (!NVolErrors(vol)) {
2300	if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
2301	ntfs_warning(sb, "Failed to clear dirty bit "
2302	"in volume information "
2303	"flags. Run chkdsk.");
2304	ntfs_commit_inode(vol->vol_ino);
2305	ntfs_commit_inode(vol->root_ino);
2306	if (vol->mftmirr_ino)
2307	ntfs_commit_inode(vol->mftmirr_ino);
2308	ntfs_commit_inode(vol->mft_ino);
2309	} else {
2310	ntfs_warning(sb, "Volume has errors. Leaving volume "
2311	"marked dirty. Run chkdsk.");
2312	}
2313	}
2314	#endif /* NTFS_RW */
2315
2316	iput(vol->vol_ino);
2317	vol->vol_ino = NULL;
2318
2319	/* NTFS 3.0+ specific clean up. */
2320	if (vol->major_ver >= 3) {
2321	#ifdef NTFS_RW
2322	if (vol->usnjrnl_j_ino) {
2323	iput(vol->usnjrnl_j_ino);
2324	vol->usnjrnl_j_ino = NULL;
2325	}
2326	if (vol->usnjrnl_max_ino) {
2327	iput(vol->usnjrnl_max_ino);
2328	vol->usnjrnl_max_ino = NULL;
2329	}
2330	if (vol->usnjrnl_ino) {
2331	iput(vol->usnjrnl_ino);
2332	vol->usnjrnl_ino = NULL;
2333	}
2334	if (vol->quota_q_ino) {
2335	iput(vol->quota_q_ino);
2336	vol->quota_q_ino = NULL;
2337	}
2338	if (vol->quota_ino) {
2339	iput(vol->quota_ino);
2340	vol->quota_ino = NULL;
2341	}
2342	#endif /* NTFS_RW */
2343	if (vol->extend_ino) {
2344	iput(vol->extend_ino);
2345	vol->extend_ino = NULL;
2346	}
2347	if (vol->secure_ino) {
2348	iput(vol->secure_ino);
2349	vol->secure_ino = NULL;
2350	}
2351	}
2352
2353	iput(vol->root_ino);
2354	vol->root_ino = NULL;
2355
2356	down_write(&vol->lcnbmp_lock);
2357	iput(vol->lcnbmp_ino);
2358	vol->lcnbmp_ino = NULL;
2359	up_write(&vol->lcnbmp_lock);
2360
2361	down_write(&vol->mftbmp_lock);
2362	iput(vol->mftbmp_ino);
2363	vol->mftbmp_ino = NULL;
2364	up_write(&vol->mftbmp_lock);
2365
2366	#ifdef NTFS_RW
2367	if (vol->logfile_ino) {
2368	iput(vol->logfile_ino);
2369	vol->logfile_ino = NULL;
2370	}
2371	if (vol->mftmirr_ino) {
2372	/* Re-commit the mft mirror and mft just in case. */
2373	ntfs_commit_inode(vol->mftmirr_ino);
2374	ntfs_commit_inode(vol->mft_ino);
2375	iput(vol->mftmirr_ino);
2376	vol->mftmirr_ino = NULL;
2377	}
2378	/*
2379	* We should have no dirty inodes left, due to
2380	* mft.c::ntfs_mft_writepage() cleaning all the dirty pages as
2381	* the underlying mft records are written out and cleaned.
2382	*/
2383	ntfs_commit_inode(vol->mft_ino);
2384	write_inode_now(vol->mft_ino, 1);
2385	#endif /* NTFS_RW */
2386
2387	iput(vol->mft_ino);
2388	vol->mft_ino = NULL;
2389
2390	/* Throw away the table of attribute definitions. */
2391	vol->attrdef_size = 0;
2392	if (vol->attrdef) {
2393	ntfs_free(vol->attrdef);
2394	vol->attrdef = NULL;
2395	}
2396	vol->upcase_len = 0;
2397	/*
2398	* Destroy the global default upcase table if necessary. Also decrease
2399	* the number of upcase users if we are a user.
2400	*/
2401	mutex_lock(&ntfs_lock);
2402	if (vol->upcase == default_upcase) {
2403	ntfs_nr_upcase_users--;
2404	vol->upcase = NULL;
2405	}
2406	if (!ntfs_nr_upcase_users && default_upcase) {
2407	ntfs_free(default_upcase);
2408	default_upcase = NULL;
2409	}
2410	if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2411	free_compression_buffers();
2412	mutex_unlock(&ntfs_lock);
2413	if (vol->upcase) {
2414	ntfs_free(vol->upcase);
2415	vol->upcase = NULL;
2416	}
2417
2418	unload_nls(vol->nls_map);
2419
2420	sb->s_fs_info = NULL;
2421	kfree(vol);
2422	}
2423
2424	/**
2425	* get_nr_free_clusters - return the number of free clusters on a volume
2426	* @vol: ntfs volume for which to obtain free cluster count
2427	*
2428	* Calculate the number of free clusters on the mounted NTFS volume @vol. We
2429	* actually calculate the number of clusters in use instead because this
2430	* allows us to not care about partial pages as these will be just zero filled
2431	* and hence not be counted as allocated clusters.
2432	*
2433	* The only particularity is that clusters beyond the end of the logical ntfs
2434	* volume will be marked as allocated to prevent errors which means we have to
2435	* discount those at the end. This is important as the cluster bitmap always
2436	* has a size in multiples of 8 bytes, i.e. up to 63 clusters could be outside
2437	* the logical volume and marked in use when they are not as they do not exist.
2438	*
2439	* If any pages cannot be read we assume all clusters in the erroring pages are
2440	* in use. This means we return an underestimate on errors which is better than
2441	* an overestimate.
2442	*/
2443	static s64 get_nr_free_clusters(ntfs_volume *vol)
2444	{
2445	s64 nr_free = vol->nr_clusters;
2446	struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
2447	struct page *page;
2448	pgoff_t index, max_index;
2449
2450	ntfs_debug("Entering.");
2451	/* Serialize accesses to the cluster bitmap. */
2452	down_read(&vol->lcnbmp_lock);
2453	/*
2454	* Convert the number of bits into bytes rounded up, then convert into
2455	* multiples of PAGE_CACHE_SIZE, rounding up so that if we have one
2456	* full and one partial page max_index = 2.
2457	*/
2458	max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_CACHE_SIZE - 1) >>
2459	PAGE_CACHE_SHIFT;
2460	/* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
2461	ntfs_debug("Reading $Bitmap, max_index = 0x%lx, max_size = 0x%lx.",
2462	max_index, PAGE_CACHE_SIZE / 4);
2463	for (index = 0; index < max_index; index++) {
2464	unsigned long *kaddr;
2465
2466	/*
2467	* Read the page from page cache, getting it from backing store
2468	* if necessary, and increment the use count.
2469	*/
2470	page = read_mapping_page(mapping, index, NULL);
2471	/* Ignore pages which errored synchronously. */
2472	if (IS_ERR(page)) {
2473	ntfs_debug("read_mapping_page() error. Skipping "
2474	"page (index 0x%lx).", index);
2475	nr_free -= PAGE_CACHE_SIZE * 8;
2476	continue;
2477	}
2478	kaddr = kmap_atomic(page, KM_USER0);
2479	/*
2480	* Subtract the number of set bits. If this
2481	* is the last page and it is partial we don't really care as
2482	* it just means we do a little extra work but it won't affect
2483	* the result as all out of range bytes are set to zero by
2484	* ntfs_readpage().
2485	*/
2486	nr_free -= bitmap_weight(kaddr,
2487	PAGE_CACHE_SIZE * BITS_PER_BYTE);
2488	kunmap_atomic(kaddr, KM_USER0);
2489	page_cache_release(page);
2490	}
2491	ntfs_debug("Finished reading $Bitmap, last index = 0x%lx.", index - 1);
2492	/*
2493	* Fixup for eventual bits outside logical ntfs volume (see function
2494	* description above).
2495	*/
2496	if (vol->nr_clusters & 63)
2497	nr_free += 64 - (vol->nr_clusters & 63);
2498	up_read(&vol->lcnbmp_lock);
2499	/* If errors occurred we may well have gone below zero, fix this. */
2500	if (nr_free < 0)
2501	nr_free = 0;
2502	ntfs_debug("Exiting.");
2503	return nr_free;
2504	}
2505
2506	/**
2507	* __get_nr_free_mft_records - return the number of free inodes on a volume
2508	* @vol: ntfs volume for which to obtain free inode count
2509	* @nr_free: number of mft records in filesystem
2510	* @max_index: maximum number of pages containing set bits
2511	*
2512	* Calculate the number of free mft records (inodes) on the mounted NTFS
2513	* volume @vol. We actually calculate the number of mft records in use instead
2514	* because this allows us to not care about partial pages as these will be just
2515	* zero filled and hence not be counted as allocated mft record.
2516	*
2517	* If any pages cannot be read we assume all mft records in the erroring pages
2518	* are in use. This means we return an underestimate on errors which is better
2519	* than an overestimate.
2520	*
2521	* NOTE: Caller must hold mftbmp_lock rw_semaphore for reading or writing.
2522	*/
2523	static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
2524	s64 nr_free, const pgoff_t max_index)
2525	{
2526	struct address_space *mapping = vol->mftbmp_ino->i_mapping;
2527	struct page *page;
2528	pgoff_t index;
2529
2530	ntfs_debug("Entering.");
2531	/* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
2532	ntfs_debug("Reading $MFT/$BITMAP, max_index = 0x%lx, max_size = "
2533	"0x%lx.", max_index, PAGE_CACHE_SIZE / 4);
2534	for (index = 0; index < max_index; index++) {
2535	unsigned long *kaddr;
2536
2537	/*
2538	* Read the page from page cache, getting it from backing store
2539	* if necessary, and increment the use count.
2540	*/
2541	page = read_mapping_page(mapping, index, NULL);
2542	/* Ignore pages which errored synchronously. */
2543	if (IS_ERR(page)) {
2544	ntfs_debug("read_mapping_page() error. Skipping "
2545	"page (index 0x%lx).", index);
2546	nr_free -= PAGE_CACHE_SIZE * 8;
2547	continue;
2548	}
2549	kaddr = kmap_atomic(page, KM_USER0);
2550	/*
2551	* Subtract the number of set bits. If this
2552	* is the last page and it is partial we don't really care as
2553	* it just means we do a little extra work but it won't affect
2554	* the result as all out of range bytes are set to zero by
2555	* ntfs_readpage().
2556	*/
2557	nr_free -= bitmap_weight(kaddr,
2558	PAGE_CACHE_SIZE * BITS_PER_BYTE);
2559	kunmap_atomic(kaddr, KM_USER0);
2560	page_cache_release(page);
2561	}
2562	ntfs_debug("Finished reading $MFT/$BITMAP, last index = 0x%lx.",
2563	index - 1);
2564	/* If errors occurred we may well have gone below zero, fix this. */
2565	if (nr_free < 0)
2566	nr_free = 0;
2567	ntfs_debug("Exiting.");
2568	return nr_free;
2569	}
2570
2571	/**
2572	* ntfs_statfs - return information about mounted NTFS volume
2573	* @dentry: dentry from mounted volume
2574	* @sfs: statfs structure in which to return the information
2575	*
2576	* Return information about the mounted NTFS volume @dentry in the statfs structure
2577	* pointed to by @sfs (this is initialized with zeros before ntfs_statfs is
2578	* called). We interpret the values to be correct of the moment in time at
2579	* which we are called. Most values are variable otherwise and this isn't just
2580	* the free values but the totals as well. For example we can increase the
2581	* total number of file nodes if we run out and we can keep doing this until
2582	* there is no more space on the volume left at all.
2583	*
2584	* Called from vfs_statfs which is used to handle the statfs, fstatfs, and
2585	* ustat system calls.
2586	*
2587	* Return 0 on success or -errno on error.
2588	*/
2589	static int ntfs_statfs(struct dentry dentry, struct kstatfs sfs)
2590	{
2591	struct super_block *sb = dentry->d_sb;
2592	s64 size;
2593	ntfs_volume *vol = NTFS_SB(sb);
2594	ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
2595	pgoff_t max_index;
2596	unsigned long flags;
2597
2598	ntfs_debug("Entering.");
2599	/* Type of filesystem. */
2600	sfs->f_type = NTFS_SB_MAGIC;
2601	/* Optimal transfer block size. */
2602	sfs->f_bsize = PAGE_CACHE_SIZE;
2603	/*
2604	* Total data blocks in filesystem in units of f_bsize and since
2605	* inodes are also stored in data blocs ($MFT is a file) this is just
2606	* the total clusters.
2607	*/
2608	sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
2609	PAGE_CACHE_SHIFT;
2610	/* Free data blocks in filesystem in units of f_bsize. */
2611	size = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
2612	PAGE_CACHE_SHIFT;
2613	if (size < 0LL)
2614	size = 0LL;
2615	/* Free blocks avail to non-superuser, same as above on NTFS. */
2616	sfs->f_bavail = sfs->f_bfree = size;
2617	/* Serialize accesses to the inode bitmap. */
2618	down_read(&vol->mftbmp_lock);
2619	read_lock_irqsave(&mft_ni->size_lock, flags);
2620	size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
2621	/*
2622	* Convert the maximum number of set bits into bytes rounded up, then
2623	* convert into multiples of PAGE_CACHE_SIZE, rounding up so that if we
2624	* have one full and one partial page max_index = 2.
2625	*/
2626	max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
2627	+ 7) >> 3) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
2628	read_unlock_irqrestore(&mft_ni->size_lock, flags);
2629	/* Number of inodes in filesystem (at this point in time). */
2630	sfs->f_files = size;
2631	/* Free inodes in fs (based on current total count). */
2632	sfs->f_ffree = __get_nr_free_mft_records(vol, size, max_index);
2633	up_read(&vol->mftbmp_lock);
2634	/*
2635	* File system id. This is extremely *nix flavour dependent and even
2636	* within Linux itself all fs do their own thing. I interpret this to
2637	* mean a unique id associated with the mounted fs and not the id
2638	* associated with the filesystem driver, the latter is already given
2639	* by the filesystem type in sfs->f_type. Thus we use the 64-bit
2640	* volume serial number splitting it into two 32-bit parts. We enter
2641	* the least significant 32-bits in f_fsid[0] and the most significant
2642	* 32-bits in f_fsid[1].
2643	*/
2644	sfs->f_fsid.val[0] = vol->serial_no & 0xffffffff;
2645	sfs->f_fsid.val[1] = (vol->serial_no >> 32) & 0xffffffff;
2646	/* Maximum length of filenames. */
2647	sfs->f_namelen = NTFS_MAX_NAME_LEN;
2648	return 0;
2649	}
2650
2651	#ifdef NTFS_RW
2652	static int ntfs_write_inode(struct inode vi, struct writeback_control wbc)
2653	{
2654	return __ntfs_write_inode(vi, wbc->sync_mode == WB_SYNC_ALL);
2655	}
2656	#endif
2657
2658	/**
2659	* The complete super operations.
2660	*/
2661	static const struct super_operations ntfs_sops = {
2662	.alloc_inode = ntfs_alloc_big_inode, /* VFS: Allocate new inode. */
2663	.destroy_inode = ntfs_destroy_big_inode, /* VFS: Deallocate inode. */
2664	#ifdef NTFS_RW
2665	//.dirty_inode = NULL, /* VFS: Called from
2666	// __mark_inode_dirty(). */
2667	.write_inode = ntfs_write_inode, /* VFS: Write dirty inode to
2668	disk. */
2669	//.drop_inode = NULL, /* VFS: Called just after the
2670	// inode reference count has
2671	// been decreased to zero.
2672	// NOTE: The inode lock is
2673	// held. See fs/inode.c::
2674	// generic_drop_inode(). */
2675	//.delete_inode = NULL, /* VFS: Delete inode from disk.
2676	// Called when i_count becomes
2677	// 0 and i_nlink is also 0. */
2678	//.write_super = NULL, /* Flush dirty super block to
2679	// disk. */
2680	//.sync_fs = NULL, /* ? */
2681	//.write_super_lockfs = NULL, /* ? */
2682	//.unlockfs = NULL, /* ? */
2683	#endif /* NTFS_RW */
2684	.put_super = ntfs_put_super, /* Syscall: umount. */
2685	.statfs = ntfs_statfs, /* Syscall: statfs */
2686	.remount_fs = ntfs_remount, /* Syscall: mount -o remount. */
2687	.evict_inode = ntfs_evict_big_inode, /* VFS: Called when an inode is
2688	removed from memory. */
2689	//.umount_begin = NULL, /* Forced umount. */
2690	.show_options = ntfs_show_options, /* Show mount options in
2691	proc. */
2692	};
2693
2694	/**
2695	* ntfs_fill_super - mount an ntfs filesystem
2696	* @sb: super block of ntfs filesystem to mount
2697	* @opt: string containing the mount options
2698	* @silent: silence error output
2699	*
2700	* ntfs_fill_super() is called by the VFS to mount the device described by @sb
2701	* with the mount otions in @data with the NTFS filesystem.
2702	*
2703	* If @silent is true, remain silent even if errors are detected. This is used
2704	* during bootup, when the kernel tries to mount the root filesystem with all
2705	* registered filesystems one after the other until one succeeds. This implies
2706	* that all filesystems except the correct one will quite correctly and
2707	* expectedly return an error, but nobody wants to see error messages when in
2708	* fact this is what is supposed to happen.
2709	*
2710	* NOTE: @sb->s_flags contains the mount options flags.
2711	*/
2712	static int ntfs_fill_super(struct super_block sb, void opt, const int silent)
2713	{
2714	ntfs_volume *vol;
2715	struct buffer_head *bh;
2716	struct inode *tmp_ino;
2717	int blocksize, result;
2718
2719	/*
2720	* We do a pretty difficult piece of bootstrap by reading the
2721	* MFT (and other metadata) from disk into memory. We'll only
2722	* release this metadata during umount, so the locking patterns
2723	* observed during bootstrap do not count. So turn off the
2724	* observation of locking patterns (strictly for this context
2725	* only) while mounting NTFS. [The validator is still active
2726	* otherwise, even for this context: it will for example record
2727	* lock class registrations.]
2728	*/
2729	lockdep_off();
2730	ntfs_debug("Entering.");
2731	#ifndef NTFS_RW
2732	sb->s_flags \|= MS_RDONLY;
2733	#endif /* ! NTFS_RW */
2734	/* Allocate a new ntfs_volume and place it in sb->s_fs_info. */
2735	sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS);
2736	vol = NTFS_SB(sb);
2737	if (!vol) {
2738	if (!silent)
2739	ntfs_error(sb, "Allocation of NTFS volume structure "
2740	"failed. Aborting mount...");
2741	lockdep_on();
2742	return -ENOMEM;
2743	}
2744	/* Initialize ntfs_volume structure. */
2745	*vol = (ntfs_volume) {
2746	.sb = sb,
2747	/*
2748	* Default is group and other don't have any access to files or
2749	* directories while owner has full access. Further, files by
2750	* default are not executable but directories are of course
2751	* browseable.
2752	*/
2753	.fmask = 0177,
2754	.dmask = 0077,
2755	};
2756	init_rwsem(&vol->mftbmp_lock);
2757	init_rwsem(&vol->lcnbmp_lock);
2758
2759	/* By default, enable sparse support. */
2760	NVolSetSparseEnabled(vol);
2761
2762	/* Important to get the mount options dealt with now. */
2763	if (!parse_options(vol, (char*)opt))
2764	goto err_out_now;
2765
2766	/* We support sector sizes up to the PAGE_CACHE_SIZE. */
2767	if (bdev_logical_block_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
2768	if (!silent)
2769	ntfs_error(sb, "Device has unsupported sector size "
2770	"(%i). The maximum supported sector "
2771	"size on this architecture is %lu "
2772	"bytes.",
2773	bdev_logical_block_size(sb->s_bdev),
2774	PAGE_CACHE_SIZE);
2775	goto err_out_now;
2776	}
2777	/*
2778	* Setup the device access block size to NTFS_BLOCK_SIZE or the hard
2779	* sector size, whichever is bigger.
2780	*/
2781	blocksize = sb_min_blocksize(sb, NTFS_BLOCK_SIZE);
2782	if (blocksize < NTFS_BLOCK_SIZE) {
2783	if (!silent)
2784	ntfs_error(sb, "Unable to set device block size.");
2785	goto err_out_now;
2786	}
2787	BUG_ON(blocksize != sb->s_blocksize);
2788	ntfs_debug("Set device block size to %i bytes (block size bits %i).",
2789	blocksize, sb->s_blocksize_bits);
2790	/* Determine the size of the device in units of block_size bytes. */
2791	if (!i_size_read(sb->s_bdev->bd_inode)) {
2792	if (!silent)
2793	ntfs_error(sb, "Unable to determine device size.");
2794	goto err_out_now;
2795	}
2796	vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2797	sb->s_blocksize_bits;
2798	/* Read the boot sector and return unlocked buffer head to it. */
2799	if (!(bh = read_ntfs_boot_sector(sb, silent))) {
2800	if (!silent)
2801	ntfs_error(sb, "Not an NTFS volume.");
2802	goto err_out_now;
2803	}
2804	/*
2805	* Extract the data from the boot sector and setup the ntfs volume
2806	* using it.
2807	*/
2808	result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
2809	brelse(bh);
2810	if (!result) {
2811	if (!silent)
2812	ntfs_error(sb, "Unsupported NTFS filesystem.");
2813	goto err_out_now;
2814	}
2815	/*
2816	* If the boot sector indicates a sector size bigger than the current
2817	* device block size, switch the device block size to the sector size.
2818	* TODO: It may be possible to support this case even when the set
2819	* below fails, we would just be breaking up the i/o for each sector
2820	* into multiple blocks for i/o purposes but otherwise it should just
2821	* work. However it is safer to leave disabled until someone hits this
2822	* error message and then we can get them to try it without the setting
2823	* so we know for sure that it works.
2824	*/
2825	if (vol->sector_size > blocksize) {
2826	blocksize = sb_set_blocksize(sb, vol->sector_size);
2827	if (blocksize != vol->sector_size) {
2828	if (!silent)
2829	ntfs_error(sb, "Unable to set device block "
2830	"size to sector size (%i).",
2831	vol->sector_size);
2832	goto err_out_now;
2833	}
2834	BUG_ON(blocksize != sb->s_blocksize);
2835	vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2836	sb->s_blocksize_bits;
2837	ntfs_debug("Changed device block size to %i bytes (block size "
2838	"bits %i) to match volume sector size.",
2839	blocksize, sb->s_blocksize_bits);
2840	}
2841	/* Initialize the cluster and mft allocators. */
2842	ntfs_setup_allocators(vol);
2843	/* Setup remaining fields in the super block. */
2844	sb->s_magic = NTFS_SB_MAGIC;
2845	/*
2846	* Ntfs allows 63 bits for the file size, i.e. correct would be:
2847	* sb->s_maxbytes = ~0ULL >> 1;
2848	* But the kernel uses a long as the page cache page index which on
2849	* 32-bit architectures is only 32-bits. MAX_LFS_FILESIZE is kernel
2850	* defined to the maximum the page cache page index can cope with
2851	* without overflowing the index or to 2^63 - 1, whichever is smaller.
2852	*/
2853	sb->s_maxbytes = MAX_LFS_FILESIZE;
2854	/* Ntfs measures time in 100ns intervals. */
2855	sb->s_time_gran = 100;
2856	/*
2857	* Now load the metadata required for the page cache and our address
2858	* space operations to function. We do this by setting up a specialised
2859	* read_inode method and then just calling the normal iget() to obtain
2860	* the inode for $MFT which is sufficient to allow our normal inode
2861	* operations and associated address space operations to function.
2862	*/
2863	sb->s_op = &ntfs_sops;
2864	tmp_ino = new_inode(sb);
2865	if (!tmp_ino) {
2866	if (!silent)
2867	ntfs_error(sb, "Failed to load essential metadata.");
2868	goto err_out_now;
2869	}
2870	tmp_ino->i_ino = FILE_MFT;
2871	insert_inode_hash(tmp_ino);
2872	if (ntfs_read_inode_mount(tmp_ino) < 0) {
2873	if (!silent)
2874	ntfs_error(sb, "Failed to load essential metadata.");
2875	goto iput_tmp_ino_err_out_now;
2876	}
2877	mutex_lock(&ntfs_lock);
2878	/*
2879	* The current mount is a compression user if the cluster size is
2880	* less than or equal 4kiB.
2881	*/
2882	if (vol->cluster_size <= 4096 && !ntfs_nr_compression_users++) {
2883	result = allocate_compression_buffers();
2884	if (result) {
2885	ntfs_error(NULL, "Failed to allocate buffers "
2886	"for compression engine.");
2887	ntfs_nr_compression_users--;
2888	mutex_unlock(&ntfs_lock);
2889	goto iput_tmp_ino_err_out_now;
2890	}
2891	}
2892	/*
2893	* Generate the global default upcase table if necessary. Also
2894	* temporarily increment the number of upcase users to avoid race
2895	* conditions with concurrent (u)mounts.
2896	*/
2897	if (!default_upcase)
2898	default_upcase = generate_default_upcase();
2899	ntfs_nr_upcase_users++;
2900	mutex_unlock(&ntfs_lock);
2901	/*
2902	* From now on, ignore @silent parameter. If we fail below this line,
2903	* it will be due to a corrupt fs or a system error, so we report it.
2904	*/
2905	/*
2906	* Open the system files with normal access functions and complete
2907	* setting up the ntfs super block.
2908	*/
2909	if (!load_system_files(vol)) {
2910	ntfs_error(sb, "Failed to load system files.");
2911	goto unl_upcase_iput_tmp_ino_err_out_now;
2912	}
2913	if ((sb->s_root = d_alloc_root(vol->root_ino))) {
2914	/* We grab a reference, simulating an ntfs_iget(). */
2915	ihold(vol->root_ino);
2916	ntfs_debug("Exiting, status successful.");
2917	/* Release the default upcase if it has no users. */
2918	mutex_lock(&ntfs_lock);
2919	if (!--ntfs_nr_upcase_users && default_upcase) {
2920	ntfs_free(default_upcase);
2921	default_upcase = NULL;
2922	}
2923	mutex_unlock(&ntfs_lock);
2924	sb->s_export_op = &ntfs_export_ops;
2925	lockdep_on();
2926	return 0;
2927	}
2928	ntfs_error(sb, "Failed to allocate root directory.");
2929	/* Clean up after the successful load_system_files() call from above. */
2930	// TODO: Use ntfs_put_super() instead of repeating all this code...
2931	// FIXME: Should mark the volume clean as the error is most likely
2932	// -ENOMEM.
2933	iput(vol->vol_ino);
2934	vol->vol_ino = NULL;
2935	/* NTFS 3.0+ specific clean up. */
2936	if (vol->major_ver >= 3) {
2937	#ifdef NTFS_RW
2938	if (vol->usnjrnl_j_ino) {
2939	iput(vol->usnjrnl_j_ino);
2940	vol->usnjrnl_j_ino = NULL;
2941	}
2942	if (vol->usnjrnl_max_ino) {
2943	iput(vol->usnjrnl_max_ino);
2944	vol->usnjrnl_max_ino = NULL;
2945	}
2946	if (vol->usnjrnl_ino) {
2947	iput(vol->usnjrnl_ino);
2948	vol->usnjrnl_ino = NULL;
2949	}
2950	if (vol->quota_q_ino) {
2951	iput(vol->quota_q_ino);
2952	vol->quota_q_ino = NULL;
2953	}
2954	if (vol->quota_ino) {
2955	iput(vol->quota_ino);
2956	vol->quota_ino = NULL;
2957	}
2958	#endif /* NTFS_RW */
2959	if (vol->extend_ino) {
2960	iput(vol->extend_ino);
2961	vol->extend_ino = NULL;
2962	}
2963	if (vol->secure_ino) {
2964	iput(vol->secure_ino);
2965	vol->secure_ino = NULL;
2966	}
2967	}
2968	iput(vol->root_ino);
2969	vol->root_ino = NULL;
2970	iput(vol->lcnbmp_ino);
2971	vol->lcnbmp_ino = NULL;
2972	iput(vol->mftbmp_ino);
2973	vol->mftbmp_ino = NULL;
2974	#ifdef NTFS_RW
2975	if (vol->logfile_ino) {
2976	iput(vol->logfile_ino);
2977	vol->logfile_ino = NULL;
2978	}
2979	if (vol->mftmirr_ino) {
2980	iput(vol->mftmirr_ino);
2981	vol->mftmirr_ino = NULL;
2982	}
2983	#endif /* NTFS_RW */
2984	/* Throw away the table of attribute definitions. */
2985	vol->attrdef_size = 0;
2986	if (vol->attrdef) {
2987	ntfs_free(vol->attrdef);
2988	vol->attrdef = NULL;
2989	}
2990	vol->upcase_len = 0;
2991	mutex_lock(&ntfs_lock);
2992	if (vol->upcase == default_upcase) {
2993	ntfs_nr_upcase_users--;
2994	vol->upcase = NULL;
2995	}
2996	mutex_unlock(&ntfs_lock);
2997	if (vol->upcase) {
2998	ntfs_free(vol->upcase);
2999	vol->upcase = NULL;
3000	}
3001	if (vol->nls_map) {
3002	unload_nls(vol->nls_map);
3003	vol->nls_map = NULL;
3004	}
3005	/* Error exit code path. */
3006	unl_upcase_iput_tmp_ino_err_out_now:
3007	/*
3008	* Decrease the number of upcase users and destroy the global default
3009	* upcase table if necessary.
3010	*/
3011	mutex_lock(&ntfs_lock);
3012	if (!--ntfs_nr_upcase_users && default_upcase) {
3013	ntfs_free(default_upcase);
3014	default_upcase = NULL;
3015	}
3016	if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
3017	free_compression_buffers();
3018	mutex_unlock(&ntfs_lock);
3019	iput_tmp_ino_err_out_now:
3020	iput(tmp_ino);
3021	if (vol->mft_ino && vol->mft_ino != tmp_ino)
3022	iput(vol->mft_ino);
3023	vol->mft_ino = NULL;
3024	/* Errors at this stage are irrelevant. */
3025	err_out_now:
3026	sb->s_fs_info = NULL;
3027	kfree(vol);
3028	ntfs_debug("Failed, returning -EINVAL.");
3029	lockdep_on();
3030	return -EINVAL;
3031	}
3032
3033	/*
3034	* This is a slab cache to optimize allocations and deallocations of Unicode
3035	* strings of the maximum length allowed by NTFS, which is NTFS_MAX_NAME_LEN
3036	* (255) Unicode characters + a terminating NULL Unicode character.
3037	*/
3038	struct kmem_cache *ntfs_name_cache;
3039
3040	/* Slab caches for efficient allocation/deallocation of inodes. */
3041	struct kmem_cache *ntfs_inode_cache;
3042	struct kmem_cache *ntfs_big_inode_cache;
3043
3044	/* Init once constructor for the inode slab cache. */
3045	static void ntfs_big_inode_init_once(void *foo)
3046	{
3047	ntfs_inode ni = (ntfs_inode )foo;
3048
3049	inode_init_once(VFS_I(ni));
3050	}
3051
3052	/*
3053	* Slab caches to optimize allocations and deallocations of attribute search
3054	* contexts and index contexts, respectively.
3055	*/
3056	struct kmem_cache *ntfs_attr_ctx_cache;
3057	struct kmem_cache *ntfs_index_ctx_cache;
3058
3059	/* Driver wide mutex. */
3060	DEFINE_MUTEX(ntfs_lock);
3061
3062	static struct dentry ntfs_mount(struct file_system_type fs_type,
3063	int flags, const char dev_name, void data)
3064	{
3065	return mount_bdev(fs_type, flags, dev_name, data, ntfs_fill_super);
3066	}
3067
3068	static struct file_system_type ntfs_fs_type = {
3069	.owner = THIS_MODULE,
3070	.name = "ntfs",
3071	.mount = ntfs_mount,
3072	.kill_sb = kill_block_super,
3073	.fs_flags = FS_REQUIRES_DEV,
3074	};
3075
3076	/* Stable names for the slab caches. */
3077	static const char ntfs_index_ctx_cache_name[] = "ntfs_index_ctx_cache";
3078	static const char ntfs_attr_ctx_cache_name[] = "ntfs_attr_ctx_cache";
3079	static const char ntfs_name_cache_name[] = "ntfs_name_cache";
3080	static const char ntfs_inode_cache_name[] = "ntfs_inode_cache";
3081	static const char ntfs_big_inode_cache_name[] = "ntfs_big_inode_cache";
3082
3083	static int __init init_ntfs_fs(void)
3084	{
3085	int err = 0;
3086
3087	/* This may be ugly but it results in pretty output so who cares. (-8 */
3088	printk(KERN_INFO "NTFS driver " NTFS_VERSION " [Flags: R/"
3089	#ifdef NTFS_RW
3090	"W"
3091	#else
3092	"O"
3093	#endif
3094	#ifdef DEBUG
3095	" DEBUG"
3096	#endif
3097	#ifdef MODULE
3098	" MODULE"
3099	#endif
3100	"].\n");
3101
3102	ntfs_debug("Debug messages are enabled.");
3103
3104	ntfs_index_ctx_cache = kmem_cache_create(ntfs_index_ctx_cache_name,
3105	sizeof(ntfs_index_context), 0 /* offset */,
3106	SLAB_HWCACHE_ALIGN, NULL /* ctor */);
3107	if (!ntfs_index_ctx_cache) {
3108	printk(KERN_CRIT "NTFS: Failed to create %s!\n",
3109	ntfs_index_ctx_cache_name);
3110	goto ictx_err_out;
3111	}
3112	ntfs_attr_ctx_cache = kmem_cache_create(ntfs_attr_ctx_cache_name,
3113	sizeof(ntfs_attr_search_ctx), 0 /* offset */,
3114	SLAB_HWCACHE_ALIGN, NULL /* ctor */);
3115	if (!ntfs_attr_ctx_cache) {
3116	printk(KERN_CRIT "NTFS: Failed to create %s!\n",
3117	ntfs_attr_ctx_cache_name);
3118	goto actx_err_out;
3119	}
3120
3121	ntfs_name_cache = kmem_cache_create(ntfs_name_cache_name,
3122	(NTFS_MAX_NAME_LEN+1) * sizeof(ntfschar), 0,
3123	SLAB_HWCACHE_ALIGN, NULL);
3124	if (!ntfs_name_cache) {
3125	printk(KERN_CRIT "NTFS: Failed to create %s!\n",
3126	ntfs_name_cache_name);
3127	goto name_err_out;
3128	}
3129
3130	ntfs_inode_cache = kmem_cache_create(ntfs_inode_cache_name,
3131	sizeof(ntfs_inode), 0,
3132	SLAB_RECLAIM_ACCOUNT\|SLAB_MEM_SPREAD, NULL);
3133	if (!ntfs_inode_cache) {
3134	printk(KERN_CRIT "NTFS: Failed to create %s!\n",
3135	ntfs_inode_cache_name);
3136	goto inode_err_out;
3137	}
3138
3139	ntfs_big_inode_cache = kmem_cache_create(ntfs_big_inode_cache_name,
3140	sizeof(big_ntfs_inode), 0,
3141	SLAB_HWCACHE_ALIGN\|SLAB_RECLAIM_ACCOUNT\|SLAB_MEM_SPREAD,
3142	ntfs_big_inode_init_once);
3143	if (!ntfs_big_inode_cache) {
3144	printk(KERN_CRIT "NTFS: Failed to create %s!\n",
3145	ntfs_big_inode_cache_name);
3146	goto big_inode_err_out;
3147	}
3148
3149	/* Register the ntfs sysctls. */
3150	err = ntfs_sysctl(1);
3151	if (err) {
3152	printk(KERN_CRIT "NTFS: Failed to register NTFS sysctls!\n");
3153	goto sysctl_err_out;
3154	}
3155
3156	err = register_filesystem(&ntfs_fs_type);
3157	if (!err) {
3158	ntfs_debug("NTFS driver registered successfully.");
3159	return 0; /* Success! */
3160	}
3161	printk(KERN_CRIT "NTFS: Failed to register NTFS filesystem driver!\n");
3162
3163	sysctl_err_out:
3164	kmem_cache_destroy(ntfs_big_inode_cache);
3165	big_inode_err_out:
3166	kmem_cache_destroy(ntfs_inode_cache);
3167	inode_err_out:
3168	kmem_cache_destroy(ntfs_name_cache);
3169	name_err_out:
3170	kmem_cache_destroy(ntfs_attr_ctx_cache);
3171	actx_err_out:
3172	kmem_cache_destroy(ntfs_index_ctx_cache);
3173	ictx_err_out:
3174	if (!err) {
3175	printk(KERN_CRIT "NTFS: Aborting NTFS filesystem driver "
3176	"registration...\n");
3177	err = -ENOMEM;
3178	}
3179	return err;
3180	}
3181
3182	static void __exit exit_ntfs_fs(void)
3183	{
3184	ntfs_debug("Unregistering NTFS driver.");
3185
3186	unregister_filesystem(&ntfs_fs_type);
3187	kmem_cache_destroy(ntfs_big_inode_cache);
3188	kmem_cache_destroy(ntfs_inode_cache);
3189	kmem_cache_destroy(ntfs_name_cache);
3190	kmem_cache_destroy(ntfs_attr_ctx_cache);
3191	kmem_cache_destroy(ntfs_index_ctx_cache);
3192	/* Unregister the ntfs sysctls. */
3193	ntfs_sysctl(0);
3194	}
3195
3196	MODULE_AUTHOR("Anton Altaparmakov <anton@tuxera.com>");
3197	MODULE_DESCRIPTION("NTFS 1.2/3.x driver - Copyright (c) 2001-2011 Anton Altaparmakov and Tuxera Inc.");
3198	MODULE_VERSION(NTFS_VERSION);
3199	MODULE_LICENSE("GPL");
3200	#ifdef DEBUG
3201	module_param(debug_msgs, bool, 0);
3202	MODULE_PARM_DESC(debug_msgs, "Enable debug messages.");
3203	#endif
3204
3205	module_init(init_ntfs_fs)
3206	module_exit(exit_ntfs_fs)
3207

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/fs/ntfs/super.c

interactive