android_kernel_xiaomi_sm8450/fs/sdcardfs/main.c

/*
 * fs/sdcardfs/main.c
 *
 * Copyright (c) 2013 Samsung Electronics Co. Ltd
 *   Authors: Daeho Jeong, Woojoong Lee, Seunghwan Hyun,
 *               Sunghwan Yun, Sungjong Seo
 *
 * This program has been developed as a stackable file system based on
 * the WrapFS which written by
 *
 * Copyright (c) 1998-2011 Erez Zadok
 * Copyright (c) 2009     Shrikar Archak
 * Copyright (c) 2003-2011 Stony Brook University
 * Copyright (c) 2003-2011 The Research Foundation of SUNY
 *
 * This file is dual licensed.  It may be redistributed and/or modified
 * under the terms of the Apache 2.0 License OR version 2 of the GNU
 * General Public License.
 */

#include "sdcardfs.h"
#include <linux/fs_context.h>
#include <linux/fs_parser.h>
#include <linux/fscrypt.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/parser.h>

enum sdcardfs_param {
	Opt_fsuid,
	Opt_fsgid,
	Opt_gid,
	Opt_debug,
	Opt_mask,
	Opt_multiuser,
	Opt_userid,
	Opt_reserved_mb,
	Opt_gid_derivation,
	Opt_default_normal,
	Opt_nocache,
	Opt_unshared_obb,
	Opt_err,
};

static const struct fs_parameter_spec sdcardfs_param_specs[] = {
	fsparam_u32("fsuid", Opt_fsuid),
	fsparam_u32("fsgid", Opt_fsgid),
	fsparam_u32("gid", Opt_gid),
	fsparam_bool("debug", Opt_debug),
	fsparam_u32("mask", Opt_mask),
	fsparam_u32("userid", Opt_userid),
	fsparam_bool("multiuser", Opt_multiuser),
	fsparam_bool("derive_gid", Opt_gid_derivation),
	fsparam_bool("default_normal", Opt_default_normal),
	fsparam_bool("unshared_obb", Opt_unshared_obb),
	fsparam_u32("reserved_mb", Opt_reserved_mb),
	fsparam_bool("nocache", Opt_nocache),
	{}
};

static const struct fs_parameter_description sdcardfs_parameters = {
	.name	= "sdcardfs",
	.specs	= sdcardfs_param_specs,
};

