6bfbc3317b6eadb62e4b927e5342972deb84d429
[openafs.git] / src / rx / rx_event.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 #ifdef AFS_SUN59_ENV
14 # include <sys/time_impl.h>
15 #endif
16
17 #ifdef KERNEL
18 # ifndef UKERNEL
19 #  include "afs/afs_osi.h"
20 # else /* !UKERNEL */
21 #  include "afs/sysincludes.h"
22 #  include "afsincludes.h"
23 # endif /* !UKERNEL */
24 # include "rx_kernel.h"
25 # include "rx_kmutex.h"
26 # if defined(AFS_SGI_ENV)
27 #  include "sys/debug.h"
28 /* These are necessary to get curproc (used by GLOCK asserts) to work. */
29 #  include "h/proc.h"
30 #  if !defined(AFS_SGI64_ENV) && !defined(UKERNEL)
31 #   include "h/user.h"
32 #  endif
33 extern void *osi_Alloc();
34 # endif
35 # if defined(AFS_OBSD_ENV)
36 #  if defined(AFS_OBSD48_ENV)
37 #   include "h/systm.h"
38 #  else
39 #   include "h/proc.h"
40 #  endif
41 # endif
42 #else /* KERNEL */
43 # include <roken.h>
44 # include "rx_user.h"
45 # ifdef AFS_PTHREAD_ENV
46 #  include "rx_pthread.h"
47 # else
48 #  include "rx_lwp.h"
49 # endif
50 #endif /* KERNEL */
51
52 #include "rx.h"
53 #include "rx_clock.h"
54 #include "rx_queue.h"
55 #include "rx_event.h"
56 #include "rx_globals.h"
57
58 /* All event processing is relative to the apparent current time given by clock_GetTime */
59
60 /* This should be static, but event_test wants to look at the free list... */
61 struct rx_queue rxevent_free;   /* It's somewhat bogus to use a doubly-linked queue for the free list */
62 struct rx_queue rxepoch_free;   /* It's somewhat bogus to use a doubly-linked queue for the free list */
63 static struct rx_queue rxepoch_queue;   /* list of waiting epochs */
64 static int rxevent_allocUnit = 10;      /* Allocation unit (number of event records to allocate at one time) */
65 static int rxepoch_allocUnit = 10;      /* Allocation unit (number of epoch records to allocate at one time) */
66 int rxevent_nFree;              /* Number of free event records */
67 int rxevent_nPosted;            /* Current number of posted events */
68 int rxepoch_nFree;              /* Number of free epoch records */
69 static void (*rxevent_ScheduledEarlierEvent) (void);    /* Proc to call when an event is scheduled that is earlier than all other events */
70 struct xfreelist {
71     void *mem;
72     int size;
73     struct xfreelist *next;
74 };
75 static struct xfreelist *xfreemallocs = 0, *xsp = 0;
76
77 struct clock rxevent_nextRaiseEvents;   /* Time of next call to raise events */
78 struct clock rxevent_lastEvent;        /* backwards time detection */
79 int rxevent_raiseScheduled;     /* true if raise events is scheduled */
80
81 #ifdef RX_ENABLE_LOCKS
82 #ifdef RX_LOCKS_DB
83 /* rxdb_fileID is used to identify the lock location, along with line#. */
84 static int rxdb_fileID = RXDB_FILE_RX_EVENT;
85 #endif /* RX_LOCKS_DB */
86 #define RX_ENABLE_LOCKS  1
87 afs_kmutex_t rxevent_lock;
88 #endif /* RX_ENABLE_LOCKS */
89
90 #ifdef AFS_PTHREAD_ENV
91 /*
92  * This mutex protects the following global variables:
93  * rxevent_initialized
94  */
95
96 afs_kmutex_t rx_event_mutex;
97 #define LOCK_EV_INIT MUTEX_ENTER(&rx_event_mutex)
98 #define UNLOCK_EV_INIT MUTEX_EXIT(&rx_event_mutex)
99 #else
100 #define LOCK_EV_INIT
101 #define UNLOCK_EV_INIT
102 #endif /* AFS_PTHREAD_ENV */
103
104
105 int
106 rxevent_adjTimes(struct clock *adjTime)
107 {
108     /* backwards clock correction */
109     int nAdjusted = 0;
110     struct rxepoch *qep, *nqep;
111     struct rxevent *qev, *nqev;
112
113     for (queue_Scan(&rxepoch_queue, qep, nqep, rxepoch)) {
114         for (queue_Scan(&qep->events, qev, nqev, rxevent)) {
115             if (clock_Gt(&qev->eventTime, adjTime)) {
116                 clock_Sub(&qev->eventTime, adjTime);
117                 nAdjusted++;
118             }
119         }
120         if (qep->epochSec > adjTime->sec) {
121             qep->epochSec -= adjTime->sec;
122         }
123     }
124     return nAdjusted;
125 }
126
127 /* Pass in the number of events to allocate at a time */
128 int rxevent_initialized = 0;
129 void
130 rxevent_Init(int nEvents, void (*scheduler) (void))
131 {
132     LOCK_EV_INIT;
133     if (rxevent_initialized) {
134         UNLOCK_EV_INIT;
135         return;
136     }
137     MUTEX_INIT(&rxevent_lock, "rxevent_lock", MUTEX_DEFAULT, 0);
138     clock_Init();
139     if (nEvents)
140         rxevent_allocUnit = nEvents;
141     queue_Init(&rxevent_free);
142     queue_Init(&rxepoch_free);
143     queue_Init(&rxepoch_queue);
144     rxevent_nFree = rxevent_nPosted = 0;
145     rxepoch_nFree = 0;
146     rxevent_ScheduledEarlierEvent = scheduler;
147     rxevent_initialized = 1;
148     clock_Zero(&rxevent_nextRaiseEvents);
149     clock_Zero(&rxevent_lastEvent);
150     rxevent_raiseScheduled = 0;
151     UNLOCK_EV_INIT;
152 }
153
154 /* Create and initialize new epoch structure */
155 struct rxepoch *
156 rxepoch_Allocate(struct clock *when)
157 {
158     struct rxepoch *ep;
159     int i;
160
161     /* If we are short on free epoch entries, create a block of new oned
162      * and add them to the free queue */
163     if (queue_IsEmpty(&rxepoch_free)) {
164 #if    defined(AFS_AIX32_ENV) && defined(KERNEL)
165         ep = rxi_Alloc(sizeof(struct rxepoch));
166         queue_Append(&rxepoch_free, &ep[0]), rxepoch_nFree++;
167 #else
168 #if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
169         ep = (struct rxepoch *)
170             afs_osi_Alloc_NoSleep(sizeof(struct rxepoch) * rxepoch_allocUnit);
171         xsp = xfreemallocs;
172         xfreemallocs =
173             (struct xfreelist *)afs_osi_Alloc_NoSleep(sizeof(struct xfreelist));
174 #else
175         ep = (struct rxepoch *)
176             osi_Alloc(sizeof(struct rxepoch) * rxepoch_allocUnit);
177         xsp = xfreemallocs;
178         xfreemallocs =
179             (struct xfreelist *)osi_Alloc(sizeof(struct xfreelist));
180 #endif
181         xfreemallocs->mem = (void *)ep;
182         xfreemallocs->size = sizeof(struct rxepoch) * rxepoch_allocUnit;
183         xfreemallocs->next = xsp;
184         for (i = 0; i < rxepoch_allocUnit; i++)
185             queue_Append(&rxepoch_free, &ep[i]), rxepoch_nFree++;
186 #endif
187     }
188     ep = queue_First(&rxepoch_free, rxepoch);
189     queue_Remove(ep);
190     rxepoch_nFree--;
191     ep->epochSec = when->sec;
192     queue_Init(&ep->events);
193     return ep;
194 }
195
196 /* Add the indicated event (function, arg) at the specified clock time.  The
197  * "when" argument specifies when "func" should be called, in clock (clock.h)
198  * units. */
199
200 struct rxevent *
201 rxevent_Post(struct clock *when, struct clock *now,
202               void (*func) (struct rxevent *, void *, void *, int),
203               void *arg, void *arg1, int arg2)
204 {
205     struct rxevent *ev, *evqe, *evqpr;
206     struct rxepoch *ep, *epqe, *epqpr;
207     int isEarliest = 0;
208
209     MUTEX_ENTER(&rxevent_lock);
210 #ifdef RXDEBUG
211     if (rx_Log_event) {
212         struct clock now1;
213         clock_GetTime(&now1);
214         fprintf(rx_Log_event, "%ld.%ld: rxevent_Post(%ld.%ld, "
215                               "%"AFS_PTR_FMT", %"AFS_PTR_FMT", "
216                               "%"AFS_PTR_FMT", %d)\n",
217                 afs_printable_int32_ld(now1.sec),
218                 afs_printable_int32_ld(now1.usec),
219                 afs_printable_int32_ld(when->sec),
220                 afs_printable_int32_ld(when->usec),
221                 func, arg,
222                 arg1, arg2);
223     }
224 #endif
225     /* If a time was provided, check for consistency */
226     if (now->sec) {
227         if (clock_Gt(&rxevent_lastEvent, now)) {
228             struct clock adjTime = rxevent_lastEvent;
229             clock_Sub(&adjTime, now);
230             rxevent_adjTimes(&adjTime);
231         }
232         rxevent_lastEvent = *now;
233     }
234     /* Get a pointer to the epoch for this event, if none is found then
235      * create a new epoch and insert it into the sorted list */
236     for (ep = NULL, queue_ScanBackwards(&rxepoch_queue, epqe, epqpr, rxepoch)) {
237         if (when->sec == epqe->epochSec) {
238             /* already have an structure for this epoch */
239             ep = epqe;
240             if (ep == queue_First(&rxepoch_queue, rxepoch))
241                 isEarliest = 1;
242             break;
243         } else if (when->sec > epqe->epochSec) {
244             /* Create a new epoch and insert after qe */
245             ep = rxepoch_Allocate(when);
246             queue_InsertAfter(epqe, ep);
247             break;
248         }
249     }
250     if (ep == NULL) {
251         /* Create a new epoch and place it at the head of the list */
252         ep = rxepoch_Allocate(when);
253         queue_Prepend(&rxepoch_queue, ep);
254         isEarliest = 1;
255     }
256
257     /* If we're short on free event entries, create a block of new ones and add
258      * them to the free queue */
259     if (queue_IsEmpty(&rxevent_free)) {
260         int i;
261 #if     defined(AFS_AIX32_ENV) && defined(KERNEL)
262         ev = rxi_Alloc(sizeof(struct rxevent));
263         queue_Append(&rxevent_free, &ev[0]), rxevent_nFree++;
264 #else
265
266 #if defined(KERNEL) && !defined(UKERNEL) && defined(AFS_FBSD80_ENV)
267         ev = (struct rxevent *)afs_osi_Alloc_NoSleep(sizeof(struct rxevent) *
268                                          rxevent_allocUnit);
269         xsp = xfreemallocs;
270         xfreemallocs =
271             (struct xfreelist *)afs_osi_Alloc_NoSleep(sizeof(struct xfreelist));
272 #else
273         ev = (struct rxevent *)osi_Alloc(sizeof(struct rxevent) *
274                                          rxevent_allocUnit);
275         xsp = xfreemallocs;
276         xfreemallocs =
277             (struct xfreelist *)osi_Alloc(sizeof(struct xfreelist));
278 #endif
279         xfreemallocs->mem = (void *)ev;
280         xfreemallocs->size = sizeof(struct rxevent) * rxevent_allocUnit;
281         xfreemallocs->next = xsp;
282         for (i = 0; i < rxevent_allocUnit; i++)
283             queue_Append(&rxevent_free, &ev[i]), rxevent_nFree++;
284 #endif
285     }
286
287     /* Grab and initialize a new rxevent structure */
288     ev = queue_First(&rxevent_free, rxevent);
289     queue_Remove(ev);
290     rxevent_nFree--;
291
292     /* Record user defined event state */
293     ev->eventTime = *when;
294     ev->func = func;
295     ev->arg = arg;
296     ev->arg1 = arg1;
297     ev->arg2 = arg2;
298     rxevent_nPosted += 1;       /* Rather than ++, to shut high-C up
299                                  *  regarding never-set variables
300                                  */
301
302     /* Insert the event into the sorted list of events for this epoch */
303     for (queue_ScanBackwards(&ep->events, evqe, evqpr, rxevent)) {
304         if (when->usec >= evqe->eventTime.usec) {
305             /* Insert event after evqe */
306             queue_InsertAfter(evqe, ev);
307             MUTEX_EXIT(&rxevent_lock);
308             return ev;
309         }
310     }
311     /* Insert event at head of current epoch */
312     queue_Prepend(&ep->events, ev);
313     if (isEarliest && rxevent_ScheduledEarlierEvent
314         && (!rxevent_raiseScheduled
315             || clock_Lt(&ev->eventTime, &rxevent_nextRaiseEvents))) {
316         rxevent_raiseScheduled = 1;
317         clock_Zero(&rxevent_nextRaiseEvents);
318         MUTEX_EXIT(&rxevent_lock);
319         /* Notify our external scheduler */
320         (*rxevent_ScheduledEarlierEvent) ();
321         MUTEX_ENTER(&rxevent_lock);
322     }
323     MUTEX_EXIT(&rxevent_lock);
324     return ev;
325 }
326
327 /* Cancel an event by moving it from the event queue to the free list.
328  * Warning, the event must be on the event queue!  If not, this should core
329  * dump (reference through 0).  This routine should be called using the macro
330  * event_Cancel, which checks for a null event and also nulls the caller's
331  * event pointer after cancelling the event.
332  */
333 #ifdef RX_ENABLE_LOCKS
334 #ifdef RX_REFCOUNT_CHECK
335 int rxevent_Cancel_type = 0;
336 #endif
337 #endif
338
339 void
340 rxevent_Cancel_1(struct rxevent *ev, struct rx_call *call,
341                  int type)
342 {
343 #ifdef RXDEBUG
344     if (rx_Log_event) {
345         struct clock now;
346         clock_GetTime(&now);
347         fprintf(rx_Log_event, "%d.%d: rxevent_Cancel_1(%d.%d, %"
348                 AFS_PTR_FMT ", %p" AFS_PTR_FMT ")\n",
349                 (int)now.sec, (int)now.usec, (int)ev->eventTime.sec,
350                 (int)ev->eventTime.usec, ev->func,
351                 ev->arg);
352     }
353 #endif
354     /* Append it to the free list (rather than prepending) to keep the free
355      * list hot so nothing pages out
356      */
357     MUTEX_ENTER(&rxevent_lock);
358     if (!ev) {
359         MUTEX_EXIT(&rxevent_lock);
360         return;
361     }
362 #ifdef RX_ENABLE_LOCKS
363     /* It's possible we're currently processing this event. */
364     if (queue_IsOnQueue(ev)) {
365         queue_MoveAppend(&rxevent_free, ev);
366         rxevent_nPosted--;
367         rxevent_nFree++;
368         if (call) {
369             call->refCount--;
370 #ifdef RX_REFCOUNT_CHECK
371             call->refCDebug[type]--;
372             if (call->refCDebug[type] < 0) {
373                 rxevent_Cancel_type = type;
374                 osi_Panic("rxevent_Cancel: call refCount < 0");
375             }
376 #endif /* RX_REFCOUNT_CHECK */
377         }
378     }
379 #else /* RX_ENABLE_LOCKS */
380     queue_MoveAppend(&rxevent_free, ev);
381     rxevent_nPosted--;
382     rxevent_nFree++;
383 #endif /* RX_ENABLE_LOCKS */
384     MUTEX_EXIT(&rxevent_lock);
385 }
386
387 /* Process all epochs that have expired relative to the current clock time
388  * (which is not re-evaluated unless clock_NewTime has been called).  The
389  * relative time to the next epoch is returned in the output parameter next
390  * and the function returns 1.  If there are is no next epoch, the function
391  * returns 0.
392  */
393 int
394 rxevent_RaiseEvents(struct clock *next)
395 {
396     struct rxepoch *ep;
397     struct rxevent *ev;
398     volatile struct clock now;
399     MUTEX_ENTER(&rxevent_lock);
400
401     /* Events are sorted by time, so only scan until an event is found that has
402      * not yet timed out */
403
404     clock_Zero(&now);
405     while (queue_IsNotEmpty(&rxepoch_queue)) {
406         ep = queue_First(&rxepoch_queue, rxepoch);
407         if (queue_IsEmpty(&ep->events)) {
408             queue_Remove(ep);
409             queue_Append(&rxepoch_free, ep);
410             rxepoch_nFree++;
411             continue;
412         }
413         do {
414         reraise:
415             ev = queue_First(&ep->events, rxevent);
416             if (clock_Lt(&now, &ev->eventTime)) {
417                 clock_GetTime(&now);
418                 if (clock_Gt(&rxevent_lastEvent, &now)) {
419                     struct clock adjTime = rxevent_lastEvent;
420                     int adjusted;
421                     clock_Sub(&adjTime, &now);
422                     adjusted = rxevent_adjTimes(&adjTime);
423                     rxevent_lastEvent = now;
424                     if (adjusted > 0)
425                         goto reraise;
426                 }
427                 if (clock_Lt(&now, &ev->eventTime)) {
428                     *next = rxevent_nextRaiseEvents = ev->eventTime;
429                     rxevent_raiseScheduled = 1;
430                     clock_Sub(next, &now);
431                     MUTEX_EXIT(&rxevent_lock);
432                     return 1;
433                 }
434             }
435             queue_Remove(ev);
436             rxevent_nPosted--;
437             MUTEX_EXIT(&rxevent_lock);
438             ev->func(ev, ev->arg, ev->arg1, ev->arg2);
439             MUTEX_ENTER(&rxevent_lock);
440             queue_Append(&rxevent_free, ev);
441             rxevent_nFree++;
442         } while (queue_IsNotEmpty(&ep->events));
443     }
444 #ifdef RXDEBUG
445     if (rx_Log_event)
446         fprintf(rx_Log_event, "rxevent_RaiseEvents(%d.%d)\n", (int)now.sec,
447                 (int)now.usec);
448 #endif
449     rxevent_raiseScheduled = 0;
450     MUTEX_EXIT(&rxevent_lock);
451     return 0;
452 }
453
454 void
455 shutdown_rxevent(void)
456 {
457     struct xfreelist *xp, *nxp;
458
459     LOCK_EV_INIT;
460     if (!rxevent_initialized) {
461         UNLOCK_EV_INIT;
462         return;
463     }
464     rxevent_initialized = 0;
465     UNLOCK_EV_INIT;
466     MUTEX_DESTROY(&rxevent_lock);
467 #if     defined(AFS_AIX32_ENV) && defined(KERNEL)
468     /* Everything is freed in afs_osinet.c */
469 #else
470     xp = xfreemallocs;
471     while (xp) {
472         nxp = xp->next;
473         osi_Free((char *)xp->mem, xp->size);
474         osi_Free((char *)xp, sizeof(struct xfreelist));
475         xp = nxp;
476     }
477     xfreemallocs = NULL;
478 #endif
479
480 }