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_waiter(struct file_lock_core *flc)
179{
180 wake_up(&flc->flc_wait);
181}
182
183static inline void locks_wake_up(struct file_lock *fl)
184{
185 locks_wake_up_waiter(flc: &fl->c);
186}
187
188static inline bool locks_can_async_lock(const struct file_operations *fops)
189{
190 return !fops->lock || fops->fop_flags & FOP_ASYNC_LOCK;
191}
192
193/* fs/locks.c */
194void locks_free_lock_context(struct inode *inode);
195void locks_free_lock(struct file_lock *fl);
196void locks_init_lock(struct file_lock *);
197struct file_lock *locks_alloc_lock(void);
198void locks_copy_lock(struct file_lock *, struct file_lock *);
199void locks_copy_conflock(struct file_lock *, struct file_lock *);
200void locks_remove_posix(struct file *, fl_owner_t);
201void locks_remove_file(struct file *);
202void locks_release_private(struct file_lock *);
203void posix_test_lock(struct file *, struct file_lock *);
204int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
205int locks_delete_block(struct file_lock *);
206int vfs_test_lock(struct file *, struct file_lock *);
207int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
208int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
209bool vfs_inode_has_locks(struct inode *inode);
210int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
211
212void locks_init_lease(struct file_lease *);
213void locks_free_lease(struct file_lease *fl);
214struct file_lease *locks_alloc_lease(void);
215int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
216void lease_get_mtime(struct inode *, struct timespec64 *time);
217int generic_setlease(struct file *, int, struct file_lease **, void **priv);
218int kernel_setlease(struct file *, int, struct file_lease **, void **);
219int vfs_setlease(struct file *, int, struct file_lease **, void **);
220int lease_modify(struct file_lease *, int, struct list_head *);
221
222struct notifier_block;
223int lease_register_notifier(struct notifier_block *);
224void lease_unregister_notifier(struct notifier_block *);
225
226struct files_struct;
227void show_fd_locks(struct seq_file *f,
228 struct file *filp, struct files_struct *files);
229bool locks_owner_has_blockers(struct file_lock_context *flctx,
230 fl_owner_t owner);
231
232static inline struct file_lock_context *
233locks_inode_context(const struct inode *inode)
234{
235 return smp_load_acquire(&inode->i_flctx);
236}
237
238#else /* !CONFIG_FILE_LOCKING */
239static inline int fcntl_getlk(struct file *file, unsigned int cmd,
240 struct flock __user *user)
241{
242 return -EINVAL;
243}
244
245static inline int fcntl_setlk(unsigned int fd, struct file *file,
246 unsigned int cmd, struct flock __user *user)
247{
248 return -EACCES;
249}
250
251#if BITS_PER_LONG == 32
252static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
253 struct flock64 *user)
254{
255 return -EINVAL;
256}
257
258static inline int fcntl_setlk64(unsigned int fd, struct file *file,
259 unsigned int cmd, struct flock64 *user)
260{
261 return -EACCES;
262}
263#endif
264static inline int fcntl_setlease(unsigned int fd, struct file *filp, int arg)
265{
266 return -EINVAL;
267}
268
269static inline int fcntl_getlease(struct file *filp)
270{
271 return F_UNLCK;
272}
273
274static inline bool lock_is_unlock(struct file_lock *fl)
275{
276 return false;
277}
278
279static inline bool lock_is_read(struct file_lock *fl)
280{
281 return false;
282}
283
284static inline bool lock_is_write(struct file_lock *fl)
285{
286 return false;
287}
288
289static inline void locks_wake_up(struct file_lock *fl)
290{
291}
292
293static inline void
294locks_free_lock_context(struct inode *inode)
295{
296}
297
298static inline void locks_init_lock(struct file_lock *fl)
299{
300 return;
301}
302
303static inline void locks_init_lease(struct file_lease *fl)
304{
305 return;
306}
307
308static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
309{
310 return;
311}
312
313static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
314{
315 return;
316}
317
318static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
319{
320 return;
321}
322
323static inline void locks_remove_file(struct file *filp)
324{
325 return;
326}
327
328static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
329{
330 return;
331}
332
333static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
334 struct file_lock *conflock)
335{
336 return -ENOLCK;
337}
338
339static inline int locks_delete_block(struct file_lock *waiter)
340{
341 return -ENOENT;
342}
343
344static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
345{
346 return 0;
347}
348
349static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
350 struct file_lock *fl, struct file_lock *conf)
351{
352 return -ENOLCK;
353}
354
355static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
356{
357 return 0;
358}
359
360static inline bool vfs_inode_has_locks(struct inode *inode)
361{
362 return false;
363}
364
365static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
366{
367 return -ENOLCK;
368}
369
370static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
371{
372 return 0;
373}
374
375static inline void lease_get_mtime(struct inode *inode,
376 struct timespec64 *time)
377{
378 return;
379}
380
381static inline int generic_setlease(struct file *filp, int arg,
382 struct file_lease **flp, void **priv)
383{
384 return -EINVAL;
385}
386
387static inline int kernel_setlease(struct file *filp, int arg,
388 struct file_lease **lease, void **priv)
389{
390 return -EINVAL;
391}
392
393static inline int vfs_setlease(struct file *filp, int arg,
394 struct file_lease **lease, void **priv)
395{
396 return -EINVAL;
397}
398
399static inline int lease_modify(struct file_lease *fl, int arg,
400 struct list_head *dispose)
401{
402 return -EINVAL;
403}
404
405struct files_struct;
406static inline void show_fd_locks(struct seq_file *f,
407 struct file *filp, struct files_struct *files) {}
408static inline bool locks_owner_has_blockers(struct file_lock_context *flctx,
409 fl_owner_t owner)
410{
411 return false;
412}
413
414static inline struct file_lock_context *
415locks_inode_context(const struct inode *inode)
416{
417 return NULL;
418}
419
420#endif /* !CONFIG_FILE_LOCKING */
421
422/* for walking lists of file_locks linked by fl_list */
423#define for_each_file_lock(_fl, _head) list_for_each_entry(_fl, _head, c.flc_list)
424
425static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
426{
427 return locks_lock_inode_wait(inode: file_inode(f: filp), fl);
428}
429
430#ifdef CONFIG_FILE_LOCKING
431static inline int break_lease(struct inode *inode, unsigned int mode)
432{
433 struct file_lock_context *flctx;
434
435 /*
436 * Since this check is lockless, we must ensure that any refcounts
437 * taken are done before checking i_flctx->flc_lease. Otherwise, we
438 * could end up racing with tasks trying to set a new lease on this
439 * file.
440 */
441 flctx = READ_ONCE(inode->i_flctx);
442 if (!flctx)
443 return 0;
444 smp_mb();
445 if (!list_empty_careful(head: &flctx->flc_lease))
446 return __break_lease(inode, flags: mode, FL_LEASE);
447 return 0;
448}
449
450static inline int break_deleg(struct inode *inode, unsigned int mode)
451{
452 struct file_lock_context *flctx;
453
454 /*
455 * Since this check is lockless, we must ensure that any refcounts
456 * taken are done before checking i_flctx->flc_lease. Otherwise, we
457 * could end up racing with tasks trying to set a new lease on this
458 * file.
459 */
460 flctx = READ_ONCE(inode->i_flctx);
461 if (!flctx)
462 return 0;
463 smp_mb();
464 if (!list_empty_careful(head: &flctx->flc_lease))
465 return __break_lease(inode, flags: mode, FL_DELEG);
466 return 0;
467}
468
469static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
470{
471 int ret;
472
473 ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
474 if (ret == -EWOULDBLOCK && delegated_inode) {
475 *delegated_inode = inode;
476 ihold(inode);
477 }
478 return ret;
479}
480
481static inline int break_deleg_wait(struct inode **delegated_inode)
482{
483 int ret;
484
485 ret = break_deleg(inode: *delegated_inode, O_WRONLY);
486 iput(*delegated_inode);
487 *delegated_inode = NULL;
488 return ret;
489}
490
491static inline int break_layout(struct inode *inode, bool wait)
492{
493 smp_mb();
494 if (inode->i_flctx && !list_empty_careful(head: &inode->i_flctx->flc_lease))
495 return __break_lease(inode,
496 flags: wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
497 FL_LAYOUT);
498 return 0;
499}
500
501#else /* !CONFIG_FILE_LOCKING */
502static inline int break_lease(struct inode *inode, unsigned int mode)
503{
504 return 0;
505}
506
507static inline int break_deleg(struct inode *inode, unsigned int mode)
508{
509 return 0;
510}
511
512static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
513{
514 return 0;
515}
516
517static inline int break_deleg_wait(struct inode **delegated_inode)
518{
519 BUG();
520 return 0;
521}
522
523static inline int break_layout(struct inode *inode, bool wait)
524{
525 return 0;
526}
527
528#endif /* CONFIG_FILE_LOCKING */
529
530#endif /* _LINUX_FILELOCK_H */
531