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