![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to poll.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / streams / src|
Return to poll.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV4 1
3:
4:
5: /*
6: * Functions related to device polling support in the DDI/DKI.
7: */
8: /*
9: *-IMPORTS:
10: * <common/ccompat.h>
11: * __USE_PROTO__
12: * __ARGS ()
13: * <kernel/ddi_cpu.h>
14: * ddi_cpu_data ()
15: * <kernel/ddi_glob.h>
16: * ddi_global_data ()
17: * <kernel/ddi_lock.h>
18: * pollglob_hierarchy
19: * pollglob_priority
20: * pollhead_hierarchy
21: * pollhead_priority
22: * pollwait_hierarchy
23: * pollwait_priority
24: * <sys/debug.h>
25: * ASSERT ()
26: * <sys/kmem.h>
27: * KM_SLEEP
28: * kmem_alloc ()
29: * kmem_free ()
30: * <sys/ksynch.h>
31: * lkinfo_t
32: * LOCK ()
33: * LOCK_ALLOC ()
34: * LOCK_DEALLOC ()
35: * SV_ALLOC ()
36: * SV_DEALLOC ()
37: * SV_WAIT_SIG ()
38: * UNLOCK ()
39: * <sys/errno.h>
40: * EAGAIN
41: */
42:
43: #include <common/ccompat.h>
44: #include <kernel/ddi_cpu.h>
45: #include <kernel/ddi_glob.h>
46: #include <kernel/ddi_lock.h>
47: #include <sys/debug.h>
48: #include <sys/kmem.h>
49: #include <sys/ksynch.h>
50: #include <sys/errno.h>
51:
52: #include <sys/inline.h>
53: #include <stddef.h>
54: #include <limits.h>
55:
56: #include <common/_poll.h>
57: #include <sys/poll.h>
58: #include <poll.h>
59: #include <stropts.h>
60:
61:
62: /*
63: * The definition of the "pollhead" structure is kept private to this source
64: * file to avoid the temptation for other code to look at its members or
65: * allocate their own.
66: *
67: * Since we want to keep things fast, we use a circular-list scheme here,
68: * unlike most other places lists are maintained. For the DDI/DKI polling
69: * system, this is not a problem because list head items are allocated via
70: * phalloc (), which ensures that they are properly set up. For the old-style
71: * Coherent versions, we hope that they have been initialised to NULL and try
72: * and detect when they need setting up properly.
73: *
74: * The 'event_t' structure used in old-style Coherent polling is defined in
75: * <sys/poll.h>.
76: */
77:
78: typedef struct pollwait pwait_t;
79: typedef struct pollev pevent_t;
80: typedef struct pollhead phead_t;
81:
82:
83: /*
84: * For DDI/DKI polling, drivers get to deal in terms of a head of a list of
85: * events.
86: */
87:
88: struct pollhead {
89: poll_t ph_node;
90: lock_t * ph_lock;
91: };
92:
93:
94: /*
95: * Structure of a polled event for DDI/DKI polling. Since these structures are
96: * allocated from a pool in the "pollwait" structure, there is no explicit
97: * per-process linkage between events.
98: */
99:
100: struct pollev {
101: poll_t pe_node;
102: pwait_t * pe_pwait;
103: phead_t * pe_head;
104: short pe_events;
105: };
106:
107:
108: #if _OLD_COH_POLLING
109:
110: /*
111: * For old-style polling, we need a cell per event being waited on; however,
112: * since old-style polling only supported POLLIN, POLLOUT, and POLLPRI there
113: * is a small upper bound on the number we need.
114: */
115:
116: typedef struct old_poll o_event_t;
117:
118: struct old_poll {
119: poll_t op_node;
120: pwait_t * op_pwait;
121: };
122:
123: #endif /* _OLD_COH_POLLING */
124:
125:
126: /*
127: * A polling process allocates a 'pollwait' structure and goes to sleep on it
128: * after checking with all the items being polled. The 'pollwait' structure
129: * records if any events have been triggered after being checked but before
130: * the process has actually gone to sleep (ie, when it is checking other
131: * devices).
132: */
133:
134: enum {
135: PW_POLLING,
136: PW_SLEEPING,
137: PW_WOKEN
138: };
139:
140:
141: struct pollwait {
142: lock_t * pw_lock;
143: sv_t * pw_sleep;
144: int pw_sleeping;
145:
146: pevent_t * pw_events;
147: int pw_nevents;
148:
149: size_t pw_size; /* allocated size of structure */
150:
151: #if _OLD_COH_POLLING
152: /*
153: * The old-style events are allocated down from the top of the same
154: * chunk of memory used for the new-style events. 'pw_oevents' is the
155: * current base and is moved down each time a new entry is allocated.
156: */
157:
158: o_event_t * pw_oevents;
159: int pw_noevents;
160: #endif /* _OLD_COH_POLLING */
161: };
162:
163:
164: /*
165: * Declare the lock information structures at file scope.
166: */
167:
168: __LOCAL__ lkinfo_t _pollhead_lkinfo = {
169: "polling pollhead lock", INTERNAL_LOCK
170: };
171:
172: __LOCAL__ lkinfo_t _pollwait_lkinfo = {
173: "polling pollwait lock", INTERNAL_LOCK
174: };
175:
176:
177: /*
178: * Utility routine to initialize a 'pnode' for use as a circular list head.
179: */
180:
181: #define INIT_PNODE(pnp) ((pnp)->pn_next = (pnp)->pn_prev = (pnp))
182:
183:
184: /*
185: * Currently, we store the user's "pollwait" structure in the per-CPU data
186: * area. However, it seems prudent to encapsulate this fact. Note that the
187: * case to "pwait_t *" in GET_POLLWAIT () exists to satisfy PC-Lint's notion
188: * of strong typing.
189: */
190:
191: #define GET_POLLWAIT() ((pwait_t *) ddi_cpu_data ()->dc_pollwait)
192: #define SET_POLLWAIT(pw) (void) (ddi_cpu_data ()->dc_pollwait = (pw))
193:
194:
195: /*
196: * Some macros to save typing given the long, descriptive names of the lock-
197: * related constants.
198: */
199:
200: #define POLLWAIT_LOCK(pw) LOCK ((pw)->pw_lock, pollwait_priority)
201: #define POLLWAIT_UNLOCK(pw,p) UNLOCK ((pw)->pw_lock, (p))
202:
203: #define POLLHEAD_LOCK(ph) LOCK ((ph)->ph_lock, pollhead_priority)
204: #define POLLHEAD_UNLOCK(ph,p) UNLOCK ((ph)->ph_lock, (p))
205:
206: #define POLL_GLOBAL_LOCK() LOCK (ddi_global_data ()->dg_polllock, \
207: poll_global_priority)
208: #define POLL_GLOBAL_UNLOCK(p) UNLOCK (ddi_global_data ()->dg_polllock, (p))
209:
210:
211: #if 1
212:
213: /*
214: * Utility routine to fetch the address of the 'pollwait' structure allocated
215: * by the currently polling process, with extra checking.
216: */
217:
218: #if __USE_PROTO__
219: __LOCAL__ pwait_t * (GET_POLLWAIT) (void)
220: #else
221: __LOCAL__ pwait_t *
222: GET_POLLWAIT __ARGS (())
223: #endif
224: {
225: pwait_t * pwaitp;
226:
227: /*
228: * Since the current 'pollwait' value is recorded in the per-CPU data
229: * area, no locking is really necessary to ensure atomic access to the
230: * data. Actually, this might not be true for some CPUs such as Intel
231: * 80x86's, but access to the value is only defined within certain
232: * limited contexts anyway.
233: *
234: * Note that we cast from a "struct pollwait *" to a "pwait_t *" in
235: * order to be able to satisfy PC-lint's strong typing.
236: */
237:
238: pwaitp = GET_POLLWAIT ();
239:
240: ASSERT (pwaitp != NULL);
241:
242: return pwaitp;
243: }
244:
245: #undef GET_POLLWAIT
246:
247: #endif
248:
249:
250: /*
251: * Utility routine to deal with signalling an event to a process that has
252: * begun polling (but may not have gone to sleep yet).
253: */
254:
255: #if __USE_PROTO__
256: void (POLL_WAKE) (pwait_t * pwaitp)
257: #else
258: void
259: POLL_WAKE __ARGS ((pwaitp))
260: pwait_t * pwaitp;
261: #endif
262: {
263: pl_t prev_pl;
264:
265: prev_pl = POLLWAIT_LOCK (pwaitp);
266:
267: if (pwaitp->pw_sleeping == PW_SLEEPING)
268: SV_SIGNAL (pwaitp->pw_sleep, 0);
269:
270: pwaitp->pw_sleeping = PW_WOKEN;
271:
272: POLLWAIT_UNLOCK (pwaitp, prev_pl);
273: }
274:
275:
276: #if _OLD_COH_POLLING
277: /*
278: * The original Coherent polling system allocated event records at the time of
279: * the first call to pollopen () based on a patchable variable. If the
280: * patchable value was 0, then more event cells would be allocated (in blocks
281: * of 32) on demand and added to the event cell pool.
282: *
283: * In the new system, event cells are allocated at the time of entry to the
284: * poll () system call, meaning that there is some fixed allocation overhead
285: * per system call but that the event cells will be returned to a general
286: * pool.
287: */
288:
289:
290: /*
291: * This function (called by old-style device drivers) requests an association
292: * between the polling process and the device's list of polling processes. The
293: * contents of the list head and the method of association are opaque, except
294: * for the "e_procp" member of the event cell and the fact that the list head
295: * structure is used directly in data structure declarations in the driver
296: * rather than being managed by constructor/destructor routines.
297: *
298: * To get around the initialization problems, we must assume that such driver
299: * structures will be initially zero-filled.
300: *
301: * Callable ONLY from base level within a Coherent old-style device-driver
302: * poll () entry point.
303: */
304:
305: #if __USE_PROTO__
306: void (pollopen) (event_t * elistp)
307: #else
308: void
309: pollopen __ARGS ((elistp))
310: event_t * elistp;
311: #endif
312: {
313: pwait_t * pwaitp = GET_POLLWAIT ();
314: o_event_t * eventp;
315: pl_t prev_pl;
316:
317: /*
318: * Detect a zero-filled (hence uninitialised) list head. We use the
319: * circular list property to detect initialization.
320: */
321:
322: if (elistp->e_node.pn_next == NULL)
323: INIT_PNODE (& elistp->e_node);
324:
325: /*
326: * Take an event from the 'pollwait' structure.
327: */
328:
329: eventp = -- pwaitp->pw_oevents;
330: pwaitp->pw_noevents ++;
331:
332: ASSERT ((pevent_t *) eventp > & pwaitp->pw_events [pwaitp->pw_nevents]);
333:
334: /*
335: * String it all together. We use interrupt priority level to protect
336: * the insertion, because code that uses this code isn't going to be
337: * multiprocessor-safe anyway.
338: */
339:
340: eventp->op_pwait = pwaitp; /* link to polling process */
341:
342: prev_pl = splhi ();
343:
344: eventp->op_node.pn_next = elistp->e_node.pn_next;
345: eventp->op_node.pn_prev = & elistp->e_node;
346: eventp->op_node.pn_next->pn_prev = & eventp->op_node;
347: elistp->e_node.pn_next = & eventp->op_node;
348:
349: /*
350: * Set the magic flag.
351: */
352:
353: elistp->e_procp = (__VOID__ *) 1;
354:
355: (void) splx (prev_pl);
356: }
357:
358:
359: /*
360: * This routine signals all the polling processes that have been queued on
361: * this event list by pollopen () that an event they are interested in has
362: * occurred.
363: */
364:
365: #if __USE_PROTO__
366: void (pollwake) (event_t * elistp)
367: #else
368: void
369: pollwake __ARGS ((elistp))
370: event_t * elistp;
371: #endif
372: {
373: poll_t * pnodep;
374:
375: /*
376: * Since we have to maintain the magic header flag, we may as well use
377: * it as well.
378: */
379:
380: if (elistp->e_procp == 0)
381: return;
382:
383: elistp->e_procp = 0;
384:
385:
386: /*
387: * Service circularly-linked polls on device queue. It may be that the
388: * driver's circular list has not yet been initialized.
389: *
390: * We don't take out a lock because this system doesn't support them,
391: * and we don't need to manipulate interrupts because we don't modify
392: * the structure.
393: */
394:
395: if ((pnodep = elistp->e_node.pn_next) != NULL) {
396: /*
397: * We detect the end of the list when the circular walk has
398: * taken us back to the list head.
399: */
400:
401: while (pnodep != & elistp->e_node) {
402: /*
403: * Downcast from the node to the queued event cell,
404: * and wake the process.
405: */
406:
407: POLL_WAKE (__DOWNCAST (o_event_t, op_node,
408: pnodep)->op_pwait);
409:
410: pnodep = pnodep->pn_next;
411: }
412: }
413: }
414:
415:
416: /*
417: * This routine cleans up any old-style events.
418: */
419:
420: #if __USE_PROTO__
421: __LOCAL__ void (oldpollclean) (o_event_t * oevents, int noevents)
422: #else
423: __LOCAL__ void
424: oldpollclean __ARGS ((oevents, noevents))
425: o_event_t * oevents;
426: int noevents;
427: #endif
428: {
429: pl_t prev_pl;
430:
431: ASSERT (oevents != NULL);
432:
433: /*
434: * Iterate over the list of queued old-style events and dequeue each
435: * one.
436: */
437:
438: prev_pl = splhi ();
439:
440: while (noevents > 0) {
441:
442: oevents->op_node.pn_next->pn_prev = oevents->op_node.pn_prev;
443: oevents->op_node.pn_prev->pn_next = oevents->op_node.pn_next;
444:
445: noevents --;
446: oevents ++;
447: }
448:
449: splx (prev_pl);
450: }
451:
452: #endif /* _OLD_COH_POLLING */
453:
454:
455: /*
456: *-STATUS:
457: * DDI/DKI
458: *
459: *-NAME:
460: * phalloc Allocate and initialize a pollhead structure.
461: *
462: *-SYNOPSIS:
463: * #include <sys/poll.h>
464: * #include <sys/kmem.h>
465: *
466: * struct pollhead * phalloc (int flag);
467: *
468: *-ARGUMENTS:
469: * flag Specifies whether the caller is willing to sleep
470: * waiting for memory. If "flag" is set to "KM_SLEEP",
471: * the caller will sleep if necessary until sufficient
472: * memory is available. If "flag" is set to "KM_NOSLEEP",
473: * the caller will not sleep, but phalloc () will return
474: * NULL if sufficient memory is not immediately
475: * available.
476: *
477: *-DESCRIPTION:
478: * phalloc () allocates and initializes a "pollhead" structure for use by
479: * non-STREAMS character drivers that wish to support polling. The "flag"
480: * argument indicates whether the caller is willing to sleep waiting for
481: * memory as described above.
482: *
483: *-RETURN VALUE:
484: * Upon successful completion, phalloc () returns a pointer to the newly
485: * allocated "pollhead" structure. If "KM_NOSLEEP" is specified and
486: * sufficient memory is not immediately available, phalloc () returns a
487: * NULL pointer.
488: *
489: *-LEVEL:
490: * Base only if "flag" is set to "KM_SLEEP". Base or interrupt if "flag"
491: * is set to "KM_NOSLEEP".
492: *
493: *-NOTES:
494: * May sleep if slag is set to "KM_SLEEP".
495: *
496: * Driver-defined basic locks and read/write locks may be held across
497: * calls to this function if "flag" is "KM_NOSLEEP" but may not be held
498: * if "flag" is "KM_SLEEP".
499: *
500: * Driver-defined sleep locks may be held across calls to this function
501: * regardless of the value of "flag".
502: *
503: * DDI/DKI conforming drivers may only use "pollhead" structures which
504: * have been allocated and initialized using phalloc (). Use of
505: * "pollhead" structures which have been obtained by any other means is
506: * prohibited.
507: *
508: *-SEE ALSO:
509: * phfree (), pollwakeup ()
510: */
511:
512: #if __USE_PROTO__
513: struct pollhead * (phalloc) (int flag)
514: #else
515: struct pollhead *
516: phalloc __ARGS ((flag))
517: int flag;
518: #endif
519: {
520: struct pollhead * php;
521:
522: if ((php = (struct pollhead *) kmem_alloc (sizeof (* php), flag))
523: != NULL) {
524:
525: if ((php->ph_lock = LOCK_ALLOC (pollhead_hierarchy,
526: pollhead_priority,
527: & _pollhead_lkinfo,
528: flag)) == NULL) {
529: kmem_free (php, sizeof (* php));
530: return NULL;
531: }
532:
533: INIT_PNODE (& php->ph_node);
534: }
535:
536: return php;
537: }
538:
539:
540: /*
541: *-STATUS:
542: * DDI/DKI
543: *
544: *-NAME:
545: * phfree Free a pollhead structure.
546: *
547: *-SYNOPSIS:
548: * #include <sys/poll.h>
549: *
550: * void phfree (struct pollhead * php);
551: *
552: *-ARGUMENTS:
553: * php Pointer to the "pollhead" structure to be freed. The
554: * structure pointed to by "php" must have been
555: * previously allocated by a call to phalloc ().
556: *
557: *-DESCRIPTION:
558: * phfree () frees the "pollhead" structure specified by "php".
559: *
560: *-RETURN VALUE:
561: * None.
562: *
563: *-LEVEL:
564: * Base or interrupt.
565: *
566: *-NOTES:
567: * Does not sleep.
568: *
569: * Driver-defined basic locks, read/write locks, and sleep locks may be
570: * held across calls to this function.
571: *
572: * DDI/DKI conforming drivers may only use "pollhead" structures which
573: * have been allocated and initialized using phalloc (). Use of
574: * "pollhead" structures which have been obtained by any other means is
575: * prohibited.
576: *
577: *-SEE ALSO:
578: * phalloc (), pollwakeup ()
579: */
580:
581: #if __USE_PROTO__
582: void (phfree) (struct pollhead * php)
583: #else
584: void
585: phfree __ARGS ((php))
586: struct pollhead * php;
587: #endif
588: {
589: poll_t * pnodep;
590: poll_t * next;
591:
592: ASSERT (php != NULL);
593:
594: /*
595: * Since phalloc () and phfree () are not constrained to be used only
596: * in driver open/close routines, the possibility exists for a poll
597: * head structure to be deallocated while processes are waiting on it.
598: * This isn't very desirable, but it seems to be legal.
599: *
600: * After acquiring the global lock, we request a lock on the pollhead
601: * structure to ensure that all activity on the structure has
602: * completed before we begin to tear it down. Since the caller has
603: * requested deallocation of the structure, the caller should be
604: * confident that no-one will try and access it after any current
605: * activity has ceased.
606: *
607: * We engage in some subterfuge here in order to create a situation
608: * where we can detect any mistaken access.
609: */
610:
611:
612: {
613: pl_t prev_pl;
614: lock_t * lock = php->ph_lock;
615:
616: prev_pl = POLL_GLOBAL_LOCK ();
617: (void) LOCK (lock, pollhead_priority);
618:
619: php->ph_lock = NULL;
620:
621: POLL_GLOBAL_UNLOCK (pollhead_priority);
622: UNLOCK (lock, prev_pl);
623:
624: LOCK_DEALLOC (lock);
625: }
626:
627:
628: /*
629: * Walking over an entire circular list removing all the queue nodes
630: * allows a few simple optimizations; because we will be touching
631: * *every* node an dequeueing it, we don't need to engage in any
632: * real manipulation of the first/next nodes. In fact, since we almost
633: * immediately deallocate the structure, we don't have to touch the
634: * list head at all.
635: */
636:
637: next = php->ph_node.pn_next;
638:
639: while ((pnodep = next) != & php->ph_node) {
640: /*
641: * Doing this ensures that multiple attempts to dequeue this
642: * node (such as from the process polling cleanup routine)
643: * will have no effect. We could use the "pe_events" member of
644: * the event structure for this, but that would need a
645: * downcast and probably wouldn't result in higher
646: * performance.
647: */
648:
649: next = pnodep->pn_next;
650: pnodep->pn_prev = pnodep->pn_next = pnodep;
651: }
652:
653: kmem_free (php, sizeof (* php));
654: }
655:
656:
657: /*
658: *-STATUS:
659: * DDI/DKI
660: *
661: *-NAME:
662: * pollwakeup Inform polling process that an event has occurred.
663: *
664: *-SYNOPSIS:
665: * #include <sys/poll.h>
666: *
667: * void pollwakeup (struct pollhead * php, short event);
668: *
669: *-ARGUMENTS:
670: * php Pointer to a "pollhead" structure.
671: *
672: * event Event to notify the process about.
673: *
674: *-DESCRIPTION:
675: * The pollwakeup () function provides non-STREAMS character drivers with
676: * a way to notify processes polling for the occurrence of an event.
677: * pollwakeup () should be called from the driver for each occurrence of
678: * an event.
679: *
680: * The "pollhead" structure will usually be associated with the driver's
681: * private data structure for the particular minor device where the event
682: * has occurred.
683: *
684: *-RETURN VALUE:
685: * None.
686: *
687: *-LEVEL:
688: * Base or interrupt.
689: *
690: *-NOTES:
691: * Does not sleep.
692: *
693: * Driver-defined basic locks, read/write locks, and sleep locks may be
694: * held across calls to this function.
695: *
696: * pollwakeup () should only be called with one event at a time.
697: *
698: *-SEE ALSO:
699: * phalloc (), phfree ()
700: */
701:
702: #if __USE_PROTO__
703: void (pollwakeup) (struct pollhead * php, short event)
704: #else
705: void
706: pollwakeup __ARGS ((php, event))
707: struct pollhead * php;
708: short event;
709: #endif
710: {
711: poll_t * pnodep;
712: poll_t * next;
713: pl_t prev_pl;
714:
715: ASSERT (php != NULL);
716: ASSERT (event == POLLIN || event == POLLPRI || event == POLLOUT ||
717: event == POLLRDNORM || event == POLLWRNORM ||
718: event == POLLRDBAND || event == POLLWRBAND ||
719: event == POLLERR || event == POLLHUP);
720:
721: /*
722: * Acquire a lock on the pollhead structure after getting a global
723: * lock on the polling system.
724: */
725:
726: prev_pl = POLL_GLOBAL_LOCK ();
727:
728: POLLHEAD_LOCK (php);
729:
730: POLL_GLOBAL_UNLOCK (pollhead_priority);
731:
732:
733: /*
734: * Scan the list of queued processes and wake up (and dequeue) any
735: * that are waiting for the event being signalled.
736: */
737:
738: next = php->ph_node.pn_next;
739:
740: while ((pnodep = next) != & php->ph_node) {
741: pevent_t * eventp;
742:
743: next = pnodep->pn_next;
744: eventp = __DOWNCAST (pevent_t, pe_node, pnodep);
745:
746: if ((eventp->pe_events & event) != 0) {
747:
748: POLL_WAKE (eventp->pe_pwait);
749:
750: /*
751: * Perform a full general dequeue, and also change
752: * the node pointers so that a second request to
753: * dequeue the node has no effect.
754: */
755:
756: next->pn_prev = pnodep->pn_prev;
757: pnodep->pn_prev->pn_next = next;
758:
759: pnodep->pn_prev = pnodep->pn_next = pnodep;
760: }
761: }
762:
763: POLLHEAD_UNLOCK (php, prev_pl);
764: }
765:
766:
767: /*
768: * This internal function allocates and initializes a 'pollwait' structure on
769: * behalf of a process that wants to perform polling operations. The 'fds'
770: * argument specifies the number of devices/streams that are being polled.
771: *
772: * The newly-allocated structure is recorded in the per-CPU DDI/DKI data area,
773: * so that it is an error for the caller to sleep between a call to pwalloc ()
774: * and a call to pwsleep ().
775: *
776: * The return value is 0 on success, or an error number on failure (due to
777: * insufficient kernel memory). This function may sleep for memory to become
778: * available. Callable from base level only.
779: */
780:
781: #define _max(a,b) ((a) < (b) ? (b) : (a))
782:
783: enum {
784: #if _OLD_COH_POLLING
785: cellsize = _max (sizeof (pevent_t), 3 * sizeof (o_event_t))
786: #else
787: cellsize = sizeof (pevent_t)
788: #endif
789: };
790:
791: #if __USE_PROTO__
792: int (pwalloc) (int fds)
793: #else
794: int
795: pwalloc __ARGS ((fds))
796: int fds;
797: #endif
798: {
799: size_t size;
800: pwait_t * pwaitp;
801:
802: ASSERT (fds >= 0 && fds < INT_MAX / cellsize);
803: ASSERT (GET_POLLWAIT () == NULL);
804:
805: /*
806: * How much memory to allocate; we assume that at most three old-style
807: * event cells could be allocated per stream, or one new event cell.
808: */
809:
810: size = fds * cellsize + sizeof (pwait_t);
811:
812: if ((pwaitp = (pwait_t *) kmem_alloc (size, KM_SLEEP)) != NULL) {
813:
814: if ((pwaitp->pw_lock =
815: LOCK_ALLOC (pollwait_hierarchy,
816: pollwait_priority,
817: & _pollwait_lkinfo,
818: KM_SLEEP)) != NULL) {
819: if ((pwaitp->pw_sleep = SV_ALLOC (KM_SLEEP))
820: != NULL) {
821:
822: ASSERT (GET_POLLWAIT () == NULL);
823:
824: pwaitp->pw_sleeping = PW_POLLING;
825: pwaitp->pw_events = (pevent_t *) (pwaitp + 1);
826: pwaitp->pw_nevents = 0;
827: pwaitp->pw_size = size;
828: #if _OLD_COH_POLLING
829: pwaitp->pw_oevents = (o_event_t *)
830: ((char *) pwaitp + size);
831: pwaitp->pw_noevents = 0;
832: #endif
833: SET_POLLWAIT (pwaitp);
834: return 0;
835: }
836:
837: LOCK_DEALLOC (pwaitp->pw_lock);
838: }
839:
840: kmem_free (pwaitp, size);
841: }
842:
843: return EAGAIN;
844: }
845:
846:
847: /*
848: * This internal function is used by user-level polling code to go to sleep
849: * after checking with each device being polled (thus registering any event
850: * cells as necessary).
851: *
852: * May sleep. Callable from base level only. Returns 0 if woken by an
853: * indication that an event has occurred, or 1 if woken by a signal.
854: */
855:
856: #if __USE_PROTO__
857: int (pollsleep) (void)
858: #else
859: int
860: pollsleep __ARGS (())
861: #endif
862: {
863: pwait_t * pwaitp = GET_POLLWAIT ();
864: int sigwake = 0;
865:
866: ASSERT (pwaitp != NULL);
867:
868: /*
869: * Lock the structure before checking to see whether we want to go
870: * to sleep or not.
871: */
872:
873: (void) POLLWAIT_LOCK (pwaitp);
874:
875: if (pwaitp->pw_sleeping == PW_POLLING) {
876: /*
877: * No events were triggered while we were scanning all the
878: * requested channels, so we do actually have to sleep.
879: */
880:
881: SET_POLLWAIT (NULL);
882: pwaitp->pw_sleeping = PW_SLEEPING;
883:
884: sigwake = SV_WAIT_SIG (pwaitp->pw_sleep, prilo,
885: pwaitp->pw_lock) == 0;
886:
887: ASSERT (GET_POLLWAIT () == NULL);
888:
889: pwaitp->pw_sleeping = PW_WOKEN;
890: SET_POLLWAIT (pwaitp);
891: } else {
892:
893: ASSERT (pwaitp->pw_sleeping == PW_WOKEN);
894:
895: POLLWAIT_UNLOCK (pwaitp, plbase);
896: }
897:
898: return sigwake;
899: }
900:
901:
902: /*
903: * This local function deals with dequeuing event cells from device polling
904: * lists.
905: */
906:
907: #if __USE_PROTO__
908: __LOCAL__ void (pollclean) (pevent_t * events, int nevents)
909: #else
910: __LOCAL__ void
911: pollclean __ARGS ((events, nevents))
912: pevent_t * events;
913: int nevents;
914: #endif
915: {
916: pl_t prev_pl;
917:
918: ASSERT (events != NULL);
919:
920: /*
921: * Iterate over the list of queued events and dequeue each one.
922: */
923:
924: while (nevents > 0) {
925:
926: prev_pl = POLLHEAD_LOCK (events->pe_head);
927:
928: events->pe_node.pn_next->pn_prev = events->pe_node.pn_prev;
929: events->pe_node.pn_prev->pn_next = events->pe_node.pn_next;
930:
931: POLLHEAD_UNLOCK (events->pe_head, prev_pl);
932:
933: nevents --;
934: events ++;
935: }
936: }
937:
938:
939: /*
940: * This function destroys and deallocates all the resources taken up by a
941: * user poll-wait structure.
942: */
943:
944: #if __USE_PROTO__
945: void (pwfree) (void)
946: #else
947: void
948: pwfree __ARGS (())
949: #endif
950: {
951: pwait_t * pwaitp = GET_POLLWAIT ();
952:
953: ASSERT (pwaitp != NULL);
954:
955: #if _OLD_COH_POLLING
956: oldpollclean (pwaitp->pw_oevents, pwaitp->pw_noevents);
957: #endif
958:
959: pollclean (pwaitp->pw_events, pwaitp->pw_nevents);
960:
961: /*
962: * Now there is no way that an interrupt-level context could try and
963: * access the pollwait structure, we can safely deallocate it.
964: */
965:
966: SV_DEALLOC (pwaitp->pw_sleep);
967:
968: LOCK_DEALLOC (pwaitp->pw_lock);
969:
970: kmem_free (pwaitp, pwaitp->pw_size);
971: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.