/*
* This function is used to acquire a contested lock.
*/
int
__thr_umtx_lock(volatile umtx_t *mtx, int timo)
{
int v, errval, ret = 0;
/* contested */
do {
v = *mtx;
if (v == 2 || atomic_cmpset_acq_int(mtx, 1, 2)) {
if (timo == 0)
_umtx_sleep_err(mtx, 2, timo);
else if ( (errval = _umtx_sleep_err(mtx, 2, timo)) > 0) {
if (errval == EAGAIN) {
if (atomic_cmpset_acq_int(mtx, 0, 2))
ret = 0;
else
ret = ETIMEDOUT;
break;
}
}
}
} while (!atomic_cmpset_acq_int(mtx, 0, 2));
return (ret);
}
/*
* This function is used to acquire a contested lock.
*
* A *mtx value of 1 indicates locked normally.
* A *mtx value of 2 indicates locked and contested.
*/
int
__thr_umtx_lock(volatile umtx_t *mtx, int id, int timo)
{
int v;
int errval;
int ret = 0;
int retry = 4;
v = *mtx;
cpu_ccfence();
id &= 0x3FFFFFFF;
for (;;) {
cpu_pause();
if (v == 0) {
if (atomic_fcmpset_int(mtx, &v, id))
break;
continue;
}
if (--retry) {
sched_yield();
v = *mtx;
continue;
}
/*
* Set the waiting bit. If the fcmpset fails v is loaded
* with the current content of the mutex, and if the waiting
* bit is already set, we can also sleep.
*/
if (atomic_fcmpset_int(mtx, &v, v|0x40000000) ||
(v & 0x40000000)) {
if (timo == 0) {
_umtx_sleep_err(mtx, v|0x40000000, timo);
} else if ((errval = _umtx_sleep_err(mtx, v|0x40000000, timo)) > 0) {
if (errval == EAGAIN) {
if (atomic_cmpset_acq_int(mtx, 0, id))
ret = 0;
else
ret = ETIMEDOUT;
break;
}
}
}
retry = 4;
}
return (ret);
}
/*
* Simple version without a timeout which can also return EINTR
*/
int
_thr_umtx_wait_intr(volatile umtx_t *mtx, int exp)
{
int ret = 0;
int errval;
cpu_ccfence();
for (;;) {
if (*mtx != exp)
return (0);
errval = _umtx_sleep_err(mtx, exp, 10000000);
if (errval == 0)
break;
if (errval == EBUSY)
break;
if (errval == EINTR) {
ret = errval;
break;
}
cpu_ccfence();
}
return (ret);
}
/*
* Regular umtx wait that cannot return EINTR
*/
int
_thr_umtx_wait(volatile umtx_t *mtx, int exp, const struct timespec *timeout,
int clockid)
{
struct timespec ts, ts2, ts3;
int timo, errval, ret = 0;
cpu_ccfence();
if (*mtx != exp)
return (0);
if (timeout == NULL) {
/*
* NOTE: If no timeout, EINTR cannot be returned. Ignore
* EINTR.
*/
while ((errval = _umtx_sleep_err(mtx, exp, 10000000)) > 0) {
if (errval == EBUSY)
break;
#if 0
if (errval == ETIMEDOUT || errval == EWOULDBLOCK) {
if (*mtx != exp) {
fprintf(stderr,
"thr_umtx_wait: FAULT VALUE CHANGE "
"%d -> %d oncond %p\n",
exp, *mtx, mtx);
}
}
#endif
if (*mtx != exp)
return(0);
}
return (ret);
}
/*
* Timed waits can return EINTR
*/
if ((timeout->tv_sec < 0) ||
(timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
return (ETIMEDOUT);
clock_gettime(clockid, &ts);
TIMESPEC_ADD(&ts, &ts, timeout);
ts2 = *timeout;
for (;;) {
if (ts2.tv_nsec) {
timo = (int)(ts2.tv_nsec / 1000);
if (timo == 0)
timo = 1;
} else {
timo = 1000000;
}
if ((errval = _umtx_sleep_err(mtx, exp, timo)) > 0) {
if (errval == EBUSY) {
ret = 0;
break;
}
if (errval == EINTR) {
ret = EINTR;
break;
}
}
clock_gettime(clockid, &ts3);
TIMESPEC_SUB(&ts2, &ts, &ts3);
if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
ret = ETIMEDOUT;
break;
}
}
return (ret);
}