static int sdcardfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
{
	struct sdcardfs_context_options *fc_opts = fc->fs_private;
	struct sdcardfs_mount_options *opts = &fc_opts->opts;
	struct sdcardfs_vfsmount_options *vfsopts = &fc_opts->vfsopts;
	struct fs_parse_result result;
	int opt;

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

	switch (opt) {
	case Opt_debug:
		opts->debug = true;
		break;
	case Opt_fsuid:
		opts->fs_low_uid = result.uint_32;
		break;
	case Opt_fsgid:
		opts->fs_low_gid = result.uint_32;
		break;
	case Opt_gid:
		vfsopts->gid = result.uint_32;
		break;
	case Opt_userid:
		opts->fs_user_id = result.uint_32;
		break;
	case Opt_mask:
		vfsopts->mask = result.uint_32;
		break;
	case Opt_multiuser:
		opts->multiuser = true;
		break;
	case Opt_reserved_mb:
		opts->reserved_mb = result.uint_32;
		break;
	case Opt_gid_derivation:
		opts->gid_derivation = true;
		break;
	case Opt_default_normal:
		opts->default_normal = true;
		break;
	case Opt_nocache:
		opts->nocache = true;
		break;
	case Opt_unshared_obb:
		opts->unshared_obb = true;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static void copy_sb_opts(struct sdcardfs_mount_options *opts,
		struct fs_context *fc)
{
	struct sdcardfs_context_options *fcopts = fc->fs_private;

	opts->debug = fcopts->opts.debug;
	opts->default_normal = fcopts->opts.default_normal;
	opts->fs_low_gid = fcopts->opts.fs_low_gid;
	opts->fs_low_uid = fcopts->opts.fs_low_uid;
	opts->fs_user_id = fcopts->opts.fs_user_id;
	opts->gid_derivation = fcopts->opts.gid_derivation;
	opts->multiuser = fcopts->opts.multiuser;
	opts->nocache = fcopts->opts.nocache;
	opts->reserved_mb = fcopts->opts.reserved_mb;
	opts->unshared_obb = fcopts->opts.unshared_obb;
}

#if 0
/*
 * our custom d_alloc_root work-alike
 *
 * we can't use d_alloc_root if we want to use our own interpose function
 * unchanged, so we simply call our own "fake" d_alloc_root
 */
static struct dentry *sdcardfs_d_alloc_root(struct super_block *sb)
{
	struct dentry *ret = NULL;

	if (sb) {
		static const struct qstr name = {
			.name = "/",
			.len = 1
		};

		ret = d_alloc(NULL, &name);
		if (ret) {
			d_set_d_op(ret, &sdcardfs_ci_dops);
			ret->d_sb = sb;
			ret->d_parent = ret;
		}
	}
	return ret;
}
#endif

DEFINE_MUTEX(sdcardfs_super_list_lock);
EXPORT_SYMBOL_GPL(sdcardfs_super_list_lock);
LIST_HEAD(sdcardfs_super_list);
EXPORT_SYMBOL_GPL(sdcardfs_super_list);

struct sdcardfs_mount_private {
	struct vfsmount *mnt;
	const char *dev_name;
	void *raw_data;
};

static int __sdcardfs_fill_super(
	struct super_block *sb,
	struct fs_context *fc)
{
	int err = 0;
	struct super_block *lower_sb;
	struct path lower_path;
	struct sdcardfs_sb_info *sb_info;
	struct inode *inode;
	const char *dev_name = fc->source;
	struct sdcardfs_context_options *fcopts = fc->fs_private;
	struct sdcardfs_mount_options *opts = &fcopts->opts;
	struct sdcardfs_vfsmount_options *mntopts = &fcopts->vfsopts;

	pr_info("sdcardfs version 2.0\n");

	if (!dev_name) {
		pr_err("sdcardfs: read_super: missing dev_name argument\n");
		err = -EINVAL;
		goto out;
	}

	pr_info("sdcardfs: dev_name -> %s\n", dev_name);
	pr_info("sdcardfs: gid=%d,mask=%x\n", mntopts->gid, mntopts->mask);

	/* parse lower path */
	err = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
			&lower_path);
	if (err) {
		pr_err("sdcardfs: error accessing lower directory '%s'\n", dev_name);
		goto out;
	}

	/* allocate superblock private data */
	sb->s_fs_info = kzalloc(sizeof(struct sdcardfs_sb_info), GFP_KERNEL);
	if (!SDCARDFS_SB(sb)) {
		pr_crit("sdcardfs: read_super: out of memory\n");
		err = -ENOMEM;
		goto out_free;
	}

	sb_info = sb->s_fs_info;
	copy_sb_opts(&sb_info->options, fc);
	if (opts->debug) {
		pr_info("sdcardfs : options - debug:%d\n", opts->debug);
		pr_info("sdcardfs : options - gid:%d\n", mntopts->gid);
		pr_info("sdcardfs : options - mask:%d\n", mntopts->mask);
	}

	/* set the lower superblock field of upper superblock */
	lower_sb = lower_path.dentry->d_sb;
	atomic_inc(&lower_sb->s_active);
	sdcardfs_set_lower_super(sb, lower_sb);

	sb->s_stack_depth = lower_sb->s_stack_depth + 1;
	if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
		pr_err("sdcardfs: maximum fs stacking depth exceeded\n");
		err = -EINVAL;
		goto out_sput;
	}

	/* inherit maxbytes from lower file system */
	sb->s_maxbytes = lower_sb->s_maxbytes;

	/*
	 * Our c/m/atime granularity is 1 ns because we may stack on file
	 * systems whose granularity is as good.
	 */
	sb->s_time_gran = 1;

	sb->s_magic = SDCARDFS_SUPER_MAGIC;
	sb->s_op = &sdcardfs_sops;

	/* get a new inode and allocate our root dentry */
	inode = sdcardfs_iget(sb, d_inode(lower_path.dentry), 0);
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_sput;
	}
	sb->s_root = d_make_root(inode);
	if (!sb->s_root) {
		err = -ENOMEM;
		goto out_sput;
	}
	d_set_d_op(sb->s_root, &sdcardfs_ci_dops);

	/* link the upper and lower dentries */
	sb->s_root->d_fsdata = NULL;
	err = new_dentry_private_data(sb->s_root);
	if (err)
		goto out_freeroot;

	/* set the lower dentries for s_root */
	sdcardfs_set_lower_path(sb->s_root, &lower_path);

	/*
	 * No need to call interpose because we already have a positive
	 * dentry, which was instantiated by d_make_root.  Just need to
	 * d_rehash it.
	 */
	d_rehash(sb->s_root);

	/* setup permission policy */
	sb_info->obbpath_s = kzalloc(PATH_MAX, GFP_KERNEL);
	mutex_lock(&sdcardfs_super_list_lock);
	if (sb_info->options.multiuser) {
		setup_derived_state(d_inode(sb->s_root), PERM_PRE_ROOT,
				sb_info->options.fs_user_id, AID_ROOT);
		snprintf(sb_info->obbpath_s, PATH_MAX, "%s/obb", dev_name);
	} else {
		setup_derived_state(d_inode(sb->s_root), PERM_ROOT,
				sb_info->options.fs_user_id, AID_ROOT);
		snprintf(sb_info->obbpath_s, PATH_MAX, "%s/Android/obb", dev_name);
	}
	fixup_tmp_permissions(d_inode(sb->s_root));
	sb_info->sb = sb;
	list_add(&sb_info->list, &sdcardfs_super_list);
	mutex_unlock(&sdcardfs_super_list_lock);

	sb_info->fscrypt_nb.notifier_call = sdcardfs_on_fscrypt_key_removed;
	fscrypt_register_key_removal_notifier(&sb_info->fscrypt_nb);

	if (!(fc->sb_flags & SB_SILENT))
		pr_info("sdcardfs: mounted on top of %s type %s\n",
				dev_name, lower_sb->s_type->name);
	goto out; /* all is well */

	/* no longer needed: free_dentry_private_data(sb->s_root); */
