* [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking
@ 2026-11-16 23:54 NeilBrown
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
` (3 more replies)
0 siblings, 4 replies; 9+ messages in thread
From: NeilBrown @ 2026-11-16 23:54 UTC (permalink / raw)
To: Alexander Viro, Christian Brauner
Cc: Jan Harkes, coda, Jan Kara, Richard Weinberger, Anton Ivanov,
Johannes Berg, Namjae Jeon, Hyunchul Lee, Carlos Maiolino,
Jeff Layton, Amir Goldstein, linux-kernel, codalist,
linux-fsdevel, linux-um, ntfs, linux-xfs
In this v2:
- shmem patch is dropped - it isn't necessary and the is a problem
with it which isn't worth fixing at this point
- configfs patch is dropped - Al didn't like it and it isn't
necessary
- ovl patch is dropped - I probably need to solve that a different
way and it is significant enough that it deserves to be separate from
this series
- slight renaming of bool var and goto labels in first patch
Original description, updated.
I am working on changes to directory locking. The medium term goal is
to lift d_alloc_parallel() locking above i_rwsem, so d_alloc_paralle()
can be run unlocked, and consequently cannot be called when ->i_rwsem is
held.
This patch set makes small changes to a number of filesystems which each
require just one patch. Patch series for nfs, afs, cifs, fuse, cephfs
have been posted separately
The main requirements are:
1/ that d_alloc_parallel() not be called while i_rwsem is held.
Places which currently do this can be changed to use d_alloc_trylock(),
or d_duplicate(), or change to drop and retake the parent lock.
2/ a dentry must not be d_drop()ed while an operation is ongoing, as an
unlocked d_alloc_parallel() would then be able to create a new
dentry with the same name. d_splice_alias() can now work with a
hash dentry, so often the d_drop() can simply be dropped. Other
times it can be moved to after the operation has completed.
I think it would be best for these to land in the VFS tree and would
appreciate Acks from relevant maintainer.
Thanks,
NeilBrown
[PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across
[PATCH v2 2/4] coda: don't d_drop() early.
[PATCH v2 3/4] hostfs: don't d_drop() before d_splice_alias() in
[PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci()
2026-11-16 23:54 [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking NeilBrown
@ 2026-11-16 23:54 ` NeilBrown
2026-11-20 13:35 ` Christian Brauner
2026-11-20 16:47 ` Christoph Hellwig
2026-11-16 23:54 ` [PATCH v2 2/4] coda: don't d_drop() early NeilBrown
` (2 subsequent siblings)
3 siblings, 2 replies; 9+ messages in thread
From: NeilBrown @ 2026-11-16 23:54 UTC (permalink / raw)
To: Alexander Viro, Christian Brauner
Cc: Jan Harkes, coda, Jan Kara, Richard Weinberger, Anton Ivanov,
Johannes Berg, Namjae Jeon, Hyunchul Lee, Carlos Maiolino,
Jeff Layton, Amir Goldstein, linux-kernel, codalist,
linux-fsdevel, linux-um, ntfs, linux-xfs
From: NeilBrown <neil@brown.name>
A proposed change will invert the lock ordering between
d_alloc_parallel() and inode_lock() on the parent.
When that happens it will not be safe to call d_alloc_parallel() while
holding the parent lock - even shared.
We don't need to keep the parent lock held when d_add_ci() is run - the
VFS doesn't need it as dentry is exclusively held due to
DCACHE_PAR_LOOKUP and the filesystem has finished its work.
So drop and reclaim the lock (shared or exclusive as determined by
LOOKUP_SHARED) to avoid future deadlock.
Signed-off-by: NeilBrown <neil@brown.name>
---
Documentation/filesystems/porting.rst | 7 ++++++
fs/dcache.c | 32 +++++++++++++++++++++++----
fs/ntfs/namei.c | 2 +-
fs/xfs/xfs_iops.c | 2 +-
include/linux/dcache.h | 3 ++-
5 files changed, 39 insertions(+), 7 deletions(-)
diff --git a/Documentation/filesystems/porting.rst b/Documentation/filesystems/porting.rst
index c38f5df755bb..4cab51e1bd6c 100644
--- a/Documentation/filesystems/porting.rst
+++ b/Documentation/filesystems/porting.rst
@@ -1422,3 +1422,10 @@ helpers take a const struct mnt_idmap *. mnt_idmap() and file_mnt_idmap()
return one. The idmapping is immutable so nothing should have modified it
anyway. References are taken and dropped via mnt_idmap_get() and
mnt_idmap_put() as before, both accept a const pointer.
+
+---
+
+**mandatory**
+
+d_add_ci() must now be passed the flags arguemnt that was given to ->lookup
+
diff --git a/fs/dcache.c b/fs/dcache.c
index 720b32cb2e03..255ebdad303d 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2419,6 +2419,7 @@ EXPORT_SYMBOL(d_obtain_root);
* @dentry: the negative dentry that was passed to the parent's lookup func
* @inode: the inode case-insensitive lookup has found
* @name: the case-exact name to be associated with the returned dentry
+ * @lookup_flags: flags passed to ->lookup
*
* This is to avoid filling the dcache with case-insensitive names to the
* same inode, only the actual correct case is stored in the dcache for
@@ -2431,9 +2432,10 @@ EXPORT_SYMBOL(d_obtain_root);
* the exact case, and return the spliced entry.
*/
struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
- struct qstr *name)
+ struct qstr *name, unsigned int lookup_flags)
{
struct dentry *found, *res;
+ bool must_relock = false;
/*
* First check if a dentry matching the name already exists,
@@ -2445,24 +2447,46 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
return found;
}
if (d_in_lookup(dentry)) {
+ /*
+ * We are holding parent lock and so don't want to wait
+ * for a d_in_lookup() dentry. We can safely drop the
+ * parent lock and reclaim it as we have exclusive
+ * access to dentry as it is d_in_lookup() (so
+ * ->d_parent is stable) and we are near the end
+ * ->lookup() and will shortly drop the lock anyway.
+ * We cannot retake the lock while the new dentry is in-lookup
+ */
+ if (lookup_flags & LOOKUP_SHARED)
+ inode_unlock_shared(d_inode(dentry->d_parent));
+ else
+ inode_unlock(d_inode(dentry->d_parent));
+ must_relock = true;
found = d_alloc_parallel(dentry->d_parent, name);
if (IS_ERR(found) || !d_in_lookup(found)) {
iput(inode);
- return found;
+ goto out_relock;
}
} else {
found = d_alloc(dentry->d_parent, name);
if (!found) {
iput(inode);
return ERR_PTR(-ENOMEM);
- }
+ }
}
res = d_splice_alias(inode, found);
if (res) {
d_lookup_done(found);
dput(found);
- return res;
+ found = res;
}
+ if (!must_relock)
+ return found;
+out_relock:
+ d_lookup_done(dentry);
+ if (lookup_flags & LOOKUP_SHARED)
+ inode_lock_shared(d_inode(dentry->d_parent));
+ else
+ inode_lock_nested(d_inode(dentry->d_parent), I_MUTEX_PARENT);
return found;
}
EXPORT_SYMBOL(d_add_ci);
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index b46fe44b63b5..16ed6027fa13 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -332,7 +332,7 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
}
nls_name.hash = full_name_hash(dent, nls_name.name, nls_name.len);
- dent = d_add_ci(dent, dent_inode, &nls_name);
+ dent = d_add_ci(dent, dent_inode, &nls_name, flags);
kfree(nls_name.name);
return dent;
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index d307ec97fac8..ec08c882c6f7 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -368,7 +368,7 @@ xfs_vn_ci_lookup(
/* else case-insensitive match... */
dname.name = ci_name.name;
dname.len = ci_name.len;
- dentry = d_add_ci(dentry, VFS_I(ip), &dname);
+ dentry = d_add_ci(dentry, VFS_I(ip), &dname, flags);
kfree(ci_name.name);
return dentry;
}
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index aaa4ba7a1299..9dd91ba2fe33 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -267,7 +267,8 @@ struct dentry *d_duplicate(struct dentry *dentry);
/* weird procfs mess; *NOT* exported */
extern struct dentry * d_splice_alias_ops(struct inode *, struct dentry *,
const struct dentry_operations *);
-extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
+extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *,
+ unsigned int);
extern bool d_same_name(const struct dentry *dentry, const struct dentry *parent,
const struct qstr *name);
extern struct dentry *d_find_any_alias(struct inode *inode);
base-commit: 7475ea8b58616b33c04afb976cf0fbaad9dd63fb
--
2.50.0.107.gf914562f5916.dirty
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH v2 2/4] coda: don't d_drop() early.
2026-11-16 23:54 [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking NeilBrown
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
@ 2026-11-16 23:54 ` NeilBrown
2026-11-20 17:30 ` Jan Harkes
2026-11-16 23:55 ` [PATCH v2 3/4] hostfs: don't d_drop() before d_splice_alias() in hostfs_mkdir() NeilBrown
2026-11-16 23:55 ` [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared() NeilBrown
3 siblings, 1 reply; 9+ messages in thread
From: NeilBrown @ 2026-11-16 23:54 UTC (permalink / raw)
To: Alexander Viro, Christian Brauner
Cc: Jan Harkes, coda, Jan Kara, Richard Weinberger, Anton Ivanov,
Johannes Berg, Namjae Jeon, Hyunchul Lee, Carlos Maiolino,
Jeff Layton, Amir Goldstein, linux-kernel, codalist,
linux-fsdevel, linux-um, ntfs, linux-xfs
From: NeilBrown <neil@brown.name>
Proposed locking changes will mean that calling d_drop() could
effectively unlock the name allowing a parallel lookup to proceed.
For this reason it should only be called *after* the attempt to create a
symlink (in this case) has completed (whether successfully or not).
So move the d_drop() to after the venus_symlink() call.
Doing this also means that if the upcall that handles venus_symlink()
happens to look up the name being created, it will get -ENOENT rather
then a possible deadlock.
Signed-off-by: NeilBrown <neil@brown.name>
---
fs/coda/dir.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index a85be5962e62..b47299527b65 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -249,13 +249,13 @@ static int coda_symlink(const struct mnt_idmap *idmap,
if (symlen > CODA_MAXPATHLEN)
return -ENAMETOOLONG;
+ error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
+ symname, symlen);
/*
- * This entry is now negative. Since we do not create
+ * This entry is still negative. Since we did not create
* an inode for the entry we have to drop it.
*/
d_drop(de);
- error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
- symname, symlen);
/* mtime is no good anymore */
if (!error)
--
2.50.0.107.gf914562f5916.dirty
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH v2 3/4] hostfs: don't d_drop() before d_splice_alias() in hostfs_mkdir()
2026-11-16 23:54 [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking NeilBrown
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
2026-11-16 23:54 ` [PATCH v2 2/4] coda: don't d_drop() early NeilBrown
@ 2026-11-16 23:55 ` NeilBrown
2026-11-16 23:55 ` [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared() NeilBrown
3 siblings, 0 replies; 9+ messages in thread
From: NeilBrown @ 2026-11-16 23:55 UTC (permalink / raw)
To: Alexander Viro, Christian Brauner
Cc: Jan Harkes, coda, Jan Kara, Richard Weinberger, Anton Ivanov,
Johannes Berg, Namjae Jeon, Hyunchul Lee, Carlos Maiolino,
Jeff Layton, Amir Goldstein, linux-kernel, codalist,
linux-fsdevel, linux-um, ntfs, linux-xfs
From: NeilBrown <neil@brown.name>
hostfs_mkdir() uses d_drop() and d_splice_alias() to ensure it has the
right dentry after a mkdir.
d_drop() is no longer needed here and will cause problem for future
changes to directory locking. So remove the d_drop().
Signed-off-by: NeilBrown <neil@brown.name>
---
fs/hostfs/hostfs_kern.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 613146e76dec..7cf25c29cb78 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -700,7 +700,6 @@ static struct dentry *hostfs_mkdir(const struct mnt_idmap *idmap, struct inode *
dentry = ERR_PTR(err);
} else {
inode = hostfs_iget(dentry->d_sb, file);
- d_drop(dentry);
dentry = d_splice_alias(inode, dentry);
}
__putname(file);
--
2.50.0.107.gf914562f5916.dirty
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared()
2026-11-16 23:54 [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking NeilBrown
` (2 preceding siblings ...)
2026-11-16 23:55 ` [PATCH v2 3/4] hostfs: don't d_drop() before d_splice_alias() in hostfs_mkdir() NeilBrown
@ 2026-11-16 23:55 ` NeilBrown
2026-11-20 13:38 ` Christian Brauner
3 siblings, 1 reply; 9+ messages in thread
From: NeilBrown @ 2026-11-16 23:55 UTC (permalink / raw)
To: Alexander Viro, Christian Brauner
Cc: Jan Harkes, coda, Jan Kara, Richard Weinberger, Anton Ivanov,
Johannes Berg, Namjae Jeon, Hyunchul Lee, Carlos Maiolino,
Jeff Layton, Amir Goldstein, linux-kernel, codalist,
linux-fsdevel, linux-um, ntfs, linux-xfs
From: NeilBrown <neil@brown.name>
When procfs finds a name in iterate_shared() that isn't in the dcache it
*must* add it so that it can have a stable inode number to report
(inodes are only accessible from the dcache in procfs).
It uses d_alloc_parallel(). A planned change to locking will make it
unsafe to call d_alloc_parallel() while holding the directory lock.
Other filesystems which prime the dcache in iterate_shared() use
d_alloc_trylock() which is safe but can fail if it races with ->lookup.
As procfs cannot handle failure we need something better.
procfs doesn't *need* the parent to be locked. There are no shared data
structures accessed that don't have their own locking. So it is safe to
drop and re-take the parent lock. We could do this around the whole
iteration, but as failure of d_alloc_trylock() is rare it is more
efficient to drop and retake it just around a call of d_alloc_parallel()
when d_alloc_trylock does fail.
Other code that drops and retakes the lock in iterate_shared needs to
be careful to check S_DEAD which could be set while the lock is
dropped. This is not needed in procfs as the flag is never set.
As d_alloc_trylock() calls try_lookup_noperm(), we can skip that call
and simplify the code.
Signed-off-by: NeilBrown <neil@brown.name>
---
fs/proc/base.c | 38 +++++++++++++++++++--------------
fs/proc/proc_sysctl.c | 49 ++++++++++++++++++++++++-------------------
2 files changed, 49 insertions(+), 38 deletions(-)
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 7685660c3624..5f9ec524ae2a 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2106,24 +2106,30 @@ bool proc_fill_cache(struct file *file, struct dir_context *ctx,
unsigned type = DT_UNKNOWN;
ino_t ino = 1;
- child = try_lookup_noperm(&qname, dir);
- if (IS_ERR(child))
- goto end_instantiate;
+ child = d_alloc_trylock(dir, &qname);
- if (!child) {
+ if (child == ERR_PTR(-EWOULDBLOCK)) {
+ /*
+ * Need to drop directory lock, which isn't really
+ * needed here anyway. As rmdir never happens in procfs
+ * we don't need to be concerned about S_DEAD being set
+ * while unlocked.
+ */
+ inode_unlock_shared(dir->d_inode);
child = d_alloc_parallel(dir, &qname);
- if (IS_ERR(child))
- goto end_instantiate;
- if (d_in_lookup(child)) {
- struct dentry *res;
- res = instantiate(child, task, ptr);
- d_lookup_done(child);
- if (unlikely(res)) {
- dput(child);
- child = res;
- if (IS_ERR(child))
- goto end_instantiate;
- }
+ inode_lock_shared(dir->d_inode);
+ }
+ if (IS_ERR(child))
+ goto end_instantiate;
+ if (d_in_lookup(child)) {
+ struct dentry *res;
+ res = instantiate(child, task, ptr);
+ d_lookup_done(child);
+ if (unlikely(res)) {
+ dput(child);
+ child = res;
+ if (IS_ERR(child))
+ goto end_instantiate;
}
}
inode = d_inode(child);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 6c0859c66563..08bcda3bbc59 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -686,29 +686,34 @@ static bool proc_sys_fill_cache(struct file *file,
ino_t ino = 0;
unsigned type = DT_UNKNOWN;
- qname.name = table->procname;
- qname.len = strlen(table->procname);
- qname.hash = full_name_hash(dir, qname.name, qname.len);
-
- child = d_lookup(dir, &qname);
- if (!child) {
+ qname = QSTR(table->procname);
+ child = d_alloc_trylock(dir, &qname);
+ if (child == ERR_PTR(-EWOULDBLOCK)) {
+ /*
+ * Need to drop directory lock, which isn't really
+ * needed here anyway. As rmdir never happens in procfs
+ * we don't need to be concerned about S_DEAD being set
+ * while unlocked.
+ */
+ inode_unlock_shared(dir->d_inode);
child = d_alloc_parallel(dir, &qname);
- if (IS_ERR(child))
- return false;
- if (d_in_lookup(child)) {
- struct dentry *res;
- inode = proc_sys_make_inode(dir->d_sb, head, table);
- res = d_splice_alias_ops(inode, child,
- &proc_sys_dentry_operations);
- d_lookup_done(child);
- if (unlikely(res)) {
- dput(child);
-
- if (IS_ERR(res))
- return false;
-
- child = res;
- }
+ inode_lock_shared(dir->d_inode);
+ }
+ if (IS_ERR(child))
+ return false;
+ if (d_in_lookup(child)) {
+ struct dentry *res;
+ inode = proc_sys_make_inode(dir->d_sb, head, table);
+ res = d_splice_alias_ops(inode, child,
+ &proc_sys_dentry_operations);
+ d_lookup_done(child);
+ if (unlikely(res)) {
+ dput(child);
+
+ if (IS_ERR(res))
+ return false;
+
+ child = res;
}
}
inode = d_inode(child);
--
2.50.0.107.gf914562f5916.dirty
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci()
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
@ 2026-11-20 13:35 ` Christian Brauner
2026-11-20 16:47 ` Christoph Hellwig
1 sibling, 0 replies; 9+ messages in thread
From: Christian Brauner @ 2026-11-20 13:35 UTC (permalink / raw)
To: NeilBrown
Cc: Alexander Viro, Jan Harkes, coda, Jan Kara, Richard Weinberger,
Anton Ivanov, Johannes Berg, Namjae Jeon, Hyunchul Lee,
Carlos Maiolino, Jeff Layton, Amir Goldstein, linux-kernel,
codalist, linux-fsdevel, linux-um, ntfs, linux-xfs
On Tue, Nov 17, 2026 at 10:54:58AM +1100, NeilBrown wrote:
> We don't need to keep the parent lock held when d_add_ci() is run - the
> VFS doesn't need it as dentry is exclusively held due to
> DCACHE_PAR_LOOKUP and the filesystem has finished its work.
I'm not sure that holds? Only d_alloc_parallel() honours
DCACHE_PAR_LOOKUP. lookup_one_qstr_excl() still uses d_alloc() and
relies on the exclusive lock to guarantee that there are no in-lookup
children at all. That stops being true here:
> + if (lookup_flags & LOOKUP_SHARED)
> + inode_unlock_shared(d_inode(dentry->d_parent));
> + else
> + inode_unlock(d_inode(dentry->d_parent));
> + must_relock = true;
> found = d_alloc_parallel(dentry->d_parent, name);
So if "Foo" exists on an ascii-ci xfs:
P1: stat("FOO") P2: unlink("Foo")
lookup_slow()
-> xfs_vn_ci_lookup()
-> d_add_ci(dentry, X, "Foo")
-> inode_unlock_shared(dir)
-> found = d_alloc_parallel()
start_dirop()
-> inode_lock_nested(dir)
-> lookup_one_qstr_excl("Foo")
-> d2 = d_alloc()
-> xfs_vn_ci_lookup()
-> d_splice_alias(X, d2)
vfs_unlink()
-> xfs_vn_unlink()
-> d_invalidate(d2)
inode_unlock(dir)
-> d_splice_alias(X, found)
IOW, "Foo" ends up as a hashed positive dentry for an unlinked inode
that nothing revalidates.
open("Foo", O_CREAT) then opens the orphan instead of creating a new
file and O_EXCL fails with EEXIST. Do a rename() instead of the unlink()
and "Foo" keeps pointing to what is now "Bar". ntfs gets there the same
way.
Before this patch lookup_slow() held the lock shared across all of
that so start_dirop() couldn't get in between.
So afaict this needs "VFS: use d_alloc_parallel() in
lookup_one_qstr_excl()" from your RFC to go in first. Unless I'm
missing something obvious.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared()
2026-11-16 23:55 ` [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared() NeilBrown
@ 2026-11-20 13:38 ` Christian Brauner
0 siblings, 0 replies; 9+ messages in thread
From: Christian Brauner @ 2026-11-20 13:38 UTC (permalink / raw)
To: NeilBrown
Cc: Alexander Viro, Jan Harkes, coda, Jan Kara, Richard Weinberger,
Anton Ivanov, Johannes Berg, Namjae Jeon, Hyunchul Lee,
Carlos Maiolino, Jeff Layton, Amir Goldstein, linux-kernel,
codalist, linux-fsdevel, linux-um, ntfs, linux-xfs
On Tue, Nov 17, 2026 at 10:55:01AM +1100, NeilBrown wrote:
> + if (child == ERR_PTR(-EWOULDBLOCK)) {
> + /*
> + * Need to drop directory lock, which isn't really
> + * needed here anyway. As rmdir never happens in procfs
> + * we don't need to be concerned about S_DEAD being set
> + * while unlocked.
> + */
> + inode_unlock_shared(dir->d_inode);
> child = d_alloc_parallel(dir, &qname);
> [...]
> + inode_lock_shared(dir->d_inode);
> + }
I think this can deadlock.
If we're colliding with the failed lookup because the fd was closed, the
task exited or the sysctl unregistered then the dentry is unhashed and
d_alloc_parallel() hands us a new in-lookup dentry.
We then retake the lock while still owning it. But the VFS waits for
in-lookup dentries with the lock held, e.g., open() with O_CREAT:
P1: getdents(/proc/$pid/fd) P2: open("/proc/$pid/fd/5", O_CREAT)
proc_fill_cache("5")
-> d_alloc_trylock() == -EWOULDBLOCK
-> inode_unlock_shared(dir)
lookup_open()
-> inode_lock(dir)
-> d_lookup("5") == NULL
-> child = d_alloc_parallel("5")
-> d_alloc_parallel("5")
-> d_wait_lookup(child)
-> inode_lock_shared(dir)
Both sleep uninterruptibly.
A shell redirect to /dev/fd/5 is enough for P2.
I don't tink it even needs O_CREAT. Any queued writer like a mkdir in
the directory or chmod on it plus a lookup_slow() of the same name that
holds the lock shared and waits on the child has the asme issue.
And under /proc/sys/net it doesn't need a failing lookup either.
proc_sys_compare() matches any in-lookup dentry but after the wait
sysctl_is_seen() rejects a dentry from another netns and we get our
own.
d_add_ci() in 1/4 gets this right and finishes all in-lookup dentries
before relocking. So I think procfs needs to do the same, sm like
(UNTESTED):
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 5f9ec52..d30f877 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2105,19 +2105,19 @@ bool proc_fill_cache(struct file *file, struct dir_context *ctx,
struct inode *inode;
unsigned type = DT_UNKNOWN;
ino_t ino = 1;
+ bool relock = false;
child = d_alloc_trylock(dir, &qname);
-
if (child == ERR_PTR(-EWOULDBLOCK)) {
/*
- * Need to drop directory lock, which isn't really
- * needed here anyway. As rmdir never happens in procfs
- * we don't need to be concerned about S_DEAD being set
- * while unlocked.
+ * Wait for the other lookup without the directory lock and
+ * don't take it back while @child is in-lookup: lookup_open()
+ * waits for in-lookup dentries with the lock held exclusive.
+ * procfs never sets S_DEAD.
*/
inode_unlock_shared(dir->d_inode);
+ relock = true;
child = d_alloc_parallel(dir, &qname);
- inode_lock_shared(dir->d_inode);
}
if (IS_ERR(child))
goto end_instantiate;
@@ -2137,6 +2137,8 @@ bool proc_fill_cache(struct file *file, struct dir_context *ctx,
type = inode->i_mode >> 12;
dput(child);
end_instantiate:
+ if (relock)
+ inode_lock_shared(dir->d_inode);
return dir_emit(ctx, name, len, ino, type);
}
The sysctl side needs the same.
This also has the same lookup_one_qstr_excl() problem as the earlier
patch.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci()
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
2026-11-20 13:35 ` Christian Brauner
@ 2026-11-20 16:47 ` Christoph Hellwig
1 sibling, 0 replies; 9+ messages in thread
From: Christoph Hellwig @ 2026-11-20 16:47 UTC (permalink / raw)
To: NeilBrown
Cc: Alexander Viro, Christian Brauner, Jan Harkes, coda, Jan Kara,
Richard Weinberger, Anton Ivanov, Johannes Berg, Namjae Jeon,
Hyunchul Lee, Carlos Maiolino, Jeff Layton, Amir Goldstein,
linux-kernel, codalist, linux-fsdevel, linux-um, ntfs, linux-xfs
On Tue, Nov 17, 2026 at 10:54:58AM +1100, NeilBrown wrote:
> const struct dentry_operations *);
> -extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
> +extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *,
Please drop the extern and fix up the formatting if you touch the code.
Bonus points for spelling out the arguments to actually make it
readable.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2 2/4] coda: don't d_drop() early.
2026-11-16 23:54 ` [PATCH v2 2/4] coda: don't d_drop() early NeilBrown
@ 2026-11-20 17:30 ` Jan Harkes
0 siblings, 0 replies; 9+ messages in thread
From: Jan Harkes @ 2026-11-20 17:30 UTC (permalink / raw)
To: NeilBrown
Cc: Alexander Viro, Christian Brauner, Jan Kara, Richard Weinberger,
Anton Ivanov, Johannes Berg, Namjae Jeon, Hyunchul Lee,
Carlos Maiolino, Jeff Layton, Amir Goldstein, linux-kernel,
linux-fsdevel, linux-um, ntfs, linux-xfs
On Mon, Nov 16, 2026 at 07:09:14PM -0500, NeilBrown wrote:
> From: NeilBrown <neil@brown.name>
>
> Proposed locking changes will mean that calling d_drop() could
> effectively unlock the name allowing a parallel lookup to proceed.
> For this reason it should only be called *after* the attempt to create a
> symlink (in this case) has completed (whether successfully or not).
>
> So move the d_drop() to after the venus_symlink() call.
>
> Doing this also means that if the upcall that handles venus_symlink()
> happens to look up the name being created, it will get -ENOENT rather
> then a possible deadlock.
>
> Signed-off-by: NeilBrown <neil@brown.name>
Acked-by: Jan Harkes <jaharkes@cs.cmu.edu>
I was sort of already assuming that the userspace cache manager should
never ever traverse into the mounted /coda file system tree because
there is only a finite pool of worker threads. But it is good to know
that this change would fix at least one possible deadlock.
> ---
> fs/coda/dir.c | 6 +++---
> 1 file changed, 3 insertions(+), 3 deletions(-)
>
> diff --git a/fs/coda/dir.c b/fs/coda/dir.c
> index a85be5962e62..b47299527b65 100644
> --- a/fs/coda/dir.c
> +++ b/fs/coda/dir.c
> @@ -249,13 +249,13 @@ static int coda_symlink(const struct mnt_idmap *idmap,
> if (symlen > CODA_MAXPATHLEN)
> return -ENAMETOOLONG;
>
> + error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
> + symname, symlen);
> /*
> - * This entry is now negative. Since we do not create
> + * This entry is still negative. Since we did not create
> * an inode for the entry we have to drop it.
> */
> d_drop(de);
> - error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
> - symname, symlen);
>
> /* mtime is no good anymore */
> if (!error)
> --
> 2.50.0.107.gf914562f5916.dirty
>
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2026-11-20 17:30 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-16 23:54 [PATCH v2 0/4] multiple-filesystems: prepare for changes to VFS locking NeilBrown
2026-11-16 23:54 ` [PATCH v2 1/4] VFS/xfs/ntfs: drop parent lock across d_alloc_parallel() in d_add_ci() NeilBrown
2026-11-20 13:35 ` Christian Brauner
2026-11-20 16:47 ` Christoph Hellwig
2026-11-16 23:54 ` [PATCH v2 2/4] coda: don't d_drop() early NeilBrown
2026-11-20 17:30 ` Jan Harkes
2026-11-16 23:55 ` [PATCH v2 3/4] hostfs: don't d_drop() before d_splice_alias() in hostfs_mkdir() NeilBrown
2026-11-16 23:55 ` [PATCH v2 4/4] procfs: drop parent lock for d_alloc_parallel() in iterate_shared() NeilBrown
2026-11-20 13:38 ` Christian Brauner
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®