Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ffbd7c8c authored by Daniel Campello's avatar Daniel Campello Committed by Daniel Rosenberg
Browse files

Port of sdcardfs to 3.18 



Change-Id: Idef6cae51c765f4cae3fa9d9a3419425827400db
Signed-off-by: default avatarDaniel Campello <campello@google.com>
parent fd3ea299

fs/sdcardfs/Kconfig

+0 −1
Original line number Diff line number Diff line 
config SDCARD_FS

	tristate "sdcard file system"

	depends on EXPERIMENTAL

	default n

	help

	  Sdcardfs is based on Wrapfs file system.

fs/sdcardfs/dentry.c

+4 −5
Original line number Diff line number Diff line
@@ -26,7 +26,7 @@ 
 *          0: tell VFS to invalidate dentry

 *          1: dentry is valid

 */

static int sdcardfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)

static int sdcardfs_d_revalidate(struct dentry *dentry, unsigned int flags)

{

	int err = 1;

	struct path parent_lower_path, lower_path;
@@ -35,7 +35,7 @@ static int sdcardfs_d_revalidate(struct dentry *dentry, struct nameidata *nd) 
	struct dentry *lower_cur_parent_dentry = NULL;

	struct dentry *lower_dentry = NULL;



	if (nd && nd->flags & LOOKUP_RCU)

	if (flags & LOOKUP_RCU)

		return -ECHILD;



	spin_lock(&dentry->d_lock);
@@ -119,7 +119,7 @@ static void sdcardfs_d_release(struct dentry *dentry) 
}



static int sdcardfs_hash_ci(const struct dentry *dentry,

				const struct inode *inode, struct qstr *qstr)

				struct qstr *qstr)

{

	/*

	 * This function is copy of vfat_hashi.
@@ -148,8 +148,7 @@ static int sdcardfs_hash_ci(const struct dentry *dentry, 
 * Case insensitive compare of two vfat names.

 */

static int sdcardfs_cmp_ci(const struct dentry *parent,

		const struct inode *pinode,

		const struct dentry *dentry, const struct inode *inode,

		const struct dentry *dentry,

		unsigned int len, const char *str, const struct qstr *name)

{

	/* This function is copy of vfat_cmpi */

fs/sdcardfs/file.c

+22 −17
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static ssize_t sdcardfs_read(struct file *file, char __user *buf, 
	/* update our inode atime upon a successful lower read */

	if (err >= 0)

		fsstack_copy_attr_atime(dentry->d_inode,

					lower_file->f_path.dentry->d_inode);

					file_inode(lower_file));



	return err;

}
@@ -59,7 +59,7 @@ static ssize_t sdcardfs_read(struct file *file, char __user *buf, 
static ssize_t sdcardfs_write(struct file *file, const char __user *buf,

			    size_t count, loff_t *ppos)

{

	int err = 0;

	int err;

	struct file *lower_file;

	struct dentry *dentry = file->f_path.dentry;
@@ -74,28 +74,28 @@ static ssize_t sdcardfs_write(struct file *file, const char __user *buf, 
	/* update our inode times+sizes upon a successful lower write */

	if (err >= 0) {

		fsstack_copy_inode_size(dentry->d_inode,

					lower_file->f_path.dentry->d_inode);

					file_inode(lower_file));

		fsstack_copy_attr_times(dentry->d_inode,

					lower_file->f_path.dentry->d_inode);

					file_inode(lower_file));

	}



	return err;

}



static int sdcardfs_readdir(struct file *file, void *dirent, filldir_t filldir)

static int sdcardfs_readdir(struct file *file, struct dir_context *ctx)

{

	int err = 0;

	int err;

	struct file *lower_file = NULL;

	struct dentry *dentry = file->f_path.dentry;



	lower_file = sdcardfs_lower_file(file);



	lower_file->f_pos = file->f_pos;

	err = vfs_readdir(lower_file, filldir, dirent);

	err = iterate_dir(lower_file, ctx);

	file->f_pos = lower_file->f_pos;

	if (err >= 0)		/* copy the atime */

		fsstack_copy_attr_atime(dentry->d_inode,

					lower_file->f_path.dentry->d_inode);

					file_inode(lower_file));

