super.c 46.1 KB
Newer Older
1 2 3 4 5 6 7 8 9
// SPDX-License-Identifier: GPL-2.0
/*
 *
 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
 *
 *
 *                 terminology
 *
 * cluster - allocation unit     - 512,1K,2K,4K,...,2M
10 11 12 13 14 15 16 17 18
 * vcn - virtual cluster number  - Offset inside the file in clusters.
 * vbo - virtual byte offset     - Offset inside the file in bytes.
 * lcn - logical cluster number  - 0 based cluster in clusters heap.
 * lbo - logical byte offset     - Absolute position inside volume.
 * run - maps VCN to LCN         - Stored in attributes in packed form.
 * attr - attribute segment      - std/name/data etc records inside MFT.
 * mi  - MFT inode               - One MFT record(usually 1024 bytes or 4K), consists of attributes.
 * ni  - NTFS inode              - Extends linux inode. consists of one or more mft inodes.
 * index - unit inside directory - 2K, 4K, <=page size, does not depend on cluster size.
19 20 21 22 23
 *
 * WSL - Windows Subsystem for Linux
 * https://docs.microsoft.com/en-us/windows/wsl/file-permissions
 * It stores uid/gid/mode/dev in xattr
 *
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
 * ntfs allows up to 2^64 clusters per volume.
 * It means you should use 64 bits lcn to operate with ntfs.
 * Implementation of ntfs.sys uses only 32 bits lcn.
 * Default ntfs3 uses 32 bits lcn too.
 * ntfs3 built with CONFIG_NTFS3_64BIT_CLUSTER (ntfs3_64) uses 64 bits per lcn.
 *
 *
 *     ntfs limits, cluster size is 4K (2^12)
 * -----------------------------------------------------------------------------
 * | Volume size   | Clusters | ntfs.sys | ntfs3  | ntfs3_64 | mkntfs | chkdsk |
 * -----------------------------------------------------------------------------
 * | < 16T, 2^44   |  < 2^32  |  yes     |  yes   |   yes    |  yes   |  yes   |
 * | > 16T, 2^44   |  > 2^32  |  no      |  no    |   yes    |  yes   |  yes   |
 * ----------------------------------------------------------|------------------
 *
 * To mount large volumes as ntfs one should use large cluster size (up to 2M)
 * The maximum volume size in this case is 2^32 * 2^21 = 2^53 = 8P
 *
42
 *     ntfs limits, cluster size is 2M (2^21)
43
 * -----------------------------------------------------------------------------
44 45
 * | < 8P, 2^53    |  < 2^32  |  yes     |  yes   |   yes    |  yes   |  yes   |
 * | > 8P, 2^53    |  > 2^32  |  no      |  no    |   yes    |  yes   |  yes   |
46 47
 * ----------------------------------------------------------|------------------
 *
48 49 50 51 52 53
 */

#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/exportfs.h>
#include <linux/fs.h>
54 55
#include <linux/fs_context.h>
#include <linux/fs_parser.h>
56
#include <linux/log2.h>
57
#include <linux/minmax.h>
58 59
#include <linux/module.h>
#include <linux/nls.h>
60
#include <linux/proc_fs.h>
61 62 63 64 65 66 67 68 69 70 71 72
#include <linux/seq_file.h>
#include <linux/statfs.h>

#include "debug.h"
#include "ntfs.h"
#include "ntfs_fs.h"
#ifdef CONFIG_NTFS3_LZX_XPRESS
#include "lib/lib.h"
#endif

#ifdef CONFIG_PRINTK
/*
73 74
 * ntfs_printk - Trace warnings/notices/errors.
 *
75 76 77 78 79 80 81 82 83
 * Thanks Joe Perches <joe@perches.com> for implementation
 */
void ntfs_printk(const struct super_block *sb, const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;
	int level;
	struct ntfs_sb_info *sbi = sb->s_fs_info;

84
	/* Should we use different ratelimits for warnings/notices/errors? */
85 86 87 88 89 90 91 92 93 94 95 96 97 98
	if (!___ratelimit(&sbi->msg_ratelimit, "ntfs3"))
		return;

	va_start(args, fmt);

	level = printk_get_level(fmt);
	vaf.fmt = printk_skip_level(fmt);
	vaf.va = &args;
	printk("%c%cntfs3: %s: %pV\n", KERN_SOH_ASCII, level, sb->s_id, &vaf);

	va_end(args);
}

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 103 104 105
/*
 * ntfs_inode_printk
 *
 * Print warnings/notices/errors about inode using name or inode number.
 */
106 107 108 109 110 111 112 113 114 115 116 117
void ntfs_inode_printk(struct inode *inode, const char *fmt, ...)
{
	struct super_block *sb = inode->i_sb;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	char *name;
	va_list args;
	struct va_format vaf;
	int level;

	if (!___ratelimit(&sbi->msg_ratelimit, "ntfs3"))
		return;

118
	/* Use static allocated buffer, if possible. */
119
	name = atomic_dec_and_test(&s_name_buf_cnt) ?
120 121
		       s_name_buf :
		       kmalloc(sizeof(s_name_buf), GFP_NOFS);
122 123 124 125 126 127

	if (name) {
		struct dentry *de = d_find_alias(inode);

		if (de) {
			spin_lock(&de->d_lock);
128 129
			snprintf(name, sizeof(s_name_buf), " \"%s\"",
				 de->d_name.name);
130 131 132 133
			spin_unlock(&de->d_lock);
		} else {
			name[0] = 0;
		}
134
		dput(de); /* Cocci warns if placed in branch "if (de)" */
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	}

	va_start(args, fmt);

	level = printk_get_level(fmt);
	vaf.fmt = printk_skip_level(fmt);
	vaf.va = &args;

	printk("%c%cntfs3: %s: ino=%lx,%s %pV\n", KERN_SOH_ASCII, level,
	       sb->s_id, inode->i_ino, name ? name : "", &vaf);

	va_end(args);

	atomic_inc(&s_name_buf_cnt);
	if (name != s_name_buf)
		kfree(name);
}
#endif

/*
 * Shared memory struct.
 *
157 158 159 160 161 162
 * On-disk ntfs's upcase table is created by ntfs formatter.
 * 'upcase' table is 128K bytes of memory.
 * We should read it into memory when mounting.
 * Several ntfs volumes likely use the same 'upcase' table.
 * It is good idea to share in-memory 'upcase' table between different volumes.
 * Unfortunately winxp/vista/win7 use different upcase tables.
163 164 165 166 167 168 169 170 171 172 173 174
 */
static DEFINE_SPINLOCK(s_shared_lock);

static struct {
	void *ptr;
	u32 len;
	int cnt;
} s_shared[8];

/*
 * ntfs_set_shared
 *
175 176 177
 * Return:
 * * @ptr - If pointer was saved in shared memory.
 * * NULL - If pointer was not shared.
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
 */
void *ntfs_set_shared(void *ptr, u32 bytes)
{
	void *ret = NULL;
	int i, j = -1;

	spin_lock(&s_shared_lock);
	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
		if (!s_shared[i].cnt) {
			j = i;
		} else if (bytes == s_shared[i].len &&
			   !memcmp(s_shared[i].ptr, ptr, bytes)) {
			s_shared[i].cnt += 1;
			ret = s_shared[i].ptr;
			break;
		}
	}

	if (!ret && j != -1) {
		s_shared[j].ptr = ptr;
		s_shared[j].len = bytes;
		s_shared[j].cnt = 1;
		ret = ptr;
	}
	spin_unlock(&s_shared_lock);

	return ret;
}

/*
 * ntfs_put_shared
 *
210 211 212
 * Return:
 * * @ptr - If pointer is not shared anymore.
 * * NULL - If pointer is still shared.
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
 */
void *ntfs_put_shared(void *ptr)
{
	void *ret = ptr;
	int i;

	spin_lock(&s_shared_lock);
	for (i = 0; i < ARRAY_SIZE(s_shared); i++) {
		if (s_shared[i].cnt && s_shared[i].ptr == ptr) {
			if (--s_shared[i].cnt)
				ret = NULL;
			break;
		}
	}
	spin_unlock(&s_shared_lock);

	return ret;
}

232
static inline void put_mount_options(struct ntfs_mount_options *options)
233
{
234
	kfree(options->nls_name);
235
	unload_nls(options->nls);
236
	kfree(options);
237 238 239 240 241 242 243 244 245 246 247 248 249
}

enum Opt {
	Opt_uid,
	Opt_gid,
	Opt_umask,
	Opt_dmask,
	Opt_fmask,
	Opt_immutable,
	Opt_discard,
	Opt_force,
	Opt_sparse,
	Opt_nohidden,
250
	Opt_hide_dot_files,
251
	Opt_windows_names,
252 253
	Opt_showmeta,
	Opt_acl,
254
	Opt_iocharset,
255
	Opt_prealloc,
256
	Opt_nocase,
257 258 259
	Opt_err,
};

