Free memory from afs_events
[openafs.git] / src / afs / OBSD / osi_sleep.c
1 /*
2  * $Id$
3  */
4
5 /*
6 copyright 2002
7 the regents of the university of michigan
8 all rights reserved
9
10 permission is granted to use, copy, create derivative works 
11 and redistribute this software and such derivative works 
12 for any purpose, so long as the name of the university of 
13 michigan is not used in any advertising or publicity 
14 pertaining to the use or distribution of this software 
15 without specific, written prior authorization.  if the 
16 above copyright notice or any other identification of the 
17 university of michigan is included in any copy of any 
18 portion of this software, then the disclaimer below must 
19 also be included.
20
21 this software is provided as is, without representation 
22 from the university of michigan as to its fitness for any 
23 purpose, and without warranty by the university of 
24 michigan of any kind, either express or implied, including 
25 without limitation the implied warranties of 
26 merchantability and fitness for a particular purpose. the 
27 regents of the university of michigan shall not be liable 
28 for any damages, including special, indirect, incidental, or 
29 consequential damages, with respect to any claim arising 
30 out of or in connection with the use of the software, even 
31 if it has been or is hereafter advised of the possibility of 
32 such damages.
33 */
34
35 /*
36  * Copyright 2000, International Business Machines Corporation and others.
37  * All Rights Reserved.
38  *
39  * This software has been released under the terms of the IBM Public
40  * License.  For details, see the LICENSE file in the top-level source
41  * directory or online at http://www.openafs.org/dl/license10.html
42  */
43
44 #include <afsconfig.h>
45 #include "afs/param.h"
46
47
48 #include "afs/sysincludes.h"    /* Standard vendor system headers */
49 #include "afs/afsincludes.h"    /* Afs-based standard headers */
50 #include "afs/afs_stats.h"      /* afs statistics */
51
52 static char waitV;
53
54
55 time_t
56 osi_Time()
57 {
58     struct timeval now;
59
60     getmicrotime(&now);
61     return now.tv_sec;
62 }
63
64 void
65 afs_osi_SetTime(osi_timeval_t * atv)
66 {
67     printf("afs attempted to set clock; use \"afsd -nosettime\"\n");
68 }
69
70 /* cancel osi_Wait */
71 void
72 afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
73 {
74     caddr_t proc;
75
76     AFS_STATCNT(osi_CancelWait);
77     proc = achandle->proc;
78     if (proc == NULL)
79         return;
80     achandle->proc = NULL;
81     wakeup(&waitV);
82 }
83
84 /* afs_osi_Wait
85  * Waits for data on ahandle, or ams ms later.  ahandle may be null.
86  * Returns 0 if timeout and EINTR if signalled.
87  */
88 int
89 afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
90 {
91     int timo, code = 0;
92     struct timeval atv, now, endTime;
93
94     AFS_STATCNT(osi_Wait);
95
96     atv.tv_sec = ams / 1000;
97     atv.tv_usec = (ams % 1000) * 1000;
98     getmicrotime(&now);
99     timeradd(&atv, &now, &endTime);
100
101     if (ahandle)
102         ahandle->proc = (caddr_t) curproc;
103     AFS_ASSERT_GLOCK();
104     AFS_GUNLOCK();
105
106     do {
107         timersub(&endTime, &now, &atv);
108         timo = atv.tv_sec * hz + atv.tv_usec * hz / 1000000 + 1;
109         if (aintok) {
110             code = tsleep(&waitV, PCATCH | PVFS, "afs_W1", timo);
111             if (code)
112                 code = (code == EWOULDBLOCK) ? 0 : EINTR;
113         } else
114             tsleep(&waitV, PVFS, "afs_W2", timo);
115
116         /* if we were cancelled, quit now */
117         if (ahandle && (ahandle->proc == NULL)) {
118             /* we've been signalled */
119             break;
120         }
121         getmicrotime(&now);
122     } while (timercmp(&now, &endTime, <));
123
124     AFS_GLOCK();
125     return code;
126 }
127
128 afs_event_t *afs_evhasht[AFS_EVHASHSIZE];     /* Hash table for events */
129 #define afs_evhash(event)       (afs_uint32) ((((long)event)>>2) & (AFS_EVHASHSIZE-1));
130 int afs_evhashcnt = 0;
131
132 /* Get and initialize event structure corresponding to lwp event (i.e. address)
133  * */
134 static afs_event_t *
135 afs_getevent(char *event)
136 {
137     afs_event_t *evp, *newp = 0;
138     int hashcode;
139
140     AFS_ASSERT_GLOCK();
141     hashcode = afs_evhash(event);
142     evp = afs_evhasht[hashcode];
143     while (evp) {
144         if (evp->event == event) {
145             evp->refcount++;
146             return evp;
147         }
148         if (evp->refcount == 0)
149             newp = evp;
150         evp = evp->next;
151     }
152     if (!newp) {
153         newp = (afs_event_t *) osi_AllocSmallSpace(sizeof(afs_event_t));
154         afs_evhashcnt++;
155         newp->next = afs_evhasht[hashcode];
156         afs_evhasht[hashcode] = newp;
157         newp->seq = 0;
158     }
159     newp->event = event;
160     newp->refcount = 1;
161     return newp;
162 }
163
164 /* Release the specified event */
165 #define relevent(evp) ((evp)->refcount--)
166
167 int
168 afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
169 {
170     int code = 0;
171     struct afs_event *evp;
172     int seq, prio;
173     int ticks;
174
175     evp = afs_getevent(event);
176     seq = evp->seq;
177     AFS_GUNLOCK();
178     if (aintok)
179         prio = PCATCH | PPAUSE;
180     else
181         prio = PVFS;
182     ticks = (ams * afs_hz) / 1000;
183     code = tsleep(event, prio, "afs_osi_TimedSleep", ticks);
184     if (seq == evp->seq)
185         code = EINTR;
186     relevent(evp);
187     AFS_GLOCK();
188     return code;
189 }
190
191 void
192 afs_osi_Sleep(void *event)
193 {
194     AFS_ASSERT_GLOCK();
195     AFS_GUNLOCK();
196     tsleep(event, PVFS, "afsslp", 0);
197     AFS_GLOCK();
198 }
199
200 int
201 afs_osi_SleepSig(void *event)
202 {
203     afs_osi_Sleep(event);
204     return 0;
205 }
206
207 int
208 afs_osi_Wakeup(void *event)
209 {
210     wakeup(event);
211     return 1;
212 }