	return err;

}
@@ -191,7 +191,6 @@ static int sdcardfs_mmap(struct file *file, struct vm_area_struct *vma) 
	 */

	file_accessed(file);

	vma->vm_ops = &sdcardfs_vm_ops;

	vma->vm_flags |= VM_CAN_NONLINEAR;



	file->f_mapping->a_ops = &sdcardfs_aops; /* set our aops */

	if (!SDCARDFS_F(file)->lower_vm_ops) /* save for our ->fault */
@@ -242,8 +241,8 @@ static int sdcardfs_open(struct inode *inode, struct file *file) 


	/* open lower object and link sdcardfs's file struct to lower's */

	sdcardfs_get_lower_path(file->f_path.dentry, &lower_path);

	lower_file = dentry_open(lower_path.dentry, lower_path.mnt,

				 file->f_flags, current_cred());

	lower_file = dentry_open(&lower_path, file->f_flags, current_cred());

	path_put(&lower_path);

	if (IS_ERR(lower_file)) {

		err = PTR_ERR(lower_file);

		lower_file = sdcardfs_lower_file(file);
@@ -275,8 +274,10 @@ static int sdcardfs_flush(struct file *file, fl_owner_t id) 
	struct file *lower_file = NULL;



	lower_file = sdcardfs_lower_file(file);

	if (lower_file && lower_file->f_op && lower_file->f_op->flush)

	if (lower_file && lower_file->f_op && lower_file->f_op->flush) {

		filemap_write_and_wait(file->f_mapping);

		err = lower_file->f_op->flush(lower_file, id);

	}



	return err;

}
@@ -296,19 +297,23 @@ static int sdcardfs_file_release(struct inode *inode, struct file *file) 
	return 0;

}



static int

sdcardfs_fsync(struct file *file, int datasync)

static int sdcardfs_fsync(struct file *file, loff_t start, loff_t end,

			int datasync)

