Skip to contentSkip to conversation

dentry->d_flags locking

RFC In review Al Viro 5 participants 87 messages Feb 24, 2025 – Jun 11, 2025

Subsystems (39)
lore
Share & tools
lore

Al Viro

author maintainer
#0 lore raw
	Recently I went looking through the ->d_flags locking (long

story, that was a side branch in digging through the issues with Neil's locking scheme); results are interesting.

	All stores to dentry->d_flags are done by somebody who

* holds a counting reference to dentry or
* has found a counting reference in shared data structures, in conditions that guarantee that this reference won't go away or
* has found dentry in alias list of some inode (under ->i_lock)
* [fs/dcache.c only] is an LRU walker callback running into that dentry in LRU list or
* [fs/dcache.c only] is owner of a shrink list running into dentry in that list or
* [fs/dcache.c only] is a d_walk() callback running into that dentry with zero refcount (and moving it to shrink list) or
* [fs/dcache.c only] is a d_walk() called by kill_litter_super() running into that dentry when unpinning theretofore persistent dentries; that can happen only during filesystem shutdown, when nobody else could be accessing it.

	The above guarantees that dentry won't disappear under us;

another interesting thing is exclusion, and that's where the things get nasty. Most of the stores to dentry->d_flags are under dentry->d_lock. There are obvious exceptions on the allocation side (stores done to dentry that is not visible to anybody else), but aside of those there are two exceptions.

One is d_set_d_op(), another - setting DCACHE_PAR_LOOKUP in
d_alloc_parallel().

	The former sets ->d_op and marks the presense of several methods

(->d_hash(), ->d_compare(), ->d_revalidate(), ->d_weak_revalidate(), ->d_delete(), ->d_prune() and ->d_real()) in ->d_flags.

It can't be done more than once and, if the filesystem
has ->s_d_op set in its superblock, it is done by the constructor
(__d_alloc()). That, obviously, falls under the "on allocation side";
so does another common case - d_alloc_pseudo() setting ->d_op to &anon_ops if __d_alloc() hadn't set it to ->s_d_op.

	Note that there's no barriers between the stores to ->d_op and

->d_flags in d_set_d_op(); for allocation time uses that's not a problem - fetches on another CPU would have to be preceded by finding the dentry in the first place, and barriers on the insertion into wherever it had been found would suffice.

There are other callers of d_set_d_op(), though - one in
simple_lookup() (again, if ->s_d_op is NULL) and the rest are all in procfs. Those are done with no locking whatsoever and dentry is *not* entirely invisible.

It's mostly invisible, though - in all those cases dentry is
* negative, and thus unreachable via the alias list of any inode
* unhashed, and thus can't be found via dcache lookup
* has the only direct reference held by the caller who has been holding it since it got allocated (i.e. it couldn't have been put into LRU or shrink lists either).

That is enough to guarantee that nobody else will be doing stores
to ->d_flags, so our store is safe even without ->d_lock. It is also fucking ugly and brittle...

	Moreover, the question about ->d_op vs ->d_flags ordering also

needs to be dealt with - unlike the calls at allocation time, insertion into wherever it had been found does *not* order fetches past both stores - not if it had been inserted into that wherever before the call of d_set_d_op().

Thankfully, the set of methods present in dentry_operations
ever fed to those late calls of d_set_d_op() is limited: ->d_revalidate, ->d_delete and, in one case, ->d_compare.

	->d_delete() is easy - it's called only from one place (retain_dentry())

and there we have just dropped the last reference to dentry in question. Since the caller of d_set_d_op() is holding a reference, the usual barriers on ->d_reflock use are enough.

	->d_compare() is a bit confusing - dentry it's getting as argument

is not the one whose method it is. We have the parent (already observed to be positive) and we are checking if this child (with ->d_parent pointing to parent) matches the name we want to look up. We take parent's ->d_compare() and give it child dentry, snapshot of child's name and the name we want to match it against.
We *CAN* get a dentry in the middle of d_set_d_op() passed to
someone's ->d_compare() - d_alloc_parent() does that to check if there's an in-lookup dentry matching the name we want. But ->d_compare() comes from parent, and that had been already observed to be positive. Which means that barriers in __d_set_inode_and_type() (from d_splice_alias()) suffice.

	->d_revalidate() is only called for dentries that had been found

in dcache hash chains at some point, so there the barrier on insertion into hash (in __d_add() from d_splice_alias()) is enough.

That covers d_set_d_op() callers; another exception is
d_alloc_parallel() when it decides to insert a new dentry into in-lookup hash and marks it with DCACHE_PAR_LOOKUP. Also safe, since dentry is only visible in the parent's list of children, has positive refcount and had it all along, so nobody else would try to do a store to ->d_flags at the same time.

In case it's not obvious from the above, I'm less than happy with
the entire thing - it may be provably correct, but it's much too brittle.

If nothing else, d_set_d_op() should be unexported. Do it to
a hashed or, worse, a positive dentry and you are asking for serious trouble. Leaving it as a public API is a really bad idea.

Something along the lines of d_splice_alias_ops(inode, dentry, ops)
(not exported, until we get a convincing modular user) is worth doing; all procfs callers of d_set_d_op() follow it with d_splice_alias() pretty much immediately. And yes, that could be done under ->d_lock, eliminating that special case from the proof.

As for the allocation-time uses... We could bloody well calculate
the ->d_flags bits to go along with ->s_d_op and just use that; it's not just about getting rid of recalculating them for each dentry ever allocated on the filesystem in question, we could get rid of quite a few always_delete_dentry users while we are at it.

	Look: ->d_delete == always_delete_dentry (and DCACHE_OP_DELETE to
go with it) is equivalent to DCACHE_DONTCACHE; the only place where we
look at either is retain_dentry(), where we have this:
        // ->d_delete() might tell us not to bother, but that requires
        // ->d_lock; can't decide without it
        if (unlikely(d_flags & DCACHE_OP_DELETE)) {
                if (!locked || dentry->d_op->d_delete(dentry))
                        return false;
        }

        // Explicitly told not to bother
        if (unlikely(d_flags & DCACHE_DONTCACHE))
                return false;
The inner if turns into
		if (!locked || 1)
			return false;

so for those DCACHE_DONTCACHE would be equivalent. And it could be put into the same "set those bits in all ->d_flags on that fs"; what's more, simple_lookup() doesn't need to set ->d_op at all - it can just set DCACHE_DONTCACHE in the unlikely case when it's not been already set.

How about something along the lines of
0) add d_splice_alias_ops(inode, dentry, dops), have procfs switch to that.
1) provide set_default_d_op(superblock, dops), use it in place of assignments to ->s_d_op. Rename ->s_d_op to catch unconverted filesystems. Tree-wide, entirely mechanical.
2) split the calculation of d_flags bits into a separate helper, add ->s_d_flags, have set_default_d_op() calculate and set that, have __d_alloc() pick ->s_d_op and ->s_d_flags directly.
3) convert those who wish to move from use of always_delete_dentry to adding DCACHE_DONTCACHE into ->s_d_flags. For devpts, for example, that avoids the need of non-NULL ->d_op.
4) replace d_set_d_op() in simple_lookup() with

	if (unlikely(!(dentry->d_flags & DCACHE_DONTCACHE))) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags |= DCACHE_DONTCACHE;
		spin_unlock(&dentry->d_lock);
	}

5) Kill simple_dentry_operations - no users would be left
6) make d_set_d_op() static in fs/dcache.c

I'll put together something along those lines and post it later today.

With that done, the last remaining store to ->d_flags without ->d_lock would be in d_alloc_parallel(); it can be killed off (we could set it in new->d_flags before anyone sees that dentry), the only reason I'd left that to actual insertion into in-lookup hash chain is that DCACHE_PAR_LOOKUP currently corresponds to "it's in in-lookup hash, what would've been ->d_alias is occupied by that hash chain" and at some point I think we had final dput() scream bloody murder if it saw such a dentry.

Hell knows... d_alloc_parallel() is going to be heavily affected by any locking reworks; what should be done with that wart depends upon the direction we take for that work.

PS: turns out that set_default_d_op() is slightly more interesting than I expected - fuse has separate dentry_operations for its root dentry. I don't see the point, TBH - the only difference is that root one lacks
* ->d_delete() (never even called for root dentry; it's
only called if d_unhashed() is false)
* ->d_revalidate() (never called for root)
* ->d_automount() (not even looked at unless you have
S_AUTOMOUNT set on the inode).
What's wrong with using fuse_dentry_operations for root dentry? Am I missing something subtle here? Miklos?

author maintainer
#1 lore raw
Quoted 11 lines · Al Viro

PS: turns out that set_default_d_op() is slightly more interesting than I expected - fuse has separate dentry_operations for its root dentry. I don't see the point, TBH - the only difference is that root one lacks
* ->d_delete() (never even called for root dentry; it's
only called if d_unhashed() is false)
* ->d_revalidate() (never called for root)
* ->d_automount() (not even looked at unless you have
S_AUTOMOUNT set on the inode).
What's wrong with using fuse_dentry_operations for root dentry? Am I missing something subtle here? Miklos?

Speaking of fun questions - does pidfs_dentry_operations need ->d_delete()? I mean, it's not even called for unhashed dentries and AFAICS there's no way for those to be hashed... The same goes for all filesystems created by init_pseudo().

Is there any reason to have that in pidfs_dentry_operations and ns_dentry_operations?

I think nsfs is my sloppiness back then - original commit message explicitly says that neither dentries nor inodes in that thing are ever hashed, so ->d_delete() had been clearly pointless from the very beginning.

Christian, pidfs looks like it just had copied that from nsfs. Is there something subtle about pidfs that makes ->d_delete() needed there?

#2 lore raw
Quoted 22 lines · Al Viro
Quoted 11 lines · Al Viro

PS: turns out that set_default_d_op() is slightly more interesting than I expected - fuse has separate dentry_operations for its root dentry. I don't see the point, TBH - the only difference is that root one lacks
* ->d_delete() (never even called for root dentry; it's
only called if d_unhashed() is false)
* ->d_revalidate() (never called for root)
* ->d_automount() (not even looked at unless you have
S_AUTOMOUNT set on the inode).
What's wrong with using fuse_dentry_operations for root dentry? Am I missing something subtle here? Miklos?

Speaking of fun questions - does pidfs_dentry_operations need ->d_delete()? I mean, it's not even called for unhashed dentries and AFAICS there's no way for those to be hashed... The same goes for all filesystems created by init_pseudo().

Is there any reason to have that in pidfs_dentry_operations and ns_dentry_operations?

Quoted 8 lines

I think nsfs is my sloppiness back then - original commit message explicitly says that neither dentries nor inodes in that thing are ever hashed, so ->d_delete() had been clearly pointless from the very beginning.

Christian, pidfs looks like it just had copied that from nsfs. Is there something subtle about pidfs that makes ->d_delete() needed there?

No, I don't think so. I put patches on top of vfs.fixes that remove it for both pidfs and nsfs. Thanks!

The fact that hashing a dentry happens during lookup and that I didn't even have to think about lookup for pidfs and nsfs because they don't matter probably just led to carrying this over for pidfs.

I think it would be worthwhile to mark dentries of such filesystems as always unhashed and then add an assert into fs/dcache.c whenever such a dentry should suddenly become hashed.

That would not just make it very easy to see for the reviewer that the dentries of this filesystem are always unhashed it would also make it possible to spot bugs.

author maintainer
#3 lore raw
Quoted 7 lines · Christian Brauner

I think it would be worthwhile to mark dentries of such filesystems as always unhashed and then add an assert into fs/dcache.c whenever such a dentry should suddenly become hashed.

That would not just make it very easy to see for the reviewer that the dentries of this filesystem are always unhashed it would also make it possible to spot bugs.

Not sure that's useful, really... Details are tied into the tree-in-dcache rework, and I'll need to finish resurrecting that; should post in a week or so.

For this series, see viro/vfs.git#work.dcache - it's a WIP at the moment, and it's going to get reordered (if nothing else, d_alloc_parallel() side needs an audit of tree-walkers to prove that it won't get confused by seeing DCACHE_PAR_LOOKUP on the stuff that hasn't yet reached in-lookup hash chains, and that might add prereqs that would need to go early in queue), but that at least fleshes out what I described upthread.

I'll post individual patches for review in a few hours.

author maintainer
#4 lore raw

PATCH 1/21 procfs: kill ->proc_dops

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

---
 fs/proc/generic.c  | 8 +++++---
 fs/proc/internal.h | 5 +++--
 2 files changed, 8 insertions(+), 5 deletions(-)
fs/proc/generic.c +5 -3
index 8ec90826a49e..499c2bf67488 100644
@@ -254,7 +254,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		inode = proc_get_inode(dir->i_sb, de);
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
-		d_set_d_op(dentry, de->proc_dops);
+		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
+			d_set_d_op(dentry, &proc_net_dentry_ops);
+		else
+			d_set_d_op(dentry, &proc_misc_dentry_ops);
 		return d_splice_alias(inode, dentry);
 	}
 	read_unlock(&proc_subdir_lock);
@@ -448,9 +451,8 @@ static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 	INIT_LIST_HEAD(&ent->pde_openers);
 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 
-	ent->proc_dops = &proc_misc_dentry_ops;
 	/* Revalidate everything under /proc/${pid}/net */
-	if ((*parent)->proc_dops == &proc_net_dentry_ops)
+	if ((*parent)->flags & PROC_ENTRY_FORCE_LOOKUP)
 		pde_force_lookup(ent);
 
 out:
fs/proc/internal.h +3 -2
index 1695509370b8..07f75c959173 100644
@@ -44,7 +44,6 @@ struct proc_dir_entry {
 		const struct proc_ops *proc_ops;
 		const struct file_operations *proc_dir_ops;
 	};
-	const struct dentry_operations *proc_dops;
 	union {
 		const struct seq_operations *seq_ops;
 		int (*single_show)(struct seq_file *, void *);
@@ -67,6 +66,8 @@ struct proc_dir_entry {
 	char inline_name[];
 } __randomize_layout;
 
+#define PROC_ENTRY_FORCE_LOOKUP 2 /* same space as PROC_ENTRY_PERMANENT */
+
 #define SIZEOF_PDE	(				\
 	sizeof(struct proc_dir_entry) < 128 ? 128 :	\
 	sizeof(struct proc_dir_entry) < 192 ? 192 :	\
@@ -346,7 +347,7 @@ extern const struct dentry_operations proc_net_dentry_ops;
 static inline void pde_force_lookup(struct proc_dir_entry *pde)
 {
 	/* /proc/net/ entries can be changed under us by setns(CLONE_NEWNET) */
-	pde->proc_dops = &proc_net_dentry_ops;
+	pde->flags |= PROC_ENTRY_FORCE_LOOKUP;
 }
 
 /*
Signature · 1 line
2.39.5
author maintainer
#5 lore raw

PATCH 2/21 new helper: d_splice_alias_ops()

Uses of d_set_d_op() on live dentry can be very dangerous; it is going to be withdrawn and replaced with saner things.

The best way for a filesystem is to have the default dentry_operations set at mount time and be done with that - __d_alloc() will use that.

Currently there are two cases when d_set_d_op() is used on a live dentry - one is procfs, which has several genuinely different dentry_operations instances (different ->d_revalidate(), etc.) and another is simple_lookup(), where we would be better off without overriding ->d_op.

For procfs we have d_set_d_op() calls followed by d_splice_alias(); provide a new helper (d_splice_alias_ops(inode, dentry, d_ops)) that would combine those two, and do the d_set_d_op() part while under ->d_lock. That eliminates one of the places where ->d_flags had been modified without holding ->d_lock; current behaviour is not racy, but the reasons for that are far too brittle. Better move to uniform locking rules and simpler proof of correctness...

The next commit will convert procfs to use of that helper; it is not exported and won't be until somebody comes up with convincing modular user for it.

Again, the best approach is to have default ->d_op and let __d_alloc() do the right thing; filesystem _may_ need non-uniform ->d_op (procfs does), but there'd better be good reasons for that.

---
 fs/dcache.c            | 63 ++++++++++++++++++++++++------------------
 include/linux/dcache.h |  3 ++
 2 files changed, 39 insertions(+), 27 deletions(-)
fs/dcache.c +36 -27
index e3634916ffb9..c85efbda133a 100644
@@ -2641,7 +2641,8 @@ EXPORT_SYMBOL(__d_lookup_unhash_wake);
 
 /* inode->i_lock held if inode is non-NULL */
 
-static inline void __d_add(struct dentry *dentry, struct inode *inode)
+static inline void __d_add(struct dentry *dentry, struct inode *inode,
+			   const struct dentry_operations *ops)
 {
 	wait_queue_head_t *d_wait;
 	struct inode *dir = NULL;
@@ -2652,6 +2653,8 @@ static inline void __d_add(struct dentry *dentry, struct inode *inode)
 		n = start_dir_add(dir);
 		d_wait = __d_lookup_unhash(dentry);
 	}
+	if (unlikely(ops))
+		d_set_d_op(dentry, ops);
 	if (inode) {
 		unsigned add_flags = d_flags_for_inode(inode);
 		hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
@@ -2683,7 +2686,7 @@ void d_add(struct dentry *entry, struct inode *inode)
 		security_d_instantiate(entry, inode);
 		spin_lock(&inode->i_lock);
 	}
-	__d_add(entry, inode);
+	__d_add(entry, inode, NULL);
 }
 EXPORT_SYMBOL(d_add);
 
@@ -2981,30 +2984,8 @@ static int __d_unalias(struct dentry *dentry, struct dentry *alias)
 	return ret;
 }
 
-/**
- * d_splice_alias - splice a disconnected dentry into the tree if one exists
- * @inode:  the inode which may have a disconnected dentry
- * @dentry: a negative dentry which we want to point to the inode.
- *
- * If inode is a directory and has an IS_ROOT alias, then d_move that in
- * place of the given dentry and return it, else simply d_add the inode
- * to the dentry and return NULL.
- *
- * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
- * we should error out: directories can't have multiple aliases.
- *
- * This is needed in the lookup routine of any filesystem that is exportable
- * (via knfsd) so that we can build dcache paths to directories effectively.
- *
- * If a dentry was found and moved, then it is returned.  Otherwise NULL
- * is returned.  This matches the expected return value of ->lookup.
- *
- * Cluster filesystems may call this function with a negative, hashed dentry.
- * In that case, we know that the inode will be a regular file, and also this
- * will only occur during atomic_open. So we need to check for the dentry
- * being already hashed only in the final case.
- */
-struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+struct dentry *d_splice_alias_ops(struct inode *inode, struct dentry *dentry,
+				  const struct dentry_operations *ops)
 {
 	if (IS_ERR(inode))
 		return ERR_CAST(inode);
@@ -3050,9 +3031,37 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 		}
 	}
 out:
-	__d_add(dentry, inode);
+	__d_add(dentry, inode, ops);
 	return NULL;
 }
+
+/**
+ * d_splice_alias - splice a disconnected dentry into the tree if one exists
+ * @inode:  the inode which may have a disconnected dentry
+ * @dentry: a negative dentry which we want to point to the inode.
+ *
+ * If inode is a directory and has an IS_ROOT alias, then d_move that in
+ * place of the given dentry and return it, else simply d_add the inode
+ * to the dentry and return NULL.
+ *
+ * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
+ * we should error out: directories can't have multiple aliases.
+ *
+ * This is needed in the lookup routine of any filesystem that is exportable
+ * (via knfsd) so that we can build dcache paths to directories effectively.
+ *
+ * If a dentry was found and moved, then it is returned.  Otherwise NULL
+ * is returned.  This matches the expected return value of ->lookup.
+ *
+ * Cluster filesystems may call this function with a negative, hashed dentry.
+ * In that case, we know that the inode will be a regular file, and also this
+ * will only occur during atomic_open. So we need to check for the dentry
+ * being already hashed only in the final case.
+ */
+struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+{
+	return d_splice_alias_ops(inode, dentry, NULL);
+}
 EXPORT_SYMBOL(d_splice_alias);
 
 /*
include/linux/dcache.h +3 -0
index 4afb60365675..f47f3a47d97b 100644
@@ -250,6 +250,9 @@ extern struct dentry * d_alloc_anon(struct super_block *);
 extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
 					wait_queue_head_t *);
 extern struct dentry * d_splice_alias(struct inode *, struct 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 bool d_same_name(const struct dentry *dentry, const struct dentry *parent,
 			const struct qstr *name);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 2/21
#6 lore raw

Re: [PATCH 02/21] new helper: d_splice_alias_ops()

Quoted 23 lines · Al Viro

Uses of d_set_d_op() on live dentry can be very dangerous; it is going to be withdrawn and replaced with saner things.

The best way for a filesystem is to have the default dentry_operations set at mount time and be done with that - __d_alloc() will use that.

Currently there are two cases when d_set_d_op() is used on a live dentry - one is procfs, which has several genuinely different dentry_operations instances (different ->d_revalidate(), etc.) and another is simple_lookup(), where we would be better off without overriding ->d_op.

For procfs we have d_set_d_op() calls followed by d_splice_alias(); provide a new helper (d_splice_alias_ops(inode, dentry, d_ops)) that would combine those two, and do the d_set_d_op() part while under ->d_lock. That eliminates one of the places where ->d_flags had been modified without holding ->d_lock; current behaviour is not racy, but the reasons for that are far too brittle. Better move to uniform locking rules and simpler proof of correctness...

The next commit will convert procfs to use of that helper; it is not exported and won't be until somebody comes up with convincing modular user for it.

Quoted 6 lines

Again, the best approach is to have default ->d_op and let __d_alloc() do the right thing; filesystem _may_ need non-uniform ->d_op (procfs does), but there'd better be good reasons for that.

---

Quoted 125 lines
 fs/dcache.c            | 63 ++++++++++++++++++++++++------------------
 include/linux/dcache.h |  3 ++
 2 files changed, 39 insertions(+), 27 deletions(-)
fs/dcache.c +36 -27
index e3634916ffb9..c85efbda133a 100644
@@ -2641,7 +2641,8 @@ EXPORT_SYMBOL(__d_lookup_unhash_wake);
 
 /* inode->i_lock held if inode is non-NULL */
 
-static inline void __d_add(struct dentry *dentry, struct inode *inode)
+static inline void __d_add(struct dentry *dentry, struct inode *inode,
+			   const struct dentry_operations *ops)
 {
 	wait_queue_head_t *d_wait;
 	struct inode *dir = NULL;
@@ -2652,6 +2653,8 @@ static inline void __d_add(struct dentry *dentry, struct inode *inode)
 		n = start_dir_add(dir);
 		d_wait = __d_lookup_unhash(dentry);
 	}
+	if (unlikely(ops))
+		d_set_d_op(dentry, ops);
 	if (inode) {
 		unsigned add_flags = d_flags_for_inode(inode);
 		hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
@@ -2683,7 +2686,7 @@ void d_add(struct dentry *entry, struct inode *inode)
 		security_d_instantiate(entry, inode);
 		spin_lock(&inode->i_lock);
 	}
-	__d_add(entry, inode);
+	__d_add(entry, inode, NULL);
 }
 EXPORT_SYMBOL(d_add);
 
@@ -2981,30 +2984,8 @@ static int __d_unalias(struct dentry *dentry, struct dentry *alias)
 	return ret;
 }
 
-/**
- * d_splice_alias - splice a disconnected dentry into the tree if one exists
- * @inode:  the inode which may have a disconnected dentry
- * @dentry: a negative dentry which we want to point to the inode.
- *
- * If inode is a directory and has an IS_ROOT alias, then d_move that in
- * place of the given dentry and return it, else simply d_add the inode
- * to the dentry and return NULL.
- *
- * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
- * we should error out: directories can't have multiple aliases.
- *
- * This is needed in the lookup routine of any filesystem that is exportable
- * (via knfsd) so that we can build dcache paths to directories effectively.
- *
- * If a dentry was found and moved, then it is returned.  Otherwise NULL
- * is returned.  This matches the expected return value of ->lookup.
- *
- * Cluster filesystems may call this function with a negative, hashed dentry.
- * In that case, we know that the inode will be a regular file, and also this
- * will only occur during atomic_open. So we need to check for the dentry
- * being already hashed only in the final case.
- */
-struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+struct dentry *d_splice_alias_ops(struct inode *inode, struct dentry *dentry,
+				  const struct dentry_operations *ops)
 {
 	if (IS_ERR(inode))
 		return ERR_CAST(inode);
@@ -3050,9 +3031,37 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 		}
 	}
 out:
-	__d_add(dentry, inode);
+	__d_add(dentry, inode, ops);
 	return NULL;
 }
