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

Commit fb16043b authored by Miklos Szeredi's avatar Miklos Szeredi
Browse files

vfs: remove open_flags from d_real() 



Opening regular files on overlayfs is now handled via ovl_open().  Remove
the now unused "open_flags" argument from d_op->d_real() and the d_real()
helper.

Signed-off-by: default avatarMiklos Szeredi <mszeredi@redhat.com>
parent 573e1784

Documentation/filesystems/Locking

+1 −2
Original line number Diff line number Diff line
@@ -21,8 +21,7 @@ prototypes: 
	char *(*d_dname)((struct dentry *dentry, char *buffer, int buflen);

	struct vfsmount *(*d_automount)(struct path *path);

	int (*d_manage)(const struct path *, bool);

	struct dentry *(*d_real)(struct dentry *, const struct inode *,

				 unsigned int);

	struct dentry *(*d_real)(struct dentry *, const struct inode *);



locking rules:

		rename_lock	->d_lock	may block	rcu-walk

Documentation/filesystems/vfs.txt

+4 −12
Original line number Diff line number Diff line
@@ -1000,8 +1000,7 @@ struct dentry_operations { 
	char *(*d_dname)(struct dentry *, char *, int);

	struct vfsmount *(*d_automount)(struct path *);

	int (*d_manage)(const struct path *, bool);

	struct dentry *(*d_real)(struct dentry *, const struct inode *,

				 unsigned int);

	struct dentry *(*d_real)(struct dentry *, const struct inode *);

};



  d_revalidate: called when the VFS needs to revalidate a dentry. This
@@ -1135,22 +1134,15 @@ struct dentry_operations { 
	dentry being transited from.



  d_real: overlay/union type filesystems implement this method to return one of

	the underlying dentries hidden by the overlay.  It is used in three

	the underlying dentries hidden by the overlay.  It is used in two

	different modes:



	Called from open it may need to copy-up the file depending on the

	supplied open flags.  This mode is selected with a non-zero flags

	argument.  In this mode the d_real method can return an error.



	Called from file_dentry() it returns the real dentry matching the inode

	argument.  The real dentry may be from a lower layer already copied up,

	but still referenced from the file.  This mode is selected with a

	non-NULL inode argument.  This will always succeed.



	With NULL inode and zero flags the topmost real underlying dentry is

	returned.  This will always succeed.

	non-NULL inode argument.



	This method is never called with both non-NULL inode and non-zero flags.

	With NULL inode the topmost real underlying dentry is returned.



Each dentry has a pointer to its parent dentry, as well as a hash list

of child dentries. Child dentries are basically like files in a

fs/overlayfs/super.c

+3 −33
Original line number Diff line number Diff line
@@ -74,28 +74,10 @@ static void ovl_dentry_release(struct dentry *dentry) 
	}

}



static int ovl_check_append_only(struct inode *inode, int flag)

{

	/*

	 * This test was moot in vfs may_open() because overlay inode does

	 * not have the S_APPEND flag, so re-check on real upper inode

	 */

	if (IS_APPEND(inode)) {

		if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))

			return -EPERM;

		if (flag & O_TRUNC)

			return -EPERM;

	}



	return 0;

}



static struct dentry *ovl_d_real(struct dentry *dentry,

				 const struct inode *inode,

				 unsigned int open_flags)

				 const struct inode *inode)

{

	struct dentry *real;

	int err;



	/* It's an overlay file */

	if (inode && d_inode(dentry) == inode)
@@ -107,28 +89,16 @@ static struct dentry *ovl_d_real(struct dentry *dentry, 
		goto bug;

	}



	if (open_flags) {

		err = ovl_open_maybe_copy_up(dentry, open_flags);

		if (err)

			return ERR_PTR(err);

	}



	real = ovl_dentry_upper(dentry);

	if (real && (!inode || inode == d_inode(real))) {

		if (!inode) {

			err = ovl_check_append_only(d_inode(real), open_flags);

			if (err)

				return ERR_PTR(err);

		}

	if (real && (!inode || inode == d_inode(real)))

		return real;

	}



	real = ovl_dentry_lower(dentry);

	if (!real)

		goto bug;



	/* Handle recursion */

	real = d_real(real, inode, open_flags);

	real = d_real(real, inode);



	if (!inode || inode == d_inode(real))

		return real;

include/linux/dcache.h

+4 −7
Original line number Diff line number Diff line
@@ -145,8 +145,7 @@ struct dentry_operations { 
	char *(*d_dname)(struct dentry *, char *, int);

	struct vfsmount *(*d_automount)(struct path *);

	int (*d_manage)(const struct path *, bool);

	struct dentry *(*d_real)(struct dentry *, const struct inode *,

				 unsigned int);

	struct dentry *(*d_real)(struct dentry *, const struct inode *);

} ____cacheline_aligned;



/*
@@ -568,7 +567,6 @@ static inline struct dentry *d_backing_dentry(struct dentry *upper) 
 * d_real - Return the real dentry

 * @dentry: the dentry to query

 * @inode: inode to select the dentry from multiple layers (can be NULL)

 * @flags: open flags to control copy-up behavior

 *

 * If dentry is on a union/overlay, then return the underlying, real dentry.

 * Otherwise return the dentry itself.
@@ -576,11 +574,10 @@ static inline struct dentry *d_backing_dentry(struct dentry *upper) 
 * See also: Documentation/filesystems/vfs.txt

 */

static inline struct dentry *d_real(struct dentry *dentry,

				    const struct inode *inode,

				    unsigned int flags)

				    const struct inode *inode)

{

	if (unlikely(dentry->d_flags & DCACHE_OP_REAL))

		return dentry->d_op->d_real(dentry, inode, flags);

		return dentry->d_op->d_real(dentry, inode);

	else

		return dentry;

}
@@ -595,7 +592,7 @@ static inline struct dentry *d_real(struct dentry *dentry, 
static inline struct inode *d_real_inode(const struct dentry *dentry)

{

	/* This usage of d_real() results in const dentry */

	return d_backing_inode(d_real((struct dentry *) dentry, NULL, 0));

	return d_backing_inode(d_real((struct dentry *) dentry, NULL));

}



struct name_snapshot {

include/linux/fs.h

+1 −1
Original line number Diff line number Diff line
@@ -1239,7 +1239,7 @@ static inline struct inode *file_inode(const struct file *f) 


static inline struct dentry *file_dentry(const struct file *file)

{

	return d_real(file->f_path.dentry, file_inode(file), 0);

	return d_real(file->f_path.dentry, file_inode(file));

}



static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)