4dd61a307bcb72600327218462fe6b49829c5453
[dragonfly.git] / lib / libthread_xu / thread / thr_umtx.c
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, 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(mtx, 2, timo);
52                         else if (umtx_sleep(mtx, 2, timo) < 0) {
53                                 if (errno == 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(mtx, 1);
78                         }
79                         break;
80                 }
81         }
82 }
83
84 int
85 __thr_umtx_timedlock(volatile umtx_t *mtx, const struct timespec *timeout)
86 {
87     struct timespec ts, ts2, ts3;
88     int timo, ret;
89
90     if ((timeout->tv_sec < 0) ||
91         (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
92         return (ETIMEDOUT);
93
94     /* XXX there should have MONO timer! */
95     clock_gettime(CLOCK_REALTIME, &ts);
96     TIMESPEC_ADD(&ts, &ts, timeout);
97     ts2 = *timeout;
98
99     for (;;) {
100         if (ts2.tv_nsec) {
101             timo = (int)(ts2.tv_nsec / 1000);
102             if (timo == 0)
103                 timo = 1;
104         } else {
105             timo = 1000000;
106         }
107         ret = __thr_umtx_lock(mtx, timo);
108         if (ret != ETIMEDOUT)
109             break;
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)) {
113             ret = ETIMEDOUT;
114             break;
115         }
116     }
117     return (ret);
118 }
119
120 int
121 _thr_umtx_wait(volatile umtx_t *mtx, int exp, const struct timespec *timeout,
122                int clockid)
123 {
124     struct timespec ts, ts2, ts3;
125     int timo, ret = 0;
126
127     if (*mtx != exp)
128         return (0);
129
130     if (timeout == NULL) {
131         while (umtx_sleep(mtx, exp, 10000000) < 0) {
132             if (errno == EBUSY) 
133                 break;
134             if (errno == EINTR) {
135                 ret = EINTR;
136                 break;
137             }
138             if (errno == ETIMEDOUT || errno == EWOULDBLOCK) {
139                 if (*mtx != exp) {
140                     fprintf(stderr, "thr_umtx_wait: FAULT VALUE CHANGE %d -> %d oncond %p\n", exp, *mtx, mtx);
141                 }
142             }
143             if (*mtx != exp)
144                 return(0);
145         }
146         return (ret);
147     }
148
149     if ((timeout->tv_sec < 0) ||
150         (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
151         return (ETIMEDOUT);
152
153     clock_gettime(clockid, &ts);
154     TIMESPEC_ADD(&ts, &ts, timeout);
155     ts2 = *timeout;
156
157     for (;;) {
158         if (ts2.tv_nsec) {
159             timo = (int)(ts2.tv_nsec / 1000);
160             if (timo == 0)
161                 timo = 1;
162         } else {
163             timo = 1000000;
164         }
165         if (umtx_sleep(mtx, exp, timo) < 0) {
166             if (errno == EBUSY) {
167                 ret = 0;
168                 break;
169             } else if (errno == EINTR) {
170                 ret = EINTR;
171                 break;
172             }
173         }
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)) {
177             ret = ETIMEDOUT;
178             break;
179         }
180     }
181     return (ret);
182 }
183
184 void _thr_umtx_wake(volatile umtx_t *mtx, int count)
185 {
186     umtx_wakeup(mtx, count);
187 }