+
+/**
+ * d_splice_alias - splice a disconnected dentry into the tree if one exists
+ * @inode:  the inode which may have a disconnected dentry
+ * @dentry: a negative dentry which we want to point to the inode.
+ *
+ * If inode is a directory and has an IS_ROOT alias, then d_move that in
+ * place of the given dentry and return it, else simply d_add the inode
+ * to the dentry and return NULL.
+ *
+ * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
+ * we should error out: directories can't have multiple aliases.
+ *
+ * This is needed in the lookup routine of any filesystem that is exportable
+ * (via knfsd) so that we can build dcache paths to directories effectively.
+ *
+ * If a dentry was found and moved, then it is returned.  Otherwise NULL
+ * is returned.  This matches the expected return value of ->lookup.
+ *
+ * Cluster filesystems may call this function with a negative, hashed dentry.
+ * In that case, we know that the inode will be a regular file, and also this
+ * will only occur during atomic_open. So we need to check for the dentry
+ * being already hashed only in the final case.
+ */
+struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+{
+	return d_splice_alias_ops(inode, dentry, NULL);
+}
 EXPORT_SYMBOL(d_splice_alias);
 
 /*
include/linux/dcache.h +3 -0
index 4afb60365675..f47f3a47d97b 100644
@@ -250,6 +250,9 @@ extern struct dentry * d_alloc_anon(struct super_block *);
 extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
 					wait_queue_head_t *);
 extern struct dentry * d_splice_alias(struct inode *, struct 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 bool d_same_name(const struct dentry *dentry, const struct dentry *parent,
 			const struct qstr *name);
Signature · 1 line
2.39.5
author maintainer
#7 lore raw

PATCH 3/21 switch procfs from d_set_d_op() to d_splice_alias_ops()

In reply to Al Viro
---
 fs/proc/base.c        | 9 +++------
 fs/proc/generic.c     | 8 ++++----
 fs/proc/internal.h    | 3 +--
 fs/proc/namespaces.c  | 3 +--
 fs/proc/proc_sysctl.c | 7 +++----
 5 files changed, 12 insertions(+), 18 deletions(-)
fs/proc/base.c +3 -6
index cd89e956c322..397a9f6f463e 100644
@@ -2709,8 +2709,7 @@ static struct dentry *proc_pident_instantiate(struct dentry *dentry,
 		inode->i_fop = p->fop;
 	ei->op = p->op;
 	pid_update_inode(task, inode);
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_pident_lookup(struct inode *dir, 
@@ -3508,8 +3507,7 @@ static struct dentry *proc_pid_instantiate(struct dentry * dentry,
 	set_nlink(inode, nlink_tgid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 struct dentry *proc_pid_lookup(struct dentry *dentry, unsigned int flags)
@@ -3813,8 +3811,7 @@ static struct dentry *proc_task_instantiate(struct dentry *dentry,
 	set_nlink(inode, nlink_tid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
fs/proc/generic.c +4 -4
index 499c2bf67488..774e18372914 100644
@@ -255,10 +255,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
 		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
-			d_set_d_op(dentry, &proc_net_dentry_ops);
-		else
-			d_set_d_op(dentry, &proc_misc_dentry_ops);
-		return d_splice_alias(inode, dentry);
+			return d_splice_alias_ops(inode, dentry,
+						  &proc_net_dentry_ops);
+		return d_splice_alias_ops(inode, dentry,
+					  &proc_misc_dentry_ops);
 	}
 	read_unlock(&proc_subdir_lock);
 	return ERR_PTR(-ENOENT);
fs/proc/internal.h +1 -2
index 07f75c959173..48410381036b 100644
@@ -358,7 +358,6 @@ static inline void pde_force_lookup(struct proc_dir_entry *pde)
 static inline struct dentry *proc_splice_unmountable(struct inode *inode,
 		struct dentry *dentry, const struct dentry_operations *d_ops)
 {
-	d_set_d_op(dentry, d_ops);
 	dont_mount(dentry);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, d_ops);
 }
fs/proc/namespaces.c +1 -2
index c610224faf10..4403a2e20c16 100644
@@ -111,8 +111,7 @@ static struct dentry *proc_ns_instantiate(struct dentry *dentry,
 	ei->ns_ops = ns_ops;
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static int proc_ns_dir_readdir(struct file *file, struct dir_context *ctx)
fs/proc/proc_sysctl.c +3 -4
index cc9d74a06ff0..7a8bffc03dc8 100644
@@ -540,9 +540,8 @@ static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
 			goto out;
 	}
 
-	d_set_d_op(dentry, &proc_sys_dentry_operations);
 	inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
-	err = d_splice_alias(inode, dentry);
+	err = d_splice_alias_ops(inode, dentry, &proc_sys_dentry_operations);
 
 out:
 	if (h)
@@ -699,9 +698,9 @@ static bool proc_sys_fill_cache(struct file *file,
 			return false;
 		if (d_in_lookup(child)) {
 			struct dentry *res;
-			d_set_d_op(child, &proc_sys_dentry_operations);
 			inode = proc_sys_make_inode(dir->d_sb, head, table);
-			res = d_splice_alias(inode, child);
+			res = d_splice_alias_ops(inode, child,
+						 &proc_sys_dentry_operations);
 			d_lookup_done(child);
 			if (unlikely(res)) {
 				dput(child);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 3/21
#8 lore raw

Re: [PATCH 03/21] switch procfs from d_set_d_op() to d_splice_alias_ops()

Quoted 2 lines · Al Viro

---

Quoted 117 lines
 fs/proc/base.c        | 9 +++------
 fs/proc/generic.c     | 8 ++++----
 fs/proc/internal.h    | 3 +--
 fs/proc/namespaces.c  | 3 +--
 fs/proc/proc_sysctl.c | 7 +++----
 5 files changed, 12 insertions(+), 18 deletions(-)
fs/proc/base.c +3 -6
index cd89e956c322..397a9f6f463e 100644
@@ -2709,8 +2709,7 @@ static struct dentry *proc_pident_instantiate(struct dentry *dentry,
 		inode->i_fop = p->fop;
 	ei->op = p->op;
 	pid_update_inode(task, inode);
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_pident_lookup(struct inode *dir, 
@@ -3508,8 +3507,7 @@ static struct dentry *proc_pid_instantiate(struct dentry * dentry,
 	set_nlink(inode, nlink_tgid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 struct dentry *proc_pid_lookup(struct dentry *dentry, unsigned int flags)
@@ -3813,8 +3811,7 @@ static struct dentry *proc_task_instantiate(struct dentry *dentry,
 	set_nlink(inode, nlink_tid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
fs/proc/generic.c +4 -4
index 499c2bf67488..774e18372914 100644
@@ -255,10 +255,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
 		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
-			d_set_d_op(dentry, &proc_net_dentry_ops);
-		else
-			d_set_d_op(dentry, &proc_misc_dentry_ops);
-		return d_splice_alias(inode, dentry);
+			return d_splice_alias_ops(inode, dentry,
+						  &proc_net_dentry_ops);
+		return d_splice_alias_ops(inode, dentry,
+					  &proc_misc_dentry_ops);
 	}
 	read_unlock(&proc_subdir_lock);
 	return ERR_PTR(-ENOENT);
fs/proc/internal.h +1 -2
index 07f75c959173..48410381036b 100644
@@ -358,7 +358,6 @@ static inline void pde_force_lookup(struct proc_dir_entry *pde)
 static inline struct dentry *proc_splice_unmountable(struct inode *inode,
 		struct dentry *dentry, const struct dentry_operations *d_ops)
 {
-	d_set_d_op(dentry, d_ops);
 	dont_mount(dentry);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, d_ops);
 }
fs/proc/namespaces.c +1 -2
index c610224faf10..4403a2e20c16 100644
@@ -111,8 +111,7 @@ static struct dentry *proc_ns_instantiate(struct dentry *dentry,
 	ei->ns_ops = ns_ops;
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static int proc_ns_dir_readdir(struct file *file, struct dir_context *ctx)
fs/proc/proc_sysctl.c +3 -4
index cc9d74a06ff0..7a8bffc03dc8 100644
@@ -540,9 +540,8 @@ static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
 			goto out;
 	}
 
-	d_set_d_op(dentry, &proc_sys_dentry_operations);
 	inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
-	err = d_splice_alias(inode, dentry);
+	err = d_splice_alias_ops(inode, dentry, &proc_sys_dentry_operations);
 
 out:
 	if (h)
@@ -699,9 +698,9 @@ static bool proc_sys_fill_cache(struct file *file,
 			return false;
 		if (d_in_lookup(child)) {
 			struct dentry *res;
-			d_set_d_op(child, &proc_sys_dentry_operations);
 			inode = proc_sys_make_inode(dir->d_sb, head, table);
-			res = d_splice_alias(inode, child);
+			res = d_splice_alias_ops(inode, child,
+						 &proc_sys_dentry_operations);
 			d_lookup_done(child);
 			if (unlikely(res)) {
 				dput(child);
Signature · 1 line
2.39.5
author maintainer
#9 lore raw

PATCH 4/21 fuse: no need for special dentry_operations for root dentry

In reply to Al Viro

->d_revalidate() is never called for root anyway...

---
 fs/fuse/dir.c    | 7 -------
 fs/fuse/fuse_i.h | 1 -
 fs/fuse/inode.c  | 4 +---
 3 files changed, 1 insertion(+), 11 deletions(-)
fs/fuse/dir.c +0 -7
index 198862b086ff..24979d5413fa 100644
@@ -336,13 +336,6 @@ const struct dentry_operations fuse_dentry_operations = {
 	.d_automount	= fuse_dentry_automount,
 };
 
-const struct dentry_operations fuse_root_dentry_operations = {
-#if BITS_PER_LONG < 64
-	.d_init		= fuse_dentry_init,
-	.d_release	= fuse_dentry_release,
-#endif
-};
-
 int fuse_valid_type(int m)
 {
 	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
fs/fuse/fuse_i.h +0 -1
index fee96fe7887b..71a2b3900854 100644
@@ -1069,7 +1069,6 @@ static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)
 extern const struct file_operations fuse_dev_operations;
 
 extern const struct dentry_operations fuse_dentry_operations;
-extern const struct dentry_operations fuse_root_dentry_operations;
 
 /**
  * Get a filled in inode
fs/fuse/inode.c +1 -3
index e9db2cb8c150..57a1ee016b73 100644
@@ -1800,12 +1800,10 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_root_dentry_operations;
+	sb->s_d_op = &fuse_dentry_operations;
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
-	/* Root dentry doesn't have .d_revalidate */
-	sb->s_d_op = &fuse_dentry_operations;
 
 	mutex_lock(&fuse_mutex);
 	err = -EINVAL;
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 4/21
#10 lore raw

Re: [PATCH 04/21] fuse: no need for special dentry_operations for root dentry

Quoted 4 lines · Al Viro

->d_revalidate() is never called for root anyway...

---

Quoted 56 lines
 fs/fuse/dir.c    | 7 -------
 fs/fuse/fuse_i.h | 1 -
 fs/fuse/inode.c  | 4 +---
 3 files changed, 1 insertion(+), 11 deletions(-)
fs/fuse/dir.c +0 -7
index 198862b086ff..24979d5413fa 100644
@@ -336,13 +336,6 @@ const struct dentry_operations fuse_dentry_operations = {
 	.d_automount	= fuse_dentry_automount,
 };
 
-const struct dentry_operations fuse_root_dentry_operations = {
-#if BITS_PER_LONG < 64
-	.d_init		= fuse_dentry_init,
-	.d_release	= fuse_dentry_release,
-#endif
-};
-
 int fuse_valid_type(int m)
 {
 	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
fs/fuse/fuse_i.h +0 -1
index fee96fe7887b..71a2b3900854 100644
@@ -1069,7 +1069,6 @@ static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)
 extern const struct file_operations fuse_dev_operations;
 
 extern const struct dentry_operations fuse_dentry_operations;
-extern const struct dentry_operations fuse_root_dentry_operations;
 
 /**
  * Get a filled in inode
fs/fuse/inode.c +1 -3
index e9db2cb8c150..57a1ee016b73 100644
@@ -1800,12 +1800,10 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_root_dentry_operations;
+	sb->s_d_op = &fuse_dentry_operations;
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
-	/* Root dentry doesn't have .d_revalidate */
-	sb->s_d_op = &fuse_dentry_operations;
 
 	mutex_lock(&fuse_mutex);
 	err = -EINVAL;
Signature · 1 line
2.39.5
author maintainer
#12 lore raw

PATCH 5/21 new helper: set_default_d_op()

In reply to Al Viro

... to be used instead of manually assigning to ->s_d_op. All in-tree filesystem converted (and field itself is renamed, so any out-of-tree ones in need of conversion will be caught by compiler).

---
 Documentation/filesystems/porting.rst |  7 +++++++
 fs/9p/vfs_super.c                     |  4 ++--
 fs/adfs/super.c                       |  2 +-
 fs/affs/super.c                       |  4 ++--
 fs/afs/super.c                        |  4 ++--
 fs/autofs/inode.c                     |  2 +-
 fs/btrfs/super.c                      |  2 +-
 fs/ceph/super.c                       |  2 +-
 fs/coda/inode.c                       |  2 +-
 fs/configfs/mount.c                   |  2 +-
 fs/dcache.c                           | 10 ++++++++--
 fs/debugfs/inode.c                    |  2 +-
 fs/devpts/inode.c                     |  2 +-
 fs/ecryptfs/main.c                    |  2 +-
 fs/efivarfs/super.c                   |  2 +-
 fs/exfat/super.c                      |  4 ++--
 fs/fat/namei_msdos.c                  |  2 +-
 fs/fat/namei_vfat.c                   |  4 ++--
 fs/fuse/inode.c                       |  4 ++--
 fs/gfs2/ops_fstype.c                  |  2 +-
 fs/hfs/super.c                        |  2 +-
 fs/hfsplus/super.c                    |  2 +-
 fs/hostfs/hostfs_kern.c               |  2 +-
 fs/hpfs/super.c                       |  2 +-
 fs/isofs/inode.c                      |  2 +-
 fs/jfs/super.c                        |  2 +-
 fs/kernfs/mount.c                     |  2 +-
 fs/libfs.c                            | 16 ++++++++--------
 fs/nfs/super.c                        |  2 +-
 fs/ntfs3/super.c                      |  3 ++-
 fs/ocfs2/super.c                      |  2 +-
 fs/orangefs/super.c                   |  2 +-
 fs/overlayfs/super.c                  |  2 +-
 fs/smb/client/cifsfs.c                |  4 ++--
 fs/tracefs/inode.c                    |  2 +-
 fs/vboxsf/super.c                     |  2 +-
 include/linux/dcache.h                |  2 ++
 include/linux/fs.h                    |  2 +-
 mm/shmem.c                            |  2 +-
 net/sunrpc/rpc_pipe.c                 |  2 +-
 40 files changed, 69 insertions(+), 53 deletions(-)
Documentation/filesystems/porting.rst +7 -0
index 1639e78e3146..004cd69617a2 100644
@@ -1157,3 +1157,10 @@ in normal case it points into the pathname being looked up.
 NOTE: if you need something like full path from the root of filesystem,
 you are still on your own - this assists with simple cases, but it's not
 magic.
+
+---
+
+**mandatory**
+
+If your filesystem sets the default dentry_operations, use set_default_d_op()
+rather than manually setting sb->s_d_op.
fs/9p/vfs_super.c +2 -2
index 489db161abc9..5c3dc3efb909 100644
@@ -135,9 +135,9 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 		goto release_sb;
 
 	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
-		sb->s_d_op = &v9fs_cached_dentry_operations;
+		set_default_d_op(sb, &v9fs_cached_dentry_operations);
 	else
-		sb->s_d_op = &v9fs_dentry_operations;
+		set_default_d_op(sb, &v9fs_dentry_operations);
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
fs/adfs/super.c +1 -1
index 017c48a80203..fdccdbbfc213 100644
@@ -397,7 +397,7 @@ static int adfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (asb->s_ftsuffix)
 		asb->s_namelen += 4;
 
-	sb->s_d_op = &adfs_dentry_operations;
+	set_default_d_op(sb, &adfs_dentry_operations);
 	root = adfs_iget(sb, &root_obj);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
fs/affs/super.c +2 -2
index 2fa40337776d..44f8aa883100 100644
@@ -500,9 +500,9 @@ static int affs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return PTR_ERR(root_inode);
 
 	if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_INTL))
-		sb->s_d_op = &affs_intl_dentry_operations;
+		set_default_d_op(sb, &affs_intl_dentry_operations);
 	else
-		sb->s_d_op = &affs_dentry_operations;
+		set_default_d_op(sb, &affs_dentry_operations);
 
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root) {
fs/afs/super.c +2 -2
index a9bee610674e..13d0414a1ddb 100644
@@ -487,12 +487,12 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 		goto error;
 
 	if (as->dyn_root) {
-		sb->s_d_op = &afs_dynroot_dentry_operations;
+		set_default_d_op(sb, &afs_dynroot_dentry_operations);
 		ret = afs_dynroot_populate(sb);
 		if (ret < 0)
 			goto error;
 	} else {
-		sb->s_d_op = &afs_fs_dentry_operations;
+		set_default_d_op(sb, &afs_fs_dentry_operations);
 		rcu_assign_pointer(as->volume->sb, sb);
 	}
 
fs/autofs/inode.c +1 -1
index ee2edccaef70..f5c16ffba013 100644
@@ -311,7 +311,7 @@ static int autofs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_blocksize_bits = 10;
 	s->s_magic = AUTOFS_SUPER_MAGIC;
 	s->s_op = &autofs_sops;
-	s->s_d_op = &autofs_dentry_operations;
+	set_default_d_op(s, &autofs_dentry_operations);
 	s->s_time_gran = 1;
 
 	/*
fs/btrfs/super.c +1 -1
index dc4fee519ca6..5f39857ea3ae 100644
@@ -954,7 +954,7 @@ static int btrfs_fill_super(struct super_block *sb,
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_magic = BTRFS_SUPER_MAGIC;
 	sb->s_op = &btrfs_super_ops;
-	sb->s_d_op = &btrfs_dentry_operations;
+	set_default_d_op(sb, &btrfs_dentry_operations);
 	sb->s_export_op = &btrfs_export_ops;
 #ifdef CONFIG_FS_VERITY
 	sb->s_vop = &btrfs_verityops;
fs/ceph/super.c +1 -1
index 4344e1f11806..adec6e2f01c4 100644
@@ -1220,7 +1220,7 @@ static int ceph_set_super(struct super_block *s, struct fs_context *fc)
 	fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
 
 	s->s_op = &ceph_super_ops;
-	s->s_d_op = &ceph_dentry_ops;
+	set_default_d_op(s, &ceph_dentry_ops);
 	s->s_export_op = &ceph_export_ops;
 
 	s->s_time_gran = 1;
fs/coda/inode.c +1 -1
index 6896fce122e1..08450d006016 100644
@@ -230,7 +230,7 @@ static int coda_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 12;
 	sb->s_magic = CODA_SUPER_MAGIC;
 	sb->s_op = &coda_super_operations;
-	sb->s_d_op = &coda_dentry_operations;
+	set_default_d_op(sb, &coda_dentry_operations);
 	sb->s_time_gran = 1;
 	sb->s_time_min = S64_MIN;
 	sb->s_time_max = S64_MAX;
fs/configfs/mount.c +1 -1
index c2d820063ec4..20412eaca972 100644
@@ -92,7 +92,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	configfs_root_group.cg_item.ci_dentry = root;
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
-	sb->s_d_op = &configfs_dentry_ops; /* the rest get that */
+	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
 	return 0;
 }
 
fs/dcache.c +8 -2
index c85efbda133a..cd5e5139ca4c 100644
@@ -1712,7 +1712,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->s_d_op);
+	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1795,7 +1795,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	struct dentry *dentry = __d_alloc(sb, name);
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
-		if (!sb->s_d_op)
+		if (!dentry->d_op)
 			d_set_d_op(dentry, &anon_ops);
 	}
 	return dentry;
@@ -1841,6 +1841,12 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 }
 EXPORT_SYMBOL(d_set_d_op);
 
+void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
+{
+	s->__s_d_op = ops;
+}
+EXPORT_SYMBOL(set_default_d_op);
+
 static unsigned d_flags_for_inode(struct inode *inode)
 {
 	unsigned add_flags = DCACHE_REGULAR_TYPE;
fs/debugfs/inode.c +1 -1
index 75715d8877ee..f54a8fd960e4 100644
@@ -273,7 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &debugfs_super_operations;
-	sb->s_d_op = &debugfs_dops;
+	set_default_d_op(sb, &debugfs_dops);
 
 	debugfs_apply_options(sb);
 
fs/devpts/inode.c +1 -1
index 1096ff8562fa..f092973236ef 100644
@@ -433,7 +433,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	s->s_d_op = &simple_dentry_operations;
+	set_default_d_op(s, &simple_dentry_operations);
 	s->s_time_gran = 1;
 
 	error = -ENOMEM;
fs/ecryptfs/main.c +1 -1
index 8dd1d7189c3b..45f9ca4465da 100644
@@ -471,7 +471,7 @@ static int ecryptfs_get_tree(struct fs_context *fc)
 	sbi = NULL;
 	s->s_op = &ecryptfs_sops;
 	s->s_xattr = ecryptfs_xattr_handlers;
-	s->s_d_op = &ecryptfs_dops;
+	set_default_d_op(s, &ecryptfs_dops);
 
 	err = "Reading sb failed";
 	rc = kern_path(fc->source, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
fs/efivarfs/super.c +1 -1
index 09fcf731e65d..3f3188e0cfa7 100644
@@ -345,7 +345,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits    = PAGE_SHIFT;
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
-	sb->s_d_op		= &efivarfs_d_ops;
+	set_default_d_op(sb, &efivarfs_d_ops);
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
fs/exfat/super.c +2 -2
index bd57844414aa..c821582fa1ef 100644
@@ -697,9 +697,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)
 	}
 
 	if (sbi->options.utf8)
-		sb->s_d_op = &exfat_utf8_dentry_ops;
+		set_default_d_op(sb, &exfat_utf8_dentry_ops);
 	else
-		sb->s_d_op = &exfat_dentry_ops;
+		set_default_d_op(sb, &exfat_dentry_ops);
 
 	root_inode = new_inode(sb);
 	if (!root_inode) {
fs/fat/namei_msdos.c +1 -1
index f06f6ba643cc..71302291d33c 100644
@@ -646,7 +646,7 @@ static const struct inode_operations msdos_dir_inode_operations = {
 static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
-	sb->s_d_op = &msdos_dentry_operations;
+	set_default_d_op(sb, &msdos_dentry_operations);
 	sb->s_flags |= SB_NOATIME;
 }
 
fs/fat/namei_vfat.c +2 -2
index 926c26e90ef8..2476afd1304d 100644
@@ -1187,9 +1187,9 @@ static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
 	if (MSDOS_SB(sb)->options.name_check != 's')
-		sb->s_d_op = &vfat_ci_dentry_ops;
+		set_default_d_op(sb, &vfat_ci_dentry_ops);
 	else
-		sb->s_d_op = &vfat_dentry_ops;
+		set_default_d_op(sb, &vfat_dentry_ops);
 }
 
 static int vfat_fill_super(struct super_block *sb, struct fs_context *fc)
fs/fuse/inode.c +2 -2
index 57a1ee016b73..9994f3b33a9f 100644
@@ -1665,7 +1665,7 @@ static int fuse_fill_super_submount(struct super_block *sb,
 	fi = get_fuse_inode(root);
 	fi->nlookup--;
 
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root)
 		return -ENOMEM;
@@ -1800,7 +1800,7 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
fs/gfs2/ops_fstype.c +1 -1
index e83d293c3614..949bbdb5b564 100644
@@ -1156,7 +1156,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_flags |= SB_NOSEC;
 	sb->s_magic = GFS2_MAGIC;
 	sb->s_op = &gfs2_super_ops;
-	sb->s_d_op = &gfs2_dops;
+	set_default_d_op(sb, &gfs2_dops);
 	sb->s_export_op = &gfs2_export_ops;
 	sb->s_qcop = &gfs2_quotactl_ops;
 	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
fs/hfs/super.c +1 -1
index fe09c2093a93..388a318297ec 100644
@@ -365,7 +365,7 @@ static int hfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (!root_inode)
 		goto bail_no_root;
 
-	sb->s_d_op = &hfs_dentry_operations;
+	set_default_d_op(sb, &hfs_dentry_operations);
 	res = -ENOMEM;
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root)
fs/hfsplus/super.c +1 -1
index 948b8aaee33e..0caf7aa1c249 100644
@@ -508,7 +508,7 @@ static int hfsplus_fill_super(struct super_block *sb, struct fs_context *fc)
 		goto out_put_alloc_file;
 	}
 
-	sb->s_d_op = &hfsplus_dentry_operations;
+	set_default_d_op(sb, &hfsplus_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
 		err = -ENOMEM;
fs/hostfs/hostfs_kern.c +1 -1
index e0741e468956..a0e0563a29d7 100644
@@ -920,7 +920,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
fs/hpfs/super.c +1 -1
index 27567920abe4..42b779b4d87f 100644
@@ -554,7 +554,7 @@ static int hpfs_fill_super(struct super_block *s, struct fs_context *fc)
 	/* Fill superblock stuff */
 	s->s_magic = HPFS_SUPER_MAGIC;
 	s->s_op = &hpfs_sops;
-	s->s_d_op = &hpfs_dentry_operations;
+	set_default_d_op(s, &hpfs_dentry_operations);
 	s->s_time_min =  local_to_gmt(s, 0);
 	s->s_time_max =  local_to_gmt(s, U32_MAX);
 
fs/isofs/inode.c +1 -1
index 47038e660812..05ddc2544ade 100644
@@ -939,7 +939,7 @@ static int isofs_fill_super(struct super_block *s, struct fs_context *fc)
 	sbi->s_check = opt->check;
 
 	if (table)
-		s->s_d_op = &isofs_dentry_ops[table - 1];
+		set_default_d_op(s, &isofs_dentry_ops[table - 1]);
 
 	/* get the root dentry */
 	s->s_root = d_make_root(inode);
fs/jfs/super.c +1 -1
index 223d9ac59839..10c3cb714423 100644
@@ -542,7 +542,7 @@ static int jfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic = JFS_SUPER_MAGIC;
 
 	if (sbi->mntflag & JFS_OS2)
-		sb->s_d_op = &jfs_ci_dentry_operations;
+		set_default_d_op(sb, &jfs_ci_dentry_operations);
 
 	inode = jfs_iget(sb, ROOT_I);
 	if (IS_ERR(inode)) {
fs/kernfs/mount.c +1 -1
index 1358c21837f1..91e788d15073 100644
@@ -281,7 +281,7 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *k
 		return -ENOMEM;
 	}
 	sb->s_root = root;
-	sb->s_d_op = &kernfs_dops;
+	set_default_d_op(sb, &kernfs_dops);
 	return 0;
 }
 
fs/libfs.c +8 -8
index 8444f5cc4064..929bef0fecbd 100644
@@ -75,7 +75,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_sb->s_d_op)
+	if (!dentry->d_op)
 		d_set_d_op(dentry, &simple_dentry_operations);
 
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
@@ -683,7 +683,7 @@ static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_root = d_make_root(root);
 	if (!s->s_root)
 		return -ENOMEM;
-	s->s_d_op = ctx->dops;
+	set_default_d_op(s, ctx->dops);
 	return 0;
 }
 
