[linux-2.6-block.git] / fs / erofs / super.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2017-2018 HUAWEI, Inc.
 *             http://www.huawei.com/
 * Created by Gao Xiang <gaoxiang25@huawei.com>
 */
#include <linux/module.h>
#include <linux/buffer_head.h>
#include <linux/statfs.h>
#include <linux/parser.h>
#include <linux/seq_file.h>
#include "xattr.h"

#define CREATE_TRACE_POINTS
#include <trace/events/erofs.h>

static struct kmem_cache *erofs_inode_cachep __read_mostly;

void _erofs_err(struct super_block *sb, const char *function,
		const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	pr_err("(device %s): %s: %pV", sb->s_id, function, &vaf);
	va_end(args);
}

void _erofs_info(struct super_block *sb, const char *function,
		 const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	pr_info("(device %s): %pV", sb->s_id, &vaf);
	va_end(args);
}

static void erofs_inode_init_once(void *ptr)
{
	struct erofs_inode *vi = ptr;

	inode_init_once(&vi->vfs_inode);
}

static struct inode *erofs_alloc_inode(struct super_block *sb)
{
	struct erofs_inode *vi =
		kmem_cache_alloc(erofs_inode_cachep, GFP_KERNEL);

	if (!vi)
		return NULL;

	/* zero out everything except vfs_inode */
	memset(vi, 0, offsetof(struct erofs_inode, vfs_inode));
	return &vi->vfs_inode;
}

static void erofs_free_inode(struct inode *inode)
{
	struct erofs_inode *vi = EROFS_I(inode);

	/* be careful of RCU symlink path */
	if (inode->i_op == &erofs_fast_symlink_iops)
		kfree(inode->i_link);
	kfree(vi->xattr_shared_xattrs);

	kmem_cache_free(erofs_inode_cachep, vi);
}

static bool check_layout_compatibility(struct super_block *sb,
				       struct erofs_super_block *dsb)
{
	const unsigned int feature = le32_to_cpu(dsb->feature_incompat);

	EROFS_SB(sb)->feature_incompat = feature;

	/* check if current kernel meets all mandatory requirements */
	if (feature & (~EROFS_ALL_FEATURE_INCOMPAT)) {
		erofs_err(sb,
			  "unidentified incompatible feature %x, please upgrade kernel version",
			   feature & ~EROFS_ALL_FEATURE_INCOMPAT);
		return false;
	}
	return true;
}

static int erofs_read_superblock(struct super_block *sb)
{
	struct erofs_sb_info *sbi;
	struct page *page;
	struct erofs_super_block *dsb;
	unsigned int blkszbits;
	void *data;
	int ret;

	page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL);
	if (!page) {
		erofs_err(sb, "cannot read erofs superblock");
		return -EIO;
	}

	sbi = EROFS_SB(sb);

	data = kmap_atomic(page);
	dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET);

	ret = -EINVAL;
	if (le32_to_cpu(dsb->magic) != EROFS_SUPER_MAGIC_V1) {
		erofs_err(sb, "cannot find valid erofs superblock");
		goto out;
	}

	blkszbits = dsb->blkszbits;
	/* 9(512 bytes) + LOG_SECTORS_PER_BLOCK == LOG_BLOCK_SIZE */
	if (blkszbits != LOG_BLOCK_SIZE) {
		erofs_err(sb, "blksize %u isn't supported on this platform",
			  1 << blkszbits);
		goto out;
	}

	if (!check_layout_compatibility(sb, dsb))
		goto out;

	sbi->blocks = le32_to_cpu(dsb->blocks);
	sbi->meta_blkaddr = le32_to_cpu(dsb->meta_blkaddr);
#ifdef CONFIG_EROFS_FS_XATTR
	sbi->xattr_blkaddr = le32_to_cpu(dsb->xattr_blkaddr);
#endif
	sbi->islotbits = ilog2(sizeof(struct erofs_inode_compact));
	sbi->root_nid = le16_to_cpu(dsb->root_nid);
	sbi->inos = le64_to_cpu(dsb->inos);

	sbi->build_time = le64_to_cpu(dsb->build_time);
	sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec);

	memcpy(&sb->s_uuid, dsb->uuid, sizeof(dsb->uuid));

	ret = strscpy(sbi->volume_name, dsb->volume_name,
		      sizeof(dsb->volume_name));
	if (ret < 0) {	/* -E2BIG */
		erofs_err(sb, "bad volume name without NIL terminator");
		ret = -EFSCORRUPTED;
		goto out;
	}
	ret = 0;
out:
	kunmap_atomic(data);
	put_page(page);
	return ret;
}

#ifdef CONFIG_EROFS_FS_ZIP
static int erofs_build_cache_strategy(struct super_block *sb,
				      substring_t *args)
{
	struct erofs_sb_info *sbi = EROFS_SB(sb);
	const char *cs = match_strdup(args);
	int err = 0;

	if (!cs) {
		erofs_err(sb, "Not enough memory to store cache strategy");
		return -ENOMEM;
	}

	if (!strcmp(cs, "disabled")) {
		sbi->cache_strategy = EROFS_ZIP_CACHE_DISABLED;
	} else if (!strcmp(cs, "readahead")) {
		sbi->cache_strategy = EROFS_ZIP_CACHE_READAHEAD;
	} else if (!strcmp(cs, "readaround")) {
		sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
	} else {
		erofs_err(sb, "Unrecognized cache strategy \"%s\"", cs);
		err = -EINVAL;
	}
	kfree(cs);
	return err;
}
#else
static int erofs_build_cache_strategy(struct super_block *sb,
				      substring_t *args)
{
	erofs_info(sb, "EROFS compression is disabled, so cache strategy is ignored");
	return 0;
}
#endif

