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
28 * $DragonFly: src/lib/libthread_xu/thread/thr_umtx.c,v 1.4 2008/04/14 20:12:41 dillon Exp $
36 #include "thr_private.h"
39 * This function is used to acquire a contested lock.
42 __thr_umtx_lock(volatile umtx_t
*mtx
, int timo
)
44 int v
, errval
, ret
= 0;
49 if (v
== 2 || atomic_cmpset_acq_int(mtx
, 1, 2)) {
51 _umtx_sleep_err(mtx
, 2, timo
);
52 else if ( (errval
= _umtx_sleep_err(mtx
, 2, timo
)) > 0) {
53 if (errval
== EAGAIN
) {
54 if (atomic_cmpset_acq_int(mtx
, 0, 2))
62 } while (!atomic_cmpset_acq_int(mtx
, 0, 2));
68 __thr_umtx_unlock(volatile umtx_t
*mtx
)
74 if (atomic_cmpset_acq_int(mtx
, v
, v
-1)) {
77 _umtx_wakeup_err(mtx
, 1);
85 __thr_umtx_timedlock(volatile umtx_t
*mtx
, const struct timespec
*timeout
)
87 struct timespec ts
, ts2
, ts3
;
90 if ((timeout
->tv_sec
< 0) ||
91 (timeout
->tv_sec
== 0 && timeout
->tv_nsec
<= 0))
94 /* XXX there should have MONO timer! */
95 clock_gettime(CLOCK_REALTIME
, &ts
);
96 TIMESPEC_ADD(&ts
, &ts
, timeout
);
101 timo
= (int)(ts2
.tv_nsec
/ 1000);
107 ret
= __thr_umtx_lock(mtx
, timo
);
108 if (ret
!= ETIMEDOUT
)
110 clock_gettime(CLOCK_REALTIME
, &ts3
);
111 TIMESPEC_SUB(&ts2
, &ts
, &ts3
);
112 if (ts2
.tv_sec
< 0 || (ts2
.tv_sec
== 0 && ts2
.tv_nsec
<= 0)) {
121 _thr_umtx_wait(volatile umtx_t
*mtx
, int exp
, const struct timespec
*timeout
,
124 struct timespec ts
, ts2
, ts3
;
125 int timo
, errval
, ret
= 0;
130 if (timeout
== NULL
) {
131 while ( (errval
= _umtx_sleep_err(mtx
, exp
, 10000000)) > 0) {
134 if (errval
== EINTR
) {
138 if (errval
== ETIMEDOUT
|| errval
== EWOULDBLOCK
) {
140 fprintf(stderr
, "thr_umtx_wait: FAULT VALUE CHANGE %d -> %d oncond %p\n", exp
, *mtx
, mtx
);
149 if ((timeout
->tv_sec
< 0) ||
150 (timeout
->tv_sec
== 0 && timeout
->tv_nsec
<= 0))
153 clock_gettime(clockid
, &ts
);
154 TIMESPEC_ADD(&ts
, &ts
, timeout
);
159 timo
= (int)(ts2
.tv_nsec
/ 1000);
165 if ( (errval
= _umtx_sleep_err(mtx
, exp
, timo
)) > 0) {
166 if (errval
== EBUSY
) {
169 } else if (errval
== EINTR
) {
174 clock_gettime(clockid
, &ts3
);
175 TIMESPEC_SUB(&ts2
, &ts
, &ts3
);
176 if (ts2
.tv_sec
< 0 || (ts2
.tv_sec
== 0 && ts2
.tv_nsec
<= 0)) {
184 void _thr_umtx_wake(volatile umtx_t
*mtx
, int count
)
186 _umtx_wakeup_err(mtx
, count
);