@@ -1943,22 +1943,22 @@ static const struct dentry_operations generic_encrypted_dentry_ops = {
  * @sb: superblock to be configured
  *
  * Filesystems supporting casefolding and/or fscrypt can call this
- * helper at mount-time to configure sb->s_d_op to best set of dentry
- * operations required for the enabled features. The helper must be
- * called after these have been configured, but before the root dentry
- * is created.
+ * helper at mount-time to configure default dentry_operations to the
+ * best set of dentry operations required for the enabled features.
+ * The helper must be called after these have been configured, but
+ * before the root dentry is created.
  */
 void generic_set_sb_d_ops(struct super_block *sb)
 {
 #if IS_ENABLED(CONFIG_UNICODE)
 	if (sb->s_encoding) {
-		sb->s_d_op = &generic_ci_dentry_ops;
+		set_default_d_op(sb, &generic_ci_dentry_ops);
 		return;
 	}
 #endif
 #ifdef CONFIG_FS_ENCRYPTION
 	if (sb->s_cop) {
-		sb->s_d_op = &generic_encrypted_dentry_ops;
+		set_default_d_op(sb, &generic_encrypted_dentry_ops);
 		return;
 	}
 #endif
fs/nfs/super.c +1 -1
index aeb715b4a690..38b0ecf02ad6 100644
@@ -1169,7 +1169,7 @@ static int nfs_set_super(struct super_block *s, struct fs_context *fc)
 	struct nfs_server *server = fc->s_fs_info;
 	int ret;
 
-	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
+	set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
 	ret = set_anon_super(s, server);
 	if (ret == 0)
 		server->s_dev = s->s_dev;
fs/ntfs3/super.c +2 -1
index 6a0f6b0a3ab2..90f5361ae13f 100644
@@ -1182,7 +1182,8 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_export_op = &ntfs_export_ops;
 	sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
 	sb->s_xattr = ntfs_xattr_handlers;
-	sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
+	if (options->nocase)
+		set_default_d_op(sb, &ntfs_dentry_ops);
 
 	options->nls = ntfs_load_nls(options->nls_name);
 	if (IS_ERR(options->nls)) {
fs/ocfs2/super.c +1 -1
index 8bb5022f3082..411f72be4a9b 100644
@@ -1959,7 +1959,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
 
 	sb->s_fs_info = osb;
 	sb->s_op = &ocfs2_sops;
-	sb->s_d_op = &ocfs2_dentry_ops;
+	set_default_d_op(sb, &ocfs2_dentry_ops);
 	sb->s_export_op = &ocfs2_export_ops;
 	sb->s_qcop = &dquot_quotactl_sysfile_ops;
 	sb->dq_op = &ocfs2_quota_operations;
fs/orangefs/super.c +1 -1
index eba3e357192e..d4c8d8b32f14 100644
@@ -434,7 +434,7 @@ static int orangefs_fill_sb(struct super_block *sb,
 	sb->s_xattr = orangefs_xattr_handlers;
 	sb->s_magic = ORANGEFS_SUPER_MAGIC;
 	sb->s_op = &orangefs_s_ops;
-	sb->s_d_op = &orangefs_dentry_operations;
+	set_default_d_op(sb, &orangefs_dentry_operations);
 
 	sb->s_blocksize = PAGE_SIZE;
 	sb->s_blocksize_bits = PAGE_SHIFT;
fs/overlayfs/super.c +1 -1
index 86ae6f6da36b..5f7a5a8c0778 100644
@@ -1315,7 +1315,7 @@ int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (WARN_ON(fc->user_ns != current_user_ns()))
 		goto out_err;
 
-	sb->s_d_op = &ovl_dentry_operations;
+	set_default_d_op(sb, &ovl_dentry_operations);
 
 	err = -ENOMEM;
 	ofs->creator_cred = cred = prepare_creds();
fs/smb/client/cifsfs.c +2 -2
index 6a3bd652d251..5ba1046d1e5a 100644
@@ -261,9 +261,9 @@ cifs_read_super(struct super_block *sb)
 	}
 
 	if (tcon->nocase)
-		sb->s_d_op = &cifs_ci_dentry_ops;
+		set_default_d_op(sb, &cifs_ci_dentry_ops);
 	else
-		sb->s_d_op = &cifs_dentry_ops;
+		set_default_d_op(sb, &cifs_dentry_ops);
 
 	sb->s_root = d_make_root(inode);
 	if (!sb->s_root) {
fs/tracefs/inode.c +1 -1
index 53214499e384..30a951133831 100644
@@ -480,7 +480,7 @@ static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &tracefs_super_operations;
-	sb->s_d_op = &tracefs_dentry_operations;
+	set_default_d_op(sb, &tracefs_dentry_operations);
 
 	return 0;
 }
fs/vboxsf/super.c +1 -1
index 1d94bb784108..46eea52beb23 100644
@@ -190,7 +190,7 @@ static int vboxsf_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize = 1024;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_op = &vboxsf_super_ops;
-	sb->s_d_op = &vboxsf_dentry_ops;
+	set_default_d_op(sb, &vboxsf_dentry_ops);
 
 	iroot = iget_locked(sb, 0);
 	if (!iroot) {
include/linux/dcache.h +2 -0
index f47f3a47d97b..e8cf1d0fdd08 100644
@@ -619,4 +619,6 @@ static inline struct dentry *d_next_sibling(const struct dentry *dentry)
 	return hlist_entry_safe(dentry->d_sib.next, struct dentry, d_sib);
 }
 
+void set_default_d_op(struct super_block *, const struct dentry_operations *);
+
 #endif	/* __LINUX_DCACHE_H */
include/linux/fs.h +1 -1
index 2c3b2f8a621f..23fd8b0d4e81 100644
@@ -1405,7 +1405,7 @@ struct super_block {
 	 */
 	const char *s_subtype;
 
-	const struct dentry_operations *s_d_op; /* default d_op for dentries */
+	const struct dentry_operations *__s_d_op; /* default d_op for dentries */
 
 	struct shrinker *s_shrink;	/* per-sb shrinker handle */
 
mm/shmem.c +1 -1
index 4ea6109a8043..0ecb49113bb2 100644
@@ -5019,7 +5019,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	if (ctx->encoding) {
 		sb->s_encoding = ctx->encoding;
-		sb->s_d_op = &shmem_ci_dentry_ops;
+		set_default_d_op(sb, &shmem_ci_dentry_ops);
 		if (ctx->strict_encoding)
 			sb->s_encoding_flags = SB_ENC_STRICT_MODE_FL;
 	}
net/sunrpc/rpc_pipe.c +1 -1
index eadc00410ebc..e093e4cf20fa 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 5/21
#13 lore raw

Re: [PATCH 05/21] new helper: set_default_d_op()

Quoted 7 lines · Al Viro

... to be used instead of manually assigning to ->s_d_op. All in-tree filesystem converted (and field itself is renamed, so any out-of-tree ones in need of conversion will be caught by compiler).

---

Quoted 656 lines
 Documentation/filesystems/porting.rst |  7 +++++++
 fs/9p/vfs_super.c                     |  4 ++--
 fs/adfs/super.c                       |  2 +-
 fs/affs/super.c                       |  4 ++--
 fs/afs/super.c                        |  4 ++--
 fs/autofs/inode.c                     |  2 +-
 fs/btrfs/super.c                      |  2 +-
 fs/ceph/super.c                       |  2 +-
 fs/coda/inode.c                       |  2 +-
 fs/configfs/mount.c                   |  2 +-
 fs/dcache.c                           | 10 ++++++++--
 fs/debugfs/inode.c                    |  2 +-
 fs/devpts/inode.c                     |  2 +-
 fs/ecryptfs/main.c                    |  2 +-
 fs/efivarfs/super.c                   |  2 +-
 fs/exfat/super.c                      |  4 ++--
 fs/fat/namei_msdos.c                  |  2 +-
 fs/fat/namei_vfat.c                   |  4 ++--
 fs/fuse/inode.c                       |  4 ++--
 fs/gfs2/ops_fstype.c                  |  2 +-
 fs/hfs/super.c                        |  2 +-
 fs/hfsplus/super.c                    |  2 +-
 fs/hostfs/hostfs_kern.c               |  2 +-
 fs/hpfs/super.c                       |  2 +-
 fs/isofs/inode.c                      |  2 +-
 fs/jfs/super.c                        |  2 +-
 fs/kernfs/mount.c                     |  2 +-
 fs/libfs.c                            | 16 ++++++++--------
 fs/nfs/super.c                        |  2 +-
 fs/ntfs3/super.c                      |  3 ++-
 fs/ocfs2/super.c                      |  2 +-
 fs/orangefs/super.c                   |  2 +-
 fs/overlayfs/super.c                  |  2 +-
 fs/smb/client/cifsfs.c                |  4 ++--
 fs/tracefs/inode.c                    |  2 +-
 fs/vboxsf/super.c                     |  2 +-
 include/linux/dcache.h                |  2 ++
 include/linux/fs.h                    |  2 +-
 mm/shmem.c                            |  2 +-
 net/sunrpc/rpc_pipe.c                 |  2 +-
 40 files changed, 69 insertions(+), 53 deletions(-)
Documentation/filesystems/porting.rst +7 -0
index 1639e78e3146..004cd69617a2 100644
@@ -1157,3 +1157,10 @@ in normal case it points into the pathname being looked up.
 NOTE: if you need something like full path from the root of filesystem,
 you are still on your own - this assists with simple cases, but it's not
 magic.
+
+---
+
+**mandatory**
+
+If your filesystem sets the default dentry_operations, use set_default_d_op()
+rather than manually setting sb->s_d_op.
fs/9p/vfs_super.c +2 -2
index 489db161abc9..5c3dc3efb909 100644
@@ -135,9 +135,9 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 		goto release_sb;
 
 	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
-		sb->s_d_op = &v9fs_cached_dentry_operations;
+		set_default_d_op(sb, &v9fs_cached_dentry_operations);
 	else
-		sb->s_d_op = &v9fs_dentry_operations;
+		set_default_d_op(sb, &v9fs_dentry_operations);
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
fs/adfs/super.c +1 -1
index 017c48a80203..fdccdbbfc213 100644
@@ -397,7 +397,7 @@ static int adfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (asb->s_ftsuffix)
 		asb->s_namelen += 4;
 
-	sb->s_d_op = &adfs_dentry_operations;
+	set_default_d_op(sb, &adfs_dentry_operations);
 	root = adfs_iget(sb, &root_obj);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
fs/affs/super.c +2 -2
index 2fa40337776d..44f8aa883100 100644
@@ -500,9 +500,9 @@ static int affs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return PTR_ERR(root_inode);
 
 	if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_INTL))
-		sb->s_d_op = &affs_intl_dentry_operations;
+		set_default_d_op(sb, &affs_intl_dentry_operations);
 	else
-		sb->s_d_op = &affs_dentry_operations;
+		set_default_d_op(sb, &affs_dentry_operations);
 
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root) {
fs/afs/super.c +2 -2
index a9bee610674e..13d0414a1ddb 100644
@@ -487,12 +487,12 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 		goto error;
 
 	if (as->dyn_root) {
-		sb->s_d_op = &afs_dynroot_dentry_operations;
+		set_default_d_op(sb, &afs_dynroot_dentry_operations);
 		ret = afs_dynroot_populate(sb);
 		if (ret < 0)
 			goto error;
 	} else {
-		sb->s_d_op = &afs_fs_dentry_operations;
+		set_default_d_op(sb, &afs_fs_dentry_operations);
 		rcu_assign_pointer(as->volume->sb, sb);
 	}
 
fs/autofs/inode.c +1 -1
index ee2edccaef70..f5c16ffba013 100644
@@ -311,7 +311,7 @@ static int autofs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_blocksize_bits = 10;
 	s->s_magic = AUTOFS_SUPER_MAGIC;
 	s->s_op = &autofs_sops;
-	s->s_d_op = &autofs_dentry_operations;
+	set_default_d_op(s, &autofs_dentry_operations);
 	s->s_time_gran = 1;
 
 	/*
fs/btrfs/super.c +1 -1
index dc4fee519ca6..5f39857ea3ae 100644
@@ -954,7 +954,7 @@ static int btrfs_fill_super(struct super_block *sb,
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_magic = BTRFS_SUPER_MAGIC;
 	sb->s_op = &btrfs_super_ops;
-	sb->s_d_op = &btrfs_dentry_operations;
+	set_default_d_op(sb, &btrfs_dentry_operations);
 	sb->s_export_op = &btrfs_export_ops;
 #ifdef CONFIG_FS_VERITY
 	sb->s_vop = &btrfs_verityops;
fs/ceph/super.c +1 -1
index 4344e1f11806..adec6e2f01c4 100644
@@ -1220,7 +1220,7 @@ static int ceph_set_super(struct super_block *s, struct fs_context *fc)
 	fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
 
 	s->s_op = &ceph_super_ops;
-	s->s_d_op = &ceph_dentry_ops;
+	set_default_d_op(s, &ceph_dentry_ops);
 	s->s_export_op = &ceph_export_ops;
 
 	s->s_time_gran = 1;
fs/coda/inode.c +1 -1
index 6896fce122e1..08450d006016 100644
@@ -230,7 +230,7 @@ static int coda_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 12;
 	sb->s_magic = CODA_SUPER_MAGIC;
 	sb->s_op = &coda_super_operations;
-	sb->s_d_op = &coda_dentry_operations;
+	set_default_d_op(sb, &coda_dentry_operations);
 	sb->s_time_gran = 1;
 	sb->s_time_min = S64_MIN;
 	sb->s_time_max = S64_MAX;
fs/configfs/mount.c +1 -1
index c2d820063ec4..20412eaca972 100644
@@ -92,7 +92,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	configfs_root_group.cg_item.ci_dentry = root;
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
-	sb->s_d_op = &configfs_dentry_ops; /* the rest get that */
+	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
 	return 0;
 }
 
fs/dcache.c +8 -2
index c85efbda133a..cd5e5139ca4c 100644
@@ -1712,7 +1712,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->s_d_op);
+	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1795,7 +1795,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	struct dentry *dentry = __d_alloc(sb, name);
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
-		if (!sb->s_d_op)
+		if (!dentry->d_op)
 			d_set_d_op(dentry, &anon_ops);
 	}
 	return dentry;
@@ -1841,6 +1841,12 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 }
 EXPORT_SYMBOL(d_set_d_op);
 
+void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
+{
+	s->__s_d_op = ops;
+}
+EXPORT_SYMBOL(set_default_d_op);
+
 static unsigned d_flags_for_inode(struct inode *inode)
 {
 	unsigned add_flags = DCACHE_REGULAR_TYPE;
fs/debugfs/inode.c +1 -1
index 75715d8877ee..f54a8fd960e4 100644
@@ -273,7 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &debugfs_super_operations;
-	sb->s_d_op = &debugfs_dops;
+	set_default_d_op(sb, &debugfs_dops);
 
 	debugfs_apply_options(sb);
 
fs/devpts/inode.c +1 -1
index 1096ff8562fa..f092973236ef 100644
@@ -433,7 +433,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	s->s_d_op = &simple_dentry_operations;
+	set_default_d_op(s, &simple_dentry_operations);
 	s->s_time_gran = 1;
 
 	error = -ENOMEM;
fs/ecryptfs/main.c +1 -1
index 8dd1d7189c3b..45f9ca4465da 100644
@@ -471,7 +471,7 @@ static int ecryptfs_get_tree(struct fs_context *fc)
 	sbi = NULL;
 	s->s_op = &ecryptfs_sops;
 	s->s_xattr = ecryptfs_xattr_handlers;
-	s->s_d_op = &ecryptfs_dops;
+	set_default_d_op(s, &ecryptfs_dops);
 
 	err = "Reading sb failed";
 	rc = kern_path(fc->source, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
fs/efivarfs/super.c +1 -1
index 09fcf731e65d..3f3188e0cfa7 100644
@@ -345,7 +345,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits    = PAGE_SHIFT;
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
-	sb->s_d_op		= &efivarfs_d_ops;
+	set_default_d_op(sb, &efivarfs_d_ops);
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
fs/exfat/super.c +2 -2
index bd57844414aa..c821582fa1ef 100644
@@ -697,9 +697,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)
 	}
 
 	if (sbi->options.utf8)
-		sb->s_d_op = &exfat_utf8_dentry_ops;
+		set_default_d_op(sb, &exfat_utf8_dentry_ops);
 	else
-		sb->s_d_op = &exfat_dentry_ops;
+		set_default_d_op(sb, &exfat_dentry_ops);
 
 	root_inode = new_inode(sb);
 	if (!root_inode) {
fs/fat/namei_msdos.c +1 -1
index f06f6ba643cc..71302291d33c 100644
@@ -646,7 +646,7 @@ static const struct inode_operations msdos_dir_inode_operations = {
 static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
-	sb->s_d_op = &msdos_dentry_operations;
+	set_default_d_op(sb, &msdos_dentry_operations);
 	sb->s_flags |= SB_NOATIME;
 }
 
fs/fat/namei_vfat.c +2 -2
index 926c26e90ef8..2476afd1304d 100644
@@ -1187,9 +1187,9 @@ static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
 	if (MSDOS_SB(sb)->options.name_check != 's')
-		sb->s_d_op = &vfat_ci_dentry_ops;
+		set_default_d_op(sb, &vfat_ci_dentry_ops);
 	else
-		sb->s_d_op = &vfat_dentry_ops;
+		set_default_d_op(sb, &vfat_dentry_ops);
 }
 
 static int vfat_fill_super(struct super_block *sb, struct fs_context *fc)
fs/fuse/inode.c +2 -2
index 57a1ee016b73..9994f3b33a9f 100644
@@ -1665,7 +1665,7 @@ static int fuse_fill_super_submount(struct super_block *sb,
 	fi = get_fuse_inode(root);
 	fi->nlookup--;
 
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root)
 		return -ENOMEM;
@@ -1800,7 +1800,7 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
fs/gfs2/ops_fstype.c +1 -1
index e83d293c3614..949bbdb5b564 100644
@@ -1156,7 +1156,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_flags |= SB_NOSEC;
 	sb->s_magic = GFS2_MAGIC;
 	sb->s_op = &gfs2_super_ops;
-	sb->s_d_op = &gfs2_dops;
+	set_default_d_op(sb, &gfs2_dops);
 	sb->s_export_op = &gfs2_export_ops;
 	sb->s_qcop = &gfs2_quotactl_ops;
 	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
fs/hfs/super.c +1 -1
index fe09c2093a93..388a318297ec 100644
@@ -365,7 +365,7 @@ static int hfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (!root_inode)
 		goto bail_no_root;
 
-	sb->s_d_op = &hfs_dentry_operations;
+	set_default_d_op(sb, &hfs_dentry_operations);
 	res = -ENOMEM;
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root)
fs/hfsplus/super.c +1 -1
index 948b8aaee33e..0caf7aa1c249 100644
@@ -508,7 +508,7 @@ static int hfsplus_fill_super(struct super_block *sb, struct fs_context *fc)
 		goto out_put_alloc_file;
 	}
 
-	sb->s_d_op = &hfsplus_dentry_operations;
+	set_default_d_op(sb, &hfsplus_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
 		err = -ENOMEM;
fs/hostfs/hostfs_kern.c +1 -1
index e0741e468956..a0e0563a29d7 100644
@@ -920,7 +920,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
fs/hpfs/super.c +1 -1
index 27567920abe4..42b779b4d87f 100644
@@ -554,7 +554,7 @@ static int hpfs_fill_super(struct super_block *s, struct fs_context *fc)
 	/* Fill superblock stuff */
 	s->s_magic = HPFS_SUPER_MAGIC;
 	s->s_op = &hpfs_sops;
-	s->s_d_op = &hpfs_dentry_operations;
+	set_default_d_op(s, &hpfs_dentry_operations);
 	s->s_time_min =  local_to_gmt(s, 0);
 	s->s_time_max =  local_to_gmt(s, U32_MAX);
 
fs/isofs/inode.c +1 -1
index 47038e660812..05ddc2544ade 100644
@@ -939,7 +939,7 @@ static int isofs_fill_super(struct super_block *s, struct fs_context *fc)
 	sbi->s_check = opt->check;
 
 	if (table)
-		s->s_d_op = &isofs_dentry_ops[table - 1];
+		set_default_d_op(s, &isofs_dentry_ops[table - 1]);
 
 	/* get the root dentry */
 	s->s_root = d_make_root(inode);
fs/jfs/super.c +1 -1
index 223d9ac59839..10c3cb714423 100644
@@ -542,7 +542,7 @@ static int jfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic = JFS_SUPER_MAGIC;
 
 	if (sbi->mntflag & JFS_OS2)
-		sb->s_d_op = &jfs_ci_dentry_operations;
+		set_default_d_op(sb, &jfs_ci_dentry_operations);
 
 	inode = jfs_iget(sb, ROOT_I);
 	if (IS_ERR(inode)) {
fs/kernfs/mount.c +1 -1
index 1358c21837f1..91e788d15073 100644
@@ -281,7 +281,7 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *k
 		return -ENOMEM;
 	}
 	sb->s_root = root;
-	sb->s_d_op = &kernfs_dops;
+	set_default_d_op(sb, &kernfs_dops);
 	return 0;
 }
 
fs/libfs.c +8 -8
index 8444f5cc4064..929bef0fecbd 100644
@@ -75,7 +75,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_sb->s_d_op)
+	if (!dentry->d_op)
 		d_set_d_op(dentry, &simple_dentry_operations);
 
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
@@ -683,7 +683,7 @@ static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_root = d_make_root(root);
 	if (!s->s_root)
 		return -ENOMEM;
-	s->s_d_op = ctx->dops;
+	set_default_d_op(s, ctx->dops);
 	return 0;
 }
 
@@ -1943,22 +1943,22 @@ static const struct dentry_operations generic_encrypted_dentry_ops = {
  * @sb: superblock to be configured
  *
  * Filesystems supporting casefolding and/or fscrypt can call this
- * helper at mount-time to configure sb->s_d_op to best set of dentry
- * operations required for the enabled features. The helper must be
- * called after these have been configured, but before the root dentry
- * is created.
+ * helper at mount-time to configure default dentry_operations to the
+ * best set of dentry operations required for the enabled features.
+ * The helper must be called after these have been configured, but
+ * before the root dentry is created.
  */
 void generic_set_sb_d_ops(struct super_block *sb)
 {
 #if IS_ENABLED(CONFIG_UNICODE)
 	if (sb->s_encoding) {
-		sb->s_d_op = &generic_ci_dentry_ops;
+		set_default_d_op(sb, &generic_ci_dentry_ops);
 		return;
 	}
 #endif
 #ifdef CONFIG_FS_ENCRYPTION
 	if (sb->s_cop) {
-		sb->s_d_op = &generic_encrypted_dentry_ops;
+		set_default_d_op(sb, &generic_encrypted_dentry_ops);
 		return;
 	}
 #endif
fs/nfs/super.c +1 -1
index aeb715b4a690..38b0ecf02ad6 100644
@@ -1169,7 +1169,7 @@ static int nfs_set_super(struct super_block *s, struct fs_context *fc)
 	struct nfs_server *server = fc->s_fs_info;
 	int ret;
 
-	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
+	set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
 	ret = set_anon_super(s, server);
 	if (ret == 0)
 		server->s_dev = s->s_dev;
fs/ntfs3/super.c +2 -1
index 6a0f6b0a3ab2..90f5361ae13f 100644
@@ -1182,7 +1182,8 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_export_op = &ntfs_export_ops;
 	sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
 	sb->s_xattr = ntfs_xattr_handlers;
-	sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
+	if (options->nocase)
+		set_default_d_op(sb, &ntfs_dentry_ops);
 
 	options->nls = ntfs_load_nls(options->nls_name);
 	if (IS_ERR(options->nls)) {
fs/ocfs2/super.c +1 -1
index 8bb5022f3082..411f72be4a9b 100644
@@ -1959,7 +1959,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
 
 	sb->s_fs_info = osb;
 	sb->s_op = &ocfs2_sops;
-	sb->s_d_op = &ocfs2_dentry_ops;
+	set_default_d_op(sb, &ocfs2_dentry_ops);
 	sb->s_export_op = &ocfs2_export_ops;
 	sb->s_qcop = &dquot_quotactl_sysfile_ops;
 	sb->dq_op = &ocfs2_quota_operations;
fs/orangefs/super.c +1 -1
index eba3e357192e..d4c8d8b32f14 100644
@@ -434,7 +434,7 @@ static int orangefs_fill_sb(struct super_block *sb,
 	sb->s_xattr = orangefs_xattr_handlers;
 	sb->s_magic = ORANGEFS_SUPER_MAGIC;
 	sb->s_op = &orangefs_s_ops;
-	sb->s_d_op = &orangefs_dentry_operations;
+	set_default_d_op(sb, &orangefs_dentry_operations);
 
 	sb->s_blocksize = PAGE_SIZE;
 	sb->s_blocksize_bits = PAGE_SHIFT;
fs/overlayfs/super.c +1 -1
index 86ae6f6da36b..5f7a5a8c0778 100644
@@ -1315,7 +1315,7 @@ int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (WARN_ON(fc->user_ns != current_user_ns()))
 		goto out_err;
 
-	sb->s_d_op = &ovl_dentry_operations;
+	set_default_d_op(sb, &ovl_dentry_operations);
 
 	err = -ENOMEM;
 	ofs->creator_cred = cred = prepare_creds();
fs/smb/client/cifsfs.c +2 -2
index 6a3bd652d251..5ba1046d1e5a 100644
@@ -261,9 +261,9 @@ cifs_read_super(struct super_block *sb)
 	}
 
 	if (tcon->nocase)
-		sb->s_d_op = &cifs_ci_dentry_ops;
+		set_default_d_op(sb, &cifs_ci_dentry_ops);
 	else
-		sb->s_d_op = &cifs_dentry_ops;
+		set_default_d_op(sb, &cifs_dentry_ops);
 
 	sb->s_root = d_make_root(inode);
 	if (!sb->s_root) {
fs/tracefs/inode.c +1 -1
index 53214499e384..30a951133831 100644
@@ -480,7 +480,7 @@ static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &tracefs_super_operations;
-	sb->s_d_op = &tracefs_dentry_operations;
+	set_default_d_op(sb, &tracefs_dentry_operations);
 
 	return 0;
 }
fs/vboxsf/super.c +1 -1
index 1d94bb784108..46eea52beb23 100644
@@ -190,7 +190,7 @@ static int vboxsf_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize = 1024;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_op = &vboxsf_super_ops;
-	sb->s_d_op = &vboxsf_dentry_ops;
+	set_default_d_op(sb, &vboxsf_dentry_ops);
 
 	iroot = iget_locked(sb, 0);
 	if (!iroot) {
include/linux/dcache.h +2 -0
index f47f3a47d97b..e8cf1d0fdd08 100644
@@ -619,4 +619,6 @@ static inline struct dentry *d_next_sibling(const struct dentry *dentry)
 	return hlist_entry_safe(dentry->d_sib.next, struct dentry, d_sib);
 }
 
+void set_default_d_op(struct super_block *, const struct dentry_operations *);
+
 #endif	/* __LINUX_DCACHE_H */
include/linux/fs.h +1 -1
index 2c3b2f8a621f..23fd8b0d4e81 100644
@@ -1405,7 +1405,7 @@ struct super_block {
 	 */
 	const char *s_subtype;
 
-	const struct dentry_operations *s_d_op; /* default d_op for dentries */
+	const struct dentry_operations *__s_d_op; /* default d_op for dentries */
 
 	struct shrinker *s_shrink;	/* per-sb shrinker handle */
 
mm/shmem.c +1 -1
index 4ea6109a8043..0ecb49113bb2 100644
@@ -5019,7 +5019,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	if (ctx->encoding) {
 		sb->s_encoding = ctx->encoding;
-		sb->s_d_op = &shmem_ci_dentry_ops;
+		set_default_d_op(sb, &shmem_ci_dentry_ops);
 		if (ctx->strict_encoding)
 			sb->s_encoding_flags = SB_ENC_STRICT_MODE_FL;
 	}
net/sunrpc/rpc_pipe.c +1 -1
index eadc00410ebc..e093e4cf20fa 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
author maintainer
#14 lore raw

PATCH 6/21 split d_flags calculation out of d_set_d_op()

In reply to Al Viro
---
 fs/dcache.c | 53 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 23 deletions(-)
fs/dcache.c +30 -23
index cd5e5139ca4c..1201149e1e2c 100644
@@ -1811,33 +1811,40 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 }
 EXPORT_SYMBOL(d_alloc_name);
 
+#define DCACHE_OP_FLAGS \
+	(DCACHE_OP_HASH | DCACHE_OP_COMPARE | DCACHE_OP_REVALIDATE | \
+	 DCACHE_OP_WEAK_REVALIDATE | DCACHE_OP_DELETE | DCACHE_OP_REAL)
+
+static unsigned int d_op_flags(const struct dentry_operations *op)
+{
+	unsigned int flags = 0;
+	if (op) {
+		if (op->d_hash)
+			flags |= DCACHE_OP_HASH;
+		if (op->d_compare)
+			flags |= DCACHE_OP_COMPARE;
+		if (op->d_revalidate)
+			flags |= DCACHE_OP_REVALIDATE;
+		if (op->d_weak_revalidate)
+			flags |= DCACHE_OP_WEAK_REVALIDATE;
+		if (op->d_delete)
+			flags |= DCACHE_OP_DELETE;
+		if (op->d_prune)
+			flags |= DCACHE_OP_PRUNE;
+		if (op->d_real)
+			flags |= DCACHE_OP_REAL;
+	}
+	return flags;
+}
+
 void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
+	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
-	WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH	|
-				DCACHE_OP_COMPARE	|
-				DCACHE_OP_REVALIDATE	|
-				DCACHE_OP_WEAK_REVALIDATE	|
-				DCACHE_OP_DELETE	|
-				DCACHE_OP_REAL));
+	WARN_ON_ONCE(dentry->d_flags & DCACHE_OP_FLAGS);
 	dentry->d_op = op;
-	if (!op)
-		return;
-	if (op->d_hash)
-		dentry->d_flags |= DCACHE_OP_HASH;
-	if (op->d_compare)
-		dentry->d_flags |= DCACHE_OP_COMPARE;
-	if (op->d_revalidate)
-		dentry->d_flags |= DCACHE_OP_REVALIDATE;
-	if (op->d_weak_revalidate)
-		dentry->d_flags |= DCACHE_OP_WEAK_REVALIDATE;
-	if (op->d_delete)
-		dentry->d_flags |= DCACHE_OP_DELETE;
-	if (op->d_prune)
-		dentry->d_flags |= DCACHE_OP_PRUNE;
-	if (op->d_real)
-		dentry->d_flags |= DCACHE_OP_REAL;
-
+	if (flags)
+		dentry->d_flags |= flags;
 }
 EXPORT_SYMBOL(d_set_d_op);
 
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 6/21
#15 lore raw