out_freeroot:
	dput(sb->s_root);
	sb->s_root = NULL;
out_sput:
	/* drop refs we took earlier */
	atomic_dec(&lower_sb->s_active);
	kfree(SDCARDFS_SB(sb));
	sb->s_fs_info = NULL;
out_free:
	path_put(&lower_path);

out:
	return err;
}

static int sdcardfs_get_tree(struct fs_context *fc)
{
	return vfs_get_super(fc, vfs_get_independent_super,
			__sdcardfs_fill_super);
}

void *sdcardfs_alloc_mnt_data(void)
{
	return kmalloc(sizeof(struct sdcardfs_vfsmount_options), GFP_KERNEL);
}

void sdcardfs_kill_sb(struct super_block *sb)
{
	struct sdcardfs_sb_info *sbi;

	if (sb->s_magic == SDCARDFS_SUPER_MAGIC && sb->s_fs_info) {
		sbi = SDCARDFS_SB(sb);

		fscrypt_unregister_key_removal_notifier(&sbi->fscrypt_nb);

		mutex_lock(&sdcardfs_super_list_lock);
		list_del(&sbi->list);
		mutex_unlock(&sdcardfs_super_list_lock);
	}
	kill_anon_super(sb);
}

static void sdcardfs_free_fs_context(struct fs_context *fc)
{
	struct sdcardfs_context_options *fc_opts = fc->fs_private;

	kfree(fc_opts);
}

