X-Git-Url: http://git.openafs.org/?p=openafs.git;a=blobdiff_plain;f=src%2Fafs%2FSOLARIS%2Fosi_sleep.c;h=bf62279532db4556e83f7e2d9b0bb4f8e9d6d744;hp=e2257282c0e34768e3e5b4601173d3f0ae5b78b0;hb=2c0a9ab3c361ade9218c2f458d86165de8eadc76;hpb=e7ec0d4213853117dc463a3629651e280c6cf0fa

diff --git a/src/afs/SOLARIS/osi_sleep.c b/src/afs/SOLARIS/osi_sleep.c
index e225728..bf62279 100644
--- a/src/afs/SOLARIS/osi_sleep.c
+++ b/src/afs/SOLARIS/osi_sleep.c
@@ -7,36 +7,36 @@
  * directory or online at http://www.openafs.org/dl/license10.html
  */
 
-#include "../afs/param.h"	/* Should be always first */
 #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/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);
-void afs_osi_Wakeup(char *event);
-void afs_osi_Sleep(char *event);
 
 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;
 }
 
 /* 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) return;
-    achandle->proc = (caddr_t) 0;   /* so dude can figure out he was signalled */
+    if (proc == 0)
+	return;
+    achandle->proc = (caddr_t) 0;	/* so dude can figure out he was signalled */
     afs_osi_Wakeup(&waitV);
 }
 
@@ -44,13 +44,14 @@ 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;
     afs_int32 endTime, tid;
 
     AFS_STATCNT(osi_Wait);
-    endTime = osi_Time() + (ams/1000);
+    endTime = osi_Time() + (ams / 1000);
     if (ahandle)
 	ahandle->proc = (caddr_t) curthread;
     do {
@@ -58,7 +59,8 @@ int afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
 	code = 0;
 	code = osi_TimedSleep(&waitV, ams, aintok);
 
-	if (code) break;	/* if something happened, quit now */
+	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 */
@@ -76,19 +78,20 @@ typedef struct afs_event {
     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 */
+				 * by wakeup calls; wait will not return until
+				 * it changes */
     kcondvar_t cond;		/* Currently associated condition variable */
 } afs_event_t;
 
 #define HASHSIZE 128
-afs_event_t *afs_evhasht[HASHSIZE];/* Hash table for events */
+afs_event_t *afs_evhasht[HASHSIZE];	/* Hash table for events */
 #define afs_evhash(event)	(afs_uint32) ((((long)event)>>2) & (HASHSIZE-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;
@@ -106,7 +109,7 @@ static afs_event_t *afs_getevent(char *event)
 	evp = evp->next;
     }
     if (!newp) {
-	newp = (afs_event_t *) osi_AllocSmallSpace(sizeof (afs_event_t));
+	newp = (afs_event_t *) osi_AllocSmallSpace(sizeof(afs_event_t));
 	afs_evhashcnt++;
 	newp->next = afs_evhasht[hashcode];
 	afs_evhasht[hashcode] = newp;
@@ -122,7 +125,8 @@ static afs_event_t *afs_getevent(char *event)
 #define relevent(evp) ((evp)->refcount--)
 
 
-void afs_osi_Sleep(char *event)
+void
+afs_osi_Sleep(void *event)
 {
     struct afs_event *evp;
     int seq;
@@ -136,6 +140,25 @@ void afs_osi_Sleep(char *event)
     relevent(evp);
 }
 
+int
+afs_osi_SleepSig(void *event)
+{
+    struct afs_event *evp;
+    int seq, code = 0;
+
+    evp = afs_getevent(event);
+    seq = evp->seq;
+    while (seq == evp->seq) {
+	AFS_ASSERT_GLOCK();
+	if (cv_wait_sig(&evp->cond, &afs_global_lock) == 0) {
+	    code = EINTR;
+	    break;
+	}
+    }
+    relevent(evp);
+    return code;
+}
+
 /* osi_TimedSleep
  * 
  * Arguments:
@@ -145,38 +168,47 @@ void afs_osi_Sleep(char *event)
  *
  * Returns 0 if timeout and EINTR if signalled.
  */
-static int osi_TimedSleep(char *event, afs_int32 ams, int aintok)
+static int
+osi_TimedSleep(char *event, afs_int32 ams, int aintok)
 {
     int code = 0;
     struct afs_event *evp;
     clock_t ticks;
 
-    ticks = ( ams * afs_hz )/1000;
-    ticks = ticks  + lbolt;
+    ticks = (ams * afs_hz) / 1000;
+#if defined(AFS_SUN510_ENV)
+    ticks = ticks + ddi_get_lbolt();
+#else
+    ticks = ticks + lbolt;
+#endif
 
     evp = afs_getevent(event);
 
     AFS_ASSERT_GLOCK();
     if (aintok) {
-	if (cv_timedwait_sig(&evp->cond, &afs_global_lock, ticks) == -1)
+	if (cv_timedwait_sig(&evp->cond, &afs_global_lock, ticks) == 0)
 	    code = EINTR;
     } else {
 	cv_timedwait(&evp->cond, &afs_global_lock, ticks);
     }
-    
+
     relevent(evp);
     return code;
 }
 
 
-void afs_osi_Wakeup(char *event)
+int
+afs_osi_Wakeup(void *event)
 {
+    int ret = 1;
     struct afs_event *evp;
 
     evp = afs_getevent(event);
     if (evp->refcount > 1) {
-	evp->seq++;    
+	evp->seq++;
 	cv_broadcast(&evp->cond);
+	ret = 0;
     }
     relevent(evp);
+    return 0;
 }