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