4 * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
5 * Doug Evans (dje@spiff.uucp), August 07, 1992
7 * Deadlock detection added.
8 * FIXME: one thing isn't handled yet:
9 * - mandatory locks (requires lots of changes elsewhere)
10 * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994.
12 * Miscellaneous edits, and a total rewrite of posix_lock_file() code.
13 * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994
15 * Converted file_lock_table to a linked list from an array, which eliminates
16 * the limits on how many active file locks are open.
17 * Chad Page (pageone@netcom.com), November 27, 1994
19 * Removed dependency on file descriptors. dup()'ed file descriptors now
20 * get the same locks as the original file descriptors, and a close() on
21 * any file descriptor removes ALL the locks on the file for the current
22 * process. Since locks still depend on the process id, locks are inherited
23 * after an exec() but not after a fork(). This agrees with POSIX, and both
24 * BSD and SVR4 practice.
25 * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995
27 * Scrapped free list which is redundant now that we allocate locks
28 * dynamically with kmalloc()/kfree().
29 * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995
31 * Implemented two lock personalities - FL_FLOCK and FL_POSIX.
33 * FL_POSIX locks are created with calls to fcntl() and lockf() through the
34 * fcntl() system call. They have the semantics described above.
36 * FL_FLOCK locks are created with calls to flock(), through the flock()
37 * system call, which is new. Old C libraries implement flock() via fcntl()
38 * and will continue to use the old, broken implementation.
40 * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated
41 * with a file pointer (filp). As a result they can be shared by a parent
42 * process and its children after a fork(). They are removed when the last
43 * file descriptor referring to the file pointer is closed (unless explicitly
46 * FL_FLOCK locks never deadlock, an existing lock is always removed before
47 * upgrading from shared to exclusive (or vice versa). When this happens
48 * any processes blocked by the current lock are woken up and allowed to
49 * run before the new lock is applied.
50 * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995
52 * Removed some race conditions in flock_lock_file(), marked other possible
53 * races. Just grep for FIXME to see them.
54 * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996.
56 * Addressed Dmitry's concerns. Deadlock checking no longer recursive.
57 * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep
58 * once we've checked for blocking and deadlocking.
59 * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996.
61 * Initial implementation of mandatory locks. SunOS turned out to be
62 * a rotten model, so I implemented the "obvious" semantics.
63 * See 'linux/Documentation/mandatory.txt' for details.
64 * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996.
66 * Don't allow mandatory locks on mmap()'ed files. Added simple functions to
67 * check if a file has mandatory locks, used by mmap(), open() and creat() to
68 * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference
70 * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996.
72 * Tidied up block list handling. Added '/proc/locks' interface.
73 * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996.
75 * Fixed deadlock condition for pathological code that mixes calls to
76 * flock() and fcntl().
77 * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996.
79 * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use
80 * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to
81 * guarantee sensible behaviour in the case where file system modules might
82 * be compiled with different options than the kernel itself.
83 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
85 * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel
86 * (Thomas.Meckel@mni.fh-giessen.de) for spotting this.
87 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
89 * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK
90 * locks. Changed process synchronisation to avoid dereferencing locks that
91 * have already been freed.
92 * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996.
94 * Made the block list a circular list to minimise searching in the list.
95 * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996.
97 * Made mandatory locking a mount option. Default is not to allow mandatory
99 * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996.
101 * Some adaptations for NFS support.
102 * Olaf Kirch (okir@monad.swb.de), Dec 1996,
104 * Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
105 * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
108 #include <linux/malloc.h>
109 #include <linux/file.h>
110 #include <linux/smp_lock.h>
112 #include <asm/uaccess.h>
114 #define OFFSET_MAX ((off_t)LONG_MAX) /* FIXME: move elsewhere? */
116 static int flock_make_lock(struct file
*filp
, struct file_lock
*fl
,
118 static int posix_make_lock(struct file
*filp
, struct file_lock
*fl
,
120 static int flock_locks_conflict(struct file_lock
*caller_fl
,
121 struct file_lock
*sys_fl
);
122 static int posix_locks_conflict(struct file_lock
*caller_fl
,
123 struct file_lock
*sys_fl
);
124 static int locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
);
125 static int flock_lock_file(struct file
*filp
, struct file_lock
*caller
,
127 static int posix_locks_deadlock(struct file_lock
*caller
,
128 struct file_lock
*blocker
);
130 static struct file_lock
*locks_empty_lock(void);
131 static struct file_lock
*locks_init_lock(struct file_lock
*,
133 static void locks_insert_lock(struct file_lock
**pos
, struct file_lock
*fl
);
134 static void locks_delete_lock(struct file_lock
**thisfl_p
, unsigned int wait
);
135 static char *lock_get_status(struct file_lock
*fl
, int id
, char *pfx
);
137 static void locks_insert_block(struct file_lock
*blocker
, struct file_lock
*waiter
);
138 static void locks_delete_block(struct file_lock
*blocker
, struct file_lock
*waiter
);
139 static void locks_wake_up_blocks(struct file_lock
*blocker
, unsigned int wait
);
141 struct file_lock
*file_lock_table
= NULL
;
143 /* Allocate a new lock, and initialize its fields from fl.
144 * The lock is not inserted into any lists until locks_insert_lock() or
145 * locks_insert_block() are called.
147 static inline struct file_lock
*locks_alloc_lock(struct file_lock
*fl
)
149 return locks_init_lock(locks_empty_lock(), fl
);
152 /* Free lock not inserted in any queue.
154 static inline void locks_free_lock(struct file_lock
*fl
)
156 if (waitqueue_active(&fl
->fl_wait
))
157 panic("Attempting to free lock with active wait queue");
159 if (fl
->fl_nextblock
!= NULL
|| fl
->fl_prevblock
!= NULL
)
160 panic("Attempting to free lock with active block list");
166 /* Check if two locks overlap each other.
168 static inline int locks_overlap(struct file_lock
*fl1
, struct file_lock
*fl2
)
170 return ((fl1
->fl_end
>= fl2
->fl_start
) &&
171 (fl2
->fl_end
>= fl1
->fl_start
));
175 * Check whether two locks have the same owner
176 * N.B. Do we need the test on PID as well as owner?
177 * (Clone tasks should be considered as one "owner".)
180 locks_same_owner(struct file_lock
*fl1
, struct file_lock
*fl2
)
182 return (fl1
->fl_owner
== fl2
->fl_owner
) &&
183 (fl1
->fl_pid
== fl2
->fl_pid
);
186 /* Insert waiter into blocker's block list.
187 * We use a circular list so that processes can be easily woken up in
188 * the order they blocked. The documentation doesn't require this but
189 * it seems like the reasonable thing to do.
191 static void locks_insert_block(struct file_lock
*blocker
,
192 struct file_lock
*waiter
)
194 struct file_lock
*prevblock
;
196 if (blocker
->fl_prevblock
== NULL
)
197 /* No previous waiters - list is empty */
200 /* Previous waiters exist - add to end of list */
201 prevblock
= blocker
->fl_prevblock
;
203 prevblock
->fl_nextblock
= waiter
;
204 blocker
->fl_prevblock
= waiter
;
205 waiter
->fl_nextblock
= blocker
;
206 waiter
->fl_prevblock
= prevblock
;
211 /* Remove waiter from blocker's block list.
212 * When blocker ends up pointing to itself then the list is empty.
214 static void locks_delete_block(struct file_lock
*blocker
,
215 struct file_lock
*waiter
)
217 struct file_lock
*nextblock
;
218 struct file_lock
*prevblock
;
220 nextblock
= waiter
->fl_nextblock
;
221 prevblock
= waiter
->fl_prevblock
;
223 if (nextblock
== NULL
)
226 nextblock
->fl_prevblock
= prevblock
;
227 prevblock
->fl_nextblock
= nextblock
;
229 waiter
->fl_prevblock
= waiter
->fl_nextblock
= NULL
;
230 if (blocker
->fl_nextblock
== blocker
)
231 /* No more locks on blocker's blocked list */
232 blocker
->fl_prevblock
= blocker
->fl_nextblock
= NULL
;
236 /* The following two are for the benefit of lockd.
239 posix_block_lock(struct file_lock
*blocker
, struct file_lock
*waiter
)
241 locks_insert_block(blocker
, waiter
);
246 posix_unblock_lock(struct file_lock
*waiter
)
248 if (waiter
->fl_prevblock
)
249 locks_delete_block(waiter
->fl_prevblock
, waiter
);
253 /* Wake up processes blocked waiting for blocker.
254 * If told to wait then schedule the processes until the block list
255 * is empty, otherwise empty the block list ourselves.
257 static void locks_wake_up_blocks(struct file_lock
*blocker
, unsigned int wait
)
259 struct file_lock
*waiter
;
261 while ((waiter
= blocker
->fl_nextblock
) != NULL
) {
262 /* N.B. Is it possible for the notify function to block?? */
263 if (waiter
->fl_notify
)
264 waiter
->fl_notify(waiter
);
265 wake_up(&waiter
->fl_wait
);
267 /* Let the blocked process remove waiter from the
268 * block list when it gets scheduled.
270 current
->policy
|= SCHED_YIELD
;
273 /* Remove waiter from the block list, because by the
274 * time it wakes up blocker won't exist any more.
276 locks_delete_block(blocker
, waiter
);
282 /* flock() system call entry point. Apply a FL_FLOCK style lock to
283 * an open file descriptor.
285 asmlinkage
int sys_flock(unsigned int fd
, unsigned int cmd
)
287 struct file_lock file_lock
;
297 if (!flock_make_lock(filp
, &file_lock
, cmd
))
300 if ((file_lock
.fl_type
!= F_UNLCK
) && !(filp
->f_mode
& 3))
302 error
= flock_lock_file(filp
, &file_lock
,
303 (cmd
& (LOCK_UN
| LOCK_NB
)) ? 0 : 1);
311 /* Report the first existing lock that would conflict with l.
312 * This implements the F_GETLK command of fcntl().
314 int fcntl_getlk(unsigned int fd
, struct flock
*l
)
317 struct file_lock
*fl
,file_lock
;
322 if (copy_from_user(&flock
, l
, sizeof(flock
)))
325 if ((flock
.l_type
!= F_RDLCK
) && (flock
.l_type
!= F_WRLCK
))
334 if (!filp
->f_dentry
|| !filp
->f_dentry
->d_inode
)
337 if (!posix_make_lock(filp
, &file_lock
, &flock
))
340 if (filp
->f_op
->lock
) {
341 error
= filp
->f_op
->lock(filp
, F_GETLK
, &file_lock
);
346 fl
= posix_test_lock(filp
, &file_lock
);
349 flock
.l_type
= F_UNLCK
;
351 flock
.l_pid
= fl
->fl_pid
;
352 flock
.l_start
= fl
->fl_start
;
353 flock
.l_len
= fl
->fl_end
== OFFSET_MAX
? 0 :
354 fl
->fl_end
- fl
->fl_start
+ 1;
356 flock
.l_type
= fl
->fl_type
;
359 if (!copy_to_user(l
, &flock
, sizeof(flock
)))
368 /* Apply the lock described by l to an open file descriptor.
369 * This implements both the F_SETLK and F_SETLKW commands of fcntl().
371 int fcntl_setlk(unsigned int fd
, unsigned int cmd
, struct flock
*l
)
374 struct file_lock file_lock
;
376 struct dentry
* dentry
;
381 * This might block, so we do it before checking the inode.
384 if (copy_from_user(&flock
, l
, sizeof(flock
)))
387 /* Get arguments and validate them ...
396 if (!(dentry
= filp
->f_dentry
))
398 if (!(inode
= dentry
->d_inode
))
401 /* Don't allow mandatory locks on files that may be memory mapped
404 if (IS_MANDLOCK(inode
) &&
405 (inode
->i_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
&&
407 struct vm_area_struct
*vma
= inode
->i_mmap
;
410 if (vma
->vm_flags
& VM_MAYSHARE
)
412 } while ((vma
= vma
->vm_next_share
) != NULL
);
416 if (!posix_make_lock(filp
, &file_lock
, &flock
))
420 switch (flock
.l_type
) {
422 if (!(filp
->f_mode
& FMODE_READ
))
426 if (!(filp
->f_mode
& FMODE_WRITE
))
434 /* warn a bit for now, but don't overdo it */
436 static int count
= 0;
440 "fcntl_setlk() called by process %d (%s) with broken flock() emulation\n",
441 current
->pid
, current
->comm
);
444 if (!(filp
->f_mode
& 3))
453 if (filp
->f_op
->lock
!= NULL
) {
454 error
= filp
->f_op
->lock(filp
, cmd
, &file_lock
);
458 error
= posix_lock_file(filp
, &file_lock
, cmd
== F_SETLKW
);
467 * This function is called when the file is being removed
468 * from the task's fd array.
470 void locks_remove_posix(struct file
*filp
, fl_owner_t owner
)
472 struct inode
* inode
= filp
->f_dentry
->d_inode
;
473 struct file_lock file_lock
, *fl
;
474 struct file_lock
**before
;
477 * For POSIX locks we free all locks on this file for the given task.
480 before
= &inode
->i_flock
;
481 while ((fl
= *before
) != NULL
) {
482 if ((fl
->fl_flags
& FL_POSIX
) && fl
->fl_owner
== owner
) {
483 int (*lock
)(struct file
*, int, struct file_lock
*);
484 lock
= filp
->f_op
->lock
;
487 file_lock
.fl_type
= F_UNLCK
;
489 locks_delete_lock(before
, 0);
491 lock(filp
, F_SETLK
, &file_lock
);
492 /* List may have changed: */
497 before
= &fl
->fl_next
;
502 * This function is called on the last close of an open file.
504 void locks_remove_flock(struct file
*filp
)
506 struct inode
* inode
= filp
->f_dentry
->d_inode
;
507 struct file_lock file_lock
, *fl
;
508 struct file_lock
**before
;
511 before
= &inode
->i_flock
;
512 while ((fl
= *before
) != NULL
) {
513 if ((fl
->fl_flags
& FL_FLOCK
) && fl
->fl_file
== filp
) {
514 int (*lock
)(struct file
*, int, struct file_lock
*);
517 lock
= filp
->f_op
->lock
;
520 file_lock
.fl_type
= F_UNLCK
;
522 locks_delete_lock(before
, 0);
524 lock(filp
, F_SETLK
, &file_lock
);
525 /* List may have changed: */
530 before
= &fl
->fl_next
;
535 posix_test_lock(struct file
*filp
, struct file_lock
*fl
)
537 struct file_lock
*cfl
;
539 for (cfl
= filp
->f_dentry
->d_inode
->i_flock
; cfl
; cfl
= cfl
->fl_next
) {
540 if (!(cfl
->fl_flags
& FL_POSIX
))
542 if (posix_locks_conflict(cfl
, fl
))
549 int locks_mandatory_locked(struct inode
*inode
)
551 fl_owner_t owner
= current
->files
;
552 struct file_lock
*fl
;
555 * Search the lock list for this inode for any POSIX locks.
558 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
559 if (!(fl
->fl_flags
& FL_POSIX
))
561 if (fl
->fl_owner
!= owner
)
565 return fl
? -EAGAIN
: 0;
568 int locks_mandatory_area(int read_write
, struct inode
*inode
,
569 struct file
*filp
, loff_t offset
,
572 struct file_lock
*fl
;
573 struct file_lock tfl
;
576 memset(&tfl
, 0, sizeof(tfl
));
579 tfl
.fl_flags
= FL_POSIX
| FL_ACCESS
;
580 tfl
.fl_owner
= current
->files
;
581 tfl
.fl_pid
= current
->pid
;
582 init_waitqueue_head(&tfl
.fl_wait
);
583 tfl
.fl_type
= (read_write
== FLOCK_VERIFY_WRITE
) ? F_WRLCK
: F_RDLCK
;
584 tfl
.fl_start
= offset
;
585 tfl
.fl_end
= offset
+ count
- 1;
591 /* Search the lock list for this inode for locks that conflict with
592 * the proposed read/write.
594 for (fl
= inode
->i_flock
; ; fl
= fl
->fl_next
) {
598 if (!(fl
->fl_flags
& FL_POSIX
))
600 /* Block for writes against a "read" lock,
601 * and both reads and writes against a "write" lock.
603 if (posix_locks_conflict(fl
, &tfl
)) {
605 if (filp
&& (filp
->f_flags
& O_NONBLOCK
))
607 error
= -ERESTARTSYS
;
608 if (signal_pending(current
))
611 if (posix_locks_deadlock(&tfl
, fl
))
614 locks_insert_block(fl
, &tfl
);
615 interruptible_sleep_on(&tfl
.fl_wait
);
616 locks_delete_block(fl
, &tfl
);
619 * If we've been sleeping someone might have
620 * changed the permissions behind our back.
622 if ((inode
->i_mode
& (S_ISGID
| S_IXGRP
)) != S_ISGID
)
631 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
634 static int posix_make_lock(struct file
*filp
, struct file_lock
*fl
,
639 memset(fl
, 0, sizeof(*fl
));
641 init_waitqueue_head(&fl
->fl_wait
);
642 fl
->fl_flags
= FL_POSIX
;
648 fl
->fl_type
= l
->l_type
;
654 switch (l
->l_whence
) {
662 start
= filp
->f_dentry
->d_inode
->i_size
;
668 if (((start
+= l
->l_start
) < 0) || (l
->l_len
< 0))
670 fl
->fl_start
= start
; /* we record the absolute position */
671 if ((l
->l_len
== 0) || ((fl
->fl_end
= start
+ l
->l_len
- 1) < 0))
672 fl
->fl_end
= OFFSET_MAX
;
675 fl
->fl_owner
= current
->files
;
676 fl
->fl_pid
= current
->pid
;
681 /* Verify a call to flock() and fill in a file_lock structure with
682 * an appropriate FLOCK lock.
684 static int flock_make_lock(struct file
*filp
, struct file_lock
*fl
,
687 memset(fl
, 0, sizeof(*fl
));
689 init_waitqueue_head(&fl
->fl_wait
);
690 if (!filp
->f_dentry
) /* just in case */
693 switch (cmd
& ~LOCK_NB
) {
695 fl
->fl_type
= F_RDLCK
;
698 fl
->fl_type
= F_WRLCK
;
701 fl
->fl_type
= F_UNLCK
;
707 fl
->fl_flags
= FL_FLOCK
;
709 fl
->fl_end
= OFFSET_MAX
;
716 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
717 * checking before calling the locks_conflict().
719 static int posix_locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
721 /* POSIX locks owned by the same process do not conflict with
724 if (!(sys_fl
->fl_flags
& FL_POSIX
) ||
725 locks_same_owner(caller_fl
, sys_fl
))
728 return (locks_conflict(caller_fl
, sys_fl
));
731 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
732 * checking before calling the locks_conflict().
734 static int flock_locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
736 /* FLOCK locks referring to the same filp do not conflict with
739 if (!(sys_fl
->fl_flags
& FL_FLOCK
) ||
740 (caller_fl
->fl_file
== sys_fl
->fl_file
))
743 return (locks_conflict(caller_fl
, sys_fl
));
746 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
747 * checks for overlapping locks and shared/exclusive status.
749 static int locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
751 if (!locks_overlap(caller_fl
, sys_fl
))
754 switch (caller_fl
->fl_type
) {
756 return (sys_fl
->fl_type
== F_WRLCK
);
762 printk("locks_conflict(): impossible lock type - %d\n",
766 return (0); /* This should never happen */
769 /* This function tests for deadlock condition before putting a process to
770 * sleep. The detection scheme is no longer recursive. Recursive was neat,
771 * but dangerous - we risked stack corruption if the lock data was bad, or
772 * if the recursion was too deep for any other reason.
774 * We rely on the fact that a task can only be on one lock's wait queue
775 * at a time. When we find blocked_task on a wait queue we can re-search
776 * with blocked_task equal to that queue's owner, until either blocked_task
777 * isn't found, or blocked_task is found on a queue owned by my_task.
779 * Note: the above assumption may not be true when handling lock requests
780 * from a broken NFS client. But broken NFS clients have a lot more to
781 * worry about than proper deadlock detection anyway... --okir
783 static int posix_locks_deadlock(struct file_lock
*caller_fl
,
784 struct file_lock
*block_fl
)
786 struct file_lock
*fl
;
787 struct file_lock
*bfl
;
788 void *caller_owner
, *blocked_owner
;
789 unsigned int caller_pid
, blocked_pid
;
791 caller_owner
= caller_fl
->fl_owner
;
792 caller_pid
= caller_fl
->fl_pid
;
793 blocked_owner
= block_fl
->fl_owner
;
794 blocked_pid
= block_fl
->fl_pid
;
797 if (caller_owner
== blocked_owner
&& caller_pid
== blocked_pid
)
799 for (fl
= file_lock_table
; fl
!= NULL
; fl
= fl
->fl_nextlink
) {
800 if (fl
->fl_owner
== NULL
|| fl
->fl_nextblock
== NULL
)
802 for (bfl
= fl
->fl_nextblock
; bfl
!= fl
; bfl
= bfl
->fl_nextblock
) {
803 if (bfl
->fl_owner
== blocked_owner
&&
804 bfl
->fl_pid
== blocked_pid
) {
805 if (fl
->fl_owner
== caller_owner
&&
806 fl
->fl_pid
== caller_pid
) {
809 blocked_owner
= fl
->fl_owner
;
810 blocked_pid
= fl
->fl_pid
;
818 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks at
819 * the head of the list, but that's secret knowledge known only to the next
822 static int flock_lock_file(struct file
*filp
, struct file_lock
*caller
,
825 struct file_lock
*fl
;
826 struct file_lock
*new_fl
= NULL
;
827 struct file_lock
**before
;
828 struct inode
* inode
= filp
->f_dentry
->d_inode
;
830 int unlock
= (caller
->fl_type
== F_UNLCK
);
833 * If we need a new lock, get it in advance to avoid races.
837 new_fl
= locks_alloc_lock(caller
);
845 before
= &inode
->i_flock
;
846 while (((fl
= *before
) != NULL
) && (fl
->fl_flags
& FL_FLOCK
)) {
847 if (caller
->fl_file
== fl
->fl_file
) {
848 if (caller
->fl_type
== fl
->fl_type
)
853 before
= &fl
->fl_next
;
855 /* change means that we are changing the type of an existing lock, or
856 * or else unlocking it.
859 /* N.B. What if the wait argument is false? */
860 locks_delete_lock(before
, !unlock
);
862 * If we waited, another lock may have been added ...
871 /* Check signals each time we start */
872 error
= -ERESTARTSYS
;
873 if (signal_pending(current
))
875 for (fl
= inode
->i_flock
; (fl
!= NULL
) && (fl
->fl_flags
& FL_FLOCK
);
877 if (!flock_locks_conflict(new_fl
, fl
))
882 locks_insert_block(fl
, new_fl
);
883 interruptible_sleep_on(&new_fl
->fl_wait
);
884 locks_delete_block(fl
, new_fl
);
887 locks_insert_lock(&inode
->i_flock
, new_fl
);
893 locks_free_lock(new_fl
);
897 /* Add a POSIX style lock to a file.
898 * We merge adjacent locks whenever possible. POSIX locks are sorted by owner
899 * task, then by starting address
902 * To make freeing a lock much faster, we keep a pointer to the lock before the
903 * actual one. But the real gain of the new coding was, that lock_it() and
904 * unlock_it() became one function.
906 * To all purists: Yes, I use a few goto's. Just pass on to the next function.
909 int posix_lock_file(struct file
*filp
, struct file_lock
*caller
,
912 struct file_lock
*fl
;
913 struct file_lock
*new_fl
, *new_fl2
;
914 struct file_lock
*left
= NULL
;
915 struct file_lock
*right
= NULL
;
916 struct file_lock
**before
;
917 struct inode
* inode
= filp
->f_dentry
->d_inode
;
918 int error
, added
= 0;
921 * We may need two file_lock structures for this operation,
922 * so we get them in advance to avoid races.
924 new_fl
= locks_empty_lock();
925 new_fl2
= locks_empty_lock();
926 error
= -ENOLCK
; /* "no luck" */
927 if (!(new_fl
&& new_fl2
))
930 if (caller
->fl_type
!= F_UNLCK
) {
932 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
933 if (!(fl
->fl_flags
& FL_POSIX
))
935 if (!posix_locks_conflict(caller
, fl
))
941 if (posix_locks_deadlock(caller
, fl
))
943 error
= -ERESTARTSYS
;
944 if (signal_pending(current
))
946 locks_insert_block(fl
, caller
);
947 interruptible_sleep_on(&caller
->fl_wait
);
948 locks_delete_block(fl
, caller
);
954 * We've allocated the new locks in advance, so there are no
955 * errors possible (and no blocking operations) from here on.
957 * Find the first old lock with the same owner as the new lock.
960 before
= &inode
->i_flock
;
962 /* First skip locks owned by other processes.
964 while ((fl
= *before
) && (!(fl
->fl_flags
& FL_POSIX
) ||
965 !locks_same_owner(caller
, fl
))) {
966 before
= &fl
->fl_next
;
969 /* Process locks with this owner.
971 while ((fl
= *before
) && locks_same_owner(caller
, fl
)) {
972 /* Detect adjacent or overlapping regions (if same lock type)
974 if (caller
->fl_type
== fl
->fl_type
) {
975 if (fl
->fl_end
< caller
->fl_start
- 1)
977 /* If the next lock in the list has entirely bigger
978 * addresses than the new one, insert the lock here.
980 if (fl
->fl_start
> caller
->fl_end
+ 1)
983 /* If we come here, the new and old lock are of the
984 * same type and adjacent or overlapping. Make one
985 * lock yielding from the lower start address of both
986 * locks to the higher end address.
988 if (fl
->fl_start
> caller
->fl_start
)
989 fl
->fl_start
= caller
->fl_start
;
991 caller
->fl_start
= fl
->fl_start
;
992 if (fl
->fl_end
< caller
->fl_end
)
993 fl
->fl_end
= caller
->fl_end
;
995 caller
->fl_end
= fl
->fl_end
;
997 locks_delete_lock(before
, 0);
1004 /* Processing for different lock types is a bit
1007 if (fl
->fl_end
< caller
->fl_start
)
1009 if (fl
->fl_start
> caller
->fl_end
)
1011 if (caller
->fl_type
== F_UNLCK
)
1013 if (fl
->fl_start
< caller
->fl_start
)
1015 /* If the next lock in the list has a higher end
1016 * address than the new one, insert the new one here.
1018 if (fl
->fl_end
> caller
->fl_end
) {
1022 if (fl
->fl_start
>= caller
->fl_start
) {
1023 /* The new lock completely replaces an old
1024 * one (This may happen several times).
1027 locks_delete_lock(before
, 0);
1030 /* Replace the old lock with the new one.
1031 * Wake up anybody waiting for the old one,
1032 * as the change in lock type might satisfy
1035 locks_wake_up_blocks(fl
, 0);
1036 fl
->fl_start
= caller
->fl_start
;
1037 fl
->fl_end
= caller
->fl_end
;
1038 fl
->fl_type
= caller
->fl_type
;
1039 fl
->fl_u
= caller
->fl_u
;
1044 /* Go on to next lock.
1047 before
= &fl
->fl_next
;
1052 if (caller
->fl_type
== F_UNLCK
)
1054 locks_init_lock(new_fl
, caller
);
1055 locks_insert_lock(before
, new_fl
);
1059 if (left
== right
) {
1060 /* The new lock breaks the old one in two pieces,
1061 * so we have to use the second new lock (in this
1062 * case, even F_UNLCK may fail!).
1064 left
= locks_init_lock(new_fl2
, right
);
1065 locks_insert_lock(before
, left
);
1068 right
->fl_start
= caller
->fl_end
+ 1;
1069 locks_wake_up_blocks(right
, 0);
1072 left
->fl_end
= caller
->fl_start
- 1;
1073 locks_wake_up_blocks(left
, 0);
1077 * Free any unused locks. (They haven't
1078 * ever been used, so we use kfree().)
1088 * Allocate an empty lock structure. We can use GFP_KERNEL now that
1089 * all allocations are done in advance.
1091 static struct file_lock
*locks_empty_lock(void)
1093 /* Okay, let's make a new file_lock structure... */
1094 return ((struct file_lock
*) kmalloc(sizeof(struct file_lock
),
1099 * Initialize a new lock from an existing file_lock structure.
1101 static struct file_lock
*locks_init_lock(struct file_lock
*new,
1102 struct file_lock
*fl
)
1105 memset(new, 0, sizeof(*new));
1106 new->fl_owner
= fl
->fl_owner
;
1107 new->fl_pid
= fl
->fl_pid
;
1108 init_waitqueue_head(&new->fl_wait
);
1109 new->fl_file
= fl
->fl_file
;
1110 new->fl_flags
= fl
->fl_flags
;
1111 new->fl_type
= fl
->fl_type
;
1112 new->fl_start
= fl
->fl_start
;
1113 new->fl_end
= fl
->fl_end
;
1114 new->fl_notify
= fl
->fl_notify
;
1115 new->fl_u
= fl
->fl_u
;
1120 /* Insert file lock fl into an inode's lock list at the position indicated
1121 * by pos. At the same time add the lock to the global file lock list.
1123 static void locks_insert_lock(struct file_lock
**pos
, struct file_lock
*fl
)
1125 fl
->fl_nextlink
= file_lock_table
;
1126 fl
->fl_prevlink
= NULL
;
1127 if (file_lock_table
!= NULL
)
1128 file_lock_table
->fl_prevlink
= fl
;
1129 file_lock_table
= fl
;
1130 fl
->fl_next
= *pos
; /* insert into file's list */
1136 /* Delete a lock and free it.
1137 * First remove our lock from the active lock lists. Then call
1138 * locks_wake_up_blocks() to wake up processes that are blocked
1139 * waiting for this lock. Finally free the lock structure.
1141 static void locks_delete_lock(struct file_lock
**thisfl_p
, unsigned int wait
)
1143 struct file_lock
*thisfl
;
1144 struct file_lock
*prevfl
;
1145 struct file_lock
*nextfl
;
1148 *thisfl_p
= thisfl
->fl_next
;
1150 prevfl
= thisfl
->fl_prevlink
;
1151 nextfl
= thisfl
->fl_nextlink
;
1154 nextfl
->fl_prevlink
= prevfl
;
1157 prevfl
->fl_nextlink
= nextfl
;
1159 file_lock_table
= nextfl
;
1161 locks_wake_up_blocks(thisfl
, wait
);
1162 locks_free_lock(thisfl
);
1168 static char *lock_get_status(struct file_lock
*fl
, int id
, char *pfx
)
1170 static char temp
[155];
1172 struct inode
*inode
;
1174 inode
= fl
->fl_file
->f_dentry
->d_inode
;
1176 p
+= sprintf(p
, "%d:%s ", id
, pfx
);
1177 if (fl
->fl_flags
& FL_POSIX
) {
1178 p
+= sprintf(p
, "%6s %s ",
1179 (fl
->fl_flags
& FL_ACCESS
) ? "ACCESS" : "POSIX ",
1180 (IS_MANDLOCK(inode
) &&
1181 (inode
->i_mode
& (S_IXGRP
| S_ISGID
)) == S_ISGID
) ?
1182 "MANDATORY" : "ADVISORY ");
1185 p
+= sprintf(p
, "FLOCK ADVISORY ");
1187 p
+= sprintf(p
, "%s ", (fl
->fl_type
== F_RDLCK
) ? "READ " : "WRITE");
1188 p
+= sprintf(p
, "%d %s:%ld %ld %ld ",
1190 kdevname(inode
->i_dev
), inode
->i_ino
, fl
->fl_start
,
1192 sprintf(p
, "%08lx %08lx %08lx %08lx %08lx\n",
1193 (long)fl
, (long)fl
->fl_prevlink
, (long)fl
->fl_nextlink
,
1194 (long)fl
->fl_next
, (long)fl
->fl_nextblock
);
1198 static inline int copy_lock_status(char *p
, char **q
, off_t pos
, int len
,
1199 off_t offset
, off_t length
)
1206 i
= len
+ length
- i
;
1223 int get_locks_status(char *buffer
, char **start
, off_t offset
, off_t length
)
1225 struct file_lock
*fl
;
1226 struct file_lock
*bfl
;
1229 off_t i
, len
, pos
= 0;
1231 for (fl
= file_lock_table
, i
= 1; fl
!= NULL
; fl
= fl
->fl_nextlink
, i
++) {
1232 p
= lock_get_status(fl
, i
, "");
1235 if (!copy_lock_status(p
, &q
, pos
, len
, offset
, length
))
1237 if ((bfl
= fl
->fl_nextblock
) == NULL
)
1240 p
= lock_get_status(bfl
, i
, " ->");
1243 if (!copy_lock_status(p
, &q
, pos
, len
, offset
, length
))
1245 } while ((bfl
= bfl
->fl_nextblock
) != fl
);
1250 return (q
- buffer
);