260
// clang-format off
261
static const struct fs_parameter_spec ntfs_fs_parameters[] = {
262 263
	fsparam_uid("uid",			Opt_uid),
	fsparam_gid("gid",			Opt_gid),
264 265 266 267 268 269 270
	fsparam_u32oct("umask",			Opt_umask),
	fsparam_u32oct("dmask",			Opt_dmask),
	fsparam_u32oct("fmask",			Opt_fmask),
	fsparam_flag_no("sys_immutable",	Opt_immutable),
	fsparam_flag_no("discard",		Opt_discard),
	fsparam_flag_no("force",		Opt_force),
	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 276
	fsparam_flag_no("acl",			Opt_acl),
	fsparam_string("iocharset",		Opt_iocharset),
277
	fsparam_flag_no("prealloc",		Opt_prealloc),
278
	fsparam_flag_no("case",		Opt_nocase),
279
	{}
280
};
281
// clang-format on
282

283 284
/*
 * Load nls table or if @nls is utf8 then return NULL.
285 286 287
 *
 * It is good idea to use here "const char *nls".
 * But load_nls accepts "char*".
288 289
 */
static struct nls_table *ntfs_load_nls(char *nls)
290
{
291
	struct nls_table *ret;
292

293 294
	if (!nls)
		nls = CONFIG_NLS_DEFAULT;
295

296 297
	if (strcmp(nls, "utf8") == 0)
		return NULL;
298

299 300
	if (strcmp(nls, CONFIG_NLS_DEFAULT) == 0)
		return load_nls_default();
301

302 303 304
	ret = load_nls(nls);
	if (ret)
		return ret;
305

306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	return ERR_PTR(-EINVAL);
}

static int ntfs_fs_parse_param(struct fs_context *fc,
			       struct fs_parameter *param)
{
	struct ntfs_mount_options *opts = fc->fs_private;
	struct fs_parse_result result;
	int opt;

	opt = fs_parse(fc, ntfs_fs_parameters, param, &result);
	if (opt < 0)
		return opt;

	switch (opt) {
	case Opt_uid:
322
		opts->fs_uid = result.uid;
323 324
		break;
	case Opt_gid:
325
		opts->fs_gid = result.gid;
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
		break;
	case Opt_umask:
		if (result.uint_32 & ~07777)
			return invalf(fc, "ntfs3: Invalid value for umask.");
		opts->fs_fmask_inv = ~result.uint_32;
		opts->fs_dmask_inv = ~result.uint_32;
		opts->fmask = 1;
		opts->dmask = 1;
		break;
	case Opt_dmask:
		if (result.uint_32 & ~07777)
			return invalf(fc, "ntfs3: Invalid value for dmask.");
		opts->fs_dmask_inv = ~result.uint_32;
		opts->dmask = 1;
		break;
	case Opt_fmask:
		if (result.uint_32 & ~07777)
			return invalf(fc, "ntfs3: Invalid value for fmask.");
		opts->fs_fmask_inv = ~result.uint_32;
		opts->fmask = 1;
		break;
	case Opt_immutable:
		opts->sys_immutable = result.negated ? 0 : 1;
		break;
	case Opt_discard:
		opts->discard = result.negated ? 0 : 1;
		break;
	case Opt_force:
		opts->force = result.negated ? 0 : 1;
		break;
	case Opt_sparse:
		opts->sparse = result.negated ? 0 : 1;
		break;
	case Opt_nohidden:
360
		opts->nohidden = result.negated ? 1 : 0;
361
		break;
362
	case Opt_hide_dot_files:
363
		opts->hide_dot_files = result.negated ? 0 : 1;
364
		break;
365 366 367
	case Opt_windows_names:
		opts->windows_names = result.negated ? 0 : 1;
		break;
368 369 370
	case Opt_showmeta:
		opts->showmeta = result.negated ? 0 : 1;
		break;
371 372
	case Opt_acl:
		if (!result.negated)
373
#ifdef CONFIG_NTFS3_FS_POSIX_ACL
374
			fc->sb_flags |= SB_POSIXACL;
375
#else
376 377
			return invalf(
				fc, "ntfs3: Support for ACL not compiled in!");
378
#endif
379 380 381
		else
			fc->sb_flags &= ~SB_POSIXACL;
		break;
382
	case Opt_iocharset:
383 384 385 386 387 388 389
		kfree(opts->nls_name);
		opts->nls_name = param->string;
		param->string = NULL;
		break;
	case Opt_prealloc:
		opts->prealloc = result.negated ? 0 : 1;
		break;
390 391 392
	case Opt_nocase:
		opts->nocase = result.negated ? 1 : 0;
		break;
393 394 395
	default:
		/* Should not be here unless we forget add case. */
		return -EINVAL;
396 397 398 399
	}
	return 0;
}

400
static int ntfs_fs_reconfigure(struct fs_context *fc)
401
{
402
	struct super_block *sb = fc->root->d_sb;
403
	struct ntfs_sb_info *sbi = sb->s_fs_info;
404 405
	struct ntfs_mount_options *new_opts = fc->fs_private;
	int ro_rw;
406

407 408 409 410 411 412
	/* If ntfs3 is used as legacy ntfs enforce read-only mode. */
	if (is_legacy_ntfs(sb)) {
		fc->sb_flags |= SB_RDONLY;
		goto out;
	}

413
	ro_rw = sb_rdonly(sb) && !(fc->sb_flags & SB_RDONLY);
414
	if (ro_rw && (sbi->flags & NTFS_FLAGS_NEED_REPLAY)) {
415 416
		errorf(fc,
		       "ntfs3: Couldn't remount rw because journal is not replayed. Please umount/remount instead\n");
417 418 419 420 421 422
		return -EINVAL;
	}

	new_opts->nls = ntfs_load_nls(new_opts->nls_name);
	if (IS_ERR(new_opts->nls)) {
		new_opts->nls = NULL;
423 424
		errorf(fc, "ntfs3: Cannot load iocharset %s",
		       new_opts->nls_name);
425
		return -EINVAL;
426
	}
427
	if (new_opts->nls != sbi->options->nls)
428 429 430
		return invalf(
			fc,
			"ntfs3: Cannot use different iocharset when remounting!");
431 432

	if (ro_rw && (sbi->volume.flags & VOLUME_FLAG_DIRTY) &&
433
	    !new_opts->force) {
434 435
		errorf(fc,
		       "ntfs3: Volume is dirty and \"force\" flag is not set!");
436
		return -EINVAL;
437 438
	}

439 440
out:
	sync_filesystem(sb);
441
	swap(sbi->options, fc->fs_private);
442

443
	return 0;
444 445
}

446 447 448 449 450 451 452 453 454 455 456
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_info_root;

/*
 * ntfs3_volinfo:
 *
 * The content of /proc/fs/ntfs3/<dev>/volinfo
 *
 * ntfs3.1
 * cluster size
 * number of clusters
457 458 459 460
 * total number of mft records
 * number of used mft records ~= number of files + folders
 * real state of ntfs "dirty"/"clean"
 * current state of ntfs "dirty"/"clean"
461 462 463 464 465 466
*/
static int ntfs3_volinfo(struct seq_file *m, void *o)
{
	struct super_block *sb = m->private;
	struct ntfs_sb_info *sbi = sb->s_fs_info;

467
	seq_printf(m, "ntfs%d.%d\n%u\n%zu\n%zu\n%zu\n%s\n%s\n",
468 469 470 471 472 473
		   sbi->volume.major_ver, sbi->volume.minor_ver,
		   sbi->cluster_size, sbi->used.bitmap.nbits,
		   sbi->mft.bitmap.nbits,
		   sbi->mft.bitmap.nbits - wnd_zeroes(&sbi->mft.bitmap),
		   sbi->volume.real_dirty ? "dirty" : "clean",
		   (sbi->volume.flags & VOLUME_FLAG_DIRTY) ? "dirty" : "clean");
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500

	return 0;
}

static int ntfs3_volinfo_open(struct inode *inode, struct file *file)
{
	return single_open(file, ntfs3_volinfo, pde_data(inode));
}

/* read /proc/fs/ntfs3/<dev>/label */
static int ntfs3_label_show(struct seq_file *m, void *o)
{
	struct super_block *sb = m->private;
	struct ntfs_sb_info *sbi = sb->s_fs_info;

	seq_printf(m, "%s\n", sbi->volume.label);

	return 0;
}

/* write /proc/fs/ntfs3/<dev>/label */
static ssize_t ntfs3_label_write(struct file *file, const char __user *buffer,
				 size_t count, loff_t *ppos)
{
	int err;
	struct super_block *sb = pde_data(file_inode(file));
	ssize_t ret = count;
501 502 503 504 505 506
	u8 *label;

	if (sb_rdonly(sb))
		return -EROFS;

	label = kmalloc(count, GFP_NOFS);
507 508 509 510 511 512 513 514 515 516 517

	if (!label)
		return -ENOMEM;

	if (copy_from_user(label, buffer, ret)) {
		ret = -EFAULT;
		goto out;
	}
	while (ret > 0 && label[ret - 1] == '\n')
		ret -= 1;

518
	err = ntfs_set_label(sb->s_fs_info, label, ret);
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554

	if (err < 0) {
		ntfs_err(sb, "failed (%d) to write label", err);
		ret = err;
		goto out;
	}

	*ppos += count;
	ret = count;
out:
	kfree(label);
	return ret;
}

