Port of sdcardfs to 4.4 (e76fbcd4) · Commits · e / devices / android_kernel_sony_msm8998

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

+26 −21

Original line number	Diff line number	Diff line
		@@ -50,8 +50,8 @@ static ssize_t sdcardfs_read(struct file file, char __user buf,
		err = vfs_read(lower_file, buf, count, ppos);
		/* 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);
		fsstack_copy_attr_atime(d_inode(dentry),
		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;

		@@ -73,29 +73,29 @@ static ssize_t sdcardfs_write(struct file file, const char __user buf,
		err = vfs_write(lower_file, buf, count, ppos);
		/* 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);
		fsstack_copy_attr_times(dentry->d_inode,
		lower_file->f_path.dentry->d_inode);
		fsstack_copy_inode_size(d_inode(dentry),
		file_inode(lower_file));
		fsstack_copy_attr_times(d_inode(dentry),
		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);
		fsstack_copy_attr_atime(d_inode(dentry),
		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

+107 −173

File changed.

Preview size limit exceeded, changes collapsed.