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  */
29 
30 #include <assert.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <sys/time.h>
34 
35 #include "thr_private.h"
36 
37 /*
38  * This function is used to acquire a contested lock.
39  */
40 int
41 __thr_umtx_lock(volatile umtx_t *mtx, int timo)
42 {
43 	int v, errval, ret = 0;
44 
45 	/* contested */
46 	do {
47 		v = *mtx;
48 		if (v == 2 || atomic_cmpset_acq_int(mtx, 1, 2)) {
49 			if (timo == 0)
50 				_umtx_sleep_err(mtx, 2, timo);
51 			else if ( (errval = _umtx_sleep_err(mtx, 2, timo)) > 0) {
52 				if (errval == EAGAIN) {
53 					if (atomic_cmpset_acq_int(mtx, 0, 2))
54 						ret = 0;
55 					else
56 						ret = ETIMEDOUT;
57 					break;
58 				}
59 			}
60 		}
61 	} while (!atomic_cmpset_acq_int(mtx, 0, 2));
62 
63 	return (ret);
64 }
65 
66 void
67 __thr_umtx_unlock(volatile umtx_t *mtx)
68 {
69 	int v;
70 
71 	for (;;) {
72 		v = *mtx;
73 		if (atomic_cmpset_acq_int(mtx, v, v-1)) {
74 			if (v != 1) {
75 				*mtx = 0;
76 				_umtx_wakeup_err(mtx, 1);
77 			}
78 			break;
79 		}
80 	}
81 }
82 
83 /*
84  * Low level timed umtx lock.  This function must never return
85  * EINTR.
86  */
87 int
88 __thr_umtx_timedlock(volatile umtx_t *mtx, const struct timespec *timeout)
89 {
90 	struct timespec ts, ts2, ts3;
91 	int timo, ret;
92 
93 	if ((timeout->tv_sec < 0) ||
94 	    (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
95 	return (ETIMEDOUT);
96 
97 	/* XXX there should have MONO timer! */
98 	clock_gettime(CLOCK_REALTIME, &ts);
99 	TIMESPEC_ADD(&ts, &ts, timeout);
100 	ts2 = *timeout;
101 
102 	for (;;) {
103 		if (ts2.tv_nsec) {
104 			timo = (int)(ts2.tv_nsec / 1000);
105 			if (timo == 0)
106 				timo = 1;
107 		} else {
108 			timo = 1000000;
109 		}
110 		ret = __thr_umtx_lock(mtx, timo);
111 		if (ret != EINTR && ret != ETIMEDOUT)
112 			break;
113 		clock_gettime(CLOCK_REALTIME, &ts3);
114 		TIMESPEC_SUB(&ts2, &ts, &ts3);
115 		if (ts2.tv_sec < 0 ||
116 		    (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 
175 		if ( (errval = _umtx_sleep_err(mtx, exp, timo)) > 0) {
176 			if (errval == EBUSY) {
177 				ret = 0;
178 				break;
179 			} else if (errval == EINTR) {
180 				ret = EINTR;
181 				break;
182 			}
183 		}
184 
185 		clock_gettime(clockid, &ts3);
186 		TIMESPEC_SUB(&ts2, &ts, &ts3);
187 		if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
188 			ret = ETIMEDOUT;
189 			break;
190 		}
191 	}
192 	return (ret);
193 }
194 
195 void
196 _thr_umtx_wake(volatile umtx_t *mtx, int count)
197 {
198 	_umtx_wakeup_err(mtx, count);
199 }
200