1 /*-
2  * Copyright (c) 2005 David Xu <davidxu@freebsd.org>
3  * Copyright (c) 2005 Matthew Dillon <dillon@backplane.com>
4  *
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
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.
15  *
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
26  * SUCH DAMAGE.
27  *
28  * $DragonFly: src/lib/libthread_xu/thread/thr_umtx.c,v 1.4 2008/04/14 20:12:41 dillon Exp $
29  */
30 
31 #include <assert.h>
32 #include <errno.h>
33 #include <unistd.h>
34 #include <sys/time.h>
35 
36 #include "thr_private.h"
37 
38 /*
39  * This function is used to acquire a contested lock.
40  */
41 int
42 __thr_umtx_lock(volatile umtx_t *mtx, int timo)
43 {
44 	int v, errval, ret = 0;
45 
46 	/* contested */
47 	do {
48 		v = *mtx;
49 		if (v == 2 || atomic_cmpset_acq_int(mtx, 1, 2)) {
50 			if (timo == 0)
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))
55 						ret = 0;
56 					else
57 						ret = ETIMEDOUT;
58 					break;
59 				}
60 			}
61 		}
62 	} while (!atomic_cmpset_acq_int(mtx, 0, 2));
63 
64 	return (ret);
65 }
66 
67 void
68 __thr_umtx_unlock(volatile umtx_t *mtx)
69 {
70 	int v;
71 
72 	for (;;) {
73 		v = *mtx;
74 		if (atomic_cmpset_acq_int(mtx, v, v-1)) {
75 			if (v != 1) {
76 				*mtx = 0;
77 				_umtx_wakeup_err(mtx, 1);
78 			}
79 			break;
80 		}
81 	}
82 }
83 
84 /*
85  * Low level timed umtx lock.  This function must never return
86  * EINTR.
87  */
88 int
89 __thr_umtx_timedlock(volatile umtx_t *mtx, const struct timespec *timeout)
90 {
91     struct timespec ts, ts2, ts3;
92     int timo, ret;
93 
94     if ((timeout->tv_sec < 0) ||
95         (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
96 	return (ETIMEDOUT);
97 
98     /* XXX there should have MONO timer! */
99     clock_gettime(CLOCK_REALTIME, &ts);
100     TIMESPEC_ADD(&ts, &ts, timeout);
101     ts2 = *timeout;
102 
103     for (;;) {
104     	if (ts2.tv_nsec) {
105 	    timo = (int)(ts2.tv_nsec / 1000);
106 	    if (timo == 0)
107 		timo = 1;
108 	} else {
109 	    timo = 1000000;
110 	}
111 	ret = __thr_umtx_lock(mtx, timo);
112 	if (ret != EINTR && ret != ETIMEDOUT)
113 	    break;
114 	clock_gettime(CLOCK_REALTIME, &ts3);
115 	TIMESPEC_SUB(&ts2, &ts, &ts3);
116 	if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
117 	    ret = ETIMEDOUT;
118 	    break;
119 	}
120     }
121     return (ret);
122 }
123 
124 int
125 _thr_umtx_wait(volatile umtx_t *mtx, int exp, const struct timespec *timeout,
126 	       int clockid)
127 {
128     struct timespec ts, ts2, ts3;
129     int timo, errval, ret = 0;
130 
131     if (*mtx != exp)
132 	return (0);
133 
134     if (timeout == NULL) {
135 	while ( (errval = _umtx_sleep_err(mtx, exp, 10000000)) > 0) {
136 	    if (errval == EBUSY)
137 		break;
138 	    if (errval == EINTR) {
139 		ret = EINTR;
140 		break;
141 	    }
142 #if 0
143 	    if (errval == ETIMEDOUT || errval == EWOULDBLOCK) {
144 		if (*mtx != exp) {
145 		    fprintf(stderr,
146 			    "thr_umtx_wait: FAULT VALUE CHANGE "
147 			    "%d -> %d oncond %p\n",
148 			    exp, *mtx, mtx);
149 		}
150 	    }
151 #endif
152 	    if (*mtx != exp)
153 		return(0);
154 	}
155 	return (ret);
156     }
157 
158     if ((timeout->tv_sec < 0) ||
159         (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
160 	return (ETIMEDOUT);
161 
162     clock_gettime(clockid, &ts);
163     TIMESPEC_ADD(&ts, &ts, timeout);
164     ts2 = *timeout;
165 
166     for (;;) {
167     	if (ts2.tv_nsec) {
168 	    timo = (int)(ts2.tv_nsec / 1000);
169 	    if (timo == 0)
170 		timo = 1;
171 	} else {
172 	    timo = 1000000;
173 	}
174 	if ( (errval = _umtx_sleep_err(mtx, exp, timo)) > 0) {
175 	    if (errval == EBUSY) {
176 		ret = 0;
177 		break;
178 	    } else if (errval == EINTR) {
179 		ret = EINTR;
180 		break;
181 	    }
182 	}
183 	clock_gettime(clockid, &ts3);
184 	TIMESPEC_SUB(&ts2, &ts, &ts3);
185 	if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
186 	    ret = ETIMEDOUT;
187 	    break;
188 	}
189     }
190     return (ret);
191 }
192 
193 void _thr_umtx_wake(volatile umtx_t *mtx, int count)
194 {
195     _umtx_wakeup_err(mtx, count);
196 }
197