d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Apply the cluebat to myself and undo the await() -> mawait() rename. The

Browse Source 
asleep() and await() functions split the functionality of msleep() up into
two halves.  Only the asleep() half (which is what puts the process on the
sleep queue) actually needs the lock usually passed to msleep() held to
prevent lost wakeups.  await() does not need the lock held, so the lock
can be released prior to calling await() and does not need to be passed in
to the await() function.  Typical usage of these functions would be as
follows:

        mtx_lock(&foo_mtx);
        ... do stuff ...
        asleep(&foo_cond, PRIxx, "foowt", hz);
        ...
        mtx_unlock&foo_mtx);
        ...
        await(-1, -1);

Inspired by:	dillon on the couch at Usenix
This commit is contained in:
jhb 2001-07-31 22:06:56 +00:00
parent 394c3bbe7d
commit 3df0102bec
2 changed files with 16 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
sys/kern/kern_synch.c
View File

@ -488,16 +488,16 @@ msleep(ident, mtx, priority, wmesg, timo)
/*
* asleep() - async sleep call. Place process on wait queue and return
* immediately without blocking. The process stays runnable until mawait()
* immediately without blocking. The process stays runnable until await()
* is called. If ident is NULL, remove process from wait queue if it is still
* on one.
*
* Only the most recent sleep condition is effective when making successive
* calls to asleep() or when calling msleep().
*
* The timeout, if any, is not initiated until mawait() is called. The sleep
* The timeout, if any, is not initiated until await() is called. The sleep
* priority, signal, and timeout is specified in the asleep() call but may be
* overriden in the mawait() call.
* overriden in the await() call.
*
* <<<<<<<< EXPERIMENTAL, UNTESTED >>>>>>>>>>
*/
@ -532,27 +532,24 @@ asleep(void *ident, int priority, const char *wmesg, int timo)
}
/*
* mawait() - wait for async condition to occur. The process blocks until
* await() - wait for async condition to occur. The process blocks until
* wakeup() is called on the most recent asleep() address. If wakeup is called
* prior to mawait(), mawait() winds up being a NOP.
* prior to await(), await() winds up being a NOP.
*
* If mawait() is called more then once (without an intervening asleep() call),
* mawait() is still effectively a NOP but it calls mi_switch() to give other
* If await() is called more then once (without an intervening asleep() call),
* await() is still effectively a NOP but it calls mi_switch() to give other
* processes some cpu before returning. The process is left runnable.
*
* <<<<<<<< EXPERIMENTAL, UNTESTED >>>>>>>>>>
*/
int
mawait(struct mtx *mtx, int priority, int timo)
await(int priority, int timo)
{
struct proc *p = curproc;
int rval = 0;
WITNESS_SAVE_DECL(mtx);
WITNESS_SLEEP(0, &mtx->mtx_object);
KASSERT(timo > 0 || mtx_owned(&Giant) || mtx != NULL,
("sleeping without a mutex"));
WITNESS_SLEEP(0, NULL);
mtx_lock_spin(&sched_lock);
if (cold || panicstr) {
/*
@ -561,19 +558,10 @@ mawait(struct mtx *mtx, int priority, int timo)
* don't run any other procs or panic below,
* in case this is the idle process and already asleep.
*/
if (mtx != NULL && priority & PDROP)
mtx_unlock_flags(mtx, MTX_NOSWITCH);
mtx_unlock_spin(&sched_lock);
return (0);
}
DROP_GIANT_NOSWITCH();
if (mtx != NULL) {
mtx_assert(mtx, MA_OWNED | MA_NOTRECURSED);
WITNESS_SAVE(&mtx->mtx_object, mtx);
mtx_unlock_flags(mtx, MTX_NOSWITCH);
if (priority & PDROP)
mtx = NULL;
}
if (p->p_wchan != NULL) {
int sig;
@ -584,7 +572,7 @@ mawait(struct mtx *mtx, int priority, int timo)
ktrcsw(p->p_tracep, 1, 0);
#endif
/*
* The call to mawait() can override defaults specified in
* The call to await() can override defaults specified in
* the original asleep().
*/
if (priority < 0)
@ -647,7 +635,7 @@ mawait(struct mtx *mtx, int priority, int timo)
#endif
} else {
/*
* If as_priority is 0, mawait() has been called without an
* If as_priority is 0, await() has been called without an
* intervening asleep(). We are still effectively a NOP,
* but we call mi_switch() for safety.
*/
@ -660,24 +648,20 @@ mawait(struct mtx *mtx, int priority, int timo)
}
/*
* clear p_asleep.as_priority as an indication that mawait() has been
* called. If mawait() is called again without an intervening asleep(),
* mawait() is still effectively a NOP but the above mi_switch() code
* clear p_asleep.as_priority as an indication that await() has been
* called. If await() is called again without an intervening asleep(),
* await() is still effectively a NOP but the above mi_switch() code
* is triggered as a safety.
*/
if (rval == 0)
p->p_asleep.as_priority = 0;
PICKUP_GIANT();
if (mtx != NULL) {
mtx_lock(mtx);
WITNESS_RESTORE(&mtx->mtx_object, mtx);
}
return (rval);
}
/*
* Implement timeout for msleep or asleep()/mawait()
* Implement timeout for msleep or asleep()/await()
*
* If process hasn't been awakened (wchan non-zero),
* set timeout flag and undo the sleep. If proc

3
sys/sys/systm.h
View File

@ -263,8 +263,7 @@ int msleep __P((void *chan, struct mtx *mtx, int pri, const char *wmesg,
int timo));
#define tsleep(chan, pri, wmesg, timo) msleep(chan, NULL, pri, wmesg, timo)
int asleep __P((void *chan, int pri, const char *wmesg, int timo));
#define await(pri, timo) mawait(NULL, pri, timo)
int mawait __P((struct mtx *mtx, int pri, int timo));
int await __P((int pri, int timo));
void wakeup __P((void *chan));
void wakeup_one __P((void *chan));