1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117#include <linux/capability.h>
118#include <linux/file.h>
119#include <linux/fdtable.h>
120#include <linux/fs.h>
121#include <linux/init.h>
122#include <linux/module.h>
123#include <linux/security.h>
124#include <linux/slab.h>
125#include <linux/syscalls.h>
126#include <linux/time.h>
127#include <linux/rcupdate.h>
128#include <linux/pid_namespace.h>
129#include <linux/hashtable.h>
130#include <linux/percpu.h>
131#include <linux/lglock.h>
132
133#include <asm/uaccess.h>
134
135#define IS_POSIX(fl) (fl->fl_flags & FL_POSIX)
136#define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK)
137#define IS_LEASE(fl) (fl->fl_flags & (FL_LEASE|FL_DELEG))
138#define IS_OFDLCK(fl) (fl->fl_flags & FL_OFDLCK)
139
140static bool lease_breaking(struct file_lock *fl)
141{
142 return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING);
143}
144
145static int target_leasetype(struct file_lock *fl)
146{
147 if (fl->fl_flags & FL_UNLOCK_PENDING)
148 return F_UNLCK;
149 if (fl->fl_flags & FL_DOWNGRADE_PENDING)
150 return F_RDLCK;
151 return fl->fl_type;
152}
153
154int leases_enable = 1;
155int lease_break_time = 45;
156
157#define for_each_lock(inode, lockp) \
158 for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
159
160
161
162
163
164
165
166DEFINE_STATIC_LGLOCK(file_lock_lglock);
167static DEFINE_PER_CPU(struct hlist_head, file_lock_list);
168
169
170
171
172
173
174
175
176
177
178
179
180#define BLOCKED_HASH_BITS 7
181static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS);
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200static DEFINE_SPINLOCK(blocked_lock_lock);
201
202static struct kmem_cache *filelock_cache __read_mostly;
203
204static void locks_init_lock_heads(struct file_lock *fl)
205{
206 INIT_HLIST_NODE(&fl->fl_link);
207 INIT_LIST_HEAD(&fl->fl_block);
208 init_waitqueue_head(&fl->fl_wait);
209}
210
211
212struct file_lock *locks_alloc_lock(void)
213{
214 struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL);
215
216 if (fl)
217 locks_init_lock_heads(fl);
218
219 return fl;
220}
221EXPORT_SYMBOL_GPL(locks_alloc_lock);
222
223void locks_release_private(struct file_lock *fl)
224{
225 if (fl->fl_ops) {
226 if (fl->fl_ops->fl_release_private)
227 fl->fl_ops->fl_release_private(fl);
228 fl->fl_ops = NULL;
229 }
230 fl->fl_lmops = NULL;
231
232}
233EXPORT_SYMBOL_GPL(locks_release_private);
234
235
236void locks_free_lock(struct file_lock *fl)
237{
238 BUG_ON(waitqueue_active(&fl->fl_wait));
239 BUG_ON(!list_empty(&fl->fl_block));
240 BUG_ON(!hlist_unhashed(&fl->fl_link));
241
242 locks_release_private(fl);
243 kmem_cache_free(filelock_cache, fl);
244}
245EXPORT_SYMBOL(locks_free_lock);
246
247void locks_init_lock(struct file_lock *fl)
248{
249 memset(fl, 0, sizeof(struct file_lock));
250 locks_init_lock_heads(fl);
251}
252
253EXPORT_SYMBOL(locks_init_lock);
254
255static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
256{
257 if (fl->fl_ops) {
258 if (fl->fl_ops->fl_copy_lock)
259 fl->fl_ops->fl_copy_lock(new, fl);
260 new->fl_ops = fl->fl_ops;
261 }
262 if (fl->fl_lmops)
263 new->fl_lmops = fl->fl_lmops;
264}
265
266
267
268
269void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl)
270{
271 new->fl_owner = fl->fl_owner;
272 new->fl_pid = fl->fl_pid;
273 new->fl_file = NULL;
274 new->fl_flags = fl->fl_flags;
275 new->fl_type = fl->fl_type;
276 new->fl_start = fl->fl_start;
277 new->fl_end = fl->fl_end;
278 new->fl_ops = NULL;
279 new->fl_lmops = NULL;
280}
281EXPORT_SYMBOL(__locks_copy_lock);
282
283void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
284{
285 locks_release_private(new);
286
287 __locks_copy_lock(new, fl);
288 new->fl_file = fl->fl_file;
289 new->fl_ops = fl->fl_ops;
290 new->fl_lmops = fl->fl_lmops;
291
292 locks_copy_private(new, fl);
293}
294
295EXPORT_SYMBOL(locks_copy_lock);
296
297static inline int flock_translate_cmd(int cmd) {
298 if (cmd & LOCK_MAND)
299 return cmd & (LOCK_MAND | LOCK_RW);
300 switch (cmd) {
301 case LOCK_SH:
302 return F_RDLCK;
303 case LOCK_EX:
304 return F_WRLCK;
305 case LOCK_UN:
306 return F_UNLCK;
307 }
308 return -EINVAL;
309}
310
311
312static int flock_make_lock(struct file *filp, struct file_lock **lock,
313 unsigned int cmd)
314{
315 struct file_lock *fl;
316 int type = flock_translate_cmd(cmd);
317 if (type < 0)
318 return type;
319
320 fl = locks_alloc_lock();
321 if (fl == NULL)
322 return -ENOMEM;
323
324 fl->fl_file = filp;
325 fl->fl_pid = current->tgid;
326 fl->fl_flags = FL_FLOCK;
327 fl->fl_type = type;
328 fl->fl_end = OFFSET_MAX;
329
330 *lock = fl;
331 return 0;
332}
333
334static int assign_type(struct file_lock *fl, long type)
335{
336 switch (type) {
337 case F_RDLCK:
338 case F_WRLCK:
339 case F_UNLCK:
340 fl->fl_type = type;
341 break;
342 default:
343 return -EINVAL;
344 }
345 return 0;
346}
347
348static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
349 struct flock64 *l)
350{
351 switch (l->l_whence) {
352 case SEEK_SET:
353 fl->fl_start = 0;
354 break;
355 case SEEK_CUR:
356 fl->fl_start = filp->f_pos;
357 break;
358 case SEEK_END:
359 fl->fl_start = i_size_read(file_inode(filp));
360 break;
361 default:
362 return -EINVAL;
363 }
364 if (l->l_start > OFFSET_MAX - fl->fl_start)
365 return -EOVERFLOW;
366 fl->fl_start += l->l_start;
367 if (fl->fl_start < 0)
368 return -EINVAL;
369
370
371
372 if (l->l_len > 0) {
373 if (l->l_len - 1 > OFFSET_MAX - fl->fl_start)
374 return -EOVERFLOW;
375 fl->fl_end = fl->fl_start + l->l_len - 1;
376
377 } else if (l->l_len < 0) {
378 if (fl->fl_start + l->l_len < 0)
379 return -EINVAL;
380 fl->fl_end = fl->fl_start - 1;
381 fl->fl_start += l->l_len;
382 } else
383 fl->fl_end = OFFSET_MAX;
384
385 fl->fl_owner = current->files;
386 fl->fl_pid = current->tgid;
387 fl->fl_file = filp;
388 fl->fl_flags = FL_POSIX;
389 fl->fl_ops = NULL;
390 fl->fl_lmops = NULL;
391
392 return assign_type(fl, l->l_type);
393}
394
395
396
397
398static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
399 struct flock *l)
400{
401 struct flock64 ll = {
402 .l_type = l->l_type,
403 .l_whence = l->l_whence,
404 .l_start = l->l_start,
405 .l_len = l->l_len,
406 };
407
408 return flock64_to_posix_lock(filp, fl, &ll);
409}
410
411
412static void lease_break_callback(struct file_lock *fl)
413{
414 kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
415}
416
417static const struct lock_manager_operations lease_manager_ops = {
418 .lm_break = lease_break_callback,
419 .lm_change = lease_modify,
420};
421
422
423
424
425static int lease_init(struct file *filp, long type, struct file_lock *fl)
426 {
427 if (assign_type(fl, type) != 0)
428 return -EINVAL;
429
430 fl->fl_owner = current->files;
431 fl->fl_pid = current->tgid;
432
433 fl->fl_file = filp;
434 fl->fl_flags = FL_LEASE;
435 fl->fl_start = 0;
436 fl->fl_end = OFFSET_MAX;
437 fl->fl_ops = NULL;
438 fl->fl_lmops = &lease_manager_ops;
439 return 0;
440}
441
442
443static struct file_lock *lease_alloc(struct file *filp, long type)
444{
445 struct file_lock *fl = locks_alloc_lock();
446 int error = -ENOMEM;
447
448 if (fl == NULL)
449 return ERR_PTR(error);
450
451 error = lease_init(filp, type, fl);
452 if (error) {
453 locks_free_lock(fl);
454 return ERR_PTR(error);
455 }
456 return fl;
457}
458
459
460
461static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
462{
463 return ((fl1->fl_end >= fl2->fl_start) &&
464 (fl2->fl_end >= fl1->fl_start));
465}
466
467
468
469
470static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
471{
472 if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner)
473 return fl2->fl_lmops == fl1->fl_lmops &&
474 fl1->fl_lmops->lm_compare_owner(fl1, fl2);
475 return fl1->fl_owner == fl2->fl_owner;
476}
477
478
479static void locks_insert_global_locks(struct file_lock *fl)
480{
481 lg_local_lock(&file_lock_lglock);
482 fl->fl_link_cpu = smp_processor_id();
483 hlist_add_head(&fl->fl_link, this_cpu_ptr(&file_lock_list));
484 lg_local_unlock(&file_lock_lglock);
485}
486
487
488static void locks_delete_global_locks(struct file_lock *fl)
489{
490
491
492
493
494
495 if (hlist_unhashed(&fl->fl_link))
496 return;
497 lg_local_lock_cpu(&file_lock_lglock, fl->fl_link_cpu);
498 hlist_del_init(&fl->fl_link);
499 lg_local_unlock_cpu(&file_lock_lglock, fl->fl_link_cpu);
500}
501
502static unsigned long
503posix_owner_key(struct file_lock *fl)
504{
505 if (fl->fl_lmops && fl->fl_lmops->lm_owner_key)
506 return fl->fl_lmops->lm_owner_key(fl);
507 return (unsigned long)fl->fl_owner;
508}
509
510static void locks_insert_global_blocked(struct file_lock *waiter)
511{
512 hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter));
513}
514
515static void locks_delete_global_blocked(struct file_lock *waiter)
516{
517 hash_del(&waiter->fl_link);
518}
519
520
521
522
523
524
525static void __locks_delete_block(struct file_lock *waiter)
526{
527 locks_delete_global_blocked(waiter);
528 list_del_init(&waiter->fl_block);
529 waiter->fl_next = NULL;
530}
531
532static void locks_delete_block(struct file_lock *waiter)
533{
534 spin_lock(&blocked_lock_lock);
535 __locks_delete_block(waiter);
536 spin_unlock(&blocked_lock_lock);
537}
538
539
540
541
542
543
544
545
546
547
548
549static void __locks_insert_block(struct file_lock *blocker,
550 struct file_lock *waiter)
551{
552 BUG_ON(!list_empty(&waiter->fl_block));
553 waiter->fl_next = blocker;
554 list_add_tail(&waiter->fl_block, &blocker->fl_block);
555 if (IS_POSIX(blocker) && !IS_OFDLCK(blocker))
556 locks_insert_global_blocked(waiter);
557}
558
559
560static void locks_insert_block(struct file_lock *blocker,
561 struct file_lock *waiter)
562{
563 spin_lock(&blocked_lock_lock);
564 __locks_insert_block(blocker, waiter);
565 spin_unlock(&blocked_lock_lock);
566}
567
568
569
570
571
572
573static void locks_wake_up_blocks(struct file_lock *blocker)
574{
575
576
577
578
579
580
581
582 if (list_empty(&blocker->fl_block))
583 return;
584
585 spin_lock(&blocked_lock_lock);
586 while (!list_empty(&blocker->fl_block)) {
587 struct file_lock *waiter;
588
589 waiter = list_first_entry(&blocker->fl_block,
590 struct file_lock, fl_block);
591 __locks_delete_block(waiter);
592 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify)
593 waiter->fl_lmops->lm_notify(waiter);
594 else
595 wake_up(&waiter->fl_wait);
596 }
597 spin_unlock(&blocked_lock_lock);
598}
599
600
601
602
603
604
605static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
606{
607 fl->fl_nspid = get_pid(task_tgid(current));
608
609
610 fl->fl_next = *pos;
611 *pos = fl;
612
613 locks_insert_global_locks(fl);
614}
615
616
617
618
619
620
621
622
623
624
625
626
627static void locks_unlink_lock(struct file_lock **thisfl_p)
628{
629 struct file_lock *fl = *thisfl_p;
630
631 locks_delete_global_locks(fl);
632
633 *thisfl_p = fl->fl_next;
634 fl->fl_next = NULL;
635
636 if (fl->fl_nspid) {
637 put_pid(fl->fl_nspid);
638 fl->fl_nspid = NULL;
639 }
640
641 locks_wake_up_blocks(fl);
642}
643
644
645
646
647
648
649static void locks_delete_lock(struct file_lock **thisfl_p)
650{
651 struct file_lock *fl = *thisfl_p;
652
653 locks_unlink_lock(thisfl_p);
654 locks_free_lock(fl);
655}
656
657
658
659
660static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
661{
662 if (sys_fl->fl_type == F_WRLCK)
663 return 1;
664 if (caller_fl->fl_type == F_WRLCK)
665 return 1;
666 return 0;
667}
668
669
670
671
672static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
673{
674
675
676
677 if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
678 return (0);
679
680
681 if (!locks_overlap(caller_fl, sys_fl))
682 return 0;
683
684 return (locks_conflict(caller_fl, sys_fl));
685}
686
687
688
689
690static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
691{
692
693
694
695 if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
696 return (0);
697 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
698 return 0;
699
700 return (locks_conflict(caller_fl, sys_fl));
701}
702
703void
704posix_test_lock(struct file *filp, struct file_lock *fl)
705{
706 struct file_lock *cfl;
707 struct inode *inode = file_inode(filp);
708
709 spin_lock(&inode->i_lock);
710 for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) {
711 if (!IS_POSIX(cfl))
712 continue;
713 if (posix_locks_conflict(fl, cfl))
714 break;
715 }
716 if (cfl) {
717 __locks_copy_lock(fl, cfl);
718 if (cfl->fl_nspid)
719 fl->fl_pid = pid_vnr(cfl->fl_nspid);
720 } else
721 fl->fl_type = F_UNLCK;
722 spin_unlock(&inode->i_lock);
723 return;
724}
725EXPORT_SYMBOL(posix_test_lock);
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760#define MAX_DEADLK_ITERATIONS 10
761
762
763static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl)
764{
765 struct file_lock *fl;
766
767 hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) {
768 if (posix_same_owner(fl, block_fl))
769 return fl->fl_next;
770 }
771 return NULL;
772}
773
774
775static int posix_locks_deadlock(struct file_lock *caller_fl,
776 struct file_lock *block_fl)
777{
778 int i = 0;
779
780
781
782
783
784 if (IS_OFDLCK(caller_fl))
785 return 0;
786
787 while ((block_fl = what_owner_is_waiting_for(block_fl))) {
788 if (i++ > MAX_DEADLK_ITERATIONS)
789 return 0;
790 if (posix_same_owner(caller_fl, block_fl))
791 return 1;
792 }
793 return 0;
794}
795
796
797
798
799
800
801
802
803static int flock_lock_file(struct file *filp, struct file_lock *request)
804{
805 struct file_lock *new_fl = NULL;
806 struct file_lock **before;
807 struct inode * inode = file_inode(filp);
808 int error = 0;
809 int found = 0;
810
811 if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) {
812 new_fl = locks_alloc_lock();
813 if (!new_fl)
814 return -ENOMEM;
815 }
816
817 spin_lock(&inode->i_lock);
818 if (request->fl_flags & FL_ACCESS)
819 goto find_conflict;
820
821 for_each_lock(inode, before) {
822 struct file_lock *fl = *before;
823 if (IS_POSIX(fl))
824 break;
825 if (IS_LEASE(fl))
826 continue;
827 if (filp != fl->fl_file)
828 continue;
829 if (request->fl_type == fl->fl_type)
830 goto out;
831 found = 1;
832 locks_delete_lock(before);
833 break;
834 }
835
836 if (request->fl_type == F_UNLCK) {
837 if ((request->fl_flags & FL_EXISTS) && !found)
838 error = -ENOENT;
839 goto out;
840 }
841
842
843
844
845
846 if (found) {
847 spin_unlock(&inode->i_lock);
848 cond_resched();
849 spin_lock(&inode->i_lock);
850 }
851
852find_conflict:
853 for_each_lock(inode, before) {
854 struct file_lock *fl = *before;
855 if (IS_POSIX(fl))
856 break;
857 if (IS_LEASE(fl))
858 continue;
859 if (!flock_locks_conflict(request, fl))
860 continue;
861 error = -EAGAIN;
862 if (!(request->fl_flags & FL_SLEEP))
863 goto out;
864 error = FILE_LOCK_DEFERRED;
865 locks_insert_block(fl, request);
866 goto out;
867 }
868 if (request->fl_flags & FL_ACCESS)
869 goto out;
870 locks_copy_lock(new_fl, request);
871 locks_insert_lock(before, new_fl);
872 new_fl = NULL;
873 error = 0;
874
875out:
876 spin_unlock(&inode->i_lock);
877 if (new_fl)
878 locks_free_lock(new_fl);
879 return error;
880}
881
882static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
883{
884 struct file_lock *fl;
885 struct file_lock *new_fl = NULL;
886 struct file_lock *new_fl2 = NULL;
887 struct file_lock *left = NULL;
888 struct file_lock *right = NULL;
889 struct file_lock **before;
890 int error;
891 bool added = false;
892
893
894
895
896
897
898
899 if (!(request->fl_flags & FL_ACCESS) &&
900 (request->fl_type != F_UNLCK ||
901 request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
902 new_fl = locks_alloc_lock();
903 new_fl2 = locks_alloc_lock();
904 }
905
906 spin_lock(&inode->i_lock);
907
908
909
910
911
912 if (request->fl_type != F_UNLCK) {
913 for_each_lock(inode, before) {
914 fl = *before;
915 if (!IS_POSIX(fl))
916 continue;
917 if (!posix_locks_conflict(request, fl))
918 continue;
919 if (conflock)
920 __locks_copy_lock(conflock, fl);
921 error = -EAGAIN;
922 if (!(request->fl_flags & FL_SLEEP))
923 goto out;
924
925
926
927
928 error = -EDEADLK;
929 spin_lock(&blocked_lock_lock);
930 if (likely(!posix_locks_deadlock(request, fl))) {
931 error = FILE_LOCK_DEFERRED;
932 __locks_insert_block(fl, request);
933 }
934 spin_unlock(&blocked_lock_lock);
935 goto out;
936 }
937 }
938
939
940 error = 0;
941 if (request->fl_flags & FL_ACCESS)
942 goto out;
943
944
945
946
947
948 before = &inode->i_flock;
949
950
951 while ((fl = *before) && (!IS_POSIX(fl) ||
952 !posix_same_owner(request, fl))) {
953 before = &fl->fl_next;
954 }
955
956
957 while ((fl = *before) && posix_same_owner(request, fl)) {
958
959
960 if (request->fl_type == fl->fl_type) {
961
962
963
964
965 if (fl->fl_end < request->fl_start - 1)
966 goto next_lock;
967
968
969
970 if (fl->fl_start - 1 > request->fl_end)
971 break;
972
973
974
975
976
977
978 if (fl->fl_start > request->fl_start)
979 fl->fl_start = request->fl_start;
980 else
981 request->fl_start = fl->fl_start;
982 if (fl->fl_end < request->fl_end)
983 fl->fl_end = request->fl_end;
984 else
985 request->fl_end = fl->fl_end;
986 if (added) {
987 locks_delete_lock(before);
988 continue;
989 }
990 request = fl;
991 added = true;
992 }
993 else {
994
995
996
997 if (fl->fl_end < request->fl_start)
998 goto next_lock;
999 if (fl->fl_start > request->fl_end)
1000 break;
1001 if (request->fl_type == F_UNLCK)
1002 added = true;
1003 if (fl->fl_start < request->fl_start)
1004 left = fl;
1005
1006
1007
1008 if (fl->fl_end > request->fl_end) {
1009 right = fl;
1010 break;
1011 }
1012 if (fl->fl_start >= request->fl_start) {
1013
1014
1015
1016 if (added) {
1017 locks_delete_lock(before);
1018 continue;
1019 }
1020
1021
1022
1023
1024
1025 locks_wake_up_blocks(fl);
1026 fl->fl_start = request->fl_start;
1027 fl->fl_end = request->fl_end;
1028 fl->fl_type = request->fl_type;
1029 locks_release_private(fl);
1030 locks_copy_private(fl, request);
1031 request = fl;
1032 added = true;
1033 }
1034 }
1035
1036
1037 next_lock:
1038 before = &fl->fl_next;
1039 }
1040
1041
1042
1043
1044
1045
1046 error = -ENOLCK;
1047 if (right && left == right && !new_fl2)
1048 goto out;
1049
1050 error = 0;
1051 if (!added) {
1052 if (request->fl_type == F_UNLCK) {
1053 if (request->fl_flags & FL_EXISTS)
1054 error = -ENOENT;
1055 goto out;
1056 }
1057
1058 if (!new_fl) {
1059 error = -ENOLCK;
1060 goto out;
1061 }
1062 locks_copy_lock(new_fl, request);
1063 locks_insert_lock(before, new_fl);
1064 new_fl = NULL;
1065 }
1066 if (right) {
1067 if (left == right) {
1068
1069
1070
1071 left = new_fl2;
1072 new_fl2 = NULL;
1073 locks_copy_lock(left, right);
1074 locks_insert_lock(before, left);
1075 }
1076 right->fl_start = request->fl_end + 1;
1077 locks_wake_up_blocks(right);
1078 }
1079 if (left) {
1080 left->fl_end = request->fl_start - 1;
1081 locks_wake_up_blocks(left);
1082 }
1083 out:
1084 spin_unlock(&inode->i_lock);
1085
1086
1087
1088 if (new_fl)
1089 locks_free_lock(new_fl);
1090 if (new_fl2)
1091 locks_free_lock(new_fl2);
1092 return error;
1093}
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109int posix_lock_file(struct file *filp, struct file_lock *fl,
1110 struct file_lock *conflock)
1111{
1112 return __posix_lock_file(file_inode(filp), fl, conflock);
1113}
1114EXPORT_SYMBOL(posix_lock_file);
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1126{
1127 int error;
1128 might_sleep ();
1129 for (;;) {
1130 error = posix_lock_file(filp, fl, NULL);
1131 if (error != FILE_LOCK_DEFERRED)
1132 break;
1133 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1134 if (!error)
1135 continue;
1136
1137 locks_delete_block(fl);
1138 break;
1139 }
1140 return error;
1141}
1142EXPORT_SYMBOL(posix_lock_file_wait);
1143
1144
1145
1146
1147
1148
1149
1150
1151int locks_mandatory_locked(struct file *file)
1152{
1153 struct inode *inode = file_inode(file);
1154 fl_owner_t owner = current->files;
1155 struct file_lock *fl;
1156
1157
1158
1159
1160 spin_lock(&inode->i_lock);
1161 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1162 if (!IS_POSIX(fl))
1163 continue;
1164 if (fl->fl_owner != owner && fl->fl_owner != (fl_owner_t)file)
1165 break;
1166 }
1167 spin_unlock(&inode->i_lock);
1168 return fl ? -EAGAIN : 0;
1169}
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184int locks_mandatory_area(int read_write, struct inode *inode,
1185 struct file *filp, loff_t offset,
1186 size_t count)
1187{
1188 struct file_lock fl;
1189 int error;
1190 bool sleep = false;
1191
1192 locks_init_lock(&fl);
1193 fl.fl_pid = current->tgid;
1194 fl.fl_file = filp;
1195 fl.fl_flags = FL_POSIX | FL_ACCESS;
1196 if (filp && !(filp->f_flags & O_NONBLOCK))
1197 sleep = true;
1198 fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
1199 fl.fl_start = offset;
1200 fl.fl_end = offset + count - 1;
1201
1202 for (;;) {
1203 if (filp) {
1204 fl.fl_owner = (fl_owner_t)filp;
1205 fl.fl_flags &= ~FL_SLEEP;
1206 error = __posix_lock_file(inode, &fl, NULL);
1207 if (!error)
1208 break;
1209 }
1210
1211 if (sleep)
1212 fl.fl_flags |= FL_SLEEP;
1213 fl.fl_owner = current->files;
1214 error = __posix_lock_file(inode, &fl, NULL);
1215 if (error != FILE_LOCK_DEFERRED)
1216 break;
1217 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
1218 if (!error) {
1219
1220
1221
1222
1223 if (__mandatory_lock(inode))
1224 continue;
1225 }
1226
1227 locks_delete_block(&fl);
1228 break;
1229 }
1230
1231 return error;
1232}
1233
1234EXPORT_SYMBOL(locks_mandatory_area);
1235
1236static void lease_clear_pending(struct file_lock *fl, int arg)
1237{
1238 switch (arg) {
1239 case F_UNLCK:
1240 fl->fl_flags &= ~FL_UNLOCK_PENDING;
1241
1242 case F_RDLCK:
1243 fl->fl_flags &= ~FL_DOWNGRADE_PENDING;
1244 }
1245}
1246
1247
1248int lease_modify(struct file_lock **before, int arg)
1249{
1250 struct file_lock *fl = *before;
1251 int error = assign_type(fl, arg);
1252
1253 if (error)
1254 return error;
1255 lease_clear_pending(fl, arg);
1256 locks_wake_up_blocks(fl);
1257 if (arg == F_UNLCK) {
1258 struct file *filp = fl->fl_file;
1259
1260 f_delown(filp);
1261 filp->f_owner.signum = 0;
1262 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
1263 if (fl->fl_fasync != NULL) {
1264 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
1265 fl->fl_fasync = NULL;
1266 }
1267 locks_delete_lock(before);
1268 }
1269 return 0;
1270}
1271
1272EXPORT_SYMBOL(lease_modify);
1273
1274static bool past_time(unsigned long then)
1275{
1276 if (!then)
1277
1278 return false;
1279 return time_after(jiffies, then);
1280}
1281
1282static void time_out_leases(struct inode *inode)
1283{
1284 struct file_lock **before;
1285 struct file_lock *fl;
1286
1287 before = &inode->i_flock;
1288 while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) {
1289 if (past_time(fl->fl_downgrade_time))
1290 lease_modify(before, F_RDLCK);
1291 if (past_time(fl->fl_break_time))
1292 lease_modify(before, F_UNLCK);
1293 if (fl == *before)
1294 before = &fl->fl_next;
1295 }
1296}
1297
1298static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker)
1299{
1300 if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE))
1301 return false;
1302 return locks_conflict(breaker, lease);
1303}
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1319{
1320 int error = 0;
1321 struct file_lock *new_fl, *flock;
1322 struct file_lock *fl;
1323 unsigned long break_time;
1324 int i_have_this_lease = 0;
1325 bool lease_conflict = false;
1326 int want_write = (mode & O_ACCMODE) != O_RDONLY;
1327
1328 new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
1329 if (IS_ERR(new_fl))
1330 return PTR_ERR(new_fl);
1331 new_fl->fl_flags = type;
1332
1333 spin_lock(&inode->i_lock);
1334
1335 time_out_leases(inode);
1336
1337 flock = inode->i_flock;
1338 if ((flock == NULL) || !IS_LEASE(flock))
1339 goto out;
1340
1341 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
1342 if (leases_conflict(fl, new_fl)) {
1343 lease_conflict = true;
1344 if (fl->fl_owner == current->files)
1345 i_have_this_lease = 1;
1346 }
1347 }
1348 if (!lease_conflict)
1349 goto out;
1350
1351 break_time = 0;
1352 if (lease_break_time > 0) {
1353 break_time = jiffies + lease_break_time * HZ;
1354 if (break_time == 0)
1355 break_time++;
1356 }
1357
1358 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
1359 if (!leases_conflict(fl, new_fl))
1360 continue;
1361 if (want_write) {
1362 if (fl->fl_flags & FL_UNLOCK_PENDING)
1363 continue;
1364 fl->fl_flags |= FL_UNLOCK_PENDING;
1365 fl->fl_break_time = break_time;
1366 } else {
1367 if (lease_breaking(flock))
1368 continue;
1369 fl->fl_flags |= FL_DOWNGRADE_PENDING;
1370 fl->fl_downgrade_time = break_time;
1371 }
1372 fl->fl_lmops->lm_break(fl);
1373 }
1374
1375 if (i_have_this_lease || (mode & O_NONBLOCK)) {
1376 error = -EWOULDBLOCK;
1377 goto out;
1378 }
1379
1380restart:
1381 break_time = flock->fl_break_time;
1382 if (break_time != 0)
1383 break_time -= jiffies;
1384 if (break_time == 0)
1385 break_time++;
1386 locks_insert_block(flock, new_fl);
1387 spin_unlock(&inode->i_lock);
1388 error = wait_event_interruptible_timeout(new_fl->fl_wait,
1389 !new_fl->fl_next, break_time);
1390 spin_lock(&inode->i_lock);
1391 locks_delete_block(new_fl);
1392 if (error >= 0) {
1393 if (error == 0)
1394 time_out_leases(inode);
1395
1396
1397
1398
1399 for (flock = inode->i_flock; flock && IS_LEASE(flock);
1400 flock = flock->fl_next) {
1401 if (leases_conflict(new_fl, flock))
1402 goto restart;
1403 }
1404 error = 0;
1405 }
1406
1407out:
1408 spin_unlock(&inode->i_lock);
1409 locks_free_lock(new_fl);
1410 return error;
1411}
1412
1413EXPORT_SYMBOL(__break_lease);
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424void lease_get_mtime(struct inode *inode, struct timespec *time)
1425{
1426 struct file_lock *flock = inode->i_flock;
1427 if (flock && IS_LEASE(flock) && (flock->fl_type == F_WRLCK))
1428 *time = current_fs_time(inode->i_sb);
1429 else
1430 *time = inode->i_mtime;
1431}
1432
1433EXPORT_SYMBOL(lease_get_mtime);
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458int fcntl_getlease(struct file *filp)
1459{
1460 struct file_lock *fl;
1461 struct inode *inode = file_inode(filp);
1462 int type = F_UNLCK;
1463
1464 spin_lock(&inode->i_lock);
1465 time_out_leases(file_inode(filp));
1466 for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl);
1467 fl = fl->fl_next) {
1468 if (fl->fl_file == filp) {
1469 type = target_leasetype(fl);
1470 break;
1471 }
1472 }
1473 spin_unlock(&inode->i_lock);
1474 return type;
1475}
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487static int
1488check_conflicting_open(const struct dentry *dentry, const long arg)
1489{
1490 int ret = 0;
1491 struct inode *inode = dentry->d_inode;
1492
1493 if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
1494 return -EAGAIN;
1495
1496 if ((arg == F_WRLCK) && ((d_count(dentry) > 1) ||
1497 (atomic_read(&inode->i_count) > 1)))
1498 ret = -EAGAIN;
1499
1500 return ret;
1501}
1502
1503static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp)
1504{
1505 struct file_lock *fl, **before, **my_before = NULL, *lease;
1506 struct dentry *dentry = filp->f_path.dentry;
1507 struct inode *inode = dentry->d_inode;
1508 bool is_deleg = (*flp)->fl_flags & FL_DELEG;
1509 int error;
1510
1511 lease = *flp;
1512
1513
1514
1515
1516
1517
1518
1519
1520 if (is_deleg && !mutex_trylock(&inode->i_mutex))
1521 return -EAGAIN;
1522
1523 if (is_deleg && arg == F_WRLCK) {
1524
1525 mutex_unlock(&inode->i_mutex);
1526 WARN_ON_ONCE(1);
1527 return -EINVAL;
1528 }
1529
1530 error = check_conflicting_open(dentry, arg);
1531 if (error)
1532 goto out;
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542 error = -EAGAIN;
1543 for (before = &inode->i_flock;
1544 ((fl = *before) != NULL) && IS_LEASE(fl);
1545 before = &fl->fl_next) {
1546 if (fl->fl_file == filp) {
1547 my_before = before;
1548 continue;
1549 }
1550
1551
1552
1553
1554 if (arg == F_WRLCK)
1555 goto out;
1556
1557
1558
1559
1560 if (fl->fl_flags & FL_UNLOCK_PENDING)
1561 goto out;
1562 }
1563
1564 if (my_before != NULL) {
1565 error = lease->fl_lmops->lm_change(my_before, arg);
1566 if (!error)
1567 *flp = *my_before;
1568 goto out;
1569 }
1570
1571 error = -EINVAL;
1572 if (!leases_enable)
1573 goto out;
1574
1575 locks_insert_lock(before, lease);
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585 smp_mb();
1586 error = check_conflicting_open(dentry, arg);
1587 if (error)
1588 locks_unlink_lock(flp);
1589out:
1590 if (is_deleg)
1591 mutex_unlock(&inode->i_mutex);
1592 return error;
1593}
1594
1595static int generic_delete_lease(struct file *filp, struct file_lock **flp)
1596{
1597 struct file_lock *fl, **before;
1598 struct dentry *dentry = filp->f_path.dentry;
1599 struct inode *inode = dentry->d_inode;
1600
1601 for (before = &inode->i_flock;
1602 ((fl = *before) != NULL) && IS_LEASE(fl);
1603 before = &fl->fl_next) {
1604 if (fl->fl_file != filp)
1605 continue;
1606 return (*flp)->fl_lmops->lm_change(before, F_UNLCK);
1607 }
1608 return -EAGAIN;
1609}
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
1623{
1624 struct dentry *dentry = filp->f_path.dentry;
1625 struct inode *inode = dentry->d_inode;
1626 int error;
1627
1628 if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
1629 return -EACCES;
1630 if (!S_ISREG(inode->i_mode))
1631 return -EINVAL;
1632 error = security_file_lock(filp, arg);
1633 if (error)
1634 return error;
1635
1636 time_out_leases(inode);
1637
1638 BUG_ON(!(*flp)->fl_lmops->lm_break);
1639
1640 switch (arg) {
1641 case F_UNLCK:
1642 return generic_delete_lease(filp, flp);
1643 case F_RDLCK:
1644 case F_WRLCK:
1645 return generic_add_lease(filp, arg, flp);
1646 default:
1647 return -EINVAL;
1648 }
1649}
1650EXPORT_SYMBOL(generic_setlease);
1651
1652static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1653{
1654 if (filp->f_op->setlease)
1655 return filp->f_op->setlease(filp, arg, lease);
1656 else
1657 return generic_setlease(filp, arg, lease);
1658}
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687int vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1688{
1689 struct inode *inode = file_inode(filp);
1690 int error;
1691
1692 spin_lock(&inode->i_lock);
1693 error = __vfs_setlease(filp, arg, lease);
1694 spin_unlock(&inode->i_lock);
1695
1696 return error;
1697}
1698EXPORT_SYMBOL_GPL(vfs_setlease);
1699
1700static int do_fcntl_delete_lease(struct file *filp)
1701{
1702 struct file_lock fl, *flp = &fl;
1703
1704 lease_init(filp, F_UNLCK, flp);
1705
1706 return vfs_setlease(filp, F_UNLCK, &flp);
1707}
1708
1709static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg)
1710{
1711 struct file_lock *fl, *ret;
1712 struct inode *inode = file_inode(filp);
1713 struct fasync_struct *new;
1714 int error;
1715
1716 fl = lease_alloc(filp, arg);
1717 if (IS_ERR(fl))
1718 return PTR_ERR(fl);
1719
1720 new = fasync_alloc();
1721 if (!new) {
1722 locks_free_lock(fl);
1723 return -ENOMEM;
1724 }
1725 ret = fl;
1726 spin_lock(&inode->i_lock);
1727 error = __vfs_setlease(filp, arg, &ret);
1728 if (error) {
1729 spin_unlock(&inode->i_lock);
1730 locks_free_lock(fl);
1731 goto out_free_fasync;
1732 }
1733 if (ret != fl)
1734 locks_free_lock(fl);
1735
1736
1737
1738
1739
1740
1741
1742 if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new))
1743 new = NULL;
1744
1745 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
1746 spin_unlock(&inode->i_lock);
1747
1748out_free_fasync:
1749 if (new)
1750 fasync_free(new);
1751 return error;
1752}
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1765{
1766 if (arg == F_UNLCK)
1767 return do_fcntl_delete_lease(filp);
1768 return do_fcntl_add_lease(fd, filp, arg);
1769}
1770
1771
1772
1773
1774
1775
1776
1777
1778int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
1779{
1780 int error;
1781 might_sleep();
1782 for (;;) {
1783 error = flock_lock_file(filp, fl);
1784 if (error != FILE_LOCK_DEFERRED)
1785 break;
1786 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1787 if (!error)
1788 continue;
1789
1790 locks_delete_block(fl);
1791 break;
1792 }
1793 return error;
1794}
1795
1796EXPORT_SYMBOL(flock_lock_file_wait);
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
1818{
1819 struct fd f = fdget(fd);
1820 struct file_lock *lock;
1821 int can_sleep, unlock;
1822 int error;
1823
1824 error = -EBADF;
1825 if (!f.file)
1826 goto out;
1827
1828 can_sleep = !(cmd & LOCK_NB);
1829 cmd &= ~LOCK_NB;
1830 unlock = (cmd == LOCK_UN);
1831
1832 if (!unlock && !(cmd & LOCK_MAND) &&
1833 !(f.file->f_mode & (FMODE_READ|FMODE_WRITE)))
1834 goto out_putf;
1835
1836 error = flock_make_lock(f.file, &lock, cmd);
1837 if (error)
1838 goto out_putf;
1839 if (can_sleep)
1840 lock->fl_flags |= FL_SLEEP;
1841
1842 error = security_file_lock(f.file, lock->fl_type);
1843 if (error)
1844 goto out_free;
1845
1846 if (f.file->f_op->flock)
1847 error = f.file->f_op->flock(f.file,
1848 (can_sleep) ? F_SETLKW : F_SETLK,
1849 lock);
1850 else
1851 error = flock_lock_file_wait(f.file, lock);
1852
1853 out_free:
1854 locks_free_lock(lock);
1855
1856 out_putf:
1857 fdput(f);
1858 out:
1859 return error;
1860}
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870int vfs_test_lock(struct file *filp, struct file_lock *fl)
1871{
1872 if (filp->f_op->lock)
1873 return filp->f_op->lock(filp, F_GETLK, fl);
1874 posix_test_lock(filp, fl);
1875 return 0;
1876}
1877EXPORT_SYMBOL_GPL(vfs_test_lock);
1878
1879static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
1880{
1881 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
1882#if BITS_PER_LONG == 32
1883
1884
1885
1886
1887 if (fl->fl_start > OFFT_OFFSET_MAX)
1888 return -EOVERFLOW;
1889 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
1890 return -EOVERFLOW;
1891#endif
1892 flock->l_start = fl->fl_start;
1893 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1894 fl->fl_end - fl->fl_start + 1;
1895 flock->l_whence = 0;
1896 flock->l_type = fl->fl_type;
1897 return 0;
1898}
1899
1900#if BITS_PER_LONG == 32
1901static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
1902{
1903 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid;
1904 flock->l_start = fl->fl_start;
1905 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1906 fl->fl_end - fl->fl_start + 1;
1907 flock->l_whence = 0;
1908 flock->l_type = fl->fl_type;
1909}
1910#endif
1911
1912
1913
1914
1915int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock __user *l)
1916{
1917 struct file_lock file_lock;
1918 struct flock flock;
1919 int error;
1920
1921 error = -EFAULT;
1922 if (copy_from_user(&flock, l, sizeof(flock)))
1923 goto out;
1924 error = -EINVAL;
1925 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
1926 goto out;
1927
1928 error = flock_to_posix_lock(filp, &file_lock, &flock);
1929 if (error)
1930 goto out;
1931
1932 if (cmd == F_OFD_GETLK) {
1933 error = -EINVAL;
1934 if (flock.l_pid != 0)
1935 goto out;
1936
1937 cmd = F_GETLK;
1938 file_lock.fl_flags |= FL_OFDLCK;
1939 file_lock.fl_owner = (fl_owner_t)filp;
1940 }
1941
1942 error = vfs_test_lock(filp, &file_lock);
1943 if (error)
1944 goto out;
1945
1946 flock.l_type = file_lock.fl_type;
1947 if (file_lock.fl_type != F_UNLCK) {
1948 error = posix_lock_to_flock(&flock, &file_lock);
1949 if (error)
1950 goto out;
1951 }
1952 error = -EFAULT;
1953 if (!copy_to_user(l, &flock, sizeof(flock)))
1954 error = 0;
1955out:
1956 return error;
1957}
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
1993{
1994 if (filp->f_op->lock)
1995 return filp->f_op->lock(filp, cmd, fl);
1996 else
1997 return posix_lock_file(filp, fl, conf);
1998}
1999EXPORT_SYMBOL_GPL(vfs_lock_file);
2000
2001static int do_lock_file_wait(struct file *filp, unsigned int cmd,
2002 struct file_lock *fl)
2003{
2004 int error;
2005
2006 error = security_file_lock(filp, fl->fl_type);
2007 if (error)
2008 return error;
2009
2010 for (;;) {
2011 error = vfs_lock_file(filp, cmd, fl, NULL);
2012 if (error != FILE_LOCK_DEFERRED)
2013 break;
2014 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
2015 if (!error)
2016 continue;
2017
2018 locks_delete_block(fl);
2019 break;
2020 }
2021
2022 return error;
2023}
2024
2025
2026static int
2027check_fmode_for_setlk(struct file_lock *fl)
2028{
2029 switch (fl->fl_type) {
2030 case F_RDLCK:
2031 if (!(fl->fl_file->f_mode & FMODE_READ))
2032 return -EBADF;
2033 break;
2034 case F_WRLCK:
2035 if (!(fl->fl_file->f_mode & FMODE_WRITE))
2036 return -EBADF;
2037 }
2038 return 0;
2039}
2040
2041
2042
2043
2044int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
2045 struct flock __user *l)
2046{
2047 struct file_lock *file_lock = locks_alloc_lock();
2048 struct flock flock;
2049 struct inode *inode;
2050 struct file *f;
2051 int error;
2052
2053 if (file_lock == NULL)
2054 return -ENOLCK;
2055
2056
2057
2058
2059 error = -EFAULT;
2060 if (copy_from_user(&flock, l, sizeof(flock)))
2061 goto out;
2062
2063 inode = file_inode(filp);
2064
2065
2066
2067
2068 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2069 error = -EAGAIN;
2070 goto out;
2071 }
2072
2073again:
2074 error = flock_to_posix_lock(filp, file_lock, &flock);
2075 if (error)
2076 goto out;
2077
2078 error = check_fmode_for_setlk(file_lock);
2079 if (error)
2080 goto out;
2081
2082
2083
2084
2085
2086 switch (cmd) {
2087 case F_OFD_SETLK:
2088 error = -EINVAL;
2089 if (flock.l_pid != 0)
2090 goto out;
2091
2092 cmd = F_SETLK;
2093 file_lock->fl_flags |= FL_OFDLCK;
2094 file_lock->fl_owner = (fl_owner_t)filp;
2095 break;
2096 case F_OFD_SETLKW:
2097 error = -EINVAL;
2098 if (flock.l_pid != 0)
2099 goto out;
2100
2101 cmd = F_SETLKW;
2102 file_lock->fl_flags |= FL_OFDLCK;
2103 file_lock->fl_owner = (fl_owner_t)filp;
2104
2105 case F_SETLKW:
2106 file_lock->fl_flags |= FL_SLEEP;
2107 }
2108
2109 error = do_lock_file_wait(filp, cmd, file_lock);
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120 spin_lock(¤t->files->file_lock);
2121 f = fcheck(fd);
2122 spin_unlock(¤t->files->file_lock);
2123 if (!error && f != filp && flock.l_type != F_UNLCK) {
2124 flock.l_type = F_UNLCK;
2125 goto again;
2126 }
2127
2128out:
2129 locks_free_lock(file_lock);
2130 return error;
2131}
2132
2133#if BITS_PER_LONG == 32
2134
2135
2136
2137int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 __user *l)
2138{
2139 struct file_lock file_lock;
2140 struct flock64 flock;
2141 int error;
2142
2143 error = -EFAULT;
2144 if (copy_from_user(&flock, l, sizeof(flock)))
2145 goto out;
2146 error = -EINVAL;
2147 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
2148 goto out;
2149
2150 error = flock64_to_posix_lock(filp, &file_lock, &flock);
2151 if (error)
2152 goto out;
2153
2154 if (cmd == F_OFD_GETLK) {
2155 error = -EINVAL;
2156 if (flock.l_pid != 0)
2157 goto out;
2158
2159 cmd = F_GETLK64;
2160 file_lock.fl_flags |= FL_OFDLCK;
2161 file_lock.fl_owner = (fl_owner_t)filp;
2162 }
2163
2164 error = vfs_test_lock(filp, &file_lock);
2165 if (error)
2166 goto out;
2167
2168 flock.l_type = file_lock.fl_type;
2169 if (file_lock.fl_type != F_UNLCK)
2170 posix_lock_to_flock64(&flock, &file_lock);
2171
2172 error = -EFAULT;
2173 if (!copy_to_user(l, &flock, sizeof(flock)))
2174 error = 0;
2175
2176out:
2177 return error;
2178}
2179
2180
2181
2182
2183int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
2184 struct flock64 __user *l)
2185{
2186 struct file_lock *file_lock = locks_alloc_lock();
2187 struct flock64 flock;
2188 struct inode *inode;
2189 struct file *f;
2190 int error;
2191
2192 if (file_lock == NULL)
2193 return -ENOLCK;
2194
2195
2196
2197
2198 error = -EFAULT;
2199 if (copy_from_user(&flock, l, sizeof(flock)))
2200 goto out;
2201
2202 inode = file_inode(filp);
2203
2204
2205
2206
2207 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2208 error = -EAGAIN;
2209 goto out;
2210 }
2211
2212again:
2213 error = flock64_to_posix_lock(filp, file_lock, &flock);
2214 if (error)
2215 goto out;
2216
2217 error = check_fmode_for_setlk(file_lock);
2218 if (error)
2219 goto out;
2220
2221
2222
2223
2224
2225 switch (cmd) {
2226 case F_OFD_SETLK:
2227 error = -EINVAL;
2228 if (flock.l_pid != 0)
2229 goto out;
2230
2231 cmd = F_SETLK64;
2232 file_lock->fl_flags |= FL_OFDLCK;
2233 file_lock->fl_owner = (fl_owner_t)filp;
2234 break;
2235 case F_OFD_SETLKW:
2236 error = -EINVAL;
2237 if (flock.l_pid != 0)
2238 goto out;
2239
2240 cmd = F_SETLKW64;
2241 file_lock->fl_flags |= FL_OFDLCK;
2242 file_lock->fl_owner = (fl_owner_t)filp;
2243
2244 case F_SETLKW64:
2245 file_lock->fl_flags |= FL_SLEEP;
2246 }
2247
2248 error = do_lock_file_wait(filp, cmd, file_lock);
2249
2250
2251
2252
2253
2254 spin_lock(¤t->files->file_lock);
2255 f = fcheck(fd);
2256 spin_unlock(¤t->files->file_lock);
2257 if (!error && f != filp && flock.l_type != F_UNLCK) {
2258 flock.l_type = F_UNLCK;
2259 goto again;
2260 }
2261
2262out:
2263 locks_free_lock(file_lock);
2264 return error;
2265}
2266#endif
2267
2268
2269
2270
2271
2272
2273void locks_remove_posix(struct file *filp, fl_owner_t owner)
2274{
2275 struct file_lock lock;
2276
2277
2278
2279
2280
2281
2282 if (!file_inode(filp)->i_flock)
2283 return;
2284
2285 lock.fl_type = F_UNLCK;
2286 lock.fl_flags = FL_POSIX | FL_CLOSE;
2287 lock.fl_start = 0;
2288 lock.fl_end = OFFSET_MAX;
2289 lock.fl_owner = owner;
2290 lock.fl_pid = current->tgid;
2291 lock.fl_file = filp;
2292 lock.fl_ops = NULL;
2293 lock.fl_lmops = NULL;
2294
2295 vfs_lock_file(filp, F_SETLK, &lock, NULL);
2296
2297 if (lock.fl_ops && lock.fl_ops->fl_release_private)
2298 lock.fl_ops->fl_release_private(&lock);
2299}
2300
2301EXPORT_SYMBOL(locks_remove_posix);
2302
2303
2304
2305
2306void locks_remove_file(struct file *filp)
2307{
2308 struct inode * inode = file_inode(filp);
2309 struct file_lock *fl;
2310 struct file_lock **before;
2311
2312 if (!inode->i_flock)
2313 return;
2314
2315 locks_remove_posix(filp, (fl_owner_t)filp);
2316
2317 if (filp->f_op->flock) {
2318 struct file_lock fl = {
2319 .fl_pid = current->tgid,
2320 .fl_file = filp,
2321 .fl_flags = FL_FLOCK,
2322 .fl_type = F_UNLCK,
2323 .fl_end = OFFSET_MAX,
2324 };
2325 filp->f_op->flock(filp, F_SETLKW, &fl);
2326 if (fl.fl_ops && fl.fl_ops->fl_release_private)
2327 fl.fl_ops->fl_release_private(&fl);
2328 }
2329
2330 spin_lock(&inode->i_lock);
2331 before = &inode->i_flock;
2332
2333 while ((fl = *before) != NULL) {
2334 if (fl->fl_file == filp) {
2335 if (IS_LEASE(fl)) {
2336 lease_modify(before, F_UNLCK);
2337 continue;
2338 }
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348 WARN(!IS_FLOCK(fl),
2349 "leftover lock: dev=%u:%u ino=%lu type=%hhd flags=0x%x start=%lld end=%lld\n",
2350 MAJOR(inode->i_sb->s_dev),
2351 MINOR(inode->i_sb->s_dev), inode->i_ino,
2352 fl->fl_type, fl->fl_flags,
2353 fl->fl_start, fl->fl_end);
2354
2355 locks_delete_lock(before);
2356 continue;
2357 }
2358 before = &fl->fl_next;
2359 }
2360 spin_unlock(&inode->i_lock);
2361}
2362
2363
2364
2365
2366
2367
2368
2369int
2370posix_unblock_lock(struct file_lock *waiter)
2371{
2372 int status = 0;
2373
2374 spin_lock(&blocked_lock_lock);
2375 if (waiter->fl_next)
2376 __locks_delete_block(waiter);
2377 else
2378 status = -ENOENT;
2379 spin_unlock(&blocked_lock_lock);
2380 return status;
2381}
2382EXPORT_SYMBOL(posix_unblock_lock);
2383
2384
2385
2386
2387
2388
2389
2390
2391int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
2392{
2393 if (filp->f_op->lock)
2394 return filp->f_op->lock(filp, F_CANCELLK, fl);
2395 return 0;
2396}
2397
2398EXPORT_SYMBOL_GPL(vfs_cancel_lock);
2399
2400#ifdef CONFIG_PROC_FS
2401#include <linux/proc_fs.h>
2402#include <linux/seq_file.h>
2403
2404struct locks_iterator {
2405 int li_cpu;
2406 loff_t li_pos;
2407};
2408
2409static void lock_get_status(struct seq_file *f, struct file_lock *fl,
2410 loff_t id, char *pfx)
2411{
2412 struct inode *inode = NULL;
2413 unsigned int fl_pid;
2414
2415 if (fl->fl_nspid)
2416 fl_pid = pid_vnr(fl->fl_nspid);
2417 else
2418 fl_pid = fl->fl_pid;
2419
2420 if (fl->fl_file != NULL)
2421 inode = file_inode(fl->fl_file);
2422
2423 seq_printf(f, "%lld:%s ", id, pfx);
2424 if (IS_POSIX(fl)) {
2425 if (fl->fl_flags & FL_ACCESS)
2426 seq_printf(f, "ACCESS");
2427 else if (IS_OFDLCK(fl))
2428 seq_printf(f, "OFDLCK");
2429 else
2430 seq_printf(f, "POSIX ");
2431
2432 seq_printf(f, " %s ",
2433 (inode == NULL) ? "*NOINODE*" :
2434 mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
2435 } else if (IS_FLOCK(fl)) {
2436 if (fl->fl_type & LOCK_MAND) {
2437 seq_printf(f, "FLOCK MSNFS ");
2438 } else {
2439 seq_printf(f, "FLOCK ADVISORY ");
2440 }
2441 } else if (IS_LEASE(fl)) {
2442 seq_printf(f, "LEASE ");
2443 if (lease_breaking(fl))
2444 seq_printf(f, "BREAKING ");
2445 else if (fl->fl_file)
2446 seq_printf(f, "ACTIVE ");
2447 else
2448 seq_printf(f, "BREAKER ");
2449 } else {
2450 seq_printf(f, "UNKNOWN UNKNOWN ");
2451 }
2452 if (fl->fl_type & LOCK_MAND) {
2453 seq_printf(f, "%s ",
2454 (fl->fl_type & LOCK_READ)
2455 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ "
2456 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
2457 } else {
2458 seq_printf(f, "%s ",
2459 (lease_breaking(fl))
2460 ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ "
2461 : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ ");
2462 }
2463 if (inode) {
2464#ifdef WE_CAN_BREAK_LSLK_NOW
2465 seq_printf(f, "%d %s:%ld ", fl_pid,
2466 inode->i_sb->s_id, inode->i_ino);
2467#else
2468
2469 seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,
2470 MAJOR(inode->i_sb->s_dev),
2471 MINOR(inode->i_sb->s_dev), inode->i_ino);
2472#endif
2473 } else {
2474 seq_printf(f, "%d <none>:0 ", fl_pid);
2475 }
2476 if (IS_POSIX(fl)) {
2477 if (fl->fl_end == OFFSET_MAX)
2478 seq_printf(f, "%Ld EOF\n", fl->fl_start);
2479 else
2480 seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
2481 } else {
2482 seq_printf(f, "0 EOF\n");
2483 }
2484}
2485
2486static int locks_show(struct seq_file *f, void *v)
2487{
2488 struct locks_iterator *iter = f->private;
2489 struct file_lock *fl, *bfl;
2490
2491 fl = hlist_entry(v, struct file_lock, fl_link);
2492
2493 lock_get_status(f, fl, iter->li_pos, "");
2494
2495 list_for_each_entry(bfl, &fl->fl_block, fl_block)
2496 lock_get_status(f, bfl, iter->li_pos, " ->");
2497
2498 return 0;
2499}
2500
2501static void *locks_start(struct seq_file *f, loff_t *pos)
2502 __acquires(&blocked_lock_lock)
2503{
2504 struct locks_iterator *iter = f->private;
2505
2506 iter->li_pos = *pos + 1;
2507 lg_global_lock(&file_lock_lglock);
2508 spin_lock(&blocked_lock_lock);
2509 return seq_hlist_start_percpu(&file_lock_list, &iter->li_cpu, *pos);
2510}
2511
2512static void *locks_next(struct seq_file *f, void *v, loff_t *pos)
2513{
2514 struct locks_iterator *iter = f->private;
2515
2516 ++iter->li_pos;
2517 return seq_hlist_next_percpu(v, &file_lock_list, &iter->li_cpu, pos);
2518}
2519
2520static void locks_stop(struct seq_file *f, void *v)
2521 __releases(&blocked_lock_lock)
2522{
2523 spin_unlock(&blocked_lock_lock);
2524 lg_global_unlock(&file_lock_lglock);
2525}
2526
2527static const struct seq_operations locks_seq_operations = {
2528 .start = locks_start,
2529 .next = locks_next,
2530 .stop = locks_stop,
2531 .show = locks_show,
2532};
2533
2534static int locks_open(struct inode *inode, struct file *filp)
2535{
2536 return seq_open_private(filp, &locks_seq_operations,
2537 sizeof(struct locks_iterator));
2538}
2539
2540static const struct file_operations proc_locks_operations = {
2541 .open = locks_open,
2542 .read = seq_read,
2543 .llseek = seq_lseek,
2544 .release = seq_release_private,
2545};
2546
2547static int __init proc_locks_init(void)
2548{
2549 proc_create("locks", 0, NULL, &proc_locks_operations);
2550 return 0;
2551}
2552module_init(proc_locks_init);
2553#endif
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
2569{
2570 struct file_lock *fl;
2571 int result = 1;
2572
2573 spin_lock(&inode->i_lock);
2574 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2575 if (IS_POSIX(fl)) {
2576 if (fl->fl_type == F_RDLCK)
2577 continue;
2578 if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2579 continue;
2580 } else if (IS_FLOCK(fl)) {
2581 if (!(fl->fl_type & LOCK_MAND))
2582 continue;
2583 if (fl->fl_type & LOCK_READ)
2584 continue;
2585 } else
2586 continue;
2587 result = 0;
2588 break;
2589 }
2590 spin_unlock(&inode->i_lock);
2591 return result;
2592}
2593
2594EXPORT_SYMBOL(lock_may_read);
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
2610{
2611 struct file_lock *fl;
2612 int result = 1;
2613
2614 spin_lock(&inode->i_lock);
2615 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2616 if (IS_POSIX(fl)) {
2617 if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2618 continue;
2619 } else if (IS_FLOCK(fl)) {
2620 if (!(fl->fl_type & LOCK_MAND))
2621 continue;
2622 if (fl->fl_type & LOCK_WRITE)
2623 continue;
2624 } else
2625 continue;
2626 result = 0;
2627 break;
2628 }
2629 spin_unlock(&inode->i_lock);
2630 return result;
2631}
2632
2633EXPORT_SYMBOL(lock_may_write);
2634
2635static int __init filelock_init(void)
2636{
2637 int i;
2638
2639 filelock_cache = kmem_cache_create("file_lock_cache",
2640 sizeof(struct file_lock), 0, SLAB_PANIC, NULL);
2641
2642 lg_lock_init(&file_lock_lglock, "file_lock_lglock");
2643
2644 for_each_possible_cpu(i)
2645 INIT_HLIST_HEAD(per_cpu_ptr(&file_lock_list, i));
2646
2647 return 0;
2648}
2649
2650core_initcall(filelock_init);
2651