/* set up default EROFS parameters */
static void erofs_default_options(struct erofs_sb_info *sbi)
{
#ifdef CONFIG_EROFS_FS_ZIP
	sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
	sbi->max_sync_decompress_pages = 3;
#endif
#ifdef CONFIG_EROFS_FS_XATTR
	set_opt(sbi, XATTR_USER);
#endif
#ifdef CONFIG_EROFS_FS_POSIX_ACL
	set_opt(sbi, POSIX_ACL);
#endif
}

enum {
	Opt_user_xattr,
	Opt_nouser_xattr,
	Opt_acl,
	Opt_noacl,
	Opt_cache_strategy,
	Opt_err
};

static match_table_t erofs_tokens = {
	{Opt_user_xattr, "user_xattr"},
	{Opt_nouser_xattr, "nouser_xattr"},
	{Opt_acl, "acl"},
	{Opt_noacl, "noacl"},
	{Opt_cache_strategy, "cache_strategy=%s"},
	{Opt_err, NULL}
};

static int erofs_parse_options(struct super_block *sb, char *options)
{
	substring_t args[MAX_OPT_ARGS];
	char *p;
	int err;

	if (!options)
		return 0;

	while ((p = strsep(&options, ","))) {
		int token;

		if (!*p)
			continue;

		args[0].to = args[0].from = NULL;
		token = match_token(p, erofs_tokens, args);

		switch (token) {
#ifdef CONFIG_EROFS_FS_XATTR
		case Opt_user_xattr:
			set_opt(EROFS_SB(sb), XATTR_USER);
			break;
		case Opt_nouser_xattr:
			clear_opt(EROFS_SB(sb), XATTR_USER);
			break;
#else
		case Opt_user_xattr:
			erofs_info(sb, "user_xattr options not supported");
			break;
		case Opt_nouser_xattr:
			erofs_info(sb, "nouser_xattr options not supported");
			break;
#endif
#ifdef CONFIG_EROFS_FS_POSIX_ACL
		case Opt_acl:
			set_opt(EROFS_SB(sb), POSIX_ACL);
			break;
		case Opt_noacl:
			clear_opt(EROFS_SB(sb), POSIX_ACL);
			break;
#else
		case Opt_acl:
			erofs_info(sb, "acl options not supported");
			break;
		case Opt_noacl:
			erofs_info(sb, "noacl options not supported");
			break;
#endif
		case Opt_cache_strategy:
			err = erofs_build_cache_strategy(sb, args);
			if (err)
				return err;
			break;
		default:
			erofs_err(sb, "Unrecognized mount option \"%s\" or missing value", p);
			return -EINVAL;
		}
	}
	return 0;
}

#ifdef CONFIG_EROFS_FS_ZIP
static const struct address_space_operations managed_cache_aops;

static int erofs_managed_cache_releasepage(struct page *page, gfp_t gfp_mask)
{
	int ret = 1;	/* 0 - busy */
	struct address_space *const mapping = page->mapping;

	DBG_BUGON(!PageLocked(page));
	DBG_BUGON(mapping->a_ops != &managed_cache_aops);

	if (PagePrivate(page))
		ret = erofs_try_to_free_cached_page(mapping, page);

	return ret;
}

static void erofs_managed_cache_invalidatepage(struct page *page,
					       unsigned int offset,
					       unsigned int length)
{
	const unsigned int stop = length + offset;

	DBG_BUGON(!PageLocked(page));

	/* Check for potential overflow in debug mode */
	DBG_BUGON(stop > PAGE_SIZE || stop < length);

	if (offset == 0 && stop == PAGE_SIZE)
		while (!erofs_managed_cache_releasepage(page, GFP_NOFS))
			cond_resched();
}

static const struct address_space_operations managed_cache_aops = {
	.releasepage = erofs_managed_cache_releasepage,
	.invalidatepage = erofs_managed_cache_invalidatepage,
};

static int erofs_init_managed_cache(struct super_block *sb)
{
	struct erofs_sb_info *const sbi = EROFS_SB(sb);
	struct inode *const inode = new_inode(sb);

	if (!inode)
		return -ENOMEM;

	set_nlink(inode, 1);
	inode->i_size = OFFSET_MAX;

	inode->i_mapping->a_ops = &managed_cache_aops;
	mapping_set_gfp_mask(inode->i_mapping,
			     GFP_NOFS | __GFP_HIGHMEM | __GFP_MOVABLE);
	sbi->managed_cache = inode;
	return 0;
}
#else
static int erofs_init_managed_cache(struct super_block *sb) { return 0; }
#endif

static int erofs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *inode;
	struct erofs_sb_info *sbi;
	int err;

	sb->s_magic = EROFS_SUPER_MAGIC;

	if (!sb_set_blocksize(sb, EROFS_BLKSIZ)) {
		erofs_err(sb, "failed to set erofs blksize");
		return -EINVAL;
	}

	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

	sb->s_fs_info = sbi;
	err = erofs_read_superblock(sb);
	if (err)
		return err;

	sb->s_flags |= SB_RDONLY | SB_NOATIME;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_time_gran = 1;

	sb->s_op = &erofs_sops;

#ifdef CONFIG_EROFS_FS_XATTR
	sb->s_xattr = erofs_xattr_handlers;
#endif
	/* set erofs default mount options */
	erofs_default_options(sbi);

	err = erofs_parse_options(sb, data);
	if (err)
		return err;

	if (test_opt(sbi, POSIX_ACL))
		sb->s_flags |= SB_POSIXACL;
	else
		sb->s_flags &= ~SB_POSIXACL;

#ifdef CONFIG_EROFS_FS_ZIP
	INIT_RADIX_TREE(&sbi->workstn_tree, GFP_ATOMIC);