static int ntfs3_label_open(struct inode *inode, struct file *file)
{
	return single_open(file, ntfs3_label_show, pde_data(inode));
}

static const struct proc_ops ntfs3_volinfo_fops = {
	.proc_read = seq_read,
	.proc_lseek = seq_lseek,
	.proc_release = single_release,
	.proc_open = ntfs3_volinfo_open,
};

static const struct proc_ops ntfs3_label_fops = {
	.proc_read = seq_read,
	.proc_lseek = seq_lseek,
	.proc_release = single_release,
	.proc_open = ntfs3_label_open,
	.proc_write = ntfs3_label_write,
};

#endif

555 556 557 558
static struct kmem_cache *ntfs_inode_cachep;

static struct inode *ntfs_alloc_inode(struct super_block *sb)
{
559
	struct ntfs_inode *ni = alloc_inode_sb(sb, ntfs_inode_cachep, GFP_NOFS);
560 561 562 563 564 565 566 567 568

	if (!ni)
		return NULL;

	memset(ni, 0, offsetof(struct ntfs_inode, vfs_inode));
	mutex_init(&ni->ni_lock);
	return &ni->vfs_inode;
}

569
static void ntfs_free_inode(struct inode *inode)
570 571 572 573 574 575 576 577 578 579 580 581 582 583
{
	struct ntfs_inode *ni = ntfs_i(inode);

	mutex_destroy(&ni->ni_lock);
	kmem_cache_free(ntfs_inode_cachep, ni);
}

static void init_once(void *foo)
{
	struct ntfs_inode *ni = foo;

	inode_init_once(&ni->vfs_inode);
}

584
/*
585
 * Noinline to reduce binary size.
586
 */
587
static noinline void ntfs3_put_sbi(struct ntfs_sb_info *sbi)
588 589 590 591
{
	wnd_close(&sbi->mft.bitmap);
	wnd_close(&sbi->used.bitmap);

592
	if (sbi->mft.ni) {
593
		iput(&sbi->mft.ni->vfs_inode);
594 595
		sbi->mft.ni = NULL;
	}
596

597
	if (sbi->security.ni) {
598
		iput(&sbi->security.ni->vfs_inode);
599 600
		sbi->security.ni = NULL;
	}
601

602
	if (sbi->reparse.ni) {
603
		iput(&sbi->reparse.ni->vfs_inode);
604 605
		sbi->reparse.ni = NULL;
	}
606

607
	if (sbi->objid.ni) {
608
		iput(&sbi->objid.ni->vfs_inode);
609 610
		sbi->objid.ni = NULL;
	}
611

612
	if (sbi->volume.ni) {
613
		iput(&sbi->volume.ni->vfs_inode);
614 615
		sbi->volume.ni = NULL;
	}
616 617 618 619 620 621 622

	ntfs_update_mftmirr(sbi, 0);

	indx_clear(&sbi->security.index_sii);
	indx_clear(&sbi->security.index_sdh);
	indx_clear(&sbi->reparse.index_r);
	indx_clear(&sbi->objid.index_o);
623 624 625 626 627 628
}

static void ntfs3_free_sbi(struct ntfs_sb_info *sbi)
{
	kfree(sbi->new_rec);
	kvfree(ntfs_put_shared(sbi->upcase));
629
	kvfree(sbi->def_table);
630
	kfree(sbi->compress.lznt);
631 632 633 634
#ifdef CONFIG_NTFS3_LZX_XPRESS
	xpress_free_decompressor(sbi->compress.xpress);
	lzx_free_decompressor(sbi->compress.lzx);
#endif
635
	kfree(sbi);
636 637 638 639 640 641
}

static void ntfs_put_super(struct super_block *sb)
{
	struct ntfs_sb_info *sbi = sb->s_fs_info;

642 643 644 645 646 647 648 649 650 651
#ifdef CONFIG_PROC_FS
	// Remove /proc/fs/ntfs3/..
	if (sbi->procdir) {
		remove_proc_entry("label", sbi->procdir);
		remove_proc_entry("volinfo", sbi->procdir);
		remove_proc_entry(sb->s_id, proc_info_root);
		sbi->procdir = NULL;
	}
#endif

652
	/* Mark rw ntfs as clear, if possible. */
653
	ntfs_set_state(sbi, NTFS_DIRTY_CLEAR);
654
	ntfs3_put_sbi(sbi);
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
}

static int ntfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	struct wnd_bitmap *wnd = &sbi->used.bitmap;

	buf->f_type = sb->s_magic;
	buf->f_bsize = sbi->cluster_size;
	buf->f_blocks = wnd->nbits;

	buf->f_bfree = buf->f_bavail = wnd_zeroes(wnd);
	buf->f_fsid.val[0] = sbi->volume.ser_num;
	buf->f_fsid.val[1] = (sbi->volume.ser_num >> 32);
	buf->f_namelen = NTFS_NAME_LEN;

	return 0;
}

static int ntfs_show_options(struct seq_file *m, struct dentry *root)
{
	struct super_block *sb = root->d_sb;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
679
	struct ntfs_mount_options *opts = sbi->options;
680 681
	struct user_namespace *user_ns = seq_user_ns(m);

682 683
	seq_printf(m, ",uid=%u", from_kuid_munged(user_ns, opts->fs_uid));
	seq_printf(m, ",gid=%u", from_kgid_munged(user_ns, opts->fs_gid));
684
	if (opts->dmask)
685
		seq_printf(m, ",dmask=%04o", opts->fs_dmask_inv ^ 0xffff);
686 687
	if (opts->fmask)
		seq_printf(m, ",fmask=%04o", opts->fs_fmask_inv ^ 0xffff);
688 689 690 691
	if (opts->sys_immutable)
		seq_puts(m, ",sys_immutable");
	if (opts->discard)
		seq_puts(m, ",discard");
692 693
	if (opts->force)
		seq_puts(m, ",force");
694 695 696 697
	if (opts->sparse)
		seq_puts(m, ",sparse");
	if (opts->nohidden)
		seq_puts(m, ",nohidden");
698
	if (opts->hide_dot_files)
699
		seq_puts(m, ",hide_dot_files");
700 701 702 703
	if (opts->windows_names)
		seq_puts(m, ",windows_names");
	if (opts->showmeta)
		seq_puts(m, ",showmeta");
704 705
	if (sb->s_flags & SB_POSIXACL)
		seq_puts(m, ",acl");
706 707 708 709 710 711 712 713
	if (opts->nls)
		seq_printf(m, ",iocharset=%s", opts->nls->charset);
	else
		seq_puts(m, ",iocharset=utf8");
	if (opts->prealloc)
		seq_puts(m, ",prealloc");
	if (opts->nocase)
		seq_puts(m, ",nocase");
714 715 716 717

	return 0;
}

718 719 720 721 722
/*
 * ntfs_shutdown - super_operations::shutdown
 */
static void ntfs_shutdown(struct super_block *sb)
{
723
	set_bit(NTFS_FLAGS_SHUTDOWN_BIT, &ntfs_sb(sb)->flags);
724 725
}

726 727 728
/*
 * ntfs_sync_fs - super_operations::sync_fs
 */
729 730 731 732 733 734 735
static int ntfs_sync_fs(struct super_block *sb, int wait)
{
	int err = 0, err2;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	struct ntfs_inode *ni;
	struct inode *inode;

736 737 738
	if (unlikely(ntfs3_forced_shutdown(sb)))
		return -EIO;

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	ni = sbi->security.ni;
	if (ni) {
		inode = &ni->vfs_inode;
		err2 = _ni_write_inode(inode, wait);
		if (err2 && !err)
			err = err2;
	}

	ni = sbi->objid.ni;
	if (ni) {
		inode = &ni->vfs_inode;
		err2 = _ni_write_inode(inode, wait);
		if (err2 && !err)
			err = err2;
	}

	ni = sbi->reparse.ni;
	if (ni) {
		inode = &ni->vfs_inode;
		err2 = _ni_write_inode(inode, wait);
		if (err2 && !err)
			err = err2;
	}

	if (!err)
		ntfs_set_state(sbi, NTFS_DIRTY_CLEAR);

	ntfs_update_mftmirr(sbi, wait);

	return err;
}

static const struct super_operations ntfs_sops = {
	.alloc_inode = ntfs_alloc_inode,
773
	.free_inode = ntfs_free_inode,
774 775 776 777
	.evict_inode = ntfs_evict_inode,
	.put_super = ntfs_put_super,
	.statfs = ntfs_statfs,
	.show_options = ntfs_show_options,
778
	.shutdown = ntfs_shutdown,
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
	.sync_fs = ntfs_sync_fs,
	.write_inode = ntfs3_write_inode,
};

