Fixup NLM and kNFSD file lock callbacks

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

Its important for NLM and kNFSD that they do not block their kernel threads inside filesystem's file_lock implementations because that can produce deadlocks. We used to make sure of this by only trusting that posix_lock_file() can correctly handle blocking lock calls asynchronously, so the lock managers would only setup their file_lock requests for async callbacks if the filesystem did not define its own lock() file operation.

However, when GFS2 and OCFS2 grew the capability to correctly handle blocking lock requests asynchronously, they started signalling this behavior with EXPORT_OP_ASYNC_LOCK, and the check for also trusting posix_lock_file() was inadvertently dropped, so now most filesystems no longer produce lock notifications when exported over NFS.

I tried to fix this by simply including the old check for lock(), but the resulting include mess and layering violations was more than I could accept. There's a much cleaner way presented here using an fop_flag, which while potentially flag-greedy, greatly simplifies the problem and grooms the

way for future uses by both filesystems and lock managers alike.

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

Its important for NLM and kNFSD that they do not block their kernel threads inside filesystem's file_lock implementations because that can produce deadlocks. We used to make sure of this by only trusting that posix_lock_file() can correctly handle blocking lock calls asynchronously, so the lock managers would only setup their file_lock requests for async callbacks if the filesystem did not define its own lock() file operation.

However, when GFS2 and OCFS2 grew the capability to correctly handle blocking lock requests asynchronously, they started signalling this behavior with EXPORT_OP_ASYNC_LOCK, and the check for also trusting posix_lock_file() was inadvertently dropped, so now most filesystems no longer produce lock notifications when exported over NFS.

I tried to fix this by simply including the old check for lock(), but the resulting include mess and layering violations was more than I could accept. There's a much cleaner way presented here using an fop_flag, which while potentially flag-greedy, greatly simplifies the problem and grooms the way for future uses by both filesystems and lock managers alike.

Criticism welcomed,
Ben

Benjamin Coddington (4):
fs: Introduce FOP_ASYNC_LOCK
gfs2/ocfs2: set FOP_ASYNC_LOCK
NLM/NFSD: Fix lock notifications for async-capable filesystems
exportfs: Remove EXPORT_OP_ASYNC_LOCK

 Documentation/filesystems/nfs/exporting.rst |  7 -------
 fs/gfs2/export.c                            |  1 -
 fs/gfs2/file.c                              |  2 ++
 fs/lockd/svclock.c                          |  5 ++---
 fs/nfsd/nfs4state.c                         | 19 ++++---------------
 fs/ocfs2/export.c                           |  1 -
 fs/ocfs2/file.c                             |  2 ++
 include/linux/exportfs.h                    | 13 -------------
 include/linux/filelock.h                    |  5 +++++
 include/linux/fs.h                          |  2 ++
 10 files changed, 17 insertions(+), 40 deletions(-)

Quoted 39 lines · Benjamin Coddington

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

Its important for NLM and kNFSD that they do not block their kernel threads inside filesystem's file_lock implementations because that can produce deadlocks. We used to make sure of this by only trusting that posix_lock_file() can correctly handle blocking lock calls asynchronously, so the lock managers would only setup their file_lock requests for async callbacks if the filesystem did not define its own lock() file operation.

However, when GFS2 and OCFS2 grew the capability to correctly handle blocking lock requests asynchronously, they started signalling this behavior with EXPORT_OP_ASYNC_LOCK, and the check for also trusting posix_lock_file() was inadvertently dropped, so now most filesystems no longer produce lock notifications when exported over NFS.

I tried to fix this by simply including the old check for lock(), but the resulting include mess and layering violations was more than I could accept. There's a much cleaner way presented here using an fop_flag, which while potentially flag-greedy, greatly simplifies the problem and grooms the way for future uses by both filesystems and lock managers alike.

Criticism welcomed,
Ben

Benjamin Coddington (4):
fs: Introduce FOP_ASYNC_LOCK
gfs2/ocfs2: set FOP_ASYNC_LOCK
NLM/NFSD: Fix lock notifications for async-capable filesystems
exportfs: Remove EXPORT_OP_ASYNC_LOCK