#endif

	/* get the root inode */
	inode = erofs_iget(sb, ROOT_NID(sbi), true);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	if (!S_ISDIR(inode->i_mode)) {
		erofs_err(sb, "rootino(nid %llu) is not a directory(i_mode %o)",
			  ROOT_NID(sbi), inode->i_mode);
		iput(inode);
		return -EINVAL;
	}

	sb->s_root = d_make_root(inode);
	if (!sb->s_root)
		return -ENOMEM;

	erofs_shrinker_register(sb);
	/* sb->s_umount is already locked, SB_ACTIVE and SB_BORN are not set */
	err = erofs_init_managed_cache(sb);
	if (err)
		return err;

	erofs_info(sb, "mounted with opts: %s, root inode @ nid %llu.",
		   (char *)data, ROOT_NID(sbi));
	return 0;
}

static struct dentry *erofs_mount(struct file_system_type *fs_type, int flags,
				  const char *dev_name, void *data)
{
	return mount_bdev(fs_type, flags, dev_name, data, erofs_fill_super);
}

/*
 * could be triggered after deactivate_locked_super()
 * is called, thus including umount and failed to initialize.
 */
static void erofs_kill_sb(struct super_block *sb)
{
	struct erofs_sb_info *sbi;

	WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC);

	kill_block_super(sb);

	sbi = EROFS_SB(sb);
	if (!sbi)
		return;
	kfree(sbi);
	sb->s_fs_info = NULL;
}

/* called when ->s_root is non-NULL */
static void erofs_put_super(struct super_block *sb)
{
	struct erofs_sb_info *const sbi = EROFS_SB(sb);

	DBG_BUGON(!sbi);

	erofs_shrinker_unregister(sb);
#ifdef CONFIG_EROFS_FS_ZIP
	iput(sbi->managed_cache);
	sbi->managed_cache = NULL;
#endif
}

static struct file_system_type erofs_fs_type = {
	.owner          = THIS_MODULE,
	.name           = "erofs",
	.mount          = erofs_mount,
	.kill_sb        = erofs_kill_sb,
	.fs_flags       = FS_REQUIRES_DEV,
};
MODULE_ALIAS_FS("erofs");

static int __init erofs_module_init(void)
{
	int err;

	erofs_check_ondisk_layout_definitions();

	erofs_inode_cachep = kmem_cache_create("erofs_inode",
					       sizeof(struct erofs_inode), 0,
					       SLAB_RECLAIM_ACCOUNT,
					       erofs_inode_init_once);
	if (!erofs_inode_cachep) {
		err = -ENOMEM;
		goto icache_err;
	}

	err = erofs_init_shrinker();
	if (err)
		goto shrinker_err;

	err = z_erofs_init_zip_subsystem();
	if (err)
		goto zip_err;

	err = register_filesystem(&erofs_fs_type);
	if (err)
		goto fs_err;

	return 0;

fs_err:
	z_erofs_exit_zip_subsystem();
zip_err:
	erofs_exit_shrinker();
shrinker_err:
	kmem_cache_destroy(erofs_inode_cachep);
icache_err:
	return err;
}

static void __exit erofs_module_exit(void)
{
	unregister_filesystem(&erofs_fs_type);
	z_erofs_exit_zip_subsystem();
	erofs_exit_shrinker();

	/* Ensure all RCU free inodes are safe before cache is destroyed. */
	rcu_barrier();
	kmem_cache_destroy(erofs_inode_cachep);
}

/* get filesystem statistics */
static int erofs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct erofs_sb_info *sbi = EROFS_SB(sb);
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);

	buf->f_type = sb->s_magic;
	buf->f_bsize = EROFS_BLKSIZ;
	buf->f_blocks = sbi->blocks;
	buf->f_bfree = buf->f_bavail = 0;

	buf->f_files = ULLONG_MAX;
	buf->f_ffree = ULLONG_MAX - sbi->inos;

	buf->f_namelen = EROFS_NAME_LEN;

	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);
	return 0;
}

static int erofs_show_options(struct seq_file *seq, struct dentry *root)
{
	struct erofs_sb_info *sbi __maybe_unused = EROFS_SB(root->d_sb);

#ifdef CONFIG_EROFS_FS_XATTR
	if (test_opt(sbi, XATTR_USER))
		seq_puts(seq, ",user_xattr");
	else
		seq_puts(seq, ",nouser_xattr");
#endif
#ifdef CONFIG_EROFS_FS_POSIX_ACL
	if (test_opt(sbi, POSIX_ACL))
		seq_puts(seq, ",acl");
	else
		seq_puts(seq, ",noacl");
#endif
#ifdef CONFIG_EROFS_FS_ZIP
	if (sbi->cache_strategy == EROFS_ZIP_CACHE_DISABLED) {
		seq_puts(seq, ",cache_strategy=disabled");
	} else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAHEAD) {
		seq_puts(seq, ",cache_strategy=readahead");
	} else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAROUND) {
		seq_puts(seq, ",cache_strategy=readaround");
	} else {
		seq_puts(seq, ",cache_strategy=(unknown)");
		DBG_BUGON(1);
	}
#endif
	return 0;
}

static int erofs_remount(struct super_block *sb, int *flags, char *data)
{
	struct erofs_sb_info *sbi = EROFS_SB(sb);
	unsigned int org_mnt_opt = sbi->mount_opt;
	int err;

	DBG_BUGON(!sb_rdonly(sb));
	err = erofs_parse_options(sb, data);
	if (err)
		goto out;

	if (test_opt(sbi, POSIX_ACL))
		sb->s_flags |= SB_POSIXACL;
	else
		sb->s_flags &= ~SB_POSIXACL;

	*flags |= SB_RDONLY;
	return 0;
out:
	sbi->mount_opt = org_mnt_opt;
	return err;
}

const struct super_operations erofs_sops = {
	.put_super = erofs_put_super,
	.alloc_inode = erofs_alloc_inode,
	.free_inode = erofs_free_inode,
	.statfs = erofs_statfs,
	.show_options = erofs_show_options,
	.remount_fs = erofs_remount,
};

