Unverified Commit 8cf9a01e authored by Benjamin Coddington's avatar Benjamin Coddington Committed by Christian Brauner
Browse files

fs: Introduce FOP_ASYNC_LOCK 



Some lock managers (NLM, kNFSD) fastidiously avoid blocking their
kernel threads while servicing blocking locks.  If a filesystem supports
asynchronous lock requests those lock managers can use notifications to
quickly inform clients they have acquired a file lock.

Historically, only posix_lock_file() was capable of supporting asynchronous
locks so the check for support was simply file_operations->lock(), but with
recent changes in DLM, both GFS2 and OCFS2 also support asynchronous locks
and have started signalling their support with EXPORT_OP_ASYNC_LOCK.

We recently noticed that those changes dropped the checks for whether a
filesystem simply defaults to posix_lock_file(), so async lock
notifications have not been attempted for NLM and NFSv4.1+ for most
filesystems.  While trying to fix this it has become clear that testing
both the export flag combined with testing ->lock() creates quite a
layering mess.  It seems appropriate to signal support with a fop_flag.

Add FOP_ASYNC_LOCK so that filesystems with ->lock() can signal their
capability to handle lock requests asynchronously.  Add a helper for
lock managers to properly test that support.

Signed-off-by: default avatarBenjamin Coddington <bcodding@redhat.com>
Link: https://lore.kernel.org/r/3330d5a324abe2ce9c1dafe89cacdc6db41945d1.1726083391.git.bcodding@redhat.com


Reviewed-by: default avatarJeff Layton <jlayton@kernel.org>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent cef48236

include/linux/filelock.h

+5 −0
Original line number Diff line number Diff line
@@ -180,6 +180,11 @@ static inline void locks_wake_up(struct file_lock *fl) 
	wake_up(&fl->c.flc_wait);

}



static inline bool locks_can_async_lock(const struct file_operations *fops)

{

	return !fops->lock || fops->fop_flags & FOP_ASYNC_LOCK;

}



/* fs/locks.c */

void locks_free_lock_context(struct inode *inode);

void locks_free_lock(struct file_lock *fl);

include/linux/fs.h

+2 −0
Original line number Diff line number Diff line
@@ -2074,6 +2074,8 @@ struct file_operations { 
#define FOP_DIO_PARALLEL_WRITE	((__force fop_flags_t)(1 << 3))

/* Contains huge pages */

#define FOP_HUGE_PAGES		((__force fop_flags_t)(1 << 4))

/* Supports asynchronous lock callbacks */

#define FOP_ASYNC_LOCK		((__force fop_flags_t)(1 << 5))



/* Wrap a directory iterator that needs exclusive inode access */

int wrap_directory_iterator(struct file *, struct dir_context *,