Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : * Copyright (c) 2008 Intel Corporation
4 : * Author: Matthew Wilcox <willy@linux.intel.com>
5 : *
6 : * This file implements counting semaphores.
7 : * A counting semaphore may be acquired 'n' times before sleeping.
8 : * See mutex.c for single-acquisition sleeping locks which enforce
9 : * rules which allow code to be debugged more easily.
10 : */
11 :
12 : /*
13 : * Some notes on the implementation:
14 : *
15 : * The spinlock controls access to the other members of the semaphore.
16 : * down_trylock() and up() can be called from interrupt context, so we
17 : * have to disable interrupts when taking the lock. It turns out various
18 : * parts of the kernel expect to be able to use down() on a semaphore in
19 : * interrupt context when they know it will succeed, so we have to use
20 : * irqsave variants for down(), down_interruptible() and down_killable()
21 : * too.
22 : *
23 : * The ->count variable represents how many more tasks can acquire this
24 : * semaphore. If it's zero, there may be tasks waiting on the wait_list.
25 : */
26 :
27 : #include <linux/compiler.h>
28 : #include <linux/kernel.h>
29 : #include <linux/export.h>
30 : #include <linux/sched.h>
31 : #include <linux/sched/debug.h>
32 : #include <linux/semaphore.h>
33 : #include <linux/spinlock.h>
34 : #include <linux/ftrace.h>
35 :
36 : static noinline void __down(struct semaphore *sem);
37 : static noinline int __down_interruptible(struct semaphore *sem);
38 : static noinline int __down_killable(struct semaphore *sem);
39 : static noinline int __down_timeout(struct semaphore *sem, long timeout);
40 : static noinline void __up(struct semaphore *sem);
41 :
42 : /**
43 : * down - acquire the semaphore
44 : * @sem: the semaphore to be acquired
45 : *
46 : * Acquires the semaphore. If no more tasks are allowed to acquire the
47 : * semaphore, calling this function will put the task to sleep until the
48 : * semaphore is released.
49 : *
50 : * Use of this function is deprecated, please use down_interruptible() or
51 : * down_killable() instead.
52 : */
53 3 : void down(struct semaphore *sem)
54 : {
55 : unsigned long flags;
56 :
57 : might_sleep();
58 3 : raw_spin_lock_irqsave(&sem->lock, flags);
59 3 : if (likely(sem->count > 0))
60 3 : sem->count--;
61 : else
62 0 : __down(sem);
63 6 : raw_spin_unlock_irqrestore(&sem->lock, flags);
64 3 : }
65 : EXPORT_SYMBOL(down);
66 :
67 : /**
68 : * down_interruptible - acquire the semaphore unless interrupted
69 : * @sem: the semaphore to be acquired
70 : *
71 : * Attempts to acquire the semaphore. If no more tasks are allowed to
72 : * acquire the semaphore, calling this function will put the task to sleep.
73 : * If the sleep is interrupted by a signal, this function will return -EINTR.
74 : * If the semaphore is successfully acquired, this function returns 0.
75 : */
76 0 : int down_interruptible(struct semaphore *sem)
77 : {
78 : unsigned long flags;
79 0 : int result = 0;
80 :
81 : might_sleep();
82 0 : raw_spin_lock_irqsave(&sem->lock, flags);
83 0 : if (likely(sem->count > 0))
84 0 : sem->count--;
85 : else
86 0 : result = __down_interruptible(sem);
87 0 : raw_spin_unlock_irqrestore(&sem->lock, flags);
88 :
89 0 : return result;
90 : }
91 : EXPORT_SYMBOL(down_interruptible);
92 :
93 : /**
94 : * down_killable - acquire the semaphore unless killed
95 : * @sem: the semaphore to be acquired
96 : *
97 : * Attempts to acquire the semaphore. If no more tasks are allowed to
98 : * acquire the semaphore, calling this function will put the task to sleep.
99 : * If the sleep is interrupted by a fatal signal, this function will return
100 : * -EINTR. If the semaphore is successfully acquired, this function returns
101 : * 0.
102 : */
103 0 : int down_killable(struct semaphore *sem)
104 : {
105 : unsigned long flags;
106 0 : int result = 0;
107 :
108 : might_sleep();
109 0 : raw_spin_lock_irqsave(&sem->lock, flags);
110 0 : if (likely(sem->count > 0))
111 0 : sem->count--;
112 : else
113 0 : result = __down_killable(sem);
114 0 : raw_spin_unlock_irqrestore(&sem->lock, flags);
115 :
116 0 : return result;
117 : }
118 : EXPORT_SYMBOL(down_killable);
119 :
120 : /**
121 : * down_trylock - try to acquire the semaphore, without waiting
122 : * @sem: the semaphore to be acquired
123 : *
124 : * Try to acquire the semaphore atomically. Returns 0 if the semaphore has
125 : * been acquired successfully or 1 if it cannot be acquired.
126 : *
127 : * NOTE: This return value is inverted from both spin_trylock and
128 : * mutex_trylock! Be careful about this when converting code.
129 : *
130 : * Unlike mutex_trylock, this function can be used from interrupt context,
131 : * and the semaphore can be released by any task or interrupt.
132 : */
133 293 : int down_trylock(struct semaphore *sem)
134 : {
135 : unsigned long flags;
136 : int count;
137 :
138 293 : raw_spin_lock_irqsave(&sem->lock, flags);
139 293 : count = sem->count - 1;
140 293 : if (likely(count >= 0))
141 293 : sem->count = count;
142 586 : raw_spin_unlock_irqrestore(&sem->lock, flags);
143 :
144 293 : return (count < 0);
145 : }
146 : EXPORT_SYMBOL(down_trylock);
147 :
148 : /**
149 : * down_timeout - acquire the semaphore within a specified time
150 : * @sem: the semaphore to be acquired
151 : * @timeout: how long to wait before failing
152 : *
153 : * Attempts to acquire the semaphore. If no more tasks are allowed to
154 : * acquire the semaphore, calling this function will put the task to sleep.
155 : * If the semaphore is not released within the specified number of jiffies,
156 : * this function returns -ETIME. It returns 0 if the semaphore was acquired.
157 : */
158 0 : int down_timeout(struct semaphore *sem, long timeout)
159 : {
160 : unsigned long flags;
161 0 : int result = 0;
162 :
163 : might_sleep();
164 0 : raw_spin_lock_irqsave(&sem->lock, flags);
165 0 : if (likely(sem->count > 0))
166 0 : sem->count--;
167 : else
168 0 : result = __down_timeout(sem, timeout);
169 0 : raw_spin_unlock_irqrestore(&sem->lock, flags);
170 :
171 0 : return result;
172 : }
173 : EXPORT_SYMBOL(down_timeout);
174 :
175 : /**
176 : * up - release the semaphore
177 : * @sem: the semaphore to release
178 : *
179 : * Release the semaphore. Unlike mutexes, up() may be called from any
180 : * context and even by tasks which have never called down().
181 : */
182 296 : void up(struct semaphore *sem)
183 : {
184 : unsigned long flags;
185 :
186 296 : raw_spin_lock_irqsave(&sem->lock, flags);
187 592 : if (likely(list_empty(&sem->wait_list)))
188 296 : sem->count++;
189 : else
190 0 : __up(sem);
191 592 : raw_spin_unlock_irqrestore(&sem->lock, flags);
192 296 : }
193 : EXPORT_SYMBOL(up);
194 :
195 : /* Functions for the contended case */
196 :
197 : struct semaphore_waiter {
198 : struct list_head list;
199 : struct task_struct *task;
200 : bool up;
201 : };
202 :
203 : /*
204 : * Because this function is inlined, the 'state' parameter will be
205 : * constant, and thus optimised away by the compiler. Likewise the
206 : * 'timeout' parameter for the cases without timeouts.
207 : */
208 0 : static inline int __sched __down_common(struct semaphore *sem, long state,
209 : long timeout)
210 : {
211 : struct semaphore_waiter waiter;
212 :
213 0 : list_add_tail(&waiter.list, &sem->wait_list);
214 0 : waiter.task = current;
215 0 : waiter.up = false;
216 :
217 : for (;;) {
218 0 : if (signal_pending_state(state, current))
219 : goto interrupted;
220 0 : if (unlikely(timeout <= 0))
221 : goto timed_out;
222 0 : __set_current_state(state);
223 0 : raw_spin_unlock_irq(&sem->lock);
224 0 : timeout = schedule_timeout(timeout);
225 0 : raw_spin_lock_irq(&sem->lock);
226 0 : if (waiter.up)
227 : return 0;
228 : }
229 :
230 : timed_out:
231 0 : list_del(&waiter.list);
232 0 : return -ETIME;
233 :
234 : interrupted:
235 0 : list_del(&waiter.list);
236 0 : return -EINTR;
237 : }
238 :
239 0 : static noinline void __sched __down(struct semaphore *sem)
240 : {
241 0 : __down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
242 0 : }
243 :
244 0 : static noinline int __sched __down_interruptible(struct semaphore *sem)
245 : {
246 0 : return __down_common(sem, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
247 : }
248 :
249 0 : static noinline int __sched __down_killable(struct semaphore *sem)
250 : {
251 0 : return __down_common(sem, TASK_KILLABLE, MAX_SCHEDULE_TIMEOUT);
252 : }
253 :
254 0 : static noinline int __sched __down_timeout(struct semaphore *sem, long timeout)
255 : {
256 0 : return __down_common(sem, TASK_UNINTERRUPTIBLE, timeout);
257 : }
258 :
259 0 : static noinline void __sched __up(struct semaphore *sem)
260 : {
261 0 : struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,
262 : struct semaphore_waiter, list);
263 0 : list_del(&waiter->list);
264 0 : waiter->up = true;
265 0 : wake_up_process(waiter->task);
266 0 : }
|