static struct inode *ntfs_export_get_inode(struct super_block *sb, u64 ino,
					   u32 generation)
{
	struct MFT_REF ref;
	struct inode *inode;

	ref.low = cpu_to_le32(ino);
#ifdef CONFIG_NTFS3_64BIT_CLUSTER
	ref.high = cpu_to_le16(ino >> 32);
#else
	ref.high = 0;
#endif
	ref.seq = cpu_to_le16(generation);

	inode = ntfs_iget5(sb, &ref, NULL);
	if (!IS_ERR(inode) && is_bad_inode(inode)) {
		iput(inode);
		inode = ERR_PTR(-ESTALE);
	}

	return inode;
}

static struct dentry *ntfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
					int fh_len, int fh_type)
{
	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
				    ntfs_export_get_inode);
}

static struct dentry *ntfs_fh_to_parent(struct super_block *sb, struct fid *fid,
					int fh_len, int fh_type)
{
	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
				    ntfs_export_get_inode);
}

/* TODO: == ntfs_sync_inode */
static int ntfs_nfs_commit_metadata(struct inode *inode)
{
	return _ni_write_inode(inode, 1);
}

static const struct export_operations ntfs_export_ops = {
827
	.encode_fh = generic_encode_ino32_fh,
828 829 830 831 832 833
	.fh_to_dentry = ntfs_fh_to_dentry,
	.fh_to_parent = ntfs_fh_to_parent,
	.get_parent = ntfs3_get_parent,
	.commit_metadata = ntfs_nfs_commit_metadata,
};

834 835 836
/*
 * format_size_gb - Return Gb,Mb to print with "%u.%02u Gb".
 */
837 838
static u32 format_size_gb(const u64 bytes, u32 *mb)
{
839
	/* Do simple right 30 bit shift of 64 bit value. */
840 841 842 843 844 845 846 847 848 849 850 851
	u64 kbytes = bytes >> 10;
	u32 kbytes32 = kbytes;

	*mb = (100 * (kbytes32 & 0xfffff) + 0x7ffff) >> 20;
	if (*mb >= 100)
		*mb = 99;

	return (kbytes32 >> 20) | (((u32)(kbytes >> 32)) << 12);
}

static u32 true_sectors_per_clst(const struct NTFS_BOOT *boot)
{
852 853 854
	if (boot->sectors_per_clusters <= 0x80)
		return boot->sectors_per_clusters;
	if (boot->sectors_per_clusters >= 0xf4) /* limit shift to 2MB max */
855
		return 1U << (-(s8)boot->sectors_per_clusters);
856
	return -EINVAL;
857 858
}

859 860
/*
 * ntfs_init_from_boot - Init internal info from on-disk boot sector.
861 862 863 864 865 866 867
 *
 * NTFS mount begins from boot - special formatted 512 bytes.
 * There are two boots: the first and the last 512 bytes of volume.
 * The content of boot is not changed during ntfs life.
 *
 * NOTE: ntfs.sys checks only first (primary) boot.
 * chkdsk checks both boots.
868
 */
869
static int ntfs_init_from_boot(struct super_block *sb, u32 sector_size,
870
			       u64 dev_size, struct NTFS_BOOT **boot2)
