xref: /openbmc/linux/fs/ntfs3/super.c (revision 706cc802)
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  */
ntfs_printk(const struct super_block * sb,const char * fmt,...)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(&sbi->msg_ratelimit, "ntfs3"))
86 		return;
87 
88 	va_start(args, fmt);
89 
90 	level = printk_get_level(fmt);
91 	vaf.fmt = printk_skip_level(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  */
ntfs_inode_printk(struct inode * inode,const char * fmt,...)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(&sbi->msg_ratelimit, "ntfs3"))
116 		return;
117 
118 	/* Use static allocated buffer, if possible. */
119 	name = atomic_dec_and_test(&s_name_buf_cnt) ?
120 		       s_name_buf :
121 		       kmalloc(sizeof(s_name_buf), GFP_NOFS);
122 
123 	if (name) {
124 		struct dentry *de = d_find_alias(inode);
125 		const u32 name_len = ARRAY_SIZE(s_name_buf) - 1;
126 
127 		if (de) {
128 			spin_lock(&de->d_lock);
129 			snprintf(name, name_len, " \"%s\"", de->d_name.name);
130 			spin_unlock(&de->d_lock);
131 			name[name_len] = 0; /* To be sure. */
132 		} else {
133 			name[0] = 0;
134 		}
135 		dput(de); /* Cocci warns if placed in branch "if (de)" */
136 	}
137 
138 	va_start(args, fmt);
139 
140 	level = printk_get_level(fmt);
141 	vaf.fmt = printk_skip_level(fmt);
142 	vaf.va = &args;
143 
144 	printk("%c%cntfs3: %s: ino=%lx,%s %pV\n", KERN_SOH_ASCII, level,
145 	       sb->s_id, inode->i_ino, name ? name : "", &vaf);
146 
147 	va_end(args);
148 
149 	atomic_inc(&s_name_buf_cnt);
150 	if (name != s_name_buf)
151 		kfree(name);
152 }
153 #endif
154 
155 /*
156  * Shared memory struct.
157  *
158  * On-disk ntfs's upcase table is created by ntfs formatter.
159  * 'upcase' table is 128K bytes of memory.
160  * We should read it into memory when mounting.
161  * Several ntfs volumes likely use the same 'upcase' table.
162  * It is good idea to share in-memory 'upcase' table between different volumes.
163  * Unfortunately winxp/vista/win7 use different upcase tables.
164  */
165 static DEFINE_SPINLOCK(s_shared_lock);
166 
167 static struct {
168 	void *ptr;
169 	u32 len;
170 	int cnt;
171 } s_shared[8];
172 
173 /*
174  * ntfs_set_shared
175  *
176  * Return:
177  * * @ptr - If pointer was saved in shared memory.
178  * * NULL - If pointer was not shared.
179  */
ntfs_set_shared(void * ptr,u32 bytes)180 void *ntfs_set_shared(void *ptr, u32 bytes)
181 {
182 	void *ret = NULL;
183 	int i, j = -1;
184 
185 	spin_lock(&s_shared_lock);
186 	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
187 		if (!s_shared[i].cnt) {
188 			j = i;
189 		} else if (bytes == s_shared[i].len &&
190 			   !memcmp(s_shared[i].ptr, ptr, bytes)) {
191 			s_shared[i].cnt += 1;
192 			ret = s_shared[i].ptr;
193 			break;
194 		}
195 	}
196 
197 	if (!ret && j != -1) {
198 		s_shared[j].ptr = ptr;
199 		s_shared[j].len = bytes;
200 		s_shared[j].cnt = 1;
201 		ret = ptr;
202 	}
203 	spin_unlock(&s_shared_lock);
204 
205 	return ret;
206 }
207 
208 /*
209  * ntfs_put_shared
210  *
211  * Return:
212  * * @ptr - If pointer is not shared anymore.
213  * * NULL - If pointer is still shared.
214  */
ntfs_put_shared(void * ptr)215 void *ntfs_put_shared(void *ptr)
216 {
217 	void *ret = ptr;
218 	int i;
219 
220 	spin_lock(&s_shared_lock);
221 	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
222 		if (s_shared[i].cnt && s_shared[i].ptr == ptr) {
223 			if (--s_shared[i].cnt)
224 				ret = NULL;
225 			break;
226 		}
227 	}
228 	spin_unlock(&s_shared_lock);
229 
230 	return ret;
231 }
232 
put_mount_options(struct ntfs_mount_options * options)233 static inline void put_mount_options(struct ntfs_mount_options *options)
234 {
235 	kfree(options->nls_name);
236 	unload_nls(options->nls);
237 	kfree(options);
238 }
239 
240 enum Opt {
241 	Opt_uid,
242 	Opt_gid,
243 	Opt_umask,
244 	Opt_dmask,
245 	Opt_fmask,
246 	Opt_immutable,
247 	Opt_discard,
248 	Opt_force,
249 	Opt_sparse,
250 	Opt_nohidden,
251 	Opt_hide_dot_files,
252 	Opt_windows_names,
253 	Opt_showmeta,
254 	Opt_acl,
255 	Opt_iocharset,
256 	Opt_prealloc,
257 	Opt_nocase,
258 	Opt_err,
259 };
260 
261 // clang-format off
262 static const struct fs_parameter_spec ntfs_fs_parameters[] = {
263 	fsparam_u32("uid",			Opt_uid),
264 	fsparam_u32("gid",			Opt_gid),
265 	fsparam_u32oct("umask",			Opt_umask),
266 	fsparam_u32oct("dmask",			Opt_dmask),
267 	fsparam_u32oct("fmask",			Opt_fmask),
268 	fsparam_flag_no("sys_immutable",	Opt_immutable),
269 	fsparam_flag_no("discard",		Opt_discard),
270 	fsparam_flag_no("force",		Opt_force),
271 	fsparam_flag_no("sparse",		Opt_sparse),
272 	fsparam_flag_no("hidden",		Opt_nohidden),
273 	fsparam_flag_no("hide_dot_files",	Opt_hide_dot_files),
274 	fsparam_flag_no("windows_names",	Opt_windows_names),
275 	fsparam_flag_no("showmeta",		Opt_showmeta),
276 	fsparam_flag_no("acl",			Opt_acl),
277 	fsparam_string("iocharset",		Opt_iocharset),
278 	fsparam_flag_no("prealloc",		Opt_prealloc),
279 	fsparam_flag_no("case",		Opt_nocase),
280 	{}
281 };
282 // clang-format on
283 
284 /*
285  * Load nls table or if @nls is utf8 then return NULL.
286  *
287  * It is good idea to use here "const char *nls".
288  * But load_nls accepts "char*".
289  */
ntfs_load_nls(char * nls)290 static struct nls_table *ntfs_load_nls(char *nls)
291 {
292 	struct nls_table *ret;
293 
294 	if (!nls)
295 		nls = CONFIG_NLS_DEFAULT;
296 
297 	if (strcmp(nls, "utf8") == 0)
298 		return NULL;
299 
300 	if (strcmp(nls, CONFIG_NLS_DEFAULT) == 0)
301 		return load_nls_default();
302 
303 	ret = load_nls(nls);
304 	if (ret)
305 		return ret;
306 
307 	return ERR_PTR(-EINVAL);
308 }
309 
ntfs_fs_parse_param(struct fs_context * fc,struct fs_parameter * param)310 static int ntfs_fs_parse_param(struct fs_context *fc,
311 			       struct fs_parameter *param)
312 {
313 	struct ntfs_mount_options *opts = fc->fs_private;
314 	struct fs_parse_result result;
315 	int opt;
316 
317 	opt = fs_parse(fc, ntfs_fs_parameters, param, &result);
318 	if (opt < 0)
319 		return opt;
320 
321 	switch (opt) {
322 	case Opt_uid:
323 		opts->fs_uid = make_kuid(current_user_ns(), result.uint_32);
324 		if (!uid_valid(opts->fs_uid))
325 			return invalf(fc, "ntfs3: Invalid value for uid.");
326 		break;
327 	case Opt_gid:
328 		opts->fs_gid = make_kgid(current_user_ns(), result.uint_32);
329 		if (!gid_valid(opts->fs_gid))
330 			return invalf(fc, "ntfs3: Invalid value for gid.");
331 		break;
332 	case Opt_umask:
333 		if (result.uint_32 & ~07777)
334 			return invalf(fc, "ntfs3: Invalid value for umask.");
335 		opts->fs_fmask_inv = ~result.uint_32;
336 		opts->fs_dmask_inv = ~result.uint_32;
337 		opts->fmask = 1;
338 		opts->dmask = 1;
339 		break;
340 	case Opt_dmask:
341 		if (result.uint_32 & ~07777)
342 			return invalf(fc, "ntfs3: Invalid value for dmask.");
343 		opts->fs_dmask_inv = ~result.uint_32;
344 		opts->dmask = 1;
345 		break;
346 	case Opt_fmask:
347 		if (result.uint_32 & ~07777)
348 			return invalf(fc, "ntfs3: Invalid value for fmask.");
349 		opts->fs_fmask_inv = ~result.uint_32;
350 		opts->fmask = 1;
351 		break;
352 	case Opt_immutable:
353 		opts->sys_immutable = result.negated ? 0 : 1;
354 		break;
355 	case Opt_discard:
356 		opts->discard = result.negated ? 0 : 1;
357 		break;
358 	case Opt_force:
359 		opts->force = result.negated ? 0 : 1;
360 		break;
361 	case Opt_sparse:
362 		opts->sparse = result.negated ? 0 : 1;
363 		break;
364 	case Opt_nohidden:
365 		opts->nohidden = result.negated ? 1 : 0;
366 		break;
367 	case Opt_hide_dot_files:
368 		opts->hide_dot_files = result.negated ? 0 : 1;
369 		break;
370 	case Opt_windows_names:
371 		opts->windows_names = result.negated ? 0 : 1;
372 		break;
373 	case Opt_showmeta:
374 		opts->showmeta = result.negated ? 0 : 1;
375 		break;
376 	case Opt_acl:
377 		if (!result.negated)
378 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
379 			fc->sb_flags |= SB_POSIXACL;
380 #else
381 			return invalf(
382 				fc, "ntfs3: Support for ACL not compiled in!");
383 #endif
384 		else
385 			fc->sb_flags &= ~SB_POSIXACL;
386 		break;
387 	case Opt_iocharset:
388 		kfree(opts->nls_name);
389 		opts->nls_name = param->string;
390 		param->string = NULL;
391 		break;
392 	case Opt_prealloc:
393 		opts->prealloc = result.negated ? 0 : 1;
394 		break;
395 	case Opt_nocase:
396 		opts->nocase = result.negated ? 1 : 0;
397 		break;
398 	default:
399 		/* Should not be here unless we forget add case. */
400 		return -EINVAL;
401 	}
402 	return 0;
403 }
404 
ntfs_fs_reconfigure(struct fs_context * fc)405 static int ntfs_fs_reconfigure(struct fs_context *fc)
406 {
407 	struct super_block *sb = fc->root->d_sb;
408 	struct ntfs_sb_info *sbi = sb->s_fs_info;
409 	struct ntfs_mount_options *new_opts = fc->fs_private;
410 	int ro_rw;
411 
412 	ro_rw = sb_rdonly(sb) && !(fc->sb_flags & SB_RDONLY);
413 	if (ro_rw && (sbi->flags & NTFS_FLAGS_NEED_REPLAY)) {
414 		errorf(fc,
415 		       "ntfs3: Couldn't remount rw because journal is not replayed. Please umount/remount instead\n");
416 		return -EINVAL;
417 	}
418 
419 	new_opts->nls = ntfs_load_nls(new_opts->nls_name);
420 	if (IS_ERR(new_opts->nls)) {
421 		new_opts->nls = NULL;
422 		errorf(fc, "ntfs3: Cannot load iocharset %s",
423 		       new_opts->nls_name);
424 		return -EINVAL;
425 	}
426 	if (new_opts->nls != sbi->options->nls)
427 		return invalf(
428 			fc,
429 			"ntfs3: Cannot use different iocharset when remounting!");
430 
431 	sync_filesystem(sb);
432 
433 	if (ro_rw && (sbi->volume.flags & VOLUME_FLAG_DIRTY) &&
434 	    !new_opts->force) {
435 		errorf(fc,
436 		       "ntfs3: Volume is dirty and \"force\" flag is not set!");
437 		return -EINVAL;
438 	}
439 
440 	swap(sbi->options, fc->fs_private);
441 
442 	return 0;
443 }
444 
445 #ifdef CONFIG_PROC_FS
446 static struct proc_dir_entry *proc_info_root;
447 
448 /*
449  * ntfs3_volinfo:
450  *
451  * The content of /proc/fs/ntfs3/<dev>/volinfo
452  *
453  * ntfs3.1
454  * cluster size
455  * number of clusters
456  * total number of mft records
457  * number of used mft records ~= number of files + folders
458  * real state of ntfs "dirty"/"clean"
459  * current state of ntfs "dirty"/"clean"
460 */
ntfs3_volinfo(struct seq_file * m,void * o)461 static int ntfs3_volinfo(struct seq_file *m, void *o)
462 {
463 	struct super_block *sb = m->private;
464 	struct ntfs_sb_info *sbi = sb->s_fs_info;
465 
466 	seq_printf(m, "ntfs%d.%d\n%u\n%zu\n%zu\n%zu\n%s\n%s\n",
467 		   sbi->volume.major_ver, sbi->volume.minor_ver,
468 		   sbi->cluster_size, sbi->used.bitmap.nbits,
469 		   sbi->mft.bitmap.nbits,
470 		   sbi->mft.bitmap.nbits - wnd_zeroes(&sbi->mft.bitmap),
471 		   sbi->volume.real_dirty ? "dirty" : "clean",
472 		   (sbi->volume.flags & VOLUME_FLAG_DIRTY) ? "dirty" : "clean");
473 
474 	return 0;
475 }
476 
ntfs3_volinfo_open(struct inode * inode,struct file * file)477 static int ntfs3_volinfo_open(struct inode *inode, struct file *file)
478 {
479 	return single_open(file, ntfs3_volinfo, pde_data(inode));
480 }
481 
482 /* read /proc/fs/ntfs3/<dev>/label */
ntfs3_label_show(struct seq_file * m,void * o)483 static int ntfs3_label_show(struct seq_file *m, void *o)
484 {
485 	struct super_block *sb = m->private;
486 	struct ntfs_sb_info *sbi = sb->s_fs_info;
487 
488 	seq_printf(m, "%s\n", sbi->volume.label);
489 
490 	return 0;
491 }
492 
493 /* write /proc/fs/ntfs3/<dev>/label */
ntfs3_label_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)494 static ssize_t ntfs3_label_write(struct file *file, const char __user *buffer,
495 				 size_t count, loff_t *ppos)
496 {
497 	int err;
498 	struct super_block *sb = pde_data(file_inode(file));
499 	ssize_t ret = count;
500 	u8 *label;
501 
502 	if (sb_rdonly(sb))
503 		return -EROFS;
504 
505 	label = kmalloc(count, GFP_NOFS);
506 
507 	if (!label)
508 		return -ENOMEM;
509 
510 	if (copy_from_user(label, buffer, ret)) {
511 		ret = -EFAULT;
512 		goto out;
513 	}
514 	while (ret > 0 && label[ret - 1] == '\n')
515 		ret -= 1;
516 
517 	err = ntfs_set_label(sb->s_fs_info, label, ret);
518 
519 	if (err < 0) {
520 		ntfs_err(sb, "failed (%d) to write label", err);
521 		ret = err;
522 		goto out;
523 	}
524 
525 	*ppos += count;
526 	ret = count;
527 out:
528 	kfree(label);
529 	return ret;
530 }
531 
ntfs3_label_open(struct inode * inode,struct file * file)532 static int ntfs3_label_open(struct inode *inode, struct file *file)
533 {
534 	return single_open(file, ntfs3_label_show, pde_data(inode));
535 }
536 
537 static const struct proc_ops ntfs3_volinfo_fops = {
538 	.proc_read = seq_read,
539 	.proc_lseek = seq_lseek,
540 	.proc_release = single_release,
541 	.proc_open = ntfs3_volinfo_open,
542 };
543 
544 static const struct proc_ops ntfs3_label_fops = {
545 	.proc_read = seq_read,
546 	.proc_lseek = seq_lseek,
547 	.proc_release = single_release,
548 	.proc_open = ntfs3_label_open,
549 	.proc_write = ntfs3_label_write,
550 };
551 
552 #endif
553 
554 static struct kmem_cache *ntfs_inode_cachep;
555 
ntfs_alloc_inode(struct super_block * sb)556 static struct inode *ntfs_alloc_inode(struct super_block *sb)
557 {
558 	struct ntfs_inode *ni = alloc_inode_sb(sb, ntfs_inode_cachep, GFP_NOFS);
559 
560 	if (!ni)
561 		return NULL;
562 
563 	memset(ni, 0, offsetof(struct ntfs_inode, vfs_inode));
564 	mutex_init(&ni->ni_lock);
565 	return &ni->vfs_inode;
566 }
567 
ntfs_free_inode(struct inode * inode)568 static void ntfs_free_inode(struct inode *inode)
569 {
570 	struct ntfs_inode *ni = ntfs_i(inode);
571 
572 	mutex_destroy(&ni->ni_lock);
573 	kmem_cache_free(ntfs_inode_cachep, ni);
574 }
575 
init_once(void * foo)576 static void init_once(void *foo)
577 {
578 	struct ntfs_inode *ni = foo;
579 
580 	inode_init_once(&ni->vfs_inode);
581 }
582 
583 /*
584  * Noinline to reduce binary size.
585  */
ntfs3_put_sbi(struct ntfs_sb_info * sbi)586 static noinline void ntfs3_put_sbi(struct ntfs_sb_info *sbi)
587 {
588 	wnd_close(&sbi->mft.bitmap);
589 	wnd_close(&sbi->used.bitmap);
590 
591 	if (sbi->mft.ni) {
592 		iput(&sbi->mft.ni->vfs_inode);
593 		sbi->mft.ni = NULL;
594 	}
595 
596 	if (sbi->security.ni) {
597 		iput(&sbi->security.ni->vfs_inode);
598 		sbi->security.ni = NULL;
599 	}
600 
601 	if (sbi->reparse.ni) {
602 		iput(&sbi->reparse.ni->vfs_inode);
603 		sbi->reparse.ni = NULL;
604 	}
605 
606 	if (sbi->objid.ni) {
607 		iput(&sbi->objid.ni->vfs_inode);
608 		sbi->objid.ni = NULL;
609 	}
610 
611 	if (sbi->volume.ni) {
612 		iput(&sbi->volume.ni->vfs_inode);
613 		sbi->volume.ni = NULL;
614 	}
615 
616 	ntfs_update_mftmirr(sbi, 0);
617 
618 	indx_clear(&sbi->security.index_sii);
619 	indx_clear(&sbi->security.index_sdh);
620 	indx_clear(&sbi->reparse.index_r);
621 	indx_clear(&sbi->objid.index_o);
622 }
623 
ntfs3_free_sbi(struct ntfs_sb_info * sbi)624 static void ntfs3_free_sbi(struct ntfs_sb_info *sbi)
625 {
626 	kfree(sbi->new_rec);
627 	kvfree(ntfs_put_shared(sbi->upcase));
628 	kvfree(sbi->def_table);
629 	kfree(sbi->compress.lznt);
630 #ifdef CONFIG_NTFS3_LZX_XPRESS
631 	xpress_free_decompressor(sbi->compress.xpress);
632 	lzx_free_decompressor(sbi->compress.lzx);
633 #endif
634 	kfree(sbi);
635 }
636 
ntfs_put_super(struct super_block * sb)637 static void ntfs_put_super(struct super_block *sb)
638 {
639 	struct ntfs_sb_info *sbi = sb->s_fs_info;
640 
641 #ifdef CONFIG_PROC_FS
642 	// Remove /proc/fs/ntfs3/..
643 	if (sbi->procdir) {
644 		remove_proc_entry("label", sbi->procdir);
645 		remove_proc_entry("volinfo", sbi->procdir);
646 		remove_proc_entry(sb->s_id, proc_info_root);
647 		sbi->procdir = NULL;
648 	}
649 #endif
650 
651 	/* Mark rw ntfs as clear, if possible. */
652 	ntfs_set_state(sbi, NTFS_DIRTY_CLEAR);
653 	ntfs3_put_sbi(sbi);
654 }
655 
ntfs_statfs(struct dentry * dentry,struct kstatfs * buf)656 static int ntfs_statfs(struct dentry *dentry, struct kstatfs *buf)
657 {
658 	struct super_block *sb = dentry->d_sb;
659 	struct ntfs_sb_info *sbi = sb->s_fs_info;
660 	struct wnd_bitmap *wnd = &sbi->used.bitmap;
661 
662 	buf->f_type = sb->s_magic;
663 	buf->f_bsize = sbi->cluster_size;
664 	buf->f_blocks = wnd->nbits;
665 
666 	buf->f_bfree = buf->f_bavail = wnd_zeroes(wnd);
667 	buf->f_fsid.val[0] = sbi->volume.ser_num;
668 	buf->f_fsid.val[1] = (sbi->volume.ser_num >> 32);
669 	buf->f_namelen = NTFS_NAME_LEN;
670 
671 	return 0;
672 }
673 
ntfs_show_options(struct seq_file * m,struct dentry * root)674 static int ntfs_show_options(struct seq_file *m, struct dentry *root)
675 {
676 	struct super_block *sb = root->d_sb;
677 	struct ntfs_sb_info *sbi = sb->s_fs_info;
678 	struct ntfs_mount_options *opts = sbi->options;
679 	struct user_namespace *user_ns = seq_user_ns(m);
680 
681 	seq_printf(m, ",uid=%u", from_kuid_munged(user_ns, opts->fs_uid));
682 	seq_printf(m, ",gid=%u", from_kgid_munged(user_ns, opts->fs_gid));
683 	if (opts->dmask)
684 		seq_printf(m, ",dmask=%04o", opts->fs_dmask_inv ^ 0xffff);
685 	if (opts->fmask)
686 		seq_printf(m, ",fmask=%04o", opts->fs_fmask_inv ^ 0xffff);
687 	if (opts->sys_immutable)
688 		seq_puts(m, ",sys_immutable");
689 	if (opts->discard)
690 		seq_puts(m, ",discard");
691 	if (opts->force)
692 		seq_puts(m, ",force");
693 	if (opts->sparse)
694 		seq_puts(m, ",sparse");
695 	if (opts->nohidden)
696 		seq_puts(m, ",nohidden");
697 	if (opts->hide_dot_files)
698 		seq_puts(m, ",hide_dot_files");
699 	if (opts->windows_names)
700 		seq_puts(m, ",windows_names");
701 	if (opts->showmeta)
702 		seq_puts(m, ",showmeta");
703 	if (sb->s_flags & SB_POSIXACL)
704 		seq_puts(m, ",acl");
705 	if (opts->nls)
706 		seq_printf(m, ",iocharset=%s", opts->nls->charset);
707 	else
708 		seq_puts(m, ",iocharset=utf8");
709 	if (opts->prealloc)
710 		seq_puts(m, ",prealloc");
711 	if (opts->nocase)
712 		seq_puts(m, ",nocase");
713 
714 	return 0;
715 }
716 
717 /*
718  * ntfs_shutdown - super_operations::shutdown
719  */
ntfs_shutdown(struct super_block * sb)720 static void ntfs_shutdown(struct super_block *sb)
721 {
722 	set_bit(NTFS_FLAGS_SHUTDOWN_BIT, &ntfs_sb(sb)->flags);
723 }
724 
725 /*
726  * ntfs_sync_fs - super_operations::sync_fs
727  */
ntfs_sync_fs(struct super_block * sb,int wait)728 static int ntfs_sync_fs(struct super_block *sb, int wait)
729 {
730 	int err = 0, err2;
731 	struct ntfs_sb_info *sbi = sb->s_fs_info;
732 	struct ntfs_inode *ni;
733 	struct inode *inode;
734 
735 	if (unlikely(ntfs3_forced_shutdown(sb)))
736 		return -EIO;
737 
738 	ni = sbi->security.ni;
739 	if (ni) {
740 		inode = &ni->vfs_inode;
741 		err2 = _ni_write_inode(inode, wait);
742 		if (err2 && !err)
743 			err = err2;
744 	}
745 
746 	ni = sbi->objid.ni;
747 	if (ni) {
748 		inode = &ni->vfs_inode;
749 		err2 = _ni_write_inode(inode, wait);
750 		if (err2 && !err)
751 			err = err2;
752 	}
753 
754 	ni = sbi->reparse.ni;
755 	if (ni) {
756 		inode = &ni->vfs_inode;
757 		err2 = _ni_write_inode(inode, wait);
758 		if (err2 && !err)
759 			err = err2;
760 	}
761 
762 	if (!err)
763 		ntfs_set_state(sbi, NTFS_DIRTY_CLEAR);
764 
765 	ntfs_update_mftmirr(sbi, wait);
766 
767 	return err;
768 }
769 
770 static const struct super_operations ntfs_sops = {
771 	.alloc_inode = ntfs_alloc_inode,
772 	.free_inode = ntfs_free_inode,
773 	.evict_inode = ntfs_evict_inode,
774 	.put_super = ntfs_put_super,
775 	.statfs = ntfs_statfs,
776 	.show_options = ntfs_show_options,
777 	.shutdown = ntfs_shutdown,
778 	.sync_fs = ntfs_sync_fs,
779 	.write_inode = ntfs3_write_inode,
780 };
781 
ntfs_export_get_inode(struct super_block * sb,u64 ino,u32 generation)782 static struct inode *ntfs_export_get_inode(struct super_block *sb, u64 ino,
783 					   u32 generation)
784 {
785 	struct MFT_REF ref;
786 	struct inode *inode;
787 
788 	ref.low = cpu_to_le32(ino);
789 #ifdef CONFIG_NTFS3_64BIT_CLUSTER
790 	ref.high = cpu_to_le16(ino >> 32);
791 #else
792 	ref.high = 0;
793 #endif
794 	ref.seq = cpu_to_le16(generation);
795 
796 	inode = ntfs_iget5(sb, &ref, NULL);
797 	if (!IS_ERR(inode) && is_bad_inode(inode)) {
798 		iput(inode);
799 		inode = ERR_PTR(-ESTALE);
800 	}
801 
802 	return inode;
803 }
804 
ntfs_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)805 static struct dentry *ntfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
806 					int fh_len, int fh_type)
807 {
808 	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
809 				    ntfs_export_get_inode);
810 }
811 
ntfs_fh_to_parent(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)812 static struct dentry *ntfs_fh_to_parent(struct super_block *sb, struct fid *fid,
813 					int fh_len, int fh_type)
814 {
815 	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
816 				    ntfs_export_get_inode);
817 }
818 
819 /* TODO: == ntfs_sync_inode */
ntfs_nfs_commit_metadata(struct inode * inode)820 static int ntfs_nfs_commit_metadata(struct inode *inode)
821 {
822 	return _ni_write_inode(inode, 1);
823 }
824 
825 static const struct export_operations ntfs_export_ops = {
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  */
format_size_gb(const u64 bytes,u32 * mb)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 
true_sectors_per_clst(const struct NTFS_BOOT * boot)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  */
ntfs_init_from_boot(struct super_block * sb,u32 sector_size,u64 dev_size,struct NTFS_BOOT ** boot2)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, 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(boot->system_id, "NTFS    ", 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(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(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(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(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(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(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(sbi->volume.size + boot_sector_size, &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(dev_size, &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(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(boot, 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(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  */
ntfs_fill_super(struct super_block * sb,struct fs_context * fc)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(options->nls_name);
1181 	if (IS_ERR(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, bdev_logical_block_size(bdev),
1196 				  bdev_nr_bytes(bdev), &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, &NAME_VOLUME);
1207 	if (IS_ERR(inode)) {
1208 		err = PTR_ERR(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, ATTR_LABEL, NULL, 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(resident_data(attr),
1223 				      le32_to_cpu(attr->res.data_size) >> 1,
1224 				      UTF16_LITTLE_ENDIAN, sbi->volume.label,
1225 				      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, ATTR_VOL_INFO, NULL, 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, &NAME_MIRROR);
1255 	if (IS_ERR(inode)) {
1256 		err = PTR_ERR(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, 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, &NAME_LOGFILE);
1270 	if (IS_ERR(inode)) {
1271 		err = PTR_ERR(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, &NAME_MFT);
1301 	if (IS_ERR(inode)) {
1302 		err = PTR_ERR(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(&sbi->mft.bitmap, sb, 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, &NAME_BITMAP);
1329 	if (IS_ERR(inode)) {
1330 		err = PTR_ERR(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 < ntfs3_bitmap_size(tt)) {
1345 		ntfs_err(sb, "$Bitmap is corrupted.");
1346 		err = -EINVAL;
1347 		goto put_inode_out;
1348 	}
1349 
1350 	err = wnd_init(&sbi->used.bitmap, sb, 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, &NAME_BADCLUS);
1369 	if (IS_ERR(inode)) {
1370 		err = PTR_ERR(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(&ni->file.run, i, &vcn, &lcn, &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(&sbi->used.bitmap, lcn, len, &tt) || tt) {
1387 			/* Bad blocks marked as free in bitmap. */
1388 			ntfs_set_state(sbi, 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, &NAME_ATTRDEF);
1407 	if (IS_ERR(inode)) {
1408 		err = PTR_ERR(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(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(inode->i_mapping, idx);
1435 
1436 		if (IS_ERR(page)) {
1437 			err = PTR_ERR(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, &NAME_UPCASE);
1480 	if (IS_ERR(inode)) {
1481 		err = PTR_ERR(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(inode->i_mapping, idx);
1496 
1497 		if (IS_ERR(page)) {
1498 			err = PTR_ERR(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(sbi->upcase, 0x10000 * sizeof(short));
1515 	if (shared && sbi->upcase != shared) {
1516 		kvfree(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, &NAME_ROOT);
1557 	if (IS_ERR(inode)) {
1558 		err = PTR_ERR(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, 0);
1584 		if (bh0) {
1585 			if (buffer_locked(bh0))
1586 				__wait_on_buffer(bh0);
1587 
1588 			lock_buffer(bh0);
1589 			memcpy(bh0->b_data, boot2, sizeof(*boot2));
1590 			set_buffer_uptodate(bh0);
1591 			mark_buffer_dirty(bh0);
1592 			unlock_buffer(bh0);
1593 			if (!sync_dirty_buffer(bh0))
1594 				ntfs_warn(sb, "primary boot is updated");
1595 			put_bh(bh0);
1596 		}
1597 
1598 		kfree(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(boot2);
1623 	ntfs3_put_sbi(sbi);
1624 	return err;
1625 }
1626 
ntfs_unmap_meta(struct super_block * sb,CLST lcn,CLST len)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(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, devblock++, 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  */
ntfs_discard(struct ntfs_sb_info * sbi,CLST lcn,CLST len)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(sb->s_bdev, start >> 9, (end - start) >> 9,
1685 				   GFP_NOFS);
1686 
1687 	if (err == -EOPNOTSUPP)
1688 		sbi->flags |= NTFS_FLAGS_NODISCARD;
1689 
1690 	return err;
1691 }
1692 
ntfs_fs_get_tree(struct fs_context * fc)1693 static int ntfs_fs_get_tree(struct fs_context *fc)
1694 {
1695 	return get_tree_bdev(fc, 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  */
ntfs_fs_free(struct fs_context * fc)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(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  */
ntfs_init_fs_context(struct fs_context * fc)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(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(sizeof(struct ntfs_sb_info), GFP_NOFS);
1752 	if (!sbi)
1753 		goto free_opts;
1754 
1755 	sbi->upcase = kvmalloc(0x10000 * sizeof(short), GFP_KERNEL);
1756 	if (!sbi->upcase)
1757 		goto free_sbi;
1758 
1759 	ratelimit_state_init(&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(sbi);
1776 free_opts:
1777 	kfree(opts);
1778 	return -ENOMEM;
1779 }
1780 
ntfs3_kill_sb(struct super_block * sb)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(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 
init_ntfs_fs(void)1803 static int __init init_ntfs_fs(void)
1804 {
1805 	int err;
1806 
1807 	if (IS_ENABLED(CONFIG_NTFS3_FS_POSIX_ACL))
1808 		pr_info("ntfs3: Enabled Linux POSIX ACLs support\n");
1809 	if (IS_ENABLED(CONFIG_NTFS3_64BIT_CLUSTER))
1810 		pr_notice(
1811 			"ntfs3: Warning: Activated 64 bits per cluster. Windows does not support this\n");
1812 	if (IS_ENABLED(CONFIG_NTFS3_LZX_XPRESS))
1813 		pr_info("ntfs3: Read-only LZX/Xpress compression included\n");
1814 
1815 #ifdef CONFIG_PROC_FS
1816 	/* Create "/proc/fs/ntfs3" */
1817 	proc_info_root = proc_mkdir("fs/ntfs3", NULL);
1818 #endif
1819 
1820 	err = ntfs3_init_bitmap();
1821 	if (err)
1822 		return err;
1823 
1824 	ntfs_inode_cachep = kmem_cache_create(
1825 		"ntfs_inode_cache", sizeof(struct ntfs_inode), 0,
1826 		(SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT),
1827 		init_once);
1828 	if (!ntfs_inode_cachep) {
1829 		err = -ENOMEM;
1830 		goto out1;
1831 	}
1832 
1833 	err = register_filesystem(&ntfs_fs_type);
1834 	if (err)
1835 		goto out;
1836 
1837 	return 0;
1838 out:
1839 	kmem_cache_destroy(ntfs_inode_cachep);
1840 out1:
1841 	ntfs3_exit_bitmap();
1842 	return err;
1843 }
1844 
exit_ntfs_fs(void)1845 static void __exit exit_ntfs_fs(void)
1846 {
1847 	rcu_barrier();
1848 	kmem_cache_destroy(ntfs_inode_cachep);
1849 	unregister_filesystem(&ntfs_fs_type);
1850 	ntfs3_exit_bitmap();
1851 
1852 #ifdef CONFIG_PROC_FS
1853 	if (proc_info_root)
1854 		remove_proc_entry("fs/ntfs3", NULL);
1855 #endif
1856 }
1857 
1858 MODULE_LICENSE("GPL");
1859 MODULE_DESCRIPTION("ntfs3 read/write filesystem");
1860 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
1861 MODULE_INFO(behaviour, "Enabled Linux POSIX ACLs support");
1862 #endif
1863 #ifdef CONFIG_NTFS3_64BIT_CLUSTER
1864 MODULE_INFO(
1865 	cluster,
1866 	"Warning: Activated 64 bits per cluster. Windows does not support this");
1867 #endif
1868 #ifdef CONFIG_NTFS3_LZX_XPRESS
1869 MODULE_INFO(compression, "Read-only lzx/xpress compression included");
1870 #endif
1871 
1872 MODULE_AUTHOR("Konstantin Komarov");
1873 MODULE_ALIAS_FS("ntfs3");
1874 
1875 module_init(init_ntfs_fs);
1876 module_exit(exit_ntfs_fs);
1877