VFS/ovl: add lookup_one_positive_killable()

ovl wants a lookup which won't block on a fatal signal.  It currently
uses down_write_killable() and then repeatedly calls to lookup_one()

The lock may not be needed if the name is already in the dcache and it
aids proposed future changes if the locking is kept internal to namei.c

So this patch adds lookup_one_positive_killable() which is like
lookup_one_positive() but will abort in the face of a fatal signal.
overlayfs is changed to use this.

Note that instead of always getting an exclusive lock, ovl now only gets
a shared lock, and only sometimes.  The exclusive lock was never needed.

However down_read_killable() was only added in v4.15 but overlayfs started
using down_write_killable() here in v4.7.

Note that the linked list ->first_maybe_whiteout ->next_maybe_white is
local to the thread so there is no concurrency in that list which could
be threatened by removing the locking.

Reviewed-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: NeilBrown <neil@brown.name>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/namei.c b/fs/namei.c
index cd43ff89fbaa38206db2aec4f097ca119819f92e..c7c6b255db2c559cdad106a30621e18172d35a6f 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1827,6 +1827,20 @@ static struct dentry *lookup_slow(const struct qstr *name,
        return res;
 }
 
+static struct dentry *lookup_slow_killable(const struct qstr *name,
+                                          struct dentry *dir,
+                                          unsigned int flags)
+{
+       struct inode *inode = dir->d_inode;
+       struct dentry *res;
+
+       if (inode_lock_shared_killable(inode))
+               return ERR_PTR(-EINTR);
+       res = __lookup_slow(name, dir, flags);
+       inode_unlock_shared(inode);
+       return res;
+}
+
 static inline int may_lookup(struct mnt_idmap *idmap,
                             struct nameidata *restrict nd)
 {
@@ -3010,6 +3024,47 @@ struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap, struct qstr *name,
 }
 EXPORT_SYMBOL(lookup_one_unlocked);
 
+/**
+ * lookup_one_positive_killable - lookup single pathname component
+ * @idmap:     idmap of the mount the lookup is performed from
+ * @name:      qstr olding pathname component to lookup
+ * @base:      base directory to lookup from
+ *
+ * This helper will yield ERR_PTR(-ENOENT) on negatives. The helper returns
+ * known positive or ERR_PTR(). This is what most of the users want.
+ *
+ * Note that pinned negative with unlocked parent _can_ become positive at any
+ * time, so callers of lookup_one_unlocked() need to be very careful; pinned
+ * positives have >d_inode stable, so this one avoids such problems.
+ *
+ * This can be used for in-kernel filesystem clients such as file servers.
+ *
+ * It should be called without the parent i_rwsem held, and will take
+ * the i_rwsem itself if necessary.  If a fatal signal is pending or
+ * delivered, it will return %-EINTR if the lock is needed.
+ */
+struct dentry *lookup_one_positive_killable(struct mnt_idmap *idmap,
+                                           struct qstr *name,
+                                           struct dentry *base)
+{
+       int err;
+       struct dentry *ret;
+
+       err = lookup_one_common(idmap, name, base);
+       if (err)
+               return ERR_PTR(err);
+
+       ret = lookup_dcache(name, base, 0);
+       if (!ret)
+               ret = lookup_slow_killable(name, base, 0);
+       if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {
+               dput(ret);
+               ret = ERR_PTR(-ENOENT);
+       }
+       return ret;
+}
+EXPORT_SYMBOL(lookup_one_positive_killable);
+
 /**
  * lookup_one_positive_unlocked - lookup single pathname component
  * @idmap:     idmap of the mount the lookup is performed from

diff --git a/fs/overlayfs/readdir.c b/fs/overlayfs/readdir.c
index b65cdfce31ce27172d28d879559f1008b9c87320..15cb06fa0c9a104c186ce9863df351917c951782 100644 (file)
--- a/fs/overlayfs/readdir.c
+++ b/fs/overlayfs/readdir.c
@@ -270,26 +270,26 @@ static bool ovl_fill_merge(struct dir_context *ctx, const char *name,
 
 static int ovl_check_whiteouts(const struct path *path, struct ovl_readdir_data *rdd)
 {
-       int err;
+       int err = 0;
        struct dentry *dentry, *dir = path->dentry;
        const struct cred *old_cred;
 
        old_cred = ovl_override_creds(rdd->dentry->d_sb);
 
-       err = down_write_killable(&dir->d_inode->i_rwsem);
-       if (!err) {
-               while (rdd->first_maybe_whiteout) {
-                       struct ovl_cache_entry *p =
-                               rdd->first_maybe_whiteout;
-                       rdd->first_maybe_whiteout = p->next_maybe_whiteout;
-                       dentry = lookup_one(mnt_idmap(path->mnt),
-                                           &QSTR_LEN(p->name, p->len), dir);
-                       if (!IS_ERR(dentry)) {
-                               p->is_whiteout = ovl_is_whiteout(dentry);
-                               dput(dentry);
-                       }
+       while (rdd->first_maybe_whiteout) {
+               struct ovl_cache_entry *p =
+                       rdd->first_maybe_whiteout;
+               rdd->first_maybe_whiteout = p->next_maybe_whiteout;
+               dentry = lookup_one_positive_killable(mnt_idmap(path->mnt),
+                                                     &QSTR_LEN(p->name, p->len),
+                                                     dir);
+               if (!IS_ERR(dentry)) {
+                       p->is_whiteout = ovl_is_whiteout(dentry);
+                       dput(dentry);
+               } else if (PTR_ERR(dentry) == -EINTR) {
+                       err = -EINTR;
+                       break;
                }
-               inode_unlock(dir->d_inode);
        }
        ovl_revert_creds(old_cred);
 

diff --git a/include/linux/namei.h b/include/linux/namei.h
index 5d085428e471d9208d6e958089c5ce5622a2d8d8..551a1a01e5e72e63e404de26c6c19e56acf64a44 100644 (file)
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -80,6 +80,9 @@ struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap,
 struct dentry *lookup_one_positive_unlocked(struct mnt_idmap *idmap,
                                            struct qstr *name,
                                            struct dentry *base);
+struct dentry *lookup_one_positive_killable(struct mnt_idmap *idmap,
+                                           struct qstr *name,
+                                           struct dentry *base);
 
 extern int follow_down_one(struct path *);
 extern int follow_down(struct path *path, unsigned int flags);