871 872 873 874
{
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	int err;
	u32 mb, gb, boot_sector_size, sct_per_clst, record_size;
875
	u64 sectors, clusters, mlcn, mlcn2, dev_size0;
876 877 878 879
	struct NTFS_BOOT *boot;
	struct buffer_head *bh;
	struct MFT_REC *rec;
	u16 fn, ao;
880
	u8 cluster_bits;
881
	u32 boot_off = 0;
882
	sector_t boot_block = 0;
883
	const char *hint = "Primary boot";
884

885 886 887
	/* Save original dev_size. Used with alternative boot. */
	dev_size0 = dev_size;

888 889
	sbi->volume.blocks = dev_size >> PAGE_SHIFT;

890 891
read_boot:
	bh = ntfs_bread(sb, boot_block);
892
	if (!bh)
893
		return boot_block ? -EINVAL : -EIO;
894 895

	err = -EINVAL;
896 897 898 899 900

	/* Corrupted image; do not read OOB */
	if (bh->b_size - sizeof(*boot) < boot_off)
		goto out;

901
	boot = (struct NTFS_BOOT *)Add2Ptr(bh->b_data, boot_off);
902

903
	if (memcmp(boot->system_id, "NTFS    ", sizeof("NTFS    ") - 1)) {
904
		ntfs_err(sb, "%s signature is not NTFS.", hint);
905
		goto out;
906
	}
907 908 909 910 911 912

	/* 0x55AA is not mandaroty. Thanks Maxim Suhanov*/
	/*if (0x55 != boot->boot_magic[0] || 0xAA != boot->boot_magic[1])
	 *	goto out;
	 */

913 914 915
	boot_sector_size = ((u32)boot->bytes_per_sector[1] << 8) |
			   boot->bytes_per_sector[0];
	if (boot_sector_size < SECTOR_SIZE ||
916
	    !is_power_of_2(boot_sector_size)) {
917 918
		ntfs_err(sb, "%s: invalid bytes per sector %u.", hint,
			 boot_sector_size);
919 920 921 922 923
		goto out;
	}

	/* cluster size: 512, 1K, 2K, 4K, ... 2M */
	sct_per_clst = true_sectors_per_clst(boot);
924
	if ((int)sct_per_clst < 0 || !is_power_of_2(sct_per_clst)) {
925 926
		ntfs_err(sb, "%s: invalid sectors per cluster %u.", hint,
			 sct_per_clst);
927
		goto out;
928 929 930 931 932 933
	}

	sbi->cluster_size = boot_sector_size * sct_per_clst;
	sbi->cluster_bits = cluster_bits = blksize_bits(sbi->cluster_size);
	sbi->cluster_mask = sbi->cluster_size - 1;
	sbi->cluster_mask_inv = ~(u64)sbi->cluster_mask;
934 935 936 937 938

	mlcn = le64_to_cpu(boot->mft_clst);
	mlcn2 = le64_to_cpu(boot->mft2_clst);
	sectors = le64_to_cpu(boot->sectors_per_volume);

939 940 941
	if (mlcn * sct_per_clst >= sectors || mlcn2 * sct_per_clst >= sectors) {
		ntfs_err(
			sb,
942 943
			"%s: start of MFT 0x%llx (0x%llx) is out of volume 0x%llx.",
			hint, mlcn, mlcn2, sectors);
944
		goto out;
945
	}
946

947 948 949 950 951 952 953 954 955 956 957
	if (boot->record_size >= 0) {
		record_size = (u32)boot->record_size << cluster_bits;
	} else if (-boot->record_size <= MAXIMUM_SHIFT_BYTES_PER_MFT) {
		record_size = 1u << (-boot->record_size);
	} else {
		ntfs_err(sb, "%s: invalid record size %d.", hint,
			 boot->record_size);
		goto out;
	}

	sbi->record_size = record_size;
958 959
	sbi->record_bits = blksize_bits(record_size);
	sbi->attr_size_tr = (5 * record_size >> 4); // ~320 bytes
960

961
	/* Check MFT record size. */
962
	if (record_size < SECTOR_SIZE || !is_power_of_2(record_size)) {
963
		ntfs_err(sb, "%s: invalid bytes per MFT record %u (%d).", hint,
964 965 966 967 968 969 970
			 record_size, boot->record_size);
		goto out;
	}

	if (record_size > MAXIMUM_BYTES_PER_MFT) {
		ntfs_err(sb, "Unsupported bytes per MFT record %u.",
			 record_size);
971 972 973
		goto out;
	}

974 975 976 977 978 979 980 981 982
	if (boot->index_size >= 0) {
		sbi->index_size = (u32)boot->index_size << cluster_bits;
	} else if (-boot->index_size <= MAXIMUM_SHIFT_BYTES_PER_INDEX) {
		sbi->index_size = 1u << (-boot->index_size);
	} else {
		ntfs_err(sb, "%s: invalid index size %d.", hint,
			 boot->index_size);
		goto out;
	}
983

984
	/* Check index record size. */
985
	if (sbi->index_size < SECTOR_SIZE || !is_power_of_2(sbi->index_size)) {
986 987
		ntfs_err(sb, "%s: invalid bytes per index %u(%d).", hint,
			 sbi->index_size, boot->index_size);
988 989 990 991
		goto out;
	}

	if (sbi->index_size > MAXIMUM_BYTES_PER_INDEX) {
992
		ntfs_err(sb, "%s: unsupported bytes per index %u.", hint,
993
			 sbi->index_size);
994 995 996
		goto out;
	}

997
	sbi->volume.size = sectors * boot_sector_size;
998

999
	gb = format_size_gb(sbi->volume.size + boot_sector_size, &mb);
1000 1001

	/*
1002 1003 1004
	 * - Volume formatted and mounted with the same sector size.
	 * - Volume formatted 4K and mounted as 512.
	 * - Volume formatted 512 and mounted as 4K.
1005
	 */
1006 1007 1008
	if (boot_sector_size != sector_size) {
		ntfs_warn(
			sb,
1009
			"Different NTFS sector size (%u) and media sector size (%u).",
1010
			boot_sector_size, sector_size);
1011 1012 1013
		dev_size += sector_size - 1;
	}

1014 1015
	sbi->mft.lbo = mlcn << cluster_bits;
	sbi->mft.lbo2 = mlcn2 << cluster_bits;
1016

1017
	/* Compare boot's cluster and sector. */
1018
	if (sbi->cluster_size < boot_sector_size) {
1019
		ntfs_err(sb, "%s: invalid bytes per cluster (%u).", hint,
1020
			 sbi->cluster_size);
1021
		goto out;
1022
	}
1023

1024 1025 1026 1027 1028
	/* Compare boot's cluster and media sector. */
	if (sbi->cluster_size < sector_size) {
		/* No way to use ntfs_get_block in this case. */
		ntfs_err(
			sb,
1029
			"Failed to mount 'cause NTFS's cluster size (%u) is less than media sector size (%u).",
1030 1031 1032 1033
			sbi->cluster_size, sector_size);
		goto out;
	}

1034
	sbi->max_bytes_per_attr =
1035
		record_size - ALIGN(MFTRECORD_FIXUP_OFFSET, 8) -
1036 1037
		ALIGN(((record_size >> SECTOR_SHIFT) * sizeof(short)), 8) -
		ALIGN(sizeof(enum ATTR_TYPE), 8);
1038 1039 1040

	sbi->volume.ser_num = le64_to_cpu(boot->serial_num);

1041
	/* Warning if RAW volume. */
1042
	if (dev_size < sbi->volume.size + boot_sector_size) {
1043 1044 1045 1046 1047
		u32 mb0, gb0;

		gb0 = format_size_gb(dev_size, &mb0);
		ntfs_warn(
			sb,
1048
			"RAW NTFS volume: Filesystem size %u.%02u Gb > volume size %u.%02u Gb. Mount in read-only.",
1049 1050 1051 1052
			gb, mb, gb0, mb0);
		sb->s_flags |= SB_RDONLY;
	}

1053
	clusters = sbi->volume.size >> cluster_bits;
1054
#ifndef CONFIG_NTFS3_64BIT_CLUSTER
1055
	/* 32 bits per cluster. */
1056 1057 1058
	if (clusters >> 32) {
		ntfs_notice(
			sb,
1059
			"NTFS %u.%02u Gb is too big to use 32 bits per cluster.",
1060 1061 1062 1063 1064 1065 1066 1067 1068
			gb, mb);
		goto out;
	}
#elif BITS_PER_LONG < 64
#error "CONFIG_NTFS3_64BIT_CLUSTER incompatible in 32 bit OS"
#endif

	sbi->used.bitmap.nbits = clusters;

1069
	rec = kzalloc(record_size, GFP_NOFS);
1070 1071 1072 1073 1074 1075 1076
	if (!rec) {
		err = -ENOMEM;
		goto out;
	}

	sbi->new_rec = rec;
	rec->rhdr.sign = NTFS_FILE_SIGNATURE;
1077
	rec->rhdr.fix_off = cpu_to_le16(MFTRECORD_FIXUP_OFFSET);
1078 1079
	fn = (sbi->record_size >> SECTOR_SHIFT) + 1;
	rec->rhdr.fix_num = cpu_to_le16(fn);
1080
	ao = ALIGN(MFTRECORD_FIXUP_OFFSET + sizeof(short) * fn, 8);
1081
	rec->attr_off = cpu_to_le16(ao);
1082
	rec->used = cpu_to_le32(ao + ALIGN(sizeof(enum ATTR_TYPE), 8));
1083 1084 1085
	rec->total = cpu_to_le32(sbi->record_size);
	((struct ATTRIB *)Add2Ptr(rec, ao))->type = ATTR_END;

1086
	sb_set_blocksize(sb, min_t(u32, sbi->cluster_size, PAGE_SIZE));
1087 1088 1089 1090 1091

	sbi->block_mask = sb->s_blocksize - 1;
	sbi->blocks_per_cluster = sbi->cluster_size >> sb->s_blocksize_bits;
	sbi->volume.blocks = sbi->volume.size >> sb->s_blocksize_bits;

1092
	/* Maximum size for normal files. */
1093
	sbi->maxbytes = (clusters << cluster_bits) - 1;
1094 1095

#ifdef CONFIG_NTFS3_64BIT_CLUSTER
1096
	if (clusters >= (1ull << (64 - cluster_bits)))
1097 1098
		sbi->maxbytes = -1;
	sbi->maxbytes_sparse = -1;
1099
	sb->s_maxbytes = MAX_LFS_FILESIZE;
1100
#else
1101
	/* Maximum size for sparse file. */
1102 1103
	sbi->maxbytes_sparse = (1ull << (cluster_bits + 32)) - 1;
	sb->s_maxbytes = 0xFFFFFFFFull << cluster_bits;
1104 1105
#endif

1106 1107 1108 1109 1110
	/*
	 * Compute the MFT zone at two steps.
	 * It would be nice if we are able to allocate 1/8 of
	 * total clusters for MFT but not more then 512 MB.
	 */
1111
	sbi->zone_max = min_t(CLST, 0x20000000 >> cluster_bits, clusters >> 3);
1112

1113 1114
	err = 0;

1115 1116
	if (bh->b_blocknr && !sb_rdonly(sb)) {
		/*
1117 1118 1119 1120
	 	 * Alternative boot is ok but primary is not ok.
	 	 * Do not update primary boot here 'cause it may be faked boot.
	 	 * Let ntfs to be mounted and update boot later.
		 */
1121
		*boot2 = kmemdup(boot, sizeof(*boot), GFP_NOFS | __GFP_NOWARN);
1122 1123
	}

1124
out:
1125 1126 1127
	brelse(bh);

	if (err == -EINVAL && !boot_block && dev_size0 > PAGE_SHIFT) {
1128
		u32 block_size = min_t(u32, sector_size, PAGE_SIZE);
1129
		u64 lbo = dev_size0 - sizeof(*boot);
1130

1131
		boot_block = lbo >> blksize_bits(block_size);
1132
		boot_off = lbo & (block_size - 1);
1133 1134 1135 1136 1137 1138 1139 1140 1141
		if (boot_block && block_size >= boot_off + sizeof(*boot)) {
			/*
			 * Try alternative boot (last sector)
			 */
			sb_set_blocksize(sb, block_size);
			hint = "Alternative boot";
			dev_size = dev_size0; /* restore original size. */
			goto read_boot;
		}
1142
	}
1143 1144 1145 1146

	return err;
}

1147 1148 1149
/*
 * ntfs_fill_super - Try to mount.
 */
