2 * Copyright (c) 2005 David Xu <davidxu@freebsd.org>
3 * Copyright (c) 2005 Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #include "thr_private.h"
37 #define cpu_ccfence() __asm __volatile("" : : : "memory")
40 * This function is used to acquire a contested lock.
43 __thr_umtx_lock(volatile umtx_t *mtx, int id, int timo)
57 if (atomic_fcmpset_int(mtx, &v, id))
68 * Set the waiting bit. If the fcmpset fails v is loaded
69 * with the current content of the mutex, and if the waiting
70 * bit is already set, we can also sleep.
72 if (atomic_fcmpset_int(mtx, &v, v|0x40000000) ||
75 _umtx_sleep_err(mtx, v|0x40000000, timo);
76 } else if ((errval = _umtx_sleep_err(mtx, v|0x40000000, timo)) > 0) {
77 if (errval == EAGAIN) {
78 if (atomic_cmpset_acq_int(mtx, 0, id))
92 * Inline followup when releasing a mutex. The mutex has been released
93 * but 'v' either doesn't match id or needs a wakeup.
96 __thr_umtx_unlock(volatile umtx_t *mtx, int v, int id)
99 _umtx_wakeup_err(mtx, 0);
102 THR_ASSERT(v == id, "thr_umtx_unlock: wrong owner");
106 * Low level timed umtx lock. This function must never return
110 __thr_umtx_timedlock(volatile umtx_t *mtx, int id,
111 const struct timespec *timeout)
113 struct timespec ts, ts2, ts3;
116 if ((timeout->tv_sec < 0) ||
117 (timeout->tv_sec == 0 && timeout->tv_nsec <= 0)) {
121 /* XXX there should have MONO timer! */
122 clock_gettime(CLOCK_REALTIME, &ts);
123 timespecadd(&ts, timeout, &ts);
130 timo = (int)(ts2.tv_nsec / 1000);
136 ret = __thr_umtx_lock(mtx, id, timo);
137 if (ret != EINTR && ret != ETIMEDOUT)
139 clock_gettime(CLOCK_REALTIME, &ts3);
140 timespecsub(&ts, &ts3, &ts2);
141 if (ts2.tv_sec < 0 ||
142 (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
151 * Regular umtx wait that cannot return EINTR
154 _thr_umtx_wait(volatile umtx_t *mtx, int exp, const struct timespec *timeout,
157 struct timespec ts, ts2, ts3;
158 int timo, errval, ret = 0;
164 if (timeout == NULL) {
166 * NOTE: If no timeout, EINTR cannot be returned. Ignore
169 while ((errval = _umtx_sleep_err(mtx, exp, 10000000)) > 0) {
173 if (errval == ETIMEDOUT || errval == EWOULDBLOCK) {
176 "thr_umtx_wait: FAULT VALUE CHANGE "
177 "%d -> %d oncond %p\n",
189 * Timed waits can return EINTR
191 if ((timeout->tv_sec < 0) ||
192 (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
195 clock_gettime(clockid, &ts);
196 timespecadd(&ts, timeout, &ts);
201 timo = (int)(ts2.tv_nsec / 1000);
208 if ((errval = _umtx_sleep_err(mtx, exp, timo)) > 0) {
209 if (errval == EBUSY) {
213 if (errval == EINTR) {
219 clock_gettime(clockid, &ts3);
220 timespecsub(&ts, &ts3, &ts2);
221 if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
230 * Simple version without a timeout which can also return EINTR
233 _thr_umtx_wait_intr(volatile umtx_t *mtx, int exp)
242 errval = _umtx_sleep_err(mtx, exp, 10000000);
247 if (errval == EINTR) {
257 _thr_umtx_wake(volatile umtx_t *mtx, int count)
259 _umtx_wakeup_err(mtx, count);