Re: [PATCH 06/21] split d_flags calculation out of d_set_d_op()

Quoted 2 lines · Al Viro

---

Quoted 74 lines
 fs/dcache.c | 53 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 23 deletions(-)
fs/dcache.c +30 -23
index cd5e5139ca4c..1201149e1e2c 100644
@@ -1811,33 +1811,40 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 }
 EXPORT_SYMBOL(d_alloc_name);
 
+#define DCACHE_OP_FLAGS \
+	(DCACHE_OP_HASH | DCACHE_OP_COMPARE | DCACHE_OP_REVALIDATE | \
+	 DCACHE_OP_WEAK_REVALIDATE | DCACHE_OP_DELETE | DCACHE_OP_REAL)
+
+static unsigned int d_op_flags(const struct dentry_operations *op)
+{
+	unsigned int flags = 0;
+	if (op) {
+		if (op->d_hash)
+			flags |= DCACHE_OP_HASH;
+		if (op->d_compare)
+			flags |= DCACHE_OP_COMPARE;
+		if (op->d_revalidate)
+			flags |= DCACHE_OP_REVALIDATE;
+		if (op->d_weak_revalidate)
+			flags |= DCACHE_OP_WEAK_REVALIDATE;
+		if (op->d_delete)
+			flags |= DCACHE_OP_DELETE;
+		if (op->d_prune)
+			flags |= DCACHE_OP_PRUNE;
+		if (op->d_real)
+			flags |= DCACHE_OP_REAL;
+	}
+	return flags;
+}
+
 void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
+	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
-	WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH	|
-				DCACHE_OP_COMPARE	|
-				DCACHE_OP_REVALIDATE	|
-				DCACHE_OP_WEAK_REVALIDATE	|
-				DCACHE_OP_DELETE	|
-				DCACHE_OP_REAL));
+	WARN_ON_ONCE(dentry->d_flags & DCACHE_OP_FLAGS);
 	dentry->d_op = op;
-	if (!op)
-		return;
-	if (op->d_hash)
-		dentry->d_flags |= DCACHE_OP_HASH;
-	if (op->d_compare)
-		dentry->d_flags |= DCACHE_OP_COMPARE;
-	if (op->d_revalidate)
-		dentry->d_flags |= DCACHE_OP_REVALIDATE;
-	if (op->d_weak_revalidate)
-		dentry->d_flags |= DCACHE_OP_WEAK_REVALIDATE;
-	if (op->d_delete)
-		dentry->d_flags |= DCACHE_OP_DELETE;
-	if (op->d_prune)
-		dentry->d_flags |= DCACHE_OP_PRUNE;
-	if (op->d_real)
-		dentry->d_flags |= DCACHE_OP_REAL;
-
+	if (flags)
+		dentry->d_flags |= flags;
 }
 EXPORT_SYMBOL(d_set_d_op);
 
Signature · 1 line
2.39.5
author maintainer
#16 lore raw

PATCH 7/21 set_default_d_op(): calculate the matching value for ->d_flags

In reply to Al Viro

... and store it in ->s_d_flags, to be used in __d_alloc()

---
 fs/dcache.c        | 6 ++++--
 include/linux/fs.h | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)
fs/dcache.c +4 -2
index 1201149e1e2c..a4795617c3db 100644
@@ -1705,14 +1705,14 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	dentry->d_inode = NULL;
 	dentry->d_parent = dentry;
 	dentry->d_sb = sb;
-	dentry->d_op = NULL;
+	dentry->d_op = sb->__s_d_op;
+	dentry->d_flags = sb->s_d_flags;
 	dentry->d_fsdata = NULL;
 	INIT_HLIST_BL_NODE(&dentry->d_hash);
 	INIT_LIST_HEAD(&dentry->d_lru);
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1850,7 +1850,9 @@ EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
+	unsigned int flags = d_op_flags(ops);
 	s->__s_d_op = ops;
+	s->s_d_flags = (s->s_d_flags & ~DCACHE_OP_FLAGS) | flags;
 }
 EXPORT_SYMBOL(set_default_d_op);
 
include/linux/fs.h +1 -0
index 23fd8b0d4e81..473a9de5fc8f 100644
@@ -1392,6 +1392,7 @@ struct super_block {
 	char			s_sysfs_name[UUID_STRING_LEN + 1];
 
 	unsigned int		s_max_links;
+	unsigned int		s_d_flags;
 
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 7/21
#17 lore raw

Re: [PATCH 07/21] set_default_d_op(): calculate the matching value for ->d_flags

Quoted 4 lines · Al Viro

... and store it in ->s_d_flags, to be used in __d_alloc()

---

Quoted 50 lines
 fs/dcache.c        | 6 ++++--
 include/linux/fs.h | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)
fs/dcache.c +4 -2
index 1201149e1e2c..a4795617c3db 100644
@@ -1705,14 +1705,14 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	dentry->d_inode = NULL;
 	dentry->d_parent = dentry;
 	dentry->d_sb = sb;
-	dentry->d_op = NULL;
+	dentry->d_op = sb->__s_d_op;
+	dentry->d_flags = sb->s_d_flags;
 	dentry->d_fsdata = NULL;
 	INIT_HLIST_BL_NODE(&dentry->d_hash);
 	INIT_LIST_HEAD(&dentry->d_lru);
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1850,7 +1850,9 @@ EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
+	unsigned int flags = d_op_flags(ops);
 	s->__s_d_op = ops;
+	s->s_d_flags = (s->s_d_flags & ~DCACHE_OP_FLAGS) | flags;
 }
 EXPORT_SYMBOL(set_default_d_op);
 
include/linux/fs.h +1 -0
index 23fd8b0d4e81..473a9de5fc8f 100644
@@ -1392,6 +1392,7 @@ struct super_block {
 	char			s_sysfs_name[UUID_STRING_LEN + 1];
 
 	unsigned int		s_max_links;
+	unsigned int		s_d_flags;
 
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
Signature · 1 line
2.39.5
author maintainer
#18 lore raw

PATCH 8/21 simple_lookup(): just set DCACHE_DONTCACHE

In reply to Al Viro

No need to mess with ->d_op at all. Note that ->d_delete that always returns 1 is equivalent to having DCACHE_DONTCACHE in ->d_flags. Later the same thing will be placed into ->s_d_flags of the filesystems where we want that behaviour for all dentries; then the check in simple_lookup() will at least get unlikely() slapped on it.

---
 fs/libfs.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
fs/libfs.c +5 -3
index 929bef0fecbd..b15a2148714e 100644
@@ -75,9 +75,11 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_op)
-		d_set_d_op(dentry, &simple_dentry_operations);
-
+	if (!(dentry->d_flags & DCACHE_DONTCACHE)) {
+		spin_lock(&dentry->d_lock);
+		dentry->d_flags |= DCACHE_DONTCACHE;
+		spin_unlock(&dentry->d_lock);
+	}
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
 		return NULL;
 
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 8/21
#19 lore raw

Re: [PATCH 08/21] simple_lookup(): just set DCACHE_DONTCACHE

Quoted 8 lines · Al Viro

No need to mess with ->d_op at all. Note that ->d_delete that always returns 1 is equivalent to having DCACHE_DONTCACHE in ->d_flags. Later the same thing will be placed into ->s_d_flags of the filesystems where we want that behaviour for all dentries; then the check in simple_lookup() will at least get unlikely() slapped on it.

---

Quoted 25 lines
 fs/libfs.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
fs/libfs.c +5 -3
index 929bef0fecbd..b15a2148714e 100644
@@ -75,9 +75,11 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_op)
-		d_set_d_op(dentry, &simple_dentry_operations);
-
+	if (!(dentry->d_flags & DCACHE_DONTCACHE)) {
+		spin_lock(&dentry->d_lock);
+		dentry->d_flags |= DCACHE_DONTCACHE;
+		spin_unlock(&dentry->d_lock);
+	}
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
 		return NULL;
 
Signature · 1 line
2.39.5
author maintainer
#20 lore raw

PATCH 9/21 make d_set_d_op() static

In reply to Al Viro

Convert the last user (d_alloc_pseudo()) and be done with that. Any out-of-tree filesystem using it should switch to d_splice_alias_ops() or, better yet, check whether it really needs to have ->d_op vary among its dentries.

---
 Documentation/filesystems/porting.rst | 11 +++++++++++
 fs/dcache.c                           |  5 ++---
 include/linux/dcache.h                |  1 -
 3 files changed, 13 insertions(+), 4 deletions(-)
Documentation/filesystems/porting.rst +11 -0
index 004cd69617a2..61b5771dde53 100644
@@ -1164,3 +1164,14 @@ magic.
 
 If your filesystem sets the default dentry_operations, use set_default_d_op()
 rather than manually setting sb->s_d_op.
+
+---
+
+**mandatory**
+
+d_set_d_op() is no longer exported (or public, for that matter); _if_
+your filesystem really needed that, make use of d_splice_alias_ops()
+to have them set.  Better yet, think hard whether you need different
+->d_op for different dentries - if not, just use set_default_d_op()
+at mount time and be done with that.  Currently procfs is the only
+thing that really needs ->d_op varying between dentries.
fs/dcache.c +2 -3
index a4795617c3db..29db27228d97 100644
@@ -1796,7 +1796,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
 		if (!dentry->d_op)
-			d_set_d_op(dentry, &anon_ops);
+			dentry->d_op = &anon_ops;
 	}
 	return dentry;
 }
@@ -1837,7 +1837,7 @@ static unsigned int d_op_flags(const struct dentry_operations *op)
 	return flags;
 }
 
-void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
+static void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
 	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
@@ -1846,7 +1846,6 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 	if (flags)
 		dentry->d_flags |= flags;
 }
-EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
include/linux/dcache.h +0 -1
index e8cf1d0fdd08..5a03e85f92a4 100644
@@ -242,7 +242,6 @@ extern void d_instantiate_new(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
 extern void d_delete(struct dentry *);
-extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
Signature · 1 line
2.39.5
#21 lore raw

Re: [PATCH 09/21] make d_set_d_op() static

Quoted 36 lines · Al Viro

Convert the last user (d_alloc_pseudo()) and be done with that. Any out-of-tree filesystem using it should switch to d_splice_alias_ops() or, better yet, check whether it really needs to have ->d_op vary among its dentries.

---
 Documentation/filesystems/porting.rst | 11 +++++++++++
 fs/dcache.c                           |  5 ++---
 include/linux/dcache.h                |  1 -
 3 files changed, 13 insertions(+), 4 deletions(-)
Documentation/filesystems/porting.rst +11 -0
index 004cd69617a2..61b5771dde53 100644
@@ -1164,3 +1164,14 @@ magic.
 
 If your filesystem sets the default dentry_operations, use set_default_d_op()
 rather than manually setting sb->s_d_op.
+
+---
+
+**mandatory**
+
+d_set_d_op() is no longer exported (or public, for that matter); _if_
+your filesystem really needed that, make use of d_splice_alias_ops()
+to have them set.  Better yet, think hard whether you need different
+->d_op for different dentries - if not, just use set_default_d_op()
+at mount time and be done with that.  Currently procfs is the only
+thing that really needs ->d_op varying between dentries.
fs/dcache.c +0 -0
index a4795617c3db..29db27228d97 100644

fs/dcache.c struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name) · line 1799

Quoted 5 lines
fs/dcache.c +1 -1
@@ -1796,7 +1796,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
 		if (!dentry->d_op)
-			d_set_d_op(dentry, &anon_ops);
+			dentry->d_op = &anon_ops;

This is safe because d_op_flags(anon_ops) is zero so there is no need to update dentry->d_flags. I wonder if that deserves a comment.

Thanks,
NeilBrown

Quoted 36 lines
fs/dcache.c +1 -2
 	}
 	return dentry;
 }
@@ -1837,7 +1837,7 @@ static unsigned int d_op_flags(const struct dentry_operations *op)
 	return flags;
 }
 
-void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
+static void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
 	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
@@ -1846,7 +1846,6 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 	if (flags)
 		dentry->d_flags |= flags;
 }
-EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
include/linux/dcache.h +0 -1
index e8cf1d0fdd08..5a03e85f92a4 100644
@@ -242,7 +242,6 @@ extern void d_instantiate_new(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
 extern void d_delete(struct dentry *);
-extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 9/21
#22 lore raw

Re: [PATCH 09/21] make d_set_d_op() static

In reply to Al Viro
Quoted 7 lines · Al Viro

Convert the last user (d_alloc_pseudo()) and be done with that. Any out-of-tree filesystem using it should switch to d_splice_alias_ops() or, better yet, check whether it really needs to have ->d_op vary among its dentries.

---

Quoted 69 lines
 Documentation/filesystems/porting.rst | 11 +++++++++++
 fs/dcache.c                           |  5 ++---
 include/linux/dcache.h                |  1 -
 3 files changed, 13 insertions(+), 4 deletions(-)
Documentation/filesystems/porting.rst +11 -0
index 004cd69617a2..61b5771dde53 100644
@@ -1164,3 +1164,14 @@ magic.
 
 If your filesystem sets the default dentry_operations, use set_default_d_op()
 rather than manually setting sb->s_d_op.
+
+---
+
+**mandatory**
+
+d_set_d_op() is no longer exported (or public, for that matter); _if_
+your filesystem really needed that, make use of d_splice_alias_ops()
+to have them set.  Better yet, think hard whether you need different
+->d_op for different dentries - if not, just use set_default_d_op()
+at mount time and be done with that.  Currently procfs is the only
+thing that really needs ->d_op varying between dentries.
fs/dcache.c +2 -3
index a4795617c3db..29db27228d97 100644
@@ -1796,7 +1796,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
 		if (!dentry->d_op)
-			d_set_d_op(dentry, &anon_ops);
+			dentry->d_op = &anon_ops;
 	}
 	return dentry;
 }
@@ -1837,7 +1837,7 @@ static unsigned int d_op_flags(const struct dentry_operations *op)
 	return flags;
 }
 
-void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
+static void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
 	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
@@ -1846,7 +1846,6 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 	if (flags)
 		dentry->d_flags |= flags;
 }
-EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
include/linux/dcache.h +0 -1
index e8cf1d0fdd08..5a03e85f92a4 100644
@@ -242,7 +242,6 @@ extern void d_instantiate_new(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
 extern void d_delete(struct dentry *);
-extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
Signature · 1 line
2.39.5
author maintainer
#23 lore raw

PATCH 10/21 d_alloc_parallel(): set DCACHE_PAR_LOOKUP earlier

In reply to Al Viro

Do that before new dentry is visible anywhere. It does create a new possible state for dentries present in ->d_children/->d_sib - DCACHE_PAR_LOOKUP present, negative, unhashed, not in in-lookup hash chains, refcount positive. Those are going to be skipped by all tree-walkers (both d_walk() callbacks in fs/dcache.c and explicit loops over children/sibling lists elsewhere) and dput() is fine with those.

NOTE: dropping the final reference to a "normal" in-lookup dentry (in in-lookup hash) is a bug - somebody must've forgotten to call d_lookup_done() on it and bad things will happen. With those it's OK; if/when we get around to making __dentry_kill() complain about such breakage, remember that predicate to check should *not* be just d_in_lookup(victim) but rather a combination of that with hlist_bl_unhashed(&victim->d_u.d_in_lookup_hash). Might be worth to consider later...

---
 fs/dcache.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)
fs/dcache.c +7 -3
index 29db27228d97..9ad7cbb5a6b0 100644
@@ -2518,13 +2518,19 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 	unsigned int hash = name->hash;
 	struct hlist_bl_head *b = in_lookup_hash(parent, hash);
 	struct hlist_bl_node *node;
-	struct dentry *new = d_alloc(parent, name);
+	struct dentry *new = __d_alloc(parent->d_sb, name);
 	struct dentry *dentry;
 	unsigned seq, r_seq, d_seq;
 
 	if (unlikely(!new))
 		return ERR_PTR(-ENOMEM);
 
+	new->d_flags |= DCACHE_PAR_LOOKUP;
+	spin_lock(&parent->d_lock);
+	new->d_parent = dget_dlock(parent);
+	hlist_add_head(&new->d_sib, &parent->d_children);
+	spin_unlock(&parent->d_lock);
+
 retry:
 	rcu_read_lock();
 	seq = smp_load_acquire(&parent->d_inode->i_dir_seq);
@@ -2608,8 +2614,6 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 		return dentry;
 	}
 	rcu_read_unlock();
-	/* we can't take ->d_lock here; it's OK, though. */
-	new->d_flags |= DCACHE_PAR_LOOKUP;
 	new->d_wait = wq;
 	hlist_bl_add_head(&new->d_u.d_in_lookup_hash, b);
 	hlist_bl_unlock(b);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 10/21
#24 lore raw

Re: [PATCH 10/21] d_alloc_parallel(): set DCACHE_PAR_LOOKUP earlier

Quoted 17 lines · Al Viro

Do that before new dentry is visible anywhere. It does create a new possible state for dentries present in ->d_children/->d_sib - DCACHE_PAR_LOOKUP present, negative, unhashed, not in in-lookup hash chains, refcount positive. Those are going to be skipped by all tree-walkers (both d_walk() callbacks in fs/dcache.c and explicit loops over children/sibling lists elsewhere) and dput() is fine with those.

NOTE: dropping the final reference to a "normal" in-lookup dentry (in in-lookup hash) is a bug - somebody must've forgotten to call d_lookup_done() on it and bad things will happen. With those it's OK; if/when we get around to making __dentry_kill() complain about such breakage, remember that predicate to check should *not* be just d_in_lookup(victim) but rather a combination of that with hlist_bl_unhashed(&victim->d_u.d_in_lookup_hash). Might be worth to consider later...

Quoted 2 lines

---

Quoted 8 lines
 fs/dcache.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)
fs/dcache.c +0 -0
index 29db27228d97..9ad7cbb5a6b0 100644

fs/dcache.c struct dentry *d_alloc_parallel(struct dentry *parent, · line 2526

Quoted 10 lines
fs/dcache.c +1 -1
@@ -2518,13 +2518,19 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 	unsigned int hash = name->hash;
 	struct hlist_bl_head *b = in_lookup_hash(parent, hash);
 	struct hlist_bl_node *node;
-	struct dentry *new = d_alloc(parent, name);
+	struct dentry *new = __d_alloc(parent->d_sb, name);
 	struct dentry *dentry;
 	unsigned seq, r_seq, d_seq;
 
 	if (unlikely(!new))
 		return ERR_PTR(-ENOMEM);

This is minor but it would be clearer if the __d_alloc() call was placed directly above the error handling.

Quoted 22 lines
fs/dcache.c +6 -2
+	new->d_flags |= DCACHE_PAR_LOOKUP;
+	spin_lock(&parent->d_lock);
+	new->d_parent = dget_dlock(parent);
+	hlist_add_head(&new->d_sib, &parent->d_children);
+	spin_unlock(&parent->d_lock);
+
 retry:
 	rcu_read_lock();
 	seq = smp_load_acquire(&parent->d_inode->i_dir_seq);
@@ -2608,8 +2614,6 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 		return dentry;
 	}
 	rcu_read_unlock();
-	/* we can't take ->d_lock here; it's OK, though. */
-	new->d_flags |= DCACHE_PAR_LOOKUP;
 	new->d_wait = wq;
 	hlist_bl_add_head(&new->d_u.d_in_lookup_hash, b);
 	hlist_bl_unlock(b);
Signature · 1 line
2.39.5
author maintainer
#25 lore raw

PATCH 11/21 nsfs, pidfs: drop the pointless ->d_delete()

In reply to Al Viro

No dentries are ever hashed on those, so ->d_delete() wouldn't be even looked at. If it's unhashed, we are not retaining it in dcache once the refcount hits zero, no matter what.

---
 fs/nsfs.c  | 1 -
 fs/pidfs.c | 1 -
 2 files changed, 2 deletions(-)
fs/nsfs.c +0 -1
index 663f8656158d..f7fddf8ecf73 100644
@@ -37,7 +37,6 @@ static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 }
 
 const struct dentry_operations ns_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_dname	= ns_dname,
 	.d_prune	= stashed_dentry_prune,
 };
fs/pidfs.c +0 -1
index 63f9699ebac3..c0478b3c55d9 100644
@@ -521,7 +521,6 @@ static char *pidfs_dname(struct dentry *dentry, char *buffer, int buflen)
 }
 
 const struct dentry_operations pidfs_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_dname	= pidfs_dname,
 	.d_prune	= stashed_dentry_prune,
 };
Signature · 1 line
2.39.5
#26 lore raw

Re: [PATCH 11/21] nsfs, pidfs: drop the pointless ->d_delete()

Quoted 6 lines · Al Viro

No dentries are ever hashed on those, so ->d_delete() wouldn't be even looked at. If it's unhashed, we are not retaining it in dcache once the refcount hits zero, no matter what.

---

Patches to remove this have already been merged into mainline.

Quoted 31 lines
 fs/nsfs.c  | 1 -
 fs/pidfs.c | 1 -
 2 files changed, 2 deletions(-)
fs/nsfs.c +0 -1
index 663f8656158d..f7fddf8ecf73 100644
@@ -37,7 +37,6 @@ static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 }
 
 const struct dentry_operations ns_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_dname	= ns_dname,
 	.d_prune	= stashed_dentry_prune,
 };
fs/pidfs.c +0 -1
index 63f9699ebac3..c0478b3c55d9 100644
@@ -521,7 +521,6 @@ static char *pidfs_dname(struct dentry *dentry, char *buffer, int buflen)
 }
 
 const struct dentry_operations pidfs_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_dname	= pidfs_dname,
 	.d_prune	= stashed_dentry_prune,
 };
Signature · 1 line
2.39.5
author maintainer
#27 lore raw

PATCH 12/21 shmem: no dentry retention past the refcount reaching zero

In reply to Al Viro

Just set DCACHE_DONTCACHE in ->s_d_flags and be done with that. Dentries there live for as long as they are pinned; once the refcount hits zero, that's it. The same, of course, goes for other tree-in-dcache filesystems - more in the next commits...

---
 mm/shmem.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
mm/shmem.c +1 -1
index 0ecb49113bb2..dd84b1c554a8 100644
@@ -4971,7 +4971,6 @@ static void shmem_put_super(struct super_block *sb)
 static const struct dentry_operations shmem_ci_dentry_ops = {
 	.d_hash = generic_ci_d_hash,
 	.d_compare = generic_ci_d_compare,
-	.d_delete = always_delete_dentry,
 };
 #endif
 
@@ -5028,6 +5027,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 #else
 	sb->s_flags |= SB_NOUSER;
 #endif /* CONFIG_TMPFS */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sbinfo->max_blocks = ctx->blocks;
 	sbinfo->max_inodes = ctx->inodes;
 	sbinfo->free_ispace = sbinfo->max_inodes * BOGO_INODE_SIZE;
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 12/21
#28 lore raw

Re: [PATCH 12/21] shmem: no dentry retention past the refcount reaching zero

Quoted 7 lines · Al Viro

Just set DCACHE_DONTCACHE in ->s_d_flags and be done with that. Dentries there live for as long as they are pinned; once the refcount hits zero, that's it. The same, of course, goes for other tree-in-dcache filesystems - more in the next commits...

---

Quoted 26 lines
 mm/shmem.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
mm/shmem.c +1 -1
index 0ecb49113bb2..dd84b1c554a8 100644
@@ -4971,7 +4971,6 @@ static void shmem_put_super(struct super_block *sb)
 static const struct dentry_operations shmem_ci_dentry_ops = {
 	.d_hash = generic_ci_d_hash,
 	.d_compare = generic_ci_d_compare,
-	.d_delete = always_delete_dentry,
 };
 #endif
 
@@ -5028,6 +5027,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 #else
 	sb->s_flags |= SB_NOUSER;
 #endif /* CONFIG_TMPFS */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sbinfo->max_blocks = ctx->blocks;
 	sbinfo->max_inodes = ctx->inodes;
 	sbinfo->free_ispace = sbinfo->max_inodes * BOGO_INODE_SIZE;
Signature · 1 line
2.39.5
author maintainer
#29 lore raw

PATCH 13/21 devpts, sunrpc: don't bother with ->d_delete or ->d_op, for that matter

In reply to Al Viro

Just put DCACHE_DONTCACHE into ->s_d_flags.

---
 fs/devpts/inode.c     | 2 +-
 net/sunrpc/rpc_pipe.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
fs/devpts/inode.c +1 -1
index f092973236ef..39344af02d1f 100644
@@ -433,7 +433,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	set_default_d_op(s, &simple_dentry_operations);
+	s->s_d_flags = DCACHE_DONTCACHE;
 	s->s_time_gran = 1;
 
 	error = -ENOMEM;
net/sunrpc/rpc_pipe.c +1 -1
index e093e4cf20fa..acb28a502580 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 13/21
#30 lore raw

Re: [PATCH 13/21] devpts, sunrpc: don't bother with ->d_delete or ->d_op, for that matter

Quoted 4 lines · Al Viro

Just put DCACHE_DONTCACHE into ->s_d_flags.

---

Quoted 33 lines
 fs/devpts/inode.c     | 2 +-
 net/sunrpc/rpc_pipe.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
fs/devpts/inode.c +1 -1
index f092973236ef..39344af02d1f 100644
@@ -433,7 +433,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	set_default_d_op(s, &simple_dentry_operations);
+	s->s_d_flags = DCACHE_DONTCACHE;
 	s->s_time_gran = 1;
 
 	error = -ENOMEM;
net/sunrpc/rpc_pipe.c +1 -1
index e093e4cf20fa..acb28a502580 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
author maintainer
#31 lore raw

PATCH 14/21 hostfs: don't bother with ->d_op

In reply to Al Viro

All we have there is ->d_delete equal to always_delete_dentry() and we want that for all dentries on that things. Setting DCACHE_DONTCACHE in ->s_d_flags will do just that.

---
 fs/hostfs/hostfs_kern.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/hostfs/hostfs_kern.c +1 -1
index a0e0563a29d7..52479205cefe 100644
@@ -920,7 +920,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 14/21
#32 lore raw

Re: [PATCH 14/21] hostfs: don't bother with ->d_op

Quoted 6 lines · Al Viro

All we have there is ->d_delete equal to always_delete_dentry() and we want that for all dentries on that things. Setting DCACHE_DONTCACHE in ->s_d_flags will do just that.

---

Quoted 19 lines
 fs/hostfs/hostfs_kern.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/hostfs/hostfs_kern.c +1 -1
index a0e0563a29d7..52479205cefe 100644
@@ -920,7 +920,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
Signature · 1 line
2.39.5
author maintainer
#33 lore raw

PATCH 15/21 kill simple_dentry_operations

In reply to Al Viro

No users left and anything that wants it would be better off just setting DCACHE_DONTCACHE in their ->s_d_flags.

---
 fs/libfs.c         | 5 -----
 include/linux/fs.h | 1 -
 2 files changed, 6 deletions(-)
fs/libfs.c +0 -5
index b15a2148714e..7eebaee9d082 100644
@@ -62,11 +62,6 @@ int always_delete_dentry(const struct dentry *dentry)
 }
 EXPORT_SYMBOL(always_delete_dentry);
 
-const struct dentry_operations simple_dentry_operations = {
-	.d_delete = always_delete_dentry,
-};
-EXPORT_SYMBOL(simple_dentry_operations);
-
 /*
  * Lookup the data. This is trivial - if the dentry didn't already
  * exist, we know it is negative.  Set d_op to delete negative dentries.
include/linux/fs.h +0 -1
index 473a9de5fc8f..bdaf2f85e1ad 100644
@@ -3540,7 +3540,6 @@ extern const struct address_space_operations ram_aops;
 extern int always_delete_dentry(const struct dentry *);
 extern struct inode *alloc_anon_inode(struct super_block *);
 extern int simple_nosetlease(struct file *, int, struct file_lease **, void **);
-extern const struct dentry_operations simple_dentry_operations;
 
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 15/21
#34 lore raw

Re: [PATCH 15/21] kill simple_dentry_operations

Quoted 5 lines · Al Viro

No users left and anything that wants it would be better off just setting DCACHE_DONTCACHE in their ->s_d_flags.

---

Quoted 35 lines
 fs/libfs.c         | 5 -----
 include/linux/fs.h | 1 -
 2 files changed, 6 deletions(-)
fs/libfs.c +0 -5
index b15a2148714e..7eebaee9d082 100644
@@ -62,11 +62,6 @@ int always_delete_dentry(const struct dentry *dentry)
 }
 EXPORT_SYMBOL(always_delete_dentry);
 
-const struct dentry_operations simple_dentry_operations = {
-	.d_delete = always_delete_dentry,
-};
-EXPORT_SYMBOL(simple_dentry_operations);
-
 /*
  * Lookup the data. This is trivial - if the dentry didn't already
  * exist, we know it is negative.  Set d_op to delete negative dentries.
include/linux/fs.h +0 -1
index 473a9de5fc8f..bdaf2f85e1ad 100644
@@ -3540,7 +3540,6 @@ extern const struct address_space_operations ram_aops;
 extern int always_delete_dentry(const struct dentry *);
 extern struct inode *alloc_anon_inode(struct super_block *);
 extern int simple_nosetlease(struct file *, int, struct file_lease **, void **);
-extern const struct dentry_operations simple_dentry_operations;
 
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
Signature · 1 line
2.39.5
author maintainer
#35 lore raw

PATCH 16/21 ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

In reply to Al Viro

makes simple_lookup() slightly cheaper there.

---
 fs/hugetlbfs/inode.c | 1 +
 fs/ramfs/inode.c     | 1 +
 ipc/mqueue.c         | 1 +
 3 files changed, 3 insertions(+)
fs/hugetlbfs/inode.c +1 -0
index 0fc179a59830..205dd7562be1 100644
@@ -1431,6 +1431,7 @@ hugetlbfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = huge_page_shift(ctx->hstate);
 	sb->s_magic = HUGETLBFS_MAGIC;
 	sb->s_op = &hugetlbfs_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	/*
fs/ramfs/inode.c +1 -0
index 8006faaaf0ec..c4ee67870c4b 100644
@@ -269,6 +269,7 @@ static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits	= PAGE_SHIFT;
 	sb->s_magic		= RAMFS_MAGIC;
 	sb->s_op		= &ramfs_ops;
+	sb->s_d_flags		= DCACHE_DONTCACHE;
 	sb->s_time_gran		= 1;
 
 	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
ipc/mqueue.c +1 -0
index 35b4f8659904..dbd5c74eecb2 100644
@@ -411,6 +411,7 @@ static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = MQUEUE_MAGIC;
 	sb->s_op = &mqueue_super_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 
 	inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL);
 	if (IS_ERR(inode))
Signature · 1 line
2.39.5
#36 lore raw

Re: [PATCH 16/21] ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

Quoted 1 line · Al Viro

makes simple_lookup() slightly cheaper there.

I think the patch make sense because there is no point keeping negative dentries for these filesystems - and positive dentries get an extra refcount so DCACHE_DONTCACHE doesn't apply.

But I don't see how this makes simple_lookup() cheaper. It means that if someone repeatedly looks up the same non-existent name then simple_lookup() will be called more often (because we didn't cache the result of the previous time) but otherwise I don't see the relevance to simple_lookup(). Am I missing something?

Thanks,
NeilBrown

Quoted 48 lines
---
 fs/hugetlbfs/inode.c | 1 +
 fs/ramfs/inode.c     | 1 +
 ipc/mqueue.c         | 1 +
 3 files changed, 3 insertions(+)
fs/hugetlbfs/inode.c +1 -0
index 0fc179a59830..205dd7562be1 100644
@@ -1431,6 +1431,7 @@ hugetlbfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = huge_page_shift(ctx->hstate);
 	sb->s_magic = HUGETLBFS_MAGIC;
 	sb->s_op = &hugetlbfs_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	/*
fs/ramfs/inode.c +1 -0
index 8006faaaf0ec..c4ee67870c4b 100644
@@ -269,6 +269,7 @@ static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits	= PAGE_SHIFT;
 	sb->s_magic		= RAMFS_MAGIC;
 	sb->s_op		= &ramfs_ops;
+	sb->s_d_flags		= DCACHE_DONTCACHE;
 	sb->s_time_gran		= 1;
 
 	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
ipc/mqueue.c +1 -0
index 35b4f8659904..dbd5c74eecb2 100644
@@ -411,6 +411,7 @@ static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = MQUEUE_MAGIC;
 	sb->s_op = &mqueue_super_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 
 	inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL);
 	if (IS_ERR(inode))
Signature · 1 line
2.39.5
author maintainer
#37 lore raw

Re: [PATCH 16/21] ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

Quoted 7 lines · NeilBrown
Quoted 1 line · Al Viro

makes simple_lookup() slightly cheaper there.

I think the patch make sense because there is no point keeping negative dentries for these filesystems - and positive dentries get an extra refcount so DCACHE_DONTCACHE doesn't apply.

Quoted 5 lines

But I don't see how this makes simple_lookup() cheaper. It means that if someone repeatedly looks up the same non-existent name then simple_lookup() will be called more often (because we didn't cache the result of the previous time) but otherwise I don't see the relevance to simple_lookup(). Am I missing something?

This:

        if (!(dentry->d_flags & DCACHE_DONTCACHE)) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags |= DCACHE_DONTCACHE;
		spin_unlock(&dentry->d_lock);
	}

IOW, no need to mark that sucker as "don't retain past the moment when its refcount drops to zero" - they'll all be marked that way since they'd been created.

Note that we used to switch then to ->d_op that had ->d_delete always returning true. That had been replaced with setting DCACHE_DONTCACHE; that was an equivalent transformation. So retention rules have not changed; the only change here is that this flag doesn't need to be set.

#38 lore raw

Re: [PATCH 16/21] ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

Quoted 14 lines · Al Viro
Quoted 7 lines · NeilBrown
Quoted 1 line · Al Viro

makes simple_lookup() slightly cheaper there.

I think the patch make sense because there is no point keeping negative dentries for these filesystems - and positive dentries get an extra refcount so DCACHE_DONTCACHE doesn't apply.

Quoted 5 lines

But I don't see how this makes simple_lookup() cheaper. It means that if someone repeatedly looks up the same non-existent name then simple_lookup() will be called more often (because we didn't cache the result of the previous time) but otherwise I don't see the relevance to simple_lookup(). Am I missing something?

Quoted 6 lines

This:

        if (!(dentry->d_flags & DCACHE_DONTCACHE)) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags |= DCACHE_DONTCACHE;
		spin_unlock(&dentry->d_lock);
	}

Ah - right. Thanks.

NeilBrown

Quoted 10 lines

IOW, no need to mark that sucker as "don't retain past the moment when its refcount drops to zero" - they'll all be marked that way since they'd been created.

Note that we used to switch then to ->d_op that had ->d_delete always returning true. That had been replaced with setting DCACHE_DONTCACHE; that was an equivalent transformation. So retention rules have not changed; the only change here is that this flag doesn't need to be set.

maintainer Reviewed-by on v1 16/21
#39 lore raw

Re: [PATCH 16/21] ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

In reply to Al Viro
Quoted 4 lines · Al Viro

makes simple_lookup() slightly cheaper there.

---

Quoted 44 lines
 fs/hugetlbfs/inode.c | 1 +
 fs/ramfs/inode.c     | 1 +
 ipc/mqueue.c         | 1 +
 3 files changed, 3 insertions(+)
fs/hugetlbfs/inode.c +1 -0
index 0fc179a59830..205dd7562be1 100644
@@ -1431,6 +1431,7 @@ hugetlbfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = huge_page_shift(ctx->hstate);
 	sb->s_magic = HUGETLBFS_MAGIC;
 	sb->s_op = &hugetlbfs_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	/*
fs/ramfs/inode.c +1 -0
index 8006faaaf0ec..c4ee67870c4b 100644
@@ -269,6 +269,7 @@ static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits	= PAGE_SHIFT;
 	sb->s_magic		= RAMFS_MAGIC;
 	sb->s_op		= &ramfs_ops;
+	sb->s_d_flags		= DCACHE_DONTCACHE;
 	sb->s_time_gran		= 1;
 
 	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
ipc/mqueue.c +1 -0
index 35b4f8659904..dbd5c74eecb2 100644
@@ -411,6 +411,7 @@ static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = MQUEUE_MAGIC;
 	sb->s_op = &mqueue_super_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 
 	inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL);
 	if (IS_ERR(inode))
Signature · 1 line
2.39.5
author maintainer
#40 lore raw

PATCH 17/21 9p: don't bother with always_delete_dentry

In reply to Al Viro

just set DCACHE_DONTCACHE for "don't cache" mounts...

---
 fs/9p/vfs_dentry.c | 1 -
 fs/9p/vfs_super.c  | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)
fs/9p/vfs_dentry.c +0 -1
index 5061f192eafd..04795508a795 100644
@@ -127,7 +127,6 @@ const struct dentry_operations v9fs_cached_dentry_operations = {
 };
 
 const struct dentry_operations v9fs_dentry_operations = {
-	.d_delete = always_delete_dentry,
 	.d_release = v9fs_dentry_release,
 	.d_unalias_trylock = v9fs_dentry_unalias_trylock,
 	.d_unalias_unlock = v9fs_dentry_unalias_unlock,
fs/9p/vfs_super.c +4 -2
index 5c3dc3efb909..795c6388744c 100644
@@ -134,10 +134,12 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 	if (retval)
 		goto release_sb;
 
-	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
+	if (v9ses->cache & (CACHE_META|CACHE_LOOSE)) {
 		set_default_d_op(sb, &v9fs_cached_dentry_operations);
-	else
+	} else {
 		set_default_d_op(sb, &v9fs_dentry_operations);
+		sb->s_d_flags |= DCACHE_DONTCACHE;
+	}
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 17/21
#41 lore raw

Re: [PATCH 17/21] 9p: don't bother with always_delete_dentry

Quoted 4 lines · Al Viro

just set DCACHE_DONTCACHE for "don't cache" mounts...

---

Quoted 38 lines
 fs/9p/vfs_dentry.c | 1 -
 fs/9p/vfs_super.c  | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)
fs/9p/vfs_dentry.c +0 -1
index 5061f192eafd..04795508a795 100644
@@ -127,7 +127,6 @@ const struct dentry_operations v9fs_cached_dentry_operations = {
 };
 
 const struct dentry_operations v9fs_dentry_operations = {
-	.d_delete = always_delete_dentry,
 	.d_release = v9fs_dentry_release,
 	.d_unalias_trylock = v9fs_dentry_unalias_trylock,
 	.d_unalias_unlock = v9fs_dentry_unalias_unlock,
fs/9p/vfs_super.c +4 -2
index 5c3dc3efb909..795c6388744c 100644
@@ -134,10 +134,12 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 	if (retval)
 		goto release_sb;
 
-	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
+	if (v9ses->cache & (CACHE_META|CACHE_LOOSE)) {
 		set_default_d_op(sb, &v9fs_cached_dentry_operations);
-	else
+	} else {
 		set_default_d_op(sb, &v9fs_dentry_operations);
+		sb->s_d_flags |= DCACHE_DONTCACHE;
+	}
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
Signature · 1 line
2.39.5
author maintainer
#42 lore raw

PATCH 18/21 efivarfs: use DCACHE_DONTCACHE instead of always_delete_dentry()

In reply to Al Viro
---
 fs/efivarfs/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/efivarfs/super.c +1 -1
index 3f3188e0cfa7..e5d3147cfcea 100644
@@ -175,7 +175,6 @@ static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 static const struct dentry_operations efivarfs_d_ops = {
 	.d_compare = efivarfs_d_compare,
 	.d_hash = efivarfs_d_hash,
-	.d_delete = always_delete_dentry,
 };
 
 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
@@ -346,6 +345,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
 	set_default_d_op(sb, &efivarfs_d_ops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 18/21
#43 lore raw

Re: [PATCH 18/21] efivarfs: use DCACHE_DONTCACHE instead of always_delete_dentry()

Quoted 2 lines · Al Viro

---

Quoted 26 lines
 fs/efivarfs/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/efivarfs/super.c +1 -1
index 3f3188e0cfa7..e5d3147cfcea 100644
@@ -175,7 +175,6 @@ static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 static const struct dentry_operations efivarfs_d_ops = {
 	.d_compare = efivarfs_d_compare,
 	.d_hash = efivarfs_d_hash,
-	.d_delete = always_delete_dentry,
 };
 
 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
@@ -346,6 +345,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
 	set_default_d_op(sb, &efivarfs_d_ops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
Signature · 1 line
2.39.5
author maintainer
#44 lore raw

PATCH 19/21 debugfs: use DCACHE_DONTCACHE

In reply to Al Viro
---
 fs/debugfs/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/debugfs/inode.c +1 -1
index f54a8fd960e4..1c71d9932a67 100644
@@ -258,7 +258,6 @@ static struct vfsmount *debugfs_automount(struct path *path)
 }
 
 static const struct dentry_operations debugfs_dops = {
-	.d_delete = always_delete_dentry,
 	.d_release = debugfs_release_dentry,
 	.d_automount = debugfs_automount,
 };
@@ -274,6 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	sb->s_op = &debugfs_super_operations;
 	set_default_d_op(sb, &debugfs_dops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 
 	debugfs_apply_options(sb);
 
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 19/21
#45 lore raw

Re: [PATCH 19/21] debugfs: use DCACHE_DONTCACHE

Quoted 2 lines · Al Viro

---

Quoted 26 lines
 fs/debugfs/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/debugfs/inode.c +1 -1
index f54a8fd960e4..1c71d9932a67 100644
@@ -258,7 +258,6 @@ static struct vfsmount *debugfs_automount(struct path *path)
 }
 
 static const struct dentry_operations debugfs_dops = {
-	.d_delete = always_delete_dentry,
 	.d_release = debugfs_release_dentry,
 	.d_automount = debugfs_automount,
 };
@@ -274,6 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	sb->s_op = &debugfs_super_operations;
 	set_default_d_op(sb, &debugfs_dops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 
 	debugfs_apply_options(sb);
 
Signature · 1 line
2.39.5
author maintainer
#46 lore raw

PATCH 20/21 configfs: use DCACHE_DONTCACHE

In reply to Al Viro
---
 fs/configfs/dir.c   | 1 -
 fs/configfs/mount.c | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
fs/configfs/dir.c +0 -1
index 7d10278db30d..637267a76ad8 100644
@@ -67,7 +67,6 @@ static void configfs_d_iput(struct dentry * dentry,
 
 const struct dentry_operations configfs_dentry_ops = {
 	.d_iput		= configfs_d_iput,
-	.d_delete	= always_delete_dentry,
 };
 
 #ifdef CONFIG_LOCKDEP
fs/configfs/mount.c +1 -0
index 20412eaca972..740f18b60c9d 100644
@@ -93,6 +93,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
 	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	return 0;
 }
 
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 20/21
#47 lore raw

Re: [PATCH 20/21] configfs: use DCACHE_DONTCACHE

Quoted 2 lines · Al Viro

---

Quoted 31 lines
 fs/configfs/dir.c   | 1 -
 fs/configfs/mount.c | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
fs/configfs/dir.c +0 -1
index 7d10278db30d..637267a76ad8 100644
@@ -67,7 +67,6 @@ static void configfs_d_iput(struct dentry * dentry,
 
 const struct dentry_operations configfs_dentry_ops = {
 	.d_iput		= configfs_d_iput,
-	.d_delete	= always_delete_dentry,
 };
 
 #ifdef CONFIG_LOCKDEP
fs/configfs/mount.c +1 -0
index 20412eaca972..740f18b60c9d 100644
@@ -93,6 +93,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
 	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	return 0;
 }
 
Signature · 1 line
2.39.5
author maintainer
#48 lore raw

PATCH 21/21 afs dynroot: use DCACHE_DONTCACHE

In reply to Al Viro
---
 fs/afs/dynroot.c | 1 -
 fs/afs/super.c   | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
fs/afs/dynroot.c +0 -1
index d8bf52f77d93..2fad2987a6dc 100644
@@ -211,7 +211,6 @@ const struct inode_operations afs_dynroot_inode_operations = {
 };
 
 const struct dentry_operations afs_dynroot_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_release	= afs_d_release,
 	.d_automount	= afs_d_automount,
 };
fs/afs/super.c +1 -0
index 13d0414a1ddb..b48f524c1cb6 100644
@@ -488,6 +488,7 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 
 	if (as->dyn_root) {
 		set_default_d_op(sb, &afs_dynroot_dentry_operations);
+		sb->s_d_flags |= DCACHE_DONTCACHE;
 		ret = afs_dynroot_populate(sb);
 		if (ret < 0)
 			goto error;
Signature · 1 line
2.39.5
maintainer Reviewed-by on v1 21/21
#49 lore raw

Re: [PATCH 21/21] afs dynroot: use DCACHE_DONTCACHE

Quoted 2 lines · Al Viro

---

Quoted 31 lines
 fs/afs/dynroot.c | 1 -
 fs/afs/super.c   | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
fs/afs/dynroot.c +0 -1
index d8bf52f77d93..2fad2987a6dc 100644
@@ -211,7 +211,6 @@ const struct inode_operations afs_dynroot_inode_operations = {
 };
 
 const struct dentry_operations afs_dynroot_dentry_operations = {
-	.d_delete	= always_delete_dentry,
 	.d_release	= afs_d_release,
 	.d_automount	= afs_d_automount,
 };
fs/afs/super.c +1 -0
index 13d0414a1ddb..b48f524c1cb6 100644
@@ -488,6 +488,7 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 
 	if (as->dyn_root) {
 		set_default_d_op(sb, &afs_dynroot_dentry_operations);
+		sb->s_d_flags |= DCACHE_DONTCACHE;
 		ret = afs_dynroot_populate(sb);
 		if (ret < 0)
 			goto error;
Signature · 1 line
2.39.5
maintainer
#50 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

In reply to Al Viro
Quoted 6 lines · Al Viro

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

FWIW I went through the patches and I like them. They look mostly straightforward enough to me and as good simplifications.

Honza

Quoted 65 lines
---
 fs/proc/generic.c  | 8 +++++---
 fs/proc/internal.h | 5 +++--
 2 files changed, 8 insertions(+), 5 deletions(-)
fs/proc/generic.c +5 -3
index 8ec90826a49e..499c2bf67488 100644
@@ -254,7 +254,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		inode = proc_get_inode(dir->i_sb, de);
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
-		d_set_d_op(dentry, de->proc_dops);
+		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
+			d_set_d_op(dentry, &proc_net_dentry_ops);
+		else
+			d_set_d_op(dentry, &proc_misc_dentry_ops);
 		return d_splice_alias(inode, dentry);
 	}
 	read_unlock(&proc_subdir_lock);
@@ -448,9 +451,8 @@ static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 	INIT_LIST_HEAD(&ent->pde_openers);
 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 
-	ent->proc_dops = &proc_misc_dentry_ops;
 	/* Revalidate everything under /proc/${pid}/net */
-	if ((*parent)->proc_dops == &proc_net_dentry_ops)
+	if ((*parent)->flags & PROC_ENTRY_FORCE_LOOKUP)
 		pde_force_lookup(ent);
 
 out:
fs/proc/internal.h +3 -2
index 1695509370b8..07f75c959173 100644
@@ -44,7 +44,6 @@ struct proc_dir_entry {
 		const struct proc_ops *proc_ops;
 		const struct file_operations *proc_dir_ops;
 	};
