VFS: Put a small type field into struct dentry::d_flags (b18825a7) · Commits · e / devices / android_kernel_sony_msm8998

fs/dcache.c

+37 −5

Original line number	Diff line number	Diff line
		@@ -343,6 +343,7 @@ static void dentry_unlink_inode(struct dentry * dentry)
		__releases(dentry->d_inode->i_lock)
		{
		struct inode *inode = dentry->d_inode;
		__d_clear_type(dentry);
		dentry->d_inode = NULL;
		hlist_del_init(&dentry->d_alias);
		dentry_rcuwalk_barrier(dentry);
		@@ -1648,14 +1649,42 @@ void d_set_d_op(struct dentry dentry, const struct dentry_operations op)
		}
		EXPORT_SYMBOL(d_set_d_op);

		static unsigned d_flags_for_inode(struct inode *inode)
		{
		unsigned add_flags = DCACHE_FILE_TYPE;

		if (!inode)
		return DCACHE_MISS_TYPE;

		if (S_ISDIR(inode->i_mode)) {
		add_flags = DCACHE_DIRECTORY_TYPE;
		if (unlikely(!(inode->i_opflags & IOP_LOOKUP))) {
		if (unlikely(!inode->i_op->lookup))
		add_flags = DCACHE_AUTODIR_TYPE;
		else
		inode->i_opflags \|= IOP_LOOKUP;
		}
		} else if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
		if (unlikely(inode->i_op->follow_link))
		add_flags = DCACHE_SYMLINK_TYPE;
		else
		inode->i_opflags \|= IOP_NOFOLLOW;
		}

		if (unlikely(IS_AUTOMOUNT(inode)))
		add_flags \|= DCACHE_NEED_AUTOMOUNT;
		return add_flags;
		}

		static void __d_instantiate(struct dentry dentry, struct inode inode)
		{
		unsigned add_flags = d_flags_for_inode(inode);

		spin_lock(&dentry->d_lock);
		if (inode) {
		if (unlikely(IS_AUTOMOUNT(inode)))
		dentry->d_flags \|= DCACHE_NEED_AUTOMOUNT;
		dentry->d_flags &= ~DCACHE_ENTRY_TYPE;
		dentry->d_flags \|= add_flags;
		if (inode)
		hlist_add_head(&dentry->d_alias, &inode->i_dentry);
		}
		dentry->d_inode = inode;
		dentry_rcuwalk_barrier(dentry);
		spin_unlock(&dentry->d_lock);
		@@ -1860,6 +1889,7 @@ struct dentry d_obtain_alias(struct inode inode)
		static const struct qstr anonstring = QSTR_INIT("/", 1);
		struct dentry *tmp;
		struct dentry *res;
		unsigned add_flags;

		if (!inode)
		return ERR_PTR(-ESTALE);
		@@ -1885,9 +1915,11 @@ struct dentry d_obtain_alias(struct inode inode)
		}

		/* attach a disconnected dentry */
		add_flags = d_flags_for_inode(inode) \| DCACHE_DISCONNECTED;

		spin_lock(&tmp->d_lock);
		tmp->d_inode = inode;
		tmp->d_flags \|= DCACHE_DISCONNECTED;
		tmp->d_flags \|= add_flags;
		hlist_add_head(&tmp->d_alias, &inode->i_dentry);
		hlist_bl_lock(&tmp->d_sb->s_anon);
		hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);

fs/namei.c

+38 −57