{

	int err;

	struct file *lower_file;

	struct path lower_path;

	struct dentry *dentry = file->f_path.dentry;



	err = __generic_file_fsync(file, start, end, datasync);

	if (err)

		goto out;



	lower_file = sdcardfs_lower_file(file);

	sdcardfs_get_lower_path(dentry, &lower_path);

	err = vfs_fsync(lower_file, datasync);

	err = vfs_fsync_range(lower_file, start, end, datasync);

	sdcardfs_put_lower_path(dentry, &lower_path);



out:

	return err;

}
@@ -344,7 +349,7 @@ const struct file_operations sdcardfs_main_fops = { 
const struct file_operations sdcardfs_dir_fops = {

	.llseek		= generic_file_llseek,

	.read		= generic_read_dir,

	.readdir	= sdcardfs_readdir,

	.iterate	= sdcardfs_readdir,

	.unlocked_ioctl	= sdcardfs_unlocked_ioctl,

#ifdef CONFIG_COMPAT

	.compat_ioctl	= sdcardfs_compat_ioctl,

fs/sdcardfs/hashtable.h

deleted100644 → 0
+0 −190
Original line number Diff line number Diff line 
/*

 * Statically sized hash table implementation

 * (C) 2012  Sasha Levin <levinsasha928@gmail.com>

 */



#ifndef _LINUX_HASHTABLE_H

#define _LINUX_HASHTABLE_H



#include <linux/list.h>

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/hash.h>

#include <linux/rculist.h>



#define DEFINE_HASHTABLE(name, bits)                                            \

        struct hlist_head name[1 << (bits)] =                                   \

                        { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }



#define DECLARE_HASHTABLE(name, bits)                                           \

        struct hlist_head name[1 << (bits)]



#define HASH_SIZE(name) (ARRAY_SIZE(name))

#define HASH_BITS(name) ilog2(HASH_SIZE(name))



/* Use hash_32 when possible to allow for fast 32bit hashing in 64bit kernels. */

#define hash_min(val, bits)                                                     \

        (sizeof(val) <= 4 ? hash_32(val, bits) : hash_long(val, bits))



static inline void __hash_init(struct hlist_head *ht, unsigned int sz)

{

        unsigned int i;



        for (i = 0; i < sz; i++)

                INIT_HLIST_HEAD(&ht[i]);

}



/**

 * hash_init - initialize a hash table

 * @hashtable: hashtable to be initialized

 *

 * Calculates the size of the hashtable from the given parameter, otherwise

 * same as hash_init_size.

 *

 * This has to be a macro since HASH_BITS() will not work on pointers since

 * it calculates the size during preprocessing.

 */

#define hash_init(hashtable) __hash_init(hashtable, HASH_SIZE(hashtable))



/**

 * hash_add - add an object to a hashtable

 * @hashtable: hashtable to add to

 * @node: the &struct hlist_node of the object to be added

 * @key: the key of the object to be added

 */

#define hash_add(hashtable, node, key)                                          \

        hlist_add_head(node, &hashtable[hash_min(key, HASH_BITS(hashtable))])



/**

 * hash_add_rcu - add an object to a rcu enabled hashtable

 * @hashtable: hashtable to add to

 * @node: the &struct hlist_node of the object to be added

 * @key: the key of the object to be added

 */

#define hash_add_rcu(hashtable, node, key)                                      \

        hlist_add_head_rcu(node, &hashtable[hash_min(key, HASH_BITS(hashtable))])



/**

 * hash_hashed - check whether an object is in any hashtable

 * @node: the &struct hlist_node of the object to be checked

 */

static inline bool hash_hashed(struct hlist_node *node)

{

        return !hlist_unhashed(node);

}



static inline bool __hash_empty(struct hlist_head *ht, unsigned int sz)

{

        unsigned int i;



        for (i = 0; i < sz; i++)

                if (!hlist_empty(&ht[i]))

                        return false;



        return true;

}



/**

 * hash_empty - check whether a hashtable is empty

 * @hashtable: hashtable to check

 *

 * This has to be a macro since HASH_BITS() will not work on pointers since

 * it calculates the size during preprocessing.

 */

#define hash_empty(hashtable) __hash_empty(hashtable, HASH_SIZE(hashtable))



/**

 * hash_del - remove an object from a hashtable

 * @node: &struct hlist_node of the object to remove

 */

static inline void hash_del(struct hlist_node *node)

{

        hlist_del_init(node);

}



/**

 * hash_del_rcu - remove an object from a rcu enabled hashtable

 * @node: &struct hlist_node of the object to remove

 */

static inline void hash_del_rcu(struct hlist_node *node)

{

        hlist_del_init_rcu(node);

}



/**

 * hash_for_each - iterate over a hashtable

 * @name: hashtable to iterate

 * @bkt: integer to use as bucket loop cursor

 * @obj: the type * to use as a loop cursor for each entry

 * @member: the name of the hlist_node within the struct

 */

#define hash_for_each(name, bkt, obj, member, pos)                           \

        for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < HASH_SIZE(name);\

                        (bkt)++)\

                hlist_for_each_entry(obj, pos, &name[bkt], member)



/**

 * hash_for_each_rcu - iterate over a rcu enabled hashtable

 * @name: hashtable to iterate

 * @bkt: integer to use as bucket loop cursor

 * @obj: the type * to use as a loop cursor for each entry

 * @member: the name of the hlist_node within the struct

 */

#define hash_for_each_rcu(name, bkt, obj, member)                       \

        for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < HASH_SIZE(name);\

                        (bkt)++)\

                hlist_for_each_entry_rcu(obj, &name[bkt], member)



/**

 * hash_for_each_safe - iterate over a hashtable safe against removal of

 * hash entry

 * @name: hashtable to iterate

 * @bkt: integer to use as bucket loop cursor

 * @tmp: a &struct used for temporary storage

 * @obj: the type * to use as a loop cursor for each entry

 * @member: the name of the hlist_node within the struct

 */

#define hash_for_each_safe(name, bkt, tmp, obj, member, pos)                 \

        for ((bkt) = 0, obj = NULL; (bkt) < HASH_SIZE(name);\

                        (bkt)++)\

                hlist_for_each_entry_safe(obj, pos, tmp, &name[bkt], member)