Quoted 12 lines

 Documentation/filesystems/nfs/exporting.rst |  7 -------
 fs/gfs2/export.c                            |  1 -
 fs/gfs2/file.c                              |  2 ++
 fs/lockd/svclock.c                          |  5 ++---
 fs/nfsd/nfs4state.c                         | 19 ++++---------------
 fs/ocfs2/export.c                           |  1 -
 fs/ocfs2/file.c                             |  2 ++
 include/linux/exportfs.h                    | 13 -------------
 include/linux/filelock.h                    |  5 +++++
 include/linux/fs.h                          |  2 ++
 10 files changed, 17 insertions(+), 40 deletions(-)

Thanks for fixing this up, Ben!

Reviewed-by Jeff Layton <[email protected]>

Quoted 53 lines · Jeff Layton

Quoted 51 lines · Benjamin Coddington

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

Its important for NLM and kNFSD that they do not block their kernel threads inside filesystem's file_lock implementations because that can produce deadlocks. We used to make sure of this by only trusting that posix_lock_file() can correctly handle blocking lock calls asynchronously, so the lock managers would only setup their file_lock requests for async callbacks if the filesystem did not define its own lock() file operation.

However, when GFS2 and OCFS2 grew the capability to correctly handle blocking lock requests asynchronously, they started signalling this behavior with EXPORT_OP_ASYNC_LOCK, and the check for also trusting posix_lock_file() was inadvertently dropped, so now most filesystems no longer produce lock notifications when exported over NFS.

I tried to fix this by simply including the old check for lock(), but the resulting include mess and layering violations was more than I could accept. There's a much cleaner way presented here using an fop_flag, which while potentially flag-greedy, greatly simplifies the problem and grooms the way for future uses by both filesystems and lock managers alike.

Criticism welcomed,
Ben

Benjamin Coddington (4):
fs: Introduce FOP_ASYNC_LOCK
gfs2/ocfs2: set FOP_ASYNC_LOCK
NLM/NFSD: Fix lock notifications for async-capable filesystems
exportfs: Remove EXPORT_OP_ASYNC_LOCK

 Documentation/filesystems/nfs/exporting.rst |  7 -------
 fs/gfs2/export.c                            |  1 -
 fs/gfs2/file.c                              |  2 ++
 fs/lockd/svclock.c                          |  5 ++---
 fs/nfsd/nfs4state.c                         | 19 ++++---------------
 fs/ocfs2/export.c                           |  1 -
 fs/ocfs2/file.c                             |  2 ++
 include/linux/exportfs.h                    | 13 -------------
 include/linux/filelock.h                    |  5 +++++
 include/linux/fs.h                          |  2 ++
 10 files changed, 17 insertions(+), 40 deletions(-)

Quoted 3 lines

Thanks for fixing this up, Ben!

Reviewed-by Jeff Layton <[email protected]>

It might be a bit late for v6.12 so I would stuff this into a branch for v6.13. Sound ok?

Quoted 3 lines · Christian Brauner

It might be a bit late for v6.12 so I would stuff this into a branch for v6.13. Sound ok?

Ok. I figured Chuck would take this set, but I guess it is more VFS-y.

I think this is reasonably safe though, so if Ben needs it before then, we could pull it in sooner.

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

[...]

Last year both GFS2 and OCFS2 had some work done to make their locking more robust when exported over NFS. Unfortunately, part of that work caused both NLM (for NFS v3 exports) and kNFSD (for NFSv4.1+ exports) to no longer send lock notifications to clients.

This in itself is not a huge problem because most NFS clients will still poll the server in order to acquire a conflicted lock, but now that I've noticed it I can't help but try to fix it because there are big advantages for setups that might depend on timely lock notifications, and we've supported that as a feature for a long time.

Its important for NLM and kNFSD that they do not block their kernel threads inside filesystem's file_lock implementations because that can produce deadlocks. We used to make sure of this by only trusting that posix_lock_file() can correctly handle blocking lock calls asynchronously, so the lock managers would only setup their file_lock requests for async callbacks if the filesystem did not define its own lock() file operation.

However, when GFS2 and OCFS2 grew the capability to correctly handle blocking lock requests asynchronously, they started signalling this behavior with EXPORT_OP_ASYNC_LOCK, and the check for also trusting posix_lock_file() was inadvertently dropped, so now most filesystems no longer produce lock notifications when exported over NFS.

I tried to fix this by simply including the old check for lock(), but the resulting include mess and layering violations was more than I could accept. There's a much cleaner way presented here using an fop_flag, which while potentially flag-greedy, greatly simplifies the problem and grooms the way for future uses by both filesystems and lock managers alike.