module_init(erofs_module_init);
module_exit(erofs_module_exit);

MODULE_DESCRIPTION("Enhanced ROM File System");
MODULE_AUTHOR("Gao Xiang, Chao Yu, Miao Xie, CONSUMER BG, HUAWEI Inc.");
MODULE_LICENSE("GPL");
Commit	Line	Data
29b24f6c	1	// SPDX-License-Identifier: GPL-2.0-only
ba2b77a8	2	/*
ba2b77a8 GX	3	* Copyright (C) 2017-2018 HUAWEI, Inc.
	4	* http://www.huawei.com/
	5	* Created by Gao Xiang <gaoxiang25@huawei.com>
ba2b77a8 GX	6	*/
	7	#include <linux/module.h>
	8	#include <linux/buffer_head.h>
	9	#include <linux/statfs.h>
	10	#include <linux/parser.h>
b17500a0	11	#include <linux/seq_file.h>
6af7b483	12	#include "xattr.h"
ba2b77a8	13
13f06f48 CY	14	#define CREATE_TRACE_POINTS
	15	#include <trace/events/erofs.h>
	16
ba2b77a8 GX	17	static struct kmem_cache *erofs_inode_cachep __read_mostly;
ba2b77a8 GX	18
4f761fa2 GX	19	void _erofs_err(struct super_block sb, const char function,
	20	const char *fmt, ...)
	21	{
	22	struct va_format vaf;
	23	va_list args;
	24
	25	va_start(args, fmt);
	26
	27	vaf.fmt = fmt;
	28	vaf.va = &args;
	29
	30	pr_err("(device %s): %s: %pV", sb->s_id, function, &vaf);
	31	va_end(args);
	32	}
	33
	34	void _erofs_info(struct super_block sb, const char function,
	35	const char *fmt, ...)
	36	{
	37	struct va_format vaf;
	38	va_list args;
	39
	40	va_start(args, fmt);
	41
	42	vaf.fmt = fmt;
	43	vaf.va = &args;
	44
	45	pr_info("(device %s): %pV", sb->s_id, &vaf);
	46	va_end(args);
	47	}
	48
99634bf3	49	static void erofs_inode_init_once(void *ptr)
ba2b77a8	50	{
a5876e24	51	struct erofs_inode *vi = ptr;
ba2b77a8 GX	52
	53	inode_init_once(&vi->vfs_inode);
	54	}
	55
99634bf3	56	static struct inode erofs_alloc_inode(struct super_block sb)
ba2b77a8	57	{
a5876e24	58	struct erofs_inode *vi =
ba2b77a8 GX	59	kmem_cache_alloc(erofs_inode_cachep, GFP_KERNEL);
ba2b77a8 GX	60
e2ff9f15	61	if (!vi)
ba2b77a8 GX	62	return NULL;
	63
	64	/* zero out everything except vfs_inode */
a5876e24	65	memset(vi, 0, offsetof(struct erofs_inode, vfs_inode));
ba2b77a8 GX	66	return &vi->vfs_inode;
	67	}
	68
99634bf3	69	static void erofs_free_inode(struct inode *inode)
ba2b77a8	70	{
a5876e24	71	struct erofs_inode *vi = EROFS_I(inode);
ba2b77a8	72
a2c75c81 GX	73	/* be careful of RCU symlink path */
a2c75c81 GX	74	if (inode->i_op == &erofs_fast_symlink_iops)
ba2b77a8	75	kfree(inode->i_link);
ba2b77a8 GX	76	kfree(vi->xattr_shared_xattrs);
	77
	78	kmem_cache_free(erofs_inode_cachep, vi);
	79	}
	80
5efe5137	81	static bool check_layout_compatibility(struct super_block *sb,
0259f209	82	struct erofs_super_block *dsb)
5efe5137	83	{
0259f209	84	const unsigned int feature = le32_to_cpu(dsb->feature_incompat);
5efe5137	85
426a9308	86	EROFS_SB(sb)->feature_incompat = feature;
5efe5137 GX	87
5efe5137 GX	88	/* check if current kernel meets all mandatory requirements */
426a9308	89	if (feature & (~EROFS_ALL_FEATURE_INCOMPAT)) {
4f761fa2 GX	90	erofs_err(sb,
	91	"unidentified incompatible feature %x, please upgrade kernel version",
	92	feature & ~EROFS_ALL_FEATURE_INCOMPAT);
5efe5137 GX	93	return false;
	94	}
	95	return true;
	96	}
	97