/* Most of the remount happens in sdcardfs_update_mnt_data */
static int sdcardfs_reconfigure_context(struct fs_context *fc)
{
	struct sdcardfs_context_options *fc_opts = fc->fs_private;
	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(fc->root->d_sb);

	sbi->options.debug = fc_opts->opts.debug;
	if (sbi->options.debug) {
		pr_info("sdcardfs : options - debug:%d\n", sbi->options.debug);
		pr_info("sdcardfs : options - gid:%d\n", fc_opts->vfsopts.gid);
		pr_info("sdcardfs : options - mask:%d\n",
						fc_opts->vfsopts.mask);
	}
	return 0;
}

/* reconfigure is handled by sdcardfs_update_mnt_data */
static const struct fs_context_operations sdcardfs_context_options_ops = {

    .parse_param    = sdcardfs_parse_param,
    .get_tree   = sdcardfs_get_tree,
    .free       = sdcardfs_free_fs_context,
    .reconfigure = sdcardfs_reconfigure_context,
};

static int sdcardfs_init_fs_context(struct fs_context *fc)
{
	struct sdcardfs_context_options *fc_opts =
		kmalloc(sizeof(struct sdcardfs_context_options), GFP_KERNEL);

	/* by default, we use AID_MEDIA_RW as uid, gid */
	fc_opts->opts.fs_low_uid = AID_MEDIA_RW;
	fc_opts->opts.fs_low_gid = AID_MEDIA_RW;
	fc_opts->opts.fs_user_id = 0;
	fc_opts->vfsopts.gid = 0;
	fc_opts->vfsopts.mask = 0;

	/* by default, 0MB is reserved */
	fc_opts->opts.reserved_mb = 0;
	/* by default, gid derivation is off */
	fc_opts->opts.gid_derivation = false;
	fc_opts->opts.default_normal = false;
	fc_opts->opts.nocache = false;
	fc_opts->opts.multiuser = false;
	fc_opts->opts.debug = false;

	fc->fs_private = fc_opts;
	fc->ops = &sdcardfs_context_options_ops;
	return 0;
}

static struct file_system_type sdcardfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= SDCARDFS_NAME,
	.alloc_mnt_data = sdcardfs_alloc_mnt_data,
	.kill_sb	= sdcardfs_kill_sb,
	.init_fs_context = sdcardfs_init_fs_context,
	.fs_flags	= 0,
};
MODULE_ALIAS_FS(SDCARDFS_NAME);

static int __init init_sdcardfs_fs(void)
{
	int err;

	pr_info("Registering sdcardfs " SDCARDFS_VERSION "\n");

	err = sdcardfs_init_inode_cache();
	if (err)
		goto out;
	err = sdcardfs_init_dentry_cache();
	if (err)
		goto out;
	err = packagelist_init();
	if (err)
		goto out;
	err = register_filesystem(&sdcardfs_fs_type);
out:
	if (err) {
		sdcardfs_destroy_inode_cache();
		sdcardfs_destroy_dentry_cache();
		packagelist_exit();
	}
	return err;
}

static void __exit exit_sdcardfs_fs(void)
{
	sdcardfs_destroy_inode_cache();
	sdcardfs_destroy_dentry_cache();
	packagelist_exit();
	unregister_filesystem(&sdcardfs_fs_type);
	pr_info("Completed sdcardfs module unload\n");
}

/* Original wrapfs authors */
MODULE_AUTHOR("Erez Zadok, Filesystems and Storage Lab, Stony Brook University (http://www.fsl.cs.sunysb.edu/)");

/* Original sdcardfs authors */
MODULE_AUTHOR("Woojoong Lee, Daeho Jeong, Kitae Lee, Yeongjin Gil System Memory Lab., Samsung Electronics");

/* Current maintainer */
MODULE_AUTHOR("Daniel Rosenberg, Google");
MODULE_DESCRIPTION("Sdcardfs " SDCARDFS_VERSION);
MODULE_LICENSE("GPL");

module_init(init_sdcardfs_fs);
module_exit(exit_sdcardfs_fs);