]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
c4e05116 IM |
2 | /* kernel/rwsem.c: R/W semaphores, public implementation |
3 | * | |
4 | * Written by David Howells (dhowells@redhat.com). | |
5 | * Derived from asm-i386/semaphore.h | |
6 | */ | |
7 | ||
8 | #include <linux/types.h> | |
9 | #include <linux/kernel.h> | |
c7af77b5 | 10 | #include <linux/sched.h> |
b17b0153 | 11 | #include <linux/sched/debug.h> |
9984de1a | 12 | #include <linux/export.h> |
c4e05116 | 13 | #include <linux/rwsem.h> |
60063497 | 14 | #include <linux/atomic.h> |
c4e05116 | 15 | |
7a215f89 | 16 | #include "rwsem.h" |
4fc828e2 | 17 | |
c4e05116 IM |
18 | /* |
19 | * lock for reading | |
20 | */ | |
c7af77b5 | 21 | void __sched down_read(struct rw_semaphore *sem) |
c4e05116 IM |
22 | { |
23 | might_sleep(); | |
24 | rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_); | |
25 | ||
4fe87745 | 26 | LOCK_CONTENDED(sem, __down_read_trylock, __down_read); |
19c5d690 | 27 | rwsem_set_reader_owned(sem); |
c4e05116 IM |
28 | } |
29 | ||
30 | EXPORT_SYMBOL(down_read); | |
31 | ||
76f8507f KT |
32 | int __sched down_read_killable(struct rw_semaphore *sem) |
33 | { | |
34 | might_sleep(); | |
35 | rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_); | |
36 | ||
37 | if (LOCK_CONTENDED_RETURN(sem, __down_read_trylock, __down_read_killable)) { | |
38 | rwsem_release(&sem->dep_map, 1, _RET_IP_); | |
39 | return -EINTR; | |
40 | } | |
41 | ||
42 | rwsem_set_reader_owned(sem); | |
43 | return 0; | |
44 | } | |
45 | ||
46 | EXPORT_SYMBOL(down_read_killable); | |
47 | ||
c4e05116 IM |
48 | /* |
49 | * trylock for reading -- returns 1 if successful, 0 if contention | |
50 | */ | |
51 | int down_read_trylock(struct rw_semaphore *sem) | |
52 | { | |
53 | int ret = __down_read_trylock(sem); | |
54 | ||
19c5d690 | 55 | if (ret == 1) { |
c4e05116 | 56 | rwsem_acquire_read(&sem->dep_map, 0, 1, _RET_IP_); |
19c5d690 WL |
57 | rwsem_set_reader_owned(sem); |
58 | } | |
c4e05116 IM |
59 | return ret; |
60 | } | |
61 | ||
62 | EXPORT_SYMBOL(down_read_trylock); | |
63 | ||
64 | /* | |
65 | * lock for writing | |
66 | */ | |
c7af77b5 | 67 | void __sched down_write(struct rw_semaphore *sem) |
c4e05116 IM |
68 | { |
69 | might_sleep(); | |
70 | rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_); | |
71 | ||
4fe87745 | 72 | LOCK_CONTENDED(sem, __down_write_trylock, __down_write); |
4fc828e2 | 73 | rwsem_set_owner(sem); |
c4e05116 IM |
74 | } |
75 | ||
76 | EXPORT_SYMBOL(down_write); | |
77 | ||
916633a4 MH |
78 | /* |
79 | * lock for writing | |
80 | */ | |
81 | int __sched down_write_killable(struct rw_semaphore *sem) | |
82 | { | |
83 | might_sleep(); | |
84 | rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_); | |
85 | ||
86 | if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) { | |
87 | rwsem_release(&sem->dep_map, 1, _RET_IP_); | |
88 | return -EINTR; | |
89 | } | |
90 | ||
91 | rwsem_set_owner(sem); | |
92 | return 0; | |
93 | } | |
94 | ||
95 | EXPORT_SYMBOL(down_write_killable); | |
96 | ||
c4e05116 IM |
97 | /* |
98 | * trylock for writing -- returns 1 if successful, 0 if contention | |
99 | */ | |
100 | int down_write_trylock(struct rw_semaphore *sem) | |
101 | { | |
102 | int ret = __down_write_trylock(sem); | |
103 | ||
4fc828e2 | 104 | if (ret == 1) { |
428e6ce0 | 105 | rwsem_acquire(&sem->dep_map, 0, 1, _RET_IP_); |
4fc828e2 DB |
106 | rwsem_set_owner(sem); |
107 | } | |
108 | ||
c4e05116 IM |
109 | return ret; |
110 | } | |
111 | ||
112 | EXPORT_SYMBOL(down_write_trylock); | |
113 | ||
114 | /* | |
115 | * release a read lock | |
116 | */ | |
117 | void up_read(struct rw_semaphore *sem) | |
118 | { | |
119 | rwsem_release(&sem->dep_map, 1, _RET_IP_); | |
120 | ||
121 | __up_read(sem); | |
122 | } | |
123 | ||
124 | EXPORT_SYMBOL(up_read); | |
125 | ||
126 | /* | |
127 | * release a write lock | |
128 | */ | |
129 | void up_write(struct rw_semaphore *sem) | |
130 | { | |
131 | rwsem_release(&sem->dep_map, 1, _RET_IP_); | |
132 | ||
4fc828e2 | 133 | rwsem_clear_owner(sem); |
c4e05116 IM |
134 | __up_write(sem); |
135 | } | |
136 | ||
137 | EXPORT_SYMBOL(up_write); | |
138 | ||
139 | /* | |
140 | * downgrade write lock to read lock | |
141 | */ | |
142 | void downgrade_write(struct rw_semaphore *sem) | |
143 | { | |
6419c4af O |
144 | lock_downgrade(&sem->dep_map, _RET_IP_); |
145 | ||
19c5d690 | 146 | rwsem_set_reader_owned(sem); |
c4e05116 IM |
147 | __downgrade_write(sem); |
148 | } | |
149 | ||
150 | EXPORT_SYMBOL(downgrade_write); | |
4ea2176d IM |
151 | |
152 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | |
153 | ||
154 | void down_read_nested(struct rw_semaphore *sem, int subclass) | |
155 | { | |
156 | might_sleep(); | |
157 | rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_); | |
158 | ||
4fe87745 | 159 | LOCK_CONTENDED(sem, __down_read_trylock, __down_read); |
19c5d690 | 160 | rwsem_set_reader_owned(sem); |
4ea2176d IM |
161 | } |
162 | ||
163 | EXPORT_SYMBOL(down_read_nested); | |
164 | ||
1b963c81 JK |
165 | void _down_write_nest_lock(struct rw_semaphore *sem, struct lockdep_map *nest) |
166 | { | |
167 | might_sleep(); | |
168 | rwsem_acquire_nest(&sem->dep_map, 0, 0, nest, _RET_IP_); | |
169 | ||
170 | LOCK_CONTENDED(sem, __down_write_trylock, __down_write); | |
4fc828e2 | 171 | rwsem_set_owner(sem); |
1b963c81 JK |
172 | } |
173 | ||
174 | EXPORT_SYMBOL(_down_write_nest_lock); | |
175 | ||
84759c6d KO |
176 | void down_read_non_owner(struct rw_semaphore *sem) |
177 | { | |
178 | might_sleep(); | |
179 | ||
180 | __down_read(sem); | |
181 | } | |
182 | ||
183 | EXPORT_SYMBOL(down_read_non_owner); | |
184 | ||
4ea2176d IM |
185 | void down_write_nested(struct rw_semaphore *sem, int subclass) |
186 | { | |
187 | might_sleep(); | |
188 | rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_); | |
189 | ||
4fe87745 | 190 | LOCK_CONTENDED(sem, __down_write_trylock, __down_write); |
4fc828e2 | 191 | rwsem_set_owner(sem); |
4ea2176d IM |
192 | } |
193 | ||
194 | EXPORT_SYMBOL(down_write_nested); | |
195 | ||
887bddfa AV |
196 | int __sched down_write_killable_nested(struct rw_semaphore *sem, int subclass) |
197 | { | |
198 | might_sleep(); | |
199 | rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_); | |
200 | ||
201 | if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) { | |
202 | rwsem_release(&sem->dep_map, 1, _RET_IP_); | |
203 | return -EINTR; | |
204 | } | |
205 | ||
206 | rwsem_set_owner(sem); | |
207 | return 0; | |
208 | } | |
209 | ||
210 | EXPORT_SYMBOL(down_write_killable_nested); | |
211 | ||
84759c6d KO |
212 | void up_read_non_owner(struct rw_semaphore *sem) |
213 | { | |
214 | __up_read(sem); | |
215 | } | |
216 | ||
217 | EXPORT_SYMBOL(up_read_non_owner); | |
218 | ||
4ea2176d IM |
219 | #endif |
220 | ||
221 |