kernel/locking/semaphore.c

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