/**

 * hash_for_each_possible - iterate over all possible objects hashing to the

 * same bucket

 * @name: hashtable to iterate

 * @obj: the type * to use as a loop cursor for each entry

 * @member: the name of the hlist_node within the struct

 * @key: the key of the objects to iterate over

 */

#define hash_for_each_possible(name, obj, member, key, pos)                  \

        hlist_for_each_entry(obj, pos, &name[hash_min(key, HASH_BITS(name))], member)



/**

 * hash_for_each_possible_rcu - iterate over all possible objects hashing to the

 * same bucket in an rcu enabled hashtable

 * in a rcu enabled hashtable

 * @name: hashtable to iterate

 * @obj: the type * to use as a loop cursor for each entry

 * @member: the name of the hlist_node within the struct

 * @key: the key of the objects to iterate over

 */

#define hash_for_each_possible_rcu(name, obj, member, key)              \

        hlist_for_each_entry_rcu(obj, &name[hash_min(key, HASH_BITS(name))],\

                member)



/**

 * hash_for_each_possible_safe - iterate over all possible objects hashing to the

 * same bucket safe against removals

 * @name: hashtable to iterate

 * @obj: the type * to use as a loop cursor for each entry

 * @tmp: a &struct used for temporary storage

 * @member: the name of the hlist_node within the struct

 * @key: the key of the objects to iterate over

 */

#define hash_for_each_possible_safe(name, obj, tmp, member, key)        \

        hlist_for_each_entry_safe(obj, tmp,\

                &name[hash_min(key, HASH_BITS(name))], member)





#endif

fs/sdcardfs/inode.c

+70 −134
Original line number Diff line number Diff line
@@ -30,8 +30,8 @@ const struct cred * override_fsids(struct sdcardfs_sb_info* sbi) 
	if (!cred)

		return NULL;



	cred->fsuid = sbi->options.fs_low_uid;

	cred->fsgid = sbi->options.fs_low_gid;

	cred->fsuid = make_kuid(&init_user_ns, sbi->options.fs_low_uid);

	cred->fsgid = make_kgid(&init_user_ns, sbi->options.fs_low_gid);



	old_cred = override_creds(cred);
@@ -49,12 +49,12 @@ void revert_fsids(const struct cred * old_cred) 
}



static int sdcardfs_create(struct inode *dir, struct dentry *dentry,

			 int mode, struct nameidata *nd)

			 umode_t mode, bool want_excl)

{

	int err = 0;

	int err;

	struct dentry *lower_dentry;

	struct dentry *lower_parent_dentry = NULL;

	struct path lower_path, saved_path;

	struct path lower_path;

	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);

	const struct cred *saved_cred = NULL;
@@ -74,18 +74,9 @@ static int sdcardfs_create(struct inode *dir, struct dentry *dentry, 
	lower_dentry = lower_path.dentry;

	lower_parent_dentry = lock_parent(lower_dentry);



	err = mnt_want_write(lower_path.mnt);

	if (err)

		goto out_unlock;



	pathcpy(&saved_path, &nd->path);

	pathcpy(&nd->path, &lower_path);



	/* set last 16bytes of mode field to 0664 */

	mode = (mode & S_IFMT) | 00664;

	err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode, nd);



	pathcpy(&nd->path, &saved_path);

	err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode, want_excl);

	if (err)

		goto out;
@@ -96,8 +87,6 @@ static int sdcardfs_create(struct inode *dir, struct dentry *dentry, 
	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);



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);
@@ -125,12 +114,8 @@ static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir, 
	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, lower_dir_dentry->d_inode,

		       lower_new_dentry);

		       lower_new_dentry, NULL);

	if (err || !lower_new_dentry->d_inode)

		goto out;
@@ -139,12 +124,10 @@ static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir, 
		goto out;

	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);

	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);

	old_dentry->d_inode->i_nlink =

		  sdcardfs_lower_inode(old_dentry->d_inode)->i_nlink;

	set_nlink(old_dentry->d_inode,

		  sdcardfs_lower_inode(old_dentry->d_inode)->i_nlink);

	i_size_write(new_dentry->d_inode, 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);
