Free memory from afs_events
[openafs.git] / src / afs / LINUX / osi_sleep.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"      /* afs statistics */
17 #include "osi_compat.h"
18
19 static char waitV, dummyV;
20
21 void
22 afs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle)
23 {
24     AFS_STATCNT(osi_InitWaitHandle);
25     achandle->proc = (caddr_t) 0;
26 }
27
28 /* cancel osi_Wait */
29 void
30 afs_osi_CancelWait(struct afs_osi_WaitHandle *achandle)
31 {
32     caddr_t proc;
33
34     AFS_STATCNT(osi_CancelWait);
35     proc = achandle->proc;
36     if (proc == 0)
37         return;
38     achandle->proc = (caddr_t) 0;       /* so dude can figure out he was signalled */
39     afs_osi_Wakeup(&waitV);
40 }
41
42 /* afs_osi_Wait
43  * Waits for data on ahandle, or ams ms later.  ahandle may be null.
44  * Returns 0 if timeout and EINTR if signalled.
45  */
46 int
47 afs_osi_Wait(afs_int32 ams, struct afs_osi_WaitHandle *ahandle, int aintok)
48 {
49     afs_int32 endTime;
50     int code;
51
52     AFS_STATCNT(osi_Wait);
53     endTime = osi_Time() + (ams / 1000);
54     if (ahandle)
55         ahandle->proc = (caddr_t) current;
56
57     do {
58         AFS_ASSERT_GLOCK();
59         code = afs_osi_TimedSleep(&waitV, ams, 1);
60         if (code)
61             break;
62         if (ahandle && (ahandle->proc == (caddr_t) 0)) {
63             /* we've been signalled */
64             break;
65         }
66     } while (osi_Time() < endTime);
67     return code;
68 }
69
70 afs_event_t *afs_evhasht[AFS_EVHASHSIZE];       /* Hash table for events */
71 #define afs_evhash(event)       (afs_uint32) ((((long)event)>>2) & (AFS_EVHASHSIZE-1));
72 int afs_evhashcnt = 0;
73
74 /* Get and initialize event structure corresponding to lwp event (i.e. address)
75  * */
76 static afs_event_t *
77 afs_getevent(char *event)
78 {
79     afs_event_t *evp, *newp = 0;
80     int hashcode;
81
82     AFS_ASSERT_GLOCK();
83     hashcode = afs_evhash(event);
84     evp = afs_evhasht[hashcode];
85     while (evp) {
86         if (evp->event == event) {
87             evp->refcount++;
88             return evp;
89         }
90         if (evp->refcount == 0)
91             newp = evp;
92         evp = evp->next;
93     }
94     if (!newp)
95         return NULL;
96
97     newp->event = event;
98     newp->refcount = 1;
99     return newp;
100 }
101
102 /* afs_addevent -- allocates a new event for the address.  It isn't returned;
103  *     instead, afs_getevent should be called again.  Thus, the real effect of
104  *     this routine is to add another event to the hash bucket for this
105  *     address.
106  *
107  * Locks:
108  *     Called with GLOCK held.
109  */
110
111 static void
112 afs_addevent(char *event)
113 {
114     int hashcode;
115     afs_event_t *newp;
116
117     AFS_ASSERT_GLOCK();
118     hashcode = afs_evhash(event);
119     newp = kzalloc(sizeof(afs_event_t), GFP_NOFS);
120     afs_evhashcnt++;
121     newp->next = afs_evhasht[hashcode];
122     afs_evhasht[hashcode] = newp;
123     init_waitqueue_head(&newp->cond);
124     newp->event = &dummyV;      /* Dummy address for new events */
125 }
126
127 #ifndef set_current_state
128 #define set_current_state(x)            current->state = (x);
129 #endif
130
131 /* Release the specified event */
132 #define relevent(evp) ((evp)->refcount--)
133
134 /* afs_osi_SleepSig
135  *
136  * Waits for an event to be notified, returning early if a signal
137  * is received.  Returns EINTR if signaled, and 0 otherwise.
138  */
139 int
140 afs_osi_SleepSig(void *event)
141 {
142     struct afs_event *evp;
143     int seq, retval;
144     int code;
145
146     evp = afs_getevent(event);
147     if (!evp) {
148         afs_addevent(event);
149         evp = afs_getevent(event);
150     }
151
152     seq = evp->seq;
153     retval = 0;
154
155     AFS_GUNLOCK();
156     code = wait_event_freezable(evp->cond, seq != evp->seq);
157     AFS_GLOCK();
158
159     if (code == -ERESTARTSYS)
160         code = EINTR;
161     else
162         code = -code;
163
164     relevent(evp);
165     return code;
166 }
167
168 /* afs_osi_Sleep -- waits for an event to be notified, ignoring signals.
169  * - NOTE: that on Linux, there are circumstances in which TASK_INTERRUPTIBLE
170  *   can wake up, even if all signals are blocked
171  * - TODO: handle signals correctly by passing an indication back to the
172  *   caller that the wait has been interrupted and the stack should be cleaned
173  *   up preparatory to signal delivery
174  */
175 void
176 afs_osi_Sleep(void *event)
177 {
178     sigset_t saved_set;
179
180     SIG_LOCK(current);
181     saved_set = current->blocked;
182     sigfillset(&current->blocked);
183     RECALC_SIGPENDING(current);
184     SIG_UNLOCK(current);
185
186     afs_osi_SleepSig(event);
187
188     SIG_LOCK(current);
189     current->blocked = saved_set;
190     RECALC_SIGPENDING(current);
191     SIG_UNLOCK(current);
192 }
193
194 /* afs_osi_TimedSleep
195  * 
196  * Arguments:
197  * event - event to sleep on
198  * ams --- max sleep time in milliseconds
199  * aintok - 1 if should sleep interruptibly
200  *
201  * Returns 0 if timeout, EINTR if signalled, and EGAIN if it might
202  * have raced.
203  */
204 int
205 afs_osi_TimedSleep(void *event, afs_int32 ams, int aintok)
206 {
207     int code = 0;
208     long ticks = (ams * HZ / 1000) + 1;
209     struct afs_event *evp;
210     int seq;
211
212     evp = afs_getevent(event);
213     if (!evp) {
214         afs_addevent(event);
215         evp = afs_getevent(event);
216     }
217
218     seq = evp->seq;
219
220     AFS_GUNLOCK();
221     code = wait_event_freezable_timeout(evp->cond, evp->seq != seq, ticks);
222     AFS_GLOCK();
223     if (code == -ERESTARTSYS)
224         code = EINTR;
225     else
226         code = -code;
227
228     relevent(evp);
229
230     return code;
231 }
232
233
234 int
235 afs_osi_Wakeup(void *event)
236 {
237     int ret = 2;
238     struct afs_event *evp;
239
240     evp = afs_getevent(event);
241     if (!evp)                   /* No sleepers */
242         return 1;
243
244     if (evp->refcount > 1) {
245         evp->seq++;
246         wake_up(&evp->cond);
247         ret = 0;
248     }
249     relevent(evp);
250     return ret;
251 }