fs: lockd: nlm_blocked list race fixes
Subsystems (3)
RFC 1/3 fs: lockd: nlm_blocked list race fixes
This patch fixes races when lockd accessing the global nlm_blocked list. It was mostly safe to access the list because everything was accessed from the lockd kernel thread context but there exists cases like nlmsvc_grant_deferred() that could manipulate the nlm_blocked list and it can be called from any context.
--- fs/lockd/svclock.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
fs/lockd/svclock.c +12 -1
@@ -131,12 +131,14 @@ static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when)static inline void nlmsvc_remove_block (struct nlm_block *block) { +spin_lock (&nlm_blocked_lock);if (!list_empty (&block->b_list)) { -spin_lock (&nlm_blocked_lock);list_del_init (&block->b_list);spin_unlock (&nlm_blocked_lock);nlmsvc_release_block (block); +return ; } +spin_unlock (&nlm_blocked_lock); }/*
@@ -152,6 +154,7 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) file, lock->fl.fl_pid, (long long )lock->fl.fl_start, (long long)lock->fl.fl_end, lock->fl.fl_type); +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) { fl = &block->b_call->a_args.lock.fl; dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
@@ -161,9 +164,11 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) nlmdbg_cookie2a(&block->b_call->a_args.cookie));if (block->b_file == file &&nlm_compare_locks (fl, &lock->fl)) {kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; } } +spin_unlock (&nlm_blocked_lock);return NULL ; }
@@ -185,16 +190,19 @@ nlmsvc_find_block(struct nlm_cookie *cookie) {struct nlm_block *block; +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_cookie_match (&block->b_call->a_args.cookie,cookie)) goto found; } +spin_unlock (&nlm_blocked_lock);return NULL ; found:dprintk ("nlmsvc_find_block(%s): block=%p\n" ,nlmdbg_cookie2a (cookie), block);kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; }
@@ -317,6 +325,7 @@ void nlmsvc_traverse_blocks(struct nlm_host *host, restart:mutex_lock (&file->f_mutex); +spin_lock (&nlm_blocked_lock);list_for_each_entry_safe (block, next, &file->f_blocks, b_flist) {if (!match (block->b_host, host))continue ;
@@ -325,11 +334,13 @@ void nlmsvc_traverse_blocks(struct nlm_host *host,if (list_empty (&block->b_list))continue ;kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex);nlmsvc_unlink_block (block);nlmsvc_release_block (block); goto restart; } +spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex); }
Signature · 1 line
2.31.1
RFC 2/3 fs: lockd: fix race in async lock request handling
This patch fixes a race in async lock request handling between adding the relevant struct nlm_block to nlm_blocked list after the request was sent by vfs_lock_file() and nlmsvc_grant_deferred() does a lookup of the nlm_block in the nlm_blocked list. It could be that the async request is completed before the nlm_block was added to the list. This would end in a -ENOENT and a kernel log message of "lockd: grant for unknown block".
To solve this issue we add the nlm_block before the vfs_lock_file() call to be sure it has been added when a possible nlmsvc_grant_deferred() is called. If the vfs_lock_file() results in an case when it wouldn't be added to nlm_blocked list, the nlm_block struct will be removed from this list again.
--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)
fs/lockd/svclock.c +59 -21
@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);
@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);
@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block); ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block); +pending_request:/* * If this is a blocking request for an * already pending lock request then we need
@@ -565,6 +577,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret = async_block ? nlm_lck_blocked : nlm_lck_denied; goto out;case FILE_LOCK_DEFERRED : + block->b_flags |=B_PENDING_CALLBACK ; +if (wait)break ;/* Filesystem lock operation is in progress
@@ -572,17 +586,16 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret =nlmsvc_defer_lock_rqst (rqstp, block); goto out;case -EDEADLK : +nlmsvc_remove_block (block); ret = nlm_deadlock; goto out;default :/* includes ENOLCK */ +nlmsvc_remove_block (block); ret = nlm_lck_denied_nolocks; goto out; } ret = nlm_lck_blocked; - -/* Append to list of blocked */ -nlmsvc_insert_block (block,NLM_NEVER ); out:mutex_unlock (&file->f_mutex);nlmsvc_release_block (block);
@@ -739,34 +752,59 @@ nlmsvc_update_deferred_block(struct nlm_block *block, int result) block->b_flags |=B_TIMED_OUT ; } +static int __nlmsvc_grant_deferred (struct nlm_block *block, +struct file_lock *fl, +int result) +{ +int rc =0 ; + +dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , + block, block->b_flags); +if (block->b_flags &B_QUEUED ) { +if (block->b_flags &B_TIMED_OUT ) { + rc = -ENOLCK ; + goto out; + } +nlmsvc_update_deferred_block (block, result); + }else if (result ==0 ) + block->b_granted =1 ; + +nlmsvc_insert_block_locked (block,0 ); +svc_wake_up (block->b_daemon); +out: +return rc; +} +static int nlmsvc_grant_deferred (struct file_lock *fl,int result) { -struct nlm_block *block; -int rc = -ENOENT ; +struct nlm_block *block =NULL ; +int rc;spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_compare_locks (&block->b_call->a_args.lock.fl, fl)) { -dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , - block, block->b_flags); -if (block->b_flags &B_QUEUED ) { -if (block->b_flags &B_TIMED_OUT ) { - rc = -ENOLCK ; -break ; - } -nlmsvc_update_deferred_block (block, result); - }else if (result ==0 ) - block->b_granted =1 ; - -nlmsvc_insert_block_locked (block,0 ); -svc_wake_up (block->b_daemon); - rc =0 ; +kref_get (&block->b_count);break ; } }spin_unlock (&nlm_blocked_lock); -if (rc == -ENOENT ) -printk (KERN_WARNING "lockd: grant for unknown block\n" ); + +if (!block) { +pr_warn ("lockd: grant for unknown pending block\n" ); +return -ENOENT ; + } + +/* don't interfere with nlmsvc_lock() */ +mutex_lock (&block->b_file->f_mutex); + block->b_flags &= ~B_PENDING_CALLBACK ; + +spin_lock (&nlm_blocked_lock); +WARN_ON_ONCE (list_empty (&block->b_list)); + rc =__nlmsvc_grant_deferred (block, fl, result); +spin_unlock (&nlm_blocked_lock); +mutex_unlock (&block->b_file->f_mutex); + +nlmsvc_release_block (block);return rc; }
include/linux/lockd/lockd.h +1 -0
@@ -189,6 +189,7 @@ struct nlm_block {#define B_QUEUED 1/* lock queued */ #define B_GOT_CALLBACK 2/* got lock or conflicting lock */ #define B_TIMED_OUT 4/* filesystem too slow to respond */ +#define B_PENDING_CALLBACK 8/* pending callback for lock request */ };/*
Signature · 1 line
2.31.1
RFC 2/3 fs: lockd: fix race in async lock request handling
Hi,
Quoted 48 lines · On Thu, Jul 20, 2023 at 8:58?AM Alexander Aring <[email protected]> wrote:
This patch fixes a race in async lock request handling between adding the relevant struct
nlm_blocktonlm_blockedlist after the request was sent byvfs_lock_file()andnlmsvc_grant_deferred()does a lookup of thenlm_blockin thenlm_blockedlist. It could be that the async request is completed before thenlm_blockwas added to the list. This would end in a-ENOENTand a kernel log message of "lockd: grant for unknown block".To solve this issue we add the
nlm_blockbefore thevfs_lock_file()call to be sure it has been added when a possiblenlmsvc_grant_deferred()is called. If thevfs_lock_file()results in an case when it wouldn't be added tonlm_blockedlist, thenlm_blockstruct will be removed from this list again.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)fs/lockd/svclock.c +8
-0@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);
fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 563
Quoted 4 lines
fs/lockd/svclock.c +1
-0@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block);
reacting here with nlmsvc_remove_block() assumes that the block was not being added to the nlm_blocked list before nlmsvc_insert_block() was called. I am not sure if this is always the case here.
Does somebody see a problem with that?
Quoted 39 lines
fs/lockd/svclock.c +7
-3ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block); +pending_request:/* * If this is a blocking request for an * already pending lock request then we need @@ -565,6 +577,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret = async_block ? nlm_lck_blocked : nlm_lck_denied; goto out;case FILE_LOCK_DEFERRED : + block->b_flags |=B_PENDING_CALLBACK ; +if (wait)break ;/* Filesystem lock operation is in progress @@ -572,17 +586,16 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret =nlmsvc_defer_lock_rqst (rqstp, block); goto out;case -EDEADLK : +nlmsvc_remove_block (block); ret = nlm_deadlock; goto out;default :/* includes ENOLCK */ +nlmsvc_remove_block (block); ret = nlm_lck_denied_nolocks; goto out; } ret = nlm_lck_blocked; - -/* Append to list of blocked */ -nlmsvc_insert_block (block,NLM_NEVER ); out:mutex_unlock (&file->f_mutex);nlmsvc_release_block (block);
fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 753
Quoted 2 lines
fs/lockd/svclock.c +0
-0@@ -739,34 +752,59 @@ nlmsvc_update_deferred_block(struct nlm_block *block, int result) block->b_flags |=B_TIMED_OUT ; }
- Alex
Jeff Layton
maintainerRFC 2/3 fs: lockd: fix race in async lock request handling
Quoted 60 lines · Alexander Aring
Hi,
Quoted 48 lines · On Thu, Jul 20, 2023 at 8:58?AM Alexander Aring <[email protected]> wrote:
This patch fixes a race in async lock request handling between adding the relevant struct
nlm_blocktonlm_blockedlist after the request was sent byvfs_lock_file()andnlmsvc_grant_deferred()does a lookup of thenlm_blockin thenlm_blockedlist. It could be that the async request is completed before thenlm_blockwas added to the list. This would end in a-ENOENTand a kernel log message of "lockd: grant for unknown block".To solve this issue we add the
nlm_blockbefore thevfs_lock_file()call to be sure it has been added when a possiblenlmsvc_grant_deferred()is called. If thevfs_lock_file()results in an case when it wouldn't be added tonlm_blockedlist, thenlm_blockstruct will be removed from this list again.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)fs/lockd/svclock.c +8
-0@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 563
Quoted 4 lines
fs/lockd/svclock.c +1
-0@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block);reacting here with
nlmsvc_remove_block()assumes that the block was not being added to thenlm_blockedlist beforenlmsvc_insert_block()was called. I am not sure if this is always the case here.
Quoted 2 lines
Does somebody see a problem with that?
The scenario is: we have a block on the list already and now another lock request comes in for the same thing: the client decided to just re- poll for the lock. That's a plausible scenario. I think the Linux NLM client will poll for locks periodically.
In this case though, the lock request was granted by the filesystem, so this is likely racing with (and winning vs.) a lm_grant callback. Given that the client decided to repoll for it, we're probably safe to just dequeue the block and respond here, and not worry about sending a grant callback.
Ditto for the other cases where the block is removed.
Quoted 5 lines
fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 568
Quoted 5 lines
fs/lockd/svclock.c +2
-0ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block);
I was thinking that it would be best to not insert a block at all in the !wait case, but it looks like DLM just returns DEFERRED and almost always does a callback, even when it's not a blocking lock request?
Anyway, I think we probably do have to handle this like you are.
Quoted 39 lines
Quoted 34 lines
fs/lockd/svclock.c +5
-3+pending_request:/* * If this is a blocking request for an * already pending lock request then we need @@ -565,6 +577,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret = async_block ? nlm_lck_blocked : nlm_lck_denied; goto out;case FILE_LOCK_DEFERRED : + block->b_flags |=B_PENDING_CALLBACK ; +if (wait)break ;/* Filesystem lock operation is in progress @@ -572,17 +586,16 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret =nlmsvc_defer_lock_rqst (rqstp, block); goto out;case -EDEADLK : +nlmsvc_remove_block (block); ret = nlm_deadlock; goto out;default :/* includes ENOLCK */ +nlmsvc_remove_block (block); ret = nlm_lck_denied_nolocks; goto out; } ret = nlm_lck_blocked; - -/* Append to list of blocked */ -nlmsvc_insert_block (block,NLM_NEVER ); out:mutex_unlock (&file->f_mutex);nlmsvc_release_block (block);fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 753
Quoted 2 lines
fs/lockd/svclock.c +0
-0@@ -739,34 +752,59 @@ nlmsvc_update_deferred_block(struct nlm_block *block, int result) block->b_flags |=B_TIMED_OUT ; }- Alex
Signature · 1 line
Jeff Layton <[email protected]>
Re: [Cluster-devel] [RFC v6.5-rc2 2/3] fs: lockd: fix race in async lock request handling
Hi,
Quoted 70 lines · Jeff Layton
Quoted 60 lines · Alexander Aring
Hi,
Quoted 48 lines · Alexander Aring
This patch fixes a race in async lock request handling between adding the relevant struct
nlm_blocktonlm_blockedlist after the request was sent byvfs_lock_file()andnlmsvc_grant_deferred()does a lookup of thenlm_blockin thenlm_blockedlist. It could be that the async request is completed before thenlm_blockwas added to the list. This would end in a-ENOENTand a kernel log message of "lockd: grant for unknown block".To solve this issue we add the
nlm_blockbefore thevfs_lock_file()call to be sure it has been added when a possiblenlmsvc_grant_deferred()is called. If thevfs_lock_file()results in an case when it wouldn't be added tonlm_blockedlist, thenlm_blockstruct will be removed from this list again.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)fs/lockd/svclock.c +8
-0@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 563
Quoted 4 lines
fs/lockd/svclock.c +1
-0@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block);reacting here with
nlmsvc_remove_block()assumes that the block was not being added to thenlm_blockedlist beforenlmsvc_insert_block()was called. I am not sure if this is always the case here.Quoted 2 lines
Does somebody see a problem with that?
The scenario is: we have a block on the list already and now another lock request comes in for the same thing: the client decided to just re- poll for the lock. That's a plausible scenario. I think the Linux NLM client will poll for locks periodically.
Quoted 8 lines
In this case though, the lock request was granted by the filesystem, so this is likely racing with (and winning vs.) a
lm_grantcallback. Given that the client decided to repoll for it, we're probably safe to just dequeue the block and respond here, and not worry about sending a grant callback.Ditto for the other cases where the block is removed.
ok.
Quoted 6 lines
Quoted 5 lines
fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 568
Quoted 5 lines
fs/lockd/svclock.c +2
-0ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block);
Quoted 6 lines
I was thinking that it would be best to not insert a block at all in the !wait case, but it looks like DLM just returns DEFERRED and almost always does a callback, even when it's not a blocking lock request?
Anyway, I think we probably do have to handle this like you are.
I would prefer to have !wait blocked. We even don't do that in DLM, it causes problems with cancellation as a cancellation will only do something (at least in DLM) when there is a waiter that the lock request waits to be granted, which is only being the case for wait lock requests.
A !wait is only a trylock, the answer should be back being mostly immediate and it also makes no sense for me to make them async, because we have the same problems with cancellation/unlock which are not being offered to be handled in an asynchronous way. As I said, the answer should be back mostly immediately. We are somehow doing this optimization for !wait lock requests only, but operations like unlock are also being called by lockd and are not being handled asynchronously. That means we probably don't care about this optimization, it looks different on wait lock requests.
We should update the documentation and only do async lock requests on wait only. Is this okay?
- Alex
Jeff Layton
maintainerRFC 2/3 fs: lockd: fix race in async lock request handling
In reply to Alexander AringQuoted 70 lines · Alexander Aring
This patch fixes a race in async lock request handling between adding the relevant struct
nlm_blocktonlm_blockedlist after the request was sent byvfs_lock_file()andnlmsvc_grant_deferred()does a lookup of thenlm_blockin thenlm_blockedlist. It could be that the async request is completed before thenlm_blockwas added to the list. This would end in a-ENOENTand a kernel log message of "lockd: grant for unknown block".To solve this issue we add the
nlm_blockbefore thevfs_lock_file()call to be sure it has been added when a possiblenlmsvc_grant_deferred()is called. If thevfs_lock_file()results in an case when it wouldn't be added tonlm_blockedlist, thenlm_blockstruct will be removed from this list again.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)fs/lockd/svclock.c +14
-0@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block); ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block); +pending_request:/* * If this is a blocking request for an * already pending lock request then we need @@ -565,6 +577,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret = async_block ? nlm_lck_blocked : nlm_lck_denied; goto out;case FILE_LOCK_DEFERRED : + block->b_flags |=B_PENDING_CALLBACK ; +if (wait)break ;/* Filesystem lock operation is in progress
fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 586
Quoted 1 line
fs/lockd/svclock.c +0
-0@@ -572,17 +586,16 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret =nlmsvc_defer_lock_rqst (rqstp, block);
When the above function is called, it's going to end up reinserting the block into the list. I think you probably also need to remove the call to nlmsvc_insert_block from nlmsvc_defer_lock_rqst since it could have been granted before that occurs.
Quoted 74 lines
fs/lockd/svclock.c +28
-19goto out;case -EDEADLK : +nlmsvc_remove_block (block); ret = nlm_deadlock; goto out;default :/* includes ENOLCK */ +nlmsvc_remove_block (block); ret = nlm_lck_denied_nolocks; goto out; } ret = nlm_lck_blocked; - -/* Append to list of blocked */ -nlmsvc_insert_block (block,NLM_NEVER ); out:mutex_unlock (&file->f_mutex);nlmsvc_release_block (block);@@ -739,34 +752,59 @@ nlmsvc_update_deferred_block(struct nlm_block *block, int result) block->b_flags |=B_TIMED_OUT ; } +static int __nlmsvc_grant_deferred (struct nlm_block *block, +struct file_lock *fl, +int result) +{ +int rc =0 ; + +dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , + block, block->b_flags); +if (block->b_flags &B_QUEUED ) { +if (block->b_flags &B_TIMED_OUT ) { + rc = -ENOLCK ; + goto out; + } +nlmsvc_update_deferred_block (block, result); + }else if (result ==0 ) + block->b_granted =1 ; + +nlmsvc_insert_block_locked (block,0 ); +svc_wake_up (block->b_daemon); +out: +return rc; +} +static int nlmsvc_grant_deferred (struct file_lock *fl,int result) { -struct nlm_block *block; -int rc = -ENOENT ; +struct nlm_block *block =NULL ; +int rc;spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_compare_locks (&block->b_call->a_args.lock.fl, fl)) { -dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , - block, block->b_flags); -if (block->b_flags &B_QUEUED ) { -if (block->b_flags &B_TIMED_OUT ) { - rc = -ENOLCK ; -break ; - } -nlmsvc_update_deferred_block (block, result); - }else if (result ==0 ) - block->b_granted =1 ; - -nlmsvc_insert_block_locked (block,0 ); -svc_wake_up (block->b_daemon); - rc =0 ; +kref_get (&block->b_count);break ; } }spin_unlock (&nlm_blocked_lock);
fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 798
Quoted 10 lines
fs/lockd/svclock.c +8
-2-if (rc == -ENOENT ) -printk (KERN_WARNING "lockd: grant for unknown block\n" ); + +if (!block) { +pr_warn ("lockd: grant for unknown pending block\n" ); +return -ENOENT ; + } + +/* don't interfere with nlmsvc_lock() */ +mutex_lock (&block->b_file->f_mutex);
This is called from lm_grant, and Documentation/filesystems/locking.rst says that lm_grant is not allowed to block. The only caller though is dlm_plock_callback, and I don't see anything that would prevent blocking.
Do we need to fix the documentation there?
fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 800
Quoted 2 lines
fs/lockd/svclock.c +2
-0+ block->b_flags &= ~B_PENDING_CALLBACK ; +
You're adding this new flag when the lock is deferred and then clearing it when the lock is granted. What about when the lock request is cancelled (e.g. by signal)? It seems like you also need to clear it then too, correct?
Quoted 22 lines
fs/lockd/svclock.c +7
-0+spin_lock (&nlm_blocked_lock); +WARN_ON_ONCE (list_empty (&block->b_list)); + rc =__nlmsvc_grant_deferred (block, fl, result); +spin_unlock (&nlm_blocked_lock); +mutex_unlock (&block->b_file->f_mutex); + +nlmsvc_release_block (block);return rc; }include/linux/lockd/lockd.h +1
-0@@ -189,6 +189,7 @@ struct nlm_block {#define B_QUEUED 1/* lock queued */ #define B_GOT_CALLBACK 2/* got lock or conflicting lock */ #define B_TIMED_OUT 4/* filesystem too slow to respond */ +#define B_PENDING_CALLBACK 8/* pending callback for lock request */ };/*
Signature · 1 line
Jeff Layton <[email protected]>
Re: [Cluster-devel] [RFC v6.5-rc2 2/3] fs: lockd: fix race in async lock request handling
Hi,
Quoted 70 lines · Jeff Layton
Quoted 68 lines · Alexander Aring
This patch fixes a race in async lock request handling between adding the relevant struct
nlm_blocktonlm_blockedlist after the request was sent byvfs_lock_file()andnlmsvc_grant_deferred()does a lookup of thenlm_blockin thenlm_blockedlist. It could be that the async request is completed before thenlm_blockwas added to the list. This would end in a-ENOENTand a kernel log message of "lockd: grant for unknown block".To solve this issue we add the
nlm_blockbefore thevfs_lock_file()call to be sure it has been added when a possiblenlmsvc_grant_deferred()is called. If thevfs_lock_file()results in an case when it wouldn't be added tonlm_blockedlist, thenlm_blockstruct will be removed from this list again.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 80 +++++++++++++++++++++++++++---------- include/linux/lockd/lockd.h | 1 + 2 files changed, 60 insertions(+), 21 deletions(-)fs/lockd/svclock.c +14
-0@@ -297,6 +297,8 @@ static void nlmsvc_free_block(struct kref *kref)dprintk ("lockd: freeing block %p...\n" , block); +WARN_ON_ONCE (block->b_flags &B_PENDING_CALLBACK ); +/* Remove block from file's list of blocks */ list_del_init (&block->b_flist);mutex_unlock (&file->f_mutex);@@ -543,6 +545,12 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, goto out; } +if (block->b_flags &B_PENDING_CALLBACK ) + goto pending_request; + +/* Append to list of blocked */ +nlmsvc_insert_block (block,NLM_NEVER ); +if (!wait) lock->fl.fl_flags &= ~FL_SLEEP ; mode =lock_to_openmode (&lock->fl);@@ -552,9 +560,13 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,dprintk ("lockd: vfs_lock_file returned %d\n" , error);switch (error) {case 0 : +nlmsvc_remove_block (block); ret = nlm_granted; goto out;case -EAGAIN : +if (!wait) +nlmsvc_remove_block (block); +pending_request:/* * If this is a blocking request for an * already pending lock request then we need @@ -565,6 +577,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret = async_block ? nlm_lck_blocked : nlm_lck_denied; goto out;case FILE_LOCK_DEFERRED : + block->b_flags |=B_PENDING_CALLBACK ; +if (wait)break ;
Quoted 9 lines
fs/lockd/svclock.c nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, · line 586
Quoted 3 lines
fs/lockd/svclock.c +0
-0/* Filesystem lock operation is in progress @@ -572,17 +586,16 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, ret =nlmsvc_defer_lock_rqst (rqstp, block);When the above function is called, it's going to end up reinserting the block into the list. I think you probably also need to remove the call to
nlmsvc_insert_blockfromnlmsvc_defer_lock_rqstsince it could have been granted before that occurs.
it cannot be granted during this time because the f_mutex is held. We insert it in the first place to have a way to get the block lookup working when a lm_grant() is really fast. Then lm_grant() will lookup the lock and have a way to get f_mutex to hold it. Then lm_grant() will only run when nobody is in this critical area (on a per nlm_file basis).
There is a difference in the call between NLM_NEVER and NLM_TIMEOUT in nlmsvc_defer_lock_rqst(), when nlmsvc_defer_lock_rqst() it will just update the timeout value. I am not sure about the consequences when it does a nlmsvc_insert_block() with NLM_NEVER instead of NLM_TIMEOUT. But as I said it should not be possible to grant the block when f_mutex is held.
Quoted 91 lines
Quoted 74 lines
fs/lockd/svclock.c +28
-19goto out;case -EDEADLK : +nlmsvc_remove_block (block); ret = nlm_deadlock; goto out;default :/* includes ENOLCK */ +nlmsvc_remove_block (block); ret = nlm_lck_denied_nolocks; goto out; } ret = nlm_lck_blocked; - -/* Append to list of blocked */ -nlmsvc_insert_block (block,NLM_NEVER ); out:mutex_unlock (&file->f_mutex);nlmsvc_release_block (block);@@ -739,34 +752,59 @@ nlmsvc_update_deferred_block(struct nlm_block *block, int result) block->b_flags |=B_TIMED_OUT ; } +static int __nlmsvc_grant_deferred (struct nlm_block *block, +struct file_lock *fl, +int result) +{ +int rc =0 ; + +dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , + block, block->b_flags); +if (block->b_flags &B_QUEUED ) { +if (block->b_flags &B_TIMED_OUT ) { + rc = -ENOLCK ; + goto out; + } +nlmsvc_update_deferred_block (block, result); + }else if (result ==0 ) + block->b_granted =1 ; + +nlmsvc_insert_block_locked (block,0 ); +svc_wake_up (block->b_daemon); +out: +return rc; +} +static int nlmsvc_grant_deferred (struct file_lock *fl,int result) { -struct nlm_block *block; -int rc = -ENOENT ; +struct nlm_block *block =NULL ; +int rc;spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_compare_locks (&block->b_call->a_args.lock.fl, fl)) { -dprintk ("lockd: nlmsvc_notify_blocked block %p flags %d\n" , - block, block->b_flags); -if (block->b_flags &B_QUEUED ) { -if (block->b_flags &B_TIMED_OUT ) { - rc = -ENOLCK ; -break ; - } -nlmsvc_update_deferred_block (block, result); - }else if (result ==0 ) - block->b_granted =1 ; - -nlmsvc_insert_block_locked (block,0 ); -svc_wake_up (block->b_daemon); - rc =0 ; +kref_get (&block->b_count);break ; } }spin_unlock (&nlm_blocked_lock);fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 798
Quoted 10 lines
fs/lockd/svclock.c +8
-2-if (rc == -ENOENT ) -printk (KERN_WARNING "lockd: grant for unknown block\n" ); + +if (!block) { +pr_warn ("lockd: grant for unknown pending block\n" ); +return -ENOENT ; + } + +/* don't interfere with nlmsvc_lock() */ +mutex_lock (&block->b_file->f_mutex);This is called from
lm_grant, andDocumentation/filesystems/locking.rstsays thatlm_grantis not allowed to block. The only caller though isdlm_plock_callback, and I don't see anything that would prevent blocking.
Quoted 2 lines
Do we need to fix the documentation there?
You are right and I think it should not call any sleepable API. However DLM is the only one upstream user and I have no other idea how to make the current situation better.
We should update the documentation but be open to make it non-sleepable in future?
Quoted 9 lines
fs/lockd/svclock.c nlmsvc_update_deferred_block(struct nlm_block *block, int result) · line 800
Quoted 3 lines
fs/lockd/svclock.c +2
-0+ block->b_flags &= ~B_PENDING_CALLBACK ; +You're adding this new flag when the lock is deferred and then clearing it when the lock is granted. What about when the lock request is cancelled (e.g. by signal)? It seems like you also need to clear it then too, correct?
correct. I add code to clear it when the block is getting removed from nlm_blocked in nlmsvc_remove_block().
Quoted 26 lines
Quoted 15 lines
fs/lockd/svclock.c +7
-0+spin_lock (&nlm_blocked_lock); +WARN_ON_ONCE (list_empty (&block->b_list)); + rc =__nlmsvc_grant_deferred (block, fl, result); +spin_unlock (&nlm_blocked_lock); +mutex_unlock (&block->b_file->f_mutex); + +nlmsvc_release_block (block);return rc; }include/linux/lockd/lockd.h +0
-0include/linux/lockd/lockd.h struct nlm_block { · line 195
Quoted 7 lines
include/linux/lockd/lockd.h +1
-0@@ -189,6 +189,7 @@ struct nlm_block {#define B_QUEUED 1/* lock queued */ #define B_GOT_CALLBACK 2/* got lock or conflicting lock */ #define B_TIMED_OUT 4/* filesystem too slow to respond */ +#define B_PENDING_CALLBACK 8/* pending callback for lock request */ };/* --
Jeff Layton <[email protected]>
Re: [RFC v6.5-rc2 2/3] fs: lockd: fix race in async lock request handling
In reply to Alexander AringHi Alexander,
[This is a private test report for your RFC patch.] kernel test robot noticed the following build warnings:
url: https://github.com/intel-lab-lkp/linux/commits/Alexander-Aring/fs-lockd-fix-race-in-async-lock-request-handling/20230720-210010 base: v6.5-rc2 patch link: https://lore.kernel.org/r/20230720125806.1385279-2-aahringo%40redhat.com patch subject: [RFC v6.5-rc2 2/3] fs: lockd: fix race in async lock request handling config: x86_64-randconfig-m001-20230720 (https://download.01.org/0day-ci/archive/20230722/[email protected]/config) compiler: gcc-12 (Debian 12.2.0-14) 12.2.0 reproduce: (https://download.01.org/0day-ci/archive/20230722/[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]> | Reported-by: Dan Carpenter <[email protected]> | Closes: https://lore.kernel.org/r/[email protected]/
smatch warnings:fs/lockd/svclock.c:798 nlmsvc_grant_deferred() warn: iterator used outside loop: 'block'
vim +/block +798 fs/lockd/svclock.c
385d3265c23730 Alexander Aring 2023-07-20 778 static int nlmsvc_grant_deferred(struct file_lock *fl, int result)
385d3265c23730 Alexander Aring 2023-07-20 779 {
385d3265c23730 Alexander Aring 2023-07-20 780 struct nlm_block *block = NULL;No need.
385d3265c23730 Alexander Aring 2023-07-20 781 int rc;
385d3265c23730 Alexander Aring 2023-07-20 782
385d3265c23730 Alexander Aring 2023-07-20 783 spin_lock(&nlm_blocked_lock);
385d3265c23730 Alexander Aring 2023-07-20 784 list_for_each_entry(block, &nlm_blocked, b_list) {
385d3265c23730 Alexander Aring 2023-07-20 785 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
385d3265c23730 Alexander Aring 2023-07-20 786 kref_get(&block->b_count);
0e4ac9d93515b2 Marc Eshel 2006-11-28 787 break;
0e4ac9d93515b2 Marc Eshel 2006-11-28 788 }
0e4ac9d93515b2 Marc Eshel 2006-11-28 789 }
f904be9cc77f36 Bryan Schumaker 2010-09-21 790 spin_unlock(&nlm_blocked_lock);
385d3265c23730 Alexander Aring 2023-07-20 791
385d3265c23730 Alexander Aring 2023-07-20 792 if (!block) {The list iterator is never NULL. The old way to check was something list if list_entry_is_head() but now we just say:
bool found = false;
list_for_each() {
if (whatever) {
found = true;
break;
}
}
if (!found)
return -ENOENT;385d3265c23730 Alexander Aring 2023-07-20 793 pr_warn("lockd: grant for unknown pending block\n");
385d3265c23730 Alexander Aring 2023-07-20 794 return -ENOENT;
385d3265c23730 Alexander Aring 2023-07-20 795 }
385d3265c23730 Alexander Aring 2023-07-20 796
385d3265c23730 Alexander Aring 2023-07-20 797 /* don't interfere with nlmsvc_lock() */
385d3265c23730 Alexander Aring 2023-07-20 @798 mutex_lock(&block->b_file->f_mutex);
385d3265c23730 Alexander Aring 2023-07-20 799 block->b_flags &= ~B_PENDING_CALLBACK;
385d3265c23730 Alexander Aring 2023-07-20 800
385d3265c23730 Alexander Aring 2023-07-20 801 spin_lock(&nlm_blocked_lock);
385d3265c23730 Alexander Aring 2023-07-20 802 WARN_ON_ONCE(list_empty(&block->b_list));
385d3265c23730 Alexander Aring 2023-07-20 803 rc = __nlmsvc_grant_deferred(block, fl, result);
385d3265c23730 Alexander Aring 2023-07-20 804 spin_unlock(&nlm_blocked_lock);
385d3265c23730 Alexander Aring 2023-07-20 805 mutex_unlock(&block->b_file->f_mutex);
385d3265c23730 Alexander Aring 2023-07-20 806
385d3265c23730 Alexander Aring 2023-07-20 807 nlmsvc_release_block(block);
0e4ac9d93515b2 Marc Eshel 2006-11-28 808 return rc;
0e4ac9d93515b2 Marc Eshel 2006-11-28 809 }Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
RFC 3/3 fs: lockd: introduce safe async lock op
In reply to Alexander AringThis patch reverts mostly commit 40595cdc93ed ("nfs: block notification on fs with its own ->lock") and introduces an EXPORT_OP_SAFE_ASYNC_LOCK export flag to signal that the "own ->lock" implementation supports async lock requests. The only main user is DLM that is used by GFS2 and OCFS2 filesystem. Those implement their own lock() implementation and return FILE_LOCK_DEFERRED as return value. Since commit 40595cdc93ed ("nfs: block notification on fs with its own ->lock") the DLM implementation were never updated. This patch should prepare for DLM to set the EXPORT_OP_SAFE_ASYNC_LOCK export flag and update the DLM plock implementation regarding to it.
--- fs/lockd/svclock.c | 5 ++--- fs/nfsd/nfs4state.c | 11 ++++++++--- include/linux/exportfs.h | 1 + 3 files changed, 11 insertions(+), 6 deletions(-)
fs/lockd/svclock.c +2 -3
@@ -483,9 +483,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, struct nlm_host *host, struct nlm_lock *lock, int wait, struct nlm_cookie *cookie, int reclaim) { -#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) struct inode *inode = nlmsvc_file_inode(file); -#endif struct nlm_block *block =NULL ;int error;int mode;
@@ -499,7 +497,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, (long long )lock->fl.fl_end, wait); -if (nlmsvc_file_file (file)->f_op->lock) { +if (!(inode->i_sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK ) && +nlmsvc_file_file (file)->f_op->lock) { async_block = wait; wait =0 ; }
fs/nfsd/nfs4state.c +8 -3
@@ -7432,6 +7432,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,struct nfsd4_blocked_lock *nbl =NULL ;struct file_lock *file_lock =NULL ;struct file_lock *conflock =NULL ; +struct super_block *sb;__be32 status =0 ;int lkflg;int err;
@@ -7453,6 +7454,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,dprintk ("NFSD: nfsd4_lock: permission denied!\n" );return status; } + sb = cstate->current_fh.fh_dentry->d_sb;if (lock->lk_is_new) {if (nfsd4_has_session (cstate))
@@ -7504,7 +7506,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, fp = lock_stp->st_stid.sc_file;switch (lock->lk_type) {case NFS4_READW_LT : -if (nfsd4_has_session (cstate)) +if (sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK && +nfsd4_has_session (cstate)) fl_flags |=FL_SLEEP ; fallthrough;case NFS4_READ_LT :
@@ -7516,7 +7519,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, fl_type =F_RDLCK ;break ;case NFS4_WRITEW_LT : -if (nfsd4_has_session (cstate)) +if (sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK && +nfsd4_has_session (cstate)) fl_flags |=FL_SLEEP ; fallthrough;case NFS4_WRITE_LT :
@@ -7544,7 +7548,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,* for file locks), so don't attempt blocking lock notifications * on those filesystems: */ -if (nf->nf_file->f_op->lock) +if (!(sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK ) && + nf->nf_file->f_op->lock) fl_flags &= ~FL_SLEEP ; nbl =find_or_allocate_block (lock_sop, &fp->fi_fhandle, nn);
include/linux/exportfs.h +1 -0
@@ -224,6 +224,7 @@ struct export_operations {atomic attribute updates */ #define EXPORT_OP_FLUSH_ON_CLOSE (0x20)/* fs flushes file data on close */ +#define EXPORT_OP_SAFE_ASYNC_LOCK (0x40)/* fs can do async lock request */ unsigned long flags; };
Signature · 1 line
2.31.1
Jeff Layton
maintainerRFC 3/3 fs: lockd: introduce safe async lock op
Quoted 63 lines · Alexander Aring
This patch reverts mostly commit
40595cdc93ed("nfs: block notification on fs with its own ->lock") and introduces anEXPORT_OP_SAFE_ASYNC_LOCKexport flag to signal that the "own ->lock" implementation supports async lock requests. The only main user is DLM that is used by GFS2 and OCFS2 filesystem. Those implement their ownlock()implementation and returnFILE_LOCK_DEFERREDas return value. Since commit40595cdc93ed("nfs: block notification on fs with its own ->lock") the DLM implementation were never updated. This patch should prepare for DLM to set theEXPORT_OP_SAFE_ASYNC_LOCKexport flag and update the DLM plock implementation regarding to it.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 5 ++--- fs/nfsd/nfs4state.c | 11 ++++++++--- include/linux/exportfs.h | 1 + 3 files changed, 11 insertions(+), 6 deletions(-)fs/lockd/svclock.c +2
-3@@ -483,9 +483,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, struct nlm_host *host, struct nlm_lock *lock, int wait, struct nlm_cookie *cookie, int reclaim) { -#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) struct inode *inode = nlmsvc_file_inode(file); -#endif struct nlm_block *block =NULL ;int error;int mode;@@ -499,7 +497,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, (long long )lock->fl.fl_end, wait); -if (nlmsvc_file_file (file)->f_op->lock) { +if (!(inode->i_sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK ) && +nlmsvc_file_file (file)->f_op->lock) { async_block = wait; wait =0 ; }fs/nfsd/nfs4state.c +2
-0@@ -7432,6 +7432,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,struct nfsd4_blocked_lock *nbl =NULL ;struct file_lock *file_lock =NULL ;struct file_lock *conflock =NULL ; +struct super_block *sb;__be32 status =0 ;int lkflg;int err;@@ -7453,6 +7454,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,dprintk ("NFSD: nfsd4_lock: permission denied!\n" );return status; } + sb = cstate->current_fh.fh_dentry->d_sb;if (lock->lk_is_new) {if (nfsd4_has_session (cstate))
fs/nfsd/nfs4state.c nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, · line 7509
Quoted 5 lines
fs/nfsd/nfs4state.c +1
-1@@ -7504,7 +7506,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, fp = lock_stp->st_stid.sc_file;switch (lock->lk_type) {case NFS4_READW_LT : -if (nfsd4_has_session (cstate)) + if (sb->s_export_op->flags & EXPORT_OP_SAFE_ASYNC_LOCK &&
This will break existing filesystems that don't set the new flag. Maybe you also need to test for the filesystem's ->lock operation here too?
This might be more nicely expressed in a helper function.
Quoted 36 lines
fs/nfsd/nfs4state.c +5
-2+ nfsd4_has_session(cstate)) fl_flags |=FL_SLEEP ; fallthrough;case NFS4_READ_LT :@@ -7516,7 +7519,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, fl_type =F_RDLCK ;break ;case NFS4_WRITEW_LT : -if (nfsd4_has_session (cstate)) +if (sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK && +nfsd4_has_session (cstate)) fl_flags |=FL_SLEEP ; fallthrough;case NFS4_WRITE_LT :@@ -7544,7 +7548,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,* for file locks), so don't attempt blocking lock notifications * on those filesystems: */ -if (nf->nf_file->f_op->lock) +if (!(sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK ) && + nf->nf_file->f_op->lock) fl_flags &= ~FL_SLEEP ; nbl =find_or_allocate_block (lock_sop, &fp->fi_fhandle, nn);include/linux/exportfs.h +1
-0@@ -224,6 +224,7 @@ struct export_operations {atomic attribute updates */ #define EXPORT_OP_FLUSH_ON_CLOSE (0x20)/* fs flushes file data on close */ +#define EXPORT_OP_SAFE_ASYNC_LOCK (0x40)/* fs can do async lock request */ unsigned long flags; };
Signature · 1 line
Jeff Layton <[email protected]>
Re: [Cluster-devel] [RFC v6.5-rc2 3/3] fs: lockd: introduce safe async lock op
Hi,
Quoted 62 lines · Jeff Layton
Quoted 60 lines · Alexander Aring
This patch reverts mostly commit
40595cdc93ed("nfs: block notification on fs with its own ->lock") and introduces anEXPORT_OP_SAFE_ASYNC_LOCKexport flag to signal that the "own ->lock" implementation supports async lock requests. The only main user is DLM that is used by GFS2 and OCFS2 filesystem. Those implement their ownlock()implementation and returnFILE_LOCK_DEFERREDas return value. Since commit40595cdc93ed("nfs: block notification on fs with its own ->lock") the DLM implementation were never updated. This patch should prepare for DLM to set theEXPORT_OP_SAFE_ASYNC_LOCKexport flag and update the DLM plock implementation regarding to it.Signed-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 5 ++--- fs/nfsd/nfs4state.c | 11 ++++++++--- include/linux/exportfs.h | 1 + 3 files changed, 11 insertions(+), 6 deletions(-)fs/lockd/svclock.c +2
-3@@ -483,9 +483,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, struct nlm_host *host, struct nlm_lock *lock, int wait, struct nlm_cookie *cookie, int reclaim) { -#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) struct inode *inode = nlmsvc_file_inode(file); -#endif struct nlm_block *block =NULL ;int error;int mode;@@ -499,7 +497,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, (long long )lock->fl.fl_end, wait); -if (nlmsvc_file_file (file)->f_op->lock) { +if (!(inode->i_sb->s_export_op->flags &EXPORT_OP_SAFE_ASYNC_LOCK ) && +nlmsvc_file_file (file)->f_op->lock) { async_block = wait; wait =0 ; }fs/nfsd/nfs4state.c +2
-0@@ -7432,6 +7432,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,struct nfsd4_blocked_lock *nbl =NULL ;struct file_lock *file_lock =NULL ;struct file_lock *conflock =NULL ; +struct super_block *sb;__be32 status =0 ;int lkflg;int err;@@ -7453,6 +7454,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,dprintk ("NFSD: nfsd4_lock: permission denied!\n" );return status; } + sb = cstate->current_fh.fh_dentry->d_sb;
Quoted 12 lines
fs/nfsd/nfs4state.c nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, · line 7509
Quoted 8 lines
fs/nfsd/nfs4state.c +1
-1if (lock->lk_is_new) {if (nfsd4_has_session (cstate))@@ -7504,7 +7506,8 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, fp = lock_stp->st_stid.sc_file;switch (lock->lk_type) {case NFS4_READW_LT : -if (nfsd4_has_session (cstate)) + if (sb->s_export_op->flags & EXPORT_OP_SAFE_ASYNC_LOCK &&This will break existing filesystems that don't set the new flag. Maybe you also need to test for the filesystem's ->lock operation here too?
yes.
Quoted 1 line
This might be more nicely expressed in a helper function.
ok.
- Alex
Jeff Layton
maintainerRFC 1/3 fs: lockd: nlm_blocked list race fixes
In reply to Alexander AringQuoted 84 lines · Alexander Aring
This patch fixes races when lockd accessing the global
nlm_blockedlist. It was mostly safe to access the list because everything was accessed from the lockd kernel thread context but there exists cases likenlmsvc_grant_deferred()that could manipulate thenlm_blockedlist and it can be called from any context.Cc stable at vger.kernel.orgSigned-off-by Alexander Aring <[email protected]>--- fs/lockd/svclock.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)fs/lockd/svclock.c +10
-1@@ -131,12 +131,14 @@ static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when)static inline void nlmsvc_remove_block (struct nlm_block *block) { +spin_lock (&nlm_blocked_lock);if (!list_empty (&block->b_list)) { -spin_lock (&nlm_blocked_lock);list_del_init (&block->b_list);spin_unlock (&nlm_blocked_lock);nlmsvc_release_block (block); +return ; } +spin_unlock (&nlm_blocked_lock); }/* @@ -152,6 +154,7 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) file, lock->fl.fl_pid, (long long )lock->fl.fl_start, (long long)lock->fl.fl_end, lock->fl.fl_type); +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) { fl = &block->b_call->a_args.lock.fl; dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",@@ -161,9 +164,11 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) nlmdbg_cookie2a(&block->b_call->a_args.cookie));if (block->b_file == file &&nlm_compare_locks (fl, &lock->fl)) {kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; } } +spin_unlock (&nlm_blocked_lock);return NULL ; }@@ -185,16 +190,19 @@ nlmsvc_find_block(struct nlm_cookie *cookie) {struct nlm_block *block; +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_cookie_match (&block->b_call->a_args.cookie,cookie)) goto found; } +spin_unlock (&nlm_blocked_lock);return NULL ; found:dprintk ("nlmsvc_find_block(%s): block=%p\n" ,nlmdbg_cookie2a (cookie), block);kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; }@@ -317,6 +325,7 @@ void nlmsvc_traverse_blocks(struct nlm_host *host, restart:mutex_lock (&file->f_mutex); +spin_lock (&nlm_blocked_lock);list_for_each_entry_safe (block, next, &file->f_blocks, b_flist) {if (!match (block->b_host, host))continue ;@@ -325,11 +334,13 @@ void nlmsvc_traverse_blocks(struct nlm_host *host,if (list_empty (&block->b_list))continue ;kref_get (&block->b_count);
fs/lockd/svclock.c void nlmsvc_traverse_blocks(struct nlm_host *host, · line 346
Quoted 10 lines
fs/lockd/svclock.c +2
-0+spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex);nlmsvc_unlink_block (block);nlmsvc_release_block (block); goto restart; } +spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex); }
The patch itself looks correct. Walking these lists without holding the lock is quite suspicious. Not sure about the stable designation here though, unless you have a way to easily reproduce this.
Chuck Lever
maintainerRFC 1/3 fs: lockd: nlm_blocked list race fixes
In reply to Alexander AringQuoted 8 lines · Alexander Aring
This patch fixes races when lockd accessing the global
nlm_blockedlist. It was mostly safe to access the list because everything was accessed from the lockd kernel thread context but there exists cases likenlmsvc_grant_deferred()that could manipulate thenlm_blockedlist and it can be called from any context.Cc stable at vger.kernel.orgSigned-off-by Alexander Aring <[email protected]>
I agree with Jeff, this one looks fine to apply to nfsd-next. I've done that so it can get test exposure while we consider 2/3 and 3/3.
I've dropped the "Cc: stable" tag -- since there is no specific bug report this fix addresses, I will defer the decision about backporting at least until we have some test experience.
Quoted 89 lines
--- fs/lockd/svclock.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)fs/lockd/svclock.c +12
-1@@ -131,12 +131,14 @@ static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when)static inline void nlmsvc_remove_block (struct nlm_block *block) { +spin_lock (&nlm_blocked_lock);if (!list_empty (&block->b_list)) { -spin_lock (&nlm_blocked_lock);list_del_init (&block->b_list);spin_unlock (&nlm_blocked_lock);nlmsvc_release_block (block); +return ; } +spin_unlock (&nlm_blocked_lock); }/* @@ -152,6 +154,7 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) file, lock->fl.fl_pid, (long long )lock->fl.fl_start, (long long)lock->fl.fl_end, lock->fl.fl_type); +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) { fl = &block->b_call->a_args.lock.fl; dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",@@ -161,9 +164,11 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) nlmdbg_cookie2a(&block->b_call->a_args.cookie));if (block->b_file == file &&nlm_compare_locks (fl, &lock->fl)) {kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; } } +spin_unlock (&nlm_blocked_lock);return NULL ; }@@ -185,16 +190,19 @@ nlmsvc_find_block(struct nlm_cookie *cookie) {struct nlm_block *block; +spin_lock (&nlm_blocked_lock);list_for_each_entry (block, &nlm_blocked, b_list) {if (nlm_cookie_match (&block->b_call->a_args.cookie,cookie)) goto found; } +spin_unlock (&nlm_blocked_lock);return NULL ; found:dprintk ("nlmsvc_find_block(%s): block=%p\n" ,nlmdbg_cookie2a (cookie), block);kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);return block; }@@ -317,6 +325,7 @@ void nlmsvc_traverse_blocks(struct nlm_host *host, restart:mutex_lock (&file->f_mutex); +spin_lock (&nlm_blocked_lock);list_for_each_entry_safe (block, next, &file->f_blocks, b_flist) {if (!match (block->b_host, host))continue ;@@ -325,11 +334,13 @@ void nlmsvc_traverse_blocks(struct nlm_host *host,if (list_empty (&block->b_list))continue ;kref_get (&block->b_count); +spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex);nlmsvc_unlink_block (block);nlmsvc_release_block (block); goto restart; } +spin_unlock (&nlm_blocked_lock);mutex_unlock (&file->f_mutex); }Signature · 1 line
2.31.1