-	const struct dentry_operations *proc_dops;
 	union {
 		const struct seq_operations *seq_ops;
 		int (*single_show)(struct seq_file *, void *);
@@ -67,6 +66,8 @@ struct proc_dir_entry {
 	char inline_name[];
 } __randomize_layout;
 
+#define PROC_ENTRY_FORCE_LOOKUP 2 /* same space as PROC_ENTRY_PERMANENT */
+
 #define SIZEOF_PDE	(				\
 	sizeof(struct proc_dir_entry) < 128 ? 128 :	\
 	sizeof(struct proc_dir_entry) < 192 ? 192 :	\
@@ -346,7 +347,7 @@ extern const struct dentry_operations proc_net_dentry_ops;
 static inline void pde_force_lookup(struct proc_dir_entry *pde)
 {
 	/* /proc/net/ entries can be changed under us by setns(CLONE_NEWNET) */
-	pde->proc_dops = &proc_net_dentry_ops;
+	pde->flags |= PROC_ENTRY_FORCE_LOOKUP;
 }
 
 /*
Signature · 1 line
2.39.5
Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
#51 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

Quoted 11 lines · Jan Kara
Quoted 6 lines · Al Viro

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

FWIW I went through the patches and I like them. They look mostly straightforward enough to me and as good simplifications.

Ditto. Nice clean-up
It might be good to document s_d_flags and particularly the value of setting DCACHE_DONTCACHE. That flag is documented in the list of DCACHE_ flags, but making the connection that it can usefully be put in s_d_flags might be a step to far for many.

Thanks,
NeilBrown

author maintainer
#52 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

Quoted 13 lines · NeilBrown
Quoted 11 lines · Jan Kara
Quoted 6 lines · Al Viro

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

FWIW I went through the patches and I like them. They look mostly straightforward enough to me and as good simplifications.

Quoted 5 lines

Ditto. Nice clean-up
It might be good to document s_d_flags and particularly the value of setting DCACHE_DONTCACHE. That flag is documented in the list of DCACHE_ flags, but making the connection that it can usefully be put in s_d_flags might be a step to far for many.

Probably... The thing is, I'm resurrecting the DCACHE_PERSISTENT patchset (aka tree-in-dcache stuff) and that will have non-trivial interplay there. But you are right - it's probably worth documenting that thing in this series.

Re documentation - I'll be posting bits and pieces of dcache docs/audit/proofs of correctness over the next few weeks; at some point we'll need to collect that into a single text, but at the moment what I've got is too disjoint for that. OTOH, we could start a WIP variant in D/f/<something> and have it augmented as we go... Not sure.

#53 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

In reply to Al Viro
Quoted 51 lines · Al Viro

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

---
 fs/proc/generic.c  | 8 +++++---
 fs/proc/internal.h | 5 +++--
 2 files changed, 8 insertions(+), 5 deletions(-)
fs/proc/generic.c +5 -3
index 8ec90826a49e..499c2bf67488 100644
@@ -254,7 +254,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		inode = proc_get_inode(dir->i_sb, de);
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
-		d_set_d_op(dentry, de->proc_dops);
+		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
+			d_set_d_op(dentry, &proc_net_dentry_ops);
+		else
+			d_set_d_op(dentry, &proc_misc_dentry_ops);
 		return d_splice_alias(inode, dentry);
 	}
 	read_unlock(&proc_subdir_lock);
@@ -448,9 +451,8 @@ static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 	INIT_LIST_HEAD(&ent->pde_openers);
 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 
-	ent->proc_dops = &proc_misc_dentry_ops;
 	/* Revalidate everything under /proc/${pid}/net */
-	if ((*parent)->proc_dops == &proc_net_dentry_ops)
+	if ((*parent)->flags & PROC_ENTRY_FORCE_LOOKUP)
 		pde_force_lookup(ent);
 
 out:
fs/proc/internal.h +0 -1
index 1695509370b8..07f75c959173 100644
@@ -44,7 +44,6 @@ struct proc_dir_entry {
 		const struct proc_ops *proc_ops;
 		const struct file_operations *proc_dir_ops;
 	};
-	const struct dentry_operations *proc_dops;
 	union {
 		const struct seq_operations *seq_ops;
 		int (*single_show)(struct seq_file *, void *);

fs/proc/internal.h struct proc_dir_entry { · line 69

Quoted 4 lines
fs/proc/internal.h +1 -0
@@ -67,6 +66,8 @@ struct proc_dir_entry {
 	char inline_name[];
 } __randomize_layout;
 
+#define PROC_ENTRY_FORCE_LOOKUP 2 /* same space as PROC_ENTRY_PERMANENT */

Should there be a note in include/linux/proc_fs.h say that '2' is in use?

Otherwise it seems sensible.

Thanks,
NeilBrown

Quoted 17 lines
fs/proc/internal.h +2 -1
+
 #define SIZEOF_PDE	(				\
 	sizeof(struct proc_dir_entry) < 128 ? 128 :	\
 	sizeof(struct proc_dir_entry) < 192 ? 192 :	\
@@ -346,7 +347,7 @@ extern const struct dentry_operations proc_net_dentry_ops;
 static inline void pde_force_lookup(struct proc_dir_entry *pde)
 {
 	/* /proc/net/ entries can be changed under us by setns(CLONE_NEWNET) */
-	pde->proc_dops = &proc_net_dentry_ops;
+	pde->flags |= PROC_ENTRY_FORCE_LOOKUP;
 }
 
 /*
Signature · 1 line
2.39.5
author maintainer
#54 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

Quoted 7 lines · NeilBrown

fs/proc/internal.h struct proc_dir_entry { · line 69

Quoted 4 lines
fs/proc/internal.h +1 -0
 	char inline_name[];
 } __randomize_layout;
 
+#define PROC_ENTRY_FORCE_LOOKUP 2 /* same space as PROC_ENTRY_PERMANENT */

Should there be a note in include/linux/proc_fs.h say that '2' is in use?

Umm... Point, I guess - or we could just put "all other bits are belong to us" there ;-)

maintainer Reviewed-by on v1 1/21
#55 lore raw

Re: [PATCH 01/21] procfs: kill ->proc_dops

In reply to Al Viro
Quoted 7 lines · Al Viro

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

---

#56 lore raw
In reply to Al Viro
Quoted 14 lines · Al Viro
Quoted 7 lines · Christian Brauner

I think it would be worthwhile to mark dentries of such filesystems as always unhashed and then add an assert into fs/dcache.c whenever such a dentry should suddenly become hashed.

That would not just make it very easy to see for the reviewer that the dentries of this filesystem are always unhashed it would also make it possible to spot bugs.

Not sure that's useful, really... Details are tied into the tree-in-dcache rework, and I'll need to finish resurrecting that; should post in a week or so.

Quoted 8 lines

For this series, see viro/vfs.git#work.dcache - it's a WIP at the moment, and it's going to get reordered (if nothing else, d_alloc_parallel() side needs an audit of tree-walkers to prove that it won't get confused by seeing DCACHE_PAR_LOOKUP on the stuff that hasn't yet reached in-lookup hash chains, and that might add prereqs that would need to go early in queue), but that at least fleshes out what I described upthread.

I'll post individual patches for review in a few hours.

Went through them all. Everything looks good! Thanks!

Christian

#57 lore raw
In reply to Al Viro
Quoted 99 lines · Al Viro
	Recently I went looking through the ->d_flags locking (long

story, that was a side branch in digging through the issues with Neil's locking scheme); results are interesting.

	All stores to dentry->d_flags are done by somebody who

* holds a counting reference to dentry or
* has found a counting reference in shared data structures, in conditions that guarantee that this reference won't go away or
* has found dentry in alias list of some inode (under ->i_lock)
* [fs/dcache.c only] is an LRU walker callback running into that dentry in LRU list or
* [fs/dcache.c only] is owner of a shrink list running into dentry in that list or
* [fs/dcache.c only] is a d_walk() callback running into that dentry with zero refcount (and moving it to shrink list) or
* [fs/dcache.c only] is a d_walk() called by kill_litter_super() running into that dentry when unpinning theretofore persistent dentries; that can happen only during filesystem shutdown, when nobody else could be accessing it.

	The above guarantees that dentry won't disappear under us;

another interesting thing is exclusion, and that's where the things get nasty. Most of the stores to dentry->d_flags are under dentry->d_lock. There are obvious exceptions on the allocation side (stores done to dentry that is not visible to anybody else), but aside of those there are two exceptions.

One is d_set_d_op(), another - setting DCACHE_PAR_LOOKUP in
d_alloc_parallel().

	The former sets ->d_op and marks the presense of several methods

(->d_hash(), ->d_compare(), ->d_revalidate(), ->d_weak_revalidate(), ->d_delete(), ->d_prune() and ->d_real()) in ->d_flags.

It can't be done more than once and, if the filesystem
has ->s_d_op set in its superblock, it is done by the constructor
(__d_alloc()). That, obviously, falls under the "on allocation side";
so does another common case - d_alloc_pseudo() setting ->d_op to &anon_ops if __d_alloc() hadn't set it to ->s_d_op.

	Note that there's no barriers between the stores to ->d_op and

->d_flags in d_set_d_op(); for allocation time uses that's not a problem - fetches on another CPU would have to be preceded by finding the dentry in the first place, and barriers on the insertion into wherever it had been found would suffice.

There are other callers of d_set_d_op(), though - one in
simple_lookup() (again, if ->s_d_op is NULL) and the rest are all in procfs. Those are done with no locking whatsoever and dentry is *not* entirely invisible.

It's mostly invisible, though - in all those cases dentry is
* negative, and thus unreachable via the alias list of any inode
* unhashed, and thus can't be found via dcache lookup
* has the only direct reference held by the caller who has been holding it since it got allocated (i.e. it couldn't have been put into LRU or shrink lists either).

That is enough to guarantee that nobody else will be doing stores
to ->d_flags, so our store is safe even without ->d_lock. It is also fucking ugly and brittle...

	Moreover, the question about ->d_op vs ->d_flags ordering also

needs to be dealt with - unlike the calls at allocation time, insertion into wherever it had been found does *not* order fetches past both stores - not if it had been inserted into that wherever before the call of d_set_d_op().

Thankfully, the set of methods present in dentry_operations
ever fed to those late calls of d_set_d_op() is limited: ->d_revalidate, ->d_delete and, in one case, ->d_compare.

	->d_delete() is easy - it's called only from one place (retain_dentry())

and there we have just dropped the last reference to dentry in question. Since the caller of d_set_d_op() is holding a reference, the usual barriers on ->d_reflock use are enough.

	->d_compare() is a bit confusing - dentry it's getting as argument

is not the one whose method it is. We have the parent (already observed to be positive) and we are checking if this child (with ->d_parent pointing to parent) matches the name we want to look up. We take parent's ->d_compare() and give it child dentry, snapshot of child's name and the name we want to match it against.
We *CAN* get a dentry in the middle of d_set_d_op() passed to
someone's ->d_compare() - d_alloc_parent() does that to check if there's an in-lookup dentry matching the name we want. But ->d_compare() comes from parent, and that had been already observed to be positive. Which means that barriers in __d_set_inode_and_type() (from d_splice_alias()) suffice.

	->d_revalidate() is only called for dentries that had been found

in dcache hash chains at some point, so there the barrier on insertion into hash (in __d_add() from d_splice_alias()) is enough.

That covers d_set_d_op() callers; another exception is
d_alloc_parallel() when it decides to insert a new dentry into in-lookup hash and marks it with DCACHE_PAR_LOOKUP. Also safe, since dentry is only visible in the parent's list of children, has positive refcount and had it all along, so nobody else would try to do a store to ->d_flags at the same time.

Quoted 4 lines

In case it's not obvious from the above, I'm less than happy with
the entire thing - it may be provably correct, but it's much too brittle.

If nothing else, d_set_d_op() should be unexported. Do it to

Agreed.

Quoted 8 lines

a hashed or, worse, a positive dentry and you are asking for serious trouble. Leaving it as a public API is a really bad idea.

Something along the lines of d_splice_alias_ops(inode, dentry, ops)
(not exported, until we get a convincing modular user) is worth doing; all procfs callers of d_set_d_op() follow it with d_splice_alias() pretty much immediately. And yes, that could be done under ->d_lock, eliminating that special case from the proof.

That sounds great.

Quoted 6 lines

As for the allocation-time uses... We could bloody well calculate
the ->d_flags bits to go along with ->s_d_op and just use that; it's not just about getting rid of recalculating them for each dentry ever allocated on the filesystem in question, we could get rid of quite a few always_delete_dentry users while we are at it.

See my reply to your other mail: I'll kill it for pidfs and nsfs.

Quoted 3 lines
	Look: ->d_delete == always_delete_dentry (and DCACHE_OP_DELETE to

go with it) is equivalent to DCACHE_DONTCACHE; the only place where we

Also mentioned in my other reply: Can you please make the unhashed case really explicit ideally at dentry allocation time. IOW, that there's a flag or some other way of simply identifying a dentry as belonging to an fs that will never hash them?

Quoted 33 lines

look at either is retain_dentry(), where we have this:

        // ->d_delete() might tell us not to bother, but that requires
        // ->d_lock; can't decide without it
        if (unlikely(d_flags & DCACHE_OP_DELETE)) {
                if (!locked || dentry->d_op->d_delete(dentry))
                        return false;
        }

        // Explicitly told not to bother
        if (unlikely(d_flags & DCACHE_DONTCACHE))
                return false;
The inner if turns into
		if (!locked || 1)
			return false;

so for those DCACHE_DONTCACHE would be equivalent. And it could be put into the same "set those bits in all ->d_flags on that fs"; what's more, simple_lookup() doesn't need to set ->d_op at all - it can just set DCACHE_DONTCACHE in the unlikely case when it's not been already set.

How about something along the lines of
0) add d_splice_alias_ops(inode, dentry, dops), have procfs switch to that.
1) provide set_default_d_op(superblock, dops), use it in place of assignments to ->s_d_op. Rename ->s_d_op to catch unconverted filesystems. Tree-wide, entirely mechanical.
2) split the calculation of d_flags bits into a separate helper, add ->s_d_flags, have set_default_d_op() calculate and set that, have __d_alloc() pick ->s_d_op and ->s_d_flags directly.
3) convert those who wish to move from use of always_delete_dentry to adding DCACHE_DONTCACHE into ->s_d_flags. For devpts, for example, that avoids the need of non-NULL ->d_op.
4) replace d_set_d_op() in simple_lookup() with

Quoted 7 lines
	if (unlikely(!(dentry->d_flags & DCACHE_DONTCACHE))) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags |= DCACHE_DONTCACHE;
		spin_unlock(&dentry->d_lock);
	}

5) Kill simple_dentry_operations - no users would be left
6) make d_set_d_op() static in fs/dcache.c

Sounds good.

author maintainer
#58 lore raw

RFC PATCH v2 1/1 dentry->d_flags locking

Quoted 4 lines · Christian Brauner

Also mentioned in my other reply: Can you please make the unhashed case really explicit ideally at dentry allocation time. IOW, that there's a flag or some other way of simply identifying a dentry as belonging to an fs that will never hash them?

This really doesn't make sense; on all those filesystems we *do* want everything positive to be hashed. So I don't see anything useful that fs/dcache.c could check, not to mention how much I dislike behaviour that depends upon "feature flags" in file_system_type in general.

All dentries are allocated unhashed negative; a plenty of such fs go through the normal lookup helpers when they populate their trees. Sure, we could have their ->lookup() just return NULL and be done with that, but then we'd have to modify the code that handles attaching the damn things to inodes accordingly...

I don't see any point, especially since it would just create churn for tree-in-dcache series porting^Wresurrection, which I'm going to do this weekend.

Or are you talking about DCACHE_DONTCACHE (i.e. "unhash as soon as refcount hits 0", rather than "never hash it at all")?

Anyway, I have ported the "safe ->d_flags" series (this thread) to 6.16-rc1. Changes:

* several commits got dropped (merged or, as in afs dynroot case, invalidated)
* procfs flag moved to include/linux/procfs.h, deconflicted.
* tracefs told to set DCACHE_DONTCACHE on everything; it is a behaviour change, and IMO the correct one.
* in "simple_lookup(): just set DCACHE_DONTCACHE", don't set the flag if ->d_op had been set and DCACHE_DONTCACHE wasn't already present. That matches the mainline logics. See comments in that commit...

Force-pushed into
git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs.git #work.dcache Individual patches in followups; if nobody comes up with objections, into #for-next it goes. Folks, please review.

author maintainer
#59 lore raw

PATCH v2 1/21 d_set_mounted(): we don't need to bump seqcount component of rename_lock

IOW, read_seqlock_excl() is sufficient there; no need to bother with write_seqlock() (forcing all rename_lock readers into retry).

That leaves rename_lock taken for write only when we want to change someone's parent or name.

---
 fs/dcache.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
fs/dcache.c +2 -2
index 03d58b2d4fa3..3c3cfb345233 100644
@@ -1436,7 +1436,7 @@ int d_set_mounted(struct dentry *dentry)
 {
 	struct dentry *p;
 	int ret = -ENOENT;
-	write_seqlock(&rename_lock);
+	read_seqlock_excl(&rename_lock);
 	for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
 		/* Need exclusion wrt. d_invalidate() */
 		spin_lock(&p->d_lock);
@@ -1456,7 +1456,7 @@ int d_set_mounted(struct dentry *dentry)
 	}
  	spin_unlock(&dentry->d_lock);
 out:
-	write_sequnlock(&rename_lock);
+	read_sequnlock_excl(&rename_lock);
 	return ret;
 }
 
Signature · 1 line
2.39.5
author maintainer
#60 lore raw

PATCH v2 2/21 procfs: kill ->proc_dops

It has two possible values - one for "forced lookup" entries, another for the normal ones. We'd be better off with that as an explicit flag anyway and in addition to that it opens some fun possibilities with ->d_op and ->d_flags handling.

[moved PROC_ENTRY_FORCE_LOOKUP to include/linux/proc_fs.h, switched it to an unused bit - there was a conflict]

---
 fs/proc/generic.c       | 8 +++++---
 fs/proc/internal.h      | 3 +--
 include/linux/proc_fs.h | 2 ++
 3 files changed, 8 insertions(+), 5 deletions(-)
fs/proc/generic.c +5 -3
index a3e22803cddf..38ce45ce0eb6 100644
@@ -254,7 +254,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		inode = proc_get_inode(dir->i_sb, de);
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
-		d_set_d_op(dentry, de->proc_dops);
+		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
+			d_set_d_op(dentry, &proc_net_dentry_ops);
+		else
+			d_set_d_op(dentry, &proc_misc_dentry_ops);
 		return d_splice_alias(inode, dentry);
 	}
 	read_unlock(&proc_subdir_lock);
@@ -448,9 +451,8 @@ static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 	INIT_LIST_HEAD(&ent->pde_openers);
 	proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 
-	ent->proc_dops = &proc_misc_dentry_ops;
 	/* Revalidate everything under /proc/${pid}/net */
-	if ((*parent)->proc_dops == &proc_net_dentry_ops)
+	if ((*parent)->flags & PROC_ENTRY_FORCE_LOOKUP)
 		pde_force_lookup(ent);
 
 out:
fs/proc/internal.h +1 -2
index 96122e91c645..a4054916f6da 100644
@@ -44,7 +44,6 @@ struct proc_dir_entry {
 		const struct proc_ops *proc_ops;
 		const struct file_operations *proc_dir_ops;
 	};
-	const struct dentry_operations *proc_dops;
 	union {
 		const struct seq_operations *seq_ops;
 		int (*single_show)(struct seq_file *, void *);
@@ -403,7 +402,7 @@ extern const struct dentry_operations proc_net_dentry_ops;
 static inline void pde_force_lookup(struct proc_dir_entry *pde)
 {
 	/* /proc/net/ entries can be changed under us by setns(CLONE_NEWNET) */
-	pde->proc_dops = &proc_net_dentry_ops;
+	pde->flags |= PROC_ENTRY_FORCE_LOOKUP;
 }
 
 /*
include/linux/proc_fs.h +2 -0
index ea62201c74c4..de1d24f19f76 100644
@@ -27,6 +27,8 @@ enum {
 
 	PROC_ENTRY_proc_read_iter	= 1U << 1,
 	PROC_ENTRY_proc_compat_ioctl	= 1U << 2,
+
+	PROC_ENTRY_FORCE_LOOKUP		= 1U << 7,
 };
 
 struct proc_ops {
Signature · 1 line
2.39.5
author maintainer
#61 lore raw

PATCH v2 3/21 new helper: d_splice_alias_ops()

In reply to Al Viro

Uses of d_set_d_op() on live dentry can be very dangerous; it is going to be withdrawn and replaced with saner things.

The best way for a filesystem is to have the default dentry_operations set at mount time and be done with that - __d_alloc() will use that.

Currently there are two cases when d_set_d_op() is used on a live dentry - one is procfs, which has several genuinely different dentry_operations instances (different ->d_revalidate(), etc.) and another is simple_lookup(), where we would be better off without overriding ->d_op.

For procfs we have d_set_d_op() calls followed by d_splice_alias(); provide a new helper (d_splice_alias_ops(inode, dentry, d_ops)) that would combine those two, and do the d_set_d_op() part while under ->d_lock. That eliminates one of the places where ->d_flags had been modified without holding ->d_lock; current behaviour is not racy, but the reasons for that are far too brittle. Better move to uniform locking rules and simpler proof of correctness...

The next commit will convert procfs to use of that helper; it is not exported and won't be until somebody comes up with convincing modular user for it.

Again, the best approach is to have default ->d_op and let __d_alloc() do the right thing; filesystem _may_ need non-uniform ->d_op (procfs does), but there'd better be good reasons for that.

---
 fs/dcache.c            | 63 ++++++++++++++++++++++++------------------
 include/linux/dcache.h |  3 ++
 2 files changed, 39 insertions(+), 27 deletions(-)
fs/dcache.c +36 -27
index 3c3cfb345233..bf550d438e40 100644
@@ -2667,7 +2667,8 @@ EXPORT_SYMBOL(__d_lookup_unhash_wake);
 
 /* inode->i_lock held if inode is non-NULL */
 
-static inline void __d_add(struct dentry *dentry, struct inode *inode)
+static inline void __d_add(struct dentry *dentry, struct inode *inode,
+			   const struct dentry_operations *ops)
 {
 	wait_queue_head_t *d_wait;
 	struct inode *dir = NULL;
@@ -2678,6 +2679,8 @@ static inline void __d_add(struct dentry *dentry, struct inode *inode)
 		n = start_dir_add(dir);
 		d_wait = __d_lookup_unhash(dentry);
 	}
+	if (unlikely(ops))
+		d_set_d_op(dentry, ops);
 	if (inode) {
 		unsigned add_flags = d_flags_for_inode(inode);
 		hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
@@ -2709,7 +2712,7 @@ void d_add(struct dentry *entry, struct inode *inode)
 		security_d_instantiate(entry, inode);
 		spin_lock(&inode->i_lock);
 	}
-	__d_add(entry, inode);
+	__d_add(entry, inode, NULL);
 }
 EXPORT_SYMBOL(d_add);
 
@@ -2961,30 +2964,8 @@ static int __d_unalias(struct dentry *dentry, struct dentry *alias)
 	return ret;
 }
 
-/**
- * d_splice_alias - splice a disconnected dentry into the tree if one exists
- * @inode:  the inode which may have a disconnected dentry
- * @dentry: a negative dentry which we want to point to the inode.
- *
- * If inode is a directory and has an IS_ROOT alias, then d_move that in
- * place of the given dentry and return it, else simply d_add the inode
- * to the dentry and return NULL.
- *
- * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
- * we should error out: directories can't have multiple aliases.
- *
- * This is needed in the lookup routine of any filesystem that is exportable
- * (via knfsd) so that we can build dcache paths to directories effectively.
- *
- * If a dentry was found and moved, then it is returned.  Otherwise NULL
- * is returned.  This matches the expected return value of ->lookup.
- *
- * Cluster filesystems may call this function with a negative, hashed dentry.
- * In that case, we know that the inode will be a regular file, and also this
- * will only occur during atomic_open. So we need to check for the dentry
- * being already hashed only in the final case.
- */
-struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+struct dentry *d_splice_alias_ops(struct inode *inode, struct dentry *dentry,
+				  const struct dentry_operations *ops)
 {
 	if (IS_ERR(inode))
 		return ERR_CAST(inode);
@@ -3030,9 +3011,37 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 		}
 	}
 out:
-	__d_add(dentry, inode);
+	__d_add(dentry, inode, ops);
 	return NULL;
 }
+
+/**
+ * d_splice_alias - splice a disconnected dentry into the tree if one exists
+ * @inode:  the inode which may have a disconnected dentry
+ * @dentry: a negative dentry which we want to point to the inode.
+ *
+ * If inode is a directory and has an IS_ROOT alias, then d_move that in
+ * place of the given dentry and return it, else simply d_add the inode
+ * to the dentry and return NULL.
+ *
+ * If a non-IS_ROOT directory is found, the filesystem is corrupt, and
+ * we should error out: directories can't have multiple aliases.
+ *
+ * This is needed in the lookup routine of any filesystem that is exportable
+ * (via knfsd) so that we can build dcache paths to directories effectively.
+ *
+ * If a dentry was found and moved, then it is returned.  Otherwise NULL
+ * is returned.  This matches the expected return value of ->lookup.
+ *
+ * Cluster filesystems may call this function with a negative, hashed dentry.
+ * In that case, we know that the inode will be a regular file, and also this
+ * will only occur during atomic_open. So we need to check for the dentry
+ * being already hashed only in the final case.
+ */
+struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
+{
+	return d_splice_alias_ops(inode, dentry, NULL);
+}
 EXPORT_SYMBOL(d_splice_alias);
 
 /*
include/linux/dcache.h +3 -0
index e29823c701ac..1993e6704552 100644
@@ -245,6 +245,9 @@ extern struct dentry * d_alloc_anon(struct super_block *);
 extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
 					wait_queue_head_t *);
 extern struct dentry * d_splice_alias(struct inode *, struct 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 bool d_same_name(const struct dentry *dentry, const struct dentry *parent,
 			const struct qstr *name);
Signature · 1 line
2.39.5
author maintainer
#62 lore raw

PATCH v2 4/21 switch procfs from d_set_d_op() to d_splice_alias_ops()

In reply to Al Viro
---
 fs/proc/base.c        | 9 +++------
 fs/proc/generic.c     | 8 ++++----
 fs/proc/internal.h    | 3 +--
 fs/proc/namespaces.c  | 3 +--
 fs/proc/proc_sysctl.c | 7 +++----
 5 files changed, 12 insertions(+), 18 deletions(-)
fs/proc/base.c +3 -6
index c667702dc69b..e93149a01341 100644
@@ -2704,8 +2704,7 @@ static struct dentry *proc_pident_instantiate(struct dentry *dentry,
 		inode->i_fop = p->fop;
 	ei->op = p->op;
 	pid_update_inode(task, inode);
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_pident_lookup(struct inode *dir, 
@@ -3501,8 +3500,7 @@ static struct dentry *proc_pid_instantiate(struct dentry * dentry,
 	set_nlink(inode, nlink_tgid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 struct dentry *proc_pid_lookup(struct dentry *dentry, unsigned int flags)
@@ -3804,8 +3802,7 @@ static struct dentry *proc_task_instantiate(struct dentry *dentry,
 	set_nlink(inode, nlink_tid);
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
fs/proc/generic.c +4 -4
index 38ce45ce0eb6..5635453cd476 100644
@@ -255,10 +255,10 @@ struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry,
 		if (!inode)
 			return ERR_PTR(-ENOMEM);
 		if (de->flags & PROC_ENTRY_FORCE_LOOKUP)
-			d_set_d_op(dentry, &proc_net_dentry_ops);
-		else
-			d_set_d_op(dentry, &proc_misc_dentry_ops);
-		return d_splice_alias(inode, dentry);
+			return d_splice_alias_ops(inode, dentry,
+						  &proc_net_dentry_ops);
+		return d_splice_alias_ops(inode, dentry,
+					  &proc_misc_dentry_ops);
 	}
 	read_unlock(&proc_subdir_lock);
 	return ERR_PTR(-ENOENT);
fs/proc/internal.h +1 -2
index a4054916f6da..520c4742101d 100644
@@ -413,7 +413,6 @@ static inline void pde_force_lookup(struct proc_dir_entry *pde)
 static inline struct dentry *proc_splice_unmountable(struct inode *inode,
 		struct dentry *dentry, const struct dentry_operations *d_ops)
 {
-	d_set_d_op(dentry, d_ops);
 	dont_mount(dentry);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, d_ops);
 }
fs/proc/namespaces.c +1 -2
index c610224faf10..4403a2e20c16 100644
@@ -111,8 +111,7 @@ static struct dentry *proc_ns_instantiate(struct dentry *dentry,
 	ei->ns_ops = ns_ops;
 	pid_update_inode(task, inode);
 
-	d_set_d_op(dentry, &pid_dentry_operations);
-	return d_splice_alias(inode, dentry);
+	return d_splice_alias_ops(inode, dentry, &pid_dentry_operations);
 }
 
 static int proc_ns_dir_readdir(struct file *file, struct dir_context *ctx)
fs/proc/proc_sysctl.c +3 -4
index cc9d74a06ff0..7a8bffc03dc8 100644
@@ -540,9 +540,8 @@ static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
 			goto out;
 	}
 
-	d_set_d_op(dentry, &proc_sys_dentry_operations);
 	inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
-	err = d_splice_alias(inode, dentry);
+	err = d_splice_alias_ops(inode, dentry, &proc_sys_dentry_operations);
 
 out:
 	if (h)
@@ -699,9 +698,9 @@ static bool proc_sys_fill_cache(struct file *file,
 			return false;
 		if (d_in_lookup(child)) {
 			struct dentry *res;
-			d_set_d_op(child, &proc_sys_dentry_operations);
 			inode = proc_sys_make_inode(dir->d_sb, head, table);
-			res = d_splice_alias(inode, child);
+			res = d_splice_alias_ops(inode, child,
+						 &proc_sys_dentry_operations);
 			d_lookup_done(child);
 			if (unlikely(res)) {
 				dput(child);
Signature · 1 line
2.39.5
author maintainer
#63 lore raw

PATCH v2 5/21 fuse: no need for special dentry_operations for root dentry

In reply to Al Viro

->d_revalidate() is never called for root anyway...

---
 fs/fuse/dir.c    | 7 -------
 fs/fuse/fuse_i.h | 1 -
 fs/fuse/inode.c  | 4 +---
 3 files changed, 1 insertion(+), 11 deletions(-)
fs/fuse/dir.c +0 -7
index 45b4c3cc1396..2d817d7cab26 100644
@@ -338,13 +338,6 @@ const struct dentry_operations fuse_dentry_operations = {
 	.d_automount	= fuse_dentry_automount,
 };
 
-const struct dentry_operations fuse_root_dentry_operations = {
-#if BITS_PER_LONG < 64
-	.d_init		= fuse_dentry_init,
-	.d_release	= fuse_dentry_release,
-#endif
-};
-
 int fuse_valid_type(int m)
 {
 	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
fs/fuse/fuse_i.h +0 -1
index b54f4f57789f..fb885376db6a 100644
@@ -1109,7 +1109,6 @@ static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)
 extern const struct file_operations fuse_dev_operations;
 
 extern const struct dentry_operations fuse_dentry_operations;
-extern const struct dentry_operations fuse_root_dentry_operations;
 
 /**
  * Get a filled in inode
fs/fuse/inode.c +1 -3
index bfe8d8af46f3..eb6177508598 100644
@@ -1850,12 +1850,10 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_root_dentry_operations;
+	sb->s_d_op = &fuse_dentry_operations;
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
-	/* Root dentry doesn't have .d_revalidate */
-	sb->s_d_op = &fuse_dentry_operations;
 
 	mutex_lock(&fuse_mutex);
 	err = -EINVAL;
