[dragonfly.git] / lib / libthread_xu / thread / thr_umtx.c

/*-
 * Copyright (c) 2005 David Xu <davidxu@freebsd.org>
 * Copyright (c) 2005 Matthew Dillon <dillon@backplane.com>
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $DragonFly: src/lib/libthread_xu/thread/thr_umtx.c,v 1.4 2008/04/14 20:12:41 dillon Exp $
 */

#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>

#include "thr_private.h"

/*
 * 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);
}

void
__thr_umtx_unlock(volatile umtx_t *mtx)
{
	int v;

	for (;;) {
		v = *mtx;
		if (atomic_cmpset_acq_int(mtx, v, v-1)) {
			if (v != 1) {
				*mtx = 0;
				_umtx_wakeup_err(mtx, 1);
			}
			break;
		}
	}
}

int
__thr_umtx_timedlock(volatile umtx_t *mtx, const struct timespec *timeout)
{
    struct timespec ts, ts2, ts3;
    int timo, ret;

    if ((timeout->tv_sec < 0) ||
        (timeout->tv_sec == 0 && timeout->tv_nsec <= 0))
	return (ETIMEDOUT);

    /* XXX there should have MONO timer! */
    clock_gettime(CLOCK_REALTIME, &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;
	}
	ret = __thr_umtx_lock(mtx, timo);
	if (ret != ETIMEDOUT)
	    break;
	clock_gettime(CLOCK_REALTIME, &ts3);
	TIMESPEC_SUB(&ts2, &ts, &ts3);
	if (ts2.tv_sec < 0 || (ts2.tv_sec == 0 && ts2.tv_nsec <= 0)) {
	    ret = ETIMEDOUT;
	    break;
	}
    }
    return (ret);
}

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;

    if (*mtx != exp)
	return (0);

    if (timeout == NULL) {
	while ( (errval = _umtx_sleep_err(mtx, exp, 10000000)) < 0) {
	    if (errval == EBUSY)
		break;
	    if (errval == EINTR) {
		ret = EINTR;
		break;
	    }
	    if (errval == ETIMEDOUT || errval == EWOULDBLOCK) {
		if (*mtx != exp) {
		    fprintf(stderr, "thr_umtx_wait: FAULT VALUE CHANGE %d -> %d oncond %p\n", exp, *mtx, mtx);
		}
	    }
	    if (*mtx != exp)
		return(0);
	}
	return (ret);
    }

    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;
	    } else 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);
}

void _thr_umtx_wake(volatile umtx_t *mtx, int count)
{
    _umtx_wakeup_err(mtx, count);
}
Commit	Line	Data
71b3fa15 DX	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	*
3db51647	28	* $DragonFly: src/lib/libthread_xu/thread/thr_umtx.c,v 1.4 2008/04/14 20:12:41 dillon Exp $
71b3fa15 DX	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
a8408233 DX	38	/*
	39	* This function is used to acquire a contested lock.
	40	*/
71b3fa15 DX	41	int
	42	__thr_umtx_lock(volatile umtx_t *mtx, int timo)
	43	{
ec7c2f67	44	int v, errval, ret = 0;
a8408233 DX	45
	46	/* contested */
	47	do {
	48	v = *mtx;
	49	if (v == 2 \|\| atomic_cmpset_acq_int(mtx, 1, 2)) {
	50	if (timo == 0)
ec7c2f67 MD	51	_umtx_sleep_err(mtx, 2, timo);
	52	else if ( (errval = _umtx_sleep_err(mtx, 2, timo)) != 0) {
	53	if (errval == EAGAIN) {
a8408233 DX	54	if (atomic_cmpset_acq_int(mtx, 0, 2))
	55	ret = 0;
	56	else
	57	ret = ETIMEDOUT;
	58	break;
	59	}
	60	}
71b3fa15	61	}
a8408233	62	} while (!atomic_cmpset_acq_int(mtx, 0, 2));
71b3fa15	63
a8408233	64	return (ret);
71b3fa15 DX	65	}
	66
	67	void
	68	__thr_umtx_unlock(volatile umtx_t *mtx)
	69	{
a8408233 DX	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;
ec7c2f67	77	_umtx_wakeup_err(mtx, 1);
a8408233 DX	78	}
	79	break;
	80	}
71b3fa15	81	}
71b3fa15 DX	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
9219c44c	121	_thr_umtx_wait(volatile umtx_t mtx, int exp, const struct timespec timeout,
3db51647	122	int clockid)
71b3fa15 DX	123	{
71b3fa15 DX	124	struct timespec ts, ts2, ts3;
ec7c2f67	125	int timo, errval, ret = 0;
71b3fa15 DX	126
	127	if (*mtx != exp)
	128	return (0);
	129
	130	if (timeout == NULL) {
ec7c2f67 MD	131	while ( (errval = _umtx_sleep_err(mtx, exp, 10000000)) < 0) {
ec7c2f67 MD	132	if (errval == EBUSY)
3db51647	133	break;
ec7c2f67	134	if (errval == EINTR) {
71b3fa15	135	ret = EINTR;
3db51647 MD	136	break;
3db51647 MD	137	}
ec7c2f67	138	if (errval == ETIMEDOUT \|\| errval == EWOULDBLOCK) {
3db51647 MD	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);
71b3fa15 DX	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
9219c44c	153	clock_gettime(clockid, &ts);
71b3fa15 DX	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	}
ec7c2f67 MD	165	if ( (errval = _umtx_sleep_err(mtx, exp, timo)) < 0) {
ec7c2f67 MD	166	if (errval == EBUSY) {
71b3fa15 DX	167	ret = 0;
71b3fa15 DX	168	break;
ec7c2f67	169	} else if (errval == EINTR) {
71b3fa15 DX	170	ret = EINTR;
	171	break;
	172	}
	173	}
9219c44c	174	clock_gettime(clockid, &ts3);
71b3fa15 DX	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	{
ec7c2f67	186	_umtx_wakeup_err(mtx, count);
71b3fa15	187	}