1150
static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
1151 1152
{
	int err;
1153
	struct ntfs_sb_info *sbi = sb->s_fs_info;
1154
	struct block_device *bdev = sb->s_bdev;
1155
	struct ntfs_mount_options *options;
1156
	struct inode *inode;
1157
	struct ntfs_inode *ni;
1158
	size_t i, tt, bad_len, bad_frags;
1159 1160 1161
	CLST vcn, lcn, len;
	struct ATTRIB *attr;
	const struct VOLUME_INFO *info;
1162
	u32 done, bytes;
1163 1164 1165
	struct ATTR_DEF_ENTRY *t;
	u16 *shared;
	struct MFT_REF ref;
1166
	bool ro = sb_rdonly(sb);
1167
	struct NTFS_BOOT *boot2 = NULL;
1168 1169 1170 1171

	ref.high = 0;

	sbi->sb = sb;
1172
	sbi->options = options = fc->fs_private;
1173
	fc->fs_private = NULL;
1174 1175 1176 1177 1178 1179
	sb->s_flags |= SB_NODIRATIME;
	sb->s_magic = 0x7366746e; // "ntfs"
	sb->s_op = &ntfs_sops;
	sb->s_export_op = &ntfs_export_ops;
	sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
	sb->s_xattr = ntfs_xattr_handlers;
1180
	sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
1181

1182 1183 1184 1185
	options->nls = ntfs_load_nls(options->nls_name);
	if (IS_ERR(options->nls)) {
		options->nls = NULL;
		errorf(fc, "Cannot load nls %s", options->nls_name);
1186 1187
		err = -EINVAL;
		goto out;
1188
	}
1189

1190 1191
	if (bdev_max_discard_sectors(bdev) && bdev_discard_granularity(bdev)) {
		sbi->discard_granularity = bdev_discard_granularity(bdev);
1192 1193 1194 1195
		sbi->discard_granularity_mask_inv =
			~(u64)(sbi->discard_granularity - 1);
	}

1196
	/* Parse boot. */
1197
	err = ntfs_init_from_boot(sb, bdev_logical_block_size(bdev),
1198
				  bdev_nr_bytes(bdev), &boot2);
1199
	if (err)
1200
		goto out;
1201 1202

	/*
1203
	 * Load $Volume. This should be done before $LogFile
1204
	 * 'cause 'sbi->volume.ni' is used in 'ntfs_set_state'.
1205 1206 1207 1208 1209
	 */
	ref.low = cpu_to_le32(MFT_REC_VOL);
	ref.seq = cpu_to_le16(MFT_REC_VOL);
	inode = ntfs_iget5(sb, &ref, &NAME_VOLUME);
	if (IS_ERR(inode)) {
1210
		err = PTR_ERR(inode);
1211
		ntfs_err(sb, "Failed to load $Volume (%d).", err);
1212
		goto out;
1213 1214 1215 1216
	}

	ni = ntfs_i(inode);

1217
	/* Load and save label (not necessary). */
1218 1219 1220 1221 1222
	attr = ni_find_attr(ni, NULL, NULL, ATTR_LABEL, NULL, 0, NULL, NULL);

	if (!attr) {
		/* It is ok if no ATTR_LABEL */
	} else if (!attr->non_res && !is_attr_ext(attr)) {
1223
		/* $AttrDef allows labels to be up to 128 symbols. */
1224 1225 1226 1227 1228 1229 1230
		err = utf16s_to_utf8s(resident_data(attr),
				      le32_to_cpu(attr->res.data_size) >> 1,
				      UTF16_LITTLE_ENDIAN, sbi->volume.label,
				      sizeof(sbi->volume.label));
		if (err < 0)
			sbi->volume.label[0] = 0;
	} else {
1231
		/* Should we break mounting here? */
1232
		//err = -EINVAL;
1233
		//goto put_inode_out;
1234 1235 1236
	}

	attr = ni_find_attr(ni, attr, NULL, ATTR_VOL_INFO, NULL, 0, NULL, NULL);
1237 1238 1239
	if (!attr || is_attr_ext(attr) ||
	    !(info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO))) {
		ntfs_err(sb, "$Volume is corrupted.");
1240
		err = -EINVAL;
1241
		goto put_inode_out;
1242 1243 1244 1245 1246 1247
	}

	sbi->volume.major_ver = info->major_ver;
	sbi->volume.minor_ver = info->minor_ver;
	sbi->volume.flags = info->flags;
	sbi->volume.ni = ni;
1248 1249 1250 1251
	if (info->flags & VOLUME_FLAG_DIRTY) {
		sbi->volume.real_dirty = true;
		ntfs_info(sb, "It is recommened to use chkdsk.");
	}
1252

1253
	/* Load $MFTMirr to estimate recs_mirr. */
1254 1255 1256 1257
	ref.low = cpu_to_le32(MFT_REC_MIRR);
	ref.seq = cpu_to_le16(MFT_REC_MIRR);
	inode = ntfs_iget5(sb, &ref, &NAME_MIRROR);
	if (IS_ERR(inode)) {
1258
		err = PTR_ERR(inode);
1259
		ntfs_err(sb, "Failed to load $MFTMirr (%d).", err);
1260
		goto out;
1261 1262
	}

1263 1264
	sbi->mft.recs_mirr = ntfs_up_cluster(sbi, inode->i_size) >>
			     sbi->record_bits;
1265 1266 1267

	iput(inode);

1268
	/* Load LogFile to replay. */
1269 1270 1271 1272
	ref.low = cpu_to_le32(MFT_REC_LOG);
	ref.seq = cpu_to_le16(MFT_REC_LOG);
	inode = ntfs_iget5(sb, &ref, &NAME_LOGFILE);
	if (IS_ERR(inode)) {
1273
		err = PTR_ERR(inode);
1274
		ntfs_err(sb, "Failed to load \x24LogFile (%d).", err);
1275
		goto out;
1276 1277 1278 1279 1280 1281
	}

	ni = ntfs_i(inode);

	err = ntfs_loadlog_and_replay(ni, sbi);
	if (err)
1282
		goto put_inode_out;
1283 1284 1285

	iput(inode);

1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
	if ((sbi->flags & NTFS_FLAGS_NEED_REPLAY) && !ro) {
		ntfs_warn(sb, "failed to replay log file. Can't mount rw!");
		err = -EINVAL;
		goto out;
	}

	if ((sbi->volume.flags & VOLUME_FLAG_DIRTY) && !ro && !options->force) {
		ntfs_warn(sb, "volume is dirty and \"force\" flag is not set!");
		err = -EINVAL;
		goto out;
1296 1297
	}

1298
	/* Load $MFT. */
1299 1300 1301 1302 1303
	ref.low = cpu_to_le32(MFT_REC_MFT);
	ref.seq = cpu_to_le16(1);

	inode = ntfs_iget5(sb, &ref, &NAME_MFT);
	if (IS_ERR(inode)) {
1304
		err = PTR_ERR(inode);
1305
		ntfs_err(sb, "Failed to load $MFT (%d).", err);
1306
		goto out;
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
	}

	ni = ntfs_i(inode);

	sbi->mft.used = ni->i_valid >> sbi->record_bits;
	tt = inode->i_size >> sbi->record_bits;
	sbi->mft.next_free = MFT_REC_USER;

	err = wnd_init(&sbi->mft.bitmap, sb, tt);
	if (err)
1317
		goto put_inode_out;
1318 1319

	err = ni_load_all_mi(ni);
1320 1321
	if (err) {
		ntfs_err(sb, "Failed to load $MFT's subrecords (%d).", err);
1322
		goto put_inode_out;
1323
	}
1324 1325 1326

	sbi->mft.ni = ni;

1327
	/* Load $Bitmap. */
1328 1329 1330 1331
	ref.low = cpu_to_le32(MFT_REC_BITMAP);
	ref.seq = cpu_to_le16(MFT_REC_BITMAP);
	inode = ntfs_iget5(sb, &ref, &NAME_BITMAP);
	if (IS_ERR(inode)) {
1332
		err = PTR_ERR(inode);
1333
		ntfs_err(sb, "Failed to load $Bitmap (%d).", err);
1334
		goto out;
1335 1336 1337 1338 1339
	}

#ifndef CONFIG_NTFS3_64BIT_CLUSTER
	if (inode->i_size >> 32) {
		err = -EINVAL;
1340
		goto put_inode_out;
1341 1342 1343
	}
#endif

1344
	/* Check bitmap boundary. */
1345
	tt = sbi->used.bitmap.nbits;
1346
	if (inode->i_size < ntfs3_bitmap_size(tt)) {
1347
		ntfs_err(sb, "$Bitmap is corrupted.");
1348
		err = -EINVAL;
1349
		goto put_inode_out;
1350 1351
	}

1352
	err = wnd_init(&sbi->used.bitmap, sb, tt);
1353 1354
	if (err) {
		ntfs_err(sb, "Failed to initialize $Bitmap (%d).", err);
1355
		goto put_inode_out;
1356
	}
1357 1358 1359

	iput(inode);

1360
	/* Compute the MFT zone. */
1361
	err = ntfs_refresh_zone(sbi);
1362 1363
	if (err) {
		ntfs_err(sb, "Failed to initialize MFT zone (%d).", err);
1364
		goto out;
1365
	}
1366

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
	/* Load $BadClus. */
	ref.low = cpu_to_le32(MFT_REC_BADCLUST);
	ref.seq = cpu_to_le16(MFT_REC_BADCLUST);
	inode = ntfs_iget5(sb, &ref, &NAME_BADCLUS);
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		ntfs_err(sb, "Failed to load $BadClus (%d).", err);
		goto out;
	}

	ni = ntfs_i(inode);
	bad_len = bad_frags = 0;
	for (i = 0; run_get_entry(&ni->file.run, i, &vcn, &lcn, &len); i++) {
		if (lcn == SPARSE_LCN)
			continue;

		bad_len += len;
		bad_frags += 1;
1385
		if (ro)
1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
			continue;

		if (wnd_set_used_safe(&sbi->used.bitmap, lcn, len, &tt) || tt) {
			/* Bad blocks marked as free in bitmap. */
			ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
		}
	}
	if (bad_len) {
		/*
		 * Notice about bad blocks.
		 * In normal cases these blocks are marked as used in bitmap.
		 * And we never allocate space in it.
		 */
		ntfs_notice(sb,
			    "Volume contains %zu bad blocks in %zu fragments.",
			    bad_len, bad_frags);
	}
	iput(inode);

1405
	/* Load $AttrDef. */
1406 1407
	ref.low = cpu_to_le32(MFT_REC_ATTR);
	ref.seq = cpu_to_le16(MFT_REC_ATTR);
1408
	inode = ntfs_iget5(sb, &ref, &NAME_ATTRDEF);
1409
	if (IS_ERR(inode)) {
1410
		err = PTR_ERR(inode);
1411
		ntfs_err(sb, "Failed to load $AttrDef (%d)", err);
1412
		goto out;
1413 1414
	}