Signature · 1 line
2.39.5
author maintainer
#64 lore raw

PATCH v2 6/21 new helper: set_default_d_op()

In reply to Al Viro

... to be used instead of manually assigning to ->s_d_op. All in-tree filesystem converted (and field itself is renamed, so any out-of-tree ones in need of conversion will be caught by compiler).

---
 Documentation/filesystems/porting.rst |  7 +++++++
 fs/9p/vfs_super.c                     |  4 ++--
 fs/adfs/super.c                       |  2 +-
 fs/affs/super.c                       |  4 ++--
 fs/afs/super.c                        |  4 ++--
 fs/autofs/inode.c                     |  2 +-
 fs/btrfs/super.c                      |  2 +-
 fs/ceph/super.c                       |  2 +-
 fs/coda/inode.c                       |  2 +-
 fs/configfs/mount.c                   |  2 +-
 fs/dcache.c                           | 10 ++++++++--
 fs/debugfs/inode.c                    |  2 +-
 fs/devpts/inode.c                     |  2 +-
 fs/ecryptfs/main.c                    |  2 +-
 fs/efivarfs/super.c                   |  2 +-
 fs/exfat/super.c                      |  4 ++--
 fs/fat/namei_msdos.c                  |  2 +-
 fs/fat/namei_vfat.c                   |  4 ++--
 fs/fuse/inode.c                       |  4 ++--
 fs/gfs2/ops_fstype.c                  |  2 +-
 fs/hfs/super.c                        |  2 +-
 fs/hfsplus/super.c                    |  2 +-
 fs/hostfs/hostfs_kern.c               |  2 +-
 fs/hpfs/super.c                       |  2 +-
 fs/isofs/inode.c                      |  2 +-
 fs/jfs/super.c                        |  2 +-
 fs/kernfs/mount.c                     |  2 +-
 fs/libfs.c                            | 16 ++++++++--------
 fs/nfs/super.c                        |  2 +-
 fs/ntfs3/super.c                      |  3 ++-
 fs/ocfs2/super.c                      |  2 +-
 fs/orangefs/super.c                   |  2 +-
 fs/overlayfs/super.c                  |  2 +-
 fs/smb/client/cifsfs.c                |  4 ++--
 fs/tracefs/inode.c                    |  2 +-
 fs/vboxsf/super.c                     |  2 +-
 include/linux/dcache.h                |  2 ++
 include/linux/fs.h                    |  2 +-
 mm/shmem.c                            |  2 +-
 net/sunrpc/rpc_pipe.c                 |  2 +-
 40 files changed, 69 insertions(+), 53 deletions(-)
Documentation/filesystems/porting.rst +7 -0
index 3616d7161dab..b16139e91942 100644
@@ -1249,3 +1249,10 @@ Using try_lookup_noperm() will require linux/namei.h to be included.
 
 Calling conventions for ->d_automount() have changed; we should *not* grab
 an extra reference to new mount - it should be returned with refcount 1.
+
+---
+
+**mandatory**
+
+If your filesystem sets the default dentry_operations, use set_default_d_op()
+rather than manually setting sb->s_d_op.
fs/9p/vfs_super.c +2 -2
index 489db161abc9..5c3dc3efb909 100644
@@ -135,9 +135,9 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 		goto release_sb;
 
 	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
-		sb->s_d_op = &v9fs_cached_dentry_operations;
+		set_default_d_op(sb, &v9fs_cached_dentry_operations);
 	else
-		sb->s_d_op = &v9fs_dentry_operations;
+		set_default_d_op(sb, &v9fs_dentry_operations);
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
fs/adfs/super.c +1 -1
index 017c48a80203..fdccdbbfc213 100644
@@ -397,7 +397,7 @@ static int adfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (asb->s_ftsuffix)
 		asb->s_namelen += 4;
 
-	sb->s_d_op = &adfs_dentry_operations;
+	set_default_d_op(sb, &adfs_dentry_operations);
 	root = adfs_iget(sb, &root_obj);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
fs/affs/super.c +2 -2
index 2fa40337776d..44f8aa883100 100644
@@ -500,9 +500,9 @@ static int affs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return PTR_ERR(root_inode);
 
 	if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_INTL))
-		sb->s_d_op = &affs_intl_dentry_operations;
+		set_default_d_op(sb, &affs_intl_dentry_operations);
 	else
-		sb->s_d_op = &affs_dentry_operations;
+		set_default_d_op(sb, &affs_dentry_operations);
 
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root) {
fs/afs/super.c +2 -2
index 25b306db6992..da407f2d6f0d 100644
@@ -483,9 +483,9 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
 		goto error;
 
 	if (as->dyn_root) {
-		sb->s_d_op = &afs_dynroot_dentry_operations;
+		set_default_d_op(sb, &afs_dynroot_dentry_operations);
 	} else {
-		sb->s_d_op = &afs_fs_dentry_operations;
+		set_default_d_op(sb, &afs_fs_dentry_operations);
 		rcu_assign_pointer(as->volume->sb, sb);
 	}
 
fs/autofs/inode.c +1 -1
index ee2edccaef70..f5c16ffba013 100644
@@ -311,7 +311,7 @@ static int autofs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_blocksize_bits = 10;
 	s->s_magic = AUTOFS_SUPER_MAGIC;
 	s->s_op = &autofs_sops;
-	s->s_d_op = &autofs_dentry_operations;
+	set_default_d_op(s, &autofs_dentry_operations);
 	s->s_time_gran = 1;
 
 	/*
fs/btrfs/super.c +1 -1
index a0c65adce1ab..ad75d9f8f404 100644
@@ -950,7 +950,7 @@ static int btrfs_fill_super(struct super_block *sb,
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_magic = BTRFS_SUPER_MAGIC;
 	sb->s_op = &btrfs_super_ops;
-	sb->s_d_op = &btrfs_dentry_operations;
+	set_default_d_op(sb, &btrfs_dentry_operations);
 	sb->s_export_op = &btrfs_export_ops;
 #ifdef CONFIG_FS_VERITY
 	sb->s_vop = &btrfs_verityops;
fs/ceph/super.c +1 -1
index 2b8438d8a324..c3eb651862c5 100644
@@ -1219,7 +1219,7 @@ static int ceph_set_super(struct super_block *s, struct fs_context *fc)
 	fsc->max_file_size = 1ULL << 40; /* temp value until we get mdsmap */
 
 	s->s_op = &ceph_super_ops;
-	s->s_d_op = &ceph_dentry_ops;
+	set_default_d_op(s, &ceph_dentry_ops);
 	s->s_export_op = &ceph_export_ops;
 
 	s->s_time_gran = 1;
fs/coda/inode.c +1 -1
index 6896fce122e1..08450d006016 100644
@@ -230,7 +230,7 @@ static int coda_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 12;
 	sb->s_magic = CODA_SUPER_MAGIC;
 	sb->s_op = &coda_super_operations;
-	sb->s_d_op = &coda_dentry_operations;
+	set_default_d_op(sb, &coda_dentry_operations);
 	sb->s_time_gran = 1;
 	sb->s_time_min = S64_MIN;
 	sb->s_time_max = S64_MAX;
fs/configfs/mount.c +1 -1
index c2d820063ec4..20412eaca972 100644
@@ -92,7 +92,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	configfs_root_group.cg_item.ci_dentry = root;
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
-	sb->s_d_op = &configfs_dentry_ops; /* the rest get that */
+	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
 	return 0;
 }
 
fs/dcache.c +8 -2
index bf550d438e40..2ed875558ccc 100644
@@ -1738,7 +1738,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->s_d_op);
+	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1821,7 +1821,7 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	struct dentry *dentry = __d_alloc(sb, name);
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
-		if (!sb->s_d_op)
+		if (!dentry->d_op)
 			d_set_d_op(dentry, &anon_ops);
 	}
 	return dentry;
@@ -1867,6 +1867,12 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 }
 EXPORT_SYMBOL(d_set_d_op);
 
+void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
+{
+	s->__s_d_op = ops;
+}
+EXPORT_SYMBOL(set_default_d_op);
+
 static unsigned d_flags_for_inode(struct inode *inode)
 {
 	unsigned add_flags = DCACHE_REGULAR_TYPE;
fs/debugfs/inode.c +1 -1
index 30c4944e1862..29c5ec382342 100644
@@ -273,7 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &debugfs_super_operations;
-	sb->s_d_op = &debugfs_dops;
+	set_default_d_op(sb, &debugfs_dops);
 
 	debugfs_apply_options(sb);
 
fs/devpts/inode.c +1 -1
index 9c20d78e41f6..fd17992ee298 100644
@@ -381,7 +381,7 @@ static int devpts_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	s->s_d_op = &simple_dentry_operations;
+	set_default_d_op(s, &simple_dentry_operations);
 	s->s_time_gran = 1;
 	fsi->sb = s;
 
fs/ecryptfs/main.c +1 -1
index 8dd1d7189c3b..45f9ca4465da 100644
@@ -471,7 +471,7 @@ static int ecryptfs_get_tree(struct fs_context *fc)
 	sbi = NULL;
 	s->s_op = &ecryptfs_sops;
 	s->s_xattr = ecryptfs_xattr_handlers;
-	s->s_d_op = &ecryptfs_dops;
+	set_default_d_op(s, &ecryptfs_dops);
 
 	err = "Reading sb failed";
 	rc = kern_path(fc->source, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
fs/efivarfs/super.c +1 -1
index c900d98bf494..f76d8dfa646b 100644
@@ -350,7 +350,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits    = PAGE_SHIFT;
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
-	sb->s_d_op		= &efivarfs_d_ops;
+	set_default_d_op(sb, &efivarfs_d_ops);
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
fs/exfat/super.c +2 -2
index 7ed858937d45..ea5c1334a214 100644
@@ -667,9 +667,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)
 	}
 
 	if (sbi->options.utf8)
-		sb->s_d_op = &exfat_utf8_dentry_ops;
+		set_default_d_op(sb, &exfat_utf8_dentry_ops);
 	else
-		sb->s_d_op = &exfat_dentry_ops;
+		set_default_d_op(sb, &exfat_dentry_ops);
 
 	root_inode = new_inode(sb);
 	if (!root_inode) {
fs/fat/namei_msdos.c +1 -1
index 23e9b9371ec3..0b920ee40a7f 100644
@@ -646,7 +646,7 @@ static const struct inode_operations msdos_dir_inode_operations = {
 static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &msdos_dir_inode_operations;
-	sb->s_d_op = &msdos_dentry_operations;
+	set_default_d_op(sb, &msdos_dentry_operations);
 	sb->s_flags |= SB_NOATIME;
 }
 
fs/fat/namei_vfat.c +2 -2
index dd910edd2404..5dbc4cbb8fce 100644
@@ -1187,9 +1187,9 @@ static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
 	if (MSDOS_SB(sb)->options.name_check != 's')
-		sb->s_d_op = &vfat_ci_dentry_ops;
+		set_default_d_op(sb, &vfat_ci_dentry_ops);
 	else
-		sb->s_d_op = &vfat_dentry_ops;
+		set_default_d_op(sb, &vfat_dentry_ops);
 }
 
 static int vfat_fill_super(struct super_block *sb, struct fs_context *fc)
fs/fuse/inode.c +2 -2
index eb6177508598..0dd65c0e9e29 100644
@@ -1715,7 +1715,7 @@ static int fuse_fill_super_submount(struct super_block *sb,
 	fi = get_fuse_inode(root);
 	fi->nlookup--;
 
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root)
 		return -ENOMEM;
@@ -1850,7 +1850,7 @@ int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
 
 	err = -ENOMEM;
 	root = fuse_get_root_inode(sb, ctx->rootmode);
-	sb->s_d_op = &fuse_dentry_operations;
+	set_default_d_op(sb, &fuse_dentry_operations);
 	root_dentry = d_make_root(root);
 	if (!root_dentry)
 		goto err_dev_free;
fs/gfs2/ops_fstype.c +1 -1
index 85c491fcf1a3..b568767dba46 100644
@@ -1145,7 +1145,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic = GFS2_MAGIC;
 	sb->s_op = &gfs2_super_ops;
 
-	sb->s_d_op = &gfs2_dops;
+	set_default_d_op(sb, &gfs2_dops);
 	sb->s_export_op = &gfs2_export_ops;
 	sb->s_qcop = &gfs2_quotactl_ops;
 	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
fs/hfs/super.c +1 -1
index fe09c2093a93..388a318297ec 100644
@@ -365,7 +365,7 @@ static int hfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (!root_inode)
 		goto bail_no_root;
 
-	sb->s_d_op = &hfs_dentry_operations;
+	set_default_d_op(sb, &hfs_dentry_operations);
 	res = -ENOMEM;
 	sb->s_root = d_make_root(root_inode);
 	if (!sb->s_root)
fs/hfsplus/super.c +1 -1
index 948b8aaee33e..0caf7aa1c249 100644
@@ -508,7 +508,7 @@ static int hfsplus_fill_super(struct super_block *sb, struct fs_context *fc)
 		goto out_put_alloc_file;
 	}
 
-	sb->s_d_op = &hfsplus_dentry_operations;
+	set_default_d_op(sb, &hfsplus_dentry_operations);
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
 		err = -ENOMEM;
fs/hostfs/hostfs_kern.c +1 -1
index 702c41317589..1c0f5038e19c 100644
@@ -933,7 +933,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
fs/hpfs/super.c +1 -1
index 27567920abe4..42b779b4d87f 100644
@@ -554,7 +554,7 @@ static int hpfs_fill_super(struct super_block *s, struct fs_context *fc)
 	/* Fill superblock stuff */
 	s->s_magic = HPFS_SUPER_MAGIC;
 	s->s_op = &hpfs_sops;
-	s->s_d_op = &hpfs_dentry_operations;
+	set_default_d_op(s, &hpfs_dentry_operations);
 	s->s_time_min =  local_to_gmt(s, 0);
 	s->s_time_max =  local_to_gmt(s, U32_MAX);
 
fs/isofs/inode.c +1 -1
index d5da9817df9b..8624393c0d8c 100644
@@ -939,7 +939,7 @@ static int isofs_fill_super(struct super_block *s, struct fs_context *fc)
 	sbi->s_check = opt->check;
 
 	if (table)
-		s->s_d_op = &isofs_dentry_ops[table - 1];
+		set_default_d_op(s, &isofs_dentry_ops[table - 1]);
 
 	/* get the root dentry */
 	s->s_root = d_make_root(inode);
fs/jfs/super.c +1 -1
index 10368c188c5e..3cfb86c5a36e 100644
@@ -542,7 +542,7 @@ static int jfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic = JFS_SUPER_MAGIC;
 
 	if (sbi->mntflag & JFS_OS2)
-		sb->s_d_op = &jfs_ci_dentry_operations;
+		set_default_d_op(sb, &jfs_ci_dentry_operations);
 
 	inode = jfs_iget(sb, ROOT_I);
 	if (IS_ERR(inode)) {
fs/kernfs/mount.c +1 -1
index c1719b5778a1..e384a69fbece 100644
@@ -318,7 +318,7 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *k
 		return -ENOMEM;
 	}
 	sb->s_root = root;
-	sb->s_d_op = &kernfs_dops;
+	set_default_d_op(sb, &kernfs_dops);
 	return 0;
 }
 
fs/libfs.c +8 -8
index 9ea0ecc325a8..ab82de070310 100644
@@ -75,7 +75,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_sb->s_d_op)
+	if (!dentry->d_op)
 		d_set_d_op(dentry, &simple_dentry_operations);
 
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
@@ -684,7 +684,7 @@ static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_root = d_make_root(root);
 	if (!s->s_root)
 		return -ENOMEM;
-	s->s_d_op = ctx->dops;
+	set_default_d_op(s, ctx->dops);
 	return 0;
 }
 
@@ -1950,22 +1950,22 @@ static const struct dentry_operations generic_encrypted_dentry_ops = {
  * @sb: superblock to be configured
  *
  * Filesystems supporting casefolding and/or fscrypt can call this
- * helper at mount-time to configure sb->s_d_op to best set of dentry
- * operations required for the enabled features. The helper must be
- * called after these have been configured, but before the root dentry
- * is created.
+ * helper at mount-time to configure default dentry_operations to the
+ * best set of dentry operations required for the enabled features.
+ * The helper must be called after these have been configured, but
+ * before the root dentry is created.
  */
 void generic_set_sb_d_ops(struct super_block *sb)
 {
 #if IS_ENABLED(CONFIG_UNICODE)
 	if (sb->s_encoding) {
-		sb->s_d_op = &generic_ci_dentry_ops;
+		set_default_d_op(sb, &generic_ci_dentry_ops);
 		return;
 	}
 #endif
 #ifdef CONFIG_FS_ENCRYPTION
 	if (sb->s_cop) {
-		sb->s_d_op = &generic_encrypted_dentry_ops;
+		set_default_d_op(sb, &generic_encrypted_dentry_ops);
 		return;
 	}
 #endif
fs/nfs/super.c +1 -1
index 91b5503b6f74..72dee6f3050e 100644
@@ -1183,7 +1183,7 @@ static int nfs_set_super(struct super_block *s, struct fs_context *fc)
 	struct nfs_server *server = fc->s_fs_info;
 	int ret;
 
-	s->s_d_op = server->nfs_client->rpc_ops->dentry_ops;
+	set_default_d_op(s, server->nfs_client->rpc_ops->dentry_ops);
 	ret = set_anon_super(s, server);
 	if (ret == 0)
 		server->s_dev = s->s_dev;
fs/ntfs3/super.c +2 -1
index 920a1ab47b63..ddff94c091b8 100644
@@ -1223,7 +1223,8 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_export_op = &ntfs_export_ops;
 	sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec
 	sb->s_xattr = ntfs_xattr_handlers;
-	sb->s_d_op = options->nocase ? &ntfs_dentry_ops : NULL;
+	if (options->nocase)
+		set_default_d_op(sb, &ntfs_dentry_ops);
 
 	options->nls = ntfs_load_nls(options->nls_name);
 	if (IS_ERR(options->nls)) {
fs/ocfs2/super.c +1 -1
index 3d2533950bae..53daa4482406 100644
@@ -1962,7 +1962,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
 
 	sb->s_fs_info = osb;
 	sb->s_op = &ocfs2_sops;
-	sb->s_d_op = &ocfs2_dentry_ops;
+	set_default_d_op(sb, &ocfs2_dentry_ops);
 	sb->s_export_op = &ocfs2_export_ops;
 	sb->s_qcop = &dquot_quotactl_sysfile_ops;
 	sb->dq_op = &ocfs2_quota_operations;
fs/orangefs/super.c +1 -1
index 64ca9498f550..f3da840758e7 100644
@@ -416,7 +416,7 @@ static int orangefs_fill_sb(struct super_block *sb,
 	sb->s_xattr = orangefs_xattr_handlers;
 	sb->s_magic = ORANGEFS_SUPER_MAGIC;
 	sb->s_op = &orangefs_s_ops;
-	sb->s_d_op = &orangefs_dentry_operations;
+	set_default_d_op(sb, &orangefs_dentry_operations);
 
 	sb->s_blocksize = PAGE_SIZE;
 	sb->s_blocksize_bits = PAGE_SHIFT;
fs/overlayfs/super.c +1 -1
index e19940d649ca..efbf0b291551 100644
@@ -1322,7 +1322,7 @@ int ovl_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (WARN_ON(fc->user_ns != current_user_ns()))
 		goto out_err;
 
-	sb->s_d_op = &ovl_dentry_operations;
+	set_default_d_op(sb, &ovl_dentry_operations);
 
 	err = -ENOMEM;
 	if (!ofs->creator_cred)
fs/smb/client/cifsfs.c +2 -2
index 0a5266ecfd15..d4ec73359922 100644
@@ -260,9 +260,9 @@ cifs_read_super(struct super_block *sb)
 	}
 
 	if (tcon->nocase)
-		sb->s_d_op = &cifs_ci_dentry_ops;
+		set_default_d_op(sb, &cifs_ci_dentry_ops);
 	else
-		sb->s_d_op = &cifs_dentry_ops;
+		set_default_d_op(sb, &cifs_dentry_ops);
 
 	sb->s_root = d_make_root(inode);
 	if (!sb->s_root) {
fs/tracefs/inode.c +1 -1
index a3fd3cc591bd..c8ca61777323 100644
@@ -480,7 +480,7 @@ static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
 		return err;
 
 	sb->s_op = &tracefs_super_operations;
-	sb->s_d_op = &tracefs_dentry_operations;
+	set_default_d_op(sb, &tracefs_dentry_operations);
 
 	return 0;
 }
fs/vboxsf/super.c +1 -1
index 0bc96ab6580b..241647b060ee 100644
@@ -189,7 +189,7 @@ static int vboxsf_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize = 1024;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_op = &vboxsf_super_ops;
-	sb->s_d_op = &vboxsf_dentry_ops;
+	set_default_d_op(sb, &vboxsf_dentry_ops);
 
 	iroot = iget_locked(sb, 0);
 	if (!iroot) {
include/linux/dcache.h +2 -0
index 1993e6704552..be7ae058fa90 100644
@@ -607,4 +607,6 @@ static inline struct dentry *d_next_sibling(const struct dentry *dentry)
 	return hlist_entry_safe(dentry->d_sib.next, struct dentry, d_sib);
 }
 
+void set_default_d_op(struct super_block *, const struct dentry_operations *);
+
 #endif	/* __LINUX_DCACHE_H */
include/linux/fs.h +1 -1
index 96c7925a6551..7cd8eaab4d4e 100644
@@ -1413,7 +1413,7 @@ struct super_block {
 	 */
 	const char *s_subtype;
 
-	const struct dentry_operations *s_d_op; /* default d_op for dentries */
+	const struct dentry_operations *__s_d_op; /* default d_op for dentries */
 
 	struct shrinker *s_shrink;	/* per-sb shrinker handle */
 
mm/shmem.c +1 -1
index 0c5fb4ffa03a..3583508800fc 100644
@@ -5028,7 +5028,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	if (ctx->encoding) {
 		sb->s_encoding = ctx->encoding;
-		sb->s_d_op = &shmem_ci_dentry_ops;
+		set_default_d_op(sb, &shmem_ci_dentry_ops);
 		if (ctx->strict_encoding)
 			sb->s_encoding_flags = SB_ENC_STRICT_MODE_FL;
 	}
net/sunrpc/rpc_pipe.c +1 -1
index 98f78cd55905..f4e880383f67 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	sb->s_d_op = &simple_dentry_operations;
+	set_default_d_op(sb, &simple_dentry_operations);
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
author maintainer
#65 lore raw

PATCH v2 7/21 split d_flags calculation out of d_set_d_op()

In reply to Al Viro
---
 fs/dcache.c | 53 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 23 deletions(-)
fs/dcache.c +30 -23
index 2ed875558ccc..f998e26c9cd4 100644
@@ -1837,33 +1837,40 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 }
 EXPORT_SYMBOL(d_alloc_name);
 
+#define DCACHE_OP_FLAGS \
+	(DCACHE_OP_HASH | DCACHE_OP_COMPARE | DCACHE_OP_REVALIDATE | \
+	 DCACHE_OP_WEAK_REVALIDATE | DCACHE_OP_DELETE | DCACHE_OP_REAL)
+
+static unsigned int d_op_flags(const struct dentry_operations *op)
+{
+	unsigned int flags = 0;
+	if (op) {
+		if (op->d_hash)
+			flags |= DCACHE_OP_HASH;
+		if (op->d_compare)
+			flags |= DCACHE_OP_COMPARE;
+		if (op->d_revalidate)
+			flags |= DCACHE_OP_REVALIDATE;
+		if (op->d_weak_revalidate)
+			flags |= DCACHE_OP_WEAK_REVALIDATE;
+		if (op->d_delete)
+			flags |= DCACHE_OP_DELETE;
+		if (op->d_prune)
+			flags |= DCACHE_OP_PRUNE;
+		if (op->d_real)
+			flags |= DCACHE_OP_REAL;
+	}
+	return flags;
+}
+
 void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
+	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
-	WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH	|
-				DCACHE_OP_COMPARE	|
-				DCACHE_OP_REVALIDATE	|
-				DCACHE_OP_WEAK_REVALIDATE	|
-				DCACHE_OP_DELETE	|
-				DCACHE_OP_REAL));
+	WARN_ON_ONCE(dentry->d_flags & DCACHE_OP_FLAGS);
 	dentry->d_op = op;
-	if (!op)
-		return;
-	if (op->d_hash)
-		dentry->d_flags |= DCACHE_OP_HASH;
-	if (op->d_compare)
-		dentry->d_flags |= DCACHE_OP_COMPARE;
-	if (op->d_revalidate)
-		dentry->d_flags |= DCACHE_OP_REVALIDATE;
-	if (op->d_weak_revalidate)
-		dentry->d_flags |= DCACHE_OP_WEAK_REVALIDATE;
-	if (op->d_delete)
-		dentry->d_flags |= DCACHE_OP_DELETE;
-	if (op->d_prune)
-		dentry->d_flags |= DCACHE_OP_PRUNE;
-	if (op->d_real)
-		dentry->d_flags |= DCACHE_OP_REAL;
-
+	if (flags)
+		dentry->d_flags |= flags;
 }
 EXPORT_SYMBOL(d_set_d_op);
 
