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             :  * Please see kernel/locking/semaphore.c for documentation of these functions
       7             :  */
       8             : #ifndef __LINUX_SEMAPHORE_H
       9             : #define __LINUX_SEMAPHORE_H
      10             : 
      11             : #include <linux/list.h>
      12             : #include <linux/spinlock.h>
      13             : 
      14             : /* Please don't access any members of this structure directly */
      15             : struct semaphore {
      16             :         raw_spinlock_t          lock;
      17             :         unsigned int            count;
      18             :         struct list_head        wait_list;
      19             : };
      20             : 
      21             : #define __SEMAPHORE_INITIALIZER(name, n)                                \
      22             : {                                                                       \
      23             :         .lock           = __RAW_SPIN_LOCK_UNLOCKED((name).lock),        \
      24             :         .count          = n,                                            \
      25             :         .wait_list      = LIST_HEAD_INIT((name).wait_list),             \
      26             : }
      27             : 
      28             : /*
      29             :  * Unlike mutexes, binary semaphores do not have an owner, so up() can
      30             :  * be called in a different thread from the one which called down().
      31             :  * It is also safe to call down_trylock() and up() from interrupt
      32             :  * context.
      33             :  */
      34             : #define DEFINE_SEMAPHORE(_name, _n)     \
      35             :         struct semaphore _name = __SEMAPHORE_INITIALIZER(_name, _n)
      36             : 
      37             : static inline void sema_init(struct semaphore *sem, int val)
      38             : {
      39             :         static struct lock_class_key __key;
      40           0 :         *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
      41             :         lockdep_init_map(&sem->lock.dep_map, "semaphore->lock", &__key, 0);
      42             : }
      43             : 
      44             : extern void down(struct semaphore *sem);
      45             : extern int __must_check down_interruptible(struct semaphore *sem);
      46             : extern int __must_check down_killable(struct semaphore *sem);
      47             : extern int __must_check down_trylock(struct semaphore *sem);
      48             : extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
      49             : extern void up(struct semaphore *sem);
      50             : 
      51             : #endif /* __LINUX_SEMAPHORE_H */