1415 1416
	/*
	 * Typical $AttrDef contains up to 20 entries.
1417
	 * Check for extremely large/small size.
1418 1419 1420 1421 1422
	 */
	if (inode->i_size < sizeof(struct ATTR_DEF_ENTRY) ||
	    inode->i_size > 100 * sizeof(struct ATTR_DEF_ENTRY)) {
		ntfs_err(sb, "Looks like $AttrDef is corrupted (size=%llu).",
			 inode->i_size);
1423
		err = -EINVAL;
1424
		goto put_inode_out;
1425
	}
1426

1427
	bytes = inode->i_size;
1428
	sbi->def_table = t = kvmalloc(bytes, GFP_KERNEL);
1429 1430
	if (!t) {
		err = -ENOMEM;
1431
		goto put_inode_out;
1432 1433
	}

1434 1435 1436 1437 1438 1439
	/* Read the entire file. */
	err = inode_read_data(inode, sbi->def_table, bytes);
	if (err) {
		ntfs_err(sb, "Failed to read $AttrDef (%d).", err);
		goto put_inode_out;
	}
1440

1441 1442 1443 1444
	if (ATTR_STD != t->type) {
		ntfs_err(sb, "$AttrDef is corrupted.");
		err = -EINVAL;
		goto put_inode_out;
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
	}

	t += 1;
	sbi->def_entries = 1;
	done = sizeof(struct ATTR_DEF_ENTRY);

	while (done + sizeof(struct ATTR_DEF_ENTRY) <= bytes) {
		u32 t32 = le32_to_cpu(t->type);
		u64 sz = le64_to_cpu(t->max_sz);

		if ((t32 & 0xF) || le32_to_cpu(t[-1].type) >= t32)
			break;

		if (t->type == ATTR_REPARSE)
			sbi->reparse.max_size = sz;
		else if (t->type == ATTR_EA)
			sbi->ea_max_size = sz;

		done += sizeof(struct ATTR_DEF_ENTRY);
		t += 1;
		sbi->def_entries += 1;
	}
	iput(inode);

1469
	/* Load $UpCase. */
1470 1471 1472 1473
	ref.low = cpu_to_le32(MFT_REC_UPCASE);
	ref.seq = cpu_to_le16(MFT_REC_UPCASE);
	inode = ntfs_iget5(sb, &ref, &NAME_UPCASE);
	if (IS_ERR(inode)) {
1474
		err = PTR_ERR(inode);
1475
		ntfs_err(sb, "Failed to load $UpCase (%d).", err);
1476
		goto out;
1477 1478 1479 1480
	}

	if (inode->i_size != 0x10000 * sizeof(short)) {
		err = -EINVAL;
1481
		ntfs_err(sb, "$UpCase is corrupted.");
1482
		goto put_inode_out;
1483 1484
	}

1485 1486 1487 1488 1489 1490
	/* Read the entire file. */
	err = inode_read_data(inode, sbi->upcase, 0x10000 * sizeof(short));
	if (err) {
		ntfs_err(sb, "Failed to read $UpCase (%d).", err);
		goto put_inode_out;
	}
1491 1492

#ifdef __BIG_ENDIAN
1493 1494 1495 1496 1497
	{
		const __le16 *src = sbi->upcase;
		u16 *dst = sbi->upcase;

		for (i = 0; i < 0x10000; i++)
1498 1499
			*dst++ = le16_to_cpu(*src++);
	}
1500
#endif
1501

1502 1503 1504
	shared = ntfs_set_shared(sbi->upcase, 0x10000 * sizeof(short));
	if (shared && sbi->upcase != shared) {
		kvfree(sbi->upcase);
1505 1506 1507 1508 1509 1510
		sbi->upcase = shared;
	}

	iput(inode);

	if (is_ntfs3(sbi)) {
1511
		/* Load $Secure. */
1512
		err = ntfs_security_init(sbi);
1513 1514
		if (err) {
			ntfs_err(sb, "Failed to initialize $Secure (%d).", err);
1515
			goto out;
1516
		}
1517

1518
		/* Load $Extend. */
1519
		err = ntfs_extend_init(sbi);
1520 1521
		if (err) {
			ntfs_warn(sb, "Failed to initialize $Extend.");
1522
			goto load_root;
1523
		}
1524

1525
		/* Load $Extend/$Reparse. */
1526
		err = ntfs_reparse_init(sbi);
1527 1528
		if (err) {
			ntfs_warn(sb, "Failed to initialize $Extend/$Reparse.");
1529
			goto load_root;
1530
		}
1531

1532
		/* Load $Extend/$ObjId. */
1533
		err = ntfs_objid_init(sbi);
1534 1535
		if (err) {
			ntfs_warn(sb, "Failed to initialize $Extend/$ObjId.");
1536
			goto load_root;
1537
		}
1538 1539 1540
	}

load_root:
1541
	/* Load root. */
1542 1543 1544
	ref.low = cpu_to_le32(MFT_REC_ROOT);
	ref.seq = cpu_to_le16(MFT_REC_ROOT);
	inode = ntfs_iget5(sb, &ref, &NAME_ROOT);
1545
	if (IS_ERR(inode)) {
1546 1547
		err = PTR_ERR(inode);
		ntfs_err(sb, "Failed to load root (%d).", err);
1548
		goto out;
1549 1550
	}

1551 1552 1553 1554 1555 1556 1557 1558 1559
	/*
	 * Final check. Looks like this case should never occurs.
	 */
	if (!inode->i_op) {
		err = -EINVAL;
		ntfs_err(sb, "Failed to load root (%d).", err);
		goto put_inode_out;
	}

1560
	sb->s_root = d_make_root(inode);
1561 1562 1563 1564
	if (!sb->s_root) {
		err = -ENOMEM;
		goto put_inode_out;
	}
1565

1566 1567
	if (boot2) {
		/*
1568 1569 1570
	 	 * Alternative boot is ok but primary is not ok.
	 	 * Volume is recognized as NTFS. Update primary boot.
		 */
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
		struct buffer_head *bh0 = sb_getblk(sb, 0);
		if (bh0) {
			if (buffer_locked(bh0))
				__wait_on_buffer(bh0);

			lock_buffer(bh0);
			memcpy(bh0->b_data, boot2, sizeof(*boot2));
			set_buffer_uptodate(bh0);
			mark_buffer_dirty(bh0);
			unlock_buffer(bh0);
			if (!sync_dirty_buffer(bh0))
				ntfs_warn(sb, "primary boot is updated");
			put_bh(bh0);
		}

		kfree(boot2);
	}

1589 1590 1591 1592
#ifdef CONFIG_PROC_FS
	/* Create /proc/fs/ntfs3/.. */
	if (proc_info_root) {
		struct proc_dir_entry *e = proc_mkdir(sb->s_id, proc_info_root);
1593
		static_assert((S_IRUGO | S_IWUSR) == 0644);
1594
		if (e) {
1595
			proc_create_data("volinfo", S_IRUGO, e,
1596
					 &ntfs3_volinfo_fops, sb);
1597 1598
			proc_create_data("label", S_IRUGO | S_IWUSR, e,
					 &ntfs3_label_fops, sb);
1599 1600 1601 1602 1603
			sbi->procdir = e;
		}
	}
#endif

1604 1605
	if (is_legacy_ntfs(sb))
		sb->s_flags |= SB_RDONLY;
1606
	return 0;
1607 1608

put_inode_out:
1609
	iput(inode);
1610
out:
1611
	ntfs3_put_sbi(sbi);
1612
	kfree(boot2);
1613
	ntfs3_put_sbi(sbi);
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
	return err;
}

void ntfs_unmap_meta(struct super_block *sb, CLST lcn, CLST len)
{
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	struct block_device *bdev = sb->s_bdev;
	sector_t devblock = (u64)lcn * sbi->blocks_per_cluster;
	unsigned long blocks = (u64)len * sbi->blocks_per_cluster;
	unsigned long cnt = 0;
	unsigned long limit = global_zone_page_state(NR_FREE_PAGES)
			      << (PAGE_SHIFT - sb->s_blocksize_bits);

	if (limit >= 0x2000)
		limit -= 0x1000;
	else if (limit < 32)
		limit = 32;
	else
		limit >>= 1;

	while (blocks--) {
		clean_bdev_aliases(bdev, devblock++, 1);
		if (cnt++ >= limit) {
			sync_blockdev(bdev);
			cnt = 0;
		}
	}
}

/*
1644
 * ntfs_discard - Issue a discard request (trim for SSD).
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
 */
