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