99634bf3	98	static int erofs_read_superblock(struct super_block *sb)
ba2b77a8 GX	99	{
ba2b77a8 GX	100	struct erofs_sb_info *sbi;
fe7c2423	101	struct page *page;
0259f209	102	struct erofs_super_block *dsb;
7dd68b14	103	unsigned int blkszbits;
fe7c2423	104	void *data;
ba2b77a8 GX	105	int ret;
ba2b77a8 GX	106
fe7c2423 GX	107	page = read_mapping_page(sb->s_bdev->bd_inode->i_mapping, 0, NULL);
fe7c2423 GX	108	if (!page) {
4f761fa2	109	erofs_err(sb, "cannot read erofs superblock");
ba2b77a8 GX	110	return -EIO;
	111	}
	112
	113	sbi = EROFS_SB(sb);
fe7c2423 GX	114
	115	data = kmap_atomic(page);
	116	dsb = (struct erofs_super_block *)(data + EROFS_SUPER_OFFSET);
ba2b77a8 GX	117
ba2b77a8 GX	118	ret = -EINVAL;
0259f209	119	if (le32_to_cpu(dsb->magic) != EROFS_SUPER_MAGIC_V1) {
4f761fa2	120	erofs_err(sb, "cannot find valid erofs superblock");
ba2b77a8 GX	121	goto out;
	122	}
	123
0259f209	124	blkszbits = dsb->blkszbits;
ba2b77a8	125	/* 9(512 bytes) + LOG_SECTORS_PER_BLOCK == LOG_BLOCK_SIZE */
8d8a09b0	126	if (blkszbits != LOG_BLOCK_SIZE) {
4f761fa2 GX	127	erofs_err(sb, "blksize %u isn't supported on this platform",
4f761fa2 GX	128	1 << blkszbits);
ba2b77a8 GX	129	goto out;
	130	}
	131
0259f209	132	if (!check_layout_compatibility(sb, dsb))
5efe5137 GX	133	goto out;
5efe5137 GX	134
0259f209 GX	135	sbi->blocks = le32_to_cpu(dsb->blocks);
0259f209 GX	136	sbi->meta_blkaddr = le32_to_cpu(dsb->meta_blkaddr);
b17500a0	137	#ifdef CONFIG_EROFS_FS_XATTR
0259f209	138	sbi->xattr_blkaddr = le32_to_cpu(dsb->xattr_blkaddr);
b17500a0	139	#endif
8a765682	140	sbi->islotbits = ilog2(sizeof(struct erofs_inode_compact));
0259f209 GX	141	sbi->root_nid = le16_to_cpu(dsb->root_nid);
0259f209 GX	142	sbi->inos = le64_to_cpu(dsb->inos);
ba2b77a8	143
0259f209 GX	144	sbi->build_time = le64_to_cpu(dsb->build_time);
0259f209 GX	145	sbi->build_time_nsec = le32_to_cpu(dsb->build_time_nsec);
ba2b77a8	146
0259f209	147	memcpy(&sb->s_uuid, dsb->uuid, sizeof(dsb->uuid));
ba2b77a8	148
0259f209 GX	149	ret = strscpy(sbi->volume_name, dsb->volume_name,
0259f209 GX	150	sizeof(dsb->volume_name));
a64d9493	151	if (ret < 0) { /* -E2BIG */
4f761fa2	152	erofs_err(sb, "bad volume name without NIL terminator");
a64d9493 GX	153	ret = -EFSCORRUPTED;
	154	goto out;
	155	}
ba2b77a8 GX	156	ret = 0;
ba2b77a8 GX	157	out:
fe7c2423 GX	158	kunmap_atomic(data);
fe7c2423 GX	159	put_page(page);
ba2b77a8 GX	160	return ret;
	161	}
	162
4279f3f9	163	#ifdef CONFIG_EROFS_FS_ZIP
4f761fa2	164	static int erofs_build_cache_strategy(struct super_block *sb,
4279f3f9 GX	165	substring_t *args)
4279f3f9 GX	166	{
4f761fa2	167	struct erofs_sb_info *sbi = EROFS_SB(sb);
4279f3f9 GX	168	const char *cs = match_strdup(args);
	169	int err = 0;
	170
	171	if (!cs) {
4f761fa2	172	erofs_err(sb, "Not enough memory to store cache strategy");
4279f3f9 GX	173	return -ENOMEM;
	174	}
	175
	176	if (!strcmp(cs, "disabled")) {
	177	sbi->cache_strategy = EROFS_ZIP_CACHE_DISABLED;
	178	} else if (!strcmp(cs, "readahead")) {
	179	sbi->cache_strategy = EROFS_ZIP_CACHE_READAHEAD;
	180	} else if (!strcmp(cs, "readaround")) {
	181	sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
	182	} else {
4f761fa2	183	erofs_err(sb, "Unrecognized cache strategy \"%s\"", cs);
4279f3f9 GX	184	err = -EINVAL;
	185	}
	186	kfree(cs);
	187	return err;
	188	}
	189	#else
4f761fa2	190	static int erofs_build_cache_strategy(struct super_block *sb,
4279f3f9 GX	191	substring_t *args)
4279f3f9 GX	192	{
4f761fa2	193	erofs_info(sb, "EROFS compression is disabled, so cache strategy is ignored");
4279f3f9 GX	194	return 0;
	195	}
	196	#endif
	197
	198	/* set up default EROFS parameters */
99634bf3	199	static void erofs_default_options(struct erofs_sb_info *sbi)
ba2b77a8	200	{
5fb76bb0	201	#ifdef CONFIG_EROFS_FS_ZIP
4279f3f9	202	sbi->cache_strategy = EROFS_ZIP_CACHE_READAROUND;
14f362b4	203	sbi->max_sync_decompress_pages = 3;
5fb76bb0	204	#endif
b17500a0 GX	205	#ifdef CONFIG_EROFS_FS_XATTR
	206	set_opt(sbi, XATTR_USER);
	207	#endif
b17500a0 GX	208	#ifdef CONFIG_EROFS_FS_POSIX_ACL
	209	set_opt(sbi, POSIX_ACL);
	210	#endif
ba2b77a8 GX	211	}
	212
	213	enum {
b17500a0 GX	214	Opt_user_xattr,
	215	Opt_nouser_xattr,
	216	Opt_acl,
	217	Opt_noacl,
4279f3f9	218	Opt_cache_strategy,
ba2b77a8 GX	219	Opt_err
	220	};
	221
	222	static match_table_t erofs_tokens = {
b17500a0 GX	223	{Opt_user_xattr, "user_xattr"},
	224	{Opt_nouser_xattr, "nouser_xattr"},
	225	{Opt_acl, "acl"},
	226	{Opt_noacl, "noacl"},
4279f3f9	227	{Opt_cache_strategy, "cache_strategy=%s"},
ba2b77a8 GX	228	{Opt_err, NULL}
	229	};
	230
