#include <afsconfig.h>
-#include "../afs/param.h"
+#include "afs/param.h"
-RCSID("$Header$");
-#include "../afs/sysincludes.h" /* Standard vendor system headers */
-#include "../afs/afsincludes.h" /* Afs-based standard headers */
-#include "../afs/afs_stats.h" /* afs statistics */
+#include "afs/sysincludes.h" /* Standard vendor system headers */
+#include "afsincludes.h" /* Afs-based standard headers */
+#include "afs/afs_stats.h" /* afs statistics */
-
-
-static int osi_TimedSleep(char *event, afs_int32 ams, int aintok);
-
-static char waitV;
-
-
-void afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
+void
+afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
{
AFS_STATCNT(osi_InitWaitHandle);
- achandle->proc = (caddr_t) 0;
+ cv_init(&achandle->wh_condvar, "afscondvar");
+ achandle->wh_inited = 1;
}
/* cancel osi_Wait */
-void afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
+/* XXX
+ * I can't tell -- is this supposed to be cv_signal() or cv_waitq_remove()?
+ * Or perhaps cv_broadcast()?
+ * Assuming cv_signal() is the desired meaning. -GAW
+ */
+void
+afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
{
- caddr_t proc;
-
AFS_STATCNT(osi_CancelWait);
- proc = achandle->proc;
- if (proc == 0) return;
- achandle->proc = (caddr_t) 0; /* so dude can figure out he was signalled */
- afs_osi_Wakeup(&waitV);
+
+ /* XXX should not be necessary */
+ if (!achandle->wh_inited)
+ return;
+ AFS_ASSERT_GLOCK();
+ cv_signal(&achandle->wh_condvar);
}
/* afs_osi_Wait
* Waits for data on ahandle, or ams ms later. ahandle may be null.
* Returns 0 if timeout and EINTR if signalled.
*/
-int afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
+int
+afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
{
int code;
- afs_int32 endTime, tid;
+ struct timeval tv;
+ int ticks;
AFS_STATCNT(osi_Wait);
- endTime = osi_Time() + (ams/1000);
- if (ahandle)
- ahandle->proc = (caddr_t) curproc;
- do {
- AFS_ASSERT_GLOCK();
- code = 0;
- code = osi_TimedSleep(&waitV, ams, aintok);
+ tv.tv_sec = ams / 1000;
+ tv.tv_usec = (ams % 1000) * 1000;
+ ticks = tvtohz(&tv);
- if (code) break; /* if something happened, quit now */
- /* if we we're cancelled, quit now */
- if (ahandle && (ahandle->proc == (caddr_t) 0)) {
- /* we've been signalled */
- break;
- }
- } while (osi_Time() < endTime);
+ AFS_ASSERT_GLOCK();
+ if (ahandle == NULL) {
+ /* This is nasty and evil and rude. */
+ code = msleep(&tv, &afs_global_mtx, (aintok ? PPAUSE|PCATCH : PVFS),
+ "afswait", ticks);
+ } else {
+ if (!ahandle->wh_inited)
+ afs_osi_InitWaitHandle(ahandle); /* XXX should not be needed */
+ if (aintok)
+ code = cv_timedwait_sig(&ahandle->wh_condvar, &afs_global_mtx,
+ ticks);
+ else
+ code = cv_timedwait(&ahandle->wh_condvar, &afs_global_mtx, ticks);
+ }
return code;
}
-
-
-
-typedef struct afs_event {
- struct afs_event *next; /* next in hash chain */
- char *event; /* lwp event: an address */
- int refcount; /* Is it in use? */
- int seq; /* Sequence number: this is incremented
- by wakeup calls; wait will not return until
- it changes */
- int cond;
-} afs_event_t;
-
-#define HASHSIZE 128
-afs_event_t *afs_evhasht[HASHSIZE];/* Hash table for events */
-#define afs_evhash(event) (afs_uint32) ((((long)event)>>2) & (HASHSIZE-1));
+afs_event_t *afs_evhasht[AFS_EVHASHSIZE]; /* Hash table for events */
+#define afs_evhash(event) (afs_uint32) ((((long)event)>>2) & (AFS_EVHASHSIZE-1))
int afs_evhashcnt = 0;
/* Get and initialize event structure corresponding to lwp event (i.e. address)
* */
-static afs_event_t *afs_getevent(char *event)
+static afs_event_t *
+afs_getevent(char *event)
{
afs_event_t *evp, *newp = 0;
int hashcode;
evp = evp->next;
}
if (!newp) {
- newp = (afs_event_t *) osi_AllocSmallSpace(sizeof (afs_event_t));
+ newp = (afs_event_t *) afs_osi_Alloc_NoSleep(sizeof(afs_event_t));
afs_evhashcnt++;
newp->next = afs_evhasht[hashcode];
afs_evhasht[hashcode] = newp;
#define relevent(evp) ((evp)->refcount--)
-void afs_osi_Sleep(void *event)
+void
+afs_osi_Sleep(void *event)
{
struct afs_event *evp;
int seq;
seq = evp->seq;
while (seq == evp->seq) {
AFS_ASSERT_GLOCK();
- AFS_GUNLOCK();
- tsleep(event, PVFS, "afs_osi_Sleep", 0);
- AFS_GLOCK();
+ msleep(event, &afs_global_mtx, PVFS, "afsslp", 0);
}
relevent(evp);
}
-int afs_osi_SleepSig(void *event)
+int
+afs_osi_SleepSig(void *event)
{
afs_osi_Sleep(event);
return 0;
*
* Returns 0 if timeout and EINTR if signalled.
*/
-static int osi_TimedSleep(char *event, afs_int32 ams, int aintok)
+int
+afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
{
- int code = 0;
struct afs_event *evp;
+ int seq, code;
+ struct timeval tv;
int ticks;
- int seq,prio;
-
- ticks = ( ams * afs_hz )/1000;
+ tv.tv_sec = ams / 1000;
+ tv.tv_usec = (ams % 1000) * 1000;
+ ticks = tvtohz(&tv);
evp = afs_getevent(event);
- seq=evp->seq;
- AFS_GUNLOCK();
- if (aintok)
- prio=PCATCH|PPAUSE;
- else
- prio=PVFS;
- code=tsleep(event, prio, "afs_osi_TimedSleep", ticks);
- AFS_GLOCK();
- if (seq == evp->seq)
- code=EINTR;
+ seq = evp->seq;
+ while (seq == evp->seq) {
+ AFS_ASSERT_GLOCK();
+ code = msleep(event, &afs_global_mtx, (aintok ? PPAUSE|PCATCH : PVFS),
+ "afstslp", ticks);
+ if (code == EINTR)
+ break;
+ }
relevent(evp);
return code;
}
-
-int afs_osi_Wakeup(void *event)
+int
+afs_osi_Wakeup(void *event)
{
- int ret=1;
+ int ret = 1;
struct afs_event *evp;
evp = afs_getevent(event);
if (evp->refcount > 1) {
- evp->seq++;
+ evp->seq++;
wakeup(event);
- ret=0;
+ ret = 0;
}
relevent(evp);
return ret;
git://git.openafs.org / openafs.git / blobdiff