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
1400#ifdef CONFIG_MANDATORY_FILE_LOCKING
1401
1402
1403
1404
1405
1406
1407
1408int locks_mandatory_locked(struct file *file)
1409{
1410 int ret;
1411 struct inode *inode = locks_inode(file);
1412 struct file_lock_context *ctx;
1413 struct file_lock *fl;
1414
1415 ctx = smp_load_acquire(&inode->i_flctx);
1416 if (!ctx || list_empty_careful(&ctx->flc_posix))
1417 return 0;
1418
1419
1420
1421
1422 spin_lock(&ctx->flc_lock);
1423 ret = 0;
1424 list_for_each_entry(fl, &ctx->flc_posix, fl_list) {
1425 if (fl->fl_owner != current->files &&
1426 fl->fl_owner != file) {
1427 ret = -EAGAIN;
1428 break;
1429 }
1430 }
1431 spin_unlock(&ctx->flc_lock);
1432 return ret;
1433}
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445int locks_mandatory_area(struct inode *inode, struct file *filp, loff_t start,
1446 loff_t end, unsigned char type)
1447{
1448 struct file_lock fl;
1449 int error;
1450 bool sleep = false;
1451
1452 locks_init_lock(&fl);
1453 fl.fl_pid = current->tgid;
1454 fl.fl_file = filp;
1455 fl.fl_flags = FL_POSIX | FL_ACCESS;
1456 if (filp && !(filp->f_flags & O_NONBLOCK))
1457 sleep = true;
1458 fl.fl_type = type;
1459 fl.fl_start = start;
1460 fl.fl_end = end;
1461
1462 for (;;) {
1463 if (filp) {
1464 fl.fl_owner = filp;
1465 fl.fl_flags &= ~FL_SLEEP;
1466 error = posix_lock_inode(inode, &fl, NULL);
1467 if (!error)
1468 break;
1469 }
1470
1471 if (sleep)
1472 fl.fl_flags |= FL_SLEEP;
1473 fl.fl_owner = current->files;
1474 error = posix_lock_inode(inode, &fl, NULL);
1475 if (error != FILE_LOCK_DEFERRED)
1476 break;
1477 error = wait_event_interruptible(fl.fl_wait,
1478 list_empty(&fl.fl_blocked_member));
1479 if (!error) {
1480
1481
1482
1483
1484 if (__mandatory_lock(inode))
1485 continue;
1486 }
1487
1488 break;
1489 }
1490 locks_delete_block(&fl);
1491
1492 return error;
1493}
1494EXPORT_SYMBOL(locks_mandatory_area);
1495#endif
1496
1497static void lease_clear_pending(struct file_lock *fl, int arg)
1498{
1499 switch (arg) {
1500 case F_UNLCK:
1501 fl->fl_flags &= ~FL_UNLOCK_PENDING;
1502 fallthrough;
1503 case F_RDLCK:
1504 fl->fl_flags &= ~FL_DOWNGRADE_PENDING;
1505 }
1506}
1507
1508
1509int lease_modify(struct file_lock *fl, int arg, struct list_head *dispose)
1510{
1511 int error = assign_type(fl, arg);
1512
1513 if (error)
1514 return error;
1515 lease_clear_pending(fl, arg);
1516 locks_wake_up_blocks(fl);
1517 if (arg == F_UNLCK) {
1518 struct file *filp = fl->fl_file;
1519
1520 f_delown(filp);
1521 filp->f_owner.signum = 0;
1522 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
1523 if (fl->fl_fasync != NULL) {
1524 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
1525 fl->fl_fasync = NULL;
1526 }
1527 locks_delete_lock_ctx(fl, dispose);
1528 }
1529 return 0;
1530}
1531EXPORT_SYMBOL(lease_modify);
1532
1533static bool past_time(unsigned long then)
1534{
1535 if (!then)
1536
1537 return false;
1538 return time_after(jiffies, then);
1539}
1540
1541static void time_out_leases(struct inode *inode, struct list_head *dispose)
1542{
1543 struct file_lock_context *ctx = inode->i_flctx;
1544 struct file_lock *fl, *tmp;
1545
1546 lockdep_assert_held(&ctx->flc_lock);
1547
1548 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) {
1549 trace_time_out_leases(inode, fl);
1550 if (past_time(fl->fl_downgrade_time))
1551 lease_modify(fl, F_RDLCK, dispose);
1552 if (past_time(fl->fl_break_time))
1553 lease_modify(fl, F_UNLCK, dispose);
1554 }
1555}
1556
1557static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker)
1558{
1559 bool rc;
1560
1561 if (lease->fl_lmops->lm_breaker_owns_lease
1562 && lease->fl_lmops->lm_breaker_owns_lease(lease))
1563 return false;
1564 if ((breaker->fl_flags & FL_LAYOUT) != (lease->fl_flags & FL_LAYOUT)) {
1565 rc = false;
1566 goto trace;
1567 }
1568 if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE)) {
1569 rc = false;
1570 goto trace;
1571 }
1572
1573 rc = locks_conflict(breaker, lease);
1574trace:
1575 trace_leases_conflict(rc, lease, breaker);
1576 return rc;
1577}
1578
1579static bool
1580any_leases_conflict(struct inode *inode, struct file_lock *breaker)
1581{
1582 struct file_lock_context *ctx = inode->i_flctx;
1583 struct file_lock *fl;
1584
1585 lockdep_assert_held(&ctx->flc_lock);
1586
1587 list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1588 if (leases_conflict(fl, breaker))
1589 return true;
1590 }
1591 return false;
1592}
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1608{
1609 int error = 0;
1610 struct file_lock_context *ctx;
1611 struct file_lock *new_fl, *fl, *tmp;
1612 unsigned long break_time;
1613 int want_write = (mode & O_ACCMODE) != O_RDONLY;
1614 LIST_HEAD(dispose);
1615
1616 new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
1617 if (IS_ERR(new_fl))
1618 return PTR_ERR(new_fl);
1619 new_fl->fl_flags = type;
1620
1621
1622 ctx = smp_load_acquire(&inode->i_flctx);
1623 if (!ctx) {
1624 WARN_ON_ONCE(1);
1625 goto free_lock;
1626 }
1627
1628 percpu_down_read(&file_rwsem);
1629 spin_lock(&ctx->flc_lock);
1630
1631 time_out_leases(inode, &dispose);
1632
1633 if (!any_leases_conflict(inode, new_fl))
1634 goto out;
1635
1636 break_time = 0;
1637 if (lease_break_time > 0) {
1638 break_time = jiffies + lease_break_time * HZ;
1639 if (break_time == 0)
1640 break_time++;
1641 }
1642
1643 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) {
1644 if (!leases_conflict(fl, new_fl))
1645 continue;
1646 if (want_write) {
1647 if (fl->fl_flags & FL_UNLOCK_PENDING)
1648 continue;
1649 fl->fl_flags |= FL_UNLOCK_PENDING;
1650 fl->fl_break_time = break_time;
1651 } else {
1652 if (lease_breaking(fl))
1653 continue;
1654 fl->fl_flags |= FL_DOWNGRADE_PENDING;
1655 fl->fl_downgrade_time = break_time;
1656 }
1657 if (fl->fl_lmops->lm_break(fl))
1658 locks_delete_lock_ctx(fl, &dispose);
1659 }
1660
1661 if (list_empty(&ctx->flc_lease))
1662 goto out;
1663
1664 if (mode & O_NONBLOCK) {
1665 trace_break_lease_noblock(inode, new_fl);
1666 error = -EWOULDBLOCK;
1667 goto out;
1668 }
1669
1670restart:
1671 fl = list_first_entry(&ctx->flc_lease, struct file_lock, fl_list);
1672 break_time = fl->fl_break_time;
1673 if (break_time != 0)
1674 break_time -= jiffies;
1675 if (break_time == 0)
1676 break_time++;
1677 locks_insert_block(fl, new_fl, leases_conflict);
1678 trace_break_lease_block(inode, new_fl);
1679 spin_unlock(&ctx->flc_lock);
1680 percpu_up_read(&file_rwsem);
1681
1682 locks_dispose_list(&dispose);
1683 error = wait_event_interruptible_timeout(new_fl->fl_wait,
1684 list_empty(&new_fl->fl_blocked_member),
1685 break_time);
1686
1687 percpu_down_read(&file_rwsem);
1688 spin_lock(&ctx->flc_lock);
1689 trace_break_lease_unblock(inode, new_fl);
1690 locks_delete_block(new_fl);
1691 if (error >= 0) {
1692
1693
1694
1695
1696 if (error == 0)
1697 time_out_leases(inode, &dispose);
1698 if (any_leases_conflict(inode, new_fl))
1699 goto restart;
1700 error = 0;
1701 }
1702out:
1703 spin_unlock(&ctx->flc_lock);
1704 percpu_up_read(&file_rwsem);
1705 locks_dispose_list(&dispose);
1706free_lock:
1707 locks_free_lock(new_fl);
1708 return error;
1709}
1710EXPORT_SYMBOL(__break_lease);
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721void lease_get_mtime(struct inode *inode, struct timespec64 *time)
1722{
1723 bool has_lease = false;
1724 struct file_lock_context *ctx;
1725 struct file_lock *fl;
1726
1727 ctx = smp_load_acquire(&inode->i_flctx);
1728 if (ctx && !list_empty_careful(&ctx->flc_lease)) {
1729 spin_lock(&ctx->flc_lock);
1730 fl = list_first_entry_or_null(&ctx->flc_lease,
1731 struct file_lock, fl_list);
1732 if (fl && (fl->fl_type == F_WRLCK))
1733 has_lease = true;
1734 spin_unlock(&ctx->flc_lock);
1735 }
1736
1737 if (has_lease)
1738 *time = current_time(inode);
1739}
1740EXPORT_SYMBOL(lease_get_mtime);
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765int fcntl_getlease(struct file *filp)
1766{
1767 struct file_lock *fl;
1768 struct inode *inode = locks_inode(filp);
1769 struct file_lock_context *ctx;
1770 int type = F_UNLCK;
1771 LIST_HEAD(dispose);
1772
1773 ctx = smp_load_acquire(&inode->i_flctx);
1774 if (ctx && !list_empty_careful(&ctx->flc_lease)) {
1775 percpu_down_read(&file_rwsem);
1776 spin_lock(&ctx->flc_lock);
1777 time_out_leases(inode, &dispose);
1778 list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1779 if (fl->fl_file != filp)
1780 continue;
1781 type = target_leasetype(fl);
1782 break;
1783 }
1784 spin_unlock(&ctx->flc_lock);
1785 percpu_up_read(&file_rwsem);
1786
1787 locks_dispose_list(&dispose);
1788 }
1789 return type;
1790}
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803static int
1804check_conflicting_open(struct file *filp, const long arg, int flags)
1805{
1806 struct inode *inode = locks_inode(filp);
1807 int self_wcount = 0, self_rcount = 0;
1808
1809 if (flags & FL_LAYOUT)
1810 return 0;
1811 if (flags & FL_DELEG)
1812
1813 return 0;
1814
1815 if (arg == F_RDLCK)
1816 return inode_is_open_for_write(inode) ? -EAGAIN : 0;
1817 else if (arg != F_WRLCK)
1818 return 0;
1819
1820
1821
1822
1823
1824
1825
1826 if (filp->f_mode & FMODE_WRITE)
1827 self_wcount = 1;
1828 else if (filp->f_mode & FMODE_READ)
1829 self_rcount = 1;
1830
1831 if (atomic_read(&inode->i_writecount) != self_wcount ||
1832 atomic_read(&inode->i_readcount) != self_rcount)
1833 return -EAGAIN;
1834
1835 return 0;
1836}
1837
1838static int
1839generic_add_lease(struct file *filp, long arg, struct file_lock **flp, void **priv)
1840{
1841 struct file_lock *fl, *my_fl = NULL, *lease;
1842 struct inode *inode = locks_inode(filp);
1843 struct file_lock_context *ctx;
1844 bool is_deleg = (*flp)->fl_flags & FL_DELEG;
1845 int error;
1846 LIST_HEAD(dispose);
1847
1848 lease = *flp;
1849 trace_generic_add_lease(inode, lease);
1850
1851
1852 ctx = locks_get_lock_context(inode, arg);
1853 if (!ctx)
1854 return -ENOMEM;
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864 if (is_deleg && !inode_trylock(inode))
1865 return -EAGAIN;
1866
1867 if (is_deleg && arg == F_WRLCK) {
1868
1869 inode_unlock(inode);
1870 WARN_ON_ONCE(1);
1871 return -EINVAL;
1872 }
1873
1874 percpu_down_read(&file_rwsem);
1875 spin_lock(&ctx->flc_lock);
1876 time_out_leases(inode, &dispose);
1877 error = check_conflicting_open(filp, arg, lease->fl_flags);
1878 if (error)
1879 goto out;
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889 error = -EAGAIN;
1890 list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1891 if (fl->fl_file == filp &&
1892 fl->fl_owner == lease->fl_owner) {
1893 my_fl = fl;
1894 continue;
1895 }
1896
1897
1898
1899
1900
1901 if (arg == F_WRLCK)
1902 goto out;
1903
1904
1905
1906
1907 if (fl->fl_flags & FL_UNLOCK_PENDING)
1908 goto out;
1909 }
1910
1911 if (my_fl != NULL) {
1912 lease = my_fl;
1913 error = lease->fl_lmops->lm_change(lease, arg, &dispose);
1914 if (error)
1915 goto out;
1916 goto out_setup;
1917 }
1918
1919 error = -EINVAL;
1920 if (!leases_enable)
1921 goto out;
1922
1923 locks_insert_lock_ctx(lease, &ctx->flc_lease);
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933 smp_mb();
1934 error = check_conflicting_open(filp, arg, lease->fl_flags);
1935 if (error) {
1936 locks_unlink_lock_ctx(lease);
1937 goto out;
1938 }
1939
1940out_setup:
1941 if (lease->fl_lmops->lm_setup)
1942 lease->fl_lmops->lm_setup(lease, priv);
1943out:
1944 spin_unlock(&ctx->flc_lock);
1945 percpu_up_read(&file_rwsem);
1946 locks_dispose_list(&dispose);
1947 if (is_deleg)
1948 inode_unlock(inode);
1949 if (!error && !my_fl)
1950 *flp = NULL;
1951 return error;
1952}
1953
1954static int generic_delete_lease(struct file *filp, void *owner)
1955{
1956 int error = -EAGAIN;
1957 struct file_lock *fl, *victim = NULL;
1958 struct inode *inode = locks_inode(filp);
1959 struct file_lock_context *ctx;
1960 LIST_HEAD(dispose);
1961
1962 ctx = smp_load_acquire(&inode->i_flctx);
1963 if (!ctx) {
1964 trace_generic_delete_lease(inode, NULL);
1965 return error;
1966 }
1967
1968 percpu_down_read(&file_rwsem);
1969 spin_lock(&ctx->flc_lock);
1970 list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1971 if (fl->fl_file == filp &&
1972 fl->fl_owner == owner) {
1973 victim = fl;
1974 break;
1975 }
1976 }
1977 trace_generic_delete_lease(inode, victim);
1978 if (victim)
1979 error = fl->fl_lmops->lm_change(victim, F_UNLCK, &dispose);
1980 spin_unlock(&ctx->flc_lock);
1981 percpu_up_read(&file_rwsem);
1982 locks_dispose_list(&dispose);
1983 return error;
1984}
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997int generic_setlease(struct file *filp, long arg, struct file_lock **flp,
1998 void **priv)
1999{
2000 struct inode *inode = locks_inode(filp);
2001 int error;
2002
2003 if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
2004 return -EACCES;
2005 if (!S_ISREG(inode->i_mode))
2006 return -EINVAL;
2007 error = security_file_lock(filp, arg);
2008 if (error)
2009 return error;
2010
2011 switch (arg) {
2012 case F_UNLCK:
2013 return generic_delete_lease(filp, *priv);
2014 case F_RDLCK:
2015 case F_WRLCK:
2016 if (!(*flp)->fl_lmops->lm_break) {
2017 WARN_ON_ONCE(1);
2018 return -ENOLCK;
2019 }
2020
2021 return generic_add_lease(filp, arg, flp, priv);
2022 default:
2023 return -EINVAL;
2024 }
2025}
2026EXPORT_SYMBOL(generic_setlease);
2027
2028#if IS_ENABLED(CONFIG_SRCU)
2029
2030
2031
2032
2033
2034
2035static struct srcu_notifier_head lease_notifier_chain;
2036
2037static inline void
2038lease_notifier_chain_init(void)
2039{
2040 srcu_init_notifier_head(&lease_notifier_chain);
2041}
2042
2043static inline void
2044setlease_notifier(long arg, struct file_lock *lease)
2045{
2046 if (arg != F_UNLCK)
2047 srcu_notifier_call_chain(&lease_notifier_chain, arg, lease);
2048}
2049
2050int lease_register_notifier(struct notifier_block *nb)
2051{
2052 return srcu_notifier_chain_register(&lease_notifier_chain, nb);
2053}
2054EXPORT_SYMBOL_GPL(lease_register_notifier);
2055
2056void lease_unregister_notifier(struct notifier_block *nb)
2057{
2058 srcu_notifier_chain_unregister(&lease_notifier_chain, nb);
2059}
2060EXPORT_SYMBOL_GPL(lease_unregister_notifier);
2061
2062#else
2063static inline void
2064lease_notifier_chain_init(void)
2065{
2066}
2067
2068static inline void
2069setlease_notifier(long arg, struct file_lock *lease)
2070{
2071}
2072
2073int lease_register_notifier(struct notifier_block *nb)
2074{
2075 return 0;
2076}
2077EXPORT_SYMBOL_GPL(lease_register_notifier);
2078
2079void lease_unregister_notifier(struct notifier_block *nb)
2080{
2081}
2082EXPORT_SYMBOL_GPL(lease_unregister_notifier);
2083
2084#endif
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103int
2104vfs_setlease(struct file *filp, long arg, struct file_lock **lease, void **priv)
2105{
2106 if (lease)
2107 setlease_notifier(arg, *lease);
2108 if (filp->f_op->setlease)
2109 return filp->f_op->setlease(filp, arg, lease, priv);
2110 else
2111 return generic_setlease(filp, arg, lease, priv);
2112}
2113EXPORT_SYMBOL_GPL(vfs_setlease);
2114
2115static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg)
2116{
2117 struct file_lock *fl;
2118 struct fasync_struct *new;
2119 int error;
2120
2121 fl = lease_alloc(filp, arg);
2122 if (IS_ERR(fl))
2123 return PTR_ERR(fl);
2124
2125 new = fasync_alloc();
2126 if (!new) {
2127 locks_free_lock(fl);
2128 return -ENOMEM;
2129 }
2130 new->fa_fd = fd;
2131
2132 error = vfs_setlease(filp, arg, &fl, (void **)&new);
2133 if (fl)
2134 locks_free_lock(fl);
2135 if (new)
2136 fasync_free(new);
2137 return error;
2138}
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
2151{
2152 if (arg == F_UNLCK)
2153 return vfs_setlease(filp, F_UNLCK, NULL, (void **)&filp);
2154 return do_fcntl_add_lease(fd, filp, arg);
2155}
2156
2157
2158
2159
2160
2161
2162
2163
2164static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)
2165{
2166 int error;
2167 might_sleep();
2168 for (;;) {
2169 error = flock_lock_inode(inode, fl);
2170 if (error != FILE_LOCK_DEFERRED)
2171 break;
2172 error = wait_event_interruptible(fl->fl_wait,
2173 list_empty(&fl->fl_blocked_member));
2174 if (error)
2175 break;
2176 }
2177 locks_delete_block(fl);
2178 return error;
2179}
2180
2181
2182
2183
2184
2185
2186
2187
2188int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
2189{
2190 int res = 0;
2191 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
2192 case FL_POSIX:
2193 res = posix_lock_inode_wait(inode, fl);
2194 break;
2195 case FL_FLOCK:
2196 res = flock_lock_inode_wait(inode, fl);
2197 break;
2198 default:
2199 BUG();
2200 }
2201 return res;
2202}
2203EXPORT_SYMBOL(locks_lock_inode_wait);
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
2223{
2224 struct fd f = fdget(fd);
2225 struct file_lock *lock;
2226 int can_sleep, unlock;
2227 int error;
2228
2229 error = -EBADF;
2230 if (!f.file)
2231 goto out;
2232
2233 can_sleep = !(cmd & LOCK_NB);
2234 cmd &= ~LOCK_NB;
2235 unlock = (cmd == LOCK_UN);
2236
2237 if (!unlock && !(cmd & LOCK_MAND) &&
2238 !(f.file->f_mode & (FMODE_READ|FMODE_WRITE)))
2239 goto out_putf;
2240
2241 lock = flock_make_lock(f.file, cmd, NULL);
2242 if (IS_ERR(lock)) {
2243 error = PTR_ERR(lock);
2244 goto out_putf;
2245 }
2246
2247 if (can_sleep)
2248 lock->fl_flags |= FL_SLEEP;
2249
2250 error = security_file_lock(f.file, lock->fl_type);
2251 if (error)
2252 goto out_free;
2253
2254 if (f.file->f_op->flock)
2255 error = f.file->f_op->flock(f.file,
2256 (can_sleep) ? F_SETLKW : F_SETLK,
2257 lock);
2258 else
2259 error = locks_lock_file_wait(f.file, lock);
2260
2261 out_free:
2262 locks_free_lock(lock);
2263
2264 out_putf:
2265 fdput(f);
2266 out:
2267 return error;
2268}
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278int vfs_test_lock(struct file *filp, struct file_lock *fl)
2279{
2280 if (filp->f_op->lock)
2281 return filp->f_op->lock(filp, F_GETLK, fl);
2282 posix_test_lock(filp, fl);
2283 return 0;
2284}
2285EXPORT_SYMBOL_GPL(vfs_test_lock);
2286
2287
2288
2289
2290
2291
2292
2293
2294static pid_t locks_translate_pid(struct file_lock *fl, struct pid_namespace *ns)
2295{
2296 pid_t vnr;
2297 struct pid *pid;
2298
2299 if (IS_OFDLCK(fl))
2300 return -1;
2301 if (IS_REMOTELCK(fl))
2302 return fl->fl_pid;
2303
2304
2305
2306
2307
2308 if (ns == &init_pid_ns)
2309 return (pid_t)fl->fl_pid;
2310
2311 rcu_read_lock();
2312 pid = find_pid_ns(fl->fl_pid, &init_pid_ns);
2313 vnr = pid_nr_ns(pid, ns);
2314 rcu_read_unlock();
2315 return vnr;
2316}
2317
2318static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
2319{
2320 flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current));
2321#if BITS_PER_LONG == 32
2322
2323
2324
2325
2326 if (fl->fl_start > OFFT_OFFSET_MAX)
2327 return -EOVERFLOW;
2328 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
2329 return -EOVERFLOW;
2330#endif
2331 flock->l_start = fl->fl_start;
2332 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
2333 fl->fl_end - fl->fl_start + 1;
2334 flock->l_whence = 0;
2335 flock->l_type = fl->fl_type;
2336 return 0;
2337}
2338
2339#if BITS_PER_LONG == 32
2340static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
2341{
2342 flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current));
2343 flock->l_start = fl->fl_start;
2344 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
2345 fl->fl_end - fl->fl_start + 1;
2346 flock->l_whence = 0;
2347 flock->l_type = fl->fl_type;
2348}
2349#endif
2350
2351
2352
2353
2354int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock)
2355{
2356 struct file_lock *fl;
2357 int error;
2358
2359 fl = locks_alloc_lock();
2360 if (fl == NULL)
2361 return -ENOMEM;
2362 error = -EINVAL;
2363 if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK)
2364 goto out;
2365
2366 error = flock_to_posix_lock(filp, fl, flock);
2367 if (error)
2368 goto out;
2369
2370 if (cmd == F_OFD_GETLK) {
2371 error = -EINVAL;
2372 if (flock->l_pid != 0)
2373 goto out;
2374
2375 fl->fl_flags |= FL_OFDLCK;
2376 fl->fl_owner = filp;
2377 }
2378
2379 error = vfs_test_lock(filp, fl);
2380 if (error)
2381 goto out;
2382
2383 flock->l_type = fl->fl_type;
2384 if (fl->fl_type != F_UNLCK) {
2385 error = posix_lock_to_flock(flock, fl);
2386 if (error)
2387 goto out;
2388 }
2389out:
2390 locks_free_lock(fl);
2391 return error;
2392}
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
2428{
2429 if (filp->f_op->lock)
2430 return filp->f_op->lock(filp, cmd, fl);
2431 else
2432 return posix_lock_file(filp, fl, conf);
2433}
2434EXPORT_SYMBOL_GPL(vfs_lock_file);
2435
2436static int do_lock_file_wait(struct file *filp, unsigned int cmd,
2437 struct file_lock *fl)
2438{
2439 int error;
2440
2441 error = security_file_lock(filp, fl->fl_type);
2442 if (error)
2443 return error;
2444
2445 for (;;) {
2446 error = vfs_lock_file(filp, cmd, fl, NULL);
2447 if (error != FILE_LOCK_DEFERRED)
2448 break;
2449 error = wait_event_interruptible(fl->fl_wait,
2450 list_empty(&fl->fl_blocked_member));
2451 if (error)
2452 break;
2453 }
2454 locks_delete_block(fl);
2455
2456 return error;
2457}
2458
2459
2460static int
2461check_fmode_for_setlk(struct file_lock *fl)
2462{
2463 switch (fl->fl_type) {
2464 case F_RDLCK:
2465 if (!(fl->fl_file->f_mode & FMODE_READ))
2466 return -EBADF;
2467 break;
2468 case F_WRLCK:
2469 if (!(fl->fl_file->f_mode & FMODE_WRITE))
2470 return -EBADF;
2471 }
2472 return 0;
2473}
2474
2475
2476
2477
2478int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
2479 struct flock *flock)
2480{
2481 struct file_lock *file_lock = locks_alloc_lock();
2482 struct inode *inode = locks_inode(filp);
2483 struct file *f;
2484 int error;
2485
2486 if (file_lock == NULL)
2487 return -ENOLCK;
2488
2489
2490
2491
2492 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2493 error = -EAGAIN;
2494 goto out;
2495 }
2496
2497 error = flock_to_posix_lock(filp, file_lock, flock);
2498 if (error)
2499 goto out;
2500
2501 error = check_fmode_for_setlk(file_lock);
2502 if (error)
2503 goto out;
2504
2505
2506
2507
2508
2509 switch (cmd) {
2510 case F_OFD_SETLK:
2511 error = -EINVAL;
2512 if (flock->l_pid != 0)
2513 goto out;
2514
2515 cmd = F_SETLK;
2516 file_lock->fl_flags |= FL_OFDLCK;
2517 file_lock->fl_owner = filp;
2518 break;
2519 case F_OFD_SETLKW:
2520 error = -EINVAL;
2521 if (flock->l_pid != 0)
2522 goto out;
2523
2524 cmd = F_SETLKW;
2525 file_lock->fl_flags |= FL_OFDLCK;
2526 file_lock->fl_owner = filp;
2527 fallthrough;
2528 case F_SETLKW:
2529 file_lock->fl_flags |= FL_SLEEP;
2530 }
2531
2532 error = do_lock_file_wait(filp, cmd, file_lock);
2533
2534
2535
2536
2537
2538
2539 if (!error && file_lock->fl_type != F_UNLCK &&
2540 !(file_lock->fl_flags & FL_OFDLCK)) {
2541 struct files_struct *files = current->files;
2542
2543
2544
2545
2546
2547 spin_lock(&files->file_lock);
2548 f = files_lookup_fd_locked(files, fd);
2549 spin_unlock(&files->file_lock);
2550 if (f != filp) {
2551 file_lock->fl_type = F_UNLCK;
2552 error = do_lock_file_wait(filp, cmd, file_lock);
2553 WARN_ON_ONCE(error);
2554 error = -EBADF;
2555 }
2556 }
2557out:
2558 trace_fcntl_setlk(inode, file_lock, error);
2559 locks_free_lock(file_lock);
2560 return error;
2561}
2562
2563#if BITS_PER_LONG == 32
2564
2565
2566
2567int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock)
2568{
2569 struct file_lock *fl;
2570 int error;
2571
2572 fl = locks_alloc_lock();
2573 if (fl == NULL)
2574 return -ENOMEM;
2575
2576 error = -EINVAL;
2577 if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK)
2578 goto out;
2579
2580 error = flock64_to_posix_lock(filp, fl, flock);
2581 if (error)
2582 goto out;
2583
2584 if (cmd == F_OFD_GETLK) {
2585 error = -EINVAL;
2586 if (flock->l_pid != 0)
2587 goto out;
2588
2589 cmd = F_GETLK64;
2590 fl->fl_flags |= FL_OFDLCK;
2591 fl->fl_owner = filp;
2592 }
2593
2594 error = vfs_test_lock(filp, fl);
2595 if (error)
2596 goto out;
2597
2598 flock->l_type = fl->fl_type;
2599 if (fl->fl_type != F_UNLCK)
2600 posix_lock_to_flock64(flock, fl);
2601
2602out:
2603 locks_free_lock(fl);
2604 return error;
2605}
2606
2607
2608
2609
2610int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
2611 struct flock64 *flock)
2612{
2613 struct file_lock *file_lock = locks_alloc_lock();
2614 struct inode *inode = locks_inode(filp);
2615 struct file *f;
2616 int error;
2617
2618 if (file_lock == NULL)
2619 return -ENOLCK;
2620
2621
2622
2623
2624 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2625 error = -EAGAIN;
2626 goto out;
2627 }
2628
2629 error = flock64_to_posix_lock(filp, file_lock, flock);
2630 if (error)
2631 goto out;
2632
2633 error = check_fmode_for_setlk(file_lock);
2634 if (error)
2635 goto out;
2636
2637
2638
2639
2640
2641 switch (cmd) {
2642 case F_OFD_SETLK:
2643 error = -EINVAL;
2644 if (flock->l_pid != 0)
2645 goto out;
2646
2647 cmd = F_SETLK64;
2648 file_lock->fl_flags |= FL_OFDLCK;
2649 file_lock->fl_owner = filp;
2650 break;
2651 case F_OFD_SETLKW:
2652 error = -EINVAL;
2653 if (flock->l_pid != 0)
2654 goto out;
2655
2656 cmd = F_SETLKW64;
2657 file_lock->fl_flags |= FL_OFDLCK;
2658 file_lock->fl_owner = filp;
2659 fallthrough;
2660 case F_SETLKW64:
2661 file_lock->fl_flags |= FL_SLEEP;
2662 }
2663
2664 error = do_lock_file_wait(filp, cmd, file_lock);
2665
2666
2667
2668
2669
2670
2671 if (!error && file_lock->fl_type != F_UNLCK &&
2672 !(file_lock->fl_flags & FL_OFDLCK)) {
2673 struct files_struct *files = current->files;
2674
2675
2676
2677
2678
2679 spin_lock(&files->file_lock);
2680 f = files_lookup_fd_locked(files, fd);
2681 spin_unlock(&files->file_lock);
2682 if (f != filp) {
2683 file_lock->fl_type = F_UNLCK;
2684 error = do_lock_file_wait(filp, cmd, file_lock);
2685 WARN_ON_ONCE(error);
2686 error = -EBADF;
2687 }
2688 }
2689out:
2690 locks_free_lock(file_lock);
2691 return error;
2692}
2693#endif
2694
2695
2696
2697
2698
2699
2700void locks_remove_posix(struct file *filp, fl_owner_t owner)
2701{
2702 int error;
2703 struct inode *inode = locks_inode(filp);
2704 struct file_lock lock;
2705 struct file_lock_context *ctx;
2706
2707
2708
2709
2710
2711
2712 ctx = smp_load_acquire(&inode->i_flctx);
2713 if (!ctx || list_empty(&ctx->flc_posix))
2714 return;
2715
2716 locks_init_lock(&lock);
2717 lock.fl_type = F_UNLCK;
2718 lock.fl_flags = FL_POSIX | FL_CLOSE;
2719 lock.fl_start = 0;
2720 lock.fl_end = OFFSET_MAX;
2721 lock.fl_owner = owner;
2722 lock.fl_pid = current->tgid;
2723 lock.fl_file = filp;
2724 lock.fl_ops = NULL;
2725 lock.fl_lmops = NULL;
2726
2727 error = vfs_lock_file(filp, F_SETLK, &lock, NULL);
2728
2729 if (lock.fl_ops && lock.fl_ops->fl_release_private)
2730 lock.fl_ops->fl_release_private(&lock);
2731 trace_locks_remove_posix(inode, &lock, error);
2732}
2733EXPORT_SYMBOL(locks_remove_posix);
2734
2735
2736static void
2737locks_remove_flock(struct file *filp, struct file_lock_context *flctx)
2738{
2739 struct file_lock fl;
2740 struct inode *inode = locks_inode(filp);
2741
2742 if (list_empty(&flctx->flc_flock))
2743 return;
2744
2745 flock_make_lock(filp, LOCK_UN, &fl);
2746 fl.fl_flags |= FL_CLOSE;
2747
2748 if (filp->f_op->flock)
2749 filp->f_op->flock(filp, F_SETLKW, &fl);
2750 else
2751 flock_lock_inode(inode, &fl);
2752
2753 if (fl.fl_ops && fl.fl_ops->fl_release_private)
2754 fl.fl_ops->fl_release_private(&fl);
2755}
2756
2757
2758static void
2759locks_remove_lease(struct file *filp, struct file_lock_context *ctx)
2760{
2761 struct file_lock *fl, *tmp;
2762 LIST_HEAD(dispose);
2763
2764 if (list_empty(&ctx->flc_lease))
2765 return;
2766
2767 percpu_down_read(&file_rwsem);
2768 spin_lock(&ctx->flc_lock);
2769 list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list)
2770 if (filp == fl->fl_file)
2771 lease_modify(fl, F_UNLCK, &dispose);
2772 spin_unlock(&ctx->flc_lock);
2773 percpu_up_read(&file_rwsem);
2774
2775 locks_dispose_list(&dispose);
2776}
2777
2778
2779
2780
2781void locks_remove_file(struct file *filp)
2782{
2783 struct file_lock_context *ctx;
2784
2785 ctx = smp_load_acquire(&locks_inode(filp)->i_flctx);
2786 if (!ctx)
2787 return;
2788
2789
2790 locks_remove_posix(filp, filp);
2791
2792
2793 locks_remove_flock(filp, ctx);
2794
2795
2796 locks_remove_lease(filp, ctx);
2797
2798 spin_lock(&ctx->flc_lock);
2799 locks_check_ctx_file_list(filp, &ctx->flc_posix, "POSIX");
2800 locks_check_ctx_file_list(filp, &ctx->flc_flock, "FLOCK");
2801 locks_check_ctx_file_list(filp, &ctx->flc_lease, "LEASE");
2802 spin_unlock(&ctx->flc_lock);
2803}
2804
2805
2806
2807
2808
2809
2810
2811
2812int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
2813{
2814 if (filp->f_op->lock)
2815 return filp->f_op->lock(filp, F_CANCELLK, fl);
2816 return 0;
2817}
2818EXPORT_SYMBOL_GPL(vfs_cancel_lock);
2819
2820#ifdef CONFIG_PROC_FS
2821#include <linux/proc_fs.h>
2822#include <linux/seq_file.h>
2823
2824struct locks_iterator {
2825 int li_cpu;
2826 loff_t li_pos;
2827};
2828
2829static void lock_get_status(struct seq_file *f, struct file_lock *fl,
2830 loff_t id, char *pfx, int repeat)
2831{
2832 struct inode *inode = NULL;
2833 unsigned int fl_pid;
2834 struct pid_namespace *proc_pidns = proc_pid_ns(file_inode(f->file)->i_sb);
2835
2836 fl_pid = locks_translate_pid(fl, proc_pidns);
2837
2838
2839
2840
2841
2842
2843 if (fl->fl_file != NULL)
2844 inode = locks_inode(fl->fl_file);
2845
2846 seq_printf(f, "%lld: ", id);
2847
2848 if (repeat)
2849 seq_printf(f, "%*s", repeat - 1 + (int)strlen(pfx), pfx);
2850
2851 if (IS_POSIX(fl)) {
2852 if (fl->fl_flags & FL_ACCESS)
2853 seq_puts(f, "ACCESS");
2854 else if (IS_OFDLCK(fl))
2855 seq_puts(f, "OFDLCK");
2856 else
2857 seq_puts(f, "POSIX ");
2858
2859 seq_printf(f, " %s ",
2860 (inode == NULL) ? "*NOINODE*" :
2861 mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
2862 } else if (IS_FLOCK(fl)) {
2863 if (fl->fl_type & LOCK_MAND) {
2864 seq_puts(f, "FLOCK MSNFS ");
2865 } else {
2866 seq_puts(f, "FLOCK ADVISORY ");
2867 }
2868 } else if (IS_LEASE(fl)) {
2869 if (fl->fl_flags & FL_DELEG)
2870 seq_puts(f, "DELEG ");
2871 else
2872 seq_puts(f, "LEASE ");
2873
2874 if (lease_breaking(fl))
2875 seq_puts(f, "BREAKING ");
2876 else if (fl->fl_file)
2877 seq_puts(f, "ACTIVE ");
2878 else
2879 seq_puts(f, "BREAKER ");
2880 } else {
2881 seq_puts(f, "UNKNOWN UNKNOWN ");
2882 }
2883 if (fl->fl_type & LOCK_MAND) {
2884 seq_printf(f, "%s ",
2885 (fl->fl_type & LOCK_READ)
2886 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ "
2887 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
2888 } else {
2889 int type = IS_LEASE(fl) ? target_leasetype(fl) : fl->fl_type;
2890
2891 seq_printf(f, "%s ", (type == F_WRLCK) ? "WRITE" :
2892 (type == F_RDLCK) ? "READ" : "UNLCK");
2893 }
2894 if (inode) {
2895
2896 seq_printf(f, "%d %02x:%02x:%lu ", fl_pid,
2897 MAJOR(inode->i_sb->s_dev),
2898 MINOR(inode->i_sb->s_dev), inode->i_ino);
2899 } else {
2900 seq_printf(f, "%d <none>:0 ", fl_pid);
2901 }
2902 if (IS_POSIX(fl)) {
2903 if (fl->fl_end == OFFSET_MAX)
2904 seq_printf(f, "%Ld EOF\n", fl->fl_start);
2905 else
2906 seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
2907 } else {
2908 seq_puts(f, "0 EOF\n");
2909 }
2910}
2911
2912static struct file_lock *get_next_blocked_member(struct file_lock *node)
2913{
2914 struct file_lock *tmp;
2915
2916
2917 if (node == NULL || node->fl_blocker == NULL)
2918 return NULL;
2919
2920
2921 tmp = list_next_entry(node, fl_blocked_member);
2922 if (list_entry_is_head(tmp, &node->fl_blocker->fl_blocked_requests, fl_blocked_member)
2923 || tmp == node) {
2924 return NULL;
2925 }
2926
2927 return tmp;
2928}
2929
2930static int locks_show(struct seq_file *f, void *v)
2931{
2932 struct locks_iterator *iter = f->private;
2933 struct file_lock *cur, *tmp;
2934 struct pid_namespace *proc_pidns = proc_pid_ns(file_inode(f->file)->i_sb);
2935 int level = 0;
2936
2937 cur = hlist_entry(v, struct file_lock, fl_link);
2938
2939 if (locks_translate_pid(cur, proc_pidns) == 0)
2940 return 0;
2941
2942
2943
2944
2945
2946
2947 while (cur != NULL) {
2948 if (level)
2949 lock_get_status(f, cur, iter->li_pos, "-> ", level);
2950 else
2951 lock_get_status(f, cur, iter->li_pos, "", level);
2952
2953 if (!list_empty(&cur->fl_blocked_requests)) {
2954
2955 cur = list_first_entry_or_null(&cur->fl_blocked_requests,
2956 struct file_lock, fl_blocked_member);
2957 level++;
2958 } else {
2959
2960 tmp = get_next_blocked_member(cur);
2961
2962 while (tmp == NULL && cur->fl_blocker != NULL) {
2963 cur = cur->fl_blocker;
2964 level--;
2965 tmp = get_next_blocked_member(cur);
2966 }
2967 cur = tmp;
2968 }
2969 }
2970
2971 return 0;
2972}
2973
2974static void __show_fd_locks(struct seq_file *f,
2975 struct list_head *head, int *id,
2976 struct file *filp, struct files_struct *files)
2977{
2978 struct file_lock *fl;
2979
2980 list_for_each_entry(fl, head, fl_list) {
2981
2982 if (filp != fl->fl_file)
2983 continue;
2984 if (fl->fl_owner != files &&
2985 fl->fl_owner != filp)
2986 continue;
2987
2988 (*id)++;
2989 seq_puts(f, "lock:\t");
2990 lock_get_status(f, fl, *id, "", 0);
2991 }
2992}
2993
2994void show_fd_locks(struct seq_file *f,
2995 struct file *filp, struct files_struct *files)
2996{
2997 struct inode *inode = locks_inode(filp);
2998 struct file_lock_context *ctx;
2999 int id = 0;
3000
3001 ctx = smp_load_acquire(&inode->i_flctx);
3002 if (!ctx)
3003 return;
3004
3005 spin_lock(&ctx->flc_lock);
3006 __show_fd_locks(f, &ctx->flc_flock, &id, filp, files);
3007 __show_fd_locks(f, &ctx->flc_posix, &id, filp, files);
3008 __show_fd_locks(f, &ctx->flc_lease, &id, filp, files);
3009 spin_unlock(&ctx->flc_lock);
3010}
3011
3012static void *locks_start(struct seq_file *f, loff_t *pos)
3013 __acquires(&blocked_lock_lock)
3014{
3015 struct locks_iterator *iter = f->private;
3016
3017 iter->li_pos = *pos + 1;
3018 percpu_down_write(&file_rwsem);
3019 spin_lock(&blocked_lock_lock);
3020 return seq_hlist_start_percpu(&file_lock_list.hlist, &iter->li_cpu, *pos);
3021}
3022
3023static void *locks_next(struct seq_file *f, void *v, loff_t *pos)
3024{
3025 struct locks_iterator *iter = f->private;
3026
3027 ++iter->li_pos;
3028 return seq_hlist_next_percpu(v, &file_lock_list.hlist, &iter->li_cpu, pos);
3029}
3030
3031static void locks_stop(struct seq_file *f, void *v)
3032 __releases(&blocked_lock_lock)
3033{
3034 spin_unlock(&blocked_lock_lock);
3035 percpu_up_write(&file_rwsem);
3036}
3037
3038static const struct seq_operations locks_seq_operations = {
3039 .start = locks_start,
3040 .next = locks_next,
3041 .stop = locks_stop,
3042 .show = locks_show,
3043};
3044
3045static int __init proc_locks_init(void)
3046{
3047 proc_create_seq_private("locks", 0, NULL, &locks_seq_operations,
3048 sizeof(struct locks_iterator), NULL);
3049 return 0;
3050}
3051fs_initcall(proc_locks_init);
3052#endif
3053
3054static int __init filelock_init(void)
3055{
3056 int i;
3057
3058 flctx_cache = kmem_cache_create("file_lock_ctx",
3059 sizeof(struct file_lock_context), 0, SLAB_PANIC, NULL);
3060
3061 filelock_cache = kmem_cache_create("file_lock_cache",
3062 sizeof(struct file_lock), 0, SLAB_PANIC, NULL);
3063
3064 for_each_possible_cpu(i) {
3065 struct file_lock_list_struct *fll = per_cpu_ptr(&file_lock_list, i);
3066
3067 spin_lock_init(&fll->lock);
3068 INIT_HLIST_HEAD(&fll->hlist);
3069 }
3070
3071 lease_notifier_chain_init();
3072 return 0;
3073}
3074core_initcall(filelock_init);
3075