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
29struct file_lock;
30struct file_lease;
31
32struct file_lock_operations {
33	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
34	void (*fl_release_private)(struct file_lock *);
35};
36
37struct 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
47struct 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
54struct 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
63struct net;
64void locks_start_grace(struct net *, struct lock_manager *);
65void locks_end_grace(struct lock_manager *);
66bool locks_in_grace(struct net *);
67bool 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
93struct 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
112struct 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
133struct 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
142struct 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
150int fcntl_getlk(struct file *, unsigned int, struct flock *);
151int fcntl_setlk(unsigned int, struct file *, unsigned int,
152			struct flock *);
153
154#if BITS_PER_LONG == 32
155int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
156int fcntl_setlk64(unsigned int, struct file *, unsigned int,
157			struct flock64 *);
158#endif
159
160int fcntl_setlease(unsigned int fd, struct file *filp, int arg);
161int fcntl_getlease(struct file *filp);
162
163static inline bool lock_is_unlock(struct file_lock *fl)
164{
165	return fl->c.flc_type == F_UNLCK;
166}
167
168static inline bool lock_is_read(struct file_lock *fl)
169{
170	return fl->c.flc_type == F_RDLCK;
171}
172
173static inline bool lock_is_write(struct file_lock *fl)
174{
175	return fl->c.flc_type == F_WRLCK;
176}
177
178static inline void locks_wake_up(struct file_lock *fl)
179{
180	wake_up(&fl->c.flc_wait);
181}
182
183/* fs/locks.c */
184void locks_free_lock_context(struct inode *inode);
185void locks_free_lock(struct file_lock *fl);
186void locks_init_lock(struct file_lock *);
187struct file_lock *locks_alloc_lock(void);
188void locks_copy_lock(struct file_lock *, struct file_lock *);
189void locks_copy_conflock(struct file_lock *, struct file_lock *);
190void locks_remove_posix(struct file *, fl_owner_t);
191void locks_remove_file(struct file *);
192void locks_release_private(struct file_lock *);
193void posix_test_lock(struct file *, struct file_lock *);
194int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
195int locks_delete_block(struct file_lock *);
196int vfs_test_lock(struct file *, struct file_lock *);
197int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
198int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
199bool vfs_inode_has_locks(struct inode *inode);
200int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
201
202void locks_init_lease(struct file_lease *);
203void locks_free_lease(struct file_lease *fl);
204struct file_lease *locks_alloc_lease(void);
205int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
206void lease_get_mtime(struct inode *, struct timespec64 *time);
207int generic_setlease(struct file *, int, struct file_lease **, void **priv);
208int kernel_setlease(struct file *, int, struct file_lease **, void **);
209int vfs_setlease(struct file *, int, struct file_lease **, void **);
210int lease_modify(struct file_lease *, int, struct list_head *);
211
212struct notifier_block;
213int lease_register_notifier(struct notifier_block *);
214void lease_unregister_notifier(struct notifier_block *);
215
216struct files_struct;
217void show_fd_locks(struct seq_file *f,
218			 struct file *filp, struct files_struct *files);
219bool locks_owner_has_blockers(struct file_lock_context *flctx,
220			fl_owner_t owner);
221
222static inline struct file_lock_context *
223locks_inode_context(const struct inode *inode)
224{
225	return smp_load_acquire(&inode->i_flctx);
226}
227
228#else /* !CONFIG_FILE_LOCKING */
229static inline int fcntl_getlk(struct file *file, unsigned int cmd,
230			      struct flock __user *user)
231{
232	return -EINVAL;
233}
234
235static 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
242static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
243				struct flock64 *user)
244{
245	return -EINVAL;
246}
247
248static inline int fcntl_setlk64(unsigned int fd, struct file *file,
249				unsigned int cmd, struct flock64 *user)
250{
251	return -EACCES;
252}
253#endif
254static inline int fcntl_setlease(unsigned int fd, struct file *filp, int arg)
255{
256	return -EINVAL;
257}
258
259static inline int fcntl_getlease(struct file *filp)
260{
261	return F_UNLCK;
262}
263
264static inline bool lock_is_unlock(struct file_lock *fl)
265{
266	return false;
267}
268
269static inline bool lock_is_read(struct file_lock *fl)
270{
271	return false;
272}
273
274static inline bool lock_is_write(struct file_lock *fl)
275{
276	return false;
277}
278
279static inline void locks_wake_up(struct file_lock *fl)
280{
281}
282
283static inline void
284locks_free_lock_context(struct inode *inode)
285{
286}
287
288static inline void locks_init_lock(struct file_lock *fl)
289{
290	return;
291}
292
293static inline void locks_init_lease(struct file_lease *fl)
294{
295	return;
296}
297
298static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
299{
300	return;
301}
302
303static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
304{
305	return;
306}
307
308static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
309{
310	return;
311}
312
313static inline void locks_remove_file(struct file *filp)
314{
315	return;
316}
317
318static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
319{
320	return;
321}
322
323static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
324				  struct file_lock *conflock)
325{
326	return -ENOLCK;
327}
328
329static inline int locks_delete_block(struct file_lock *waiter)
330{
331	return -ENOENT;
332}
333
334static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
335{
336	return 0;
337}
338
339static 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
345static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
346{
347	return 0;
348}
349
350static inline bool vfs_inode_has_locks(struct inode *inode)
351{
352	return false;
353}
354
355static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
356{
357	return -ENOLCK;
358}
359
360static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
361{
362	return 0;
363}
364
365static inline void lease_get_mtime(struct inode *inode,
366				   struct timespec64 *time)
367{
368	return;
369}
370
371static inline int generic_setlease(struct file *filp, int arg,
372				    struct file_lease **flp, void **priv)
373{
374	return -EINVAL;
375}
376
377static inline int kernel_setlease(struct file *filp, int arg,
378			       struct file_lease **lease, void **priv)
379{
380	return -EINVAL;
381}
382
383static inline int vfs_setlease(struct file *filp, int arg,
384			       struct file_lease **lease, void **priv)
385{
386	return -EINVAL;
387}
388
389static inline int lease_modify(struct file_lease *fl, int arg,
390			       struct list_head *dispose)
391{
392	return -EINVAL;
393}
394
395struct files_struct;
396static inline void show_fd_locks(struct seq_file *f,
397			struct file *filp, struct files_struct *files) {}
398static inline bool locks_owner_has_blockers(struct file_lock_context *flctx,
399			fl_owner_t owner)
400{
401	return false;
402}
403
404static inline struct file_lock_context *
405locks_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
415static 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
421static inline int break_lease(struct inode *inode, unsigned int mode)
422{
423	/*
424	 * Since this check is lockless, we must ensure that any refcounts
425	 * taken are done before checking i_flctx->flc_lease. Otherwise, we
426	 * could end up racing with tasks trying to set a new lease on this
427	 * file.
428	 */
429	smp_mb();
430	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
431		return __break_lease(inode, mode, FL_LEASE);
432	return 0;
433}
434
435static inline int break_deleg(struct inode *inode, unsigned int mode)
436{
437	/*
438	 * Since this check is lockless, we must ensure that any refcounts
439	 * taken are done before checking i_flctx->flc_lease. Otherwise, we
440	 * could end up racing with tasks trying to set a new lease on this
441	 * file.
442	 */
443	smp_mb();
444	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
445		return __break_lease(inode, mode, FL_DELEG);
446	return 0;
447}
448
449static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
450{
451	int ret;
452
453	ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
454	if (ret == -EWOULDBLOCK && delegated_inode) {
455		*delegated_inode = inode;
456		ihold(inode);
457	}
458	return ret;
459}
460
461static inline int break_deleg_wait(struct inode **delegated_inode)
462{
463	int ret;
464
465	ret = break_deleg(*delegated_inode, O_WRONLY);
466	iput(*delegated_inode);
467	*delegated_inode = NULL;
468	return ret;
469}
470
471static inline int break_layout(struct inode *inode, bool wait)
472{
473	smp_mb();
474	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
475		return __break_lease(inode,
476				wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
477				FL_LAYOUT);
478	return 0;
479}
480
481#else /* !CONFIG_FILE_LOCKING */
482static inline int break_lease(struct inode *inode, unsigned int mode)
483{
484	return 0;
485}
486
487static inline int break_deleg(struct inode *inode, unsigned int mode)
488{
489	return 0;
490}
491
492static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
493{
494	return 0;
495}
496
497static inline int break_deleg_wait(struct inode **delegated_inode)
498{
499	BUG();
500	return 0;
501}
502
503static inline int break_layout(struct inode *inode, bool wait)
504{
505	return 0;
506}
507
508#endif /* CONFIG_FILE_LOCKING */
509
510#endif /* _LINUX_FILELOCK_H */
511