1  /* SPDX-License-Identifier: GPL-2.0 */
2  #ifndef _LINUX_FILELOCK_H
3  #define _LINUX_FILELOCK_H
4  
5  #include <linux/fs.h>
6  
7  #define FL_POSIX	1
8  #define FL_FLOCK	2
9  #define FL_DELEG	4	/* NFSv4 delegation */
10  #define FL_ACCESS	8	/* not trying to lock, just looking */
11  #define FL_EXISTS	16	/* when unlocking, test for existence */
12  #define FL_LEASE	32	/* lease held on this file */
13  #define FL_CLOSE	64	/* unlock on close */
14  #define FL_SLEEP	128	/* A blocking lock */
15  #define FL_DOWNGRADE_PENDING	256 /* Lease is being downgraded */
16  #define FL_UNLOCK_PENDING	512 /* Lease is being broken */
17  #define FL_OFDLCK	1024	/* lock is "owned" by struct file */
18  #define FL_LAYOUT	2048	/* outstanding pNFS layout */
19  #define FL_RECLAIM	4096	/* reclaiming from a reboot server */
20  
21  #define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
22  
23  /*
24   * Special return value from posix_lock_file() and vfs_lock_file() for
25   * asynchronous locking.
26   */
27  #define FILE_LOCK_DEFERRED 1
28  
29  struct file_lock;
30  struct file_lease;
31  
32  struct file_lock_operations {
33  	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
34  	void (*fl_release_private)(struct file_lock *);
35  };
36  
37  struct lock_manager_operations {
38  	void *lm_mod_owner;
39  	fl_owner_t (*lm_get_owner)(fl_owner_t);
40  	void (*lm_put_owner)(fl_owner_t);
41  	void (*lm_notify)(struct file_lock *);	/* unblock callback */
42  	int (*lm_grant)(struct file_lock *, int);
43  	bool (*lm_lock_expirable)(struct file_lock *cfl);
44  	void (*lm_expire_lock)(void);
45  };
46  
47  struct lease_manager_operations {
48  	bool (*lm_break)(struct file_lease *);
49  	int (*lm_change)(struct file_lease *, int, struct list_head *);
50  	void (*lm_setup)(struct file_lease *, void **);
51  	bool (*lm_breaker_owns_lease)(struct file_lease *);
52  };
53  
54  struct lock_manager {
55  	struct list_head list;
56  	/*
57  	 * NFSv4 and up also want opens blocked during the grace period;
58  	 * NLM doesn't care:
59  	 */
60  	bool block_opens;
61  };
62  
63  struct net;
64  void locks_start_grace(struct net *, struct lock_manager *);
65  void locks_end_grace(struct lock_manager *);
66  bool locks_in_grace(struct net *);
67  bool opens_in_grace(struct net *);
68  
69  /*
70   * struct file_lock has a union that some filesystems use to track
71   * their own private info. The NFS side of things is defined here:
72   */
73  #include <linux/nfs_fs_i.h>
74  
75  /*
76   * struct file_lock represents a generic "file lock". It's used to represent
77   * POSIX byte range locks, BSD (flock) locks, and leases. It's important to
78   * note that the same struct is used to represent both a request for a lock and
79   * the lock itself, but the same object is never used for both.
80   *
81   * FIXME: should we create a separate "struct lock_request" to help distinguish
82   * these two uses?
83   *
84   * The varous i_flctx lists are ordered by:
85   *
86   * 1) lock owner
87   * 2) lock range start
88   * 3) lock range end
89   *
90   * Obviously, the last two criteria only matter for POSIX locks.
91   */
92  
93  struct file_lock_core {
94  	struct file_lock_core *flc_blocker;	/* The lock that is blocking us */
95  	struct list_head flc_list;	/* link into file_lock_context */
96  	struct hlist_node flc_link;	/* node in global lists */
97  	struct list_head flc_blocked_requests;	/* list of requests with
98  						 * ->fl_blocker pointing here
99  						 */
100  	struct list_head flc_blocked_member;	/* node in
101  						 * ->fl_blocker->fl_blocked_requests
102  						 */
103  	fl_owner_t flc_owner;
104  	unsigned int flc_flags;
105  	unsigned char flc_type;
106  	pid_t flc_pid;
107  	int flc_link_cpu;		/* what cpu's list is this on? */
108  	wait_queue_head_t flc_wait;
109  	struct file *flc_file;
110  };
111  
112  struct file_lock {
113  	struct file_lock_core c;
114  	loff_t fl_start;
115  	loff_t fl_end;
116  
117  	const struct file_lock_operations *fl_ops;	/* Callbacks for filesystems */
118  	const struct lock_manager_operations *fl_lmops;	/* Callbacks for lockmanagers */
119  	union {
120  		struct nfs_lock_info	nfs_fl;
121  		struct nfs4_lock_info	nfs4_fl;
122  		struct {
123  			struct list_head link;	/* link in AFS vnode's pending_locks list */
124  			int state;		/* state of grant or error if -ve */
125  			unsigned int	debug_id;
126  		} afs;
127  		struct {
128  			struct inode *inode;
129  		} ceph;
130  	} fl_u;
131  } __randomize_layout;
132  
133  struct file_lease {
134  	struct file_lock_core c;
135  	struct fasync_struct *	fl_fasync; /* for lease break notifications */
136  	/* for lease breaks: */
137  	unsigned long fl_break_time;
138  	unsigned long fl_downgrade_time;
139  	const struct lease_manager_operations *fl_lmops; /* Callbacks for lease managers */
140  } __randomize_layout;
141  
142  struct file_lock_context {
143  	spinlock_t		flc_lock;
144  	struct list_head	flc_flock;
145  	struct list_head	flc_posix;
146  	struct list_head	flc_lease;
147  };
148  
149  #ifdef CONFIG_FILE_LOCKING
150  int fcntl_getlk(struct file *, unsigned int, struct flock *);
151  int fcntl_setlk(unsigned int, struct file *, unsigned int,
152  			struct flock *);
153  
154  #if BITS_PER_LONG == 32
155  int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
156  int fcntl_setlk64(unsigned int, struct file *, unsigned int,
157  			struct flock64 *);
158  #endif
159  
160  int fcntl_setlease(unsigned int fd, struct file *filp, int arg);
161  int fcntl_getlease(struct file *filp);
162  
lock_is_unlock(struct file_lock * fl)163  static inline bool lock_is_unlock(struct file_lock *fl)
164  {
165  	return fl->c.flc_type == F_UNLCK;
166  }
167  
lock_is_read(struct file_lock * fl)168  static inline bool lock_is_read(struct file_lock *fl)
169  {
170  	return fl->c.flc_type == F_RDLCK;
171  }
172  
lock_is_write(struct file_lock * fl)173  static inline bool lock_is_write(struct file_lock *fl)
174  {
175  	return fl->c.flc_type == F_WRLCK;
176  }
177  
locks_wake_up(struct file_lock * fl)178  static inline void locks_wake_up(struct file_lock *fl)
179  {
180  	wake_up(&fl->c.flc_wait);
181  }
182  
183  /* fs/locks.c */
184  void locks_free_lock_context(struct inode *inode);
185  void locks_free_lock(struct file_lock *fl);
186  void locks_init_lock(struct file_lock *);
187  struct file_lock *locks_alloc_lock(void);
188  void locks_copy_lock(struct file_lock *, struct file_lock *);
189  void locks_copy_conflock(struct file_lock *, struct file_lock *);
190  void locks_remove_posix(struct file *, fl_owner_t);
191  void locks_remove_file(struct file *);
192  void locks_release_private(struct file_lock *);
193  void posix_test_lock(struct file *, struct file_lock *);
194  int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
195  int locks_delete_block(struct file_lock *);
196  int vfs_test_lock(struct file *, struct file_lock *);
197  int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
198  int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
199  bool vfs_inode_has_locks(struct inode *inode);
200  int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
201  
202  void locks_init_lease(struct file_lease *);
203  void locks_free_lease(struct file_lease *fl);
204  struct file_lease *locks_alloc_lease(void);
205  int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
206  void lease_get_mtime(struct inode *, struct timespec64 *time);
207  int generic_setlease(struct file *, int, struct file_lease **, void **priv);
208  int kernel_setlease(struct file *, int, struct file_lease **, void **);
209  int vfs_setlease(struct file *, int, struct file_lease **, void **);
210  int lease_modify(struct file_lease *, int, struct list_head *);
211  
212  struct notifier_block;
213  int lease_register_notifier(struct notifier_block *);
214  void lease_unregister_notifier(struct notifier_block *);
215  
216  struct files_struct;
217  void show_fd_locks(struct seq_file *f,
218  			 struct file *filp, struct files_struct *files);
219  bool locks_owner_has_blockers(struct file_lock_context *flctx,
220  			fl_owner_t owner);
221  
222  static inline struct file_lock_context *
locks_inode_context(const struct inode * inode)223  locks_inode_context(const struct inode *inode)
224  {
225  	return smp_load_acquire(&inode->i_flctx);
226  }
227  
228  #else /* !CONFIG_FILE_LOCKING */
fcntl_getlk(struct file * file,unsigned int cmd,struct flock __user * user)229  static inline int fcntl_getlk(struct file *file, unsigned int cmd,
230  			      struct flock __user *user)
231  {
232  	return -EINVAL;
233  }
234  
fcntl_setlk(unsigned int fd,struct file * file,unsigned int cmd,struct flock __user * user)235  static inline int fcntl_setlk(unsigned int fd, struct file *file,
236  			      unsigned int cmd, struct flock __user *user)
237  {
238  	return -EACCES;
239  }
240  
241  #if BITS_PER_LONG == 32
fcntl_getlk64(struct file * file,unsigned int cmd,struct flock64 * user)242  static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
243  				struct flock64 *user)
244  {
245  	return -EINVAL;
246  }
247  
fcntl_setlk64(unsigned int fd,struct file * file,unsigned int cmd,struct flock64 * user)248  static inline int fcntl_setlk64(unsigned int fd, struct file *file,
249  				unsigned int cmd, struct flock64 *user)
250  {
251  	return -EACCES;
252  }
253  #endif
fcntl_setlease(unsigned int fd,struct file * filp,int arg)254  static inline int fcntl_setlease(unsigned int fd, struct file *filp, int arg)
255  {
256  	return -EINVAL;
257  }
258  
fcntl_getlease(struct file * filp)259  static inline int fcntl_getlease(struct file *filp)
260  {
261  	return F_UNLCK;
262  }
263  
lock_is_unlock(struct file_lock * fl)264  static inline bool lock_is_unlock(struct file_lock *fl)
265  {
266  	return false;
267  }
268  
lock_is_read(struct file_lock * fl)269  static inline bool lock_is_read(struct file_lock *fl)
270  {
271  	return false;
272  }
273  
lock_is_write(struct file_lock * fl)274  static inline bool lock_is_write(struct file_lock *fl)
275  {
276  	return false;
277  }
278  
locks_wake_up(struct file_lock * fl)279  static inline void locks_wake_up(struct file_lock *fl)
280  {
281  }
282  
283  static inline void
locks_free_lock_context(struct inode * inode)284  locks_free_lock_context(struct inode *inode)
285  {
286  }
287  
locks_init_lock(struct file_lock * fl)288  static inline void locks_init_lock(struct file_lock *fl)
289  {
290  	return;
291  }
292  
locks_init_lease(struct file_lease * fl)293  static inline void locks_init_lease(struct file_lease *fl)
294  {
295  	return;
296  }
297  
locks_copy_conflock(struct file_lock * new,struct file_lock * fl)298  static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
299  {
300  	return;
301  }
302  
locks_copy_lock(struct file_lock * new,struct file_lock * fl)303  static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
304  {
305  	return;
306  }
307  
locks_remove_posix(struct file * filp,fl_owner_t owner)308  static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
309  {
310  	return;
311  }
312  
locks_remove_file(struct file * filp)313  static inline void locks_remove_file(struct file *filp)
314  {
315  	return;
316  }
317  
posix_test_lock(struct file * filp,struct file_lock * fl)318  static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
319  {
320  	return;
321  }
322  
posix_lock_file(struct file * filp,struct file_lock * fl,struct file_lock * conflock)323  static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
324  				  struct file_lock *conflock)
325  {
326  	return -ENOLCK;
327  }
328  
locks_delete_block(struct file_lock * waiter)329  static inline int locks_delete_block(struct file_lock *waiter)
330  {
331  	return -ENOENT;
332  }
333  
vfs_test_lock(struct file * filp,struct file_lock * fl)334  static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
335  {
336  	return 0;
337  }
338  
vfs_lock_file(struct file * filp,unsigned int cmd,struct file_lock * fl,struct file_lock * conf)339  static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
340  				struct file_lock *fl, struct file_lock *conf)
341  {
342  	return -ENOLCK;
343  }
344  
vfs_cancel_lock(struct file * filp,struct file_lock * fl)345  static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
346  {
347  	return 0;
348  }
349  
vfs_inode_has_locks(struct inode * inode)350  static inline bool vfs_inode_has_locks(struct inode *inode)
351  {
352  	return false;
353  }
354  
locks_lock_inode_wait(struct inode * inode,struct file_lock * fl)355  static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
356  {
357  	return -ENOLCK;
358  }
359  
__break_lease(struct inode * inode,unsigned int mode,unsigned int type)360  static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
361  {
362  	return 0;
363  }
364  
lease_get_mtime(struct inode * inode,struct timespec64 * time)365  static inline void lease_get_mtime(struct inode *inode,
366  				   struct timespec64 *time)
367  {
368  	return;
369  }
370  
generic_setlease(struct file * filp,int arg,struct file_lease ** flp,void ** priv)371  static inline int generic_setlease(struct file *filp, int arg,
372  				    struct file_lease **flp, void **priv)
373  {
374  	return -EINVAL;
375  }
376  
kernel_setlease(struct file * filp,int arg,struct file_lease ** lease,void ** priv)377  static inline int kernel_setlease(struct file *filp, int arg,
378  			       struct file_lease **lease, void **priv)
379  {
380  	return -EINVAL;
381  }
382  
vfs_setlease(struct file * filp,int arg,struct file_lease ** lease,void ** priv)383  static inline int vfs_setlease(struct file *filp, int arg,
384  			       struct file_lease **lease, void **priv)
385  {
386  	return -EINVAL;
387  }
388  
lease_modify(struct file_lease * fl,int arg,struct list_head * dispose)389  static inline int lease_modify(struct file_lease *fl, int arg,
390  			       struct list_head *dispose)
391  {
392  	return -EINVAL;
393  }
394  
395  struct files_struct;
show_fd_locks(struct seq_file * f,struct file * filp,struct files_struct * files)396  static inline void show_fd_locks(struct seq_file *f,
397  			struct file *filp, struct files_struct *files) {}
locks_owner_has_blockers(struct file_lock_context * flctx,fl_owner_t owner)398  static inline bool locks_owner_has_blockers(struct file_lock_context *flctx,
399  			fl_owner_t owner)
400  {
401  	return false;
402  }
403  
404  static inline struct file_lock_context *
locks_inode_context(const struct inode * inode)405  locks_inode_context(const struct inode *inode)
406  {
407  	return NULL;
408  }
409  
410  #endif /* !CONFIG_FILE_LOCKING */
411  
412  /* for walking lists of file_locks linked by fl_list */
413  #define for_each_file_lock(_fl, _head)	list_for_each_entry(_fl, _head, c.flc_list)
414  
locks_lock_file_wait(struct file * filp,struct file_lock * fl)415  static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
416  {
417  	return locks_lock_inode_wait(file_inode(filp), fl);
418  }
419  
420  #ifdef CONFIG_FILE_LOCKING
break_lease(struct inode * inode,unsigned int mode)421  static inline int break_lease(struct inode *inode, unsigned int mode)
422  {
423  	struct file_lock_context *flctx;
424  
425  	/*
426  	 * Since this check is lockless, we must ensure that any refcounts
427  	 * taken are done before checking i_flctx->flc_lease. Otherwise, we
428  	 * could end up racing with tasks trying to set a new lease on this
429  	 * file.
430  	 */
431  	flctx = READ_ONCE(inode->i_flctx);
432  	if (!flctx)
433  		return 0;
434  	smp_mb();
435  	if (!list_empty_careful(&flctx->flc_lease))
436  		return __break_lease(inode, mode, FL_LEASE);
437  	return 0;
438  }
439  
break_deleg(struct inode * inode,unsigned int mode)440  static inline int break_deleg(struct inode *inode, unsigned int mode)
441  {
442  	struct file_lock_context *flctx;
443  
444  	/*
445  	 * Since this check is lockless, we must ensure that any refcounts
446  	 * taken are done before checking i_flctx->flc_lease. Otherwise, we
447  	 * could end up racing with tasks trying to set a new lease on this
448  	 * file.
449  	 */
450  	flctx = READ_ONCE(inode->i_flctx);
451  	if (!flctx)
452  		return 0;
453  	smp_mb();
454  	if (!list_empty_careful(&flctx->flc_lease))
455  		return __break_lease(inode, mode, FL_DELEG);
456  	return 0;
457  }
458  
try_break_deleg(struct inode * inode,struct inode ** delegated_inode)459  static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
460  {
461  	int ret;
462  
463  	ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
464  	if (ret == -EWOULDBLOCK && delegated_inode) {
465  		*delegated_inode = inode;
466  		ihold(inode);
467  	}
468  	return ret;
469  }
470  
break_deleg_wait(struct inode ** delegated_inode)471  static inline int break_deleg_wait(struct inode **delegated_inode)
472  {
473  	int ret;
474  
475  	ret = break_deleg(*delegated_inode, O_WRONLY);
476  	iput(*delegated_inode);
477  	*delegated_inode = NULL;
478  	return ret;
479  }
480  
break_layout(struct inode * inode,bool wait)481  static inline int break_layout(struct inode *inode, bool wait)
482  {
483  	smp_mb();
484  	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
485  		return __break_lease(inode,
486  				wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
487  				FL_LAYOUT);
488  	return 0;
489  }
490  
491  #else /* !CONFIG_FILE_LOCKING */
break_lease(struct inode * inode,unsigned int mode)492  static inline int break_lease(struct inode *inode, unsigned int mode)
493  {
494  	return 0;
495  }
496  
break_deleg(struct inode * inode,unsigned int mode)497  static inline int break_deleg(struct inode *inode, unsigned int mode)
498  {
499  	return 0;
500  }
501  
try_break_deleg(struct inode * inode,struct inode ** delegated_inode)502  static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
503  {
504  	return 0;
505  }
506  
break_deleg_wait(struct inode ** delegated_inode)507  static inline int break_deleg_wait(struct inode **delegated_inode)
508  {
509  	BUG();
510  	return 0;
511  }
512  
break_layout(struct inode * inode,bool wait)513  static inline int break_layout(struct inode *inode, bool wait)
514  {
515  	return 0;
516  }
517  
518  #endif /* CONFIG_FILE_LOCKING */
519  
520  #endif /* _LINUX_FILELOCK_H */
521