@@ -180,10 +163,7 @@ static int sdcardfs_unlink(struct inode *dir, struct dentry *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);

	err = vfs_unlink(lower_dir_inode, lower_dentry, NULL);



	/*

	 * Note: unlinking on top of NFS can cause silly-renamed files.
@@ -198,13 +178,11 @@ static int sdcardfs_unlink(struct inode *dir, struct dentry *dentry) 
		goto out;

	fsstack_copy_attr_times(dir, lower_dir_inode);

	fsstack_copy_inode_size(dir, lower_dir_inode);

	dentry->d_inode->i_nlink =

		  sdcardfs_lower_inode(dentry->d_inode)->i_nlink;

	set_nlink(dentry->d_inode,

		  sdcardfs_lower_inode(dentry->d_inode)->i_nlink);

	dentry->d_inode->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);
@@ -217,7 +195,7 @@ out_eacces: 
static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry,

			  const char *symname)

{

	int err = 0;

	int err;

	struct dentry *lower_dentry;

	struct dentry *lower_parent_dentry = NULL;

	struct path lower_path;
@@ -228,9 +206,6 @@ static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry, 
	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(lower_parent_dentry->d_inode, lower_dentry, symname);

	if (err)

		goto out;
@@ -241,8 +216,6 @@ static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry, 
	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);



out:

	mnt_drop_write(lower_path.mnt);

out_unlock:

	unlock_dir(lower_parent_dentry);

	sdcardfs_put_lower_path(dentry, &lower_path);

	REVERT_CRED();
@@ -266,9 +239,9 @@ static int touch(char *abs_path, mode_t mode) { 
	return 0;

}



static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)

static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)

{

	int err = 0;

	int err;

	int make_nomedia_in_obb = 0;

	struct dentry *lower_dentry;

	struct dentry *lower_parent_dentry = NULL;
@@ -306,10 +279,6 @@ static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
	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 0775 */

	mode = (mode & S_IFMT) | 00775;

	err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry, mode);
@@ -343,7 +312,7 @@ static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
	fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));

	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);

	/* update number of links on parent directory */

	dir->i_nlink = sdcardfs_lower_inode(dir)->i_nlink;

	set_nlink(dir, sdcardfs_lower_inode(dir)->i_nlink);



	if ((sbi->options.derive == DERIVE_UNIFIED) && (!strcasecmp(dentry->d_name.name, "obb"))

		&& (pi->perm == PERM_ANDROID) && (pi->userid == 0))
@@ -388,8 +357,6 @@ static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
		kfree(nomedia_fullpath);

	}

out:

	mnt_drop_write(lower_path.mnt);

out_unlock:

	unlock_dir(lower_parent_dentry);

	sdcardfs_put_lower_path(dentry, &lower_path);

out_revert:
@@ -427,9 +394,6 @@ static int sdcardfs_rmdir(struct inode *dir, struct dentry *dentry) 
	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(lower_dir_dentry->d_inode, lower_dentry);

	if (err)

		goto out;
@@ -439,11 +403,9 @@ static int sdcardfs_rmdir(struct inode *dir, struct dentry *dentry) 
		clear_nlink(dentry->d_inode);

	fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);

	fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);

	dir->i_nlink = lower_dir_dentry->d_inode->i_nlink;

	set_nlink(dir, lower_dir_dentry->d_inode->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);
@@ -452,10 +414,10 @@ out_eacces: 
}



#if 0

static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, int mode,

static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,

			dev_t dev)

{

	int err = 0;

	int err;

	struct dentry *lower_dentry;

	struct dentry *lower_parent_dentry = NULL;

	struct path lower_path;
@@ -466,9 +428,6 @@ static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, int mode, 
	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(lower_parent_dentry->d_inode, lower_dentry, mode, dev);

	if (err)

		goto out;
@@ -480,8 +439,6 @@ static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, int mode, 
	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);