99634bf3	231	static int erofs_parse_options(struct super_block sb, char options)
ba2b77a8 GX	232	{
	233	substring_t args[MAX_OPT_ARGS];
	234	char *p;
01e4ae4b	235	int err;
ba2b77a8 GX	236
	237	if (!options)
	238	return 0;
	239
561fb35a	240	while ((p = strsep(&options, ","))) {
ba2b77a8 GX	241	int token;
	242
	243	if (!*p)
	244	continue;
	245
	246	args[0].to = args[0].from = NULL;
	247	token = match_token(p, erofs_tokens, args);
	248
	249	switch (token) {
b17500a0 GX	250	#ifdef CONFIG_EROFS_FS_XATTR
	251	case Opt_user_xattr:
	252	set_opt(EROFS_SB(sb), XATTR_USER);
	253	break;
	254	case Opt_nouser_xattr:
	255	clear_opt(EROFS_SB(sb), XATTR_USER);
	256	break;
	257	#else
	258	case Opt_user_xattr:
4f761fa2	259	erofs_info(sb, "user_xattr options not supported");
b17500a0 GX	260	break;
b17500a0 GX	261	case Opt_nouser_xattr:
4f761fa2	262	erofs_info(sb, "nouser_xattr options not supported");
b17500a0 GX	263	break;
	264	#endif
	265	#ifdef CONFIG_EROFS_FS_POSIX_ACL
	266	case Opt_acl:
	267	set_opt(EROFS_SB(sb), POSIX_ACL);
	268	break;
	269	case Opt_noacl:
	270	clear_opt(EROFS_SB(sb), POSIX_ACL);
	271	break;
	272	#else
	273	case Opt_acl:
4f761fa2	274	erofs_info(sb, "acl options not supported");
b17500a0 GX	275	break;
b17500a0 GX	276	case Opt_noacl:
4f761fa2	277	erofs_info(sb, "noacl options not supported");
b17500a0 GX	278	break;
b17500a0 GX	279	#endif
4279f3f9	280	case Opt_cache_strategy:
4f761fa2	281	err = erofs_build_cache_strategy(sb, args);
4279f3f9 GX	282	if (err)
	283	return err;
	284	break;
ba2b77a8	285	default:
4f761fa2	286	erofs_err(sb, "Unrecognized mount option \"%s\" or missing value", p);
ba2b77a8 GX	287	return -EINVAL;
	288	}
	289	}
	290	return 0;
	291	}
	292
4279f3f9	293	#ifdef CONFIG_EROFS_FS_ZIP
105d4ad8 GX	294	static const struct address_space_operations managed_cache_aops;
105d4ad8 GX	295
99634bf3	296	static int erofs_managed_cache_releasepage(struct page *page, gfp_t gfp_mask)
105d4ad8 GX	297	{
	298	int ret = 1; /* 0 - busy */
	299	struct address_space *const mapping = page->mapping;
	300
8b987bca GX	301	DBG_BUGON(!PageLocked(page));
8b987bca GX	302	DBG_BUGON(mapping->a_ops != &managed_cache_aops);
105d4ad8 GX	303
105d4ad8 GX	304	if (PagePrivate(page))
47e541a1	305	ret = erofs_try_to_free_cached_page(mapping, page);
105d4ad8 GX	306
	307	return ret;
	308	}
	309
99634bf3 GX	310	static void erofs_managed_cache_invalidatepage(struct page *page,
	311	unsigned int offset,
	312	unsigned int length)
