kernel/locking/semaphore.c

   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 #include <trace/events/lock.h>
  36
  37 static noinline void __down(struct semaphore *sem);
  38 static noinline int __down_interruptible(struct semaphore *sem);
  39 static noinline int __down_killable(struct semaphore *sem);
  40 static noinline int __down_timeout(struct semaphore *sem, long timeout);
  41 static noinline void __up(struct semaphore *sem);
  42
  43 /**
  44  * down - acquire the semaphore
  45  * @sem: the semaphore to be acquired
  46  *
  47  * Acquires the semaphore.  If no more tasks are allowed to acquire the
  48  * semaphore, calling this function will put the task to sleep until the
  49  * semaphore is released.
  50  *
  51  * Use of this function is deprecated, please use down_interruptible() or
  52  * down_killable() instead.
  53  */
  54 void __sched down(struct semaphore *sem)
  55 {
  56         unsigned long flags;
  57
  58         might_sleep();
  59         raw_spin_lock_irqsave(&sem->lock, flags);
  60         if (likely(sem->count > 0))
  61                 sem->count--;
  62         else
  63                 __down(sem);
  64         raw_spin_unlock_irqrestore(&sem->lock, flags);
  65 }
  66 EXPORT_SYMBOL(down);
  67
  68 /**
  69  * down_interruptible - acquire the semaphore unless interrupted
  70  * @sem: the semaphore to be acquired
  71  *
  72  * Attempts to acquire the semaphore.  If no more tasks are allowed to
  73  * acquire the semaphore, calling this function will put the task to sleep.
  74  * If the sleep is interrupted by a signal, this function will return -EINTR.
  75  * If the semaphore is successfully acquired, this function returns 0.
  76  */
  77 int __sched down_interruptible(struct semaphore *sem)
  78 {
  79         unsigned long flags;
  80         int result = 0;
  81
  82         might_sleep();
  83         raw_spin_lock_irqsave(&sem->lock, flags);
  84         if (likely(sem->count > 0))
  85                 sem->count--;
  86         else
  87                 result = __down_interruptible(sem);
  88         raw_spin_unlock_irqrestore(&sem->lock, flags);
  89
  90         return result;
  91 }
  92 EXPORT_SYMBOL(down_interruptible);
  93
  94 /**
  95  * down_killable - acquire the semaphore unless killed
  96  * @sem: the semaphore to be acquired
  97  *
  98  * Attempts to acquire the semaphore.  If no more tasks are allowed to
  99  * acquire the semaphore, calling this function will put the task to sleep.
 100  * If the sleep is interrupted by a fatal signal, this function will return
 101  * -EINTR.  If the semaphore is successfully acquired, this function returns
 102  * 0.
 103  */
 104 int __sched down_killable(struct semaphore *sem)
 105 {
 106         unsigned long flags;
 107         int result = 0;
 108
 109         might_sleep();
 110         raw_spin_lock_irqsave(&sem->lock, flags);
 111         if (likely(sem->count > 0))
 112                 sem->count--;
 113         else
 114                 result = __down_killable(sem);
 115         raw_spin_unlock_irqrestore(&sem->lock, flags);
 116
 117         return result;
 118 }
 119 EXPORT_SYMBOL(down_killable);
 120
 121 /**
 122  * down_trylock - try to acquire the semaphore, without waiting
 123  * @sem: the semaphore to be acquired
 124  *
 125  * Try to acquire the semaphore atomically.  Returns 0 if the semaphore has
 126  * been acquired successfully or 1 if it cannot be acquired.
 127  *
 128  * NOTE: This return value is inverted from both spin_trylock and
 129  * mutex_trylock!  Be careful about this when converting code.
 130  *
 131  * Unlike mutex_trylock, this function can be used from interrupt context,
 132  * and the semaphore can be released by any task or interrupt.
 133  */
 134 int __sched down_trylock(struct semaphore *sem)
 135 {
 136         unsigned long flags;
 137         int count;
 138
 139         raw_spin_lock_irqsave(&sem->lock, flags);
 140         count = sem->count - 1;
 141         if (likely(count >= 0))
 142                 sem->count = count;
 143         raw_spin_unlock_irqrestore(&sem->lock, flags);
 144
 145         return (count < 0);
 146 }
 147 EXPORT_SYMBOL(down_trylock);
 148
 149 /**
 150  * down_timeout - acquire the semaphore within a specified time
 151  * @sem: the semaphore to be acquired
 152  * @timeout: how long to wait before failing
 153  *
 154  * Attempts to acquire the semaphore.  If no more tasks are allowed to
 155  * acquire the semaphore, calling this function will put the task to sleep.
 156  * If the semaphore is not released within the specified number of jiffies,
 157  * this function returns -ETIME.  It returns 0 if the semaphore was acquired.
 158  */
 159 int __sched down_timeout(struct semaphore *sem, long timeout)
 160 {
 161         unsigned long flags;
 162         int result = 0;
 163
 164         might_sleep();
 165         raw_spin_lock_irqsave(&sem->lock, flags);
 166         if (likely(sem->count > 0))
 167                 sem->count--;
 168         else
 169                 result = __down_timeout(sem, timeout);
 170         raw_spin_unlock_irqrestore(&sem->lock, flags);
 171
 172         return result;
 173 }
 174 EXPORT_SYMBOL(down_timeout);
 175
 176 /**
 177  * up - release the semaphore
 178  * @sem: the semaphore to release
 179  *
 180  * Release the semaphore.  Unlike mutexes, up() may be called from any
 181  * context and even by tasks which have never called down().
 182  */
 183 void __sched up(struct semaphore *sem)
 184 {
 185         unsigned long flags;
 186
 187         raw_spin_lock_irqsave(&sem->lock, flags);
 188         if (likely(list_empty(&sem->wait_list)))
 189                 sem->count++;
 190         else
 191                 __up(sem);
 192         raw_spin_unlock_irqrestore(&sem->lock, flags);
 193 }
 194 EXPORT_SYMBOL(up);
 195
 196 /* Functions for the contended case */
 197
 198 struct semaphore_waiter {
 199         struct list_head list;
 200         struct task_struct *task;
 201         bool up;
 202 };
 203
 204 /*
 205  * Because this function is inlined, the 'state' parameter will be
 206  * constant, and thus optimised away by the compiler.  Likewise the
 207  * 'timeout' parameter for the cases without timeouts.
 208  */
 209 static inline int __sched ___down_common(struct semaphore *sem, long state,
 210                                                                 long timeout)
 211 {
 212         struct semaphore_waiter waiter;
 213
 214         list_add_tail(&waiter.list, &sem->wait_list);
 215         waiter.task = current;
 216         waiter.up = false;
 217
 218         for (;;) {
 219                 if (signal_pending_state(state, current))
 220                         goto interrupted;
 221                 if (unlikely(timeout <= 0))
 222                         goto timed_out;
 223                 __set_current_state(state);
 224                 raw_spin_unlock_irq(&sem->lock);
 225                 timeout = schedule_timeout(timeout);
 226                 raw_spin_lock_irq(&sem->lock);
 227                 if (waiter.up)
 228                         return 0;
 229         }
 230
 231  timed_out:
 232         list_del(&waiter.list);
 233         return -ETIME;
 234
 235  interrupted:
 236         list_del(&waiter.list);
 237         return -EINTR;
 238 }
 239
 240 static inline int __sched __down_common(struct semaphore *sem, long state,
 241                                         long timeout)
 242 {
 243         int ret;
 244
 245         trace_contention_begin(sem, 0);
 246         ret = ___down_common(sem, state, timeout);
 247         trace_contention_end(sem, ret);
 248
 249         return ret;
 250 }
 251
 252 static noinline void __sched __down(struct semaphore *sem)
 253 {
 254         __down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 255 }
 256
 257 static noinline int __sched __down_interruptible(struct semaphore *sem)
 258 {
 259         return __down_common(sem, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 260 }
 261
 262 static noinline int __sched __down_killable(struct semaphore *sem)
 263 {
 264         return __down_common(sem, TASK_KILLABLE, MAX_SCHEDULE_TIMEOUT);
 265 }
 266
 267 static noinline int __sched __down_timeout(struct semaphore *sem, long timeout)
 268 {
 269         return __down_common(sem, TASK_UNINTERRUPTIBLE, timeout);
 270 }
 271
 272 static noinline void __sched __up(struct semaphore *sem)
 273 {
 274         struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,
 275                                                 struct semaphore_waiter, list);
 276         list_del(&waiter->list);
 277         waiter->up = true;
 278         wake_up_process(waiter->task);
 279 }