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
*);
515 lock
= filp
->f_op
->lock
;
518 file_lock
.fl_type
= F_UNLCK
;
520 locks_delete_lock(before
, 0);
522 lock(filp
, F_SETLK
, &file_lock
);
523 /* List may have changed: */
528 before
= &fl
->fl_next
;
533 posix_test_lock(struct file
*filp
, struct file_lock
*fl
)
535 struct file_lock
*cfl
;
537 for (cfl
= filp
->f_dentry
->d_inode
->i_flock
; cfl
; cfl
= cfl
->fl_next
) {
538 if (!(cfl
->fl_flags
& FL_POSIX
))
540 if (posix_locks_conflict(cfl
, fl
))
547 int locks_verify_locked(struct inode
*inode
)
549 /* Candidates for mandatory locking have the setgid bit set
550 * but no group execute bit - an otherwise meaningless combination.
552 if (IS_MANDLOCK(inode
) &&
553 (inode
->i_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
)
554 return (locks_mandatory_locked(inode
));
558 int locks_verify_area(int read_write
, struct inode
*inode
, struct file
*filp
,
559 loff_t offset
, size_t count
)
561 /* Candidates for mandatory locking have the setgid bit set
562 * but no group execute bit - an otherwise meaningless combination.
564 if (IS_MANDLOCK(inode
) &&
565 (inode
->i_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
)
566 return (locks_mandatory_area(read_write
, inode
, filp
, offset
,
571 int locks_mandatory_locked(struct inode
*inode
)
573 fl_owner_t owner
= current
->files
;
574 struct file_lock
*fl
;
576 /* Search the lock list for this inode for any POSIX locks.
578 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
579 if (!(fl
->fl_flags
& FL_POSIX
))
581 if (fl
->fl_owner
!= owner
)
587 int locks_mandatory_area(int read_write
, struct inode
*inode
,
588 struct file
*filp
, loff_t offset
,
591 struct file_lock
*fl
;
592 struct file_lock tfl
;
594 memset(&tfl
, 0, sizeof(tfl
));
597 tfl
.fl_flags
= FL_POSIX
| FL_ACCESS
;
598 tfl
.fl_owner
= current
->files
;
599 tfl
.fl_pid
= current
->pid
;
600 tfl
.fl_type
= (read_write
== FLOCK_VERIFY_WRITE
) ? F_WRLCK
: F_RDLCK
;
601 tfl
.fl_start
= offset
;
602 tfl
.fl_end
= offset
+ count
- 1;
605 /* Search the lock list for this inode for locks that conflict with
606 * the proposed read/write.
608 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
609 if (!(fl
->fl_flags
& FL_POSIX
))
611 /* Block for writes against a "read" lock,
612 * and both reads and writes against a "write" lock.
614 if (posix_locks_conflict(fl
, &tfl
)) {
615 if (filp
&& (filp
->f_flags
& O_NONBLOCK
))
617 if (signal_pending(current
))
618 return (-ERESTARTSYS
);
619 if (posix_locks_deadlock(&tfl
, fl
))
622 locks_insert_block(fl
, &tfl
);
623 interruptible_sleep_on(&tfl
.fl_wait
);
624 locks_delete_block(fl
, &tfl
);
626 if (signal_pending(current
))
627 return (-ERESTARTSYS
);
628 /* If we've been sleeping someone might have
629 * changed the permissions behind our back.
631 if ((inode
->i_mode
& (S_ISGID
| S_IXGRP
)) != S_ISGID
)
639 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
642 static int posix_make_lock(struct file
*filp
, struct file_lock
*fl
,
647 memset(fl
, 0, sizeof(*fl
));
649 fl
->fl_flags
= FL_POSIX
;
655 fl
->fl_type
= l
->l_type
;
661 switch (l
->l_whence
) {
669 start
= filp
->f_dentry
->d_inode
->i_size
;
675 if (((start
+= l
->l_start
) < 0) || (l
->l_len
< 0))
677 fl
->fl_start
= start
; /* we record the absolute position */
678 if ((l
->l_len
== 0) || ((fl
->fl_end
= start
+ l
->l_len
- 1) < 0))
679 fl
->fl_end
= OFFSET_MAX
;
682 fl
->fl_owner
= current
->files
;
683 fl
->fl_pid
= current
->pid
;
688 /* Verify a call to flock() and fill in a file_lock structure with
689 * an appropriate FLOCK lock.
691 static int flock_make_lock(struct file
*filp
, struct file_lock
*fl
,
694 memset(fl
, 0, sizeof(*fl
));
696 if (!filp
->f_dentry
) /* just in case */
699 switch (cmd
& ~LOCK_NB
) {
701 fl
->fl_type
= F_RDLCK
;
704 fl
->fl_type
= F_WRLCK
;
707 fl
->fl_type
= F_UNLCK
;
713 fl
->fl_flags
= FL_FLOCK
;
715 fl
->fl_end
= OFFSET_MAX
;
722 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
723 * checking before calling the locks_conflict().
725 static int posix_locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
727 /* POSIX locks owned by the same process do not conflict with
730 if (!(sys_fl
->fl_flags
& FL_POSIX
) ||
731 locks_same_owner(caller_fl
, sys_fl
))
734 return (locks_conflict(caller_fl
, sys_fl
));
737 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
738 * checking before calling the locks_conflict().
740 static int flock_locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
742 /* FLOCK locks referring to the same filp do not conflict with
745 if (!(sys_fl
->fl_flags
& FL_FLOCK
) ||
746 (caller_fl
->fl_file
== sys_fl
->fl_file
))
749 return (locks_conflict(caller_fl
, sys_fl
));
752 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
753 * checks for overlapping locks and shared/exclusive status.
755 static int locks_conflict(struct file_lock
*caller_fl
, struct file_lock
*sys_fl
)
757 if (!locks_overlap(caller_fl
, sys_fl
))
760 switch (caller_fl
->fl_type
) {
762 return (sys_fl
->fl_type
== F_WRLCK
);
768 printk("locks_conflict(): impossible lock type - %d\n",
772 return (0); /* This should never happen */
775 /* This function tests for deadlock condition before putting a process to
776 * sleep. The detection scheme is no longer recursive. Recursive was neat,
777 * but dangerous - we risked stack corruption if the lock data was bad, or
778 * if the recursion was too deep for any other reason.
780 * We rely on the fact that a task can only be on one lock's wait queue
781 * at a time. When we find blocked_task on a wait queue we can re-search
782 * with blocked_task equal to that queue's owner, until either blocked_task
783 * isn't found, or blocked_task is found on a queue owned by my_task.
785 * Note: the above assumption may not be true when handling lock requests
786 * from a broken NFS client. But broken NFS clients have a lot more to
787 * worry about than proper deadlock detection anyway... --okir
789 static int posix_locks_deadlock(struct file_lock
*caller_fl
,
790 struct file_lock
*block_fl
)
792 struct file_lock
*fl
;
793 struct file_lock
*bfl
;
794 void *caller_owner
, *blocked_owner
;
795 unsigned int caller_pid
, blocked_pid
;
797 caller_owner
= caller_fl
->fl_owner
;
798 caller_pid
= caller_fl
->fl_pid
;
799 blocked_owner
= block_fl
->fl_owner
;
800 blocked_pid
= block_fl
->fl_pid
;
803 if (caller_owner
== blocked_owner
&& caller_pid
== blocked_pid
)
805 for (fl
= file_lock_table
; fl
!= NULL
; fl
= fl
->fl_nextlink
) {
806 if (fl
->fl_owner
== NULL
|| fl
->fl_nextblock
== NULL
)
808 for (bfl
= fl
->fl_nextblock
; bfl
!= fl
; bfl
= bfl
->fl_nextblock
) {
809 if (bfl
->fl_owner
== blocked_owner
&&
810 bfl
->fl_pid
== blocked_pid
) {
811 if (fl
->fl_owner
== caller_owner
&&
812 fl
->fl_pid
== caller_pid
) {
815 blocked_owner
= fl
->fl_owner
;
816 blocked_pid
= fl
->fl_pid
;
824 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks at
825 * the head of the list, but that's secret knowledge known only to the next
828 static int flock_lock_file(struct file
*filp
, struct file_lock
*caller
,
831 struct file_lock
*fl
;
832 struct file_lock
*new_fl
= NULL
;
833 struct file_lock
**before
;
834 struct inode
* inode
= filp
->f_dentry
->d_inode
;
836 int unlock
= (caller
->fl_type
== F_UNLCK
);
839 * If we need a new lock, get it in advance to avoid races.
843 new_fl
= locks_alloc_lock(caller
);
851 before
= &inode
->i_flock
;
852 while (((fl
= *before
) != NULL
) && (fl
->fl_flags
& FL_FLOCK
)) {
853 if (caller
->fl_file
== fl
->fl_file
) {
854 if (caller
->fl_type
== fl
->fl_type
)
859 before
= &fl
->fl_next
;
861 /* change means that we are changing the type of an existing lock, or
862 * or else unlocking it.
865 /* N.B. What if the wait argument is false? */
866 locks_delete_lock(before
, !unlock
);
868 * If we waited, another lock may have been added ...
877 /* Check signals each time we start */
878 error
= -ERESTARTSYS
;
879 if (signal_pending(current
))
881 for (fl
= inode
->i_flock
; (fl
!= NULL
) && (fl
->fl_flags
& FL_FLOCK
);
883 if (!flock_locks_conflict(new_fl
, fl
))
888 locks_insert_block(fl
, new_fl
);
889 interruptible_sleep_on(&new_fl
->fl_wait
);
890 locks_delete_block(fl
, new_fl
);
893 locks_insert_lock(&inode
->i_flock
, new_fl
);
899 locks_free_lock(new_fl
);
903 /* Add a POSIX style lock to a file.
904 * We merge adjacent locks whenever possible. POSIX locks are sorted by owner
905 * task, then by starting address
908 * To make freeing a lock much faster, we keep a pointer to the lock before the
909 * actual one. But the real gain of the new coding was, that lock_it() and
910 * unlock_it() became one function.
912 * To all purists: Yes, I use a few goto's. Just pass on to the next function.
915 int posix_lock_file(struct file
*filp
, struct file_lock
*caller
,
918 struct file_lock
*fl
;
919 struct file_lock
*new_fl
, *new_fl2
;
920 struct file_lock
*left
= NULL
;
921 struct file_lock
*right
= NULL
;
922 struct file_lock
**before
;
923 struct inode
* inode
= filp
->f_dentry
->d_inode
;
924 int error
, added
= 0;
927 * We may need two file_lock structures for this operation,
928 * so we get them in advance to avoid races.
930 new_fl
= locks_empty_lock();
931 new_fl2
= locks_empty_lock();
932 error
= -ENOLCK
; /* "no luck" */
933 if (!(new_fl
&& new_fl2
))
936 if (caller
->fl_type
!= F_UNLCK
) {
938 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
939 if (!(fl
->fl_flags
& FL_POSIX
))
941 if (!posix_locks_conflict(caller
, fl
))
947 if (posix_locks_deadlock(caller
, fl
))
949 error
= -ERESTARTSYS
;
950 if (signal_pending(current
))
952 locks_insert_block(fl
, caller
);
953 interruptible_sleep_on(&caller
->fl_wait
);
954 locks_delete_block(fl
, caller
);
960 * We've allocated the new locks in advance, so there are no
961 * errors possible (and no blocking operations) from here on.
963 * Find the first old lock with the same owner as the new lock.
966 before
= &inode
->i_flock
;
968 /* First skip locks owned by other processes.
970 while ((fl
= *before
) && (!(fl
->fl_flags
& FL_POSIX
) ||
971 !locks_same_owner(caller
, fl
))) {
972 before
= &fl
->fl_next
;
975 /* Process locks with this owner.
977 while ((fl
= *before
) && locks_same_owner(caller
, fl
)) {
978 /* Detect adjacent or overlapping regions (if same lock type)
980 if (caller
->fl_type
== fl
->fl_type
) {
981 if (fl
->fl_end
< caller
->fl_start
- 1)
983 /* If the next lock in the list has entirely bigger
984 * addresses than the new one, insert the lock here.
986 if (fl
->fl_start
> caller
->fl_end
+ 1)
989 /* If we come here, the new and old lock are of the
990 * same type and adjacent or overlapping. Make one
991 * lock yielding from the lower start address of both
992 * locks to the higher end address.
994 if (fl
->fl_start
> caller
->fl_start
)
995 fl
->fl_start
= caller
->fl_start
;
997 caller
->fl_start
= fl
->fl_start
;
998 if (fl
->fl_end
< caller
->fl_end
)
999 fl
->fl_end
= caller
->fl_end
;
1001 caller
->fl_end
= fl
->fl_end
;
1003 locks_delete_lock(before
, 0);
1010 /* Processing for different lock types is a bit
1013 if (fl
->fl_end
< caller
->fl_start
)
1015 if (fl
->fl_start
> caller
->fl_end
)
1017 if (caller
->fl_type
== F_UNLCK
)
1019 if (fl
->fl_start
< caller
->fl_start
)
1021 /* If the next lock in the list has a higher end
1022 * address than the new one, insert the new one here.
1024 if (fl
->fl_end
> caller
->fl_end
) {
1028 if (fl
->fl_start
>= caller
->fl_start
) {
1029 /* The new lock completely replaces an old
1030 * one (This may happen several times).
1033 locks_delete_lock(before
, 0);
1036 /* Replace the old lock with the new one.
1037 * Wake up anybody waiting for the old one,
1038 * as the change in lock type might satisfy
1041 locks_wake_up_blocks(fl
, 0);
1042 fl
->fl_start
= caller
->fl_start
;
1043 fl
->fl_end
= caller
->fl_end
;
1044 fl
->fl_type
= caller
->fl_type
;
1045 fl
->fl_u
= caller
->fl_u
;
1050 /* Go on to next lock.
1053 before
= &fl
->fl_next
;
1058 if (caller
->fl_type
== F_UNLCK
)
1060 locks_init_lock(new_fl
, caller
);
1061 locks_insert_lock(before
, new_fl
);
1065 if (left
== right
) {
1066 /* The new lock breaks the old one in two pieces,
1067 * so we have to use the second new lock (in this
1068 * case, even F_UNLCK may fail!).
1070 left
= locks_init_lock(new_fl2
, right
);
1071 locks_insert_lock(before
, left
);
1074 right
->fl_start
= caller
->fl_end
+ 1;
1075 locks_wake_up_blocks(right
, 0);
1078 left
->fl_end
= caller
->fl_start
- 1;
1079 locks_wake_up_blocks(left
, 0);
1083 * Free any unused locks. (They haven't
1084 * ever been used, so we use kfree().)
1094 * Allocate an empty lock structure. We can use GFP_KERNEL now that
1095 * all allocations are done in advance.
1097 static struct file_lock
*locks_empty_lock(void)
1099 /* Okay, let's make a new file_lock structure... */
1100 return ((struct file_lock
*) kmalloc(sizeof(struct file_lock
),
1105 * Initialize a new lock from an existing file_lock structure.
1107 static struct file_lock
*locks_init_lock(struct file_lock
*new,
1108 struct file_lock
*fl
)
1111 memset(new, 0, sizeof(*new));
1112 new->fl_owner
= fl
->fl_owner
;
1113 new->fl_pid
= fl
->fl_pid
;
1114 new->fl_file
= fl
->fl_file
;
1115 new->fl_flags
= fl
->fl_flags
;
1116 new->fl_type
= fl
->fl_type
;
1117 new->fl_start
= fl
->fl_start
;
1118 new->fl_end
= fl
->fl_end
;
1119 new->fl_notify
= fl
->fl_notify
;
1120 new->fl_u
= fl
->fl_u
;
1125 /* Insert file lock fl into an inode's lock list at the position indicated
1126 * by pos. At the same time add the lock to the global file lock list.
1128 static void locks_insert_lock(struct file_lock
**pos
, struct file_lock
*fl
)
1130 fl
->fl_nextlink
= file_lock_table
;
1131 fl
->fl_prevlink
= NULL
;
1132 if (file_lock_table
!= NULL
)
1133 file_lock_table
->fl_prevlink
= fl
;
1134 file_lock_table
= fl
;
1135 fl
->fl_next
= *pos
; /* insert into file's list */
1141 /* Delete a lock and free it.
1142 * First remove our lock from the active lock lists. Then call
1143 * locks_wake_up_blocks() to wake up processes that are blocked
1144 * waiting for this lock. Finally free the lock structure.
1146 static void locks_delete_lock(struct file_lock
**thisfl_p
, unsigned int wait
)
1148 struct file_lock
*thisfl
;
1149 struct file_lock
*prevfl
;
1150 struct file_lock
*nextfl
;
1153 *thisfl_p
= thisfl
->fl_next
;
1155 prevfl
= thisfl
->fl_prevlink
;
1156 nextfl
= thisfl
->fl_nextlink
;
1159 nextfl
->fl_prevlink
= prevfl
;
1162 prevfl
->fl_nextlink
= nextfl
;
1164 file_lock_table
= nextfl
;
1166 locks_wake_up_blocks(thisfl
, wait
);
1167 locks_free_lock(thisfl
);
1173 static char *lock_get_status(struct file_lock
*fl
, int id
, char *pfx
)
1175 static char temp
[155];
1177 struct inode
*inode
;
1179 inode
= fl
->fl_file
->f_dentry
->d_inode
;
1181 p
+= sprintf(p
, "%d:%s ", id
, pfx
);
1182 if (fl
->fl_flags
& FL_POSIX
) {
1183 p
+= sprintf(p
, "%6s %s ",
1184 (fl
->fl_flags
& FL_ACCESS
) ? "ACCESS" : "POSIX ",
1185 (IS_MANDLOCK(inode
) &&
1186 (inode
->i_mode
& (S_IXGRP
| S_ISGID
)) == S_ISGID
) ?
1187 "MANDATORY" : "ADVISORY ");
1190 p
+= sprintf(p
, "FLOCK ADVISORY ");
1192 p
+= sprintf(p
, "%s ", (fl
->fl_type
== F_RDLCK
) ? "READ " : "WRITE");
1193 p
+= sprintf(p
, "%d %s:%ld %ld %ld ",
1195 kdevname(inode
->i_dev
), inode
->i_ino
, fl
->fl_start
,
1197 sprintf(p
, "%08lx %08lx %08lx %08lx %08lx\n",
1198 (long)fl
, (long)fl
->fl_prevlink
, (long)fl
->fl_nextlink
,
1199 (long)fl
->fl_next
, (long)fl
->fl_nextblock
);
1203 static inline int copy_lock_status(char *p
, char **q
, off_t pos
, int len
,
1204 off_t offset
, off_t length
)
1211 i
= len
+ length
- i
;
1228 int get_locks_status(char *buffer
, char **start
, off_t offset
, off_t length
)
1230 struct file_lock
*fl
;
1231 struct file_lock
*bfl
;
1234 off_t i
, len
, pos
= 0;
1236 for (fl
= file_lock_table
, i
= 1; fl
!= NULL
; fl
= fl
->fl_nextlink
, i
++) {
1237 p
= lock_get_status(fl
, i
, "");
1240 if (!copy_lock_status(p
, &q
, pos
, len
, offset
, length
))
1242 if ((bfl
= fl
->fl_nextblock
) == NULL
)
1245 p
= lock_get_status(bfl
, i
, " ->");
1248 if (!copy_lock_status(p
, &q
, pos
, len
, offset
, length
))
1250 } while ((bfl
= bfl
->fl_nextblock
) != fl
);
1255 return (q
- buffer
);