namei: fix revalidate vs. rename race
RFC PATCH 1/1 namei: fix revalidate vs. rename race
If a path component is revalidated while a rename is in progress the filesystem might find the already exchanged files, while the kernel still has the old ones in dcache (d_revalidate may be called without any locks). This mismatch will cause the dentry to be invalidated (unhashed), resulting in "(deleted)" being appended to proc paths and submounts unmounted.
Another race introduced by commit 5be1fa8abd7b ("Pass parent directory inode and expected name to ->d_revalidate()") is that the name passed to revalidate can be stale (rename succeeded after the dentry was looked up in the dcache).
Solve this by
a) samping dentry->d_seq when the dentry is looked up from the cache
b) setting a DCACHE_RENAMING flag on the dentry during rename
c) verifying in d_invalidate() that the sequence number is unchanged and no rename is happening
This should also fix race with d_splice_alias() moving the dentry.
--- fs/dcache.c | 81 +++++++++++++++++++++++++++++++++++------- fs/internal.h | 3 +- fs/namei.c | 41 +++++++++++++++++---- include/linux/dcache.h | 5 +++ 4 files changed, 110 insertions(+), 20 deletions(-)
fs/dcache.c +69 -12
@@ -1636,14 +1636,10 @@ static enum d_walk_ret find_submount(void *_data, struct dentry *dentry)return D_WALK_CONTINUE ; } -/** -* d_invalidate - detach submounts, prune dcache, and drop -* @dentry: dentry to invalidate (aka detach, prune and drop) -*/ -void d_invalidate (struct dentry *dentry) +static void d_invalidate_locked (struct dentry *dentry) {bool had_submounts = false; -spin_lock (&dentry->d_lock); +if (d_unhashed (dentry)) {spin_unlock (&dentry->d_lock);return ;
@@ -1669,8 +1665,47 @@ void d_invalidate(struct dentry *dentry)dput (victim); } } + +/** +* d_invalidate - detach submounts, prune dcache, and drop +* @dentry: dentry to invalidate (aka detach, prune and drop) +*/ +void d_invalidate (struct dentry *dentry) +{ +spin_lock (&dentry->d_lock); +d_invalidate_locked (dentry); +}EXPORT_SYMBOL (d_invalidate); +/** +* d_invalidate_reval - conditionally invalidate a dentry for revalidation +* @dentry: dentry to conditionally invalidate +* @seq: sequence number sampled during dentry lookup +* +* Check if the dentry has been renamed since the sequence number was sampled +* or if it's currently being renamed. If either condition is true, skip the +* invalidation to avoid the race between dentry revalidation and renames. +*/ +void d_invalidate_reval (struct dentry *dentry,unsigned int seq) +{ +spin_lock (&dentry->d_lock); + +/* Check if dentry is currently being renamed */ +if (dentry->d_flags &DCACHE_RENAMING ) { +spin_unlock (&dentry->d_lock); +return ; + } + +/* Check if dentry sequence has changed since sampling */ +if (read_seqcount_retry (&dentry->d_seq, seq)) { +spin_unlock (&dentry->d_lock); +return ; + } + +/* Safe to invalidate - no rename race detected */ +d_invalidate_locked (dentry); +} +/** * __d_alloc - allocate a dcache entry * @sb: filesystem it will belong to
@@ -2329,19 +2364,24 @@ struct dentry *__d_lookup_rcu(const struct dentry *parent,* dentry is returned. The caller must use dput to free the entry when it has * finished using it. %NULL is returned if the dentry does not exist. */ -struct dentry *d_lookup (const struct dentry *parent,const struct qstr *name) +struct dentry *d_lookup_seq (const struct dentry *parent,const struct qstr *name,unsigned int *d_seq) {struct dentry *dentry;unsigned seq;do { seq =read_seqbegin (&rename_lock); - dentry =__d_lookup (parent, name); + dentry =__d_lookup (parent, name, d_seq);if (dentry)break ; }while (read_seqretry (&rename_lock, seq));return dentry; } + +struct dentry *d_lookup (const struct dentry *parent,const struct qstr *name) +{ +return d_lookup_seq (parent, name,NULL ); +}EXPORT_SYMBOL (d_lookup);/**
@@ -2359,7 +2399,8 @@ EXPORT_SYMBOL(d_lookup);* * __d_lookup callers must be commented. */ -struct dentry *__d_lookup (const struct dentry *parent,const struct qstr *name) +struct dentry *__d_lookup (const struct dentry *parent,const struct qstr *name, +unsigned int *seq) {unsigned int hash = name->hash;struct hlist_bl_head *b =d_hash (hash);
@@ -2404,6 +2445,8 @@ struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name) goto next; dentry->d_lockref.count++; +if (seq) + *seq =raw_seqcount_begin (&dentry->d_seq); found = dentry;spin_unlock (&dentry->d_lock);break ;
@@ -2539,9 +2582,10 @@ static void d_wait_lookup(struct dentry *dentry) } } -struct dentry *d_alloc_parallel (struct dentry *parent, -const struct qstr *name, -wait_queue_head_t *wq) +struct dentry *__d_alloc_parallel (struct dentry *parent, +const struct qstr *name, +wait_queue_head_t *wq, +unsigned int *seqp) {unsigned int hash = name->hash;struct hlist_bl_head *b =in_lookup_hash (parent, hash);
@@ -2575,6 +2619,8 @@ struct dentry *d_alloc_parallel(struct dentry *parent, goto retry; }rcu_read_unlock (); +if (seqp) + *seqp = d_seq;dput (new);return dentry; }
@@ -2637,6 +2683,8 @@ struct dentry *d_alloc_parallel(struct dentry *parent,if (unlikely (!d_same_name (dentry, parent, name))) goto mismatch;/* OK, it *is* a hashed match; return it */ +if (seqp) + *seqp =read_seqcount_begin (&dentry->d_seq);spin_unlock (&dentry->d_lock);dput (new);return dentry;
@@ -2645,12 +2693,21 @@ struct dentry *d_alloc_parallel(struct dentry *parent, new->d_wait = wq;hlist_bl_add_head (&new->d_u.d_in_lookup_hash, b);hlist_bl_unlock (b); +if (seqp) + *seqp =read_seqcount_begin (&new->d_seq);return new; mismatch:spin_unlock (&dentry->d_lock);dput (dentry); goto retry; } + +struct dentry *d_alloc_parallel (struct dentry *parent, +const struct qstr *name, +wait_queue_head_t *wq) +{ +return __d_alloc_parallel (parent, name, wq,NULL ); +}EXPORT_SYMBOL (d_alloc_parallel);/*
fs/internal.h +2 -1
@@ -224,7 +224,8 @@ extern char *simple_dname(struct dentry *, char *, int);extern void dput_to_list (struct dentry *,struct list_head *);extern void shrink_dentry_list (struct list_head *);extern void shrink_dcache_for_umount (struct super_block *); -extern struct dentry *__d_lookup (const struct dentry *,const struct qstr *); +extern struct dentry *__d_lookup (const struct dentry *parent, +const struct qstr *name,unsigned int *seq);extern struct dentry *__d_lookup_rcu (const struct dentry *parent,const struct qstr *name,unsigned *seq);extern void d_genocide (struct dentry *);
fs/namei.c +34 -7
102 lines not on this page · raw message
include/linux/dcache.h +5 -0
@@ -222,6 +222,7 @@ enum dentry_flags {DCACHE_PAR_LOOKUP =BIT (24 ),/* being looked up (with parent locked shared) */ DCACHE_DENTRY_CURSOR =BIT (25 ),DCACHE_NORCU =BIT (26 ),/* No RCU delay for freeing */ + DCACHE_RENAMING = BIT(27), /* dentry is being renamed */ };#define DCACHE_MANAGED_DENTRY \
@@ -243,6 +244,8 @@ extern struct dentry * d_alloc(struct dentry *, const struct qstr *);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_alloc_parallel (struct dentry *,const struct qstr *, +wait_queue_head_t *,unsigned int *);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 *,
@@ -256,6 +259,7 @@ extern struct dentry * d_obtain_root(struct inode *);extern void shrink_dcache_sb (struct super_block *);extern void shrink_dcache_parent (struct dentry *);extern void d_invalidate (struct dentry *); +extern void d_invalidate_reval (struct dentry *,unsigned int );/* only used at mount-time */ extern struct dentry *d_make_root (struct inode *);
@@ -284,6 +288,7 @@ extern void d_exchange(struct dentry *, struct dentry *);extern struct dentry *d_ancestor (struct dentry *,struct dentry *);extern struct dentry *d_lookup (const struct dentry *,const struct qstr *); +extern struct dentry *d_lookup_seq (const struct dentry *parent,const struct qstr *name,unsigned int *d_seq);static inline unsigned d_count (const struct dentry *dentry) {
Signature · 1 line
2.51.0
Quoted 13 lines · Miklos Szeredi
If a path component is revalidated while a rename is in progress the filesystem might find the already exchanged files, while the kernel still has the old ones in dcache (
d_revalidatemay be called without any locks). This mismatch will cause the dentry to be invalidated (unhashed), resulting in "(deleted)" being appended to proc paths and submounts unmounted.Another race introduced by commit
5be1fa8abd7b("Pass parent directory inode and expected name to ->d_revalidate()") is that the name passed to revalidate can be stale (rename succeeded after the dentry was looked up in the dcache).Solve this by
Quoted 8 lines
a) samping
dentry->d_seqwhen the dentry is looked up from the cacheb) setting a
DCACHE_RENAMINGflag on the dentry during renamec) verifying in
d_invalidate()that the sequence number is unchanged and no rename is happeningThis should also fix race with
d_splice_alias()moving the dentry.
I think this makes sense. The DCACHE_RENAMING flag is a good solution of the fact that d_seq isn't changed until *after* the rename has happened on the server.
However this change means that the dentry isn't invalidated where the code currently expects that it will be. i.e. lookup_dcache() can return NULL when there is still a perfectly valid dentry. Does this matter?
It can only happen when the parent isn't locked and when it does happen, current code will lock that parent and repeat the lookup.
So if we simplified the change to only call d_invalidate() if we have the parent locked, then that will almost work.
The remaining gap is that directories can be renamed by d_splice_alias() while the parent is locked shared. I think that is a different problem that would be best served with a different, more focused, solution.
So, at present, I would be in favour of duplicating lookup_dcache() to lookup_dcache_locked() and call lookup_dcache() only when parent isn't locked.
Then removed the d_invalidate() calls after a failing d_revalidate() in cases where the parent isn't locked.
I think that is a simple solution that gets us most of what we need.
Then we can dig more into what we really want when a directory gets moved on the server and how that gets noticed.
Thanks,
NeilBrown
Quoted 346 lines
Suggested-by NeilBrown <[email protected]>Signed-off-by Miklos Szeredi <[email protected]>--- fs/dcache.c | 81 +++++++++++++++++++++++++++++++++++------- fs/internal.h | 3 +- fs/namei.c | 41 +++++++++++++++++---- include/linux/dcache.h | 5 +++ 4 files changed, 110 insertions(+), 20 deletions(-)fs/dcache.c +69
-12@@ -1636,14 +1636,10 @@ static enum d_walk_ret find_submount(void *_data, struct dentry *dentry)return D_WALK_CONTINUE ; } -/** -* d_invalidate - detach submounts, prune dcache, and drop -* @dentry: dentry to invalidate (aka detach, prune and drop) -*/ -void d_invalidate (struct dentry *dentry) +static void d_invalidate_locked (struct dentry *dentry) {bool had_submounts = false; -spin_lock (&dentry->d_lock); +if (d_unhashed (dentry)) {spin_unlock (&dentry->d_lock);return ;@@ -1669,8 +1665,47 @@ void d_invalidate(struct dentry *dentry)dput (victim); } } + +/** +* d_invalidate - detach submounts, prune dcache, and drop +* @dentry: dentry to invalidate (aka detach, prune and drop) +*/ +void d_invalidate (struct dentry *dentry) +{ +spin_lock (&dentry->d_lock); +d_invalidate_locked (dentry); +}EXPORT_SYMBOL (d_invalidate); +/** +* d_invalidate_reval - conditionally invalidate a dentry for revalidation +* @dentry: dentry to conditionally invalidate +* @seq: sequence number sampled during dentry lookup +* +* Check if the dentry has been renamed since the sequence number was sampled +* or if it's currently being renamed. If either condition is true, skip the +* invalidation to avoid the race between dentry revalidation and renames. +*/ +void d_invalidate_reval (struct dentry *dentry,unsigned int seq) +{ +spin_lock (&dentry->d_lock); + +/* Check if dentry is currently being renamed */ +if (dentry->d_flags &DCACHE_RENAMING ) { +spin_unlock (&dentry->d_lock); +return ; + } + +/* Check if dentry sequence has changed since sampling */ +if (read_seqcount_retry (&dentry->d_seq, seq)) { +spin_unlock (&dentry->d_lock); +return ; + } + +/* Safe to invalidate - no rename race detected */ +d_invalidate_locked (dentry); +} +/** * __d_alloc - allocate a dcache entry * @sb: filesystem it will belong to @@ -2329,19 +2364,24 @@ struct dentry *__d_lookup_rcu(const struct dentry *parent,* dentry is returned. The caller must use dput to free the entry when it has * finished using it. %NULL is returned if the dentry does not exist. */ -struct dentry *d_lookup (const struct dentry *parent,const struct qstr *name) +struct dentry *d_lookup_seq (const struct dentry *parent,const struct qstr *name,unsigned int *d_seq) {struct dentry *dentry;unsigned seq;do { seq =read_seqbegin (&rename_lock); - dentry =__d_lookup (parent, name); + dentry =__d_lookup (parent, name, d_seq);if (dentry)break ; }while (read_seqretry (&rename_lock, seq));return dentry; } + +struct dentry *d_lookup (const struct dentry *parent,const struct qstr *name) +{ +return d_lookup_seq (parent, name,NULL ); +}EXPORT_SYMBOL (d_lookup);/** @@ -2359,7 +2399,8 @@ EXPORT_SYMBOL(d_lookup);* * __d_lookup callers must be commented. */ -struct dentry *__d_lookup (const struct dentry *parent,const struct qstr *name) +struct dentry *__d_lookup (const struct dentry *parent,const struct qstr *name, +unsigned int *seq) {unsigned int hash = name->hash;struct hlist_bl_head *b =d_hash (hash);@@ -2404,6 +2445,8 @@ struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name) goto next; dentry->d_lockref.count++; +if (seq) + *seq =raw_seqcount_begin (&dentry->d_seq); found = dentry;spin_unlock (&dentry->d_lock);break ;@@ -2539,9 +2582,10 @@ static void d_wait_lookup(struct dentry *dentry) } } -struct dentry *d_alloc_parallel (struct dentry *parent, -const struct qstr *name, -wait_queue_head_t *wq) +struct dentry *__d_alloc_parallel (struct dentry *parent, +const struct qstr *name, +wait_queue_head_t *wq, +unsigned int *seqp) {unsigned int hash = name->hash;struct hlist_bl_head *b =in_lookup_hash (parent, hash);@@ -2575,6 +2619,8 @@ struct dentry *d_alloc_parallel(struct dentry *parent, goto retry; }rcu_read_unlock (); +if (seqp) + *seqp = d_seq;dput (new);return dentry; }@@ -2637,6 +2683,8 @@ struct dentry *d_alloc_parallel(struct dentry *parent,if (unlikely (!d_same_name (dentry, parent, name))) goto mismatch;/* OK, it *is* a hashed match; return it */ +if (seqp) + *seqp =read_seqcount_begin (&dentry->d_seq);spin_unlock (&dentry->d_lock);dput (new);return dentry;@@ -2645,12 +2693,21 @@ struct dentry *d_alloc_parallel(struct dentry *parent, new->d_wait = wq;hlist_bl_add_head (&new->d_u.d_in_lookup_hash, b);hlist_bl_unlock (b); +if (seqp) + *seqp =read_seqcount_begin (&new->d_seq);return new; mismatch:spin_unlock (&dentry->d_lock);dput (dentry); goto retry; } + +struct dentry *d_alloc_parallel (struct dentry *parent, +const struct qstr *name, +wait_queue_head_t *wq) +{ +return __d_alloc_parallel (parent, name, wq,NULL ); +}EXPORT_SYMBOL (d_alloc_parallel);/* fs/internal.h +2
-1@@ -224,7 +224,8 @@ extern char *simple_dname(struct dentry *, char *, int);extern void dput_to_list (struct dentry *,struct list_head *);extern void shrink_dentry_list (struct list_head *);extern void shrink_dcache_for_umount (struct super_block *); -extern struct dentry *__d_lookup (const struct dentry *,const struct qstr *); +extern struct dentry *__d_lookup (const struct dentry *parent, +const struct qstr *name,unsigned int *seq);extern struct dentry *__d_lookup_rcu (const struct dentry *parent,const struct qstr *name,unsigned *seq);extern void d_genocide (struct dentry *);fs/namei.c +34
-7@@ -1652,12 +1652,15 @@ static struct dentry *lookup_dcache(const struct qstr *name, struct dentry *dir, unsigned int flags) { -struct dentry *dentry =d_lookup (dir, name); +struct dentry *dentry; +unsigned int seq; + + dentry =d_lookup_seq (dir, name, &seq);if (dentry) {int error =d_revalidate (dir->d_inode, name, dentry, flags);if (unlikely (error <=0 )) {if (!error) -d_invalidate (dentry); +d_invalidate_reval (dentry, seq);dput (dentry);return ERR_PTR (error); }@@ -1763,14 +1766,14 @@ static struct dentry *lookup_fast(struct nameidata *nd) status =d_revalidate (nd->inode, &nd->last, dentry, nd->flags); }else { - dentry =__d_lookup (parent, &nd->last); + dentry =__d_lookup (parent, &nd->last, &nd->next_seq);if (unlikely (!dentry))return NULL ; status =d_revalidate (nd->inode, &nd->last, dentry, nd->flags); }if (unlikely (status <=0 )) {if (!status) -d_invalidate (dentry); +d_invalidate_reval (dentry, nd->next_seq);dput (dentry);return ERR_PTR (status); }@@ -1784,20 +1787,21 @@ static struct dentry *__lookup_slow(const struct qstr *name, {struct dentry *dentry, *old;struct inode *inode = dir->d_inode; +unsigned int seq;DECLARE_WAIT_QUEUE_HEAD_ONSTACK (wq);/* Don't go there if it's already dead */ if (unlikely (IS_DEADDIR (inode)))return ERR_PTR (-ENOENT ); again: - dentry =d_alloc_parallel (dir, name, &wq); + dentry =__d_alloc_parallel (dir, name, &wq, &seq);if (IS_ERR (dentry))return dentry;if (unlikely (!d_in_lookup (dentry))) {int error =d_revalidate (inode, name, dentry, flags);if (unlikely (error <=0 )) {if (!error) { -d_invalidate (dentry); +d_invalidate_reval (dentry, seq);dput (dentry); goto again; }@@ -4958,6 +4962,20 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newnamereturn do_linkat (AT_FDCWD ,getname (oldname),AT_FDCWD ,getname (newname),0 ); } +static void dentry_set_renaming (struct dentry *dentry) +{ +spin_lock (&dentry->d_lock); + dentry->d_flags |=DCACHE_RENAMING ; +spin_unlock (&dentry->d_lock); +} + +static void dentry_clear_renaming (struct dentry *dentry) +{ +spin_lock (&dentry->d_lock); + dentry->d_flags &= ~DCACHE_RENAMING ; +spin_unlock (&dentry->d_lock); +} +/** * vfs_rename - rename a filesystem object * @rd: pointer to &struct renamedata info @@ -5126,10 +5144,15 @@ int vfs_rename(struct renamedata *rd)if (error) goto out; } + +dentry_set_renaming (old_dentry); +if (flags &RENAME_EXCHANGE ) +dentry_set_renaming (new_dentry); + error = old_dir->i_op->rename (rd->new_mnt_idmap, old_dir, old_dentry, new_dir, new_dentry, flags);if (error) - goto out; + goto out_clear_renaming;if (!(flags &RENAME_EXCHANGE ) && target) {if (is_dir) {@@ -5145,6 +5168,10 @@ int vfs_rename(struct renamedata *rd)else d_exchange (old_dentry, new_dentry); } +out_clear_renaming: +dentry_clear_renaming (old_dentry); +if (flags &RENAME_EXCHANGE ) +dentry_clear_renaming (new_dentry); out:if (!is_dir || lock_old_subdir)inode_unlock (source);include/linux/dcache.h +5
-0@@ -222,6 +222,7 @@ enum dentry_flags {DCACHE_PAR_LOOKUP =BIT (24 ),/* being looked up (with parent locked shared) */ DCACHE_DENTRY_CURSOR =BIT (25 ),DCACHE_NORCU =BIT (26 ),/* No RCU delay for freeing */ + DCACHE_RENAMING = BIT(27), /* dentry is being renamed */ };#define DCACHE_MANAGED_DENTRY \@@ -243,6 +244,8 @@ extern struct dentry * d_alloc(struct dentry *, const struct qstr *);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_alloc_parallel (struct dentry *,const struct qstr *, +wait_queue_head_t *,unsigned int *);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 *,@@ -256,6 +259,7 @@ extern struct dentry * d_obtain_root(struct inode *);extern void shrink_dcache_sb (struct super_block *);extern void shrink_dcache_parent (struct dentry *);extern void d_invalidate (struct dentry *); +extern void d_invalidate_reval (struct dentry *,unsigned int );/* only used at mount-time */ extern struct dentry *d_make_root (struct inode *);@@ -284,6 +288,7 @@ extern void d_exchange(struct dentry *, struct dentry *);extern struct dentry *d_ancestor (struct dentry *,struct dentry *);extern struct dentry *d_lookup (const struct dentry *,const struct qstr *); +extern struct dentry *d_lookup_seq (const struct dentry *parent,const struct qstr *name,unsigned int *d_seq);static inline unsigned d_count (const struct dentry *dentry) {Signature · 1 line
2.51.0
Quoted 8 lines · NeilBrown
So, at present, I would be in favour of duplicating
lookup_dcache()tolookup_dcache_locked()and calllookup_dcache()only when parent isn't locked.
Then removed thed_invalidate()calls after a failingd_revalidate()in cases where the parent isn't locked.I think that is a simple solution that gets us most of what we need.
I've been reflecting on this and I'm now not sure sure it is quite right.
It would mean a ->d_revalidate() might do an expensive check when unlocked and it might then have to be repeated after taking the lock. So I think we need to tell ->d_revalidate() if the lock is held so that it can decide if it is worth do an expensive revalidation. We could achieve that by passing LOOKUP_RCU. This could be taken to mean "the parent is not locked". If '1' is returned we could still invalidate, but if -ECHILD were returned the revalidate would be retried with the parent locked.
That needs to provide a good balance to me - though would could introduce a new LOOKUP_UNLOCKED rather than overloading LOOKUP_RCU.
NeilBrown
Quoted 8 lines · NeilBrown
However this change means that the dentry isn't invalidated where the code currently expects that it will be. i.e.
lookup_dcache()can return NULL when there is still a perfectly valid dentry. Does this matter?
It can only happen when the parent isn't locked and when it does happen, current code will lock that parent and repeat the lookup.
So if we simplified the change to only calld_invalidate()if we have the parent locked, then that will almost work.
But why bother? This is a rare race, optimizing it makes no sense to me.
Quoted 3 lines
The remaining gap is that directories can be renamed by
d_splice_alias()while the parent is locked shared. I think that is a different problem that would be best served with a different, more focused, solution.
I'm not even sure anything needs to be fixed here. It's not possible
to fix the "race" between revalidation of old name and lookup of new name. At least not in the VFS.
Thanks,
Miklos
kernel test robot
build botkernel test robot noticed the following build warnings:
Hi Miklos,
[This is a private test report for your RFC patch.] kernel test robot noticed the following build warnings:
[auto build test WARNING on brauner-vfs/vfs.all]
[also build test WARNING on viro-vfs/for-next linus/master v6.17-rc6 next-20250919] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Miklos-Szeredi/namei-fix-revalidate-vs-rename-race/20250919-162113 base: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git vfs.all patch link: https://lore.kernel.org/r/20250919081843.522786-1-mszeredi%40redhat.com patch subject: [RFC PATCH] namei: fix revalidate vs. rename race config: x86_64-buildonly-randconfig-003-20250920 (https://download.01.org/0day-ci/archive/20250920/[email protected]/config) compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250920/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
>> Warning: fs/dcache.c:2403 function parameter 'seq' not described in '__d_lookup'
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki