910 lines
25 KiB
C
910 lines
25 KiB
C
/*
|
|
* fs/sdcardfs/inode.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"
|
|
|
|
/* Do not directly use this function. Use OVERRIDE_CRED() instead. */
|
|
const struct cred *override_fsids(uid_t fsuid, gid_t fsgid)
|
|
{
|
|
struct cred *cred;
|
|
const struct cred *old_cred;
|
|
|
|
cred = prepare_creds();
|
|
if (!cred)
|
|
return NULL;
|
|
|
|
cred->fsuid = make_kuid(current_user_ns(), fsuid);
|
|
cred->fsgid = make_kgid(current_user_ns(), fsgid);
|
|
|
|
old_cred = override_creds(cred);
|
|
|
|
return old_cred;
|
|
}
|
|
|
|
/* Do not directly use this function, use REVERT_CRED() instead. */
|
|
void revert_fsids(const struct cred *old_cred)
|
|
{
|
|
const struct cred *cur_cred;
|
|
|
|
cur_cred = current->cred;
|
|
revert_creds(old_cred);
|
|
put_cred(cur_cred);
|
|
}
|
|
|
|
static int sdcardfs_create(struct inode *dir, struct dentry *dentry,
|
|
umode_t mode, bool excl)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct dentry *lower_parent_dentry = NULL;
|
|
struct path lower_path;
|
|
const struct cred *saved_cred = NULL;
|
|
|
|
if (!check_caller_access_to_name(dir, dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
goto out_eacces;
|
|
}
|
|
|
|
/* save current_cred and override it */
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_parent_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
|
|
/* set last 16bytes of mode field to 0664 */
|
|
mode = (mode & S_IFMT) | 00664;
|
|
err = vfs_create(d_inode(lower_parent_dentry), lower_dentry, mode, true);
|
|
|
|
if (err)
|
|
goto out;
|
|
|
|
err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
|
|
if (err)
|
|
goto out;
|
|
fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
|
|
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_parent_dentry);
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
REVERT_CRED(saved_cred);
|
|
out_eacces:
|
|
return err;
|
|
}
|
|
|
|
#if 0
|
|
static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir,
|
|
struct dentry *new_dentry)
|
|
{
|
|
struct dentry *lower_old_dentry;
|
|
struct dentry *lower_new_dentry;
|
|
struct dentry *lower_dir_dentry;
|
|
u64 file_size_save;
|
|
int err;
|
|
struct path lower_old_path, lower_new_path;
|
|
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
|
|
|
|
file_size_save = i_size_read(d_inode(old_dentry));
|
|
sdcardfs_get_lower_path(old_dentry, &lower_old_path);
|
|
sdcardfs_get_lower_path(new_dentry, &lower_new_path);
|
|
lower_old_dentry = lower_old_path.dentry;
|
|
lower_new_dentry = lower_new_path.dentry;
|
|
lower_dir_dentry = lock_parent(lower_new_dentry);
|
|
|
|
err = mnt_want_write(lower_new_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
|
|
err = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
|
|
lower_new_dentry);
|
|
if (err || !d_inode(lower_new_dentry))
|
|
goto out;
|
|
|
|
err = sdcardfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
|
|
if (err)
|
|
goto out;
|
|
fsstack_copy_attr_times(dir, d_inode(lower_new_dentry));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_new_dentry));
|
|
set_nlink(d_inode(old_dentry),
|
|
sdcardfs_lower_inode(d_inode(old_dentry))->i_nlink);
|
|
i_size_write(d_inode(new_dentry), file_size_save);
|
|
out:
|
|
mnt_drop_write(lower_new_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_dir_dentry);
|
|
sdcardfs_put_lower_path(old_dentry, &lower_old_path);
|
|
sdcardfs_put_lower_path(new_dentry, &lower_new_path);
|
|
REVERT_CRED();
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
static int sdcardfs_unlink(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct inode *lower_dir_inode = sdcardfs_lower_inode(dir);
|
|
struct dentry *lower_dir_dentry;
|
|
struct path lower_path;
|
|
const struct cred *saved_cred = NULL;
|
|
|
|
if (!check_caller_access_to_name(dir, dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
goto out_eacces;
|
|
}
|
|
|
|
/* save current_cred and override it */
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
dget(lower_dentry);
|
|
lower_dir_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
err = vfs_unlink(lower_dir_inode, lower_dentry, NULL);
|
|
|
|
/*
|
|
* Note: unlinking on top of NFS can cause silly-renamed files.
|
|
* Trying to delete such files results in EBUSY from NFS
|
|
* below. Silly-renamed files will get deleted by NFS later on, so
|
|
* we just need to detect them here and treat such EBUSY errors as
|
|
* if the upper file was successfully deleted.
|
|
*/
|
|
if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)
|
|
err = 0;
|
|
if (err)
|
|
goto out;
|
|
fsstack_copy_attr_times(dir, lower_dir_inode);
|
|
fsstack_copy_inode_size(dir, lower_dir_inode);
|
|
set_nlink(d_inode(dentry),
|
|
sdcardfs_lower_inode(d_inode(dentry))->i_nlink);
|
|
d_inode(dentry)->i_ctime = dir->i_ctime;
|
|
d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_dir_dentry);
|
|
dput(lower_dentry);
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
REVERT_CRED(saved_cred);
|
|
out_eacces:
|
|
return err;
|
|
}
|
|
|
|
#if 0
|
|
static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry,
|
|
const char *symname)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct dentry *lower_parent_dentry = NULL;
|
|
struct path lower_path;
|
|
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_parent_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
err = vfs_symlink(d_inode(lower_parent_dentry), lower_dentry, symname);
|
|
if (err)
|
|
goto out;
|
|
err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
|
|
if (err)
|
|
goto out;
|
|
fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
|
|
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_parent_dentry);
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
REVERT_CRED();
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
static int touch(char *abs_path, mode_t mode)
|
|
{
|
|
struct file *filp = filp_open(abs_path, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, mode);
|
|
if (IS_ERR(filp)) {
|
|
if (PTR_ERR(filp) == -EEXIST) {
|
|
return 0;
|
|
} else {
|
|
printk(KERN_ERR "sdcardfs: failed to open(%s): %ld\n",
|
|
abs_path, PTR_ERR(filp));
|
|
return PTR_ERR(filp);
|
|
}
|
|
}
|
|
filp_close(filp, current->files);
|
|
return 0;
|
|
}
|
|
|
|
static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
|
|
{
|
|
int err;
|
|
int make_nomedia_in_obb = 0;
|
|
struct dentry *lower_dentry;
|
|
struct dentry *lower_parent_dentry = NULL;
|
|
struct path lower_path;
|
|
const struct cred *saved_cred = NULL;
|
|
struct sdcardfs_inode_info *pi = SDCARDFS_I(dir);
|
|
char *page_buf;
|
|
char *nomedia_dir_name;
|
|
char *nomedia_fullpath;
|
|
int fullpath_namelen;
|
|
int touch_err = 0;
|
|
|
|
if (!check_caller_access_to_name(dir, dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
goto out_eacces;
|
|
}
|
|
|
|
/* save current_cred and override it */
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
|
|
|
|
/* check disk space */
|
|
if (!check_min_free_space(dentry, 0, 1)) {
|
|
printk(KERN_INFO "sdcardfs: No minimum free space.\n");
|
|
err = -ENOSPC;
|
|
goto out_revert;
|
|
}
|
|
|
|
/* the lower_dentry is negative here */
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_parent_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err) {
|
|
unlock_dir(lower_parent_dentry);
|
|
goto out_unlock;
|
|
}
|
|
|
|
/* set last 16bytes of mode field to 0775 */
|
|
mode = (mode & S_IFMT) | 00775;
|
|
err = vfs_mkdir(d_inode(lower_parent_dentry), lower_dentry, mode);
|
|
|
|
if (err) {
|
|
unlock_dir(lower_parent_dentry);
|
|
goto out;
|
|
}
|
|
|
|
/* if it is a local obb dentry, setup it with the base obbpath */
|
|
if (need_graft_path(dentry)) {
|
|
|
|
err = setup_obb_dentry(dentry, &lower_path);
|
|
if (err) {
|
|
/* if the sbi->obbpath is not available, the lower_path won't be
|
|
* changed by setup_obb_dentry() but the lower path is saved to
|
|
* its orig_path. this dentry will be revalidated later.
|
|
* but now, the lower_path should be NULL */
|
|
sdcardfs_put_reset_lower_path(dentry);
|
|
|
|
/* the newly created lower path which saved to its orig_path or
|
|
* the lower_path is the base obbpath.
|
|
* therefore, an additional path_get is required */
|
|
path_get(&lower_path);
|
|
} else
|
|
make_nomedia_in_obb = 1;
|
|
}
|
|
|
|
err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
|
|
if (err) {
|
|
unlock_dir(lower_parent_dentry);
|
|
goto out;
|
|
}
|
|
|
|
fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
|
|
/* update number of links on parent directory */
|
|
set_nlink(dir, sdcardfs_lower_inode(dir)->i_nlink);
|
|
|
|
unlock_dir(lower_parent_dentry);
|
|
|
|
if (!strcasecmp(dentry->d_name.name, "obb") && (pi->perm == PERM_ANDROID))
|
|
make_nomedia_in_obb = 1;
|
|
|
|
/* When creating /Android/data and /Android/obb, mark them as .nomedia */
|
|
if (make_nomedia_in_obb ||
|
|
((pi->perm == PERM_ANDROID) && (!strcasecmp(dentry->d_name.name, "data")))) {
|
|
|
|
page_buf = (char *)__get_free_page(GFP_KERNEL);
|
|
if (!page_buf) {
|
|
printk(KERN_ERR "sdcardfs: failed to allocate page buf\n");
|
|
goto out;
|
|
}
|
|
|
|
nomedia_dir_name = d_absolute_path(&lower_path, page_buf, PAGE_SIZE);
|
|
if (IS_ERR(nomedia_dir_name)) {
|
|
free_page((unsigned long)page_buf);
|
|
printk(KERN_ERR "sdcardfs: failed to get .nomedia dir name\n");
|
|
goto out;
|
|
}
|
|
|
|
fullpath_namelen = page_buf + PAGE_SIZE - nomedia_dir_name - 1;
|
|
fullpath_namelen += strlen("/.nomedia");
|
|
nomedia_fullpath = kzalloc(fullpath_namelen + 1, GFP_KERNEL);
|
|
if (!nomedia_fullpath) {
|
|
free_page((unsigned long)page_buf);
|
|
printk(KERN_ERR "sdcardfs: failed to allocate .nomedia fullpath buf\n");
|
|
goto out;
|
|
}
|
|
|
|
strcpy(nomedia_fullpath, nomedia_dir_name);
|
|
free_page((unsigned long)page_buf);
|
|
strcat(nomedia_fullpath, "/.nomedia");
|
|
touch_err = touch(nomedia_fullpath, 0664);
|
|
if (touch_err) {
|
|
printk(KERN_ERR "sdcardfs: failed to touch(%s): %d\n",
|
|
nomedia_fullpath, touch_err);
|
|
kfree(nomedia_fullpath);
|
|
goto out;
|
|
}
|
|
kfree(nomedia_fullpath);
|
|
}
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
out_revert:
|
|
REVERT_CRED(saved_cred);
|
|
out_eacces:
|
|
return err;
|
|
}
|
|
|
|
static int sdcardfs_rmdir(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct dentry *lower_dentry;
|
|
struct dentry *lower_dir_dentry;
|
|
int err;
|
|
struct path lower_path;
|
|
const struct cred *saved_cred = NULL;
|
|
|
|
if (!check_caller_access_to_name(dir, dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
goto out_eacces;
|
|
}
|
|
|
|
/* save current_cred and override it */
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
|
|
|
|
/* sdcardfs_get_real_lower(): in case of remove an user's obb dentry
|
|
* the dentry on the original path should be deleted. */
|
|
sdcardfs_get_real_lower(dentry, &lower_path);
|
|
|
|
lower_dentry = lower_path.dentry;
|
|
lower_dir_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
err = vfs_rmdir(d_inode(lower_dir_dentry), lower_dentry);
|
|
if (err)
|
|
goto out;
|
|
|
|
d_drop(dentry); /* drop our dentry on success (why not VFS's job?) */
|
|
if (d_inode(dentry))
|
|
clear_nlink(d_inode(dentry));
|
|
fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
|
|
set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
|
|
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_dir_dentry);
|
|
sdcardfs_put_real_lower(dentry, &lower_path);
|
|
REVERT_CRED(saved_cred);
|
|
out_eacces:
|
|
return err;
|
|
}
|
|
|
|
#if 0
|
|
static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
|
|
dev_t dev)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct dentry *lower_parent_dentry = NULL;
|
|
struct path lower_path;
|
|
|
|
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_parent_dentry = lock_parent(lower_dentry);
|
|
|
|
err = mnt_want_write(lower_path.mnt);
|
|
if (err)
|
|
goto out_unlock;
|
|
err = vfs_mknod(d_inode(lower_parent_dentry), lower_dentry, mode, dev);
|
|
if (err)
|
|
goto out;
|
|
|
|
err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
|
|
if (err)
|
|
goto out;
|
|
fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
|
|
fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
|
|
|
|
out:
|
|
mnt_drop_write(lower_path.mnt);
|
|
out_unlock:
|
|
unlock_dir(lower_parent_dentry);
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
REVERT_CRED();
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* The locking rules in sdcardfs_rename are complex. We could use a simpler
|
|
* superblock-level name-space lock for renames and copy-ups.
|
|
*/
|
|
static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,
|
|
struct inode *new_dir, struct dentry *new_dentry, unsigned int flags)
|
|
{
|
|
int err = 0;
|
|
struct dentry *lower_old_dentry = NULL;
|
|
struct dentry *lower_new_dentry = NULL;
|
|
struct dentry *lower_old_dir_dentry = NULL;
|
|
struct dentry *lower_new_dir_dentry = NULL;
|
|
struct dentry *trap = NULL;
|
|
struct dentry *new_parent = NULL;
|
|
struct dentry *old_parent = NULL;
|
|
struct path lower_old_path, lower_new_path;
|
|
struct sdcardfs_inode_info *new_dir_info = SDCARDFS_I(new_dir);
|
|
const struct cred *saved_cred = NULL;
|
|
|
|
if (!check_caller_access_to_name(old_dir, old_dentry->d_name.name) ||
|
|
!check_caller_access_to_name(new_dir, new_dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" new_dentry: %s, task:%s\n",
|
|
__func__, new_dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
goto out_eacces;
|
|
}
|
|
|
|
/* save current_cred and override it */
|
|
OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb), saved_cred);
|
|
|
|
sdcardfs_get_real_lower(old_dentry, &lower_old_path);
|
|
sdcardfs_get_lower_path(new_dentry, &lower_new_path);
|
|
lower_old_dentry = lower_old_path.dentry;
|
|
lower_new_dentry = lower_new_path.dentry;
|
|
lower_old_dir_dentry = dget_parent(lower_old_dentry);
|
|
lower_new_dir_dentry = dget_parent(lower_new_dentry);
|
|
|
|
trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
|
|
/* source should not be ancestor of target */
|
|
if (trap == lower_old_dentry) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
/* target should not be ancestor of source */
|
|
if (trap == lower_new_dentry) {
|
|
err = -ENOTEMPTY;
|
|
goto out;
|
|
}
|
|
|
|
err = mnt_want_write(lower_old_path.mnt);
|
|
if (err)
|
|
goto out;
|
|
err = mnt_want_write(lower_new_path.mnt);
|
|
if (err)
|
|
goto out_drop_old_write;
|
|
|
|
err = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
|
|
d_inode(lower_new_dir_dentry), lower_new_dentry, NULL, flags);
|
|
if (err)
|
|
goto out_err;
|
|
|
|
/* Copy attrs from lower dir, but i_uid/i_gid */
|
|
sdcardfs_copy_inode_attr(new_dir, d_inode(lower_new_dir_dentry));
|
|
fsstack_copy_inode_size(new_dir, d_inode(lower_new_dir_dentry));
|
|
fix_derived_permission(new_dir);
|
|
if (new_dir != old_dir) {
|
|
sdcardfs_copy_inode_attr(old_dir, d_inode(lower_old_dir_dentry));
|
|
fsstack_copy_inode_size(old_dir, d_inode(lower_old_dir_dentry));
|
|
fix_derived_permission(old_dir);
|
|
/* update the derived permission of the old_dentry
|
|
* with its new parent
|
|
*/
|
|
new_parent = dget_parent(new_dentry);
|
|
if (new_parent) {
|
|
if (d_inode(old_dentry)) {
|
|
get_derived_permission(new_parent, old_dentry);
|
|
fix_derived_permission(d_inode(old_dentry));
|
|
}
|
|
dput(new_parent);
|
|
}
|
|
/* if RENAME_EXCHANGE,
|
|
* update the derived permission of the new_dentry also
|
|
* because new_dentry will survive under old_parent after rename
|
|
*/
|
|
if (flags & RENAME_EXCHANGE) {
|
|
old_parent = dget_parent(old_dentry);
|
|
if (old_parent) {
|
|
if (d_inode(new_dentry)) {
|
|
get_derived_permission(old_parent, new_dentry);
|
|
fix_derived_permission(d_inode(new_dentry));
|
|
}
|
|
dput(old_parent);
|
|
}
|
|
}
|
|
}
|
|
if (!uid_eq(old_dir->i_uid, new_dir->i_uid) ||
|
|
new_dir_info->perm == PERM_ANDROID_DATA ||
|
|
new_dir_info->perm == PERM_ANDROID_OBB ||
|
|
new_dir_info->perm == PERM_ANDROID_MEDIA) {
|
|
spin_lock(&old_dentry->d_lock);
|
|
old_dentry->d_flags |= DCACHE_WILL_INVALIDATE;
|
|
spin_unlock(&old_dentry->d_lock);
|
|
if (flags & RENAME_EXCHANGE) {
|
|
spin_lock(&new_dentry->d_lock);
|
|
new_dentry->d_flags |= DCACHE_WILL_INVALIDATE;
|
|
spin_unlock(&new_dentry->d_lock);
|
|
}
|
|
}
|
|
|
|
out_err:
|
|
mnt_drop_write(lower_new_path.mnt);
|
|
out_drop_old_write:
|
|
mnt_drop_write(lower_old_path.mnt);
|
|
out:
|
|
unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
|
|
dput(lower_old_dir_dentry);
|
|
dput(lower_new_dir_dentry);
|
|
sdcardfs_put_real_lower(old_dentry, &lower_old_path);
|
|
sdcardfs_put_lower_path(new_dentry, &lower_new_path);
|
|
REVERT_CRED(saved_cred);
|
|
out_eacces:
|
|
return err;
|
|
}
|
|
|
|
#if 0
|
|
static int sdcardfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct path lower_path;
|
|
/* XXX readlink does not requires overriding credential */
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
if (!d_inode(lower_dentry)->i_op ||
|
|
!d_inode(lower_dentry)->i_op->readlink) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
err = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
|
|
buf, bufsiz);
|
|
if (err < 0)
|
|
goto out;
|
|
fsstack_copy_attr_atime(d_inode(dentry), d_inode(lower_dentry));
|
|
|
|
out:
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
static void *sdcardfs_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
char *buf;
|
|
int len = PAGE_SIZE, err;
|
|
mm_segment_t old_fs;
|
|
|
|
/* This is freed by the put_link method assuming a successful call. */
|
|
buf = kmalloc(len, GFP_KERNEL);
|
|
if (!buf) {
|
|
buf = ERR_PTR(-ENOMEM);
|
|
goto out;
|
|
}
|
|
|
|
/* read the symlink, and then we will follow it */
|
|
old_fs = get_fs();
|
|
set_fs(KERNEL_DS);
|
|
err = sdcardfs_readlink(dentry, buf, len);
|
|
set_fs(old_fs);
|
|
if (err < 0) {
|
|
kfree(buf);
|
|
buf = ERR_PTR(err);
|
|
} else {
|
|
buf[err] = '\0';
|
|
}
|
|
out:
|
|
nd_set_link(nd, buf);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
/* this @nd *IS* still used */
|
|
static void sdcardfs_put_link(struct dentry *dentry, struct nameidata *nd,
|
|
void *cookie)
|
|
{
|
|
char *buf = nd_get_link(nd);
|
|
if (!IS_ERR(buf)) /* free the char* */
|
|
kfree(buf);
|
|
}
|
|
#endif
|
|
|
|
static int sdcardfs_permission(struct inode *inode, int mask)
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Permission check on sdcardfs inode.
|
|
* Calling process should have AID_SDCARD_RW permission
|
|
*/
|
|
err = generic_permission(inode, mask);
|
|
|
|
/* XXX
|
|
* Original sdcardfs code calls inode_permission(lower_inode,.. )
|
|
* for checking inode permission. But doing such things here seems
|
|
* duplicated work, because the functions called after this func,
|
|
* such as vfs_create, vfs_unlink, vfs_rename, and etc,
|
|
* does exactly same thing, i.e., they calls inode_permission().
|
|
* So we just let they do the things.
|
|
* If there are any security hole, just uncomment following if block.
|
|
*/
|
|
#if 0
|
|
if (!err) {
|
|
/*
|
|
* Permission check on lower_inode(=EXT4).
|
|
* we check it with AID_MEDIA_RW permission
|
|
*/
|
|
struct inode *lower_inode;
|
|
OVERRIDE_CRED(SDCARDFS_SB(inode->sb));
|
|
|
|
lower_inode = sdcardfs_lower_inode(inode);
|
|
err = inode_permission(lower_inode, mask);
|
|
|
|
REVERT_CRED();
|
|
}
|
|
#endif
|
|
return err;
|
|
|
|
}
|
|
|
|
static int sdcardfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|
struct kstat *stat)
|
|
{
|
|
struct dentry *lower_dentry;
|
|
struct inode *inode;
|
|
struct inode *lower_inode;
|
|
struct path lower_path;
|
|
struct dentry *parent;
|
|
|
|
parent = dget_parent(dentry);
|
|
if (!check_caller_access_to_name(d_inode(parent), dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
dput(parent);
|
|
return -EACCES;
|
|
}
|
|
dput(parent);
|
|
|
|
inode = d_inode(dentry);
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_inode = sdcardfs_lower_inode(inode);
|
|
|
|
/* need to get inode->i_mutex */
|
|
mutex_lock(&inode->i_mutex);
|
|
sdcardfs_copy_inode_attr(inode, lower_inode);
|
|
fsstack_copy_inode_size(inode, lower_inode);
|
|
/* if the dentry has been moved from other location
|
|
* so, on this stage, its derived permission must be
|
|
* rechecked from its private field.
|
|
*/
|
|
fix_derived_permission(inode);
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
generic_fillattr(inode, stat);
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
return 0;
|
|
}
|
|
|
|
static int sdcardfs_setattr(struct dentry *dentry, struct iattr *ia)
|
|
{
|
|
int err;
|
|
struct dentry *lower_dentry;
|
|
struct inode *inode;
|
|
struct inode *lower_inode;
|
|
struct path lower_path;
|
|
struct iattr lower_ia;
|
|
struct dentry *parent;
|
|
|
|
inode = d_inode(dentry);
|
|
|
|
/*
|
|
* Check if user has permission to change inode. We don't check if
|
|
* this user can change the lower inode: that should happen when
|
|
* calling notify_change on the lower inode.
|
|
*/
|
|
err = inode_change_ok(inode, ia);
|
|
|
|
/* no vfs_XXX operations required, cred overriding will be skipped. wj*/
|
|
if (!err) {
|
|
/* check the Android group ID */
|
|
parent = dget_parent(dentry);
|
|
if (!check_caller_access_to_name(d_inode(parent), dentry->d_name.name)) {
|
|
printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
|
|
" dentry: %s, task:%s\n",
|
|
__func__, dentry->d_name.name, current->comm);
|
|
err = -EACCES;
|
|
}
|
|
dput(parent);
|
|
}
|
|
|
|
if (err)
|
|
goto out_err;
|
|
|
|
sdcardfs_get_lower_path(dentry, &lower_path);
|
|
lower_dentry = lower_path.dentry;
|
|
lower_inode = sdcardfs_lower_inode(inode);
|
|
|
|
/* prepare our own lower struct iattr (with the lower file) */
|
|
memcpy(&lower_ia, ia, sizeof(lower_ia));
|
|
if (ia->ia_valid & ATTR_FILE)
|
|
lower_ia.ia_file = sdcardfs_lower_file(ia->ia_file);
|
|
|
|
lower_ia.ia_valid &= ~(ATTR_UID | ATTR_GID | ATTR_MODE);
|
|
|
|
/*
|
|
* If shrinking, first truncate upper level to cancel writing dirty
|
|
* pages beyond the new eof; and also if its' maxbytes is more
|
|
* limiting (fail with -EFBIG before making any change to the lower
|
|
* level). There is no need to vmtruncate the upper level
|
|
* afterwards in the other cases: we fsstack_copy_inode_size from
|
|
* the lower level.
|
|
*/
|
|
if (ia->ia_valid & ATTR_SIZE) {
|
|
err = inode_newsize_ok(inode, ia->ia_size);
|
|
if (err)
|
|
goto out;
|
|
truncate_setsize(inode, ia->ia_size);
|
|
}
|
|
|
|
/*
|
|
* mode change is for clearing setuid/setgid bits. Allow lower fs
|
|
* to interpret this in its own way.
|
|
*/
|
|
if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
|
|
lower_ia.ia_valid &= ~ATTR_MODE;
|
|
|
|
/* notify the (possibly copied-up) lower inode */
|
|
/*
|
|
* Note: we use d_inode(lower_dentry), because lower_inode may be
|
|
* unlinked (no inode->i_sb and i_ino==0. This happens if someone
|
|
* tries to open(), unlink(), then ftruncate() a file.
|
|
*/
|
|
mutex_lock(&d_inode(lower_dentry)->i_mutex);
|
|
err = notify_change(lower_dentry, &lower_ia, NULL); /* note: lower_ia */
|
|
mutex_unlock(&d_inode(lower_dentry)->i_mutex);
|
|
if (err)
|
|
goto out;
|
|
|
|
/* get attributes from the lower inode, i_mutex held */
|
|
sdcardfs_copy_inode_attr(inode, lower_inode);
|
|
/* update derived permission of the upper inode */
|
|
fix_derived_permission(inode);
|
|
|
|
/*
|
|
* Not running fsstack_copy_inode_size(inode, lower_inode), because
|
|
* VFS should update our inode size, and notify_change on
|
|
* lower_inode should update its size.
|
|
*/
|
|
|
|
out:
|
|
sdcardfs_put_lower_path(dentry, &lower_path);
|
|
out_err:
|
|
return err;
|
|
}
|
|
|
|
const struct inode_operations sdcardfs_symlink_iops = {
|
|
.permission = sdcardfs_permission,
|
|
.setattr = sdcardfs_setattr,
|
|
#ifdef SDCARD_FS_XATTR
|
|
.setxattr = sdcardfs_setxattr,
|
|
.getxattr = sdcardfs_getxattr,
|
|
.listxattr = sdcardfs_listxattr,
|
|
.removexattr = sdcardfs_removexattr,
|
|
#endif // SDCARD_FS_XATTR
|
|
/* XXX Following operations are implemented,
|
|
* but FUSE(sdcard) or FAT does not support them
|
|
* These methods are *NOT* perfectly tested.
|
|
.readlink = sdcardfs_readlink,
|
|
.follow_link = sdcardfs_follow_link,
|
|
.put_link = sdcardfs_put_link,
|
|
*/
|
|
};
|
|
|
|
const struct inode_operations sdcardfs_dir_iops = {
|
|
.create = sdcardfs_create,
|
|
.lookup = sdcardfs_lookup,
|
|
.permission = sdcardfs_permission,
|
|
.unlink = sdcardfs_unlink,
|
|
.mkdir = sdcardfs_mkdir,
|
|
.rmdir = sdcardfs_rmdir,
|
|
.rename2 = sdcardfs_rename,
|
|
.setattr = sdcardfs_setattr,
|
|
.getattr = sdcardfs_getattr,
|
|
#ifdef SDCARD_FS_XATTR
|
|
.setxattr = sdcardfs_setxattr,
|
|
.getxattr = sdcardfs_getxattr,
|
|
.listxattr = sdcardfs_listxattr,
|
|
.removexattr = sdcardfs_removexattr,
|
|
#endif // SDCARD_FS_XATTR
|
|
/* XXX Following operations are implemented,
|
|
* but FUSE(sdcard) or FAT does not support them
|
|
* These methods are *NOT* perfectly tested.
|
|
.symlink = sdcardfs_symlink,
|
|
.link = sdcardfs_link,
|
|
.mknod = sdcardfs_mknod,
|
|
*/
|
|
};
|
|
|
|
const struct inode_operations sdcardfs_main_iops = {
|
|
.permission = sdcardfs_permission,
|
|
.setattr = sdcardfs_setattr,
|
|
.getattr = sdcardfs_getattr,
|
|
#ifdef SDCARD_FS_XATTR
|
|
.setxattr = sdcardfs_setxattr,
|
|
.getxattr = sdcardfs_getxattr,
|
|
.listxattr = sdcardfs_listxattr,
|
|
.removexattr = sdcardfs_removexattr,
|
|
#endif // SDCARDFS_XATTR
|
|
};
|