105d4ad8 GX	313	{
	314	const unsigned int stop = length + offset;
	315
8b987bca	316	DBG_BUGON(!PageLocked(page));
105d4ad8	317
8b987bca GX	318	/* Check for potential overflow in debug mode */
8b987bca GX	319	DBG_BUGON(stop > PAGE_SIZE \|\| stop < length);
105d4ad8 GX	320
105d4ad8 GX	321	if (offset == 0 && stop == PAGE_SIZE)
99634bf3	322	while (!erofs_managed_cache_releasepage(page, GFP_NOFS))
105d4ad8 GX	323	cond_resched();
	324	}
	325
	326	static const struct address_space_operations managed_cache_aops = {
99634bf3 GX	327	.releasepage = erofs_managed_cache_releasepage,
99634bf3 GX	328	.invalidatepage = erofs_managed_cache_invalidatepage,
105d4ad8 GX	329	};
105d4ad8 GX	330
8f7acdae	331	static int erofs_init_managed_cache(struct super_block *sb)
105d4ad8	332	{
8f7acdae GX	333	struct erofs_sb_info *const sbi = EROFS_SB(sb);
8f7acdae GX	334	struct inode *const inode = new_inode(sb);
105d4ad8	335
8d8a09b0	336	if (!inode)
8f7acdae	337	return -ENOMEM;
105d4ad8 GX	338
	339	set_nlink(inode, 1);
	340	inode->i_size = OFFSET_MAX;
	341
	342	inode->i_mapping->a_ops = &managed_cache_aops;
	343	mapping_set_gfp_mask(inode->i_mapping,
8494c29f	344	GFP_NOFS \| __GFP_HIGHMEM \| __GFP_MOVABLE);
8f7acdae GX	345	sbi->managed_cache = inode;
8f7acdae GX	346	return 0;
105d4ad8	347	}
8f7acdae GX	348	#else
8f7acdae GX	349	static int erofs_init_managed_cache(struct super_block *sb) { return 0; }
105d4ad8 GX	350	#endif
105d4ad8 GX	351
9e794de5	352	static int erofs_fill_super(struct super_block sb, void data, int silent)
ba2b77a8 GX	353	{
	354	struct inode *inode;
	355	struct erofs_sb_info *sbi;
8f7acdae	356	int err;
ba2b77a8	357
8f7acdae GX	358	sb->s_magic = EROFS_SUPER_MAGIC;
8f7acdae GX	359
8d8a09b0	360	if (!sb_set_blocksize(sb, EROFS_BLKSIZ)) {
4f761fa2	361	erofs_err(sb, "failed to set erofs blksize");
8f7acdae	362	return -EINVAL;
ba2b77a8 GX	363	}
ba2b77a8 GX	364
a9f69bd5	365	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
8d8a09b0	366	if (!sbi)
8f7acdae	367	return -ENOMEM;
ba2b77a8	368
8f7acdae	369	sb->s_fs_info = sbi;
99634bf3	370	err = erofs_read_superblock(sb);
ba2b77a8	371	if (err)
8f7acdae	372	return err;
ba2b77a8	373
5f0abea6	374	sb->s_flags \|= SB_RDONLY \| SB_NOATIME;
ba2b77a8 GX	375	sb->s_maxbytes = MAX_LFS_FILESIZE;
	376	sb->s_time_gran = 1;
	377
	378	sb->s_op = &erofs_sops;
	379
b17500a0 GX	380	#ifdef CONFIG_EROFS_FS_XATTR
	381	sb->s_xattr = erofs_xattr_handlers;
	382	#endif
ba2b77a8	383	/* set erofs default mount options */
99634bf3	384	erofs_default_options(sbi);
ba2b77a8	385
99634bf3	386	err = erofs_parse_options(sb, data);
8d8a09b0	387	if (err)
8f7acdae	388	return err;
ba2b77a8	389
516c115c GX	390	if (test_opt(sbi, POSIX_ACL))
	391	sb->s_flags \|= SB_POSIXACL;
	392	else
	393	sb->s_flags &= ~SB_POSIXACL;
	394
e7e9a307 GX	395	#ifdef CONFIG_EROFS_FS_ZIP
	396	INIT_RADIX_TREE(&sbi->workstn_tree, GFP_ATOMIC);
	397	#endif
	398
ba2b77a8 GX	399	/* get the root inode */
ba2b77a8 GX	400	inode = erofs_iget(sb, ROOT_NID(sbi), true);
8f7acdae GX	401	if (IS_ERR(inode))
8f7acdae GX	402	return PTR_ERR(inode);
ba2b77a8	403
8d8a09b0	404	if (!S_ISDIR(inode->i_mode)) {
4f761fa2 GX	405	erofs_err(sb, "rootino(nid %llu) is not a directory(i_mode %o)",
4f761fa2 GX	406	ROOT_NID(sbi), inode->i_mode);
94832d93	407	iput(inode);
8f7acdae	408	return -EINVAL;
ba2b77a8 GX	409	}
	410
	411	sb->s_root = d_make_root(inode);
8d8a09b0	412	if (!sb->s_root)
8f7acdae	413	return -ENOMEM;
ba2b77a8	414
22fe04a7	415	erofs_shrinker_register(sb);
8f7acdae GX	416	/* sb->s_umount is already locked, SB_ACTIVE and SB_BORN are not set */
8f7acdae GX	417	err = erofs_init_managed_cache(sb);
8d8a09b0	418	if (err)
8f7acdae	419	return err;
2497ee41	420
4f761fa2 GX	421	erofs_info(sb, "mounted with opts: %s, root inode @ nid %llu.",
4f761fa2 GX	422	(char *)data, ROOT_NID(sbi));
ba2b77a8	423	return 0;
8f7acdae GX	424	}
	425
	426	static struct dentry erofs_mount(struct file_system_type fs_type, int flags,
	427	const char dev_name, void data)
	428	{
	429	return mount_bdev(fs_type, flags, dev_name, data, erofs_fill_super);
ba2b77a8 GX	430	}
	431
	432	/*
	433	* could be triggered after deactivate_locked_super()
	434	* is called, thus including umount and failed to initialize.
	435	*/
8f7acdae	436	static void erofs_kill_sb(struct super_block *sb)
ba2b77a8	437	{
8f7acdae GX	438	struct erofs_sb_info *sbi;
	439
	440	WARN_ON(sb->s_magic != EROFS_SUPER_MAGIC);
ba2b77a8	441
8f7acdae GX	442	kill_block_super(sb);
	443
	444	sbi = EROFS_SB(sb);
e2ff9f15	445	if (!sbi)
ba2b77a8	446	return;
8f7acdae GX	447	kfree(sbi);
	448	sb->s_fs_info = NULL;
	449	}
