Free memory from afs_events

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

diff --git a/src/afs/IRIX/osi_sleep.c b/src/afs/IRIX/osi_sleep.c
index 3674baf..0f8c674 100644 (file)
--- a/src/afs/IRIX/osi_sleep.c
+++ b/src/afs/IRIX/osi_sleep.c
@@ -10,34 +10,31 @@
 #include <afsconfig.h>
 #include "afs/param.h"
 
-RCSID("$Header$");
 
 #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);
+#include "afs/afs_stats.h"     /* afs statistics */
 
 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);
 }
 
@@ -45,21 +42,23 @@ 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) curthreadp;
     do {
        AFS_ASSERT_GLOCK();
        code = 0;
-       code = osi_TimedSleep(&waitV, ams, aintok);
+       code = afs_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 */
@@ -72,28 +71,18 @@ int afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
 
 
 
-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 */
-    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[AFS_EVHASHSIZE];      /* Hash table for events */
 #if (_MIPS_SZPTR == 64)
-#define afs_evhash(event)      (afs_uint32) ((((long)event)>>3) & (HASHSIZE-1));
+#define afs_evhash(event)      (afs_uint32) ((((long)event)>>3) & (AFS_EVHASHSIZE-1));
 #else
-#define afs_evhash(event)      (afs_uint32) ((((long)event)>>2) & (HASHSIZE-1));
+#define afs_evhash(event)      (afs_uint32) ((((long)event)>>2) & (AFS_EVHASHSIZE-1));
 #endif
 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;
@@ -111,7 +100,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;
@@ -127,7 +116,8 @@ static afs_event_t *afs_getevent(char *event)
 #define relevent(evp) ((evp)->refcount--)
 
 
-void afs_osi_Sleep(void *event)
+void
+afs_osi_Sleep(void *event)
 {
     struct afs_event *evp;
     int seq;
@@ -141,13 +131,14 @@ void afs_osi_Sleep(void *event)
     relevent(evp);
 }
 
-int afs_osi_SleepSig(void *event)
+int
+afs_osi_SleepSig(void *event)
 {
     afs_osi_Sleep(event);
     return 0;
 }
 
-/* osi_TimedSleep
+/* afs_osi_TimedSleep
  * 
  * Arguments:
  * event - event to sleep on
@@ -156,43 +147,45 @@ int afs_osi_SleepSig(void *event)
  *
  * 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;
     struct timespec ticks;
 
     ticks.tv_sec = ams / 1000;
-    ticks.tv_nsec = (ams - (ticks.tv_sec * 1000) ) * 1000000;
-
+    ticks.tv_nsec = (ams - (ticks.tv_sec * 1000)) * 1000000;
 
     evp = afs_getevent(event);
 
     AFS_ASSERT_GLOCK();
     if (aintok) {
-       if (sv_timedwait_sig(&evp->cond, AFSD_PRI(), &afs_global_lock,
-                            0, 0, &ticks, (struct timespec*)0))
+       if (sv_timedwait_sig
+           (&evp->cond, AFSD_PRI(), &afs_global_lock, 0, 0, &ticks,
+            (struct timespec *)0))
            code = EINTR;
-       AFS_MUTEX_ENTER(&afs_global_lock); 
+       AFS_MUTEX_ENTER(&afs_global_lock);
     } else {
        cv_timedwait(&evp->cond, &afs_global_lock, ticks);
     }
-    
+
     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++;
        cv_broadcast(&evp->cond);
-       ret=0;
+       ret = 0;
     }
     relevent(evp);
     return ret;