Merge branch 'work.namei' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs into for-5.12/io_uring

Merge RESOLVE_CACHED bits from Al, as the io_uring changes will build on top of that. * 'work.namei' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: fs: expose LOOKUP_CACHED through openat2() RESOLVE_CACHED fs: add support for LOOKUP_CACHED saner calling conventions for unlazy_child() fs: make unlazy_walk() error handling consistent fs/namei.c: Remove unlikely of status being -ECHILD in lookup_fast() do_tmpfile(): don't mess with finish_open()

Jens Axboe committed 5 years ago

Commit b2d86c72 parents 1048ba8 99668f65 files · +55 −46Browse files

Unified · Split

5 files

fs/namei.c +43 −45
fs/open.c +6 −0
include/linux/fcntl.h +1 −1
include/linux/namei.h +1 −0
include/uapi/linux/openat2.h +4 −0

fs/namei.c+43−45

  */
 /**
- * unlazy_walk - try to switch to ref-walk mode.
+ * try_to_unlazy - try to switch to ref-walk mode.
  * @nd: nameidata pathwalk data
- * Returns: 0 on success, -ECHILD on failure
+ * Returns: true on success, false on failure
  *
- * unlazy_walk attempts to legitimize the current nd->path and nd->root
+ * try_to_unlazy attempts to legitimize the current nd->path and nd->root
  * for ref-walk mode.
  * Must be called from rcu-walk context.
- * Nothing should touch nameidata between unlazy_walk() failure and
+ * Nothing should touch nameidata between try_to_unlazy() failure and
  * terminate_walk().
  */
-static int unlazy_walk(struct nameidata *nd)
+static bool try_to_unlazy(struct nameidata *nd)
 {
 	struct dentry *parent = nd->path.dentry;
 	BUG_ON(!(nd->flags & LOOKUP_RCU));
 	nd->flags &= ~LOOKUP_RCU;
+	if (nd->flags & LOOKUP_CACHED)
+		goto out1;
 	if (unlikely(!legitimize_links(nd)))
 		goto out1;
 	if (unlikely(!legitimize_path(nd, &nd->path, nd->seq)))
 		goto out;
 	rcu_read_unlock();
 	BUG_ON(nd->inode != parent->d_inode);
-	return 0;
+	return true;
 out1:
 	nd->path.mnt = NULL;
 	nd->path.dentry = NULL;
 out:
 	rcu_read_unlock();
-	return -ECHILD;
+	return false;
 }
 /**
- * unlazy_child - try to switch to ref-walk mode.
+ * try_to_unlazy_next - try to switch to ref-walk mode.
  * @nd: nameidata pathwalk data
- * @dentry: child of nd->path.dentry
+ * @dentry: next dentry to step into
- * @seq: seq number to check dentry against
+ * @seq: seq number to check @dentry against
- * Returns: 0 on success, -ECHILD on failure
+ * Returns: true on success, false on failure
  *
- * unlazy_child attempts to legitimize the current nd->path, nd->root and dentry
+ * Similar to to try_to_unlazy(), but here we have the next dentry already
- * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
+ * picked by rcu-walk and want to legitimize that in addition to the current
- * @nd.  Must be called from rcu-walk context.
+ * nd->path and nd->root for ref-walk mode.  Must be called from rcu-walk context.
- * Nothing should touch nameidata between unlazy_child() failure and
+ * Nothing should touch nameidata between try_to_unlazy_next() failure and
  * terminate_walk().
  */
-static int unlazy_child(struct nameidata *nd, struct dentry *dentry, unsigned seq)
+static bool try_to_unlazy_next(struct nameidata *nd, struct dentry *dentry, unsigned seq)
 {
 	BUG_ON(!(nd->flags & LOOKUP_RCU));
 	nd->flags &= ~LOOKUP_RCU;
+	if (nd->flags & LOOKUP_CACHED)
+		goto out2;
 	if (unlikely(!legitimize_links(nd)))
 		goto out2;
 	if (unlikely(!legitimize_mnt(nd->path.mnt, nd->m_seq)))
 	if (unlikely(!legitimize_root(nd)))
 		goto out_dput;
 	rcu_read_unlock();
-	return 0;
+	return true;
 out2:
 	nd->path.mnt = NULL;
 	nd->path.dentry = NULL;
 out:
 	rcu_read_unlock();
-	return -ECHILD;
+	return false;
 out_dput:
 	rcu_read_unlock();
 	dput(dentry);
-	return -ECHILD;
+	return false;
 }
 static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
 		 */
 		if (!(nd->flags & (LOOKUP_ROOT | LOOKUP_IS_SCOPED)))
 			nd->root.mnt = NULL;