ba2b77a8	450
8f7acdae GX	451	/* called when ->s_root is non-NULL */
	452	static void erofs_put_super(struct super_block *sb)
	453	{
	454	struct erofs_sb_info *const sbi = EROFS_SB(sb);
ba2b77a8	455
8f7acdae	456	DBG_BUGON(!sbi);
ba2b77a8	457
22fe04a7	458	erofs_shrinker_unregister(sb);
4279f3f9	459	#ifdef CONFIG_EROFS_FS_ZIP
105d4ad8	460	iput(sbi->managed_cache);
8f7acdae	461	sbi->managed_cache = NULL;
105d4ad8	462	#endif
ba2b77a8 GX	463	}
ba2b77a8 GX	464
ba2b77a8 GX	465	static struct file_system_type erofs_fs_type = {
	466	.owner = THIS_MODULE,
	467	.name = "erofs",
	468	.mount = erofs_mount,
8f7acdae	469	.kill_sb = erofs_kill_sb,
ba2b77a8 GX	470	.fs_flags = FS_REQUIRES_DEV,
	471	};
	472	MODULE_ALIAS_FS("erofs");
	473
	474	static int __init erofs_module_init(void)
	475	{
	476	int err;
	477
	478	erofs_check_ondisk_layout_definitions();
ba2b77a8	479
1c2dfbf9	480	erofs_inode_cachep = kmem_cache_create("erofs_inode",
a5876e24	481	sizeof(struct erofs_inode), 0,
1c2dfbf9	482	SLAB_RECLAIM_ACCOUNT,
99634bf3	483	erofs_inode_init_once);
1c2dfbf9 GX	484	if (!erofs_inode_cachep) {
1c2dfbf9 GX	485	err = -ENOMEM;
ba2b77a8	486	goto icache_err;
1c2dfbf9	487	}
ba2b77a8	488
22fe04a7	489	err = erofs_init_shrinker();
a1581312 GX	490	if (err)
	491	goto shrinker_err;
	492
3883a79a GX	493	err = z_erofs_init_zip_subsystem();
	494	if (err)
	495	goto zip_err;
3883a79a	496
ba2b77a8 GX	497	err = register_filesystem(&erofs_fs_type);
	498	if (err)
	499	goto fs_err;
	500
ba2b77a8 GX	501	return 0;
	502
	503	fs_err:
3883a79a GX	504	z_erofs_exit_zip_subsystem();
3883a79a GX	505	zip_err:
22fe04a7	506	erofs_exit_shrinker();
a1581312	507	shrinker_err:
1c2dfbf9	508	kmem_cache_destroy(erofs_inode_cachep);
ba2b77a8 GX	509	icache_err:
	510	return err;
	511	}
	512
	513	static void __exit erofs_module_exit(void)
	514	{
	515	unregister_filesystem(&erofs_fs_type);
3883a79a	516	z_erofs_exit_zip_subsystem();
22fe04a7	517	erofs_exit_shrinker();
1c2dfbf9 GX	518
	519	/* Ensure all RCU free inodes are safe before cache is destroyed. */
	520	rcu_barrier();
	521	kmem_cache_destroy(erofs_inode_cachep);
ba2b77a8 GX	522	}
	523
	524	/* get filesystem statistics */
	525	static int erofs_statfs(struct dentry dentry, struct kstatfs buf)
	526	{
	527	struct super_block *sb = dentry->d_sb;
	528	struct erofs_sb_info *sbi = EROFS_SB(sb);
	529	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
	530
	531	buf->f_type = sb->s_magic;
	532	buf->f_bsize = EROFS_BLKSIZ;
	533	buf->f_blocks = sbi->blocks;
	534	buf->f_bfree = buf->f_bavail = 0;
	535
	536	buf->f_files = ULLONG_MAX;
	537	buf->f_ffree = ULLONG_MAX - sbi->inos;
	538
	539	buf->f_namelen = EROFS_NAME_LEN;
	540
	541	buf->f_fsid.val[0] = (u32)id;
	542	buf->f_fsid.val[1] = (u32)(id >> 32);
	543	return 0;
	544	}
	545
	546	static int erofs_show_options(struct seq_file seq, struct dentry root)
	547	{
b17500a0 GX	548	struct erofs_sb_info *sbi __maybe_unused = EROFS_SB(root->d_sb);
	549
	550	#ifdef CONFIG_EROFS_FS_XATTR
	551	if (test_opt(sbi, XATTR_USER))
	552	seq_puts(seq, ",user_xattr");
	553	else
	554	seq_puts(seq, ",nouser_xattr");
	555	#endif
	556	#ifdef CONFIG_EROFS_FS_POSIX_ACL
	557	if (test_opt(sbi, POSIX_ACL))
	558	seq_puts(seq, ",acl");
	559	else
	560	seq_puts(seq, ",noacl");
9c07b3b3	561	#endif
4279f3f9 GX	562	#ifdef CONFIG_EROFS_FS_ZIP
	563	if (sbi->cache_strategy == EROFS_ZIP_CACHE_DISABLED) {
	564	seq_puts(seq, ",cache_strategy=disabled");
	565	} else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAHEAD) {
	566	seq_puts(seq, ",cache_strategy=readahead");
	567	} else if (sbi->cache_strategy == EROFS_ZIP_CACHE_READAROUND) {
	568	seq_puts(seq, ",cache_strategy=readaround");
	569	} else {
	570	seq_puts(seq, ",cache_strategy=(unknown)");
	571	DBG_BUGON(1);
	572	}
	573	#endif
ba2b77a8 GX	574	return 0;
	575	}
	576
	577	static int erofs_remount(struct super_block sb, int flags, char *data)
	578	{
d41076ea CX	579	struct erofs_sb_info *sbi = EROFS_SB(sb);
d41076ea CX	580	unsigned int org_mnt_opt = sbi->mount_opt;
d41076ea CX	581	int err;
d41076ea CX	582
8b987bca	583	DBG_BUGON(!sb_rdonly(sb));
99634bf3	584	err = erofs_parse_options(sb, data);
d41076ea CX	585	if (err)
d41076ea CX	586	goto out;
ba2b77a8	587
516c115c GX	588	if (test_opt(sbi, POSIX_ACL))
	589	sb->s_flags \|= SB_POSIXACL;
	590	else
	591	sb->s_flags &= ~SB_POSIXACL;
	592
5f0abea6	593	*flags \|= SB_RDONLY;
ba2b77a8	594	return 0;
d41076ea	595	out:
d41076ea	596	sbi->mount_opt = org_mnt_opt;
d41076ea	597	return err;
ba2b77a8 GX	598	}
	599
	600	const struct super_operations erofs_sops = {
	601	.put_super = erofs_put_super,
99634bf3 GX	602	.alloc_inode = erofs_alloc_inode,
99634bf3 GX	603	.free_inode = erofs_free_inode,
ba2b77a8 GX	604	.statfs = erofs_statfs,
	605	.show_options = erofs_show_options,
	606	.remount_fs = erofs_remount,
	607	};
	608
	609	module_init(erofs_module_init);
	610	module_exit(erofs_module_exit);
	611
	612	MODULE_DESCRIPTION("Enhanced ROM File System");
bc33d9f3	613	MODULE_AUTHOR("Gao Xiang, Chao Yu, Miao Xie, CONSUMER BG, HUAWEI Inc.");
ba2b77a8 GX	614	MODULE_LICENSE("GPL");
ba2b77a8 GX	615