xref: /freebsd/lib/libthr/thread/thr_sem.c (revision 262e143bd46171a6415a5b28af260a5efa2a3db8)
1 /*
2  * Copyright (C) 2005 David Xu <davidxu@freebsd.org>.
3  * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice(s), this list of conditions and the following disclaimer as
11  *    the first lines of this file unmodified other than the possible
12  *    addition of one or more copyright notices.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice(s), this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
28  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * $FreeBSD$
31  */
32 
33 #include "namespace.h"
34 #include <sys/types.h>
35 #include <sys/queue.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <pthread.h>
39 #include <semaphore.h>
40 #include <stdlib.h>
41 #include <time.h>
42 #include <_semaphore.h>
43 #include "un-namespace.h"
44 
45 #include "thr_private.h"
46 
47 
48 __weak_reference(_sem_init, sem_init);
49 __weak_reference(_sem_destroy, sem_destroy);
50 __weak_reference(_sem_getvalue, sem_getvalue);
51 __weak_reference(_sem_trywait, sem_trywait);
52 __weak_reference(_sem_wait, sem_wait);
53 __weak_reference(_sem_timedwait, sem_timedwait);
54 __weak_reference(_sem_post, sem_post);
55 
56 
57 static inline int
58 sem_check_validity(sem_t *sem)
59 {
60 
61 	if ((sem != NULL) && ((*sem)->magic == SEM_MAGIC))
62 		return (0);
63 	else {
64 		errno = EINVAL;
65 		return (-1);
66 	}
67 }
68 
69 static sem_t
70 sem_alloc(unsigned int value, semid_t semid, int system_sem)
71 {
72 	sem_t sem;
73 
74 	if (value > SEM_VALUE_MAX) {
75 		errno = EINVAL;
76 		return (NULL);
77 	}
78 
79 	sem = (sem_t)malloc(sizeof(struct sem));
80 	if (sem == NULL) {
81 		errno = ENOSPC;
82 		return (NULL);
83 	}
84 	_thr_umtx_init((umtx_t *)&sem->lock);
85 	/*
86 	 * Fortunatly count and nwaiters are adjacency, so we can
87 	 * use umtx_wait to wait on it, umtx_wait needs an address
88 	 * can be accessed as a long interger.
89 	 */
90 	sem->count = (u_int32_t)value;
91 	sem->nwaiters = 0;
92 	sem->magic = SEM_MAGIC;
93 	sem->semid = semid;
94 	sem->syssem = system_sem;
95 	return (sem);
96 }
97 
98 int
99 _sem_init(sem_t *sem, int pshared, unsigned int value)
100 {
101 	semid_t semid;
102 
103 	semid = (semid_t)SEM_USER;
104 	if ((pshared != 0) && (ksem_init(&semid, value) != 0))
105 		return (-1);
106 
107 	(*sem) = sem_alloc(value, semid, pshared);
108 	if ((*sem) == NULL) {
109 		if (pshared != 0)
110 			ksem_destroy(semid);
111 		return (-1);
112 	}
113 	return (0);
114 }
115 
116 int
117 _sem_destroy(sem_t *sem)
118 {
119 	int retval;
120 
121 	if (sem_check_validity(sem) != 0)
122 		return (-1);
123 
124 	/*
125 	 * If this is a system semaphore let the kernel track it otherwise
126 	 * make sure there are no waiters.
127 	 */
128 	if ((*sem)->syssem != 0)
129 		retval = ksem_destroy((*sem)->semid);
130 	else {
131 		retval = 0;
132 		(*sem)->magic = 0;
133 	}
134 	if (retval == 0)
135 		free(*sem);
136 	return (retval);
137 }
138 
139 int
140 _sem_getvalue(sem_t * __restrict sem, int * __restrict sval)
141 {
142 	int retval;
143 
144 	if (sem_check_validity(sem) != 0)
145 		return (-1);
146 
147 	if ((*sem)->syssem != 0)
148 		retval = ksem_getvalue((*sem)->semid, sval);
149         else {
150 		*sval = (int)(*sem)->count;
151 		retval = 0;
152 	}
153 	return (retval);
154 }
155 
156 int
157 _sem_trywait(sem_t *sem)
158 {
159 	int val;
160 
161 	if (sem_check_validity(sem) != 0)
162 		return (-1);
163 
164 	if ((*sem)->syssem != 0)
165  		return (ksem_trywait((*sem)->semid));
166 
167 	while ((val = (*sem)->count) > 0) {
168 		if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
169 			return (0);
170 	}
171 	errno = EAGAIN;
172 	return (-1);
173 }
174 
175 int
176 _sem_wait(sem_t *sem)
177 {
178 	struct pthread *curthread;
179 	int val, oldcancel, retval;
180 
181 	if (sem_check_validity(sem) != 0)
182 		return (-1);
183 
184 	curthread = _get_curthread();
185 	if ((*sem)->syssem != 0) {
186 		oldcancel = _thr_cancel_enter(curthread);
187 		retval = ksem_wait((*sem)->semid);
188 		_thr_cancel_leave(curthread, oldcancel);
189 		return (retval);
190 	}
191 
192 	_pthread_testcancel();
193 	do {
194 		while ((val = (*sem)->count) > 0) {
195 			if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
196 				return (0);
197 		}
198 		oldcancel = _thr_cancel_enter(curthread);
199 		retval = _thr_umtx_wait((umtx_t *)&(*sem)->count, 0, NULL);
200 		_thr_cancel_leave(curthread, oldcancel);
201 	} while (retval == 0);
202 	errno = retval;
203 	return (-1);
204 }
205 
206 int
207 _sem_timedwait(sem_t * __restrict sem, struct timespec * __restrict abstime)
208 {
209 	struct timespec ts, ts2;
210 	struct pthread *curthread;
211 	int val, oldcancel, retval;
212 
213 	if (sem_check_validity(sem) != 0)
214 		return (-1);
215 
216 	curthread = _get_curthread();
217 	if ((*sem)->syssem != 0) {
218 		oldcancel = _thr_cancel_enter(curthread);
219 		retval = ksem_timedwait((*sem)->semid, abstime);
220 		_thr_cancel_leave(curthread, oldcancel);
221 		return (retval);
222 	}
223 
224 	/*
225 	 * The timeout argument is only supposed to
226 	 * be checked if the thread would have blocked.
227 	 */
228 	_pthread_testcancel();
229 	do {
230 		while ((val = (*sem)->count) > 0) {
231 			if (atomic_cmpset_acq_int(&(*sem)->count, val, val - 1))
232 				return (0);
233 		}
234 		if (abstime == NULL) {
235 			errno = EINVAL;
236 			return (-1);
237 		}
238 		clock_gettime(CLOCK_REALTIME, &ts);
239 		TIMESPEC_SUB(&ts2, abstime, &ts);
240 		oldcancel = _thr_cancel_enter(curthread);
241 		retval = _thr_umtx_wait((umtx_t *)&(*sem)->count, 0, &ts2);
242 		_thr_cancel_leave(curthread, oldcancel);
243 	} while (retval == 0);
244 	errno = retval;
245 	return (-1);
246 }
247 
248 int
249 _sem_post(sem_t *sem)
250 {
251 	int val, retval;
252 
253 	if (sem_check_validity(sem) != 0)
254 		return (-1);
255 
256 	if ((*sem)->syssem != 0)
257 		return (ksem_post((*sem)->semid));
258 
259 	/*
260 	 * sem_post() is required to be safe to call from within
261 	 * signal handlers, these code should work as that.
262 	 */
263 	do {
264 		val = (*sem)->count;
265 	} while (!atomic_cmpset_acq_int(&(*sem)->count, val, val + 1));
266 	retval = _thr_umtx_wake((umtx_t *)&(*sem)->count, val + 1);
267 	if (retval > 0)
268 		retval = 0;
269 	return (retval);
270 }
271