-		if (unlikely(unlazy_walk(nd)))
+		nd->flags &= ~LOOKUP_CACHED;
+		if (!try_to_unlazy(nd))
 			return -ECHILD;
 	}
 			return -ENOENT;
 		if (likely(__follow_mount_rcu(nd, path, inode, seqp)))
 			return 0;
-		if (unlazy_child(nd, dentry, seq))
+		if (!try_to_unlazy_next(nd, dentry, seq))
 			return -ECHILD;
 		// *path might've been clobbered by __follow_mount_rcu()
 		path->mnt = nd->path.mnt;
 		unsigned seq;
 		dentry = __d_lookup_rcu(parent, &nd->last, &seq);
 		if (unlikely(!dentry)) {
-			if (unlazy_walk(nd))
+			if (!try_to_unlazy(nd))
 				return ERR_PTR(-ECHILD);
 			return NULL;
 		}
 		status = d_revalidate(dentry, nd->flags);
 		if (likely(status > 0))
 			return dentry;
-		if (unlazy_child(nd, dentry, seq))
+		if (!try_to_unlazy_next(nd, dentry, seq))
 			return ERR_PTR(-ECHILD);
-		if (unlikely(status == -ECHILD))
+		if (status == -ECHILD)
 			/* we'd been told to redo it in non-rcu mode */
 			status = d_revalidate(dentry, nd->flags);
 	} else {
 {
 	if (nd->flags & LOOKUP_RCU) {
 		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
-		if (err != -ECHILD)
+		if (err != -ECHILD || !try_to_unlazy(nd))
 			return err;
-		if (unlazy_walk(nd))
-			return -ECHILD;
 	}
 	return inode_permission(nd->inode, MAY_EXEC);
 }
 		// unlazy even if we fail to grab the link - cleanup needs it
 		bool grabbed_link = legitimize_path(nd, link, seq);
-		if (unlazy_walk(nd) != 0 || !grabbed_link)
+		if (!try_to_unlazy(nd) != 0 || !grabbed_link)
 			return -ECHILD;
 		if (nd_alloc_stack(nd))
 		touch_atime(&last->link);
 		cond_resched();
 	} else if (atime_needs_update(&last->link, inode)) {
-		if (unlikely(unlazy_walk(nd)))
+		if (!try_to_unlazy(nd))
 			return ERR_PTR(-ECHILD);
 		touch_atime(&last->link);
 	}
 		get = inode->i_op->get_link;
 		if (nd->flags & LOOKUP_RCU) {
 			res = get(NULL, inode, &last->done);
-			if (res == ERR_PTR(-ECHILD)) {
+			if (res == ERR_PTR(-ECHILD) && try_to_unlazy(nd))
-				if (unlikely(unlazy_walk(nd)))
-					return ERR_PTR(-ECHILD);
 				res = get(link->dentry, inode, &last->done);
-			}
 		} else {
 			res = get(link->dentry, inode, &last->done);
 		}
 		}
 		if (unlikely(!d_can_lookup(nd->path.dentry))) {
 			if (nd->flags & LOOKUP_RCU) {
-				if (unlazy_walk(nd))
+				if (!try_to_unlazy(nd))
 					return -ECHILD;
 			}
 			return -ENOTDIR;
 	int error;
 	const char *s = nd->name->name;
+	/* LOOKUP_CACHED requires RCU, ask caller to retry */
+	if ((flags & (LOOKUP_RCU | LOOKUP_CACHED)) == LOOKUP_CACHED)
+		return ERR_PTR(-EAGAIN);
 	if (!*s)
 		flags &= ~LOOKUP_RCU;
 	if (flags & LOOKUP_RCU)
 	struct inode *inode;
 	struct dentry *dentry;
 	const char *res;
-	int error;
 	nd->flags |= op->intent;
 	} else {
 		/* create side of things */
 		if (nd->flags & LOOKUP_RCU) {
-			error = unlazy_walk(nd);
+			if (!try_to_unlazy(nd))
-			if (unlikely(error))
+				return ERR_PTR(-ECHILD);
-				return ERR_PTR(error);
 		}
 		audit_inode(nd->name, dir, AUDIT_INODE_PARENT);
 		/* trailing slashes? */
 	}
 	if (open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) {
-		error = mnt_want_write(nd->path.mnt);
+		got_write = !mnt_want_write(nd->path.mnt);
-		if (!error)
-			got_write = true;
 		/*
 		 * do _not_ fail yet - we might not need that or fail with
 		 * a different error; let lookup_open() decide; we'll be
 	audit_inode(nd->name, child, 0);
 	/* Don't check for other permissions, the inode was just created */
 	error = may_open(&path, 0, op->open_flag);
-	if (error)
+	if (!error)
-		goto out2;
+		error = vfs_open(&path, file);
-	file->f_path.mnt = path.mnt;
-	error = finish_open(file, child, NULL);
 out2:
 	mnt_drop_write(path.mnt);
 out:

fs/open.c+6−0

 		lookup_flags |= LOOKUP_BENEATH;
 	if (how->resolve & RESOLVE_IN_ROOT)
 		lookup_flags |= LOOKUP_IN_ROOT;
+	if (how->resolve & RESOLVE_CACHED) {
+		/* Don't bother even trying for create/truncate/tmpfile open */
+		if (flags & (O_TRUNC | O_CREAT | O_TMPFILE))
+			return -EAGAIN;
+		lookup_flags |= LOOKUP_CACHED;
+	}
 	op->lookup_flags = lookup_flags;
 	return 0;

include/linux/fcntl.h+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	/* List of all valid flags for the how->resolve argument: */	19	/* List of all valid flags for the how->resolve argument: */
20	#define VALID_RESOLVE_FLAGS \	20	#define VALID_RESOLVE_FLAGS \
21	(RESOLVE_NO_XDEV \| RESOLVE_NO_MAGICLINKS \| RESOLVE_NO_SYMLINKS \| \	21	(RESOLVE_NO_XDEV \| RESOLVE_NO_MAGICLINKS \| RESOLVE_NO_SYMLINKS \| \
22	RESOLVE_BENEATH \| RESOLVE_IN_ROOT)	22	RESOLVE_BENEATH \| RESOLVE_IN_ROOT \| RESOLVE_CACHED)
23		23
24	/* List of all open_how "versions". */	24	/* List of all open_how "versions". */
25	#define OPEN_HOW_SIZE_VER0 24 /* sizeof first published struct */	25	#define OPEN_HOW_SIZE_VER0 24 /* sizeof first published struct */

include/linux/namei.h+1−0

@@ -46,6 +46,7 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT}; · 45 unmodified lines
46	#define LOOKUP_NO_XDEV 0x040000 /* No mountpoint crossing. */	46	#define LOOKUP_NO_XDEV 0x040000 /* No mountpoint crossing. */
47	#define LOOKUP_BENEATH 0x080000 /* No escaping from starting point. */	47	#define LOOKUP_BENEATH 0x080000 /* No escaping from starting point. */
48	#define LOOKUP_IN_ROOT 0x100000 /* Treat dirfd as fs root. */	48	#define LOOKUP_IN_ROOT 0x100000 /* Treat dirfd as fs root. */
		49	#define LOOKUP_CACHED 0x200000 /* Only do cached lookup */
49	/* LOOKUP_* flags which do scope-related checks based on the dirfd. */	50	/* LOOKUP_* flags which do scope-related checks based on the dirfd. */
50	#define LOOKUP_IS_SCOPED (LOOKUP_BENEATH \| LOOKUP_IN_ROOT)	51	#define LOOKUP_IS_SCOPED (LOOKUP_BENEATH \| LOOKUP_IN_ROOT)
51		52

include/uapi/linux/openat2.h+4−0

 #define RESOLVE_IN_ROOT		0x10 /* Make all jumps to "/" and ".."
 					be scoped inside the dirfd
 					(similar to chroot(2)). */
+#define RESOLVE_CACHED		0x20 /* Only complete if resolution can be
+					completed through cached lookup. May
+					return -EAGAIN if that's not
+					possible. */
 #endif /* _UAPI_LINUX_OPENAT2_H */

Merge branch 'work.namei' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs into for-5.12/io_uring

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code