out:

	mnt_drop_write(lower_path.mnt);

out_unlock:

	unlock_dir(lower_parent_dentry);

	sdcardfs_put_lower_path(dentry, &lower_path);

	REVERT_CRED();
@@ -541,17 +498,11 @@ static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
		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(lower_old_dir_dentry->d_inode, lower_old_dentry,

			 lower_new_dir_dentry->d_inode, lower_new_dentry);

			 lower_new_dir_dentry->d_inode, lower_new_dentry,

			 NULL, 0);

	if (err)

		goto out_err;

		goto out;



	/* Copy attrs from lower dir, but i_uid/i_gid */

	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
@@ -574,10 +525,6 @@ static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
		}

	}



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);
@@ -648,29 +595,15 @@ out: 
}

#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, unsigned int flags)

static int sdcardfs_permission(struct inode *inode, int mask)

{

	int err;



	if (flags & IPERM_FLAG_RCU)

		return -ECHILD;



	/*

	 * Permission check on sdcardfs inode.

	 * Calling process should have AID_SDCARD_RW permission

	 */

	err = generic_permission(inode, mask, 0, inode->i_op->check_acl);

	err = generic_permission(inode, mask);



	/* XXX

	 * Original sdcardfs code calls inode_permission(lower_inode,.. )
@@ -700,49 +633,9 @@ static int sdcardfs_permission(struct inode *inode, int mask, unsigned int flags 


}



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;

	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);



	parent = dget_parent(dentry);

	if(!check_caller_access_to_name(parent->d_inode, dentry->d_name.name,

						sbi->options.derive, 0, 0)) {

		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 = dentry->d_inode;



	sdcardfs_get_lower_path(dentry, &lower_path);

	lower_dentry = lower_path.dentry;

	lower_inode = sdcardfs_lower_inode(inode);



	fsstack_copy_attr_all(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);



	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 = 0;

	int err;

	struct dentry *lower_dentry;

	struct inode *inode;

	struct inode *lower_inode;
@@ -824,7 +717,8 @@ static int sdcardfs_setattr(struct dentry *dentry, struct iattr *ia) 
	 * tries to open(), unlink(), then ftruncate() a file.

	 */

	mutex_lock(&lower_dentry->d_inode->i_mutex);

	err = notify_change(lower_dentry, &lower_ia); /* note: lower_ia */

	err = notify_change(lower_dentry, &lower_ia, /* note: lower_ia */

			NULL);

	mutex_unlock(&lower_dentry->d_inode->i_mutex);

	if (current->mm)

		up_write(&current->mm->mmap_sem);
@@ -848,6 +742,46 @@ out_err: 
	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;

	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);



	parent = dget_parent(dentry);

	if(!check_caller_access_to_name(parent->d_inode, dentry->d_name.name,

						sbi->options.derive, 0, 0)) {

		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 = dentry->d_inode;



	sdcardfs_get_lower_path(dentry, &lower_path);

	lower_dentry = lower_path.dentry;

	lower_inode = sdcardfs_lower_inode(inode);



	fsstack_copy_attr_all(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);



	generic_fillattr(inode, stat);

	sdcardfs_put_lower_path(dentry, &lower_path);

	return 0;

}



const struct inode_operations sdcardfs_symlink_iops = {

	.permission	= sdcardfs_permission,

	.setattr	= sdcardfs_setattr,
@@ -856,14 +790,16 @@ const struct inode_operations sdcardfs_symlink_iops = { 
	 *     These methods are *NOT* perfectly tested.

	.readlink	= sdcardfs_readlink,

	.follow_link	= sdcardfs_follow_link,

	.put_link	= sdcardfs_put_link,

	.put_link	= kfree_put_link,

	 */

};



const struct inode_operations sdcardfs_dir_iops = {

	.create		= sdcardfs_create,

	.lookup		= sdcardfs_lookup,

#if 0

	.permission	= sdcardfs_permission,

#endif

	.unlink		= sdcardfs_unlink,

	.mkdir		= sdcardfs_mkdir,

	.rmdir		= sdcardfs_rmdir,