1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	*
4	* Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
5	*
6	*
7	* terminology
8	*
9	* cluster - allocation unit - 512,1K,2K,4K,...,2M
10	* vcn - virtual cluster number - Offset inside the file in clusters.
11	* vbo - virtual byte offset - Offset inside the file in bytes.
12	* lcn - logical cluster number - 0 based cluster in clusters heap.
13	* lbo - logical byte offset - Absolute position inside volume.
14	* run - maps VCN to LCN - Stored in attributes in packed form.
15	* attr - attribute segment - std/name/data etc records inside MFT.
16	* mi - MFT inode - One MFT record(usually 1024 bytes or 4K), consists of attributes.
17	* ni - NTFS inode - Extends linux inode. consists of one or more mft inodes.
18	* index - unit inside directory - 2K, 4K, <=page size, does not depend on cluster size.
19	*
20	* WSL - Windows Subsystem for Linux
21	* https://docs.microsoft.com/en-us/windows/wsl/file-permissions
22	* It stores uid/gid/mode/dev in xattr
23	*
24	* ntfs allows up to 2^64 clusters per volume.
25	* It means you should use 64 bits lcn to operate with ntfs.
26	* Implementation of ntfs.sys uses only 32 bits lcn.
27	* Default ntfs3 uses 32 bits lcn too.
28	* ntfs3 built with CONFIG_NTFS3_64BIT_CLUSTER (ntfs3_64) uses 64 bits per lcn.
29	*
30	*
31	* ntfs limits, cluster size is 4K (2^12)
32	* -----------------------------------------------------------------------------
33	* | Volume size | Clusters | ntfs.sys | ntfs3 | ntfs3_64 | mkntfs | chkdsk |
34	* -----------------------------------------------------------------------------
35	* | < 16T, 2^44 | < 2^32 | yes | yes | yes | yes | yes |
36	* | > 16T, 2^44 | > 2^32 | no | no | yes | yes | yes |
37	* ----------------------------------------------------------|------------------
38	*
39	* To mount large volumes as ntfs one should use large cluster size (up to 2M)
40	* The maximum volume size in this case is 2^32 * 2^21 = 2^53 = 8P
41	*
42	* ntfs limits, cluster size is 2M (2^21)
43	* -----------------------------------------------------------------------------
44	* | < 8P, 2^53 | < 2^32 | yes | yes | yes | yes | yes |
45	* | > 8P, 2^53 | > 2^32 | no | no | yes | yes | yes |
46	* ----------------------------------------------------------|------------------
47	*
48	*/
49
50	#include <linux/blkdev.h>
51	#include <linux/buffer_head.h>
52	#include <linux/exportfs.h>
53	#include <linux/fs.h>
54	#include <linux/fs_context.h>
55	#include <linux/fs_parser.h>
56	#include <linux/log2.h>
57	#include <linux/minmax.h>
58	#include <linux/module.h>
59	#include <linux/nls.h>
60	#include <linux/proc_fs.h>
61	#include <linux/seq_file.h>
62	#include <linux/statfs.h>
63
64	#include "debug.h"
65	#include "ntfs.h"
66	#include "ntfs_fs.h"
67	#ifdef CONFIG_NTFS3_LZX_XPRESS
68	#include "lib/lib.h"
69	#endif
70
71	#ifdef CONFIG_PRINTK
72	/*
73	* ntfs_printk - Trace warnings/notices/errors.
74	*
75	* Thanks Joe Perches <joe@perches.com> for implementation
76	*/
77	void ntfs_printk(const struct super_block *sb, const char *fmt, ...)
78	{
79	struct va_format vaf;
80	va_list args;
81	int level;
82	struct ntfs_sb_info *sbi = sb->s_fs_info;
83
84	/* Should we use different ratelimits for warnings/notices/errors? */
85	if (!___ratelimit(rs: &sbi->msg_ratelimit, func: "ntfs3"))
86	return;
87
88	va_start(args, fmt);
89
90	level = printk_get_level(buffer: fmt);
91	vaf.fmt = printk_skip_level(buffer: fmt);
92	vaf.va = &args;
93	printk("%c%cntfs3: %s: %pV\n", KERN_SOH_ASCII, level, sb->s_id, &vaf);
94
95	va_end(args);
96	}
97
98	static char s_name_buf[512];
99	static atomic_t s_name_buf_cnt = ATOMIC_INIT(1); // 1 means 'free s_name_buf'.
100
101	/*
102	* ntfs_inode_printk
103	*
104	* Print warnings/notices/errors about inode using name or inode number.
105	*/
106	void ntfs_inode_printk(struct inode *inode, const char *fmt, ...)
107	{
108	struct super_block *sb = inode->i_sb;
109	struct ntfs_sb_info *sbi = sb->s_fs_info;
110	char *name;
111	va_list args;
112	struct va_format vaf;
113	int level;
114
115	if (!___ratelimit(rs: &sbi->msg_ratelimit, func: "ntfs3"))
116	return;
117
118	/* Use static allocated buffer, if possible. */
119	name = atomic_dec_and_test(v: &s_name_buf_cnt) ?
120	s_name_buf :
121	kmalloc(size: sizeof(s_name_buf), GFP_NOFS);
122
123	if (name) {
124	struct dentry *de = d_find_alias(inode);
125
126	if (de) {
127	spin_lock(lock: &de->d_lock);
128	snprintf(buf: name, size: sizeof(s_name_buf), fmt: " \"%s\"",
129	de->d_name.name);
130	spin_unlock(lock: &de->d_lock);
131	} else {
132	name[0] = 0;
133	}
134	dput(de); /* Cocci warns if placed in branch "if (de)" */
135	}
136
137	va_start(args, fmt);
138
139	level = printk_get_level(buffer: fmt);
140	vaf.fmt = printk_skip_level(buffer: fmt);
141	vaf.va = &args;
142
143	printk("%c%cntfs3: %s: ino=%lx,%s %pV\n", KERN_SOH_ASCII, level,
144	sb->s_id, inode->i_ino, name ? name : "", &vaf);
145
146	va_end(args);
147
148	atomic_inc(v: &s_name_buf_cnt);
149	if (name != s_name_buf)
150	kfree(objp: name);
151	}
152	#endif
153
154	/*
155	* Shared memory struct.
156	*
157	* On-disk ntfs's upcase table is created by ntfs formatter.
158	* 'upcase' table is 128K bytes of memory.
159	* We should read it into memory when mounting.
160	* Several ntfs volumes likely use the same 'upcase' table.
161	* It is good idea to share in-memory 'upcase' table between different volumes.
162	* Unfortunately winxp/vista/win7 use different upcase tables.
163	*/
164	static DEFINE_SPINLOCK(s_shared_lock);
165
166	static struct {
167	void *ptr;
168	u32 len;
169	int cnt;
170	} s_shared[8];
171
172	/*
173	* ntfs_set_shared
174	*
175	* Return:
176	* * @ptr - If pointer was saved in shared memory.
177	* * NULL - If pointer was not shared.
178	*/
179	void *ntfs_set_shared(void *ptr, u32 bytes)
180	{
181	void *ret = NULL;
182	int i, j = -1;
183
184	spin_lock(lock: &s_shared_lock);
185	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
186	if (!s_shared[i].cnt) {
187	j = i;
188	} else if (bytes == s_shared[i].len &&
189	!memcmp(p: s_shared[i].ptr, q: ptr, size: bytes)) {
190	s_shared[i].cnt += 1;
191	ret = s_shared[i].ptr;
192	break;
193	}
194	}
195
196	if (!ret && j != -1) {
197	s_shared[j].ptr = ptr;
198	s_shared[j].len = bytes;
199	s_shared[j].cnt = 1;
200	ret = ptr;
201	}
202	spin_unlock(lock: &s_shared_lock);
203
204	return ret;
205	}
206
207	/*
208	* ntfs_put_shared
209	*
210	* Return:
211	* * @ptr - If pointer is not shared anymore.
212	* * NULL - If pointer is still shared.
213	*/
214	void *ntfs_put_shared(void *ptr)
215	{
216	void *ret = ptr;
217	int i;
218
219	spin_lock(lock: &s_shared_lock);
220	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
221	if (s_shared[i].cnt && s_shared[i].ptr == ptr) {
222	if (--s_shared[i].cnt)
223	ret = NULL;
224	break;
225	}
226	}
227	spin_unlock(lock: &s_shared_lock);
228
229	return ret;
230	}
231
232	static inline void put_mount_options(struct ntfs_mount_options *options)
233	{
234	kfree(objp: options->nls_name);
235	unload_nls(options->nls);
236	kfree(objp: options);
237	}
238
239	enum Opt {
240	Opt_uid,
241	Opt_gid,
242	Opt_umask,
243	Opt_dmask,
244	Opt_fmask,
245	Opt_immutable,
246	Opt_discard,
247	Opt_force,
248	Opt_sparse,
249	Opt_nohidden,
250	Opt_hide_dot_files,
251	Opt_windows_names,
252	Opt_showmeta,
253	Opt_acl,
254	Opt_iocharset,
255	Opt_prealloc,
256	Opt_nocase,
257	Opt_err,
258	};
259
260	// clang-format off
261	static const struct fs_parameter_spec ntfs_fs_parameters[] = {
262	fsparam_u32("uid", Opt_uid),
263	fsparam_u32("gid", Opt_gid),
264	fsparam_u32oct("umask", Opt_umask),
265	fsparam_u32oct("dmask", Opt_dmask),
266	fsparam_u32oct("fmask", Opt_fmask),
267	fsparam_flag_no("sys_immutable", Opt_immutable),
268	fsparam_flag_no("discard", Opt_discard),
269	fsparam_flag_no("force", Opt_force),
270	fsparam_flag_no("sparse", Opt_sparse),
271	fsparam_flag_no("hidden", Opt_nohidden),
272	fsparam_flag_no("hide_dot_files", Opt_hide_dot_files),
273	fsparam_flag_no("windows_names", Opt_windows_names),
274	fsparam_flag_no("showmeta", Opt_showmeta),
275	fsparam_flag_no("acl", Opt_acl),
276	fsparam_string("iocharset", Opt_iocharset),
277	fsparam_flag_no("prealloc", Opt_prealloc),
278	fsparam_flag_no("nocase", Opt_nocase),
279	{}
280	};
281	// clang-format on
282
283	/*
284	* Load nls table or if @nls is utf8 then return NULL.
285	*
286	* It is good idea to use here "const char *nls".
287	* But load_nls accepts "char*".
288	*/
289	static struct nls_table *ntfs_load_nls(char *nls)
290	{
291	struct nls_table *ret;
292
293	if (!nls)
294	nls = CONFIG_NLS_DEFAULT;
295
296	if (strcmp(nls, "utf8") == 0)
297	return NULL;
298
299	if (strcmp(nls, CONFIG_NLS_DEFAULT) == 0)
300	return load_nls_default();
301
302	ret = load_nls(charset: nls);
303	if (ret)
304	return ret;
305
306	return ERR_PTR(error: -EINVAL);
307	}
308
309	static int ntfs_fs_parse_param(struct fs_context *fc,
310	struct fs_parameter *param)
311	{
312	struct ntfs_mount_options *opts = fc->fs_private;
313	struct fs_parse_result result;
314	int opt;
315
316	opt = fs_parse(fc, desc: ntfs_fs_parameters, param, result: &result);
317	if (opt < 0)
318	return opt;
319
320	switch (opt) {
321	case Opt_uid:
322	opts->fs_uid = make_kuid(current_user_ns(), uid: result.uint_32);
323	if (!uid_valid(uid: opts->fs_uid))
324	return invalf(fc, "ntfs3: Invalid value for uid.");
325	break;
326	case Opt_gid:
327	opts->fs_gid = make_kgid(current_user_ns(), gid: result.uint_32);
328	if (!gid_valid(gid: opts->fs_gid))
329	return invalf(fc, "ntfs3: Invalid value for gid.");
330	break;
331	case Opt_umask:
332	if (result.uint_32 & ~07777)
333	return invalf(fc, "ntfs3: Invalid value for umask.");
334	opts->fs_fmask_inv = ~result.uint_32;
335	opts->fs_dmask_inv = ~result.uint_32;
336	opts->fmask = 1;
337	opts->dmask = 1;
338	break;
339	case Opt_dmask:
340	if (result.uint_32 & ~07777)
341	return invalf(fc, "ntfs3: Invalid value for dmask.");
342	opts->fs_dmask_inv = ~result.uint_32;
343	opts->dmask = 1;
344	break;
345	case Opt_fmask:
346	if (result.uint_32 & ~07777)
347	return invalf(fc, "ntfs3: Invalid value for fmask.");
348	opts->fs_fmask_inv = ~result.uint_32;
349	opts->fmask = 1;
350	break;
351	case Opt_immutable:
352	opts->sys_immutable = result.negated ? 0 : 1;
353	break;
354	case Opt_discard:
355	opts->discard = result.negated ? 0 : 1;
356	break;
357	case Opt_force:
358	opts->force = result.negated ? 0 : 1;
359	break;
360	case Opt_sparse:
361	opts->sparse = result.negated ? 0 : 1;
362	break;
363	case Opt_nohidden:
364	opts->nohidden = result.negated ? 1 : 0;
365	break;
366	case Opt_hide_dot_files:
367	opts->hide_dot_files = result.negated ? 0 : 1;
368	break;
369	case Opt_windows_names:
370	opts->windows_names = result.negated ? 0 : 1;
371	break;
372	case Opt_showmeta:
373	opts->showmeta = result.negated ? 0 : 1;
374	break;
375	case Opt_acl:
376	if (!result.negated)
377	#ifdef CONFIG_NTFS3_FS_POSIX_ACL
378	fc->sb_flags |= SB_POSIXACL;
379	#else
380	return invalf(
381	fc, "ntfs3: Support for ACL not compiled in!");
382	#endif
383	else
384	fc->sb_flags &= ~SB_POSIXACL;
385	break;
386	case Opt_iocharset:
387	kfree(objp: opts->nls_name);
388	opts->nls_name = param->string;
389	param->string = NULL;
390	break;
391	case Opt_prealloc:
392	opts->prealloc = result.negated ? 0 : 1;
393	break;
394	case Opt_nocase:
395	opts->nocase = result.negated ? 1 : 0;
396	break;
397	default:
398	/* Should not be here unless we forget add case. */
399	return -EINVAL;
400	}
401	return 0;
402	}
403
404	static int ntfs_fs_reconfigure(struct fs_context *fc)
405	{
406	struct super_block *sb = fc->root->d_sb;
407	struct ntfs_sb_info *sbi = sb->s_fs_info;
408	struct ntfs_mount_options *new_opts = fc->fs_private;
409	int ro_rw;
410
411	ro_rw = sb_rdonly(sb) && !(fc->sb_flags & SB_RDONLY);
412	if (ro_rw && (sbi->flags & NTFS_FLAGS_NEED_REPLAY)) {
413	errorf(fc,
414	"ntfs3: Couldn't remount rw because journal is not replayed. Please umount/remount instead\n");
415	return -EINVAL;
416	}
417
418	new_opts->nls = ntfs_load_nls(nls: new_opts->nls_name);
419	if (IS_ERR(ptr: new_opts->nls)) {
420	new_opts->nls = NULL;
421	errorf(fc, "ntfs3: Cannot load iocharset %s",
422	new_opts->nls_name);
423	return -EINVAL;
424	}
425	if (new_opts->nls != sbi->options->nls)
426	return invalf(
427	fc,
428	"ntfs3: Cannot use different iocharset when remounting!");
429
430	sync_filesystem(sb);
431
432	if (ro_rw && (sbi->volume.flags & VOLUME_FLAG_DIRTY) &&
433	!new_opts->force) {
434	errorf(fc,
435	"ntfs3: Volume is dirty and \"force\" flag is not set!");
436	return -EINVAL;
437	}
438
439	swap(sbi->options, fc->fs_private);
440
441	return 0;
442	}
443
444	#ifdef CONFIG_PROC_FS
445	static struct proc_dir_entry *proc_info_root;
446
447	/*
448	* ntfs3_volinfo:
449	*
450	* The content of /proc/fs/ntfs3/<dev>/volinfo
451	*
452	* ntfs3.1
453	* cluster size
454	* number of clusters
455	* total number of mft records
456	* number of used mft records ~= number of files + folders
457	* real state of ntfs "dirty"/"clean"
458	* current state of ntfs "dirty"/"clean"
459	*/
460	static int ntfs3_volinfo(struct seq_file *m, void *o)
461	{
462	struct super_block *sb = m->private;
463	struct ntfs_sb_info *sbi = sb->s_fs_info;
464
465	seq_printf(m, fmt: "ntfs%d.%d\n%u\n%zu\n\%zu\n%zu\n%s\n%s\n",
466	sbi->volume.major_ver, sbi->volume.minor_ver,
467	sbi->cluster_size, sbi->used.bitmap.nbits,
468	sbi->mft.bitmap.nbits,
469	sbi->mft.bitmap.nbits - wnd_zeroes(wnd: &sbi->mft.bitmap),
470	sbi->volume.real_dirty ? "dirty" : "clean",
471	(sbi->volume.flags & VOLUME_FLAG_DIRTY) ? "dirty" : "clean");
472
473	return 0;
474	}
475
476	static int ntfs3_volinfo_open(struct inode *inode, struct file *file)
477	{
478	return single_open(file, ntfs3_volinfo, pde_data(inode));
479	}
480
481	/* read /proc/fs/ntfs3/<dev>/label */
482	static int ntfs3_label_show(struct seq_file *m, void *o)
483	{
484	struct super_block *sb = m->private;
485	struct ntfs_sb_info *sbi = sb->s_fs_info;
486
487	seq_printf(m, fmt: "%s\n", sbi->volume.label);
488
489	return 0;
490	}
491
492	/* write /proc/fs/ntfs3/<dev>/label */
493	static ssize_t ntfs3_label_write(struct file *file, const char __user *buffer,
494	size_t count, loff_t *ppos)
495	{
496	int err;
497	struct super_block *sb = pde_data(inode: file_inode(f: file));
498	ssize_t ret = count;
499	u8 *label;
500
501	if (sb_rdonly(sb))
502	return -EROFS;
503
504	label = kmalloc(size: count, GFP_NOFS);
505
506	if (!label)
507	return -ENOMEM;
508
509	if (copy_from_user(to: label, from: buffer, n: ret)) {
510	ret = -EFAULT;
511	goto out;
512	}
513	while (ret > 0 && label[ret - 1] == '\n')
514	ret -= 1;
515
516	err = ntfs_set_label(sbi: sb->s_fs_info, label, len: ret);
517
518	if (err < 0) {
519	ntfs_err(sb, "failed (%d) to write label", err);
520	ret = err;
521	goto out;
522	}
523
524	*ppos += count;
525	ret = count;
526	out:
527	kfree(objp: label);
528	return ret;
529	}
530
531	static int ntfs3_label_open(struct inode *inode, struct file *file)
532	{
533	return single_open(file, ntfs3_label_show, pde_data(inode));
534	}
535
536	static const struct proc_ops ntfs3_volinfo_fops = {
537	.proc_read = seq_read,
538	.proc_lseek = seq_lseek,
539	.proc_release = single_release,
540	.proc_open = ntfs3_volinfo_open,
541	};
542
543	static const struct proc_ops ntfs3_label_fops = {
544	.proc_read = seq_read,
545	.proc_lseek = seq_lseek,
546	.proc_release = single_release,
547	.proc_open = ntfs3_label_open,
548	.proc_write = ntfs3_label_write,
549	};
550
551	#endif
552
553	static struct kmem_cache *ntfs_inode_cachep;
554
555	static struct inode *ntfs_alloc_inode(struct super_block *sb)
556	{
557	struct ntfs_inode *ni = alloc_inode_sb(sb, cache: ntfs_inode_cachep, GFP_NOFS);
558
559	if (!ni)
560	return NULL;
561
562	memset(ni, 0, offsetof(struct ntfs_inode, vfs_inode));
563	mutex_init(&ni->ni_lock);
564	return &ni->vfs_inode;
565	}
566
567	static void ntfs_free_inode(struct inode *inode)
568	{
569	struct ntfs_inode *ni = ntfs_i(inode);
570
571	mutex_destroy(lock: &ni->ni_lock);
572	kmem_cache_free(s: ntfs_inode_cachep, objp: ni);
573	}
574
575	static void init_once(void *foo)
576	{
577	struct ntfs_inode *ni = foo;
578
579	inode_init_once(&ni->vfs_inode);
580	}
581
582	/*
583	* Noinline to reduce binary size.
584	*/
585	static noinline void ntfs3_put_sbi(struct ntfs_sb_info *sbi)
586	{
587	wnd_close(wnd: &sbi->mft.bitmap);
588	wnd_close(wnd: &sbi->used.bitmap);
589
590	if (sbi->mft.ni) {
591	iput(&sbi->mft.ni->vfs_inode);
592	sbi->mft.ni = NULL;
593	}
594
595	if (sbi->security.ni) {
596	iput(&sbi->security.ni->vfs_inode);
597	sbi->security.ni = NULL;
598	}
599
600	if (sbi->reparse.ni) {
601	iput(&sbi->reparse.ni->vfs_inode);
602	sbi->reparse.ni = NULL;
603	}
604
605	if (sbi->objid.ni) {
606	iput(&sbi->objid.ni->vfs_inode);
607	sbi->objid.ni = NULL;
608	}
609
610	if (sbi->volume.ni) {
611	iput(&sbi->volume.ni->vfs_inode);
612	sbi->volume.ni = NULL;
613	}
614
615	ntfs_update_mftmirr(sbi, wait: 0);
616
617	indx_clear(idx: &sbi->security.index_sii);
618	indx_clear(idx: &sbi->security.index_sdh);
619	indx_clear(idx: &sbi->reparse.index_r);
620	indx_clear(idx: &sbi->objid.index_o);
621	}
622
623	static void ntfs3_free_sbi(struct ntfs_sb_info *sbi)
624	{
625	kfree(objp: sbi->new_rec);
626	kvfree(addr: ntfs_put_shared(ptr: sbi->upcase));
627	kvfree(addr: sbi->def_table);
628	kfree(objp: sbi->compress.lznt);
629	#ifdef CONFIG_NTFS3_LZX_XPRESS
630	xpress_free_decompressor(d: sbi->compress.xpress);
631	lzx_free_decompressor(d: sbi->compress.lzx);
632	#endif
633	kfree(objp: sbi);
634	}
635
636	static void ntfs_put_super(struct super_block *sb)
637	{
638	struct ntfs_sb_info *sbi = sb->s_fs_info;
639
640	#ifdef CONFIG_PROC_FS
641	// Remove /proc/fs/ntfs3/..
642	if (sbi->procdir) {
643	remove_proc_entry("label", sbi->procdir);
644	remove_proc_entry("volinfo", sbi->procdir);
645	remove_proc_entry(sb->s_id, proc_info_root);
646	sbi->procdir = NULL;
647	}
648	#endif
649
650	/* Mark rw ntfs as clear, if possible. */
651	ntfs_set_state(sbi, dirty: NTFS_DIRTY_CLEAR);
652	ntfs3_put_sbi(sbi);
653	}
654
655	static int ntfs_statfs(struct dentry *dentry, struct kstatfs *buf)
656	{
657	struct super_block *sb = dentry->d_sb;
658	struct ntfs_sb_info *sbi = sb->s_fs_info;
659	struct wnd_bitmap *wnd = &sbi->used.bitmap;
660
661	buf->f_type = sb->s_magic;
662	buf->f_bsize = sbi->cluster_size;
663	buf->f_blocks = wnd->nbits;
664
665	buf->f_bfree = buf->f_bavail = wnd_zeroes(wnd);
666	buf->f_fsid.val[0] = sbi->volume.ser_num;
667	buf->f_fsid.val[1] = (sbi->volume.ser_num >> 32);
668	buf->f_namelen = NTFS_NAME_LEN;
669
670	return 0;
671	}
672
673	static int ntfs_show_options(struct seq_file *m, struct dentry *root)
674	{
675	struct super_block *sb = root->d_sb;
676	struct ntfs_sb_info *sbi = sb->s_fs_info;
677	struct ntfs_mount_options *opts = sbi->options;
678	struct user_namespace *user_ns = seq_user_ns(seq: m);
679
680	seq_printf(m, fmt: ",uid=%u", from_kuid_munged(to: user_ns, uid: opts->fs_uid));
681	seq_printf(m, fmt: ",gid=%u", from_kgid_munged(to: user_ns, gid: opts->fs_gid));
682	if (opts->dmask)
683	seq_printf(m, fmt: ",dmask=%04o", opts->fs_dmask_inv ^ 0xffff);
684	if (opts->fmask)
685	seq_printf(m, fmt: ",fmask=%04o", opts->fs_fmask_inv ^ 0xffff);
686	if (opts->sys_immutable)
687	seq_puts(m, s: ",sys_immutable");
688	if (opts->discard)
689	seq_puts(m, s: ",discard");
690	if (opts->force)
691	seq_puts(m, s: ",force");
692	if (opts->sparse)
693	seq_puts(m, s: ",sparse");
694	if (opts->nohidden)
695	seq_puts(m, s: ",nohidden");
696	if (opts->hide_dot_files)
697	seq_puts(m, s: ",hide_dot_files");
698	if (opts->windows_names)
699	seq_puts(m, s: ",windows_names");
700	if (opts->showmeta)
701	seq_puts(m, s: ",showmeta");
702	if (sb->s_flags & SB_POSIXACL)
703	seq_puts(m, s: ",acl");
704	if (opts->nls)
705	seq_printf(m, fmt: ",iocharset=%s", opts->nls->charset);
706	else
707	seq_puts(m, s: ",iocharset=utf8");
708	if (opts->prealloc)
709	seq_puts(m, s: ",prealloc");
710	if (opts->nocase)
711	seq_puts(m, s: ",nocase");
712
713	return 0;
714	}
715
716	/*
717	* ntfs_shutdown - super_operations::shutdown
718	*/
719	static void ntfs_shutdown(struct super_block *sb)
720	{
721	set_bit(NTFS_FLAGS_SHUTDOWN_BIT, addr: &ntfs_sb(sb)->flags);
722	}
723
724	/*
725	* ntfs_sync_fs - super_operations::sync_fs
726	*/
727	static int ntfs_sync_fs(struct super_block *sb, int wait)
728	{
729	int err = 0, err2;
730	struct ntfs_sb_info *sbi = sb->s_fs_info;
731	struct ntfs_inode *ni;
732	struct inode *inode;
733
734	if (unlikely(ntfs3_forced_shutdown(sb)))
735	return -EIO;
736
737	ni = sbi->security.ni;
738	if (ni) {
739	inode = &ni->vfs_inode;
740	err2 = _ni_write_inode(inode, wait);
741	if (err2 && !err)
742	err = err2;
743	}
744
745	ni = sbi->objid.ni;
746	if (ni) {
747	inode = &ni->vfs_inode;
748	err2 = _ni_write_inode(inode, wait);
749	if (err2 && !err)
750	err = err2;
751	}
752
753	ni = sbi->reparse.ni;
754	if (ni) {
755	inode = &ni->vfs_inode;
756	err2 = _ni_write_inode(inode, wait);
757	if (err2 && !err)
758	err = err2;
759	}
760
761	if (!err)
762	ntfs_set_state(sbi, dirty: NTFS_DIRTY_CLEAR);
763
764	ntfs_update_mftmirr(sbi, wait);
765
766	return err;
767	}
768
769	static const struct super_operations ntfs_sops = {
770	.alloc_inode = ntfs_alloc_inode,
771	.free_inode = ntfs_free_inode,
772	.evict_inode = ntfs_evict_inode,
773	.put_super = ntfs_put_super,
774	.statfs = ntfs_statfs,
775	.show_options = ntfs_show_options,
776	.shutdown = ntfs_shutdown,
777	.sync_fs = ntfs_sync_fs,
778	.write_inode = ntfs3_write_inode,
779	};
780
781	static struct inode *ntfs_export_get_inode(struct super_block *sb, u64 ino,
782	u32 generation)
783	{
784	struct MFT_REF ref;
785	struct inode *inode;
786
787	ref.low = cpu_to_le32(ino);
788	#ifdef CONFIG_NTFS3_64BIT_CLUSTER
789	ref.high = cpu_to_le16(ino >> 32);
790	#else
791	ref.high = 0;
792	#endif
793	ref.seq = cpu_to_le16(generation);
794
795	inode = ntfs_iget5(sb, ref: &ref, NULL);
796	if (!IS_ERR(ptr: inode) && is_bad_inode(inode)) {
797	iput(inode);
798	inode = ERR_PTR(error: -ESTALE);
799	}
800
801	return inode;
802	}
803
804	static struct dentry *ntfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
805	int fh_len, int fh_type)
806	{
807	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
808	get_inode: ntfs_export_get_inode);
809	}
810
811	static struct dentry *ntfs_fh_to_parent(struct super_block *sb, struct fid *fid,
812	int fh_len, int fh_type)
813	{
814	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
815	get_inode: ntfs_export_get_inode);
816	}
817
818	/* TODO: == ntfs_sync_inode */
819	static int ntfs_nfs_commit_metadata(struct inode *inode)
820	{
821	return _ni_write_inode(inode, 1);
822	}
823
824	static const struct export_operations ntfs_export_ops = {
825	.encode_fh = generic_encode_ino32_fh,
826	.fh_to_dentry = ntfs_fh_to_dentry,
827	.fh_to_parent = ntfs_fh_to_parent,
828	.get_parent = ntfs3_get_parent,
829	.commit_metadata = ntfs_nfs_commit_metadata,
830	};
831
832	/*
833	* format_size_gb - Return Gb,Mb to print with "%u.%02u Gb".
834	*/
835	static u32 format_size_gb(const u64 bytes, u32 *mb)
836	{
837	/* Do simple right 30 bit shift of 64 bit value. */
838	u64 kbytes = bytes >> 10;
839	u32 kbytes32 = kbytes;
840
841	*mb = (100 * (kbytes32 & 0xfffff) + 0x7ffff) >> 20;
842	if (*mb >= 100)
843	*mb = 99;
844
845	return (kbytes32 >> 20) | (((u32)(kbytes >> 32)) << 12);
846	}
847
848	static u32 true_sectors_per_clst(const struct NTFS_BOOT *boot)
849	{
850	if (boot->sectors_per_clusters <= 0x80)
851	return boot->sectors_per_clusters;
852	if (boot->sectors_per_clusters >= 0xf4) /* limit shift to 2MB max */
853	return 1U << (-(s8)boot->sectors_per_clusters);
854	return -EINVAL;
855	}
856
857	/*
858	* ntfs_init_from_boot - Init internal info from on-disk boot sector.
859	*
860	* NTFS mount begins from boot - special formatted 512 bytes.
861	* There are two boots: the first and the last 512 bytes of volume.
862	* The content of boot is not changed during ntfs life.
863	*
864	* NOTE: ntfs.sys checks only first (primary) boot.
865	* chkdsk checks both boots.
866	*/
867	static int ntfs_init_from_boot(struct super_block *sb, u32 sector_size,
868	u64 dev_size, struct NTFS_BOOT **boot2)
869	{
870	struct ntfs_sb_info *sbi = sb->s_fs_info;
871	int err;
872	u32 mb, gb, boot_sector_size, sct_per_clst, record_size;
873	u64 sectors, clusters, mlcn, mlcn2, dev_size0;
874	struct NTFS_BOOT *boot;
875	struct buffer_head *bh;
876	struct MFT_REC *rec;
877	u16 fn, ao;
878	u8 cluster_bits;
879	u32 boot_off = 0;
880	sector_t boot_block = 0;
881	const char *hint = "Primary boot";
882
883	/* Save original dev_size. Used with alternative boot. */
884	dev_size0 = dev_size;
885
886	sbi->volume.blocks = dev_size >> PAGE_SHIFT;
887
888	read_boot:
889	bh = ntfs_bread(sb, block: boot_block);
890	if (!bh)
891	return boot_block ? -EINVAL : -EIO;
892
893	err = -EINVAL;
894
895	/* Corrupted image; do not read OOB */
896	if (bh->b_size - sizeof(*boot) < boot_off)
897	goto out;
898
899	boot = (struct NTFS_BOOT *)Add2Ptr(bh->b_data, boot_off);
900
901	if (memcmp(p: boot->system_id, q: "NTFS ", size: sizeof("NTFS ") - 1)) {
902	ntfs_err(sb, "%s signature is not NTFS.", hint);
903	goto out;
904	}
905
906	/* 0x55AA is not mandaroty. Thanks Maxim Suhanov*/
907	/*if (0x55 != boot->boot_magic[0] || 0xAA != boot->boot_magic[1])
908	* goto out;
909	*/
910
911	boot_sector_size = ((u32)boot->bytes_per_sector[1] << 8) |
912	boot->bytes_per_sector[0];
913	if (boot_sector_size < SECTOR_SIZE ||
914	!is_power_of_2(n: boot_sector_size)) {
915	ntfs_err(sb, "%s: invalid bytes per sector %u.", hint,
916	boot_sector_size);
917	goto out;
918	}
919
920	/* cluster size: 512, 1K, 2K, 4K, ... 2M */
921	sct_per_clst = true_sectors_per_clst(boot);
922	if ((int)sct_per_clst < 0 || !is_power_of_2(n: sct_per_clst)) {
923	ntfs_err(sb, "%s: invalid sectors per cluster %u.", hint,
924	sct_per_clst);
925	goto out;
926	}
927
928	sbi->cluster_size = boot_sector_size * sct_per_clst;
929	sbi->cluster_bits = cluster_bits = blksize_bits(size: sbi->cluster_size);
930	sbi->cluster_mask = sbi->cluster_size - 1;
931	sbi->cluster_mask_inv = ~(u64)sbi->cluster_mask;
932
933	mlcn = le64_to_cpu(boot->mft_clst);
934	mlcn2 = le64_to_cpu(boot->mft2_clst);
935	sectors = le64_to_cpu(boot->sectors_per_volume);
936
937	if (mlcn * sct_per_clst >= sectors || mlcn2 * sct_per_clst >= sectors) {
938	ntfs_err(
939	sb,
940	"%s: start of MFT 0x%llx (0x%llx) is out of volume 0x%llx.",
941	hint, mlcn, mlcn2, sectors);
942	goto out;
943	}
944
945	if (boot->record_size >= 0) {
946	record_size = (u32)boot->record_size << cluster_bits;
947	} else if (-boot->record_size <= MAXIMUM_SHIFT_BYTES_PER_MFT) {
948	record_size = 1u << (-boot->record_size);
949	} else {
950	ntfs_err(sb, "%s: invalid record size %d.", hint,
951	boot->record_size);
952	goto out;
953	}
954
955	sbi->record_size = record_size;
956	sbi->record_bits = blksize_bits(size: record_size);
957	sbi->attr_size_tr = (5 * record_size >> 4); // ~320 bytes
958
959	/* Check MFT record size. */
960	if (record_size < SECTOR_SIZE || !is_power_of_2(n: record_size)) {
961	ntfs_err(sb, "%s: invalid bytes per MFT record %u (%d).", hint,
962	record_size, boot->record_size);
963	goto out;
964	}
965
966	if (record_size > MAXIMUM_BYTES_PER_MFT) {
967	ntfs_err(sb, "Unsupported bytes per MFT record %u.",
968	record_size);
969	goto out;
970	}
971
972	if (boot->index_size >= 0) {
973	sbi->index_size = (u32)boot->index_size << cluster_bits;
974	} else if (-boot->index_size <= MAXIMUM_SHIFT_BYTES_PER_INDEX) {
975	sbi->index_size = 1u << (-boot->index_size);
976	} else {
977	ntfs_err(sb, "%s: invalid index size %d.", hint,
978	boot->index_size);
979	goto out;
980	}
981
982	/* Check index record size. */
983	if (sbi->index_size < SECTOR_SIZE || !is_power_of_2(n: sbi->index_size)) {
984	ntfs_err(sb, "%s: invalid bytes per index %u(%d).", hint,
985	sbi->index_size, boot->index_size);
986	goto out;
987	}
988
989	if (sbi->index_size > MAXIMUM_BYTES_PER_INDEX) {
990	ntfs_err(sb, "%s: unsupported bytes per index %u.", hint,
991	sbi->index_size);
992	goto out;
993	}
994
995	sbi->volume.size = sectors * boot_sector_size;
996
997	gb = format_size_gb(bytes: sbi->volume.size + boot_sector_size, mb: &mb);
998
999	/*
1000	* - Volume formatted and mounted with the same sector size.
1001	* - Volume formatted 4K and mounted as 512.
1002	* - Volume formatted 512 and mounted as 4K.
1003	*/
1004	if (boot_sector_size != sector_size) {
1005	ntfs_warn(
1006	sb,
1007	"Different NTFS sector size (%u) and media sector size (%u).",
1008	boot_sector_size, sector_size);
1009	dev_size += sector_size - 1;
1010	}
1011
1012	sbi->mft.lbo = mlcn << cluster_bits;
1013	sbi->mft.lbo2 = mlcn2 << cluster_bits;
1014
1015	/* Compare boot's cluster and sector. */
1016	if (sbi->cluster_size < boot_sector_size) {
1017	ntfs_err(sb, "%s: invalid bytes per cluster (%u).", hint,
1018	sbi->cluster_size);
1019	goto out;
1020	}
1021
1022	/* Compare boot's cluster and media sector. */
1023	if (sbi->cluster_size < sector_size) {
1024	/* No way to use ntfs_get_block in this case. */
1025	ntfs_err(
1026	sb,
1027	"Failed to mount 'cause NTFS's cluster size (%u) is less than media sector size (%u).",
1028	sbi->cluster_size, sector_size);
1029	goto out;
1030	}
1031
1032	sbi->max_bytes_per_attr =
1033	record_size - ALIGN(MFTRECORD_FIXUP_OFFSET, 8) -
1034	ALIGN(((record_size >> SECTOR_SHIFT) * sizeof(short)), 8) -
1035	ALIGN(sizeof(enum ATTR_TYPE), 8);
1036
1037	sbi->volume.ser_num = le64_to_cpu(boot->serial_num);
1038
1039	/* Warning if RAW volume. */
1040	if (dev_size < sbi->volume.size + boot_sector_size) {
1041	u32 mb0, gb0;
1042
1043	gb0 = format_size_gb(bytes: dev_size, mb: &mb0);
1044	ntfs_warn(
1045	sb,
1046	"RAW NTFS volume: Filesystem size %u.%02u Gb > volume size %u.%02u Gb. Mount in read-only.",
1047	gb, mb, gb0, mb0);
1048	sb->s_flags |= SB_RDONLY;
1049	}
1050
1051	clusters = sbi->volume.size >> cluster_bits;
1052	#ifndef CONFIG_NTFS3_64BIT_CLUSTER
1053	/* 32 bits per cluster. */
1054	if (clusters >> 32) {
1055	ntfs_notice(
1056	sb,
1057	"NTFS %u.%02u Gb is too big to use 32 bits per cluster.",
1058	gb, mb);
1059	goto out;
1060	}
1061	#elif BITS_PER_LONG < 64
1062	#error "CONFIG_NTFS3_64BIT_CLUSTER incompatible in 32 bit OS"
1063	#endif
1064
1065	sbi->used.bitmap.nbits = clusters;
1066
1067	rec = kzalloc(size: record_size, GFP_NOFS);
1068	if (!rec) {
1069	err = -ENOMEM;
1070	goto out;
1071	}
1072
1073	sbi->new_rec = rec;
1074	rec->rhdr.sign = NTFS_FILE_SIGNATURE;
1075	rec->rhdr.fix_off = cpu_to_le16(MFTRECORD_FIXUP_OFFSET);
1076	fn = (sbi->record_size >> SECTOR_SHIFT) + 1;
1077	rec->rhdr.fix_num = cpu_to_le16(fn);
1078	ao = ALIGN(MFTRECORD_FIXUP_OFFSET + sizeof(short) * fn, 8);
1079	rec->attr_off = cpu_to_le16(ao);
1080	rec->used = cpu_to_le32(ao + ALIGN(sizeof(enum ATTR_TYPE), 8));
1081	rec->total = cpu_to_le32(sbi->record_size);
1082	((struct ATTRIB *)Add2Ptr(rec, ao))->type = ATTR_END;
1083
1084	sb_set_blocksize(sb, min_t(u32, sbi->cluster_size, PAGE_SIZE));
1085
1086	sbi->block_mask = sb->s_blocksize - 1;
1087	sbi->blocks_per_cluster = sbi->cluster_size >> sb->s_blocksize_bits;
1088	sbi->volume.blocks = sbi->volume.size >> sb->s_blocksize_bits;
1089
1090	/* Maximum size for normal files. */
1091	sbi->maxbytes = (clusters << cluster_bits) - 1;
1092
1093	#ifdef CONFIG_NTFS3_64BIT_CLUSTER
1094	if (clusters >= (1ull << (64 - cluster_bits)))
1095	sbi->maxbytes = -1;
1096	sbi->maxbytes_sparse = -1;
1097	sb->s_maxbytes = MAX_LFS_FILESIZE;
1098	#else
1099	/* Maximum size for sparse file. */
1100	sbi->maxbytes_sparse = (1ull << (cluster_bits + 32)) - 1;
1101	sb->s_maxbytes = 0xFFFFFFFFull << cluster_bits;
1102	#endif
1103
1104	/*
1105	* Compute the MFT zone at two steps.
1106	* It would be nice if we are able to allocate 1/8 of
1107	* total clusters for MFT but not more then 512 MB.
1108	*/
1109	sbi->zone_max = min_t(CLST, 0x20000000 >> cluster_bits, clusters >> 3);
1110
1111	err = 0;
1112
1113	if (bh->b_blocknr && !sb_rdonly(sb)) {
1114	/*
1115	* Alternative boot is ok but primary is not ok.
1116	* Do not update primary boot here 'cause it may be faked boot.
1117	* Let ntfs to be mounted and update boot later.
1118	*/
1119	*boot2 = kmemdup(p: boot, size: sizeof(*boot), GFP_NOFS | __GFP_NOWARN);
1120	}
1121
1122	out:
1123	brelse(bh);
1124
1125	if (err == -EINVAL && !boot_block && dev_size0 > PAGE_SHIFT) {
1126	u32 block_size = min_t(u32, sector_size, PAGE_SIZE);
1127	u64 lbo = dev_size0 - sizeof(*boot);
1128
1129	boot_block = lbo >> blksize_bits(size: block_size);
1130	boot_off = lbo & (block_size - 1);
1131	if (boot_block && block_size >= boot_off + sizeof(*boot)) {
1132	/*
1133	* Try alternative boot (last sector)
1134	*/
1135	sb_set_blocksize(sb, block_size);
1136	hint = "Alternative boot";
1137	dev_size = dev_size0; /* restore original size. */
1138	goto read_boot;
1139	}
1140	}
1141
1142	return err;
1143	}
1144
1145	/*
1146	* ntfs_fill_super - Try to mount.
1147	*/
1148	static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
1149	{
1150	int err;
1151	struct ntfs_sb_info *sbi = sb->s_fs_info;
1152	struct block_device *bdev = sb->s_bdev;
1153	struct ntfs_mount_options *options;
1154	struct inode *inode;
1155	struct ntfs_inode *ni;
1156	size_t i, tt, bad_len, bad_frags;
1157	CLST vcn, lcn, len;
1158	struct ATTRIB *attr;
1159	const struct VOLUME_INFO *info;
1160	u32 idx, done, bytes;
1161	struct ATTR_DEF_ENTRY *t;
1162	u16 *shared;
1163	struct MFT_REF ref;
1164	bool ro = sb_rdonly(sb);
1165	struct NTFS_BOOT *boot2 = NULL;
1166
1167	ref.high = 0;
1168
1169	sbi->sb = sb;
1170	sbi->options = options = fc->fs_private;
1171	fc->fs_private = NULL;
1172	sb->s_flags |= SB_NODIRATIME;
1173	sb->s_magic = 0x7366746e; // "ntfs"
1174	sb->s_op = &ntfs_sops;
1175	sb->s_export_op = &ntfs_export_ops;
1176	sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
1177	sb->s_xattr = ntfs_xattr_handlers;
1178	sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
1179
1180	options->nls = ntfs_load_nls(nls: options->nls_name);
1181	if (IS_ERR(ptr: options->nls)) {
1182	options->nls = NULL;
1183	errorf(fc, "Cannot load nls %s", options->nls_name);
1184	err = -EINVAL;
1185	goto out;
1186	}
1187
1188	if (bdev_max_discard_sectors(bdev) && bdev_discard_granularity(bdev)) {
1189	sbi->discard_granularity = bdev_discard_granularity(bdev);
1190	sbi->discard_granularity_mask_inv =
1191	~(u64)(sbi->discard_granularity - 1);
1192	}
1193
1194	/* Parse boot. */
1195	err = ntfs_init_from_boot(sb, sector_size: bdev_logical_block_size(bdev),
1196	dev_size: bdev_nr_bytes(bdev), boot2: &boot2);
1197	if (err)
1198	goto out;
1199
1200	/*
1201	* Load $Volume. This should be done before $LogFile
1202	* 'cause 'sbi->volume.ni' is used 'ntfs_set_state'.
1203	*/
1204	ref.low = cpu_to_le32(MFT_REC_VOL);
1205	ref.seq = cpu_to_le16(MFT_REC_VOL);
1206	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_VOLUME);
1207	if (IS_ERR(ptr: inode)) {
1208	err = PTR_ERR(ptr: inode);
1209	ntfs_err(sb, "Failed to load $Volume (%d).", err);
1210	goto out;
1211	}
1212
1213	ni = ntfs_i(inode);
1214
1215	/* Load and save label (not necessary). */
1216	attr = ni_find_attr(ni, NULL, NULL, type: ATTR_LABEL, NULL, name_len: 0, NULL, NULL);
1217
1218	if (!attr) {
1219	/* It is ok if no ATTR_LABEL */
1220	} else if (!attr->non_res && !is_attr_ext(attr)) {
1221	/* $AttrDef allows labels to be up to 128 symbols. */
1222	err = utf16s_to_utf8s(pwcs: resident_data(attr),
1223	le32_to_cpu(attr->res.data_size) >> 1,
1224	endian: UTF16_LITTLE_ENDIAN, s: sbi->volume.label,
1225	maxlen: sizeof(sbi->volume.label));
1226	if (err < 0)
1227	sbi->volume.label[0] = 0;
1228	} else {
1229	/* Should we break mounting here? */
1230	//err = -EINVAL;
1231	//goto put_inode_out;
1232	}
1233
1234	attr = ni_find_attr(ni, attr, NULL, type: ATTR_VOL_INFO, NULL, name_len: 0, NULL, NULL);
1235	if (!attr || is_attr_ext(attr) ||
1236	!(info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO))) {
1237	ntfs_err(sb, "$Volume is corrupted.");
1238	err = -EINVAL;
1239	goto put_inode_out;
1240	}
1241
1242	sbi->volume.major_ver = info->major_ver;
1243	sbi->volume.minor_ver = info->minor_ver;
1244	sbi->volume.flags = info->flags;
1245	sbi->volume.ni = ni;
1246	if (info->flags & VOLUME_FLAG_DIRTY) {
1247	sbi->volume.real_dirty = true;
1248	ntfs_info(sb, "It is recommened to use chkdsk.");
1249	}
1250
1251	/* Load $MFTMirr to estimate recs_mirr. */
1252	ref.low = cpu_to_le32(MFT_REC_MIRR);
1253	ref.seq = cpu_to_le16(MFT_REC_MIRR);
1254	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_MIRROR);
1255	if (IS_ERR(ptr: inode)) {
1256	err = PTR_ERR(ptr: inode);
1257	ntfs_err(sb, "Failed to load $MFTMirr (%d).", err);
1258	goto out;
1259	}
1260
1261	sbi->mft.recs_mirr = ntfs_up_cluster(sbi, size: inode->i_size) >>
1262	sbi->record_bits;
1263
1264	iput(inode);
1265
1266	/* Load LogFile to replay. */
1267	ref.low = cpu_to_le32(MFT_REC_LOG);
1268	ref.seq = cpu_to_le16(MFT_REC_LOG);
1269	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_LOGFILE);
1270	if (IS_ERR(ptr: inode)) {
1271	err = PTR_ERR(ptr: inode);
1272	ntfs_err(sb, "Failed to load \x24LogFile (%d).", err);
1273	goto out;
1274	}
1275
1276	ni = ntfs_i(inode);
1277
1278	err = ntfs_loadlog_and_replay(ni, sbi);
1279	if (err)
1280	goto put_inode_out;
1281
1282	iput(inode);
1283
1284	if ((sbi->flags & NTFS_FLAGS_NEED_REPLAY) && !ro) {
1285	ntfs_warn(sb, "failed to replay log file. Can't mount rw!");
1286	err = -EINVAL;
1287	goto out;
1288	}
1289
1290	if ((sbi->volume.flags & VOLUME_FLAG_DIRTY) && !ro && !options->force) {
1291	ntfs_warn(sb, "volume is dirty and \"force\" flag is not set!");
1292	err = -EINVAL;
1293	goto out;
1294	}
1295
1296	/* Load $MFT. */
1297	ref.low = cpu_to_le32(MFT_REC_MFT);
1298	ref.seq = cpu_to_le16(1);
1299
1300	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_MFT);
1301	if (IS_ERR(ptr: inode)) {
1302	err = PTR_ERR(ptr: inode);
1303	ntfs_err(sb, "Failed to load $MFT (%d).", err);
1304	goto out;
1305	}
1306
1307	ni = ntfs_i(inode);
1308
1309	sbi->mft.used = ni->i_valid >> sbi->record_bits;
1310	tt = inode->i_size >> sbi->record_bits;
1311	sbi->mft.next_free = MFT_REC_USER;
1312
1313	err = wnd_init(wnd: &sbi->mft.bitmap, sb, nbits: tt);
1314	if (err)
1315	goto put_inode_out;
1316
1317	err = ni_load_all_mi(ni);
1318	if (err) {
1319	ntfs_err(sb, "Failed to load $MFT's subrecords (%d).", err);
1320	goto put_inode_out;
1321	}
1322
1323	sbi->mft.ni = ni;
1324
1325	/* Load $Bitmap. */
1326	ref.low = cpu_to_le32(MFT_REC_BITMAP);
1327	ref.seq = cpu_to_le16(MFT_REC_BITMAP);
1328	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_BITMAP);
1329	if (IS_ERR(ptr: inode)) {
1330	err = PTR_ERR(ptr: inode);
1331	ntfs_err(sb, "Failed to load $Bitmap (%d).", err);
1332	goto out;
1333	}
1334
1335	#ifndef CONFIG_NTFS3_64BIT_CLUSTER
1336	if (inode->i_size >> 32) {
1337	err = -EINVAL;
1338	goto put_inode_out;
1339	}
1340	#endif
1341
1342	/* Check bitmap boundary. */
1343	tt = sbi->used.bitmap.nbits;
1344	if (inode->i_size < bitmap_size(bits: tt)) {
1345	ntfs_err(sb, "$Bitmap is corrupted.");
1346	err = -EINVAL;
1347	goto put_inode_out;
1348	}
1349
1350	err = wnd_init(wnd: &sbi->used.bitmap, sb, nbits: tt);
1351	if (err) {
1352	ntfs_err(sb, "Failed to initialize $Bitmap (%d).", err);
1353	goto put_inode_out;
1354	}
1355
1356	iput(inode);
1357
1358	/* Compute the MFT zone. */
1359	err = ntfs_refresh_zone(sbi);
1360	if (err) {
1361	ntfs_err(sb, "Failed to initialize MFT zone (%d).", err);
1362	goto out;
1363	}
1364
1365	/* Load $BadClus. */
1366	ref.low = cpu_to_le32(MFT_REC_BADCLUST);
1367	ref.seq = cpu_to_le16(MFT_REC_BADCLUST);
1368	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_BADCLUS);
1369	if (IS_ERR(ptr: inode)) {
1370	err = PTR_ERR(ptr: inode);
1371	ntfs_err(sb, "Failed to load $BadClus (%d).", err);
1372	goto out;
1373	}
1374
1375	ni = ntfs_i(inode);
1376	bad_len = bad_frags = 0;
1377	for (i = 0; run_get_entry(run: &ni->file.run, index: i, vcn: &vcn, lcn: &lcn, len: &len); i++) {
1378	if (lcn == SPARSE_LCN)
1379	continue;
1380
1381	bad_len += len;
1382	bad_frags += 1;
1383	if (ro)
1384	continue;
1385
1386	if (wnd_set_used_safe(wnd: &sbi->used.bitmap, bit: lcn, bits: len, done: &tt) || tt) {
1387	/* Bad blocks marked as free in bitmap. */
1388	ntfs_set_state(sbi, dirty: NTFS_DIRTY_ERROR);
1389	}
1390	}
1391	if (bad_len) {
1392	/*
1393	* Notice about bad blocks.
1394	* In normal cases these blocks are marked as used in bitmap.
1395	* And we never allocate space in it.
1396	*/
1397	ntfs_notice(sb,
1398	"Volume contains %zu bad blocks in %zu fragments.",
1399	bad_len, bad_frags);
1400	}
1401	iput(inode);
1402
1403	/* Load $AttrDef. */
1404	ref.low = cpu_to_le32(MFT_REC_ATTR);
1405	ref.seq = cpu_to_le16(MFT_REC_ATTR);
1406	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_ATTRDEF);
1407	if (IS_ERR(ptr: inode)) {
1408	err = PTR_ERR(ptr: inode);
1409	ntfs_err(sb, "Failed to load $AttrDef (%d)", err);
1410	goto out;
1411	}
1412
1413	/*
1414	* Typical $AttrDef contains up to 20 entries.
1415	* Check for extremely large/small size.
1416	*/
1417	if (inode->i_size < sizeof(struct ATTR_DEF_ENTRY) ||
1418	inode->i_size > 100 * sizeof(struct ATTR_DEF_ENTRY)) {
1419	ntfs_err(sb, "Looks like $AttrDef is corrupted (size=%llu).",
1420	inode->i_size);
1421	err = -EINVAL;
1422	goto put_inode_out;
1423	}
1424
1425	bytes = inode->i_size;
1426	sbi->def_table = t = kvmalloc(size: bytes, GFP_KERNEL);
1427	if (!t) {
1428	err = -ENOMEM;
1429	goto put_inode_out;
1430	}
1431
1432	for (done = idx = 0; done < bytes; done += PAGE_SIZE, idx++) {
1433	unsigned long tail = bytes - done;
1434	struct page *page = ntfs_map_page(mapping: inode->i_mapping, index: idx);
1435
1436	if (IS_ERR(ptr: page)) {
1437	err = PTR_ERR(ptr: page);
1438	ntfs_err(sb, "Failed to read $AttrDef (%d).", err);
1439	goto put_inode_out;
1440	}
1441	memcpy(Add2Ptr(t, done), page_address(page),
1442	min(PAGE_SIZE, tail));
1443	ntfs_unmap_page(page);
1444
1445	if (!idx && ATTR_STD != t->type) {
1446	ntfs_err(sb, "$AttrDef is corrupted.");
1447	err = -EINVAL;
1448	goto put_inode_out;
1449	}
1450	}
1451
1452	t += 1;
1453	sbi->def_entries = 1;
1454	done = sizeof(struct ATTR_DEF_ENTRY);
1455	sbi->reparse.max_size = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
1456	sbi->ea_max_size = 0x10000; /* default formatter value */
1457
1458	while (done + sizeof(struct ATTR_DEF_ENTRY) <= bytes) {
1459	u32 t32 = le32_to_cpu(t->type);
1460	u64 sz = le64_to_cpu(t->max_sz);
1461
1462	if ((t32 & 0xF) || le32_to_cpu(t[-1].type) >= t32)
1463	break;
1464
1465	if (t->type == ATTR_REPARSE)
1466	sbi->reparse.max_size = sz;
1467	else if (t->type == ATTR_EA)
1468	sbi->ea_max_size = sz;
1469
1470	done += sizeof(struct ATTR_DEF_ENTRY);
1471	t += 1;
1472	sbi->def_entries += 1;
1473	}
1474	iput(inode);
1475
1476	/* Load $UpCase. */
1477	ref.low = cpu_to_le32(MFT_REC_UPCASE);
1478	ref.seq = cpu_to_le16(MFT_REC_UPCASE);
1479	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_UPCASE);
1480	if (IS_ERR(ptr: inode)) {
1481	err = PTR_ERR(ptr: inode);
1482	ntfs_err(sb, "Failed to load $UpCase (%d).", err);
1483	goto out;
1484	}
1485
1486	if (inode->i_size != 0x10000 * sizeof(short)) {
1487	err = -EINVAL;
1488	ntfs_err(sb, "$UpCase is corrupted.");
1489	goto put_inode_out;
1490	}
1491
1492	for (idx = 0; idx < (0x10000 * sizeof(short) >> PAGE_SHIFT); idx++) {
1493	const __le16 *src;
1494	u16 *dst = Add2Ptr(sbi->upcase, idx << PAGE_SHIFT);
1495	struct page *page = ntfs_map_page(mapping: inode->i_mapping, index: idx);
1496
1497	if (IS_ERR(ptr: page)) {
1498	err = PTR_ERR(ptr: page);
1499	ntfs_err(sb, "Failed to read $UpCase (%d).", err);
1500	goto put_inode_out;
1501	}
1502
1503	src = page_address(page);
1504
1505	#ifdef __BIG_ENDIAN
1506	for (i = 0; i < PAGE_SIZE / sizeof(u16); i++)
1507	*dst++ = le16_to_cpu(*src++);
1508	#else
1509	memcpy(dst, src, PAGE_SIZE);
1510	#endif
1511	ntfs_unmap_page(page);
1512	}
1513
1514	shared = ntfs_set_shared(ptr: sbi->upcase, bytes: 0x10000 * sizeof(short));
1515	if (shared && sbi->upcase != shared) {
1516	kvfree(addr: sbi->upcase);
1517	sbi->upcase = shared;
1518	}
1519
1520	iput(inode);
1521
1522	if (is_ntfs3(sbi)) {
1523	/* Load $Secure. */
1524	err = ntfs_security_init(sbi);
1525	if (err) {
1526	ntfs_err(sb, "Failed to initialize $Secure (%d).", err);
1527	goto out;
1528	}
1529
1530	/* Load $Extend. */
1531	err = ntfs_extend_init(sbi);
1532	if (err) {
1533	ntfs_warn(sb, "Failed to initialize $Extend.");
1534	goto load_root;
1535	}
1536
1537	/* Load $Extend/$Reparse. */
1538	err = ntfs_reparse_init(sbi);
1539	if (err) {
1540	ntfs_warn(sb, "Failed to initialize $Extend/$Reparse.");
1541	goto load_root;
1542	}
1543
1544	/* Load $Extend/$ObjId. */
1545	err = ntfs_objid_init(sbi);
1546	if (err) {
1547	ntfs_warn(sb, "Failed to initialize $Extend/$ObjId.");
1548	goto load_root;
1549	}
1550	}
1551
1552	load_root:
1553	/* Load root. */
1554	ref.low = cpu_to_le32(MFT_REC_ROOT);
1555	ref.seq = cpu_to_le16(MFT_REC_ROOT);
1556	inode = ntfs_iget5(sb, ref: &ref, name: &NAME_ROOT);
1557	if (IS_ERR(ptr: inode)) {
1558	err = PTR_ERR(ptr: inode);
1559	ntfs_err(sb, "Failed to load root (%d).", err);
1560	goto out;
1561	}
1562
1563	/*
1564	* Final check. Looks like this case should never occurs.
1565	*/
1566	if (!inode->i_op) {
1567	err = -EINVAL;
1568	ntfs_err(sb, "Failed to load root (%d).", err);
1569	goto put_inode_out;
1570	}
1571
1572	sb->s_root = d_make_root(inode);
1573	if (!sb->s_root) {
1574	err = -ENOMEM;
1575	goto put_inode_out;
1576	}
1577
1578	if (boot2) {
1579	/*
1580	* Alternative boot is ok but primary is not ok.
1581	* Volume is recognized as NTFS. Update primary boot.
1582	*/
1583	struct buffer_head *bh0 = sb_getblk(sb, block: 0);
1584	if (bh0) {
1585	if (buffer_locked(bh: bh0))
1586	__wait_on_buffer(bh0);
1587
1588	lock_buffer(bh: bh0);
1589	memcpy(bh0->b_data, boot2, sizeof(*boot2));
1590	set_buffer_uptodate(bh0);
1591	mark_buffer_dirty(bh: bh0);
1592	unlock_buffer(bh: bh0);
1593	if (!sync_dirty_buffer(bh: bh0))
1594	ntfs_warn(sb, "primary boot is updated");
1595	put_bh(bh: bh0);
1596	}
1597
1598	kfree(objp: boot2);
1599	}
1600
1601	#ifdef CONFIG_PROC_FS
1602	/* Create /proc/fs/ntfs3/.. */
1603	if (proc_info_root) {
1604	struct proc_dir_entry *e = proc_mkdir(sb->s_id, proc_info_root);
1605	static_assert((S_IRUGO | S_IWUSR) == 0644);
1606	if (e) {
1607	proc_create_data("volinfo", S_IRUGO, e,
1608	&ntfs3_volinfo_fops, sb);
1609	proc_create_data("label", S_IRUGO | S_IWUSR, e,
1610	&ntfs3_label_fops, sb);
1611	sbi->procdir = e;
1612	}
1613	}
1614	#endif
1615
1616	return 0;
1617
1618	put_inode_out:
1619	iput(inode);
1620	out:
1621	ntfs3_put_sbi(sbi);
1622	kfree(objp: boot2);
1623	ntfs3_put_sbi(sbi);
1624	return err;
1625	}
1626
1627	void ntfs_unmap_meta(struct super_block *sb, CLST lcn, CLST len)
1628	{
1629	struct ntfs_sb_info *sbi = sb->s_fs_info;
1630	struct block_device *bdev = sb->s_bdev;
1631	sector_t devblock = (u64)lcn * sbi->blocks_per_cluster;
1632	unsigned long blocks = (u64)len * sbi->blocks_per_cluster;
1633	unsigned long cnt = 0;
1634	unsigned long limit = global_zone_page_state(item: NR_FREE_PAGES)
1635	<< (PAGE_SHIFT - sb->s_blocksize_bits);
1636
1637	if (limit >= 0x2000)
1638	limit -= 0x1000;
1639	else if (limit < 32)
1640	limit = 32;
1641	else
1642	limit >>= 1;
1643
1644	while (blocks--) {
1645	clean_bdev_aliases(bdev, block: devblock++, len: 1);
1646	if (cnt++ >= limit) {
1647	sync_blockdev(bdev);
1648	cnt = 0;
1649	}
1650	}
1651	}
1652
1653	/*
1654	* ntfs_discard - Issue a discard request (trim for SSD).
1655	*/
1656	int ntfs_discard(struct ntfs_sb_info *sbi, CLST lcn, CLST len)
1657	{
1658	int err;
1659	u64 lbo, bytes, start, end;
1660	struct super_block *sb;
1661
1662	if (sbi->used.next_free_lcn == lcn + len)
1663	sbi->used.next_free_lcn = lcn;
1664
1665	if (sbi->flags & NTFS_FLAGS_NODISCARD)
1666	return -EOPNOTSUPP;
1667
1668	if (!sbi->options->discard)
1669	return -EOPNOTSUPP;
1670
1671	lbo = (u64)lcn << sbi->cluster_bits;
1672	bytes = (u64)len << sbi->cluster_bits;
1673
1674	/* Align up 'start' on discard_granularity. */
1675	start = (lbo + sbi->discard_granularity - 1) &
1676	sbi->discard_granularity_mask_inv;
1677	/* Align down 'end' on discard_granularity. */
1678	end = (lbo + bytes) & sbi->discard_granularity_mask_inv;
1679
1680	sb = sbi->sb;
1681	if (start >= end)
1682	return 0;
1683
1684	err = blkdev_issue_discard(bdev: sb->s_bdev, sector: start >> 9, nr_sects: (end - start) >> 9,
1685	GFP_NOFS);
1686
1687	if (err == -EOPNOTSUPP)
1688	sbi->flags |= NTFS_FLAGS_NODISCARD;
1689
1690	return err;
1691	}
1692
1693	static int ntfs_fs_get_tree(struct fs_context *fc)
1694	{
1695	return get_tree_bdev(fc, fill_super: ntfs_fill_super);
1696	}
1697
1698	/*
1699	* ntfs_fs_free - Free fs_context.
1700	*
1701	* Note that this will be called after fill_super and reconfigure
1702	* even when they pass. So they have to take pointers if they pass.
1703	*/
1704	static void ntfs_fs_free(struct fs_context *fc)
1705	{
1706	struct ntfs_mount_options *opts = fc->fs_private;
1707	struct ntfs_sb_info *sbi = fc->s_fs_info;
1708
1709	if (sbi) {
1710	ntfs3_put_sbi(sbi);
1711	ntfs3_free_sbi(sbi);
1712	}
1713
1714	if (opts)
1715	put_mount_options(options: opts);
1716	}
1717
1718	// clang-format off
1719	static const struct fs_context_operations ntfs_context_ops = {
1720	.parse_param = ntfs_fs_parse_param,
1721	.get_tree = ntfs_fs_get_tree,
1722	.reconfigure = ntfs_fs_reconfigure,
1723	.free = ntfs_fs_free,
1724	};
1725	// clang-format on
1726
1727	/*
1728	* ntfs_init_fs_context - Initialize sbi and opts
1729	*
1730	* This will called when mount/remount. We will first initialize
1731	* options so that if remount we can use just that.
1732	*/
1733	static int ntfs_init_fs_context(struct fs_context *fc)
1734	{
1735	struct ntfs_mount_options *opts;
1736	struct ntfs_sb_info *sbi;
1737
1738	opts = kzalloc(size: sizeof(struct ntfs_mount_options), GFP_NOFS);
1739	if (!opts)
1740	return -ENOMEM;
1741
1742	/* Default options. */
1743	opts->fs_uid = current_uid();
1744	opts->fs_gid = current_gid();
1745	opts->fs_fmask_inv = ~current_umask();
1746	opts->fs_dmask_inv = ~current_umask();
1747
1748	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE)
1749	goto ok;
1750
1751	sbi = kzalloc(size: sizeof(struct ntfs_sb_info), GFP_NOFS);
1752	if (!sbi)
1753	goto free_opts;
1754
1755	sbi->upcase = kvmalloc(size: 0x10000 * sizeof(short), GFP_KERNEL);
1756	if (!sbi->upcase)
1757	goto free_sbi;
1758
1759	ratelimit_state_init(rs: &sbi->msg_ratelimit, DEFAULT_RATELIMIT_INTERVAL,
1760	DEFAULT_RATELIMIT_BURST);
1761
1762	mutex_init(&sbi->compress.mtx_lznt);
1763	#ifdef CONFIG_NTFS3_LZX_XPRESS
1764	mutex_init(&sbi->compress.mtx_xpress);
1765	mutex_init(&sbi->compress.mtx_lzx);
1766	#endif
1767
1768	fc->s_fs_info = sbi;
1769	ok:
1770	fc->fs_private = opts;
1771	fc->ops = &ntfs_context_ops;
1772
1773	return 0;
1774	free_sbi:
1775	kfree(objp: sbi);
1776	free_opts:
1777	kfree(objp: opts);
1778	return -ENOMEM;
1779	}
1780
1781	static void ntfs3_kill_sb(struct super_block *sb)
1782	{
1783	struct ntfs_sb_info *sbi = sb->s_fs_info;
1784
1785	kill_block_super(sb);
1786
1787	if (sbi->options)
1788	put_mount_options(options: sbi->options);
1789	ntfs3_free_sbi(sbi);
1790	}
1791
1792	// clang-format off
1793	static struct file_system_type ntfs_fs_type = {
1794	.owner = THIS_MODULE,
1795	.name = "ntfs3",
1796	.init_fs_context = ntfs_init_fs_context,
1797	.parameters = ntfs_fs_parameters,
1798	.kill_sb = ntfs3_kill_sb,
1799	.fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
1800	};
1801	// clang-format on
1802
1803	static int __init init_ntfs_fs(void)
1804	{
1805	int err;
1806
1807	pr_info("ntfs3: Max link count %u\n", NTFS_LINK_MAX);
1808
1809	if (IS_ENABLED(CONFIG_NTFS3_FS_POSIX_ACL))
1810	pr_info("ntfs3: Enabled Linux POSIX ACLs support\n");
1811	if (IS_ENABLED(CONFIG_NTFS3_64BIT_CLUSTER))
1812	pr_notice(
1813	"ntfs3: Warning: Activated 64 bits per cluster. Windows does not support this\n");
1814	if (IS_ENABLED(CONFIG_NTFS3_LZX_XPRESS))
1815	pr_info("ntfs3: Read-only LZX/Xpress compression included\n");
1816
1817	#ifdef CONFIG_PROC_FS
1818	/* Create "/proc/fs/ntfs3" */
1819	proc_info_root = proc_mkdir("fs/ntfs3", NULL);
1820	#endif
1821
1822	err = ntfs3_init_bitmap();
1823	if (err)
1824	return err;
1825
1826	ntfs_inode_cachep = kmem_cache_create(
1827	name: "ntfs_inode_cache", size: sizeof(struct ntfs_inode), align: 0,
1828	flags: (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
1829	ctor: init_once);
1830	if (!ntfs_inode_cachep) {
1831	err = -ENOMEM;
1832	goto out1;
1833	}
1834
1835	err = register_filesystem(&ntfs_fs_type);
1836	if (err)
1837	goto out;
1838
1839	return 0;
1840	out:
1841	kmem_cache_destroy(s: ntfs_inode_cachep);
1842	out1:
1843	ntfs3_exit_bitmap();
1844	return err;
1845	}
1846
1847	static void __exit exit_ntfs_fs(void)
1848	{
1849	rcu_barrier();
1850	kmem_cache_destroy(s: ntfs_inode_cachep);
1851	unregister_filesystem(&ntfs_fs_type);
1852	ntfs3_exit_bitmap();
1853
1854	#ifdef CONFIG_PROC_FS
1855	if (proc_info_root)
1856	remove_proc_entry("fs/ntfs3", NULL);
1857	#endif
1858	}
1859
1860	MODULE_LICENSE("GPL");
1861	MODULE_DESCRIPTION("ntfs3 read/write filesystem");
1862	#ifdef CONFIG_NTFS3_FS_POSIX_ACL
1863	MODULE_INFO(behaviour, "Enabled Linux POSIX ACLs support");
1864	#endif
1865	#ifdef CONFIG_NTFS3_64BIT_CLUSTER
1866	MODULE_INFO(
1867	cluster,
1868	"Warning: Activated 64 bits per cluster. Windows does not support this");
1869	#endif
1870	#ifdef CONFIG_NTFS3_LZX_XPRESS
1871	MODULE_INFO(compression, "Read-only lzx/xpress compression included");
1872	#endif
1873
1874	MODULE_AUTHOR("Konstantin Komarov");
1875	MODULE_ALIAS_FS("ntfs3");
1876
1877	module_init(init_ntfs_fs);
1878	module_exit(exit_ntfs_fs);
1879