1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/spinlock.h>
14#include <linux/module.h>
15#include <linux/sched.h>
16#include <linux/timer.h>
17
18#include "rtmutex_common.h"
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
53static void
54rt_mutex_set_owner(struct rt_mutex *lock, struct task_struct *owner,
55 unsigned long mask)
56{
57 unsigned long val = (unsigned long)owner | mask;
58
59 if (rt_mutex_has_waiters(lock))
60 val |= RT_MUTEX_HAS_WAITERS;
61
62 lock->owner = (struct task_struct *)val;
63}
64
65static inline void clear_rt_mutex_waiters(struct rt_mutex *lock)
66{
67 lock->owner = (struct task_struct *)
68 ((unsigned long)lock->owner & ~RT_MUTEX_HAS_WAITERS);
69}
70
71static void fixup_rt_mutex_waiters(struct rt_mutex *lock)
72{
73 if (!rt_mutex_has_waiters(lock))
74 clear_rt_mutex_waiters(lock);
75}
76
77
78
79
80
81#if defined(__HAVE_ARCH_CMPXCHG) && !defined(CONFIG_DEBUG_RT_MUTEXES)
82# define rt_mutex_cmpxchg(l,c,n) (cmpxchg(&l->owner, c, n) == c)
83static inline void mark_rt_mutex_waiters(struct rt_mutex *lock)
84{
85 unsigned long owner, *p = (unsigned long *) &lock->owner;
86
87 do {
88 owner = *p;
89 } while (cmpxchg(p, owner, owner | RT_MUTEX_HAS_WAITERS) != owner);
90}
91#else
92# define rt_mutex_cmpxchg(l,c,n) (0)
93static inline void mark_rt_mutex_waiters(struct rt_mutex *lock)
94{
95 lock->owner = (struct task_struct *)
96 ((unsigned long)lock->owner | RT_MUTEX_HAS_WAITERS);
97}
98#endif
99
100
101
102
103
104
105
106int rt_mutex_getprio(struct task_struct *task)
107{
108 if (likely(!task_has_pi_waiters(task)))
109 return task->normal_prio;
110
111 return min(task_top_pi_waiter(task)->pi_list_entry.prio,
112 task->normal_prio);
113}
114
115
116
117
118
119
120static void __rt_mutex_adjust_prio(struct task_struct *task)
121{
122 int prio = rt_mutex_getprio(task);
123
124 if (task->prio != prio)
125 rt_mutex_setprio(task, prio);
126}
127
128
129
130
131
132
133
134
135
136
137static void rt_mutex_adjust_prio(struct task_struct *task)
138{
139 unsigned long flags;
140
141 spin_lock_irqsave(&task->pi_lock, flags);
142 __rt_mutex_adjust_prio(task);
143 spin_unlock_irqrestore(&task->pi_lock, flags);
144}
145
146
147
148
149int max_lock_depth = 1024;
150
151
152
153
154
155
156static int rt_mutex_adjust_prio_chain(struct task_struct *task,
157 int deadlock_detect,
158 struct rt_mutex *orig_lock,
159 struct rt_mutex_waiter *orig_waiter,
160 struct task_struct *top_task)
161{
162 struct rt_mutex *lock;
163 struct rt_mutex_waiter *waiter, *top_waiter = orig_waiter;
164 int detect_deadlock, ret = 0, depth = 0;
165 unsigned long flags;
166
167 detect_deadlock = debug_rt_mutex_detect_deadlock(orig_waiter,
168 deadlock_detect);
169
170
171
172
173
174
175
176 again:
177 if (++depth > max_lock_depth) {
178 static int prev_max;
179
180
181
182
183
184 if (prev_max != max_lock_depth) {
185 prev_max = max_lock_depth;
186 printk(KERN_WARNING "Maximum lock depth %d reached "
187 "task: %s (%d)\n", max_lock_depth,
188 top_task->comm, task_pid_nr(top_task));
189 }
190 put_task_struct(task);
191
192 return deadlock_detect ? -EDEADLK : 0;
193 }
194 retry:
195
196
197
198 spin_lock_irqsave(&task->pi_lock, flags);
199
200 waiter = task->pi_blocked_on;
201
202
203
204
205
206 if (!waiter || !waiter->task)
207 goto out_unlock_pi;
208
209
210
211
212
213
214 if (orig_waiter && !orig_waiter->task)
215 goto out_unlock_pi;
216
217
218
219
220
221
222 if (top_waiter && (!task_has_pi_waiters(task) ||
223 top_waiter != task_top_pi_waiter(task)))
224 goto out_unlock_pi;
225
226
227
228
229
230 if (!detect_deadlock && waiter->list_entry.prio == task->prio)
231 goto out_unlock_pi;
232
233 lock = waiter->lock;
234 if (!spin_trylock(&lock->wait_lock)) {
235 spin_unlock_irqrestore(&task->pi_lock, flags);
236 cpu_relax();
237 goto retry;
238 }
239
240
241 if (lock == orig_lock || rt_mutex_owner(lock) == top_task) {
242 debug_rt_mutex_deadlock(deadlock_detect, orig_waiter, lock);
243 spin_unlock(&lock->wait_lock);
244 ret = deadlock_detect ? -EDEADLK : 0;
245 goto out_unlock_pi;
246 }
247
248 top_waiter = rt_mutex_top_waiter(lock);
249
250
251 plist_del(&waiter->list_entry, &lock->wait_list);
252 waiter->list_entry.prio = task->prio;
253 plist_add(&waiter->list_entry, &lock->wait_list);
254
255
256 spin_unlock_irqrestore(&task->pi_lock, flags);
257 put_task_struct(task);
258
259
260 task = rt_mutex_owner(lock);
261 get_task_struct(task);
262 spin_lock_irqsave(&task->pi_lock, flags);
263
264 if (waiter == rt_mutex_top_waiter(lock)) {
265
266 plist_del(&top_waiter->pi_list_entry, &task->pi_waiters);
267 waiter->pi_list_entry.prio = waiter->list_entry.prio;
268 plist_add(&waiter->pi_list_entry, &task->pi_waiters);
269 __rt_mutex_adjust_prio(task);
270
271 } else if (top_waiter == waiter) {
272
273 plist_del(&waiter->pi_list_entry, &task->pi_waiters);
274 waiter = rt_mutex_top_waiter(lock);
275 waiter->pi_list_entry.prio = waiter->list_entry.prio;
276 plist_add(&waiter->pi_list_entry, &task->pi_waiters);
277 __rt_mutex_adjust_prio(task);
278 }
279
280 spin_unlock_irqrestore(&task->pi_lock, flags);
281
282 top_waiter = rt_mutex_top_waiter(lock);
283 spin_unlock(&lock->wait_lock);
284
285 if (!detect_deadlock && waiter != top_waiter)
286 goto out_put_task;
287
288 goto again;
289
290 out_unlock_pi:
291 spin_unlock_irqrestore(&task->pi_lock, flags);
292 out_put_task:
293 put_task_struct(task);
294
295 return ret;
296}
297
298
299
300
301
302
303static inline int try_to_steal_lock(struct rt_mutex *lock,
304 struct task_struct *task)
305{
306 struct task_struct *pendowner = rt_mutex_owner(lock);
307 struct rt_mutex_waiter *next;
308 unsigned long flags;
309
310 if (!rt_mutex_owner_pending(lock))
311 return 0;
312
313 if (pendowner == task)
314 return 1;
315
316 spin_lock_irqsave(&pendowner->pi_lock, flags);
317 if (task->prio >= pendowner->prio) {
318 spin_unlock_irqrestore(&pendowner->pi_lock, flags);
319 return 0;
320 }
321
322
323
324
325
326
327 if (likely(!rt_mutex_has_waiters(lock))) {
328 spin_unlock_irqrestore(&pendowner->pi_lock, flags);
329 return 1;
330 }
331
332
333 next = rt_mutex_top_waiter(lock);
334 plist_del(&next->pi_list_entry, &pendowner->pi_waiters);
335 __rt_mutex_adjust_prio(pendowner);
336 spin_unlock_irqrestore(&pendowner->pi_lock, flags);
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352 if (likely(next->task != task)) {
353 spin_lock_irqsave(&task->pi_lock, flags);
354 plist_add(&next->pi_list_entry, &task->pi_waiters);
355 __rt_mutex_adjust_prio(task);
356 spin_unlock_irqrestore(&task->pi_lock, flags);
357 }
358 return 1;
359}
360
361
362
363
364
365
366
367
368
369
370static int try_to_take_rt_mutex(struct rt_mutex *lock)
371{
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391 mark_rt_mutex_waiters(lock);
392
393 if (rt_mutex_owner(lock) && !try_to_steal_lock(lock, current))
394 return 0;
395
396
397 debug_rt_mutex_lock(lock);
398
399 rt_mutex_set_owner(lock, current, 0);
400
401 rt_mutex_deadlock_account_lock(lock, current);
402
403 return 1;
404}
405
406
407
408
409
410
411
412
413static int task_blocks_on_rt_mutex(struct rt_mutex *lock,
414 struct rt_mutex_waiter *waiter,
415 struct task_struct *task,
416 int detect_deadlock)
417{
418 struct task_struct *owner = rt_mutex_owner(lock);
419 struct rt_mutex_waiter *top_waiter = waiter;
420 unsigned long flags;
421 int chain_walk = 0, res;
422
423 spin_lock_irqsave(&task->pi_lock, flags);
424 __rt_mutex_adjust_prio(task);
425 waiter->task = task;
426 waiter->lock = lock;
427 plist_node_init(&waiter->list_entry, task->prio);
428 plist_node_init(&waiter->pi_list_entry, task->prio);
429
430
431 if (rt_mutex_has_waiters(lock))
432 top_waiter = rt_mutex_top_waiter(lock);
433 plist_add(&waiter->list_entry, &lock->wait_list);
434
435 task->pi_blocked_on = waiter;
436
437 spin_unlock_irqrestore(&task->pi_lock, flags);
438
439 if (waiter == rt_mutex_top_waiter(lock)) {
440 spin_lock_irqsave(&owner->pi_lock, flags);
441 plist_del(&top_waiter->pi_list_entry, &owner->pi_waiters);
442 plist_add(&waiter->pi_list_entry, &owner->pi_waiters);
443
444 __rt_mutex_adjust_prio(owner);
445 if (owner->pi_blocked_on)
446 chain_walk = 1;
447 spin_unlock_irqrestore(&owner->pi_lock, flags);
448 }
449 else if (debug_rt_mutex_detect_deadlock(waiter, detect_deadlock))
450 chain_walk = 1;
451
452 if (!chain_walk)
453 return 0;
454
455
456
457
458
459
460 get_task_struct(owner);
461
462 spin_unlock(&lock->wait_lock);
463
464 res = rt_mutex_adjust_prio_chain(owner, detect_deadlock, lock, waiter,
465 task);
466
467 spin_lock(&lock->wait_lock);
468
469 return res;
470}
471
472
473
474
475
476
477
478
479
480static void wakeup_next_waiter(struct rt_mutex *lock)
481{
482 struct rt_mutex_waiter *waiter;
483 struct task_struct *pendowner;
484 unsigned long flags;
485
486 spin_lock_irqsave(¤t->pi_lock, flags);
487
488 waiter = rt_mutex_top_waiter(lock);
489 plist_del(&waiter->list_entry, &lock->wait_list);
490
491
492
493
494
495
496
497 plist_del(&waiter->pi_list_entry, ¤t->pi_waiters);
498 pendowner = waiter->task;
499 waiter->task = NULL;
500
501 rt_mutex_set_owner(lock, pendowner, RT_MUTEX_OWNER_PENDING);
502
503 spin_unlock_irqrestore(¤t->pi_lock, flags);
504
505
506
507
508
509
510
511
512 spin_lock_irqsave(&pendowner->pi_lock, flags);
513
514 WARN_ON(!pendowner->pi_blocked_on);
515 WARN_ON(pendowner->pi_blocked_on != waiter);
516 WARN_ON(pendowner->pi_blocked_on->lock != lock);
517
518 pendowner->pi_blocked_on = NULL;
519
520 if (rt_mutex_has_waiters(lock)) {
521 struct rt_mutex_waiter *next;
522
523 next = rt_mutex_top_waiter(lock);
524 plist_add(&next->pi_list_entry, &pendowner->pi_waiters);
525 }
526 spin_unlock_irqrestore(&pendowner->pi_lock, flags);
527
528 wake_up_process(pendowner);
529}
530
531
532
533
534
535
536static void remove_waiter(struct rt_mutex *lock,
537 struct rt_mutex_waiter *waiter)
538{
539 int first = (waiter == rt_mutex_top_waiter(lock));
540 struct task_struct *owner = rt_mutex_owner(lock);
541 unsigned long flags;
542 int chain_walk = 0;
543
544 spin_lock_irqsave(¤t->pi_lock, flags);
545 plist_del(&waiter->list_entry, &lock->wait_list);
546 waiter->task = NULL;
547 current->pi_blocked_on = NULL;
548 spin_unlock_irqrestore(¤t->pi_lock, flags);
549
550 if (first && owner != current) {
551
552 spin_lock_irqsave(&owner->pi_lock, flags);
553
554 plist_del(&waiter->pi_list_entry, &owner->pi_waiters);
555
556 if (rt_mutex_has_waiters(lock)) {
557 struct rt_mutex_waiter *next;
558
559 next = rt_mutex_top_waiter(lock);
560 plist_add(&next->pi_list_entry, &owner->pi_waiters);
561 }
562 __rt_mutex_adjust_prio(owner);
563
564 if (owner->pi_blocked_on)
565 chain_walk = 1;
566
567 spin_unlock_irqrestore(&owner->pi_lock, flags);
568 }
569
570 WARN_ON(!plist_node_empty(&waiter->pi_list_entry));
571
572 if (!chain_walk)
573 return;
574
575
576 get_task_struct(owner);
577
578 spin_unlock(&lock->wait_lock);
579
580 rt_mutex_adjust_prio_chain(owner, 0, lock, NULL, current);
581
582 spin_lock(&lock->wait_lock);
583}
584
585
586
587
588
589
590void rt_mutex_adjust_pi(struct task_struct *task)
591{
592 struct rt_mutex_waiter *waiter;
593 unsigned long flags;
594
595 spin_lock_irqsave(&task->pi_lock, flags);
596
597 waiter = task->pi_blocked_on;
598 if (!waiter || waiter->list_entry.prio == task->prio) {
599 spin_unlock_irqrestore(&task->pi_lock, flags);
600 return;
601 }
602
603 spin_unlock_irqrestore(&task->pi_lock, flags);
604
605
606 get_task_struct(task);
607 rt_mutex_adjust_prio_chain(task, 0, NULL, NULL, task);
608}
609
610
611
612
613
614
615
616
617
618
619
620
621static int __sched
622__rt_mutex_slowlock(struct rt_mutex *lock, int state,
623 struct hrtimer_sleeper *timeout,
624 struct rt_mutex_waiter *waiter,
625 int detect_deadlock)
626{
627 int ret = 0;
628
629 for (;;) {
630
631 if (try_to_take_rt_mutex(lock))
632 break;
633
634
635
636
637
638 if (unlikely(state == TASK_INTERRUPTIBLE)) {
639
640 if (signal_pending(current))
641 ret = -EINTR;
642 if (timeout && !timeout->task)
643 ret = -ETIMEDOUT;
644 if (ret)
645 break;
646 }
647
648
649
650
651
652
653 if (!waiter->task) {
654 ret = task_blocks_on_rt_mutex(lock, waiter, current,
655 detect_deadlock);
656
657
658
659
660
661 if (unlikely(!waiter->task)) {
662
663
664
665
666
667
668 ret = 0;
669 continue;
670 }
671 if (unlikely(ret))
672 break;
673 }
674
675 spin_unlock(&lock->wait_lock);
676
677 debug_rt_mutex_print_deadlock(waiter);
678
679 if (waiter->task)
680 schedule_rt_mutex(lock);
681
682 spin_lock(&lock->wait_lock);
683 set_current_state(state);
684 }
685
686 return ret;
687}
688
689
690
691
692static int __sched
693rt_mutex_slowlock(struct rt_mutex *lock, int state,
694 struct hrtimer_sleeper *timeout,
695 int detect_deadlock)
696{
697 struct rt_mutex_waiter waiter;
698 int ret = 0;
699
700 debug_rt_mutex_init_waiter(&waiter);
701 waiter.task = NULL;
702
703 spin_lock(&lock->wait_lock);
704
705
706 if (try_to_take_rt_mutex(lock)) {
707 spin_unlock(&lock->wait_lock);
708 return 0;
709 }
710
711 set_current_state(state);
712
713
714 if (unlikely(timeout)) {
715 hrtimer_start_expires(&timeout->timer, HRTIMER_MODE_ABS);
716 if (!hrtimer_active(&timeout->timer))
717 timeout->task = NULL;
718 }
719
720 ret = __rt_mutex_slowlock(lock, state, timeout, &waiter,
721 detect_deadlock);
722
723 set_current_state(TASK_RUNNING);
724
725 if (unlikely(waiter.task))
726 remove_waiter(lock, &waiter);
727
728
729
730
731
732 fixup_rt_mutex_waiters(lock);
733
734 spin_unlock(&lock->wait_lock);
735
736
737 if (unlikely(timeout))
738 hrtimer_cancel(&timeout->timer);
739
740
741
742
743
744
745 if (unlikely(ret))
746 rt_mutex_adjust_prio(current);
747
748 debug_rt_mutex_free_waiter(&waiter);
749
750 return ret;
751}
752
753
754
755
756static inline int
757rt_mutex_slowtrylock(struct rt_mutex *lock)
758{
759 int ret = 0;
760
761 spin_lock(&lock->wait_lock);
762
763 if (likely(rt_mutex_owner(lock) != current)) {
764
765 ret = try_to_take_rt_mutex(lock);
766
767
768
769
770 fixup_rt_mutex_waiters(lock);
771 }
772
773 spin_unlock(&lock->wait_lock);
774
775 return ret;
776}
777
778
779
780
781static void __sched
782rt_mutex_slowunlock(struct rt_mutex *lock)
783{
784 spin_lock(&lock->wait_lock);
785
786 debug_rt_mutex_unlock(lock);
787
788 rt_mutex_deadlock_account_unlock(current);
789
790 if (!rt_mutex_has_waiters(lock)) {
791 lock->owner = NULL;
792 spin_unlock(&lock->wait_lock);
793 return;
794 }
795
796 wakeup_next_waiter(lock);
797
798 spin_unlock(&lock->wait_lock);
799
800
801 rt_mutex_adjust_prio(current);
802}
803
804
805
806
807
808
809
810static inline int
811rt_mutex_fastlock(struct rt_mutex *lock, int state,
812 int detect_deadlock,
813 int (*slowfn)(struct rt_mutex *lock, int state,
814 struct hrtimer_sleeper *timeout,
815 int detect_deadlock))
816{
817 if (!detect_deadlock && likely(rt_mutex_cmpxchg(lock, NULL, current))) {
818 rt_mutex_deadlock_account_lock(lock, current);
819 return 0;
820 } else
821 return slowfn(lock, state, NULL, detect_deadlock);
822}
823
824static inline int
825rt_mutex_timed_fastlock(struct rt_mutex *lock, int state,
826 struct hrtimer_sleeper *timeout, int detect_deadlock,
827 int (*slowfn)(struct rt_mutex *lock, int state,
828 struct hrtimer_sleeper *timeout,
829 int detect_deadlock))
830{
831 if (!detect_deadlock && likely(rt_mutex_cmpxchg(lock, NULL, current))) {
832 rt_mutex_deadlock_account_lock(lock, current);
833 return 0;
834 } else
835 return slowfn(lock, state, timeout, detect_deadlock);
836}
837
838static inline int
839rt_mutex_fasttrylock(struct rt_mutex *lock,
840 int (*slowfn)(struct rt_mutex *lock))
841{
842 if (likely(rt_mutex_cmpxchg(lock, NULL, current))) {
843 rt_mutex_deadlock_account_lock(lock, current);
844 return 1;
845 }
846 return slowfn(lock);
847}
848
849static inline void
850rt_mutex_fastunlock(struct rt_mutex *lock,
851 void (*slowfn)(struct rt_mutex *lock))
852{
853 if (likely(rt_mutex_cmpxchg(lock, current, NULL)))
854 rt_mutex_deadlock_account_unlock(current);
855 else
856 slowfn(lock);
857}
858
859
860
861
862
863
864void __sched rt_mutex_lock(struct rt_mutex *lock)
865{
866 might_sleep();
867
868 rt_mutex_fastlock(lock, TASK_UNINTERRUPTIBLE, 0, rt_mutex_slowlock);
869}
870EXPORT_SYMBOL_GPL(rt_mutex_lock);
871
872
873
874
875
876
877
878
879
880
881
882
883int __sched rt_mutex_lock_interruptible(struct rt_mutex *lock,
884 int detect_deadlock)
885{
886 might_sleep();
887
888 return rt_mutex_fastlock(lock, TASK_INTERRUPTIBLE,
889 detect_deadlock, rt_mutex_slowlock);
890}
891EXPORT_SYMBOL_GPL(rt_mutex_lock_interruptible);
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908int
909rt_mutex_timed_lock(struct rt_mutex *lock, struct hrtimer_sleeper *timeout,
910 int detect_deadlock)
911{
912 might_sleep();
913
914 return rt_mutex_timed_fastlock(lock, TASK_INTERRUPTIBLE, timeout,
915 detect_deadlock, rt_mutex_slowlock);
916}
917EXPORT_SYMBOL_GPL(rt_mutex_timed_lock);
918
919
920
921
922
923
924
925
926int __sched rt_mutex_trylock(struct rt_mutex *lock)
927{
928 return rt_mutex_fasttrylock(lock, rt_mutex_slowtrylock);
929}
930EXPORT_SYMBOL_GPL(rt_mutex_trylock);
931
932
933
934
935
936
937void __sched rt_mutex_unlock(struct rt_mutex *lock)
938{
939 rt_mutex_fastunlock(lock, rt_mutex_slowunlock);
940}
941EXPORT_SYMBOL_GPL(rt_mutex_unlock);
942
943
944
945
946
947
948
949
950
951void rt_mutex_destroy(struct rt_mutex *lock)
952{
953 WARN_ON(rt_mutex_is_locked(lock));
954#ifdef CONFIG_DEBUG_RT_MUTEXES
955 lock->magic = NULL;
956#endif
957}
958
959EXPORT_SYMBOL_GPL(rt_mutex_destroy);
960
961
962
963
964
965
966
967
968
969
970void __rt_mutex_init(struct rt_mutex *lock, const char *name)
971{
972 lock->owner = NULL;
973 spin_lock_init(&lock->wait_lock);
974 plist_head_init(&lock->wait_list, &lock->wait_lock);
975
976 debug_rt_mutex_init(lock, name);
977}
978EXPORT_SYMBOL_GPL(__rt_mutex_init);
979
980
981
982
983
984
985
986
987
988
989
990void rt_mutex_init_proxy_locked(struct rt_mutex *lock,
991 struct task_struct *proxy_owner)
992{
993 __rt_mutex_init(lock, NULL);
994 debug_rt_mutex_proxy_lock(lock, proxy_owner);
995 rt_mutex_set_owner(lock, proxy_owner, 0);
996 rt_mutex_deadlock_account_lock(lock, proxy_owner);
997}
998
999
1000
1001
1002
1003
1004
1005
1006
1007void rt_mutex_proxy_unlock(struct rt_mutex *lock,
1008 struct task_struct *proxy_owner)
1009{
1010 debug_rt_mutex_proxy_unlock(lock);
1011 rt_mutex_set_owner(lock, NULL, 0);
1012 rt_mutex_deadlock_account_unlock(proxy_owner);
1013}
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029int rt_mutex_start_proxy_lock(struct rt_mutex *lock,
1030 struct rt_mutex_waiter *waiter,
1031 struct task_struct *task, int detect_deadlock)
1032{
1033 int ret;
1034
1035 spin_lock(&lock->wait_lock);
1036
1037 mark_rt_mutex_waiters(lock);
1038
1039 if (!rt_mutex_owner(lock) || try_to_steal_lock(lock, task)) {
1040
1041 debug_rt_mutex_lock(lock);
1042 rt_mutex_set_owner(lock, task, 0);
1043 spin_unlock(&lock->wait_lock);
1044 rt_mutex_deadlock_account_lock(lock, task);
1045 return 1;
1046 }
1047
1048 ret = task_blocks_on_rt_mutex(lock, waiter, task, detect_deadlock);
1049
1050 if (ret && !waiter->task) {
1051
1052
1053
1054
1055
1056
1057 ret = 0;
1058 }
1059 spin_unlock(&lock->wait_lock);
1060
1061 debug_rt_mutex_print_deadlock(waiter);
1062
1063 return ret;
1064}
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078struct task_struct *rt_mutex_next_owner(struct rt_mutex *lock)
1079{
1080 if (!rt_mutex_has_waiters(lock))
1081 return NULL;
1082
1083 return rt_mutex_top_waiter(lock)->task;
1084}
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102int rt_mutex_finish_proxy_lock(struct rt_mutex *lock,
1103 struct hrtimer_sleeper *to,
1104 struct rt_mutex_waiter *waiter,
1105 int detect_deadlock)
1106{
1107 int ret;
1108
1109 spin_lock(&lock->wait_lock);
1110
1111 set_current_state(TASK_INTERRUPTIBLE);
1112
1113 ret = __rt_mutex_slowlock(lock, TASK_INTERRUPTIBLE, to, waiter,
1114 detect_deadlock);
1115
1116 set_current_state(TASK_RUNNING);
1117
1118 if (unlikely(waiter->task))
1119 remove_waiter(lock, waiter);
1120
1121
1122
1123
1124
1125 fixup_rt_mutex_waiters(lock);
1126
1127 spin_unlock(&lock->wait_lock);
1128
1129
1130
1131
1132
1133
1134 if (unlikely(ret))
1135 rt_mutex_adjust_prio(current);
1136
1137 return ret;
1138}
1139