Original line number	Diff line number	Diff line
		@@ -1501,18 +1501,9 @@ static void terminate_walk(struct nameidata *nd)
		* so we keep a cache of "no, this doesn't need follow_link"
		* for the common case.
		*/
		static inline int should_follow_link(struct inode *inode, int follow)
		static inline int should_follow_link(struct dentry *dentry, int follow)
		{
		if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
		if (likely(inode->i_op->follow_link))
		return follow;

		/* This gets set once for the inode lifetime */
		spin_lock(&inode->i_lock);
		inode->i_opflags \|= IOP_NOFOLLOW;
		spin_unlock(&inode->i_lock);
		}
		return 0;
		return unlikely(d_is_symlink(dentry)) ? follow : 0;
		}

		static inline int walk_component(struct nameidata nd, struct path path,
		@@ -1542,7 +1533,7 @@ static inline int walk_component(struct nameidata nd, struct path path,
		if (!inode)
		goto out_path_put;

		if (should_follow_link(inode, follow)) {
		if (should_follow_link(path->dentry, follow)) {
		if (nd->flags & LOOKUP_RCU) {
		if (unlikely(unlazy_walk(nd, path->dentry))) {
		err = -ECHILD;
		@@ -1600,26 +1591,6 @@ static inline int nested_symlink(struct path path, struct nameidata nd)
		return res;
		}

		/*
		* We really don't want to look at inode->i_op->lookup
		* when we don't have to. So we keep a cache bit in
		* the inode ->i_opflags field that says "yes, we can
		* do lookup on this inode".
		*/
		static inline int can_lookup(struct inode *inode)
		{
		if (likely(inode->i_opflags & IOP_LOOKUP))
		return 1;
		if (likely(!inode->i_op->lookup))
		return 0;

		/* We do this once for the lifetime of the inode */
		spin_lock(&inode->i_lock);
		inode->i_opflags \|= IOP_LOOKUP;
		spin_unlock(&inode->i_lock);
		return 1;
		}

		/*
		* We can do the critical dentry name comparison and hashing
		* operations one word at a time, but we are limited to:
		@@ -1823,7 +1794,7 @@ static int link_path_walk(const char name, struct nameidata nd)
		if (err)
		return err;
		}
		if (!can_lookup(nd->inode)) {
		if (!d_is_directory(nd->path.dentry)) {
		err = -ENOTDIR;
		break;
		}
		@@ -1841,9 +1812,10 @@ static int path_init(int dfd, const char *name, unsigned int flags,
		nd->flags = flags \| LOOKUP_JUMPED;
		nd->depth = 0;
		if (flags & LOOKUP_ROOT) {
		struct inode *inode = nd->root.dentry->d_inode;
		struct dentry *root = nd->root.dentry;
		struct inode *inode = root->d_inode;
		if (*name) {
		if (!can_lookup(inode))
		if (!d_is_directory(root))
		return -ENOTDIR;
		retval = inode_permission(inode, MAY_EXEC);
		if (retval)
		@@ -1899,7 +1871,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
		dentry = f.file->f_path.dentry;

		if (*name) {
		if (!can_lookup(dentry->d_inode)) {
		if (!d_is_directory(dentry)) {
		fdput(f);
		return -ENOTDIR;
		}
		@@ -1981,7 +1953,7 @@ static int path_lookupat(int dfd, const char *name,
		err = complete_walk(nd);

		if (!err && nd->flags & LOOKUP_DIRECTORY) {
		if (!can_lookup(nd->inode)) {
		if (!d_is_directory(nd->path.dentry)) {
		path_put(&nd->path);
		err = -ENOTDIR;
		}
		@@ -2273,7 +2245,7 @@ done:
		}
		path->dentry = dentry;
		path->mnt = mntget(nd->path.mnt);
		if (should_follow_link(dentry->d_inode, nd->flags & LOOKUP_FOLLOW))
		if (should_follow_link(dentry, nd->flags & LOOKUP_FOLLOW))
		return 1;
		follow_mount(path);
		error = 0;
		@@ -2417,12 +2389,14 @@ static inline int check_sticky(struct inode dir, struct inode inode)
		* 10. We don't allow removal of NFS sillyrenamed files; it's handled by
		* nfs_async_unlink().
		*/
		static int may_delete(struct inode dir,struct dentry victim,int isdir)
		static int may_delete(struct inode dir, struct dentry victim, bool isdir)
		{
		struct inode *inode = victim->d_inode;
		int error;

		if (!victim->d_inode)
		if (d_is_negative(victim))
		return -ENOENT;
		BUG_ON(!inode);

		BUG_ON(victim->d_parent->d_inode != dir);
		audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
		@@ -2432,15 +2406,16 @@ static int may_delete(struct inode dir,struct dentry victim,int isdir)
		return error;
		if (IS_APPEND(dir))
		return -EPERM;
		if (check_sticky(dir, victim->d_inode)\|\|IS_APPEND(victim->d_inode)\|\|
		IS_IMMUTABLE(victim->d_inode) \|\| IS_SWAPFILE(victim->d_inode))

		if (check_sticky(dir, inode) \|\| IS_APPEND(inode) \|\|
		IS_IMMUTABLE(inode) \|\| IS_SWAPFILE(inode))
		return -EPERM;
		if (isdir) {
		if (!S_ISDIR(victim->d_inode->i_mode))
		if (!d_is_directory(victim) && !d_is_autodir(victim))
		return -ENOTDIR;
		if (IS_ROOT(victim))
		return -EBUSY;
		} else if (S_ISDIR(victim->d_inode->i_mode))
		} else if (d_is_directory(victim) \|\| d_is_autodir(victim))
		return -EISDIR;
		if (IS_DEADDIR(dir))
		return -ENOENT;
		@@ -2974,7 +2949,7 @@ retry_lookup:
		/*
		* create/update audit record if it already exists.
		*/
		if (path->dentry->d_inode)
		if (d_is_positive(path->dentry))
		audit_inode(name, path->dentry, 0);

		/*
		@@ -3003,12 +2978,12 @@ retry_lookup:
		finish_lookup:
		/* we _can_ be in RCU mode here */
		error = -ENOENT;
		if (!inode) {
		if (d_is_negative(path->dentry)) {
		path_to_nameidata(path, nd);
		goto out;
		}

		if (should_follow_link(inode, !symlink_ok)) {
		if (should_follow_link(path->dentry, !symlink_ok)) {
		if (nd->flags & LOOKUP_RCU) {
		if (unlikely(unlazy_walk(nd, path->dentry))) {
		error = -ECHILD;
		@@ -3037,10 +3012,11 @@ finish_open:
		}
		audit_inode(name, nd->path.dentry, 0);
		error = -EISDIR;
		if ((open_flag & O_CREAT) && S_ISDIR(nd->inode->i_mode))
		if ((open_flag & O_CREAT) &&
		(d_is_directory(nd->path.dentry) \|\| d_is_autodir(nd->path.dentry)))
		goto out;
		error = -ENOTDIR;
		if ((nd->flags & LOOKUP_DIRECTORY) && !can_lookup(nd->inode))
		if ((nd->flags & LOOKUP_DIRECTORY) && !d_is_directory(nd->path.dentry))
		goto out;
		if (!S_ISREG(nd->inode->i_mode))
		will_truncate = false;
		@@ -3266,7 +3242,7 @@ struct file do_file_open_root(struct dentry dentry, struct vfsmount *mnt,
		nd.root.mnt = mnt;
		nd.root.dentry = dentry;

		if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN)
		if (d_is_symlink(dentry) && op->intent & LOOKUP_OPEN)
		return ERR_PTR(-ELOOP);

		file = path_openat(-1, &filename, &nd, op, flags \| LOOKUP_RCU);
		@@ -3316,8 +3292,9 @@ struct dentry kern_path_create(int dfd, const char pathname,
		goto unlock;

		error = -EEXIST;
		if (dentry->d_inode)
		if (d_is_positive(dentry))
		goto fail;

		/*
		* Special case - lookup gave negative, but... we had foo/bar/
		* From the vfs_mknod() POV we just have a negative dentry -
		@@ -3706,7 +3683,7 @@ retry:
		if (nd.last.name[nd.last.len])
		goto slashes;
		inode = dentry->d_inode;
		if (!inode)
		if (d_is_negative(dentry))
		goto slashes;
		ihold(inode);
		error = security_path_unlink(&nd.path, dentry);
		@@ -3731,8 +3708,12 @@ exit1:
		return error;

		slashes:
		error = !dentry->d_inode ? -ENOENT :
		S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
		if (d_is_negative(dentry))
		error = -ENOENT;
		else if (d_is_directory(dentry) \|\| d_is_autodir(dentry))
		error = -EISDIR;
		else
		error = -ENOTDIR;
		goto exit2;
		}

		@@ -4046,7 +4027,7 @@ int vfs_rename(struct inode old_dir, struct dentry old_dentry,
		struct inode new_dir, struct dentry new_dentry)
		{
		int error;
		int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
		int is_dir = d_is_directory(old_dentry) \|\| d_is_autodir(old_dentry);
		const unsigned char *old_name;

		if (old_dentry->d_inode == new_dentry->d_inode)
		@@ -4134,10 +4115,10 @@ retry:
		goto exit3;
		/* source must exist */
		error = -ENOENT;
		if (!old_dentry->d_inode)
		if (d_is_negative(old_dentry))
		goto exit4;
		/* unless the source is a directory trailing slashes give -ENOTDIR */
		if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
		if (!d_is_directory(old_dentry) && !d_is_autodir(old_dentry)) {
		error = -ENOTDIR;
		if (oldnd.last.name[oldnd.last.len])
		goto exit4;

include/linux/dcache.h

+83 −20

Original line number	Diff line number	Diff line
		@@ -169,13 +169,13 @@ struct dentry_operations {
		*/

		/* d_flags entries */
		#define DCACHE_OP_HASH 0x0001
		#define DCACHE_OP_COMPARE 0x0002
		#define DCACHE_OP_REVALIDATE 0x0004
		#define DCACHE_OP_DELETE 0x0008
		#define DCACHE_OP_PRUNE 0x0010
		#define DCACHE_OP_HASH 0x00000001
		#define DCACHE_OP_COMPARE 0x00000002
		#define DCACHE_OP_REVALIDATE 0x00000004
		#define DCACHE_OP_DELETE 0x00000008
		#define DCACHE_OP_PRUNE 0x00000010

		#define DCACHE_DISCONNECTED 0x0020
		#define DCACHE_DISCONNECTED 0x00000020
		/* This dentry is possibly not currently connected to the dcache tree, in
		* which case its parent will either be itself, or will have this flag as
		* well. nfsd will not use a dentry with this bit set, but will first
		@@ -186,30 +186,38 @@ struct dentry_operations {
		* dentry into place and return that dentry rather than the passed one,
		* typically using d_splice_alias. */

		#define DCACHE_REFERENCED 0x0040 /* Recently used, don't discard. */
		#define DCACHE_RCUACCESS 0x0080 /* Entry has ever been RCU-visible */
		#define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */
		#define DCACHE_RCUACCESS 0x00000080 /* Entry has ever been RCU-visible */

		#define DCACHE_CANT_MOUNT 0x0100
		#define DCACHE_GENOCIDE 0x0200
		#define DCACHE_SHRINK_LIST 0x0400
		#define DCACHE_CANT_MOUNT 0x00000100
		#define DCACHE_GENOCIDE 0x00000200
		#define DCACHE_SHRINK_LIST 0x00000400

		#define DCACHE_OP_WEAK_REVALIDATE 0x0800
		#define DCACHE_OP_WEAK_REVALIDATE 0x00000800

		#define DCACHE_NFSFS_RENAMED 0x1000
		#define DCACHE_NFSFS_RENAMED 0x00001000
		/* this dentry has been "silly renamed" and has to be deleted on the last
		* dput() */
		#define DCACHE_COOKIE 0x2000 /* For use by dcookie subsystem */
		#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
		#define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */
		#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000
		/* Parent inode is watched by some fsnotify listener */

		#define DCACHE_MOUNTED 0x10000 /* is a mountpoint */
		#define DCACHE_NEED_AUTOMOUNT 0x20000 /* handle automount on this dir */
		#define DCACHE_MANAGE_TRANSIT 0x40000 /* manage transit from this dirent */
		#define DCACHE_DENTRY_KILLED 0x00008000

		#define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */
		#define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */
		#define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */
		#define DCACHE_MANAGED_DENTRY \
		(DCACHE_MOUNTED\|DCACHE_NEED_AUTOMOUNT\|DCACHE_MANAGE_TRANSIT)

		#define DCACHE_LRU_LIST 0x80000
		#define DCACHE_DENTRY_KILLED 0x100000
		#define DCACHE_LRU_LIST 0x00080000

		#define DCACHE_ENTRY_TYPE 0x00700000
		#define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry */
		#define DCACHE_DIRECTORY_TYPE 0x00100000 /* Normal directory */
		#define DCACHE_AUTODIR_TYPE 0x00200000 /* Lookupless directory (presumed automount) */
		#define DCACHE_SYMLINK_TYPE 0x00300000 /* Symlink */
		#define DCACHE_FILE_TYPE 0x00400000 /* Other file type */

		extern seqlock_t rename_lock;

		@@ -394,6 +402,61 @@ static inline bool d_mountpoint(const struct dentry *dentry)
		return dentry->d_flags & DCACHE_MOUNTED;
		}

		/*
		* Directory cache entry type accessor functions.
		*/
		static inline void __d_set_type(struct dentry *dentry, unsigned type)
		{
		dentry->d_flags = (dentry->d_flags & ~DCACHE_ENTRY_TYPE) \| type;
		}

		static inline void __d_clear_type(struct dentry *dentry)
		{
		__d_set_type(dentry, DCACHE_MISS_TYPE);
		}

		static inline void d_set_type(struct dentry *dentry, unsigned type)
		{
		spin_lock(&dentry->d_lock);
		__d_set_type(dentry, type);
		spin_unlock(&dentry->d_lock);
		}

		static inline unsigned __d_entry_type(const struct dentry *dentry)
		{
		return dentry->d_flags & DCACHE_ENTRY_TYPE;
		}

		static inline bool d_is_directory(const struct dentry *dentry)
		{
		return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE;
		}

		static inline bool d_is_autodir(const struct dentry *dentry)
		{
		return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE;
		}

		static inline bool d_is_symlink(const struct dentry *dentry)
		{
		return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE;
		}

		static inline bool d_is_file(const struct dentry *dentry)
		{
		return __d_entry_type(dentry) == DCACHE_FILE_TYPE;
		}

		static inline bool d_is_negative(const struct dentry *dentry)
		{
		return __d_entry_type(dentry) == DCACHE_MISS_TYPE;
		}

		static inline bool d_is_positive(const struct dentry *dentry)
		{
		return !d_is_negative(dentry);
		}

		extern int sysctl_vfs_cache_pressure;

		static inline unsigned long vfs_pressure_ratio(unsigned long val)