Criticism welcomed,
Ben

Benjamin Coddington (4):
fs: Introduce FOP_ASYNC_LOCK
gfs2/ocfs2: set FOP_ASYNC_LOCK
NLM/NFSD: Fix lock notifications for async-capable filesystems
exportfs: Remove EXPORT_OP_ASYNC_LOCK

Documentation/filesystems/nfs/exporting.rst |  7 -------
fs/gfs2/export.c                            |  1 -
fs/gfs2/file.c                              |  2 ++
fs/lockd/svclock.c                          |  5 ++---
fs/nfsd/nfs4state.c                         | 19 ++++---------------
fs/ocfs2/export.c                           |  1 -
fs/ocfs2/file.c                             |  2 ++
include/linux/exportfs.h                    | 13 -------------
include/linux/filelock.h                    |  5 +++++
include/linux/fs.h                          |  2 ++
10 files changed, 17 insertions(+), 40 deletions(-)

Signature · 1 line

2.44.0

For the NFSD and exportfs hunks:

Acked-by Chuck Lever <[email protected] <mailto:[email protected]>>

"lockd: introduce safe async lock op" is in v6.10. Does this series need to be backported to v6.10.y ? Should the series have "Fixes: 2dd10de8e6bc ("lockd: introduce safe async lock
op")" ?

Quoted 8 lines · Chuck Lever III

For the NFSD and exportfs hunks:

Acked-by Chuck Lever <[email protected] <mailto:[email protected]>>

"lockd: introduce safe async lock op" is in v6.10. Does this series need to be backported to v6.10.y ? Should the series have "Fixes: 2dd10de8e6bc ("lockd: introduce safe async lock op")" ?

Thanks Chuck! Probably yes, if we want notifications fixed up there. It should be sufficient to add this to the signoff area for at least the first three (and fourth for cleanup):

Cc <[email protected]> # 6.10.x

Quoted 13 lines · Benjamin Coddington

Quoted 8 lines · Chuck Lever III

For the NFSD and exportfs hunks:

Acked-by Chuck Lever <[email protected] <mailto:[email protected]>>

"lockd: introduce safe async lock op" is in v6.10. Does this series need to be backported to v6.10.y ? Should the series have "Fixes: 2dd10de8e6bc ("lockd: introduce safe async lock op")" ?

Quoted 5 lines

Thanks Chuck! Probably yes, if we want notifications fixed up there. It should be sufficient to add this to the signoff area for at least the first three (and fourth for cleanup):

Cc <[email protected]> # 6.10.x

2dd10de8e6bc landed in v6.7.

I suppose that since v6.10.y is likely to be closed by the time this series is applied upstream, this tag might be confusing.

Thus Fixes: 2dd10de8e6bc and a plain Cc: stable should work best. Then whichever stable kernel is open when your fixes are merged upstream will automatically get fixed.

Quoted 25 lines · Chuck Lever III

Quoted 13 lines · Benjamin Coddington

Quoted 8 lines · Chuck Lever III

For the NFSD and exportfs hunks:

Acked-by Chuck Lever <[email protected] <mailto:[email protected]>>

"lockd: introduce safe async lock op" is in v6.10. Does this series need to be backported to v6.10.y ? Should the series have "Fixes: 2dd10de8e6bc ("lockd: introduce safe async lock op")" ?

Quoted 5 lines

Thanks Chuck! Probably yes, if we want notifications fixed up there. It should be sufficient to add this to the signoff area for at least the first three (and fourth for cleanup):

Cc <[email protected]> # 6.10.x

2dd10de8e6bc landed in v6.7.

I suppose that since v6.10.y is likely to be closed by the time this series is applied upstream, this tag might be confusing.

Quoted 3 lines

Thus Fixes: 2dd10de8e6bc and a plain Cc: stable should work best. Then whichever stable kernel is open when your fixes are merged upstream will automatically get fixed.

So you want "Fixes: 2dd10de8e6bc" on all these patches? Fixing the problem requires all of the first three patches together.

My worry is that a
"Fixes" on each implies a complete fix within that patch, so its really not appropriate.

The stable-kernel-rules.rst documentation says for a series, the Cc: stable tag should be suffient to request dependencies within the series, so that's why I suggested it for the version you requested.

What exactly would you like to see? I am happy to send a 2nd version.