Signature · 1 line
2.39.5
author maintainer
#66 lore raw

PATCH v2 8/21 correct the set of flags forbidden at d_set_d_op() time

In reply to Al Viro

DCACHE_OP_PRUNE in ->d_flags at the time of d_set_d_op() should've been treated the same as any other DCACHE_OP_... - we forgot to adjust that WARN_ON() when DCACHE_OP_PRUNE had been introduced...

---
 fs/dcache.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
fs/dcache.c +2 -1
index f998e26c9cd4..27e6d2f36973 100644
@@ -1839,7 +1839,8 @@ EXPORT_SYMBOL(d_alloc_name);
 
 #define DCACHE_OP_FLAGS \
 	(DCACHE_OP_HASH | DCACHE_OP_COMPARE | DCACHE_OP_REVALIDATE | \
-	 DCACHE_OP_WEAK_REVALIDATE | DCACHE_OP_DELETE | DCACHE_OP_REAL)
+	 DCACHE_OP_WEAK_REVALIDATE | DCACHE_OP_DELETE | DCACHE_OP_PRUNE | \
+	 DCACHE_OP_REAL)
 
 static unsigned int d_op_flags(const struct dentry_operations *op)
 {
Signature · 1 line
2.39.5
maintainer Reviewed-by on v2 8/21
#67 lore raw

Re: [PATCH v2 08/21] correct the set of flags forbidden at d_set_d_op() time

Quoted 6 lines · Al Viro

DCACHE_OP_PRUNE in ->d_flags at the time of d_set_d_op() should've been treated the same as any other DCACHE_OP_... - we forgot to adjust that WARN_ON() when DCACHE_OP_PRUNE had been introduced...

---

author maintainer
#68 lore raw

PATCH v2 9/21 set_default_d_op(): calculate the matching value for ->d_flags

In reply to Al Viro

... and store it in ->s_d_flags, to be used by __d_alloc()

---
 fs/dcache.c        | 6 ++++--
 include/linux/fs.h | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)
fs/dcache.c +4 -2
index 27e6d2f36973..7519c5f66f79 100644
@@ -1731,14 +1731,14 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
 	dentry->d_inode = NULL;
 	dentry->d_parent = dentry;
 	dentry->d_sb = sb;
-	dentry->d_op = NULL;
+	dentry->d_op = sb->__s_d_op;
+	dentry->d_flags = sb->s_d_flags;
 	dentry->d_fsdata = NULL;
 	INIT_HLIST_BL_NODE(&dentry->d_hash);
 	INIT_LIST_HEAD(&dentry->d_lru);
 	INIT_HLIST_HEAD(&dentry->d_children);
 	INIT_HLIST_NODE(&dentry->d_u.d_alias);
 	INIT_HLIST_NODE(&dentry->d_sib);
-	d_set_d_op(dentry, dentry->d_sb->__s_d_op);
 
 	if (dentry->d_op && dentry->d_op->d_init) {
 		err = dentry->d_op->d_init(dentry);
@@ -1877,7 +1877,9 @@ EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
+	unsigned int flags = d_op_flags(ops);
 	s->__s_d_op = ops;
+	s->s_d_flags = (s->s_d_flags & ~DCACHE_OP_FLAGS) | flags;
 }
 EXPORT_SYMBOL(set_default_d_op);
 
include/linux/fs.h +1 -0
index 7cd8eaab4d4e..65548e70e596 100644
@@ -1400,6 +1400,7 @@ struct super_block {
 	char			s_sysfs_name[UUID_STRING_LEN + 1];
 
 	unsigned int		s_max_links;
+	unsigned int		s_d_flags;	/* default d_flags for dentries */
 
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
Signature · 1 line
2.39.5
author maintainer
#69 lore raw

PATCH v2 10/21 simple_lookup(): just set DCACHE_DONTCACHE

In reply to Al Viro

No need to mess with ->d_op at all. Note that ->d_delete that always returns 1 is equivalent to having DCACHE_DONTCACHE in ->d_flags. Later the same thing will be placed into ->s_d_flags of the filesystems where we want that behaviour for all dentries; then the check in simple_lookup() will at least get unlikely() slapped on it.

NOTE: there are only two filesystems where
* simple_lookup() might be called
* default ->d_op is non-NULL
* its ->d_delete() doesn't always return 1
If not for those, we could have simple_lookup() just set DCACHE_DONTCACHE without even looking at ->d_op. Filesystems in question are btrfs (where ->d_delete() takes care to recognize the dentries that might come from simple_lookup() and returns 1 for those) and tracefs.

The former would be fine with simple_lookup() setting DCACHE_DONTCACHE; the latter... probably wants DCACHE_DONTCACHE in default d_flags.

IOW, we might want to drop the check for ->d_op in simple_lookup(); it's definitely a separate story, though.

---
 fs/libfs.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
fs/libfs.c +5 -3
index ab82de070310..19cc12651708 100644
@@ -75,9 +75,11 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned
 {
 	if (dentry->d_name.len > NAME_MAX)
 		return ERR_PTR(-ENAMETOOLONG);
-	if (!dentry->d_op)
-		d_set_d_op(dentry, &simple_dentry_operations);
-
+	if (!dentry->d_op && !(dentry->d_flags & DCACHE_DONTCACHE)) {
+		spin_lock(&dentry->d_lock);
+		dentry->d_flags |= DCACHE_DONTCACHE;
+		spin_unlock(&dentry->d_lock);
+	}
 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))
 		return NULL;
 
Signature · 1 line
2.39.5
maintainer Reviewed-by on v2 10/21
#70 lore raw

Re: [PATCH v2 10/21] simple_lookup(): just set DCACHE_DONTCACHE

Quoted 15 lines · Al Viro

No need to mess with ->d_op at all. Note that ->d_delete that always returns 1 is equivalent to having DCACHE_DONTCACHE in ->d_flags. Later the same thing will be placed into ->s_d_flags of the filesystems where we want that behaviour for all dentries; then the check in simple_lookup() will at least get unlikely() slapped on it.

NOTE: there are only two filesystems where
* simple_lookup() might be called
* default ->d_op is non-NULL
* its ->d_delete() doesn't always return 1
If not for those, we could have simple_lookup() just set DCACHE_DONTCACHE without even looking at ->d_op. Filesystems in question are btrfs (where ->d_delete() takes care to recognize the dentries that might come from simple_lookup() and returns 1 for those) and tracefs.

Quoted 8 lines

The former would be fine with simple_lookup() setting DCACHE_DONTCACHE; the latter... probably wants DCACHE_DONTCACHE in default d_flags.

IOW, we might want to drop the check for ->d_op in simple_lookup(); it's definitely a separate story, though.

---

author maintainer
#71 lore raw

PATCH v2 11/21 make d_set_d_op() static

In reply to Al Viro

Convert the last user (d_alloc_pseudo()) and be done with that. Any out-of-tree filesystem using it should switch to d_splice_alias_ops() or, better yet, check whether it really needs to have ->d_op vary among its dentries.

---
 Documentation/filesystems/porting.rst | 11 +++++++++++
 fs/dcache.c                           |  6 +++---
 include/linux/dcache.h                |  1 -
 3 files changed, 14 insertions(+), 4 deletions(-)
Documentation/filesystems/porting.rst +11 -0
index b16139e91942..579f17df46cf 100644
@@ -1256,3 +1256,14 @@ an extra reference to new mount - it should be returned with refcount 1.
 
 If your filesystem sets the default dentry_operations, use set_default_d_op()
 rather than manually setting sb->s_d_op.
+
+---
+
+**mandatory**
+
+d_set_d_op() is no longer exported (or public, for that matter); _if_
+your filesystem really needed that, make use of d_splice_alias_ops()
+to have them set.  Better yet, think hard whether you need different
+->d_op for different dentries - if not, just use set_default_d_op()
+at mount time and be done with that.  Currently procfs is the only
+thing that really needs ->d_op varying between dentries.
fs/dcache.c +3 -3
index 7519c5f66f79..4e6ab27471a4 100644
@@ -1821,8 +1821,9 @@ struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
 	struct dentry *dentry = __d_alloc(sb, name);
 	if (likely(dentry)) {
 		dentry->d_flags |= DCACHE_NORCU;
+		/* d_op_flags(&anon_ops) is 0 */
 		if (!dentry->d_op)
-			d_set_d_op(dentry, &anon_ops);
+			dentry->d_op = &anon_ops;
 	}
 	return dentry;
 }
@@ -1864,7 +1865,7 @@ static unsigned int d_op_flags(const struct dentry_operations *op)
 	return flags;
 }
 
-void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
+static void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 {
 	unsigned int flags = d_op_flags(op);
 	WARN_ON_ONCE(dentry->d_op);
@@ -1873,7 +1874,6 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 	if (flags)
 		dentry->d_flags |= flags;
 }
-EXPORT_SYMBOL(d_set_d_op);
 
 void set_default_d_op(struct super_block *s, const struct dentry_operations *ops)
 {
include/linux/dcache.h +0 -1
index be7ae058fa90..cc3e1c1a3454 100644
@@ -237,7 +237,6 @@ extern void d_instantiate_new(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
 extern void d_delete(struct dentry *);
-extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
Signature · 1 line
2.39.5
author maintainer
#72 lore raw

PATCH v2 12/21 d_alloc_parallel(): set DCACHE_PAR_LOOKUP earlier

In reply to Al Viro

Do that before new dentry is visible anywhere. It does create a new possible state for dentries present in ->d_children/->d_sib - DCACHE_PAR_LOOKUP present, negative, unhashed, not in in-lookup hash chains, refcount positive. Those are going to be skipped by all tree-walkers (both d_walk() callbacks in fs/dcache.c and explicit loops over children/sibling lists elsewhere) and dput() is fine with those.

NOTE: dropping the final reference to a "normal" in-lookup dentry (in in-lookup hash) is a bug - somebody must've forgotten to call d_lookup_done() on it and bad things will happen. With those it's OK; if/when we get around to making __dentry_kill() complain about such breakage, remember that predicate to check should *not* be just d_in_lookup(victim) but rather a combination of that with !hlist_bl_unhashed(&victim->d_u.d_in_lookup_hash). Might be worth considering later...

---
 fs/dcache.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)
fs/dcache.c +7 -3
index 4e6ab27471a4..2adac023ba23 100644
@@ -2546,13 +2546,19 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 	unsigned int hash = name->hash;
 	struct hlist_bl_head *b = in_lookup_hash(parent, hash);
 	struct hlist_bl_node *node;
-	struct dentry *new = d_alloc(parent, name);
+	struct dentry *new = __d_alloc(parent->d_sb, name);
 	struct dentry *dentry;
 	unsigned seq, r_seq, d_seq;
 
 	if (unlikely(!new))
 		return ERR_PTR(-ENOMEM);
 
+	new->d_flags |= DCACHE_PAR_LOOKUP;
+	spin_lock(&parent->d_lock);
+	new->d_parent = dget_dlock(parent);
+	hlist_add_head(&new->d_sib, &parent->d_children);
+	spin_unlock(&parent->d_lock);
+
 retry:
 	rcu_read_lock();
 	seq = smp_load_acquire(&parent->d_inode->i_dir_seq);
@@ -2636,8 +2642,6 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 		return dentry;
 	}
 	rcu_read_unlock();
-	/* we can't take ->d_lock here; it's OK, though. */
-	new->d_flags |= DCACHE_PAR_LOOKUP;
 	new->d_wait = wq;
 	hlist_bl_add_head(&new->d_u.d_in_lookup_hash, b);
 	hlist_bl_unlock(b);
Signature · 1 line
2.39.5
author maintainer
#73 lore raw

PATCH v2 13/21 shmem: no dentry retention past the refcount reaching zero

In reply to Al Viro

Just set DCACHE_DONTCACHE in ->s_d_flags and be done with that. Dentries there live for as long as they are pinned; once the refcount hits zero, that's it. The same, of course, goes for other tree-in-dcache filesystems - more in the next commits...

---
 mm/shmem.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
mm/shmem.c +1 -1
index 3583508800fc..94b2b4264607 100644
@@ -4980,7 +4980,6 @@ static void shmem_put_super(struct super_block *sb)
 static const struct dentry_operations shmem_ci_dentry_ops = {
 	.d_hash = generic_ci_d_hash,
 	.d_compare = generic_ci_d_compare,
-	.d_delete = always_delete_dentry,
 };
 #endif
 
@@ -5037,6 +5036,7 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
 #else
 	sb->s_flags |= SB_NOUSER;
 #endif /* CONFIG_TMPFS */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sbinfo->max_blocks = ctx->blocks;
 	sbinfo->max_inodes = ctx->inodes;
 	sbinfo->free_ispace = sbinfo->max_inodes * BOGO_INODE_SIZE;
Signature · 1 line
2.39.5
author maintainer
#74 lore raw

PATCH v2 14/21 devpts, sunrpc, hostfs: don't bother with ->d_op

In reply to Al Viro

Default ->d_op being simple_dentry_operations is equivalent to leaving it NULL and putting DCACHE_DONTCACHE into ->s_d_flags.

---
 fs/devpts/inode.c       | 2 +-
 fs/hostfs/hostfs_kern.c | 2 +-
 net/sunrpc/rpc_pipe.c   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
fs/devpts/inode.c +1 -1
index fd17992ee298..fdf22264a8e9 100644
@@ -381,7 +381,7 @@ static int devpts_fill_super(struct super_block *s, struct fs_context *fc)
 	s->s_blocksize_bits = 10;
 	s->s_magic = DEVPTS_SUPER_MAGIC;
 	s->s_op = &devpts_sops;
-	set_default_d_op(s, &simple_dentry_operations);
+	s->s_d_flags = DCACHE_DONTCACHE;
 	s->s_time_gran = 1;
 	fsi->sb = s;
 
fs/hostfs/hostfs_kern.c +1 -1
index 1c0f5038e19c..1f512f8ea757 100644
@@ -933,7 +933,7 @@ static int hostfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = 10;
 	sb->s_magic = HOSTFS_SUPER_MAGIC;
 	sb->s_op = &hostfs_sbops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	err = super_setup_bdi(sb);
 	if (err)
net/sunrpc/rpc_pipe.c +1 -1
index f4e880383f67..b85537191f8f 100644
@@ -1363,7 +1363,7 @@ rpc_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = RPCAUTH_GSSMAGIC;
 	sb->s_op = &s_ops;
-	set_default_d_op(sb, &simple_dentry_operations);
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	inode = rpc_get_inode(sb, S_IFDIR | 0555);
Signature · 1 line
2.39.5
author maintainer
#76 lore raw

PATCH v2 15/21 kill simple_dentry_operations

In reply to Al Viro

No users left and anything that wants it would be better off just setting DCACHE_DONTCACHE in their ->s_d_flags.

---
 fs/libfs.c         | 5 -----
 include/linux/fs.h | 1 -
 2 files changed, 6 deletions(-)
fs/libfs.c +0 -5
index 19cc12651708..3051211998b6 100644
@@ -62,11 +62,6 @@ int always_delete_dentry(const struct dentry *dentry)
 }
 EXPORT_SYMBOL(always_delete_dentry);
 
-const struct dentry_operations simple_dentry_operations = {
-	.d_delete = always_delete_dentry,
-};
-EXPORT_SYMBOL(simple_dentry_operations);
-
 /*
  * Lookup the data. This is trivial - if the dentry didn't already
  * exist, we know it is negative.  Set d_op to delete negative dentries.
include/linux/fs.h +0 -1
index 65548e70e596..d58bbb8262e8 100644
@@ -3606,7 +3606,6 @@ extern const struct address_space_operations ram_aops;
 extern int always_delete_dentry(const struct dentry *);
 extern struct inode *alloc_anon_inode(struct super_block *);
 extern int simple_nosetlease(struct file *, int, struct file_lease **, void **);
-extern const struct dentry_operations simple_dentry_operations;
 
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
Signature · 1 line
2.39.5
author maintainer
#77 lore raw

PATCH v2 16/21 ramfs, hugetlbfs, mqueue: set DCACHE_DONTCACHE

In reply to Al Viro

makes simple_lookup() slightly cheaper there - no need for simple_lookup() to set the flag and we want it on everything on those anyway.

---
 fs/hugetlbfs/inode.c | 1 +
 fs/ramfs/inode.c     | 1 +
 ipc/mqueue.c         | 1 +
 3 files changed, 3 insertions(+)
fs/hugetlbfs/inode.c +1 -0
index e4de5425838d..6e0ade365a33 100644
@@ -1433,6 +1433,7 @@ hugetlbfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = huge_page_shift(ctx->hstate);
 	sb->s_magic = HUGETLBFS_MAGIC;
 	sb->s_op = &hugetlbfs_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 	sb->s_time_gran = 1;
 
 	/*
fs/ramfs/inode.c +1 -0
index 775fa905fda0..f8874c3b8c1e 100644
@@ -269,6 +269,7 @@ static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits	= PAGE_SHIFT;
 	sb->s_magic		= RAMFS_MAGIC;
 	sb->s_op		= &ramfs_ops;
+	sb->s_d_flags		= DCACHE_DONTCACHE;
 	sb->s_time_gran		= 1;
 
 	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
ipc/mqueue.c +1 -0
index 82ed2d3c9846..482af449e00d 100644
@@ -411,6 +411,7 @@ static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_blocksize_bits = PAGE_SHIFT;
 	sb->s_magic = MQUEUE_MAGIC;
 	sb->s_op = &mqueue_super_ops;
+	sb->s_d_flags = DCACHE_DONTCACHE;
 
 	inode = mqueue_get_inode(sb, ns, S_IFDIR | S_ISVTX | S_IRWXUGO, NULL);
 	if (IS_ERR(inode))
Signature · 1 line
2.39.5
author maintainer
#78 lore raw

PATCH v2 17/21 9p: don't bother with always_delete_dentry

In reply to Al Viro

just set DCACHE_DONTCACHE for "don't cache" mounts...

---
 fs/9p/vfs_dentry.c | 1 -
 fs/9p/vfs_super.c  | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)
fs/9p/vfs_dentry.c +0 -1
index 5061f192eafd..04795508a795 100644
@@ -127,7 +127,6 @@ const struct dentry_operations v9fs_cached_dentry_operations = {
 };
 
 const struct dentry_operations v9fs_dentry_operations = {
-	.d_delete = always_delete_dentry,
 	.d_release = v9fs_dentry_release,
 	.d_unalias_trylock = v9fs_dentry_unalias_trylock,
 	.d_unalias_unlock = v9fs_dentry_unalias_unlock,
fs/9p/vfs_super.c +4 -2
index 5c3dc3efb909..795c6388744c 100644
@@ -134,10 +134,12 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
 	if (retval)
 		goto release_sb;
 
-	if (v9ses->cache & (CACHE_META|CACHE_LOOSE))
+	if (v9ses->cache & (CACHE_META|CACHE_LOOSE)) {
 		set_default_d_op(sb, &v9fs_cached_dentry_operations);
-	else
+	} else {
 		set_default_d_op(sb, &v9fs_dentry_operations);
+		sb->s_d_flags |= DCACHE_DONTCACHE;
+	}
 
 	inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);
 	if (IS_ERR(inode)) {
Signature · 1 line
2.39.5
author maintainer
#79 lore raw

PATCH v2 18/21 efivarfs: use DCACHE_DONTCACHE instead of always_delete_dentry()

In reply to Al Viro
---
 fs/efivarfs/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/efivarfs/super.c +1 -1
index f76d8dfa646b..23ff4e873651 100644
@@ -183,7 +183,6 @@ static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 static const struct dentry_operations efivarfs_d_ops = {
 	.d_compare = efivarfs_d_compare,
 	.d_hash = efivarfs_d_hash,
-	.d_delete = always_delete_dentry,
 };
 
 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
@@ -351,6 +350,7 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	sb->s_magic             = EFIVARFS_MAGIC;
 	sb->s_op                = &efivarfs_ops;
 	set_default_d_op(sb, &efivarfs_d_ops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	sb->s_time_gran         = 1;
 
 	if (!efivar_supports_writes())
Signature · 1 line
2.39.5
author maintainer
#80 lore raw

PATCH v2 19/21 debugfs: use DCACHE_DONTCACHE

In reply to Al Viro
---
 fs/debugfs/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/debugfs/inode.c +1 -1
index 29c5ec382342..441e3547a4f3 100644
@@ -258,7 +258,6 @@ static struct vfsmount *debugfs_automount(struct path *path)
 }
 
 static const struct dentry_operations debugfs_dops = {
-	.d_delete = always_delete_dentry,
 	.d_release = debugfs_release_dentry,
 	.d_automount = debugfs_automount,
 };
@@ -274,6 +273,7 @@ static int debugfs_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	sb->s_op = &debugfs_super_operations;
 	set_default_d_op(sb, &debugfs_dops);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 
 	debugfs_apply_options(sb);
 
Signature · 1 line
2.39.5
author maintainer
#81 lore raw

PATCH v2 20/21 configfs: use DCACHE_DONTCACHE

In reply to Al Viro
---
 fs/configfs/dir.c   | 1 -
 fs/configfs/mount.c | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)
fs/configfs/dir.c +0 -1
index ebf32822e29b..f327fbb9a0ca 100644
@@ -67,7 +67,6 @@ static void configfs_d_iput(struct dentry * dentry,
 
 const struct dentry_operations configfs_dentry_ops = {
 	.d_iput		= configfs_d_iput,
-	.d_delete	= always_delete_dentry,
 };
 
 #ifdef CONFIG_LOCKDEP
fs/configfs/mount.c +1 -0
index 20412eaca972..740f18b60c9d 100644
@@ -93,6 +93,7 @@ static int configfs_fill_super(struct super_block *sb, struct fs_context *fc)
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
 	set_default_d_op(sb, &configfs_dentry_ops); /* the rest get that */
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 	return 0;
 }
 
Signature · 1 line
2.39.5
author maintainer
#82 lore raw

PATCH v2 21/21 tracefs: set DCACHE_DONTCACHE

In reply to Al Viro

*NOTE* - this does change behaviour; as it is, cache misses are hashed and retained there.

---
 fs/tracefs/inode.c | 1 +
 1 file changed, 1 insertion(+)
fs/tracefs/inode.c +1 -0
index c8ca61777323..40fa6220189d 100644
@@ -481,6 +481,7 @@ static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	sb->s_op = &tracefs_super_operations;
 	set_default_d_op(sb, &tracefs_dentry_operations);
+	sb->s_d_flags |= DCACHE_DONTCACHE;
 
 	return 0;
 }
Signature · 1 line
2.39.5
#84 lore raw
In reply to Al Viro
Quoted 2 lines

Or are you talking about DCACHE_DONTCACHE (i.e. "unhash as soon as refcount hits 0", rather than "never hash it at all")?

Yes. The series is doing exactly that.

maintainer
#85 lore raw
In reply to Al Viro
Quoted 11 lines · Al Viro

PS: turns out that set_default_d_op() is slightly more interesting than I expected - fuse has separate dentry_operations for its root dentry. I don't see the point, TBH - the only difference is that root one lacks
* ->d_delete() (never even called for root dentry; it's
only called if d_unhashed() is false)
* ->d_revalidate() (never called for root)
* ->d_automount() (not even looked at unless you have
S_AUTOMOUNT set on the inode).
What's wrong with using fuse_dentry_operations for root dentry? Am I missing something subtle here? Miklos?

Looks like a historical accident:

- initial version only had .d_revalidate and only set d_op in .loookup.
- then it grew .d_init/.d_release
- then, as a bugfix, the separate fuse_root_dentry_operations was added

Will fix.

Thanks,
Miklos

author maintainer
#86 lore raw
Quoted 14 lines · Miklos Szeredi
Quoted 11 lines · Al Viro

PS: turns out that set_default_d_op() is slightly more interesting than I expected - fuse has separate dentry_operations for its root dentry. I don't see the point, TBH - the only difference is that root one lacks
* ->d_delete() (never even called for root dentry; it's
only called if d_unhashed() is false)
* ->d_revalidate() (never called for root)
* ->d_automount() (not even looked at unless you have
S_AUTOMOUNT set on the inode).
What's wrong with using fuse_dentry_operations for root dentry? Am I missing something subtle here? Miklos?

Quoted 5 lines

Looks like a historical accident:

- initial version only had .d_revalidate and only set d_op in .loookup.
- then it grew .d_init/.d_release
- then, as a bugfix, the separate fuse_root_dentry_operations was added

Speaking of historical accidents - "seqlock: Add a new locking reader type" (introduction of read_seqlock_excl()) happened a week after your "vfs: check unlinked ancestors before mount" (Sep 12 and Sep 5 2013, resp.)

I'm switching d_set_mounted() from write_seqlock(&rename_lock); to read_seqlock_excl(&rename_lock) - we need exclusion with movers, but there's no need for anyone to retry ancestry chains or hash lookups just because we have marked something as a mountpoint.

IOW, it's a reader, not writer; we can't replace it with need_seqretry loop without more audit of d_mountpoint() callers I want to mess with at the moment[*], but exclusive reader is fine.

[*] the ones under ->d_lock are not a problem and so are all that are followed by "check if something's mounted in our namespace, ignore if there isn't" as well as the ones that have an exclusion with the caller of d_set_mounted(), but for now let's not go there.