/usr/include/asterisk/sem.h is in asterisk-dev 1:13.18.3~dfsg-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | /*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2013, Digium, Inc.
*
* David M. Lee, II <dlee@digium.com>
*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU General Public License Version 2. See the LICENSE file
* at the top of the source tree.
*/
#ifndef ASTERISK_SEMAPHORE_H
#define ASTERISK_SEMAPHORE_H
/*!
* \file Asterisk semaphore API
*
* This API is a thin wrapper around the POSIX semaphore API (when available),
* so see the POSIX documentation for further details.
*/
#ifdef HAS_WORKING_SEMAPHORE
/* Working semaphore implementation detected */
#include <semaphore.h>
struct ast_sem {
sem_t real_sem;
};
#define AST_SEM_VALUE_MAX SEM_VALUE_MAX
/* These are thin wrappers; might as well inline them */
static force_inline int ast_sem_init(struct ast_sem *sem, int pshared, unsigned int value)
{
return sem_init(&sem->real_sem, pshared, value);
}
static force_inline int ast_sem_destroy(struct ast_sem *sem)
{
return sem_destroy(&sem->real_sem);
}
static force_inline int ast_sem_post(struct ast_sem *sem)
{
return sem_post(&sem->real_sem);
}
static force_inline int ast_sem_wait(struct ast_sem *sem)
{
return sem_wait(&sem->real_sem);
}
static force_inline int ast_sem_timedwait(struct ast_sem *sem, const struct timespec *abs_timeout)
{
return sem_timedwait(&sem->real_sem, abs_timeout);
}
static force_inline int ast_sem_getvalue(struct ast_sem *sem, int *sval)
{
return sem_getvalue(&sem->real_sem, sval);
}
#else
/* Unnamed semaphores don't work. Rolling our own, I guess... */
#include "asterisk/lock.h"
#include <limits.h>
struct ast_sem {
/*! Current count of this semaphore */
int count;
/*! Number of threads currently waiting for this semaphore */
int waiters;
/*! Mutual exclusion */
ast_mutex_t mutex;
/*! Condition for singalling waiters */
ast_cond_t cond;
};
#define AST_SEM_VALUE_MAX INT_MAX
/*!
* \brief Initialize a semaphore.
*
* \param sem Semaphore to initialize.
* \param pshared Pass true (nonzero) to share this thread between processes.
* Not be supported on all platforms, so be wary!
* But leave the parameter, to be compatible with the POSIX ABI
* in case we need to add support in the future.
* \param value Initial value of the semaphore.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_init(struct ast_sem *sem, int pshared, unsigned int value);
/*!
* \brief Destroy a semaphore.
*
* Destroying a semaphore that other threads are currently blocked on produces
* undefined behavior.
*
* \param sem Semaphore to destroy.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_destroy(struct ast_sem *sem);
/*!
* \brief Increments the semaphore, unblocking a waiter if necessary.
*
* \param sem Semaphore to increment.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_post(struct ast_sem *sem);
/*!
* \brief Decrements the semaphore.
*
* If the semaphore's current value is zero, this function blocks until another
* thread posts (ast_sem_post()) to the semaphore (or is interrupted by a signal
* handler, which sets errno to EINTR).
*
* \param sem Semaphore to decrement.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_wait(struct ast_sem *sem);
/*!
* \brief Decrements the semaphore, waiting until abs_timeout.
*
* If the semaphore's current value is zero, this function blocks until another
* thread posts (ast_sem_post()) to the semaphore (or is interrupted by a signal
* handler, which sets errno to EINTR).
*
* \param sem Semaphore to decrement.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_timedwait(struct ast_sem *sem, const struct timespec *abs_timeout);
/*!
* \brief Gets the current value of the semaphore.
*
* If threads are blocked on this semaphore, POSIX allows the return value to be
* either 0 or a negative number whose absolute value is the number of threads
* blocked. Don't assume that it will give you one or the other; Asterisk has
* been ported to just about everything.
*
* \param sem Semaphore to query.
* \param[out] sval Output value.
*
* \return 0 on success.
* \return -1 on error, errno set to indicate error.
*/
int ast_sem_getvalue(struct ast_sem *sem, int *sval);
#endif
#endif /* ASTERISK_SEMAPHORE_H */
|