PERFORCE change 100183 for review
Kip Macy
kmacy at FreeBSD.org
Wed Jun 28 03:54:44 UTC 2006
http://perforce.freebsd.org/chv.cgi?CH=100183
Change 100183 by kmacy at kmacy_storage:sun4v_work_sleepq on 2006/06/28 03:54:19
rename sx to sxu
add condition variable for drain waiter
Affected files ...
.. //depot/projects/kmacy_sun4v/src/sys/kern/kern_sxu.c#3 edit
.. //depot/projects/kmacy_sun4v/src/sys/sys/sxu.h#2 edit
Differences ...
==== //depot/projects/kmacy_sun4v/src/sys/kern/kern_sxu.c#3 (text+ko) ====
@@ -54,11 +54,11 @@
#include <ddb/ddb.h>
#ifdef DDB
-static void db_show_sx(struct lock_object *lock);
+static void db_show_sxu(struct lock_object *lock);
#endif
-struct lock_class lock_class_sx = {
- "sx",
+struct lock_class lock_class_sxu = {
+ "sxu",
LC_SLEEPLOCK | LC_SLEEPABLE | LC_RECURSABLE | LC_UPGRADABLE,
#ifdef DDB
db_show_sx
@@ -66,52 +66,52 @@
};
#ifndef INVARIANTS
-#define _sx_assert(sx, what, file, line)
+#define _sxu_assert(sx, what, file, line)
#endif
void
-sx_sysinit(void *arg)
+sxu_sysinit(void *arg)
{
- struct sx_args *sargs = arg;
+ struct sxu_args *sargs = arg;
- sx_init(sargs->sa_sx, sargs->sa_desc);
+ sxu_init(sargs->sa_sxu, sargs->sa_desc);
}
void
-sx_init(struct sx *sx, const char *description)
+sxu_init(struct sxu *sx, const char *description)
{
- sx->sx_lock = mtx_pool_find(mtxpool_lockbuilder, sx);
- sx->sx_cnt = 0;
- cv_init(&sx->sx_shrd_cv, description);
- sx->sx_shrd_wcnt = 0;
- cv_init(&sx->sx_excl_cv, description);
- sx->sx_excl_wcnt = 0;
- sx->sx_xholder = NULL;
+ sx->sxu_lock = mtx_pool_find(mtxpool_lockbuilder, sx);
+ sx->sxu_cnt = 0;
+ cv_init(&sx->sxu_shrd_cv, description);
+ sx->sxu_shrd_wcnt = 0;
+ cv_init(&sx->sxu_excl_cv, description);
+ sx->sxu_excl_wcnt = 0;
+ sx->sxu_xholder = NULL;
- lock_profile_init(&sx->sx_object, description);
- lock_init(&sx->sx_object, &lock_class_sx, description, NULL,
+ lock_profile_init(&sx->sxu_object, description);
+ lock_init(&sx->sxu_object, &lock_class_sxu, description, NULL,
LO_WITNESS | LO_RECURSABLE | LO_SLEEPABLE | LO_UPGRADABLE);
}
void
-sx_destroy(struct sx *sx)
+sxu_destroy(struct sxu *sx)
{
- KASSERT((sx->sx_cnt == 0 && sx->sx_shrd_wcnt == 0 && sx->sx_excl_wcnt ==
+ KASSERT((sx->sxu_cnt == 0 && sx->sxu_shrd_wcnt == 0 && sx->sxu_excl_wcnt ==
0), ("%s (%s): holders or waiters\n", __func__,
- sx->sx_object.lo_name));
+ sx->sxu_object.lo_name));
- sx->sx_lock = NULL;
- cv_destroy(&sx->sx_shrd_cv);
- cv_destroy(&sx->sx_excl_cv);
+ sx->sxu_lock = NULL;
+ cv_destroy(&sx->sxu_shrd_cv);
+ cv_destroy(&sx->sxu_excl_cv);
- lock_profile_destroy(&sx->sx_object);
- lock_destroy(&sx->sx_object);
+ lock_profile_destroy(&sx->sxu_object);
+ lock_destroy(&sx->sxu_object);
}
int
-_sx_slock(struct sx *sx, int timo, const char *file, int line)
+_sxu_slock(struct sxu *sx, int timo, const char *file, int line)
{
int contested, error;
@@ -120,64 +120,64 @@
waittime = 0;
error = 0;
- mtx_lock(sx->sx_lock);
- KASSERT(sx->sx_xholder != curthread,
+ mtx_lock(sx->sxu_lock);
+ KASSERT(sx->sxu_xholder != curthread,
("%s (%s): slock while xlock is held @ %s:%d\n", __func__,
- sx->sx_object.lo_name, file, line));
- WITNESS_CHECKORDER(&sx->sx_object, LOP_NEWORDER, file, line);
+ sx->sxu_object.lo_name, file, line));
+ WITNESS_CHECKORDER(&sx->sxu_object, LOP_NEWORDER, file, line);
/*
* Loop in case we lose the race for lock acquisition.
*/
- if (sx->sx_cnt < 0)
+ if (sx->sxu_cnt < 0)
lock_profile_waitstart(&waittime);
- while (sx->sx_cnt < 0) {
- sx->sx_shrd_wcnt++;
- lock_profile_obtain_lock_failed(&sx->sx_object, &contested);
+ while (sx->sxu_cnt < 0) {
+ sx->sxu_shrd_wcnt++;
+ lock_profile_obtain_lock_failed(&sx->sxu_object, &contested);
if (timo)
- error = cv_timedwait(&sx->sx_shrd_cv, sx->sx_lock, timo);
+ error = cv_timedwait(&sx->sxu_shrd_cv, sx->sxu_lock, timo);
else
- cv_wait(&sx->sx_shrd_cv, sx->sx_lock);
- sx->sx_shrd_wcnt--;
+ cv_wait(&sx->sxu_shrd_cv, sx->sxu_lock);
+ sx->sxu_shrd_wcnt--;
if (error)
goto fail;
}
/* Acquire a shared lock. */
- sx->sx_cnt++;
+ sx->sxu_cnt++;
- if (sx->sx_cnt == 1)
- lock_profile_obtain_lock_success(&sx->sx_object, waittime, file, line);
+ if (sx->sxu_cnt == 1)
+ lock_profile_obtain_lock_success(&sx->sxu_object, waittime, file, line);
- LOCK_LOG_LOCK("SLOCK", &sx->sx_object, 0, 0, file, line);
- WITNESS_LOCK(&sx->sx_object, 0, file, line);
+ LOCK_LOG_LOCK("SLOCK", &sx->sxu_object, 0, 0, file, line);
+ WITNESS_LOCK(&sx->sxu_object, 0, file, line);
fail:
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
return (error);
}
int
-_sx_try_slock(struct sx *sx, const char *file, int line)
+_sxu_try_slock(struct sxu *sx, const char *file, int line)
{
- mtx_lock(sx->sx_lock);
- if (sx->sx_cnt >= 0) {
- sx->sx_cnt++;
- LOCK_LOG_TRY("SLOCK", &sx->sx_object, 0, 1, file, line);
- WITNESS_LOCK(&sx->sx_object, LOP_TRYLOCK, file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_lock(sx->sxu_lock);
+ if (sx->sxu_cnt >= 0) {
+ sx->sxu_cnt++;
+ LOCK_LOG_TRY("SLOCK", &sx->sxu_object, 0, 1, file, line);
+ WITNESS_LOCK(&sx->sxu_object, LOP_TRYLOCK, file, line);
+ mtx_unlock(sx->sxu_lock);
return (1);
} else {
- LOCK_LOG_TRY("SLOCK", &sx->sx_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ LOCK_LOG_TRY("SLOCK", &sx->sxu_object, 0, 0, file, line);
+ mtx_unlock(sx->sxu_lock);
return (0);
}
}
int
-_sx_xlock(struct sx *sx, int timo, const char *file, int line)
+_sxu_xlock(struct sxu *sx, int timo, const char *file, int line)
{
int contested, error;
@@ -186,7 +186,7 @@
error = 0;
waittime= 0;
- mtx_lock(sx->sx_lock);
+ mtx_lock(sx->sxu_lock);
/*
* With sx locks, we're absolutely not permitted to recurse on
@@ -195,74 +195,74 @@
* xlock while in here, we consider it API abuse and put it under
* INVARIANTS.
*/
- KASSERT(sx->sx_xholder != curthread,
+ KASSERT(sx->sxu_xholder != curthread,
("%s (%s): xlock already held @ %s:%d", __func__,
- sx->sx_object.lo_name, file, line));
- WITNESS_CHECKORDER(&sx->sx_object, LOP_NEWORDER | LOP_EXCLUSIVE, file,
+ sx->sxu_object.lo_name, file, line));
+ WITNESS_CHECKORDER(&sx->sxu_object, LOP_NEWORDER | LOP_EXCLUSIVE, file,
line);
/* Loop in case we lose the race for lock acquisition. */
- if (sx->sx_cnt)
+ if (sx->sxu_cnt)
lock_profile_waitstart(&waittime);
- while (sx->sx_cnt != 0) {
- sx->sx_excl_wcnt++;
- lock_profile_obtain_lock_failed(&sx->sx_object, &contested);
+ while (sx->sxu_cnt != 0) {
+ sx->sxu_excl_wcnt++;
+ lock_profile_obtain_lock_failed(&sx->sxu_object, &contested);
if (timo)
- error = cv_timedwait(&sx->sx_excl_cv, sx->sx_lock, timo);
+ error = cv_timedwait(&sx->sxu_excl_cv, sx->sxu_lock, timo);
else
- cv_wait(&sx->sx_excl_cv, sx->sx_lock);
- sx->sx_excl_wcnt--;
+ cv_wait(&sx->sxu_excl_cv, sx->sxu_lock);
+ sx->sxu_excl_wcnt--;
if (error)
goto fail;
}
- MPASS(sx->sx_cnt == 0);
+ MPASS(sx->sxu_cnt == 0);
/* Acquire an exclusive lock. */
- sx->sx_cnt--;
- sx->sx_xholder = curthread;
+ sx->sxu_cnt--;
+ sx->sxu_xholder = curthread;
- lock_profile_obtain_lock_success(&sx->sx_object, waittime, file, line);
- LOCK_LOG_LOCK("XLOCK", &sx->sx_object, 0, 0, file, line);
- WITNESS_LOCK(&sx->sx_object, LOP_EXCLUSIVE, file, line);
+ lock_profile_obtain_lock_success(&sx->sxu_object, waittime, file, line);
+ LOCK_LOG_LOCK("XLOCK", &sx->sxu_object, 0, 0, file, line);
+ WITNESS_LOCK(&sx->sxu_object, LOP_EXCLUSIVE, file, line);
fail:
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
return (error);
}
int
-_sx_try_xlock(struct sx *sx, const char *file, int line)
+_sxu_try_xlock(struct sxu *sx, const char *file, int line)
{
- mtx_lock(sx->sx_lock);
- if (sx->sx_cnt == 0) {
- sx->sx_cnt--;
- sx->sx_xholder = curthread;
- LOCK_LOG_TRY("XLOCK", &sx->sx_object, 0, 1, file, line);
- WITNESS_LOCK(&sx->sx_object, LOP_EXCLUSIVE | LOP_TRYLOCK, file,
+ mtx_lock(sx->sxu_lock);
+ if (sx->sxu_cnt == 0) {
+ sx->sxu_cnt--;
+ sx->sxu_xholder = curthread;
+ LOCK_LOG_TRY("XLOCK", &sx->sxu_object, 0, 1, file, line);
+ WITNESS_LOCK(&sx->sxu_object, LOP_EXCLUSIVE | LOP_TRYLOCK, file,
line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
return (1);
} else {
- LOCK_LOG_TRY("XLOCK", &sx->sx_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ LOCK_LOG_TRY("XLOCK", &sx->sxu_object, 0, 0, file, line);
+ mtx_unlock(sx->sxu_lock);
return (0);
}
}
void
-_sx_sunlock(struct sx *sx, const char *file, int line)
+_sxu_sunlock(struct sxu *sx, const char *file, int line)
{
- _sx_assert(sx, SX_SLOCKED, file, line);
- mtx_lock(sx->sx_lock);
+ _sxu_assert(sx, SXU_SLOCKED, file, line);
+ mtx_lock(sx->sxu_lock);
- WITNESS_UNLOCK(&sx->sx_object, 0, file, line);
+ WITNESS_UNLOCK(&sx->sxu_object, 0, file, line);
/* Release. */
- sx->sx_cnt--;
+ sx->sxu_cnt--;
/*
* If we just released the last shared lock, wake any waiters up, giving
@@ -270,143 +270,143 @@
* lockers won't be blocked forever, don't wake shared lock waiters if
* there are exclusive lock waiters.
*/
- if (sx->sx_cnt == 0)
- lock_profile_release_lock(&sx->sx_object);
+ if (sx->sxu_cnt == 0)
+ lock_profile_release_lock(&sx->sxu_object);
- if (sx->sx_excl_wcnt > 0) {
- if (sx->sx_cnt == 0)
- cv_signal(&sx->sx_excl_cv);
- } else if (sx->sx_shrd_wcnt > 0) /* XXX why would shrd_wcnt be > 0 if the holder is shared? */
- cv_broadcast(&sx->sx_shrd_cv);
+ if (sx->sxu_excl_wcnt > 0) {
+ if (sx->sxu_cnt == 0)
+ cv_signal(&sx->sxu_excl_cv);
+ } else if (sx->sxu_shrd_wcnt > 0) /* XXX why would shrd_wcnt be > 0 if the holder is shared? */
+ cv_broadcast(&sx->sxu_shrd_cv);
- LOCK_LOG_LOCK("SUNLOCK", &sx->sx_object, 0, 0, file, line);
+ LOCK_LOG_LOCK("SUNLOCK", &sx->sxu_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
}
void
-_sx_xunlock(struct sx *sx, const char *file, int line)
+_sxu_xunlock(struct sxu *sx, const char *file, int line)
{
- _sx_assert(sx, SX_XLOCKED, file, line);
- mtx_lock(sx->sx_lock);
- MPASS(sx->sx_cnt == -1);
+ _sxu_assert(sx, SXU_XLOCKED, file, line);
+ mtx_lock(sx->sxu_lock);
+ MPASS(sx->sxu_cnt == -1);
- WITNESS_UNLOCK(&sx->sx_object, LOP_EXCLUSIVE, file, line);
+ WITNESS_UNLOCK(&sx->sxu_object, LOP_EXCLUSIVE, file, line);
/* Release. */
- sx->sx_cnt++;
- sx->sx_xholder = NULL;
+ sx->sxu_cnt++;
+ sx->sxu_xholder = NULL;
- lock_profile_release_lock(&sx->sx_object);
+ lock_profile_release_lock(&sx->sxu_object);
/*
* Wake up waiters if there are any. Give precedence to slock waiters.
*/
- if (sx->sx_shrd_wcnt > 0)
- cv_broadcast(&sx->sx_shrd_cv);
- else if (sx->sx_excl_wcnt > 0)
- cv_signal(&sx->sx_excl_cv);
+ if (sx->sxu_shrd_wcnt > 0)
+ cv_broadcast(&sx->sxu_shrd_cv);
+ else if (sx->sxu_excl_wcnt > 0)
+ cv_signal(&sx->sxu_excl_cv);
- LOCK_LOG_LOCK("XUNLOCK", &sx->sx_object, 0, 0, file, line);
+ LOCK_LOG_LOCK("XUNLOCK", &sx->sxu_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
}
int
-_sx_try_upgrade(struct sx *sx, const char *file, int line)
+_sxu_try_upgrade(struct sxu *sx, const char *file, int line)
{
- _sx_assert(sx, SX_SLOCKED, file, line);
- mtx_lock(sx->sx_lock);
+ _sxu_assert(sx, SXU_SLOCKED, file, line);
+ mtx_lock(sx->sxu_lock);
- if (sx->sx_cnt == 1) {
- sx->sx_cnt = -1;
- sx->sx_xholder = curthread;
+ if (sx->sxu_cnt == 1) {
+ sx->sxu_cnt = -1;
+ sx->sxu_xholder = curthread;
- LOCK_LOG_TRY("XUPGRADE", &sx->sx_object, 0, 1, file, line);
- WITNESS_UPGRADE(&sx->sx_object, LOP_EXCLUSIVE | LOP_TRYLOCK,
+ LOCK_LOG_TRY("XUPGRADE", &sx->sxu_object, 0, 1, file, line);
+ WITNESS_UPGRADE(&sx->sxu_object, LOP_EXCLUSIVE | LOP_TRYLOCK,
file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
return (1);
} else {
- LOCK_LOG_TRY("XUPGRADE", &sx->sx_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ LOCK_LOG_TRY("XUPGRADE", &sx->sxu_object, 0, 0, file, line);
+ mtx_unlock(sx->sxu_lock);
return (0);
}
}
void
-_sx_downgrade(struct sx *sx, const char *file, int line)
+_sxu_downgrade(struct sxu *sx, const char *file, int line)
{
- _sx_assert(sx, SX_XLOCKED, file, line);
- mtx_lock(sx->sx_lock);
- MPASS(sx->sx_cnt == -1);
+ _sxu_assert(sx, SXU_XLOCKED, file, line);
+ mtx_lock(sx->sxu_lock);
+ MPASS(sx->sxu_cnt == -1);
- WITNESS_DOWNGRADE(&sx->sx_object, 0, file, line);
+ WITNESS_DOWNGRADE(&sx->sxu_object, 0, file, line);
- sx->sx_cnt = 1;
- sx->sx_xholder = NULL;
- if (sx->sx_shrd_wcnt > 0)
- cv_broadcast(&sx->sx_shrd_cv);
+ sx->sxu_cnt = 1;
+ sx->sxu_xholder = NULL;
+ if (sx->sxu_shrd_wcnt > 0)
+ cv_broadcast(&sx->sxu_shrd_cv);
- LOCK_LOG_LOCK("XDOWNGRADE", &sx->sx_object, 0, 0, file, line);
+ LOCK_LOG_LOCK("XDOWNGRADE", &sx->sxu_object, 0, 0, file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
}
#ifdef INVARIANT_SUPPORT
#ifndef INVARIANTS
-#undef _sx_assert
+#undef _sxu_assert
#endif
/*
- * In the non-WITNESS case, sx_assert() can only detect that at least
+ * In the non-WITNESS case, sxu_assert() can only detect that at least
* *some* thread owns an slock, but it cannot guarantee that *this*
* thread owns an slock.
*/
void
-_sx_assert(struct sx *sx, int what, const char *file, int line)
+_sxu_assert(struct sxu *sx, int what, const char *file, int line)
{
if (panicstr != NULL)
return;
switch (what) {
- case SX_LOCKED:
- case SX_SLOCKED:
+ case SXU_LOCKED:
+ case SXU_SLOCKED:
#ifdef WITNESS
- witness_assert(&sx->sx_object, what, file, line);
+ witness_assert(&sx->sxu_object, what, file, line);
#else
- mtx_lock(sx->sx_lock);
- if (sx->sx_cnt <= 0 &&
- (what == SX_SLOCKED || sx->sx_xholder != curthread))
+ mtx_lock(sx->sxu_lock);
+ if (sx->sxu_cnt <= 0 &&
+ (what == SXU_SLOCKED || sx->sxu_xholder != curthread))
panic("Lock %s not %slocked @ %s:%d\n",
- sx->sx_object.lo_name, (what == SX_SLOCKED) ?
+ sx->sxu_object.lo_name, (what == SXU_SLOCKED) ?
"share " : "", file, line);
- mtx_unlock(sx->sx_lock);
+ mtx_unlock(sx->sxu_lock);
#endif
break;
- case SX_XLOCKED:
- mtx_lock(sx->sx_lock);
- if (sx->sx_xholder != curthread)
+ case SXU_XLOCKED:
+ mtx_lock(sx->sxu_lock);
+ if (sx->sxu_xholder != curthread)
panic("Lock %s not exclusively locked @ %s:%d\n",
- sx->sx_object.lo_name, file, line);
- mtx_unlock(sx->sx_lock);
+ sx->sxu_object.lo_name, file, line);
+ mtx_unlock(sx->sxu_lock);
break;
- case SX_UNLOCKED:
+ case SXU_UNLOCKED:
#ifdef WITNESS
- witness_assert(&sx->sx_object, what, file, line);
+ witness_assert(&sx->sxu_object, what, file, line);
#else
/*
* We are able to check only exclusive lock here,
* we cannot assert that *this* thread owns slock.
*/
- mtx_lock(sx->sx_lock);
- if (sx->sx_xholder == curthread)
+ mtx_lock(sx->sxu_lock);
+ if (sx->sxu_xholder == curthread)
panic("Lock %s exclusively locked @ %s:%d\n",
- sx->sx_object.lo_name, file, line);
- mtx_unlock(sx->sx_lock);
+ sx->sxu_object.lo_name, file, line);
+ mtx_unlock(sx->sxu_lock);
#endif
break;
default:
@@ -418,23 +418,23 @@
#ifdef DDB
void
-db_show_sx(struct lock_object *lock)
+db_show_sxu(struct lock_object *lock)
{
struct thread *td;
- struct sx *sx;
+ struct sxu *sx;
- sx = (struct sx *)lock;
+ sx = (struct sxu *)lock;
db_printf(" state: ");
- if (sx->sx_cnt < 0) {
- td = sx->sx_xholder;
+ if (sx->sxu_cnt < 0) {
+ td = sx->sxu_xholder;
db_printf("XLOCK: %p (tid %d, pid %d, \"%s\")\n", td,
td->td_tid, td->td_proc->p_pid, td->td_proc->p_comm);
- } else if (sx->sx_cnt > 0)
- db_printf("SLOCK: %d locks\n", sx->sx_cnt);
+ } else if (sx->sxu_cnt > 0)
+ db_printf("SLOCK: %d locks\n", sx->sxu_cnt);
else
db_printf("UNLOCKED\n");
- db_printf(" waiters: %d shared, %d exclusive\n", sx->sx_shrd_wcnt,
- sx->sx_excl_wcnt);
+ db_printf(" waiters: %d shared, %d exclusive\n", sx->sxu_shrd_wcnt,
+ sx->sxu_excl_wcnt);
}
#endif
==== //depot/projects/kmacy_sun4v/src/sys/sys/sxu.h#2 (text+ko) ====
@@ -34,35 +34,36 @@
#include <sys/_lock.h>
#include <sys/condvar.h> /* XXX */
-struct sx {
- struct lock_object sx_object; /* Common lock properties. */
- struct mtx *sx_lock; /* General protection lock. */
- int sx_cnt; /* -1: xlock, > 0: slock count. */
- struct cv sx_shrd_cv; /* slock waiters. */
- int sx_shrd_wcnt; /* Number of slock waiters. */
- struct cv sx_excl_cv; /* xlock waiters. */
- int sx_excl_wcnt; /* Number of xlock waiters. */
- struct thread *sx_xholder; /* Thread presently holding xlock. */
+struct sxu {
+ struct lock_object sxu_object; /* Common lock properties. */
+ struct mtx *sxu_lock; /* General protection lock. */
+ int sxu_cnt; /* -1: xlock, > 0: slock count. */
+ struct cv sxu_shrd_cv; /* slock waiters. */
+ int sxu_shrd_wcnt; /* Number of slock waiters. */
+ struct cv sxu_excl_cv; /* xlock waiters. */
+ int sxu_excl_wcnt; /* Number of xlock waiters. */
+ struct thread *sxu_xholder; /* Thread presently holding xlock. */
+ struct cv sxu_drain_cv; /* drain waiter. */
};
#ifdef _KERNEL
-void sx_sysinit(void *arg);
-void sx_init(struct sx *sx, const char *description);
-void sx_destroy(struct sx *sx);
-void _sx_slock(struct sx *sx, const char *file, int line);
-void _sx_xlock(struct sx *sx, const char *file, int line);
-int _sx_try_slock(struct sx *sx, const char *file, int line);
-int _sx_try_xlock(struct sx *sx, const char *file, int line);
-void _sx_sunlock(struct sx *sx, const char *file, int line);
-void _sx_xunlock(struct sx *sx, const char *file, int line);
-int _sx_try_upgrade(struct sx *sx, const char *file, int line);
-void _sx_downgrade(struct sx *sx, const char *file, int line);
+void sxu_sysinit(void *arg);
+void sxu_init(struct sxu *sx, const char *description);
+void sxu_destroy(struct sxu *sx);
+void _sxu_slock(struct sxu *sx, int timo, const char *file, int line);
+void _sxu_xlock(struct sxu *sx, int timo, const char *file, int line);
+int _sxu_try_slock(struct sxu *sx, const char *file, int line);
+int _sxu_try_xlock(struct sxu *sx, const char *file, int line);
+void _sxu_sunlock(struct sxu *sx, const char *file, int line);
+void _sxu_xunlock(struct sxu *sx, const char *file, int line);
+int _sxu_try_upgrade(struct sxu *sx, const char *file, int line);
+void _sxu_downgrade(struct sxu *sx, const char *file, int line);
#ifdef INVARIANT_SUPPORT
-void _sx_assert(struct sx *sx, int what, const char *file, int line);
+void _sxu_assert(struct sxu *sxu, int what, const char *file, int line);
#endif
struct sx_args {
- struct sx *sa_sx;
+ struct sxu *sa_sxu;
const char *sa_desc;
};
@@ -71,24 +72,26 @@
(sxa), \
(desc) \
}; \
- SYSINIT(name##_sx_sysinit, SI_SUB_LOCK, SI_ORDER_MIDDLE, \
- sx_sysinit, &name##_args); \
- SYSUNINIT(name##_sx_sysuninit, SI_SUB_LOCK, SI_ORDER_MIDDLE, \
- sx_destroy, (sxa))
+ SYSINIT(name##_sxu_sysinit, SI_SUB_LOCK, SI_ORDER_MIDDLE, \
+ sxu_sysinit, &name##_args); \
+ SYSUNINIT(name##_sxu_sysuninit, SI_SUB_LOCK, SI_ORDER_MIDDLE, \
+ sxu_destroy, (sxa))
-#define sx_slock(sx) _sx_slock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_xlock(sx) _sx_xlock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_try_slock(sx) _sx_try_slock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_try_xlock(sx) _sx_try_xlock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_sunlock(sx) _sx_sunlock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_xunlock(sx) _sx_xunlock((sx), LOCK_FILE, LOCK_LINE)
-#define sx_try_upgrade(sx) _sx_try_upgrade((sx), LOCK_FILE, LOCK_LINE)
-#define sx_downgrade(sx) _sx_downgrade((sx), LOCK_FILE, LOCK_LINE)
-#define sx_unlock(sx) do { \
+#define sxu_slock(sx) _sxu_slock((sx), (0), LOCK_FILE, LOCK_LINE)
+#define sxu_xlock(sx) _sxu_xlock((sx), (0), LOCK_FILE, LOCK_LINE)
+#define sxu_slock_timedwait(sx, timo) _sxu_slock((sx), (timo), LOCK_FILE, LOCK_LINE)
+#define sxu_xlock_timedwait(sx, timo) _sxu_xlock((sx), (timo), LOCK_FILE, LOCK_LINE)
+#define sxu_try_slock(sx) _sxu_try_slock((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_try_xlock(sx) _sxu_try_xlock((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_sunlock(sx) _sxu_sunlock((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_xunlock(sx) _sxu_xunlock((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_try_upgrade(sx) _sxu_try_upgrade((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_downgrade(sx) _sxu_downgrade((sx), LOCK_FILE, LOCK_LINE)
+#define sxu_unlock(sx) do { \
if ((sx)->sx_cnt < 0) \
- sx_xunlock(sx); \
+ sxu_xunlock(sx); \
else \
- sx_sunlock(sx); \
+ sxu_sunlock(sx); \
} while (0)
#if defined(INVARIANTS) || defined(INVARIANT_SUPPORT)
@@ -99,11 +102,11 @@
#endif
#ifdef INVARIANTS
-#define sx_assert(sx, what) _sx_assert((sx), (what), LOCK_FILE, LOCK_LINE)
+#define sxu_assert(sx, what) _sxu_assert((sx), (what), LOCK_FILE, LOCK_LINE)
#else
-#define sx_assert(sx, what)
+#define sxu_assert(sx, what)
#endif
#endif /* _KERNEL */
-#endif /* !_SYS_SX_H_ */
+#endif /* !_SYS_SXU_H_ */
More information about the p4-projects
mailing list