int ntfs_discard(struct ntfs_sb_info *sbi, CLST lcn, CLST len)
{
	int err;
	u64 lbo, bytes, start, end;
	struct super_block *sb;

	if (sbi->used.next_free_lcn == lcn + len)
		sbi->used.next_free_lcn = lcn;

	if (sbi->flags & NTFS_FLAGS_NODISCARD)
		return -EOPNOTSUPP;

1658
	if (!sbi->options->discard)
1659 1660 1661 1662 1663
		return -EOPNOTSUPP;

	lbo = (u64)lcn << sbi->cluster_bits;
	bytes = (u64)len << sbi->cluster_bits;

1664
	/* Align up 'start' on discard_granularity. */
1665 1666
	start = (lbo + sbi->discard_granularity - 1) &
		sbi->discard_granularity_mask_inv;
1667
	/* Align down 'end' on discard_granularity. */
1668 1669 1670 1671 1672 1673 1674
	end = (lbo + bytes) & sbi->discard_granularity_mask_inv;

	sb = sbi->sb;
	if (start >= end)
		return 0;

	err = blkdev_issue_discard(sb->s_bdev, start >> 9, (end - start) >> 9,
1675
				   GFP_NOFS);
1676 1677 1678 1679 1680 1681 1682

	if (err == -EOPNOTSUPP)
		sbi->flags |= NTFS_FLAGS_NODISCARD;

	return err;
}

1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
static int ntfs_fs_get_tree(struct fs_context *fc)
{
	return get_tree_bdev(fc, ntfs_fill_super);
}

/*
 * ntfs_fs_free - Free fs_context.
 *
 * Note that this will be called after fill_super and reconfigure
 * even when they pass. So they have to take pointers if they pass.
 */
static void ntfs_fs_free(struct fs_context *fc)
{
	struct ntfs_mount_options *opts = fc->fs_private;
	struct ntfs_sb_info *sbi = fc->s_fs_info;

1699 1700
	if (sbi) {
		ntfs3_put_sbi(sbi);
1701
		ntfs3_free_sbi(sbi);
1702
	}
1703 1704 1705 1706 1707

	if (opts)
		put_mount_options(opts);
}

1708
// clang-format off
1709 1710 1711 1712 1713 1714
static const struct fs_context_operations ntfs_context_ops = {
	.parse_param	= ntfs_fs_parse_param,
	.get_tree	= ntfs_fs_get_tree,
	.reconfigure	= ntfs_fs_reconfigure,
	.free		= ntfs_fs_free,
};
1715
// clang-format on
1716 1717

/*
1718
 * ntfs_init_fs_context - Initialize sbi and opts
1719
 *
1720
 * This will called when mount/remount. We will first initialize
1721 1722
 * options so that if remount we can use just that.
 */
1723
static int __ntfs_init_fs_context(struct fs_context *fc)
1724
{
1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
	struct ntfs_mount_options *opts;
	struct ntfs_sb_info *sbi;

	opts = kzalloc(sizeof(struct ntfs_mount_options), GFP_NOFS);
	if (!opts)
		return -ENOMEM;

	/* Default options. */
	opts->fs_uid = current_uid();
	opts->fs_gid = current_gid();
	opts->fs_fmask_inv = ~current_umask();
	opts->fs_dmask_inv = ~current_umask();

	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE)
		goto ok;

	sbi = kzalloc(sizeof(struct ntfs_sb_info), GFP_NOFS);
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
	if (!sbi)
		goto free_opts;

	sbi->upcase = kvmalloc(0x10000 * sizeof(short), GFP_KERNEL);
	if (!sbi->upcase)
		goto free_sbi;

	ratelimit_state_init(&sbi->msg_ratelimit, DEFAULT_RATELIMIT_INTERVAL,
			     DEFAULT_RATELIMIT_BURST);

	mutex_init(&sbi->compress.mtx_lznt);
#ifdef CONFIG_NTFS3_LZX_XPRESS
	mutex_init(&sbi->compress.mtx_xpress);
	mutex_init(&sbi->compress.mtx_lzx);
#endif
1757 1758 1759 1760 1761 1762 1763

	fc->s_fs_info = sbi;
ok:
	fc->fs_private = opts;
	fc->ops = &ntfs_context_ops;

	return 0;
1764 1765
free_sbi:
	kfree(sbi);
1766 1767
free_opts:
	kfree(opts);
1768
	return -ENOMEM;
1769 1770
}

1771 1772 1773 1774 1775
static int ntfs_init_fs_context(struct fs_context *fc)
{
	return __ntfs_init_fs_context(fc);
}

1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
static void ntfs3_kill_sb(struct super_block *sb)
{
	struct ntfs_sb_info *sbi = sb->s_fs_info;

	kill_block_super(sb);

	if (sbi->options)
		put_mount_options(sbi->options);
	ntfs3_free_sbi(sbi);
}

1787 1788
// clang-format off
static struct file_system_type ntfs_fs_type = {
1789 1790 1791 1792
	.owner			= THIS_MODULE,
	.name			= "ntfs3",
	.init_fs_context	= ntfs_init_fs_context,
	.parameters		= ntfs_fs_parameters,
1793
	.kill_sb		= ntfs3_kill_sb,
1794
	.fs_flags		= FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
1795
};
1796 1797

#if IS_ENABLED(CONFIG_NTFS_FS)
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
static int ntfs_legacy_init_fs_context(struct fs_context *fc)
{
	int ret;

	ret = __ntfs_init_fs_context(fc);
	/* If ntfs3 is used as legacy ntfs enforce read-only mode. */
	fc->sb_flags |= SB_RDONLY;
	return ret;
}

1808 1809 1810
static struct file_system_type ntfs_legacy_fs_type = {
	.owner			= THIS_MODULE,
	.name			= "ntfs",
1811
	.init_fs_context	= ntfs_legacy_init_fs_context,
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828
	.parameters		= ntfs_fs_parameters,
	.kill_sb		= ntfs3_kill_sb,
	.fs_flags		= FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
};
MODULE_ALIAS_FS("ntfs");

static inline void register_as_ntfs_legacy(void)
{
	int err = register_filesystem(&ntfs_legacy_fs_type);
	if (err)
		pr_warn("ntfs3: Failed to register legacy ntfs filesystem driver: %d\n", err);
}

static inline void unregister_as_ntfs_legacy(void)
{
	unregister_filesystem(&ntfs_legacy_fs_type);
}
1829 1830 1831 1832
bool is_legacy_ntfs(struct super_block *sb)
{
	return sb->s_type == &ntfs_legacy_fs_type;
}
1833 1834 1835 1836 1837
#else
static inline void register_as_ntfs_legacy(void) {}
static inline void unregister_as_ntfs_legacy(void) {}
#endif

1838 1839 1840 1841 1842 1843
// clang-format on

static int __init init_ntfs_fs(void)
{
	int err;

1844 1845 1846
	if (IS_ENABLED(CONFIG_NTFS3_FS_POSIX_ACL))
		pr_info("ntfs3: Enabled Linux POSIX ACLs support\n");
	if (IS_ENABLED(CONFIG_NTFS3_64BIT_CLUSTER))
1847 1848
		pr_notice(
			"ntfs3: Warning: Activated 64 bits per cluster. Windows does not support this\n");
1849 1850
	if (IS_ENABLED(CONFIG_NTFS3_LZX_XPRESS))
		pr_info("ntfs3: Read-only LZX/Xpress compression included\n");
1851

1852 1853 1854 1855 1856
#ifdef CONFIG_PROC_FS
	/* Create "/proc/fs/ntfs3" */
	proc_info_root = proc_mkdir("fs/ntfs3", NULL);
#endif

1857 1858 1859 1860 1861 1862
	err = ntfs3_init_bitmap();
	if (err)
		return err;

	ntfs_inode_cachep = kmem_cache_create(
		"ntfs_inode_cache", sizeof(struct ntfs_inode), 0,
1863
		(SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT), init_once);
1864 1865 1866 1867 1868
	if (!ntfs_inode_cachep) {
		err = -ENOMEM;
		goto out1;
	}

1869
	register_as_ntfs_legacy();
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
	err = register_filesystem(&ntfs_fs_type);
	if (err)
		goto out;

	return 0;
out:
	kmem_cache_destroy(ntfs_inode_cachep);
out1:
	ntfs3_exit_bitmap();
	return err;
}

static void __exit exit_ntfs_fs(void)
{
1884 1885
	rcu_barrier();
	kmem_cache_destroy(ntfs_inode_cachep);
1886
	unregister_filesystem(&ntfs_fs_type);
1887
	unregister_as_ntfs_legacy();
1888
	ntfs3_exit_bitmap();
1889 1890 1891 1892 1893

#ifdef CONFIG_PROC_FS
	if (proc_info_root)
		remove_proc_entry("fs/ntfs3", NULL);
#endif
1894 1895 1896 1897 1898 1899 1900 1901
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("ntfs3 read/write filesystem");
#ifdef CONFIG_NTFS3_FS_POSIX_ACL
MODULE_INFO(behaviour, "Enabled Linux POSIX ACLs support");
#endif
#ifdef CONFIG_NTFS3_64BIT_CLUSTER
1902 1903 1904
MODULE_INFO(
	cluster,
	"Warning: Activated 64 bits per cluster. Windows does not support this");
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
#endif
#ifdef CONFIG_NTFS3_LZX_XPRESS
MODULE_INFO(compression, "Read-only lzx/xpress compression included");
#endif

MODULE_AUTHOR("Konstantin Komarov");
MODULE_ALIAS_FS("ntfs3");

module_init(init_ntfs_fs);
module_exit(exit_ntfs_fs);