OpenBSD: Fix parameters in call to afs_close()

[openafs.git] / src / afs / OBSD / osi_sleep.c

diff --git a/src/afs/OBSD/osi_sleep.c b/src/afs/OBSD/osi_sleep.c
index f22922f..6f9c195 100644 (file)
--- a/src/afs/OBSD/osi_sleep.c
+++ b/src/afs/OBSD/osi_sleep.c
@@ -44,29 +44,38 @@ such damages.
 #include <afsconfig.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/afs_stats.h"     /* afs statistics */
 
 static char waitV;
 
 
-void afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
+time_t
+osi_Time()
 {
-    AFS_STATCNT(osi_InitWaitHandle);
-    achandle->proc = NULL;
+    struct timeval now;
+
+    getmicrotime(&now);
+    return now.tv_sec;
+}
+
+void
+afs_osi_SetTime(osi_timeval_t * atv)
+{
+    printf("afs attempted to set clock; use \"afsd -nosettime\"\n");
 }
 
 /* cancel osi_Wait */
-void afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
+void
+afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
 {
     caddr_t proc;
 
     AFS_STATCNT(osi_CancelWait);
     proc = achandle->proc;
-    if (proc == 0)
+    if (proc == NULL)
        return;
     achandle->proc = NULL;
     wakeup(&waitV);
@@ -76,54 +85,88 @@ void afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
  * 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 = 0;
-    afs_int32 endTime;
-    int timo = (ams * afs_hz) / 1000 + 1;
+    int timo, code = 0;
+    struct timeval atv, now, endTime;
 
     AFS_STATCNT(osi_Wait);
-    endTime = osi_Time() + (ams / 1000);
+
+    atv.tv_sec = ams / 1000;
+    atv.tv_usec = (ams % 1000) * 1000;
+    getmicrotime(&now);
+    timeradd(&atv, &now, &endTime);
+
     if (ahandle)
        ahandle->proc = (caddr_t) curproc;
     AFS_ASSERT_GLOCK();
     AFS_GUNLOCK();
+
     do {
+       timersub(&endTime, &now, &atv);
+       timo = atv.tv_sec * hz + atv.tv_usec * hz / 1000000 + 1;
        if (aintok) {
-           code = tsleep(&waitV, PCATCH | (PZERO+8), "afs_osi_Wait", timo);
-           if (code)   /* if interrupted, return EINTR */
-               code = EINTR;
+           code = tsleep(&waitV, PCATCH | PVFS, "afs_W1", timo);
+           if (code)
+               code = (code == EWOULDBLOCK) ? 0 : EINTR;
        } else
-           tsleep(&waitV, (PZERO-3), "afs_osi_Wait", timo);
+           tsleep(&waitV, PVFS, "afs_W2", timo);
 
        /* if we were cancelled, quit now */
        if (ahandle && (ahandle->proc == NULL)) {
            /* we've been signalled */
            break;
        }
-    } while (osi_Time() < endTime);
+       getmicrotime(&now);
+    } while (timercmp(&now, &endTime, <));
+
     AFS_GLOCK();
     return code;
 }
 
-void afs_osi_Sleep(void *event)
+int
+afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
 {
-    AFS_ASSERT_GLOCK();
+    int code = 0;
+    struct afs_event *evp;
+    int seq, prio;
+    int ticks;
+
+    evp = afs_getevent(event);
+    seq = evp->seq;
     AFS_GUNLOCK();
-    tsleep(event, PVFS, "afs", 0);
+    if (aintok)
+       prio = PCATCH | PPAUSE;
+    else
+       prio = PVFS;
+    ticks = (ams * afs_hz) / 1000;
+    code = tsleep(event, prio, "afs_osi_TimedSleep", ticks);
+    if (seq == evp->seq)
+       code = EINTR;
+    relevent(evp);
     AFS_GLOCK();
+    return code;
 }
 
-int afs_osi_SleepSig(void *event)
+void
+afs_osi_Sleep(void *event)
 {
     AFS_ASSERT_GLOCK();
     AFS_GUNLOCK();
-    tsleep(event, PVFS, "afs", 0);
+    tsleep(event, PVFS, "afsslp", 0);
     AFS_GLOCK();
+}
+
+int
+afs_osi_SleepSig(void *event)
+{
+    afs_osi_Sleep(event);
     return 0;
 }
 
-int afs_osi_Wakeup(void *event)
+int
+afs_osi_Wakeup(void *event)
 {
     wakeup(event);
     return 1;