| Message ID | 20230105211937.1572384-1-jlayton@kernel.org (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | [v2] filelock: move file locking definitions to separate header file | expand |
On Thu, Jan 05, 2023 at 04:19:29PM -0500, Jeff Layton wrote: > The file locking definitions have lived in fs.h since the dawn of time, > but they are only used by a small subset of the source files that > include it. > > Move the file locking definitions to a new header file, and add the > appropriate #include directives to the source files that need them. By > doing this we trim down fs.h a bit and limit the amount of rebuilding > that has to be done when we make changes to the file locking APIs. > > Reviewed-by: Xiubo Li <xiubli@redhat.com> > Reviewed-by: Christian Brauner (Microsoft) <brauner@kernel.org> > Reviewed-by: Christoph Hellwig <hch@lst.de> > Reviewed-by: David Howells <dhowells@redhat.com> > Acked-by: Chuck Lever <chuck.lever@oracle.com> > Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> > Acked-by: Steve French <stfrench@microsoft.com> > Signed-off-by: Jeff Layton <jlayton@kernel.org> The XFS part looks good, Acked-by: Darrick J. Wong <djwong@kernel.org> --D > --- > arch/arm/kernel/sys_oabi-compat.c | 1 + > fs/9p/vfs_file.c | 1 + > fs/afs/internal.h | 1 + > fs/attr.c | 1 + > fs/ceph/locks.c | 1 + > fs/cifs/cifsfs.c | 1 + > fs/cifs/cifsglob.h | 1 + > fs/cifs/cifssmb.c | 1 + > fs/cifs/file.c | 1 + > fs/cifs/smb2file.c | 1 + > fs/dlm/plock.c | 1 + > fs/fcntl.c | 1 + > fs/file_table.c | 1 + > fs/fuse/file.c | 1 + > fs/gfs2/file.c | 1 + > fs/inode.c | 1 + > fs/ksmbd/smb2pdu.c | 1 + > fs/ksmbd/vfs.c | 1 + > fs/ksmbd/vfs_cache.c | 1 + > fs/lockd/clntproc.c | 1 + > fs/lockd/netns.h | 1 + > fs/locks.c | 1 + > fs/namei.c | 1 + > fs/nfs/file.c | 1 + > fs/nfs/nfs4_fs.h | 1 + > fs/nfs/pagelist.c | 1 + > fs/nfs/write.c | 1 + > fs/nfs_common/grace.c | 1 + > fs/nfsd/netns.h | 1 + > fs/ocfs2/locks.c | 1 + > fs/ocfs2/stack_user.c | 1 + > fs/open.c | 1 + > fs/orangefs/file.c | 1 + > fs/posix_acl.c | 1 + > fs/proc/fd.c | 1 + > fs/utimes.c | 1 + > fs/xattr.c | 1 + > fs/xfs/xfs_linux.h | 1 + > include/linux/filelock.h | 438 ++++++++++++++++++++++++++++++ > include/linux/fs.h | 426 ----------------------------- > include/linux/lockd/xdr.h | 1 + > 41 files changed, 477 insertions(+), 426 deletions(-) > create mode 100644 include/linux/filelock.h > > v2: > - drop pointless externs from the new filelock.h > - move include into xfs_linux.h instead of xfs_buf.h > - have filelock.h #include fs.h. Any file including filelock.h will > almost certainly need fs.h anyway. > > I've left some of Al's comments unaddressed for now, as I'd like to keep > this move mostly mechanical, and no go changing function prototypes > until the dust settles. > > I'll plan to drop this into linux-next within the next few days, with an > eye toward merging this for v6.3. > > diff --git a/arch/arm/kernel/sys_oabi-compat.c b/arch/arm/kernel/sys_oabi-compat.c > index 68112c172025..006163195d67 100644 > --- a/arch/arm/kernel/sys_oabi-compat.c > +++ b/arch/arm/kernel/sys_oabi-compat.c > @@ -73,6 +73,7 @@ > #include <linux/syscalls.h> > #include <linux/errno.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/cred.h> > #include <linux/fcntl.h> > #include <linux/eventpoll.h> > diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c > index b740017634ef..b6ba22975781 100644 > --- a/fs/9p/vfs_file.c > +++ b/fs/9p/vfs_file.c > @@ -9,6 +9,7 @@ > #include <linux/module.h> > #include <linux/errno.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/sched.h> > #include <linux/file.h> > #include <linux/stat.h> > diff --git a/fs/afs/internal.h b/fs/afs/internal.h > index fd8567b98e2b..2d6d7dae225a 100644 > --- a/fs/afs/internal.h > +++ b/fs/afs/internal.h > @@ -9,6 +9,7 @@ > #include <linux/kernel.h> > #include <linux/ktime.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/pagemap.h> > #include <linux/rxrpc.h> > #include <linux/key.h> > diff --git a/fs/attr.c b/fs/attr.c > index b45f30e516fa..f3eb8e57b451 100644 > --- a/fs/attr.c > +++ b/fs/attr.c > @@ -14,6 +14,7 @@ > #include <linux/capability.h> > #include <linux/fsnotify.h> > #include <linux/fcntl.h> > +#include <linux/filelock.h> > #include <linux/security.h> > #include <linux/evm.h> > #include <linux/ima.h> > diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c > index f3b461c708a8..476f25bba263 100644 > --- a/fs/ceph/locks.c > +++ b/fs/ceph/locks.c > @@ -7,6 +7,7 @@ > > #include "super.h" > #include "mds_client.h" > +#include <linux/filelock.h> > #include <linux/ceph/pagelist.h> > > static u64 lock_secret; > diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c > index 10e00c624922..f052f190b2e8 100644 > --- a/fs/cifs/cifsfs.c > +++ b/fs/cifs/cifsfs.c > @@ -12,6 +12,7 @@ > > #include <linux/module.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/mount.h> > #include <linux/slab.h> > #include <linux/init.h> > diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h > index cfdd5bf701a1..cd8171a1c9a0 100644 > --- a/fs/cifs/cifsglob.h > +++ b/fs/cifs/cifsglob.h > @@ -26,6 +26,7 @@ > #include <uapi/linux/cifs/cifs_mount.h> > #include "../smbfs_common/smb2pdu.h" > #include "smb2pdu.h" > +#include <linux/filelock.h> > > #define SMB_PATH_MAX 260 > #define CIFS_PORT 445 > diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c > index 23f10e0d6e7e..60dd4e37030a 100644 > --- a/fs/cifs/cifssmb.c > +++ b/fs/cifs/cifssmb.c > @@ -15,6 +15,7 @@ > /* want to reuse a stale file handle and only the caller knows the file info */ > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/kernel.h> > #include <linux/vfs.h> > #include <linux/slab.h> > diff --git a/fs/cifs/file.c b/fs/cifs/file.c > index 22dfc1f8b4f1..1d9cc59d8259 100644 > --- a/fs/cifs/file.c > +++ b/fs/cifs/file.c > @@ -9,6 +9,7 @@ > * > */ > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/backing-dev.h> > #include <linux/stat.h> > #include <linux/fcntl.h> > diff --git a/fs/cifs/smb2file.c b/fs/cifs/smb2file.c > index ba6cc50af390..9f1dd04b555a 100644 > --- a/fs/cifs/smb2file.c > +++ b/fs/cifs/smb2file.c > @@ -7,6 +7,7 @@ > * > */ > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/stat.h> > #include <linux/slab.h> > #include <linux/pagemap.h> > diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c > index 737f185aad8d..ed4357e62f35 100644 > --- a/fs/dlm/plock.c > +++ b/fs/dlm/plock.c > @@ -4,6 +4,7 @@ > */ > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/miscdevice.h> > #include <linux/poll.h> > #include <linux/dlm.h> > diff --git a/fs/fcntl.c b/fs/fcntl.c > index 146c9ab0cd4b..7852e946fdf4 100644 > --- a/fs/fcntl.c > +++ b/fs/fcntl.c > @@ -10,6 +10,7 @@ > #include <linux/mm.h> > #include <linux/sched/task.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/file.h> > #include <linux/fdtable.h> > #include <linux/capability.h> > diff --git a/fs/file_table.c b/fs/file_table.c > index dd88701e54a9..372653b92617 100644 > --- a/fs/file_table.c > +++ b/fs/file_table.c > @@ -13,6 +13,7 @@ > #include <linux/init.h> > #include <linux/module.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/security.h> > #include <linux/cred.h> > #include <linux/eventpoll.h> > diff --git a/fs/fuse/file.c b/fs/fuse/file.c > index 875314ee6f59..1458412f2492 100644 > --- a/fs/fuse/file.c > +++ b/fs/fuse/file.c > @@ -18,6 +18,7 @@ > #include <linux/falloc.h> > #include <linux/uio.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > > static int fuse_send_open(struct fuse_mount *fm, u64 nodeid, > unsigned int open_flags, int opcode, > diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c > index eea5be4fbf0e..e8e20a716004 100644 > --- a/fs/gfs2/file.c > +++ b/fs/gfs2/file.c > @@ -15,6 +15,7 @@ > #include <linux/mm.h> > #include <linux/mount.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/gfs2_ondisk.h> > #include <linux/falloc.h> > #include <linux/swap.h> > diff --git a/fs/inode.c b/fs/inode.c > index f453eb58fd03..d02dd8f1e967 100644 > --- a/fs/inode.c > +++ b/fs/inode.c > @@ -5,6 +5,7 @@ > */ > #include <linux/export.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/mm.h> > #include <linux/backing-dev.h> > #include <linux/hash.h> > diff --git a/fs/ksmbd/smb2pdu.c b/fs/ksmbd/smb2pdu.c > index 14d7f3599c63..000a6648f122 100644 > --- a/fs/ksmbd/smb2pdu.c > +++ b/fs/ksmbd/smb2pdu.c > @@ -12,6 +12,7 @@ > #include <linux/ethtool.h> > #include <linux/falloc.h> > #include <linux/mount.h> > +#include <linux/filelock.h> > > #include "glob.h" > #include "smbfsctl.h" > diff --git a/fs/ksmbd/vfs.c b/fs/ksmbd/vfs.c > index ff0e7a4fcd4d..5851934dc85b 100644 > --- a/fs/ksmbd/vfs.c > +++ b/fs/ksmbd/vfs.c > @@ -6,6 +6,7 @@ > > #include <linux/kernel.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/uaccess.h> > #include <linux/backing-dev.h> > #include <linux/writeback.h> > diff --git a/fs/ksmbd/vfs_cache.c b/fs/ksmbd/vfs_cache.c > index da9163b00350..552c3882a8f4 100644 > --- a/fs/ksmbd/vfs_cache.c > +++ b/fs/ksmbd/vfs_cache.c > @@ -5,6 +5,7 @@ > */ > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/slab.h> > #include <linux/vmalloc.h> > > diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c > index 99fffc9cb958..e875a3571c41 100644 > --- a/fs/lockd/clntproc.c > +++ b/fs/lockd/clntproc.c > @@ -12,6 +12,7 @@ > #include <linux/types.h> > #include <linux/errno.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/nfs_fs.h> > #include <linux/utsname.h> > #include <linux/freezer.h> > diff --git a/fs/lockd/netns.h b/fs/lockd/netns.h > index 5bec78c8e431..17432c445fe6 100644 > --- a/fs/lockd/netns.h > +++ b/fs/lockd/netns.h > @@ -3,6 +3,7 @@ > #define __LOCKD_NETNS_H__ > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <net/netns/generic.h> > > struct lockd_net { > diff --git a/fs/locks.c b/fs/locks.c > index 8f01bee17715..a5cc90c958c9 100644 > --- a/fs/locks.c > +++ b/fs/locks.c > @@ -52,6 +52,7 @@ > #include <linux/capability.h> > #include <linux/file.h> > #include <linux/fdtable.h> > +#include <linux/filelock.h> > #include <linux/fs.h> > #include <linux/init.h> > #include <linux/security.h> > diff --git a/fs/namei.c b/fs/namei.c > index 309ae6fc8c99..60a9d3ac941f 100644 > --- a/fs/namei.c > +++ b/fs/namei.c > @@ -20,6 +20,7 @@ > #include <linux/kernel.h> > #include <linux/slab.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/namei.h> > #include <linux/pagemap.h> > #include <linux/sched/mm.h> > diff --git a/fs/nfs/file.c b/fs/nfs/file.c > index d8ec889a4b3f..b0f3c9339e70 100644 > --- a/fs/nfs/file.c > +++ b/fs/nfs/file.c > @@ -31,6 +31,7 @@ > #include <linux/swap.h> > > #include <linux/uaccess.h> > +#include <linux/filelock.h> > > #include "delegation.h" > #include "internal.h" > diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h > index 5edd1704f735..4c9f8bd866ab 100644 > --- a/fs/nfs/nfs4_fs.h > +++ b/fs/nfs/nfs4_fs.h > @@ -23,6 +23,7 @@ > #define NFS4_MAX_LOOP_ON_RECOVER (10) > > #include <linux/seqlock.h> > +#include <linux/filelock.h> > > struct idmap; > > diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c > index 16be6dae524f..779bfc37233c 100644 > --- a/fs/nfs/pagelist.c > +++ b/fs/nfs/pagelist.c > @@ -21,6 +21,7 @@ > #include <linux/nfs_page.h> > #include <linux/nfs_mount.h> > #include <linux/export.h> > +#include <linux/filelock.h> > > #include "internal.h" > #include "pnfs.h" > diff --git a/fs/nfs/write.c b/fs/nfs/write.c > index 80c240e50952..1a80d548253a 100644 > --- a/fs/nfs/write.c > +++ b/fs/nfs/write.c > @@ -25,6 +25,7 @@ > #include <linux/freezer.h> > #include <linux/wait.h> > #include <linux/iversion.h> > +#include <linux/filelock.h> > > #include <linux/uaccess.h> > #include <linux/sched/mm.h> > diff --git a/fs/nfs_common/grace.c b/fs/nfs_common/grace.c > index 0a9b72685f98..1479583fbb62 100644 > --- a/fs/nfs_common/grace.c > +++ b/fs/nfs_common/grace.c > @@ -9,6 +9,7 @@ > #include <net/net_namespace.h> > #include <net/netns/generic.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > > static unsigned int grace_net_id; > static DEFINE_SPINLOCK(grace_lock); > diff --git a/fs/nfsd/netns.h b/fs/nfsd/netns.h > index 8c854ba3285b..bc139401927d 100644 > --- a/fs/nfsd/netns.h > +++ b/fs/nfsd/netns.h > @@ -10,6 +10,7 @@ > > #include <net/net_namespace.h> > #include <net/netns/generic.h> > +#include <linux/filelock.h> > #include <linux/percpu_counter.h> > #include <linux/siphash.h> > > diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c > index 73a3854b2afb..f37174e79fad 100644 > --- a/fs/ocfs2/locks.c > +++ b/fs/ocfs2/locks.c > @@ -8,6 +8,7 @@ > */ > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/fcntl.h> > > #include <cluster/masklog.h> > diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c > index 64e6ddcfe329..05d4414d0c33 100644 > --- a/fs/ocfs2/stack_user.c > +++ b/fs/ocfs2/stack_user.c > @@ -9,6 +9,7 @@ > > #include <linux/module.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/miscdevice.h> > #include <linux/mutex.h> > #include <linux/slab.h> > diff --git a/fs/open.c b/fs/open.c > index 82c1a28b3308..9b1c08298a07 100644 > --- a/fs/open.c > +++ b/fs/open.c > @@ -33,6 +33,7 @@ > #include <linux/dnotify.h> > #include <linux/compat.h> > #include <linux/mnt_idmapping.h> > +#include <linux/filelock.h> > > #include "internal.h" > > diff --git a/fs/orangefs/file.c b/fs/orangefs/file.c > index 167fa43b24f9..4ecb91a9bbeb 100644 > --- a/fs/orangefs/file.c > +++ b/fs/orangefs/file.c > @@ -14,6 +14,7 @@ > #include "orangefs-kernel.h" > #include "orangefs-bufmap.h" > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/pagemap.h> > > static int flush_racache(struct inode *inode) > diff --git a/fs/posix_acl.c b/fs/posix_acl.c > index d7bc81fc0840..d2271431f344 100644 > --- a/fs/posix_acl.c > +++ b/fs/posix_acl.c > @@ -28,6 +28,7 @@ > #include <linux/security.h> > #include <linux/evm.h> > #include <linux/fsnotify.h> > +#include <linux/filelock.h> > > #include "internal.h" > > diff --git a/fs/proc/fd.c b/fs/proc/fd.c > index fc46d6fe080c..53e4919ef860 100644 > --- a/fs/proc/fd.c > +++ b/fs/proc/fd.c > @@ -12,6 +12,7 @@ > #include <linux/file.h> > #include <linux/seq_file.h> > #include <linux/fs.h> > +#include <linux/filelock.h> > > #include <linux/proc_fs.h> > > diff --git a/fs/utimes.c b/fs/utimes.c > index 39f356017635..00499e4ba955 100644 > --- a/fs/utimes.c > +++ b/fs/utimes.c > @@ -7,6 +7,7 @@ > #include <linux/uaccess.h> > #include <linux/compat.h> > #include <asm/unistd.h> > +#include <linux/filelock.h> > > static bool nsec_valid(long nsec) > { > diff --git a/fs/xattr.c b/fs/xattr.c > index adab9a70b536..3fead374901b 100644 > --- a/fs/xattr.c > +++ b/fs/xattr.c > @@ -9,6 +9,7 @@ > Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com> > */ > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/slab.h> > #include <linux/file.h> > #include <linux/xattr.h> > diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h > index f9878021e7d0..e88f18f85e4b 100644 > --- a/fs/xfs/xfs_linux.h > +++ b/fs/xfs/xfs_linux.h > @@ -34,6 +34,7 @@ typedef __u32 xfs_nlink_t; > #include <linux/module.h> > #include <linux/mutex.h> > #include <linux/file.h> > +#include <linux/filelock.h> > #include <linux/swap.h> > #include <linux/errno.h> > #include <linux/sched/signal.h> > diff --git a/include/linux/filelock.h b/include/linux/filelock.h > new file mode 100644 > index 000000000000..deee04385127 > --- /dev/null > +++ b/include/linux/filelock.h > @@ -0,0 +1,438 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef _LINUX_FILELOCK_H > +#define _LINUX_FILELOCK_H > + > +#include <linux/fs.h> > + > +#define FL_POSIX 1 > +#define FL_FLOCK 2 > +#define FL_DELEG 4 /* NFSv4 delegation */ > +#define FL_ACCESS 8 /* not trying to lock, just looking */ > +#define FL_EXISTS 16 /* when unlocking, test for existence */ > +#define FL_LEASE 32 /* lease held on this file */ > +#define FL_CLOSE 64 /* unlock on close */ > +#define FL_SLEEP 128 /* A blocking lock */ > +#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ > +#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ > +#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ > +#define FL_LAYOUT 2048 /* outstanding pNFS layout */ > +#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ > + > +#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) > + > +/* > + * Special return value from posix_lock_file() and vfs_lock_file() for > + * asynchronous locking. > + */ > +#define FILE_LOCK_DEFERRED 1 > + > +struct file_lock; > + > +struct file_lock_operations { > + void (*fl_copy_lock)(struct file_lock *, struct file_lock *); > + void (*fl_release_private)(struct file_lock *); > +}; > + > +struct lock_manager_operations { > + void *lm_mod_owner; > + fl_owner_t (*lm_get_owner)(fl_owner_t); > + void (*lm_put_owner)(fl_owner_t); > + void (*lm_notify)(struct file_lock *); /* unblock callback */ > + int (*lm_grant)(struct file_lock *, int); > + bool (*lm_break)(struct file_lock *); > + int (*lm_change)(struct file_lock *, int, struct list_head *); > + void (*lm_setup)(struct file_lock *, void **); > + bool (*lm_breaker_owns_lease)(struct file_lock *); > + bool (*lm_lock_expirable)(struct file_lock *cfl); > + void (*lm_expire_lock)(void); > +}; > + > +struct lock_manager { > + struct list_head list; > + /* > + * NFSv4 and up also want opens blocked during the grace period; > + * NLM doesn't care: > + */ > + bool block_opens; > +}; > + > +struct net; > +void locks_start_grace(struct net *, struct lock_manager *); > +void locks_end_grace(struct lock_manager *); > +bool locks_in_grace(struct net *); > +bool opens_in_grace(struct net *); > + > +/* > + * struct file_lock has a union that some filesystems use to track > + * their own private info. The NFS side of things is defined here: > + */ > +#include <linux/nfs_fs_i.h> > + > +/* > + * struct file_lock represents a generic "file lock". It's used to represent > + * POSIX byte range locks, BSD (flock) locks, and leases. It's important to > + * note that the same struct is used to represent both a request for a lock and > + * the lock itself, but the same object is never used for both. > + * > + * FIXME: should we create a separate "struct lock_request" to help distinguish > + * these two uses? > + * > + * The varous i_flctx lists are ordered by: > + * > + * 1) lock owner > + * 2) lock range start > + * 3) lock range end > + * > + * Obviously, the last two criteria only matter for POSIX locks. > + */ > +struct file_lock { > + struct file_lock *fl_blocker; /* The lock, that is blocking us */ > + struct list_head fl_list; /* link into file_lock_context */ > + struct hlist_node fl_link; /* node in global lists */ > + struct list_head fl_blocked_requests; /* list of requests with > + * ->fl_blocker pointing here > + */ > + struct list_head fl_blocked_member; /* node in > + * ->fl_blocker->fl_blocked_requests > + */ > + fl_owner_t fl_owner; > + unsigned int fl_flags; > + unsigned char fl_type; > + unsigned int fl_pid; > + int fl_link_cpu; /* what cpu's list is this on? */ > + wait_queue_head_t fl_wait; > + struct file *fl_file; > + loff_t fl_start; > + loff_t fl_end; > + > + struct fasync_struct * fl_fasync; /* for lease break notifications */ > + /* for lease breaks: */ > + unsigned long fl_break_time; > + unsigned long fl_downgrade_time; > + > + const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ > + const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ > + union { > + struct nfs_lock_info nfs_fl; > + struct nfs4_lock_info nfs4_fl; > + struct { > + struct list_head link; /* link in AFS vnode's pending_locks list */ > + int state; /* state of grant or error if -ve */ > + unsigned int debug_id; > + } afs; > + } fl_u; > +} __randomize_layout; > + > +struct file_lock_context { > + spinlock_t flc_lock; > + struct list_head flc_flock; > + struct list_head flc_posix; > + struct list_head flc_lease; > +}; > + > +#define locks_inode(f) file_inode(f) > + > +#ifdef CONFIG_FILE_LOCKING > +int fcntl_getlk(struct file *, unsigned int, struct flock *); > +int fcntl_setlk(unsigned int, struct file *, unsigned int, > + struct flock *); > + > +#if BITS_PER_LONG == 32 > +int fcntl_getlk64(struct file *, unsigned int, struct flock64 *); > +int fcntl_setlk64(unsigned int, struct file *, unsigned int, > + struct flock64 *); > +#endif > + > +int fcntl_setlease(unsigned int fd, struct file *filp, long arg); > +int fcntl_getlease(struct file *filp); > + > +/* fs/locks.c */ > +void locks_free_lock_context(struct inode *inode); > +void locks_free_lock(struct file_lock *fl); > +void locks_init_lock(struct file_lock *); > +struct file_lock * locks_alloc_lock(void); > +void locks_copy_lock(struct file_lock *, struct file_lock *); > +void locks_copy_conflock(struct file_lock *, struct file_lock *); > +void locks_remove_posix(struct file *, fl_owner_t); > +void locks_remove_file(struct file *); > +void locks_release_private(struct file_lock *); > +void posix_test_lock(struct file *, struct file_lock *); > +int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); > +int locks_delete_block(struct file_lock *); > +int vfs_test_lock(struct file *, struct file_lock *); > +int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *); > +int vfs_cancel_lock(struct file *filp, struct file_lock *fl); > +bool vfs_inode_has_locks(struct inode *inode); > +int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl); > +int __break_lease(struct inode *inode, unsigned int flags, unsigned int type); > +void lease_get_mtime(struct inode *, struct timespec64 *time); > +int generic_setlease(struct file *, long, struct file_lock **, void **priv); > +int vfs_setlease(struct file *, long, struct file_lock **, void **); > +int lease_modify(struct file_lock *, int, struct list_head *); > + > +struct notifier_block; > +int lease_register_notifier(struct notifier_block *); > +void lease_unregister_notifier(struct notifier_block *); > + > +struct files_struct; > +void show_fd_locks(struct seq_file *f, > + struct file *filp, struct files_struct *files); > +bool locks_owner_has_blockers(struct file_lock_context *flctx, > + fl_owner_t owner); > + > +static inline struct file_lock_context * > +locks_inode_context(const struct inode *inode) > +{ > + return smp_load_acquire(&inode->i_flctx); > +} > + > +#else /* !CONFIG_FILE_LOCKING */ > +static inline int fcntl_getlk(struct file *file, unsigned int cmd, > + struct flock __user *user) > +{ > + return -EINVAL; > +} > + > +static inline int fcntl_setlk(unsigned int fd, struct file *file, > + unsigned int cmd, struct flock __user *user) > +{ > + return -EACCES; > +} > + > +#if BITS_PER_LONG == 32 > +static inline int fcntl_getlk64(struct file *file, unsigned int cmd, > + struct flock64 *user) > +{ > + return -EINVAL; > +} > + > +static inline int fcntl_setlk64(unsigned int fd, struct file *file, > + unsigned int cmd, struct flock64 *user) > +{ > + return -EACCES; > +} > +#endif > +static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) > +{ > + return -EINVAL; > +} > + > +static inline int fcntl_getlease(struct file *filp) > +{ > + return F_UNLCK; > +} > + > +static inline void > +locks_free_lock_context(struct inode *inode) > +{ > +} > + > +static inline void locks_init_lock(struct file_lock *fl) > +{ > + return; > +} > + > +static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) > +{ > + return; > +} > + > +static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) > +{ > + return; > +} > + > +static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) > +{ > + return; > +} > + > +static inline void locks_remove_file(struct file *filp) > +{ > + return; > +} > + > +static inline void posix_test_lock(struct file *filp, struct file_lock *fl) > +{ > + return; > +} > + > +static inline int posix_lock_file(struct file *filp, struct file_lock *fl, > + struct file_lock *conflock) > +{ > + return -ENOLCK; > +} > + > +static inline int locks_delete_block(struct file_lock *waiter) > +{ > + return -ENOENT; > +} > + > +static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) > +{ > + return 0; > +} > + > +static inline int vfs_lock_file(struct file *filp, unsigned int cmd, > + struct file_lock *fl, struct file_lock *conf) > +{ > + return -ENOLCK; > +} > + > +static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) > +{ > + return 0; > +} > + > +static inline bool vfs_inode_has_locks(struct inode *inode) > +{ > + return false; > +} > + > +static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) > +{ > + return -ENOLCK; > +} > + > +static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) > +{ > + return 0; > +} > + > +static inline void lease_get_mtime(struct inode *inode, > + struct timespec64 *time) > +{ > + return; > +} > + > +static inline int generic_setlease(struct file *filp, long arg, > + struct file_lock **flp, void **priv) > +{ > + return -EINVAL; > +} > + > +static inline int vfs_setlease(struct file *filp, long arg, > + struct file_lock **lease, void **priv) > +{ > + return -EINVAL; > +} > + > +static inline int lease_modify(struct file_lock *fl, int arg, > + struct list_head *dispose) > +{ > + return -EINVAL; > +} > + > +struct files_struct; > +static inline void show_fd_locks(struct seq_file *f, > + struct file *filp, struct files_struct *files) {} > +static inline bool locks_owner_has_blockers(struct file_lock_context *flctx, > + fl_owner_t owner) > +{ > + return false; > +} > + > +static inline struct file_lock_context * > +locks_inode_context(const struct inode *inode) > +{ > + return NULL; > +} > + > +#endif /* !CONFIG_FILE_LOCKING */ > + > +static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl) > +{ > + return locks_lock_inode_wait(locks_inode(filp), fl); > +} > + > +#ifdef CONFIG_FILE_LOCKING > +static inline int break_lease(struct inode *inode, unsigned int mode) > +{ > + /* > + * Since this check is lockless, we must ensure that any refcounts > + * taken are done before checking i_flctx->flc_lease. Otherwise, we > + * could end up racing with tasks trying to set a new lease on this > + * file. > + */ > + smp_mb(); > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > + return __break_lease(inode, mode, FL_LEASE); > + return 0; > +} > + > +static inline int break_deleg(struct inode *inode, unsigned int mode) > +{ > + /* > + * Since this check is lockless, we must ensure that any refcounts > + * taken are done before checking i_flctx->flc_lease. Otherwise, we > + * could end up racing with tasks trying to set a new lease on this > + * file. > + */ > + smp_mb(); > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > + return __break_lease(inode, mode, FL_DELEG); > + return 0; > +} > + > +static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) > +{ > + int ret; > + > + ret = break_deleg(inode, O_WRONLY|O_NONBLOCK); > + if (ret == -EWOULDBLOCK && delegated_inode) { > + *delegated_inode = inode; > + ihold(inode); > + } > + return ret; > +} > + > +static inline int break_deleg_wait(struct inode **delegated_inode) > +{ > + int ret; > + > + ret = break_deleg(*delegated_inode, O_WRONLY); > + iput(*delegated_inode); > + *delegated_inode = NULL; > + return ret; > +} > + > +static inline int break_layout(struct inode *inode, bool wait) > +{ > + smp_mb(); > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > + return __break_lease(inode, > + wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, > + FL_LAYOUT); > + return 0; > +} > + > +#else /* !CONFIG_FILE_LOCKING */ > +static inline int break_lease(struct inode *inode, unsigned int mode) > +{ > + return 0; > +} > + > +static inline int break_deleg(struct inode *inode, unsigned int mode) > +{ > + return 0; > +} > + > +static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) > +{ > + return 0; > +} > + > +static inline int break_deleg_wait(struct inode **delegated_inode) > +{ > + BUG(); > + return 0; > +} > + > +static inline int break_layout(struct inode *inode, bool wait) > +{ > + return 0; > +} > + > +#endif /* CONFIG_FILE_LOCKING */ > + > +#endif /* _LINUX_FILELOCK_H */ > diff --git a/include/linux/fs.h b/include/linux/fs.h > index 066555ad1bf8..006278d84d2f 100644 > --- a/include/linux/fs.h > +++ b/include/linux/fs.h > @@ -1003,132 +1003,11 @@ static inline struct file *get_file(struct file *f) > #define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX) > #endif > > -#define FL_POSIX 1 > -#define FL_FLOCK 2 > -#define FL_DELEG 4 /* NFSv4 delegation */ > -#define FL_ACCESS 8 /* not trying to lock, just looking */ > -#define FL_EXISTS 16 /* when unlocking, test for existence */ > -#define FL_LEASE 32 /* lease held on this file */ > -#define FL_CLOSE 64 /* unlock on close */ > -#define FL_SLEEP 128 /* A blocking lock */ > -#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ > -#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ > -#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ > -#define FL_LAYOUT 2048 /* outstanding pNFS layout */ > -#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ > - > -#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) > - > -/* > - * Special return value from posix_lock_file() and vfs_lock_file() for > - * asynchronous locking. > - */ > -#define FILE_LOCK_DEFERRED 1 > - > /* legacy typedef, should eventually be removed */ > typedef void *fl_owner_t; > > struct file_lock; > > -struct file_lock_operations { > - void (*fl_copy_lock)(struct file_lock *, struct file_lock *); > - void (*fl_release_private)(struct file_lock *); > -}; > - > -struct lock_manager_operations { > - void *lm_mod_owner; > - fl_owner_t (*lm_get_owner)(fl_owner_t); > - void (*lm_put_owner)(fl_owner_t); > - void (*lm_notify)(struct file_lock *); /* unblock callback */ > - int (*lm_grant)(struct file_lock *, int); > - bool (*lm_break)(struct file_lock *); > - int (*lm_change)(struct file_lock *, int, struct list_head *); > - void (*lm_setup)(struct file_lock *, void **); > - bool (*lm_breaker_owns_lease)(struct file_lock *); > - bool (*lm_lock_expirable)(struct file_lock *cfl); > - void (*lm_expire_lock)(void); > -}; > - > -struct lock_manager { > - struct list_head list; > - /* > - * NFSv4 and up also want opens blocked during the grace period; > - * NLM doesn't care: > - */ > - bool block_opens; > -}; > - > -struct net; > -void locks_start_grace(struct net *, struct lock_manager *); > -void locks_end_grace(struct lock_manager *); > -bool locks_in_grace(struct net *); > -bool opens_in_grace(struct net *); > - > -/* that will die - we need it for nfs_lock_info */ > -#include <linux/nfs_fs_i.h> > - > -/* > - * struct file_lock represents a generic "file lock". It's used to represent > - * POSIX byte range locks, BSD (flock) locks, and leases. It's important to > - * note that the same struct is used to represent both a request for a lock and > - * the lock itself, but the same object is never used for both. > - * > - * FIXME: should we create a separate "struct lock_request" to help distinguish > - * these two uses? > - * > - * The varous i_flctx lists are ordered by: > - * > - * 1) lock owner > - * 2) lock range start > - * 3) lock range end > - * > - * Obviously, the last two criteria only matter for POSIX locks. > - */ > -struct file_lock { > - struct file_lock *fl_blocker; /* The lock, that is blocking us */ > - struct list_head fl_list; /* link into file_lock_context */ > - struct hlist_node fl_link; /* node in global lists */ > - struct list_head fl_blocked_requests; /* list of requests with > - * ->fl_blocker pointing here > - */ > - struct list_head fl_blocked_member; /* node in > - * ->fl_blocker->fl_blocked_requests > - */ > - fl_owner_t fl_owner; > - unsigned int fl_flags; > - unsigned char fl_type; > - unsigned int fl_pid; > - int fl_link_cpu; /* what cpu's list is this on? */ > - wait_queue_head_t fl_wait; > - struct file *fl_file; > - loff_t fl_start; > - loff_t fl_end; > - > - struct fasync_struct * fl_fasync; /* for lease break notifications */ > - /* for lease breaks: */ > - unsigned long fl_break_time; > - unsigned long fl_downgrade_time; > - > - const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ > - const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ > - union { > - struct nfs_lock_info nfs_fl; > - struct nfs4_lock_info nfs4_fl; > - struct { > - struct list_head link; /* link in AFS vnode's pending_locks list */ > - int state; /* state of grant or error if -ve */ > - unsigned int debug_id; > - } afs; > - } fl_u; > -} __randomize_layout; > - > -struct file_lock_context { > - spinlock_t flc_lock; > - struct list_head flc_flock; > - struct list_head flc_posix; > - struct list_head flc_lease; > -}; > - > /* The following constant reflects the upper bound of the file/locking space */ > #ifndef OFFSET_MAX > #define OFFSET_MAX type_max(loff_t) > @@ -1137,216 +1016,6 @@ struct file_lock_context { > > extern void send_sigio(struct fown_struct *fown, int fd, int band); > > -#define locks_inode(f) file_inode(f) > - > -#ifdef CONFIG_FILE_LOCKING > -extern int fcntl_getlk(struct file *, unsigned int, struct flock *); > -extern int fcntl_setlk(unsigned int, struct file *, unsigned int, > - struct flock *); > - > -#if BITS_PER_LONG == 32 > -extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *); > -extern int fcntl_setlk64(unsigned int, struct file *, unsigned int, > - struct flock64 *); > -#endif > - > -extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg); > -extern int fcntl_getlease(struct file *filp); > - > -/* fs/locks.c */ > -void locks_free_lock_context(struct inode *inode); > -void locks_free_lock(struct file_lock *fl); > -extern void locks_init_lock(struct file_lock *); > -extern struct file_lock * locks_alloc_lock(void); > -extern void locks_copy_lock(struct file_lock *, struct file_lock *); > -extern void locks_copy_conflock(struct file_lock *, struct file_lock *); > -extern void locks_remove_posix(struct file *, fl_owner_t); > -extern void locks_remove_file(struct file *); > -extern void locks_release_private(struct file_lock *); > -extern void posix_test_lock(struct file *, struct file_lock *); > -extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); > -extern int locks_delete_block(struct file_lock *); > -extern int vfs_test_lock(struct file *, struct file_lock *); > -extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *); > -extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl); > -bool vfs_inode_has_locks(struct inode *inode); > -extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl); > -extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type); > -extern void lease_get_mtime(struct inode *, struct timespec64 *time); > -extern int generic_setlease(struct file *, long, struct file_lock **, void **priv); > -extern int vfs_setlease(struct file *, long, struct file_lock **, void **); > -extern int lease_modify(struct file_lock *, int, struct list_head *); > - > -struct notifier_block; > -extern int lease_register_notifier(struct notifier_block *); > -extern void lease_unregister_notifier(struct notifier_block *); > - > -struct files_struct; > -extern void show_fd_locks(struct seq_file *f, > - struct file *filp, struct files_struct *files); > -extern bool locks_owner_has_blockers(struct file_lock_context *flctx, > - fl_owner_t owner); > - > -static inline struct file_lock_context * > -locks_inode_context(const struct inode *inode) > -{ > - return smp_load_acquire(&inode->i_flctx); > -} > - > -#else /* !CONFIG_FILE_LOCKING */ > -static inline int fcntl_getlk(struct file *file, unsigned int cmd, > - struct flock __user *user) > -{ > - return -EINVAL; > -} > - > -static inline int fcntl_setlk(unsigned int fd, struct file *file, > - unsigned int cmd, struct flock __user *user) > -{ > - return -EACCES; > -} > - > -#if BITS_PER_LONG == 32 > -static inline int fcntl_getlk64(struct file *file, unsigned int cmd, > - struct flock64 *user) > -{ > - return -EINVAL; > -} > - > -static inline int fcntl_setlk64(unsigned int fd, struct file *file, > - unsigned int cmd, struct flock64 *user) > -{ > - return -EACCES; > -} > -#endif > -static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) > -{ > - return -EINVAL; > -} > - > -static inline int fcntl_getlease(struct file *filp) > -{ > - return F_UNLCK; > -} > - > -static inline void > -locks_free_lock_context(struct inode *inode) > -{ > -} > - > -static inline void locks_init_lock(struct file_lock *fl) > -{ > - return; > -} > - > -static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) > -{ > - return; > -} > - > -static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) > -{ > - return; > -} > - > -static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) > -{ > - return; > -} > - > -static inline void locks_remove_file(struct file *filp) > -{ > - return; > -} > - > -static inline void posix_test_lock(struct file *filp, struct file_lock *fl) > -{ > - return; > -} > - > -static inline int posix_lock_file(struct file *filp, struct file_lock *fl, > - struct file_lock *conflock) > -{ > - return -ENOLCK; > -} > - > -static inline int locks_delete_block(struct file_lock *waiter) > -{ > - return -ENOENT; > -} > - > -static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) > -{ > - return 0; > -} > - > -static inline int vfs_lock_file(struct file *filp, unsigned int cmd, > - struct file_lock *fl, struct file_lock *conf) > -{ > - return -ENOLCK; > -} > - > -static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) > -{ > - return 0; > -} > - > -static inline bool vfs_inode_has_locks(struct inode *inode) > -{ > - return false; > -} > - > -static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) > -{ > - return -ENOLCK; > -} > - > -static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) > -{ > - return 0; > -} > - > -static inline void lease_get_mtime(struct inode *inode, > - struct timespec64 *time) > -{ > - return; > -} > - > -static inline int generic_setlease(struct file *filp, long arg, > - struct file_lock **flp, void **priv) > -{ > - return -EINVAL; > -} > - > -static inline int vfs_setlease(struct file *filp, long arg, > - struct file_lock **lease, void **priv) > -{ > - return -EINVAL; > -} > - > -static inline int lease_modify(struct file_lock *fl, int arg, > - struct list_head *dispose) > -{ > - return -EINVAL; > -} > - > -struct files_struct; > -static inline void show_fd_locks(struct seq_file *f, > - struct file *filp, struct files_struct *files) {} > -static inline bool locks_owner_has_blockers(struct file_lock_context *flctx, > - fl_owner_t owner) > -{ > - return false; > -} > - > -static inline struct file_lock_context * > -locks_inode_context(const struct inode *inode) > -{ > - return NULL; > -} > - > -#endif /* !CONFIG_FILE_LOCKING */ > - > static inline struct inode *file_inode(const struct file *f) > { > return f->f_inode; > @@ -1357,11 +1026,6 @@ static inline struct dentry *file_dentry(const struct file *file) > return d_real(file->f_path.dentry, file_inode(file)); > } > > -static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl) > -{ > - return locks_lock_inode_wait(locks_inode(filp), fl); > -} > - > struct fasync_struct { > rwlock_t fa_lock; > int magic; > @@ -2621,96 +2285,6 @@ extern struct kobject *fs_kobj; > > #define MAX_RW_COUNT (INT_MAX & PAGE_MASK) > > -#ifdef CONFIG_FILE_LOCKING > -static inline int break_lease(struct inode *inode, unsigned int mode) > -{ > - /* > - * Since this check is lockless, we must ensure that any refcounts > - * taken are done before checking i_flctx->flc_lease. Otherwise, we > - * could end up racing with tasks trying to set a new lease on this > - * file. > - */ > - smp_mb(); > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > - return __break_lease(inode, mode, FL_LEASE); > - return 0; > -} > - > -static inline int break_deleg(struct inode *inode, unsigned int mode) > -{ > - /* > - * Since this check is lockless, we must ensure that any refcounts > - * taken are done before checking i_flctx->flc_lease. Otherwise, we > - * could end up racing with tasks trying to set a new lease on this > - * file. > - */ > - smp_mb(); > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > - return __break_lease(inode, mode, FL_DELEG); > - return 0; > -} > - > -static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) > -{ > - int ret; > - > - ret = break_deleg(inode, O_WRONLY|O_NONBLOCK); > - if (ret == -EWOULDBLOCK && delegated_inode) { > - *delegated_inode = inode; > - ihold(inode); > - } > - return ret; > -} > - > -static inline int break_deleg_wait(struct inode **delegated_inode) > -{ > - int ret; > - > - ret = break_deleg(*delegated_inode, O_WRONLY); > - iput(*delegated_inode); > - *delegated_inode = NULL; > - return ret; > -} > - > -static inline int break_layout(struct inode *inode, bool wait) > -{ > - smp_mb(); > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) > - return __break_lease(inode, > - wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, > - FL_LAYOUT); > - return 0; > -} > - > -#else /* !CONFIG_FILE_LOCKING */ > -static inline int break_lease(struct inode *inode, unsigned int mode) > -{ > - return 0; > -} > - > -static inline int break_deleg(struct inode *inode, unsigned int mode) > -{ > - return 0; > -} > - > -static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) > -{ > - return 0; > -} > - > -static inline int break_deleg_wait(struct inode **delegated_inode) > -{ > - BUG(); > - return 0; > -} > - > -static inline int break_layout(struct inode *inode, bool wait) > -{ > - return 0; > -} > - > -#endif /* CONFIG_FILE_LOCKING */ > - > /* fs/open.c */ > struct audit_names; > struct filename { > diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h > index 67e4a2c5500b..b60fbcd8cdfa 100644 > --- a/include/linux/lockd/xdr.h > +++ b/include/linux/lockd/xdr.h > @@ -11,6 +11,7 @@ > #define LOCKD_XDR_H > > #include <linux/fs.h> > +#include <linux/filelock.h> > #include <linux/nfs.h> > #include <linux/sunrpc/xdr.h> > > -- > 2.39.0 >
On 06/01/2023 05:19, Jeff Layton wrote: > The file locking definitions have lived in fs.h since the dawn of time, > but they are only used by a small subset of the source files that > include it. > > Move the file locking definitions to a new header file, and add the > appropriate #include directives to the source files that need them. By > doing this we trim down fs.h a bit and limit the amount of rebuilding > that has to be done when we make changes to the file locking APIs. > > Reviewed-by: Xiubo Li <xiubli@redhat.com> > Reviewed-by: Christian Brauner (Microsoft) <brauner@kernel.org> > Reviewed-by: Christoph Hellwig <hch@lst.de> > Reviewed-by: David Howells <dhowells@redhat.com> > Acked-by: Chuck Lever <chuck.lever@oracle.com> > Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> > Acked-by: Steve French <stfrench@microsoft.com> > Signed-off-by: Jeff Layton <jlayton@kernel.org> > --- > arch/arm/kernel/sys_oabi-compat.c | 1 + > fs/9p/vfs_file.c | 1 + > fs/afs/internal.h | 1 + > fs/attr.c | 1 + > fs/ceph/locks.c | 1 + ceph part looks good to me. Thanks - Xiubo
On Wed, 2023-01-11 at 02:12 +0000, Al Viro wrote: > On Thu, Jan 05, 2023 at 04:19:29PM -0500, Jeff Layton wrote: > > The file locking definitions have lived in fs.h since the dawn of time, > > but they are only used by a small subset of the source files that > > include it. > > > > Move the file locking definitions to a new header file, and add the > > appropriate #include directives to the source files that need them. By > > doing this we trim down fs.h a bit and limit the amount of rebuilding > > that has to be done when we make changes to the file locking APIs. > > > > Reviewed-by: Xiubo Li <xiubli@redhat.com> > > Reviewed-by: Christian Brauner (Microsoft) <brauner@kernel.org> > > Reviewed-by: Christoph Hellwig <hch@lst.de> > > Reviewed-by: David Howells <dhowells@redhat.com> > > Acked-by: Chuck Lever <chuck.lever@oracle.com> > > Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> > > Acked-by: Steve French <stfrench@microsoft.com> > > Signed-off-by: Jeff Layton <jlayton@kernel.org> > > Same question re git tree preferences (and my Acked-by in any case) I'll take this one via the file locking tree as well. FWIW, I have some other filelock API changes I'd like to propose, so I think that'll be easier. Thanks,
On Thu, Jan 05, 2023 at 04:19:29PM -0500, Jeff Layton wrote: > The file locking definitions have lived in fs.h since the dawn of time, > but they are only used by a small subset of the source files that > include it. > > Move the file locking definitions to a new header file, and add the > appropriate #include directives to the source files that need them. By > doing this we trim down fs.h a bit and limit the amount of rebuilding > that has to be done when we make changes to the file locking APIs. > > Reviewed-by: Xiubo Li <xiubli@redhat.com> > Reviewed-by: Christian Brauner (Microsoft) <brauner@kernel.org> > Reviewed-by: Christoph Hellwig <hch@lst.de> > Reviewed-by: David Howells <dhowells@redhat.com> > Acked-by: Chuck Lever <chuck.lever@oracle.com> > Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com> > Acked-by: Steve French <stfrench@microsoft.com> > Signed-off-by: Jeff Layton <jlayton@kernel.org> > --- > arch/arm/kernel/sys_oabi-compat.c | 1 + For arm: Reviewed-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk> Thanks.
diff --git a/arch/arm/kernel/sys_oabi-compat.c b/arch/arm/kernel/sys_oabi-compat.c index 68112c172025..006163195d67 100644 --- a/arch/arm/kernel/sys_oabi-compat.c +++ b/arch/arm/kernel/sys_oabi-compat.c @@ -73,6 +73,7 @@ #include <linux/syscalls.h> #include <linux/errno.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/cred.h> #include <linux/fcntl.h> #include <linux/eventpoll.h> diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c index b740017634ef..b6ba22975781 100644 --- a/fs/9p/vfs_file.c +++ b/fs/9p/vfs_file.c @@ -9,6 +9,7 @@ #include <linux/module.h> #include <linux/errno.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/sched.h> #include <linux/file.h> #include <linux/stat.h> diff --git a/fs/afs/internal.h b/fs/afs/internal.h index fd8567b98e2b..2d6d7dae225a 100644 --- a/fs/afs/internal.h +++ b/fs/afs/internal.h @@ -9,6 +9,7 @@ #include <linux/kernel.h> #include <linux/ktime.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/pagemap.h> #include <linux/rxrpc.h> #include <linux/key.h> diff --git a/fs/attr.c b/fs/attr.c index b45f30e516fa..f3eb8e57b451 100644 --- a/fs/attr.c +++ b/fs/attr.c @@ -14,6 +14,7 @@ #include <linux/capability.h> #include <linux/fsnotify.h> #include <linux/fcntl.h> +#include <linux/filelock.h> #include <linux/security.h> #include <linux/evm.h> #include <linux/ima.h> diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c index f3b461c708a8..476f25bba263 100644 --- a/fs/ceph/locks.c +++ b/fs/ceph/locks.c @@ -7,6 +7,7 @@ #include "super.h" #include "mds_client.h" +#include <linux/filelock.h> #include <linux/ceph/pagelist.h> static u64 lock_secret; diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c index 10e00c624922..f052f190b2e8 100644 --- a/fs/cifs/cifsfs.c +++ b/fs/cifs/cifsfs.c @@ -12,6 +12,7 @@ #include <linux/module.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/mount.h> #include <linux/slab.h> #include <linux/init.h> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h index cfdd5bf701a1..cd8171a1c9a0 100644 --- a/fs/cifs/cifsglob.h +++ b/fs/cifs/cifsglob.h @@ -26,6 +26,7 @@ #include <uapi/linux/cifs/cifs_mount.h> #include "../smbfs_common/smb2pdu.h" #include "smb2pdu.h" +#include <linux/filelock.h> #define SMB_PATH_MAX 260 #define CIFS_PORT 445 diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c index 23f10e0d6e7e..60dd4e37030a 100644 --- a/fs/cifs/cifssmb.c +++ b/fs/cifs/cifssmb.c @@ -15,6 +15,7 @@ /* want to reuse a stale file handle and only the caller knows the file info */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/kernel.h> #include <linux/vfs.h> #include <linux/slab.h> diff --git a/fs/cifs/file.c b/fs/cifs/file.c index 22dfc1f8b4f1..1d9cc59d8259 100644 --- a/fs/cifs/file.c +++ b/fs/cifs/file.c @@ -9,6 +9,7 @@ * */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/backing-dev.h> #include <linux/stat.h> #include <linux/fcntl.h> diff --git a/fs/cifs/smb2file.c b/fs/cifs/smb2file.c index ba6cc50af390..9f1dd04b555a 100644 --- a/fs/cifs/smb2file.c +++ b/fs/cifs/smb2file.c @@ -7,6 +7,7 @@ * */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/stat.h> #include <linux/slab.h> #include <linux/pagemap.h> diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c index 737f185aad8d..ed4357e62f35 100644 --- a/fs/dlm/plock.c +++ b/fs/dlm/plock.c @@ -4,6 +4,7 @@ */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/miscdevice.h> #include <linux/poll.h> #include <linux/dlm.h> diff --git a/fs/fcntl.c b/fs/fcntl.c index 146c9ab0cd4b..7852e946fdf4 100644 --- a/fs/fcntl.c +++ b/fs/fcntl.c @@ -10,6 +10,7 @@ #include <linux/mm.h> #include <linux/sched/task.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/file.h> #include <linux/fdtable.h> #include <linux/capability.h> diff --git a/fs/file_table.c b/fs/file_table.c index dd88701e54a9..372653b92617 100644 --- a/fs/file_table.c +++ b/fs/file_table.c @@ -13,6 +13,7 @@ #include <linux/init.h> #include <linux/module.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/security.h> #include <linux/cred.h> #include <linux/eventpoll.h> diff --git a/fs/fuse/file.c b/fs/fuse/file.c index 875314ee6f59..1458412f2492 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c @@ -18,6 +18,7 @@ #include <linux/falloc.h> #include <linux/uio.h> #include <linux/fs.h> +#include <linux/filelock.h> static int fuse_send_open(struct fuse_mount *fm, u64 nodeid, unsigned int open_flags, int opcode, diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c index eea5be4fbf0e..e8e20a716004 100644 --- a/fs/gfs2/file.c +++ b/fs/gfs2/file.c @@ -15,6 +15,7 @@ #include <linux/mm.h> #include <linux/mount.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/gfs2_ondisk.h> #include <linux/falloc.h> #include <linux/swap.h> diff --git a/fs/inode.c b/fs/inode.c index f453eb58fd03..d02dd8f1e967 100644 --- a/fs/inode.c +++ b/fs/inode.c @@ -5,6 +5,7 @@ */ #include <linux/export.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/mm.h> #include <linux/backing-dev.h> #include <linux/hash.h> diff --git a/fs/ksmbd/smb2pdu.c b/fs/ksmbd/smb2pdu.c index 14d7f3599c63..000a6648f122 100644 --- a/fs/ksmbd/smb2pdu.c +++ b/fs/ksmbd/smb2pdu.c @@ -12,6 +12,7 @@ #include <linux/ethtool.h> #include <linux/falloc.h> #include <linux/mount.h> +#include <linux/filelock.h> #include "glob.h" #include "smbfsctl.h" diff --git a/fs/ksmbd/vfs.c b/fs/ksmbd/vfs.c index ff0e7a4fcd4d..5851934dc85b 100644 --- a/fs/ksmbd/vfs.c +++ b/fs/ksmbd/vfs.c @@ -6,6 +6,7 @@ #include <linux/kernel.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/uaccess.h> #include <linux/backing-dev.h> #include <linux/writeback.h> diff --git a/fs/ksmbd/vfs_cache.c b/fs/ksmbd/vfs_cache.c index da9163b00350..552c3882a8f4 100644 --- a/fs/ksmbd/vfs_cache.c +++ b/fs/ksmbd/vfs_cache.c @@ -5,6 +5,7 @@ */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/slab.h> #include <linux/vmalloc.h> diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c index 99fffc9cb958..e875a3571c41 100644 --- a/fs/lockd/clntproc.c +++ b/fs/lockd/clntproc.c @@ -12,6 +12,7 @@ #include <linux/types.h> #include <linux/errno.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/nfs_fs.h> #include <linux/utsname.h> #include <linux/freezer.h> diff --git a/fs/lockd/netns.h b/fs/lockd/netns.h index 5bec78c8e431..17432c445fe6 100644 --- a/fs/lockd/netns.h +++ b/fs/lockd/netns.h @@ -3,6 +3,7 @@ #define __LOCKD_NETNS_H__ #include <linux/fs.h> +#include <linux/filelock.h> #include <net/netns/generic.h> struct lockd_net { diff --git a/fs/locks.c b/fs/locks.c index 8f01bee17715..a5cc90c958c9 100644 --- a/fs/locks.c +++ b/fs/locks.c @@ -52,6 +52,7 @@ #include <linux/capability.h> #include <linux/file.h> #include <linux/fdtable.h> +#include <linux/filelock.h> #include <linux/fs.h> #include <linux/init.h> #include <linux/security.h> diff --git a/fs/namei.c b/fs/namei.c index 309ae6fc8c99..60a9d3ac941f 100644 --- a/fs/namei.c +++ b/fs/namei.c @@ -20,6 +20,7 @@ #include <linux/kernel.h> #include <linux/slab.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/namei.h> #include <linux/pagemap.h> #include <linux/sched/mm.h> diff --git a/fs/nfs/file.c b/fs/nfs/file.c index d8ec889a4b3f..b0f3c9339e70 100644 --- a/fs/nfs/file.c +++ b/fs/nfs/file.c @@ -31,6 +31,7 @@ #include <linux/swap.h> #include <linux/uaccess.h> +#include <linux/filelock.h> #include "delegation.h" #include "internal.h" diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h index 5edd1704f735..4c9f8bd866ab 100644 --- a/fs/nfs/nfs4_fs.h +++ b/fs/nfs/nfs4_fs.h @@ -23,6 +23,7 @@ #define NFS4_MAX_LOOP_ON_RECOVER (10) #include <linux/seqlock.h> +#include <linux/filelock.h> struct idmap; diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c index 16be6dae524f..779bfc37233c 100644 --- a/fs/nfs/pagelist.c +++ b/fs/nfs/pagelist.c @@ -21,6 +21,7 @@ #include <linux/nfs_page.h> #include <linux/nfs_mount.h> #include <linux/export.h> +#include <linux/filelock.h> #include "internal.h" #include "pnfs.h" diff --git a/fs/nfs/write.c b/fs/nfs/write.c index 80c240e50952..1a80d548253a 100644 --- a/fs/nfs/write.c +++ b/fs/nfs/write.c @@ -25,6 +25,7 @@ #include <linux/freezer.h> #include <linux/wait.h> #include <linux/iversion.h> +#include <linux/filelock.h> #include <linux/uaccess.h> #include <linux/sched/mm.h> diff --git a/fs/nfs_common/grace.c b/fs/nfs_common/grace.c index 0a9b72685f98..1479583fbb62 100644 --- a/fs/nfs_common/grace.c +++ b/fs/nfs_common/grace.c @@ -9,6 +9,7 @@ #include <net/net_namespace.h> #include <net/netns/generic.h> #include <linux/fs.h> +#include <linux/filelock.h> static unsigned int grace_net_id; static DEFINE_SPINLOCK(grace_lock); diff --git a/fs/nfsd/netns.h b/fs/nfsd/netns.h index 8c854ba3285b..bc139401927d 100644 --- a/fs/nfsd/netns.h +++ b/fs/nfsd/netns.h @@ -10,6 +10,7 @@ #include <net/net_namespace.h> #include <net/netns/generic.h> +#include <linux/filelock.h> #include <linux/percpu_counter.h> #include <linux/siphash.h> diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c index 73a3854b2afb..f37174e79fad 100644 --- a/fs/ocfs2/locks.c +++ b/fs/ocfs2/locks.c @@ -8,6 +8,7 @@ */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/fcntl.h> #include <cluster/masklog.h> diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c index 64e6ddcfe329..05d4414d0c33 100644 --- a/fs/ocfs2/stack_user.c +++ b/fs/ocfs2/stack_user.c @@ -9,6 +9,7 @@ #include <linux/module.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/miscdevice.h> #include <linux/mutex.h> #include <linux/slab.h> diff --git a/fs/open.c b/fs/open.c index 82c1a28b3308..9b1c08298a07 100644 --- a/fs/open.c +++ b/fs/open.c @@ -33,6 +33,7 @@ #include <linux/dnotify.h> #include <linux/compat.h> #include <linux/mnt_idmapping.h> +#include <linux/filelock.h> #include "internal.h" diff --git a/fs/orangefs/file.c b/fs/orangefs/file.c index 167fa43b24f9..4ecb91a9bbeb 100644 --- a/fs/orangefs/file.c +++ b/fs/orangefs/file.c @@ -14,6 +14,7 @@ #include "orangefs-kernel.h" #include "orangefs-bufmap.h" #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/pagemap.h> static int flush_racache(struct inode *inode) diff --git a/fs/posix_acl.c b/fs/posix_acl.c index d7bc81fc0840..d2271431f344 100644 --- a/fs/posix_acl.c +++ b/fs/posix_acl.c @@ -28,6 +28,7 @@ #include <linux/security.h> #include <linux/evm.h> #include <linux/fsnotify.h> +#include <linux/filelock.h> #include "internal.h" diff --git a/fs/proc/fd.c b/fs/proc/fd.c index fc46d6fe080c..53e4919ef860 100644 --- a/fs/proc/fd.c +++ b/fs/proc/fd.c @@ -12,6 +12,7 @@ #include <linux/file.h> #include <linux/seq_file.h> #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/proc_fs.h> diff --git a/fs/utimes.c b/fs/utimes.c index 39f356017635..00499e4ba955 100644 --- a/fs/utimes.c +++ b/fs/utimes.c @@ -7,6 +7,7 @@ #include <linux/uaccess.h> #include <linux/compat.h> #include <asm/unistd.h> +#include <linux/filelock.h> static bool nsec_valid(long nsec) { diff --git a/fs/xattr.c b/fs/xattr.c index adab9a70b536..3fead374901b 100644 --- a/fs/xattr.c +++ b/fs/xattr.c @@ -9,6 +9,7 @@ Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com> */ #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/slab.h> #include <linux/file.h> #include <linux/xattr.h> diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h index f9878021e7d0..e88f18f85e4b 100644 --- a/fs/xfs/xfs_linux.h +++ b/fs/xfs/xfs_linux.h @@ -34,6 +34,7 @@ typedef __u32 xfs_nlink_t; #include <linux/module.h> #include <linux/mutex.h> #include <linux/file.h> +#include <linux/filelock.h> #include <linux/swap.h> #include <linux/errno.h> #include <linux/sched/signal.h> diff --git a/include/linux/filelock.h b/include/linux/filelock.h new file mode 100644 index 000000000000..deee04385127 --- /dev/null +++ b/include/linux/filelock.h @@ -0,0 +1,438 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_FILELOCK_H +#define _LINUX_FILELOCK_H + +#include <linux/fs.h> + +#define FL_POSIX 1 +#define FL_FLOCK 2 +#define FL_DELEG 4 /* NFSv4 delegation */ +#define FL_ACCESS 8 /* not trying to lock, just looking */ +#define FL_EXISTS 16 /* when unlocking, test for existence */ +#define FL_LEASE 32 /* lease held on this file */ +#define FL_CLOSE 64 /* unlock on close */ +#define FL_SLEEP 128 /* A blocking lock */ +#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ +#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ +#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ +#define FL_LAYOUT 2048 /* outstanding pNFS layout */ +#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ + +#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) + +/* + * Special return value from posix_lock_file() and vfs_lock_file() for + * asynchronous locking. + */ +#define FILE_LOCK_DEFERRED 1 + +struct file_lock; + +struct file_lock_operations { + void (*fl_copy_lock)(struct file_lock *, struct file_lock *); + void (*fl_release_private)(struct file_lock *); +}; + +struct lock_manager_operations { + void *lm_mod_owner; + fl_owner_t (*lm_get_owner)(fl_owner_t); + void (*lm_put_owner)(fl_owner_t); + void (*lm_notify)(struct file_lock *); /* unblock callback */ + int (*lm_grant)(struct file_lock *, int); + bool (*lm_break)(struct file_lock *); + int (*lm_change)(struct file_lock *, int, struct list_head *); + void (*lm_setup)(struct file_lock *, void **); + bool (*lm_breaker_owns_lease)(struct file_lock *); + bool (*lm_lock_expirable)(struct file_lock *cfl); + void (*lm_expire_lock)(void); +}; + +struct lock_manager { + struct list_head list; + /* + * NFSv4 and up also want opens blocked during the grace period; + * NLM doesn't care: + */ + bool block_opens; +}; + +struct net; +void locks_start_grace(struct net *, struct lock_manager *); +void locks_end_grace(struct lock_manager *); +bool locks_in_grace(struct net *); +bool opens_in_grace(struct net *); + +/* + * struct file_lock has a union that some filesystems use to track + * their own private info. The NFS side of things is defined here: + */ +#include <linux/nfs_fs_i.h> + +/* + * struct file_lock represents a generic "file lock". It's used to represent + * POSIX byte range locks, BSD (flock) locks, and leases. It's important to + * note that the same struct is used to represent both a request for a lock and + * the lock itself, but the same object is never used for both. + * + * FIXME: should we create a separate "struct lock_request" to help distinguish + * these two uses? + * + * The varous i_flctx lists are ordered by: + * + * 1) lock owner + * 2) lock range start + * 3) lock range end + * + * Obviously, the last two criteria only matter for POSIX locks. + */ +struct file_lock { + struct file_lock *fl_blocker; /* The lock, that is blocking us */ + struct list_head fl_list; /* link into file_lock_context */ + struct hlist_node fl_link; /* node in global lists */ + struct list_head fl_blocked_requests; /* list of requests with + * ->fl_blocker pointing here + */ + struct list_head fl_blocked_member; /* node in + * ->fl_blocker->fl_blocked_requests + */ + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_type; + unsigned int fl_pid; + int fl_link_cpu; /* what cpu's list is this on? */ + wait_queue_head_t fl_wait; + struct file *fl_file; + loff_t fl_start; + loff_t fl_end; + + struct fasync_struct * fl_fasync; /* for lease break notifications */ + /* for lease breaks: */ + unsigned long fl_break_time; + unsigned long fl_downgrade_time; + + const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ + const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ + union { + struct nfs_lock_info nfs_fl; + struct nfs4_lock_info nfs4_fl; + struct { + struct list_head link; /* link in AFS vnode's pending_locks list */ + int state; /* state of grant or error if -ve */ + unsigned int debug_id; + } afs; + } fl_u; +} __randomize_layout; + +struct file_lock_context { + spinlock_t flc_lock; + struct list_head flc_flock; + struct list_head flc_posix; + struct list_head flc_lease; +}; + +#define locks_inode(f) file_inode(f) + +#ifdef CONFIG_FILE_LOCKING +int fcntl_getlk(struct file *, unsigned int, struct flock *); +int fcntl_setlk(unsigned int, struct file *, unsigned int, + struct flock *); + +#if BITS_PER_LONG == 32 +int fcntl_getlk64(struct file *, unsigned int, struct flock64 *); +int fcntl_setlk64(unsigned int, struct file *, unsigned int, + struct flock64 *); +#endif + +int fcntl_setlease(unsigned int fd, struct file *filp, long arg); +int fcntl_getlease(struct file *filp); + +/* fs/locks.c */ +void locks_free_lock_context(struct inode *inode); +void locks_free_lock(struct file_lock *fl); +void locks_init_lock(struct file_lock *); +struct file_lock * locks_alloc_lock(void); +void locks_copy_lock(struct file_lock *, struct file_lock *); +void locks_copy_conflock(struct file_lock *, struct file_lock *); +void locks_remove_posix(struct file *, fl_owner_t); +void locks_remove_file(struct file *); +void locks_release_private(struct file_lock *); +void posix_test_lock(struct file *, struct file_lock *); +int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); +int locks_delete_block(struct file_lock *); +int vfs_test_lock(struct file *, struct file_lock *); +int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *); +int vfs_cancel_lock(struct file *filp, struct file_lock *fl); +bool vfs_inode_has_locks(struct inode *inode); +int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl); +int __break_lease(struct inode *inode, unsigned int flags, unsigned int type); +void lease_get_mtime(struct inode *, struct timespec64 *time); +int generic_setlease(struct file *, long, struct file_lock **, void **priv); +int vfs_setlease(struct file *, long, struct file_lock **, void **); +int lease_modify(struct file_lock *, int, struct list_head *); + +struct notifier_block; +int lease_register_notifier(struct notifier_block *); +void lease_unregister_notifier(struct notifier_block *); + +struct files_struct; +void show_fd_locks(struct seq_file *f, + struct file *filp, struct files_struct *files); +bool locks_owner_has_blockers(struct file_lock_context *flctx, + fl_owner_t owner); + +static inline struct file_lock_context * +locks_inode_context(const struct inode *inode) +{ + return smp_load_acquire(&inode->i_flctx); +} + +#else /* !CONFIG_FILE_LOCKING */ +static inline int fcntl_getlk(struct file *file, unsigned int cmd, + struct flock __user *user) +{ + return -EINVAL; +} + +static inline int fcntl_setlk(unsigned int fd, struct file *file, + unsigned int cmd, struct flock __user *user) +{ + return -EACCES; +} + +#if BITS_PER_LONG == 32 +static inline int fcntl_getlk64(struct file *file, unsigned int cmd, + struct flock64 *user) +{ + return -EINVAL; +} + +static inline int fcntl_setlk64(unsigned int fd, struct file *file, + unsigned int cmd, struct flock64 *user) +{ + return -EACCES; +} +#endif +static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) +{ + return -EINVAL; +} + +static inline int fcntl_getlease(struct file *filp) +{ + return F_UNLCK; +} + +static inline void +locks_free_lock_context(struct inode *inode) +{ +} + +static inline void locks_init_lock(struct file_lock *fl) +{ + return; +} + +static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) +{ + return; +} + +static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) +{ + return; +} + +static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) +{ + return; +} + +static inline void locks_remove_file(struct file *filp) +{ + return; +} + +static inline void posix_test_lock(struct file *filp, struct file_lock *fl) +{ + return; +} + +static inline int posix_lock_file(struct file *filp, struct file_lock *fl, + struct file_lock *conflock) +{ + return -ENOLCK; +} + +static inline int locks_delete_block(struct file_lock *waiter) +{ + return -ENOENT; +} + +static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) +{ + return 0; +} + +static inline int vfs_lock_file(struct file *filp, unsigned int cmd, + struct file_lock *fl, struct file_lock *conf) +{ + return -ENOLCK; +} + +static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) +{ + return 0; +} + +static inline bool vfs_inode_has_locks(struct inode *inode) +{ + return false; +} + +static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) +{ + return -ENOLCK; +} + +static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) +{ + return 0; +} + +static inline void lease_get_mtime(struct inode *inode, + struct timespec64 *time) +{ + return; +} + +static inline int generic_setlease(struct file *filp, long arg, + struct file_lock **flp, void **priv) +{ + return -EINVAL; +} + +static inline int vfs_setlease(struct file *filp, long arg, + struct file_lock **lease, void **priv) +{ + return -EINVAL; +} + +static inline int lease_modify(struct file_lock *fl, int arg, + struct list_head *dispose) +{ + return -EINVAL; +} + +struct files_struct; +static inline void show_fd_locks(struct seq_file *f, + struct file *filp, struct files_struct *files) {} +static inline bool locks_owner_has_blockers(struct file_lock_context *flctx, + fl_owner_t owner) +{ + return false; +} + +static inline struct file_lock_context * +locks_inode_context(const struct inode *inode) +{ + return NULL; +} + +#endif /* !CONFIG_FILE_LOCKING */ + +static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl) +{ + return locks_lock_inode_wait(locks_inode(filp), fl); +} + +#ifdef CONFIG_FILE_LOCKING +static inline int break_lease(struct inode *inode, unsigned int mode) +{ + /* + * Since this check is lockless, we must ensure that any refcounts + * taken are done before checking i_flctx->flc_lease. Otherwise, we + * could end up racing with tasks trying to set a new lease on this + * file. + */ + smp_mb(); + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) + return __break_lease(inode, mode, FL_LEASE); + return 0; +} + +static inline int break_deleg(struct inode *inode, unsigned int mode) +{ + /* + * Since this check is lockless, we must ensure that any refcounts + * taken are done before checking i_flctx->flc_lease. Otherwise, we + * could end up racing with tasks trying to set a new lease on this + * file. + */ + smp_mb(); + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) + return __break_lease(inode, mode, FL_DELEG); + return 0; +} + +static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) +{ + int ret; + + ret = break_deleg(inode, O_WRONLY|O_NONBLOCK); + if (ret == -EWOULDBLOCK && delegated_inode) { + *delegated_inode = inode; + ihold(inode); + } + return ret; +} + +static inline int break_deleg_wait(struct inode **delegated_inode) +{ + int ret; + + ret = break_deleg(*delegated_inode, O_WRONLY); + iput(*delegated_inode); + *delegated_inode = NULL; + return ret; +} + +static inline int break_layout(struct inode *inode, bool wait) +{ + smp_mb(); + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) + return __break_lease(inode, + wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, + FL_LAYOUT); + return 0; +} + +#else /* !CONFIG_FILE_LOCKING */ +static inline int break_lease(struct inode *inode, unsigned int mode) +{ + return 0; +} + +static inline int break_deleg(struct inode *inode, unsigned int mode) +{ + return 0; +} + +static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) +{ + return 0; +} + +static inline int break_deleg_wait(struct inode **delegated_inode) +{ + BUG(); + return 0; +} + +static inline int break_layout(struct inode *inode, bool wait) +{ + return 0; +} + +#endif /* CONFIG_FILE_LOCKING */ + +#endif /* _LINUX_FILELOCK_H */ diff --git a/include/linux/fs.h b/include/linux/fs.h index 066555ad1bf8..006278d84d2f 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -1003,132 +1003,11 @@ static inline struct file *get_file(struct file *f) #define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX) #endif -#define FL_POSIX 1 -#define FL_FLOCK 2 -#define FL_DELEG 4 /* NFSv4 delegation */ -#define FL_ACCESS 8 /* not trying to lock, just looking */ -#define FL_EXISTS 16 /* when unlocking, test for existence */ -#define FL_LEASE 32 /* lease held on this file */ -#define FL_CLOSE 64 /* unlock on close */ -#define FL_SLEEP 128 /* A blocking lock */ -#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ -#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ -#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ -#define FL_LAYOUT 2048 /* outstanding pNFS layout */ -#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ - -#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) - -/* - * Special return value from posix_lock_file() and vfs_lock_file() for - * asynchronous locking. - */ -#define FILE_LOCK_DEFERRED 1 - /* legacy typedef, should eventually be removed */ typedef void *fl_owner_t; struct file_lock; -struct file_lock_operations { - void (*fl_copy_lock)(struct file_lock *, struct file_lock *); - void (*fl_release_private)(struct file_lock *); -}; - -struct lock_manager_operations { - void *lm_mod_owner; - fl_owner_t (*lm_get_owner)(fl_owner_t); - void (*lm_put_owner)(fl_owner_t); - void (*lm_notify)(struct file_lock *); /* unblock callback */ - int (*lm_grant)(struct file_lock *, int); - bool (*lm_break)(struct file_lock *); - int (*lm_change)(struct file_lock *, int, struct list_head *); - void (*lm_setup)(struct file_lock *, void **); - bool (*lm_breaker_owns_lease)(struct file_lock *); - bool (*lm_lock_expirable)(struct file_lock *cfl); - void (*lm_expire_lock)(void); -}; - -struct lock_manager { - struct list_head list; - /* - * NFSv4 and up also want opens blocked during the grace period; - * NLM doesn't care: - */ - bool block_opens; -}; - -struct net; -void locks_start_grace(struct net *, struct lock_manager *); -void locks_end_grace(struct lock_manager *); -bool locks_in_grace(struct net *); -bool opens_in_grace(struct net *); - -/* that will die - we need it for nfs_lock_info */ -#include <linux/nfs_fs_i.h> - -/* - * struct file_lock represents a generic "file lock". It's used to represent - * POSIX byte range locks, BSD (flock) locks, and leases. It's important to - * note that the same struct is used to represent both a request for a lock and - * the lock itself, but the same object is never used for both. - * - * FIXME: should we create a separate "struct lock_request" to help distinguish - * these two uses? - * - * The varous i_flctx lists are ordered by: - * - * 1) lock owner - * 2) lock range start - * 3) lock range end - * - * Obviously, the last two criteria only matter for POSIX locks. - */ -struct file_lock { - struct file_lock *fl_blocker; /* The lock, that is blocking us */ - struct list_head fl_list; /* link into file_lock_context */ - struct hlist_node fl_link; /* node in global lists */ - struct list_head fl_blocked_requests; /* list of requests with - * ->fl_blocker pointing here - */ - struct list_head fl_blocked_member; /* node in - * ->fl_blocker->fl_blocked_requests - */ - fl_owner_t fl_owner; - unsigned int fl_flags; - unsigned char fl_type; - unsigned int fl_pid; - int fl_link_cpu; /* what cpu's list is this on? */ - wait_queue_head_t fl_wait; - struct file *fl_file; - loff_t fl_start; - loff_t fl_end; - - struct fasync_struct * fl_fasync; /* for lease break notifications */ - /* for lease breaks: */ - unsigned long fl_break_time; - unsigned long fl_downgrade_time; - - const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */ - const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */ - union { - struct nfs_lock_info nfs_fl; - struct nfs4_lock_info nfs4_fl; - struct { - struct list_head link; /* link in AFS vnode's pending_locks list */ - int state; /* state of grant or error if -ve */ - unsigned int debug_id; - } afs; - } fl_u; -} __randomize_layout; - -struct file_lock_context { - spinlock_t flc_lock; - struct list_head flc_flock; - struct list_head flc_posix; - struct list_head flc_lease; -}; - /* The following constant reflects the upper bound of the file/locking space */ #ifndef OFFSET_MAX #define OFFSET_MAX type_max(loff_t) @@ -1137,216 +1016,6 @@ struct file_lock_context { extern void send_sigio(struct fown_struct *fown, int fd, int band); -#define locks_inode(f) file_inode(f) - -#ifdef CONFIG_FILE_LOCKING -extern int fcntl_getlk(struct file *, unsigned int, struct flock *); -extern int fcntl_setlk(unsigned int, struct file *, unsigned int, - struct flock *); - -#if BITS_PER_LONG == 32 -extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *); -extern int fcntl_setlk64(unsigned int, struct file *, unsigned int, - struct flock64 *); -#endif - -extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg); -extern int fcntl_getlease(struct file *filp); - -/* fs/locks.c */ -void locks_free_lock_context(struct inode *inode); -void locks_free_lock(struct file_lock *fl); -extern void locks_init_lock(struct file_lock *); -extern struct file_lock * locks_alloc_lock(void); -extern void locks_copy_lock(struct file_lock *, struct file_lock *); -extern void locks_copy_conflock(struct file_lock *, struct file_lock *); -extern void locks_remove_posix(struct file *, fl_owner_t); -extern void locks_remove_file(struct file *); -extern void locks_release_private(struct file_lock *); -extern void posix_test_lock(struct file *, struct file_lock *); -extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *); -extern int locks_delete_block(struct file_lock *); -extern int vfs_test_lock(struct file *, struct file_lock *); -extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *); -extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl); -bool vfs_inode_has_locks(struct inode *inode); -extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl); -extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type); -extern void lease_get_mtime(struct inode *, struct timespec64 *time); -extern int generic_setlease(struct file *, long, struct file_lock **, void **priv); -extern int vfs_setlease(struct file *, long, struct file_lock **, void **); -extern int lease_modify(struct file_lock *, int, struct list_head *); - -struct notifier_block; -extern int lease_register_notifier(struct notifier_block *); -extern void lease_unregister_notifier(struct notifier_block *); - -struct files_struct; -extern void show_fd_locks(struct seq_file *f, - struct file *filp, struct files_struct *files); -extern bool locks_owner_has_blockers(struct file_lock_context *flctx, - fl_owner_t owner); - -static inline struct file_lock_context * -locks_inode_context(const struct inode *inode) -{ - return smp_load_acquire(&inode->i_flctx); -} - -#else /* !CONFIG_FILE_LOCKING */ -static inline int fcntl_getlk(struct file *file, unsigned int cmd, - struct flock __user *user) -{ - return -EINVAL; -} - -static inline int fcntl_setlk(unsigned int fd, struct file *file, - unsigned int cmd, struct flock __user *user) -{ - return -EACCES; -} - -#if BITS_PER_LONG == 32 -static inline int fcntl_getlk64(struct file *file, unsigned int cmd, - struct flock64 *user) -{ - return -EINVAL; -} - -static inline int fcntl_setlk64(unsigned int fd, struct file *file, - unsigned int cmd, struct flock64 *user) -{ - return -EACCES; -} -#endif -static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) -{ - return -EINVAL; -} - -static inline int fcntl_getlease(struct file *filp) -{ - return F_UNLCK; -} - -static inline void -locks_free_lock_context(struct inode *inode) -{ -} - -static inline void locks_init_lock(struct file_lock *fl) -{ - return; -} - -static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl) -{ - return; -} - -static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) -{ - return; -} - -static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) -{ - return; -} - -static inline void locks_remove_file(struct file *filp) -{ - return; -} - -static inline void posix_test_lock(struct file *filp, struct file_lock *fl) -{ - return; -} - -static inline int posix_lock_file(struct file *filp, struct file_lock *fl, - struct file_lock *conflock) -{ - return -ENOLCK; -} - -static inline int locks_delete_block(struct file_lock *waiter) -{ - return -ENOENT; -} - -static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) -{ - return 0; -} - -static inline int vfs_lock_file(struct file *filp, unsigned int cmd, - struct file_lock *fl, struct file_lock *conf) -{ - return -ENOLCK; -} - -static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) -{ - return 0; -} - -static inline bool vfs_inode_has_locks(struct inode *inode) -{ - return false; -} - -static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl) -{ - return -ENOLCK; -} - -static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type) -{ - return 0; -} - -static inline void lease_get_mtime(struct inode *inode, - struct timespec64 *time) -{ - return; -} - -static inline int generic_setlease(struct file *filp, long arg, - struct file_lock **flp, void **priv) -{ - return -EINVAL; -} - -static inline int vfs_setlease(struct file *filp, long arg, - struct file_lock **lease, void **priv) -{ - return -EINVAL; -} - -static inline int lease_modify(struct file_lock *fl, int arg, - struct list_head *dispose) -{ - return -EINVAL; -} - -struct files_struct; -static inline void show_fd_locks(struct seq_file *f, - struct file *filp, struct files_struct *files) {} -static inline bool locks_owner_has_blockers(struct file_lock_context *flctx, - fl_owner_t owner) -{ - return false; -} - -static inline struct file_lock_context * -locks_inode_context(const struct inode *inode) -{ - return NULL; -} - -#endif /* !CONFIG_FILE_LOCKING */ - static inline struct inode *file_inode(const struct file *f) { return f->f_inode; @@ -1357,11 +1026,6 @@ static inline struct dentry *file_dentry(const struct file *file) return d_real(file->f_path.dentry, file_inode(file)); } -static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl) -{ - return locks_lock_inode_wait(locks_inode(filp), fl); -} - struct fasync_struct { rwlock_t fa_lock; int magic; @@ -2621,96 +2285,6 @@ extern struct kobject *fs_kobj; #define MAX_RW_COUNT (INT_MAX & PAGE_MASK) -#ifdef CONFIG_FILE_LOCKING -static inline int break_lease(struct inode *inode, unsigned int mode) -{ - /* - * Since this check is lockless, we must ensure that any refcounts - * taken are done before checking i_flctx->flc_lease. Otherwise, we - * could end up racing with tasks trying to set a new lease on this - * file. - */ - smp_mb(); - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) - return __break_lease(inode, mode, FL_LEASE); - return 0; -} - -static inline int break_deleg(struct inode *inode, unsigned int mode) -{ - /* - * Since this check is lockless, we must ensure that any refcounts - * taken are done before checking i_flctx->flc_lease. Otherwise, we - * could end up racing with tasks trying to set a new lease on this - * file. - */ - smp_mb(); - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) - return __break_lease(inode, mode, FL_DELEG); - return 0; -} - -static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) -{ - int ret; - - ret = break_deleg(inode, O_WRONLY|O_NONBLOCK); - if (ret == -EWOULDBLOCK && delegated_inode) { - *delegated_inode = inode; - ihold(inode); - } - return ret; -} - -static inline int break_deleg_wait(struct inode **delegated_inode) -{ - int ret; - - ret = break_deleg(*delegated_inode, O_WRONLY); - iput(*delegated_inode); - *delegated_inode = NULL; - return ret; -} - -static inline int break_layout(struct inode *inode, bool wait) -{ - smp_mb(); - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) - return __break_lease(inode, - wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, - FL_LAYOUT); - return 0; -} - -#else /* !CONFIG_FILE_LOCKING */ -static inline int break_lease(struct inode *inode, unsigned int mode) -{ - return 0; -} - -static inline int break_deleg(struct inode *inode, unsigned int mode) -{ - return 0; -} - -static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode) -{ - return 0; -} - -static inline int break_deleg_wait(struct inode **delegated_inode) -{ - BUG(); - return 0; -} - -static inline int break_layout(struct inode *inode, bool wait) -{ - return 0; -} - -#endif /* CONFIG_FILE_LOCKING */ - /* fs/open.c */ struct audit_names; struct filename { diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h index 67e4a2c5500b..b60fbcd8cdfa 100644 --- a/include/linux/lockd/xdr.h +++ b/include/linux/lockd/xdr.h @@ -11,6 +11,7 @@ #define LOCKD_XDR_H #include <linux/fs.h> +#include <linux/filelock.h> #include <linux/nfs.h> #include <linux/sunrpc/xdr.h>