![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to thread_call.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / kern|
Return to thread_call.c CVS log | Up to [Apple Darwin 0.x] / kernel / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1993, 1994, 1995 NeXT Computer, Inc.
27: *
28: * Thread-based callout module.
29: *
30: * 3 July 1993 ? at NeXT
31: * Created.
32: */
33:
34: #import <mach/mach_types.h>
35:
36: #import <kern/sched_prim.h>
37: #import <kern/clock.h>
38:
39: #import <kern/thread_call.h>
40: #import <kern/thread_call_private.h>
41:
42: #include <kern/kdebug.h>
43:
44: #define internal_call_num 768
45:
46: static
47: struct _thread_call
48: internal_call_storage[internal_call_num];
49:
50: static
51: simple_lock_data_t
52: thread_call_lock;
53:
54: static
55: queue_head_t
56: internal_call_free_queue,
57: pending_call_queue, delayed_call_queue;
58:
59: static int
60: pending_call_num, active_call_num,
61: call_thread_num;
62:
63: #define call_thread_min 4
64:
65: static boolean_t
66: thread_call_initialized = FALSE;
67:
68: static __inline__ _thread_call_t
69: _internal_call_allocate(void);
70:
71: static __inline__ _thread_call_t
72: thread_call_release(
73: _thread_call_t call
74: );
75:
76: static __inline__ void
77: _pending_call_enqueue(
78: _thread_call_t call
79: ),
80: _pending_call_dequeue(
81: _thread_call_t call
82: ),
83: _delayed_call_enqueue(
84: _thread_call_t call
85: ),
86: _delayed_call_dequeue(
87: _thread_call_t call
88: );
89:
90: static void __inline__
91: _set_delayed_call_timer(
92: _thread_call_t call
93: );
94:
95: static boolean_t
96: _remove_from_pending_queue(
97: thread_call_func_t func,
98: thread_call_spec_t spec,
99: boolean_t remove_all
100: ),
101: _remove_from_delayed_queue(
102: thread_call_func_t func,
103: thread_call_spec_t spec,
104: boolean_t remove_all
105: );
106:
107: static __inline__ void
108: _call_thread_wake(void);
109:
110: static void
111: _call_thread(void),
112: _call_activate_thread(void);
113:
114: static void
115: _delayed_call_interrupt(
116: tvalspec_t timestamp
117: );
118:
119: #define qe(x) ((queue_entry_t)(x))
120: #define TC(x) ((_thread_call_t)(x))
121:
122: /*
123: * Routine: thread_call_initialized [public]
124: *
125: * Description: Initialize this module, called
126: * early during system initialization.
127: *
128: * Preconditions: None.
129: *
130: * Postconditions: None.
131: */
132:
133: void
134: thread_call_init(void)
135: {
136: _thread_call_t call;
137:
138: if (thread_call_initialized)
139: panic("thread_call_init");
140:
141: simple_lock_init(&thread_call_lock);
142:
143: queue_init(&pending_call_queue);
144: queue_init(&delayed_call_queue);
145:
146: queue_init(&internal_call_free_queue);
147: for (
148: call = internal_call_storage;
149: call < &internal_call_storage[internal_call_num];
150: call++) {
151:
152: enqueue_tail(&internal_call_free_queue, qe(call));
153: }
154:
155: (void) kernel_thread(kernel_task, _call_activate_thread, (void *)0);
156:
157: timer_set_expire_func(SystemWide, (timer_func_t)_delayed_call_interrupt);
158:
159: thread_call_initialized = TRUE;
160: }
161:
162: /*
163: * Routine: _internal_call_allocate [private, inline]
164: *
165: * Purpose: Allocate an internal callout entry.
166: *
167: * Preconditions: thread_call_lock held.
168: *
169: * Postconditions: None.
170: */
171:
172: static __inline__ _thread_call_t
173: _internal_call_allocate(void)
174: {
175: _thread_call_t call;
176:
177: if (queue_empty(&internal_call_free_queue))
178: panic("_internal_call_allocate");
179:
180: call = TC(dequeue_head(&internal_call_free_queue));
181:
182: return (call);
183: }
184:
185: /*
186: * Routine: thread_call_release [private, inline]
187: *
188: * Purpose: Release a callout entry which is no
189: * longer pending (or delayed). Returns
190: * its argument for external entries, zero
191: * otherwise.
192: *
193: * Preconditions: thread_call_lock held.
194: *
195: * Postconditions: None.
196: */
197:
198: static __inline__
199: _thread_call_t
200: thread_call_release(
201: _thread_call_t call
202: )
203: {
204: if (
205: call >= internal_call_storage
206: &&
207: call < &internal_call_storage[internal_call_num]) {
208:
209: enqueue_tail(&internal_call_free_queue, qe(call)); call = 0;
210: }
211:
212: return (call);
213: }
214:
215: /*
216: * Routine: _pending_call_enqueue [private, inline]
217: *
218: * Purpose: Place an entry at the end of the
219: * pending queue, to be executed soon.
220: *
221: * Preconditions: thread_call_lock held.
222: *
223: * Postconditions: None.
224: */
225:
226: static __inline__
227: void
228: _pending_call_enqueue(
229: _thread_call_t call
230: )
231: {
232: enqueue_tail(&pending_call_queue, qe(call)); pending_call_num++;
233:
234: call->status = PENDING;
235: }
236:
237: /*
238: * Routine: _pending_call_dequeue [private, inline]
239: *
240: * Purpose: Remove an entry from the pending queue,
241: * effectively unscheduling it.
242: *
243: * Preconditions: thread_call_lock held.
244: *
245: * Postconditions: None.
246: */
247:
248: static __inline__
249: void
250: _pending_call_dequeue(
251: _thread_call_t call
252: )
253: {
254: remqueue(&pending_call_queue, qe(call)); pending_call_num--;
255:
256: call->status = IDLE;
257: }
258:
259: /*
260: * Routine: _delayed_call_enqueue [private, inline]
261: *
262: * Purpose: Place an entry on the delayed queue,
263: * after existing entries with an earlier
264: * (or identical) deadline.
265: *
266: * Preconditions: thread_call_lock held.
267: *
268: * Postconditions: None.
269: */
270:
271: static __inline__
272: void
273: _delayed_call_enqueue(
274: _thread_call_t call
275: )
276: {
277: _thread_call_t current;
278: int deadline_cmp;
279:
280: current = TC(queue_first(&delayed_call_queue));
281:
282: while (TRUE) {
283: if (
284: queue_end(&delayed_call_queue, qe(current))
285: ||
286: (deadline_cmp = CMP_TVALSPEC(&call->deadline,
287: ¤t->deadline)) < 0) {
288: current = TC(queue_prev(qe(current)));
289: break;
290: }
291: else if (deadline_cmp == 0)
292: break;
293:
294: current = TC(queue_next(qe(current)));
295: }
296:
297: insque(qe(call), qe(current));
298:
299: call->status = DELAYED;
300: }
301:
302: /*
303: * Routine: _delayed_call_dequeue [private, inline]
304: *
305: * Purpose: Remove an entry from the delayed queue,
306: * effectively unscheduling it.
307: *
308: * Preconditions: thread_call_lock held.
309: *
310: * Postconditions: None.
311: */
312:
313: static __inline__
314: void
315: _delayed_call_dequeue(
316: _thread_call_t call
317: )
318: {
319: remqueue(&delayed_call_queue, qe(call));
320:
321: call->status = IDLE;
322: }
323:
324: /*
325: * Routine: _set_delayed_call_timer [private]
326: *
327: * Purpose: Reset the timer so that it
328: * next expires when the entry is due.
329: *
330: * Preconditions: thread_call_lock held.
331: *
332: * Postconditions: None.
333: */
334:
335: static __inline__ void
336: _set_delayed_call_timer(
337: _thread_call_t call
338: )
339: {
340: timer_set_deadline(SystemWide, call->deadline);
341: }
342:
343: /*
344: * Routine: _remove_from_pending_queue [private]
345: *
346: * Purpose: Remove the first (or all) matching
347: * entries from the pending queue,
348: * effectively unscheduling them.
349: * Returns whether any matching entries
350: * were found for the !removeAll case,
351: * FALSE otherwise.
352: *
353: * Preconditions: thread_call_lock held.
354: *
355: * Postconditions: None.
356: */
357:
358: static
359: boolean_t
360: _remove_from_pending_queue(
361: thread_call_func_t func,
362: thread_call_spec_t spec,
363: boolean_t remove_all
364: )
365: {
366: boolean_t call_removed = FALSE;
367: _thread_call_t call;
368:
369: call = TC(queue_first(&pending_call_queue));
370:
371: while (!queue_end(&pending_call_queue, qe(call))) {
372: if (
373: call->func == func
374: &&
375: call->spec == spec) {
376: _thread_call_t next = TC(queue_next(qe(call)));
377:
378: _pending_call_dequeue(call);
379:
380: thread_call_release(call);
381:
382: call_removed = TRUE;
383: if (!remove_all)
384: break;
385:
386: call = next;
387: }
388: else
389: call = TC(queue_next(qe(call)));
390: }
391:
392: return (!remove_all? call_removed : FALSE);
393: }
394:
395: /*
396: * Routine: _remove_from_delayed_queue [private]
397: *
398: * Purpose: Remove the first (or all) matching
399: * entries from the delayed queue,
400: * effectively unscheduling them.
401: * Returns whether any matching entries
402: * were found for the !removeAll case,
403: * FALSE otherwise.
404: *
405: * Preconditions: thread_call_lock held.
406: *
407: * Postconditions: None.
408: */
409:
410: static
411: boolean_t
412: _remove_from_delayed_queue(
413: thread_call_func_t func,
414: thread_call_spec_t spec,
415: boolean_t remove_all
416: )
417: {
418: boolean_t call_removed = FALSE;
419: _thread_call_t call;
420:
421: call = TC(queue_first(&delayed_call_queue));
422:
423: while (!queue_end(&delayed_call_queue, qe(call))) {
424: if (
425: call->func == func
426: &&
427: call->spec == spec) {
428: _thread_call_t next = TC(queue_next(qe(call)));
429:
430: _delayed_call_dequeue(call);
431:
432: thread_call_release(call);
433:
434: call_removed = TRUE;
435: if (!remove_all)
436: break;
437:
438: call = next;
439: }
440: else
441: call = TC(queue_next(qe(call)));
442: }
443:
444: return (!remove_all? call_removed : FALSE);
445: }
446:
447: tvalspec_t
448: deadline_from_interval(
449: tvalspec_t interval
450: )
451: {
452: tvalspec_t result = clock_get_counter(System);
453:
454: ADD_TVALSPEC(&result, &interval);
455:
456: return (result);
457: }
458:
459: /*
460: * Routine: thread_call_func [public]
461: *
462: * Purpose: Schedule a function callout.
463: * Guarantees { function, argument }
464: * uniqueness if unique_call is TRUE.
465: *
466: * Preconditions: Callable from an interrupt context
467: * below splsched.
468: *
469: * Postconditions: None.
470: */
471:
472: void
473: thread_call_func(
474: thread_call_func_t func,
475: thread_call_spec_t spec,
476: boolean_t unique_call
477: )
478: {
479: _thread_call_t call;
480: int s;
481:
482: if (!thread_call_initialized)
483: panic("thread_call_func_unique");
484:
485: s = splsched();
486:
487: simple_lock(&thread_call_lock);
488:
489: call = TC(queue_first(&pending_call_queue));
490:
491: if (unique_call) while (!queue_end(&pending_call_queue, qe(call))) {
492: if (
493: call->func == func
494: &&
495: call->spec == spec) {
496:
497: break;
498: }
499:
500: call = TC(queue_next(qe(call)));
501: }
502:
503: if (!unique_call || queue_end(&pending_call_queue, qe(call))) {
504:
505: call = _internal_call_allocate();
506:
507: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_CALLOUT),
508: 0, call->func, call->spec,
509: 0, 0);
510: call->func = func;
511: call->spec = spec;
512: call->spec_proto = 0;
513:
514: _pending_call_enqueue(call);
515:
516: _call_thread_wake();
517: }
518: else
519: simple_unlock(&thread_call_lock);
520:
521: splx(s);
522: }
523:
524: /*
525: * Routine: thread_call_func_delayed [public]
526: *
527: * Purpose: Schedule a function callout to
528: * occur at the stated time.
529: *
530: * Preconditions: Callable from an interrupt context
531: * below splsched.
532: *
533: * Postconditions: None.
534: */
535:
536: void
537: thread_call_func_delayed(
538: thread_call_func_t func,
539: thread_call_spec_t spec,
540: tvalspec_t deadline
541: )
542: {
543: _thread_call_t call;
544: int s;
545:
546: if (!thread_call_initialized)
547: panic("thread_call_func_delayed");
548:
549: if (BAD_TVALSPEC(&deadline))
550: deadline = TVALSPEC_ZERO;
551:
552: s = splsched();
553:
554: simple_lock(&thread_call_lock);
555:
556: call = _internal_call_allocate();
557:
558: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_CALLOUT),
559: 1, func, spec,
560: deadline.tv_sec, deadline.tv_nsec);
561: call->func = func;
562: call->spec = spec;
563: call->spec_proto = 0;
564: call->deadline = deadline;
565:
566: _delayed_call_enqueue(call);
567:
568: if (queue_first(&delayed_call_queue) == qe(call))
569: _set_delayed_call_timer(call);
570:
571: simple_unlock(&thread_call_lock);
572:
573: splx(s);
574: }
575:
576: /*
577: * Routine: thread_call_func_cancel [public]
578: *
579: * Purpose: Unschedule a function callout.
580: * Removes one (or all)
581: * { function, argument }
582: * instance(s) from either (or both)
583: * the pending and the delayed queue,
584: * in that order.
585: *
586: * Preconditions: Callable from an interrupt context
587: * below splsched.
588: *
589: * Postconditions: None.
590: */
591:
592: void
593: thread_call_func_cancel(
594: thread_call_func_t func,
595: thread_call_spec_t spec,
596: boolean_t cancel_all
597: )
598: {
599: int s;
600:
601: s = splsched();
602:
603: simple_lock(&thread_call_lock);
604:
605: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_CALLOUT),
606: 2, func, spec,
607: cancel_all, 0);
608: _remove_from_pending_queue(func, spec, cancel_all) ||
609: _remove_from_delayed_queue(func, spec, cancel_all);
610:
611: simple_unlock(&thread_call_lock);
612:
613: splx(s);
614: }
615:
616: /*
617: * Routine: thread_call_allocate [public]
618: *
619: * Purpose: Allocate an external callout
620: * entry.
621: *
622: * Preconditions: None.
623: *
624: * Postconditions: None.
625: */
626:
627: thread_call_t
628: thread_call_allocate(
629: thread_call_func_t func,
630: thread_call_spec_t spec
631: )
632: {
633: _thread_call_t call = (void *)kalloc(sizeof (struct _thread_call));
634:
635: call->func = func;
636: call->spec = 0;
637: call->spec_proto = spec;
638: call->deadline = TVALSPEC_ZERO;
639: call->status = IDLE;
640:
641: return (call);
642: }
643:
644: /*
645: * Routine: thread_call_free [public]
646: *
647: * Purpose: Free an external callout
648: * entry.
649: *
650: * Preconditions: None.
651: *
652: * Postconditions: None.
653: */
654:
655: void
656: thread_call_free(
657: thread_call_t _call
658: )
659: {
660: _thread_call_t call = _call;
661: int s;
662:
663: s = splsched();
664:
665: simple_lock(&thread_call_lock);
666:
667: if (call->status != IDLE) {
668: simple_unlock(&thread_call_lock);
669: panic("thread_call_free");
670: }
671:
672: simple_unlock(&thread_call_lock);
673:
674: splx(s);
675:
676: kfree((void *)call, sizeof (struct _thread_call));
677: }
678:
679: /*
680: * Routine: thread_call_enter [public]
681: *
682: * Purpose: Schedule an external callout
683: * entry. There is no effect if
684: * the entry is not idle.
685: *
686: * Preconditions: Callable from an interrupt context
687: * below splsched.
688: *
689: * Postconditions: None.
690: */
691:
692: void
693: thread_call_enter(
694: thread_call_t _call
695: )
696: {
697: _thread_call_t call = _call;
698: int s;
699:
700: s = splsched();
701:
702: simple_lock(&thread_call_lock);
703:
704: if (call->status == IDLE) {
705: call->spec = call->spec_proto;
706:
707: _pending_call_enqueue(call);
708:
709: _call_thread_wake();
710: }
711: else
712: simple_unlock(&thread_call_lock);
713:
714: splx(s);
715: }
716:
717: void
718: thread_call_enter_spec(
719: thread_call_t _call,
720: thread_call_spec_t spec
721: )
722: {
723: _thread_call_t call = _call;
724: int s;
725:
726: s = splsched();
727:
728: simple_lock(&thread_call_lock);
729:
730: if (call->status == IDLE) {
731: call->spec = spec;
732:
733: _pending_call_enqueue(call);
734:
735: _call_thread_wake();
736: }
737: else
738: simple_unlock(&thread_call_lock);
739:
740: splx(s);
741: }
742:
743: /*
744: * Routine: thread_call_enter_delayed [public]
745: *
746: * Purpose: Schedule an external callout
747: * entry to occur at the stated time.
748: * There is no effect if the entry
749: * is not idle.
750: *
751: * Preconditions: Callable from an interrupt context
752: * below splsched.
753: *
754: * Postconditions: None.
755: */
756:
757: void
758: thread_call_enter_delayed(
759: thread_call_t _call,
760: tvalspec_t deadline
761: )
762: {
763: _thread_call_t call = _call;
764: int s;
765:
766: if (BAD_TVALSPEC(&deadline))
767: deadline = TVALSPEC_ZERO;
768:
769: s = splsched();
770:
771: simple_lock(&thread_call_lock);
772:
773: if (call->status == IDLE) {
774: call->spec = call->spec_proto;
775: call->deadline = deadline;
776:
777: _delayed_call_enqueue(call);
778:
779: if (queue_first(&delayed_call_queue) == qe(call))
780: _set_delayed_call_timer(call);
781: }
782:
783: simple_unlock(&thread_call_lock);
784:
785: splx(s);
786: }
787:
788: void
789: thread_call_enter_spec_delayed(
790: thread_call_t _call,
791: thread_call_spec_t spec,
792: tvalspec_t deadline
793: )
794: {
795: _thread_call_t call = _call;
796: int s;
797:
798: if (BAD_TVALSPEC(&deadline))
799: deadline = TVALSPEC_ZERO;
800:
801: s = splsched();
802:
803: simple_lock(&thread_call_lock);
804:
805: if (call->status == IDLE) {
806: call->spec = spec;
807: call->deadline = deadline;
808:
809: _delayed_call_enqueue(call);
810:
811: if (queue_first(&delayed_call_queue) == qe(call))
812: _set_delayed_call_timer(call);
813: }
814:
815: simple_unlock(&thread_call_lock);
816:
817: splx(s);
818: }
819:
820: /*
821: * Routine: thread_call_cancel [public]
822: *
823: * Purpose: Unschedule a callout entry.
824: * There is no effect if the
825: * entry is already idle.
826: *
827: * Preconditions: Callable from an interrupt context
828: * below splsched.
829: *
830: * Postconditions: None.
831: */
832:
833: void
834: thread_call_cancel(
835: thread_call_t _call
836: )
837: {
838: _thread_call_t call = _call;
839: int s;
840:
841: s = splsched();
842:
843: simple_lock(&thread_call_lock);
844:
845: if (call->status == PENDING) {
846: _pending_call_dequeue(call);
847:
848: thread_call_release(call);
849: }
850: else if (call->status == DELAYED) {
851: _delayed_call_dequeue(call);
852:
853: thread_call_release(call);
854: }
855: else
856: /* do nothing */;
857:
858: simple_unlock(&thread_call_lock);
859:
860: splx(s);
861: }
862:
863: /*
864: * Routine: _call_thread_wake [private]
865: *
866: * Purpose: Wakeup one callout thread to handle
867: * a new callout entry. May wakeup
868: * the callout activate thread to
869: * create a new callout thread.
870: *
871: * Preconditions: thread_call_lock held.
872: *
873: * Postconditions: thread_call_lock released.
874: */
875:
876: static __inline__
877: void
878: _call_thread_wake(void)
879: {
880: boolean_t wake_activate_thread = FALSE;
881:
882: if (call_thread_num < (active_call_num + pending_call_num))
883: wake_activate_thread = TRUE;
884:
885: simple_unlock(&thread_call_lock);
886:
887: thread_wakeup_one(&pending_call_num);
888:
889: if (wake_activate_thread)
890: thread_wakeup_one(&call_thread_num);
891: }
892:
893: /*
894: * Routine: _call_thread [private]
895: *
896: * Purpose: Executed by a callout thread.
897: *
898: * Preconditions: None.
899: *
900: * Postconditions: None.
901: */
902:
903: static
904: void
905: _call_thread_continue(void)
906: {
907: thread_t self = current_thread();
908:
909: (void) splsched();
910:
911: simple_lock(&thread_call_lock);
912:
913: while (pending_call_num > 0) {
914: _thread_call_t call;
915: thread_call_func_t func;
916: thread_call_spec_t spec;
917:
918: call = TC(dequeue_head(&pending_call_queue)); pending_call_num--;
919:
920: func = call->func;
921: spec = call->spec;
922:
923: call->status = IDLE;
924:
925: call = thread_call_release(call);
926:
927: active_call_num++; simple_unlock(&thread_call_lock);
928:
929: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_CALLOUT) | DBG_FUNC_START,
930: 3, self, func,
931: spec, 0);
932:
933: (void) spl0(); (*func)(spec, call); (void) splsched();
934:
935: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_CALLOUT) | DBG_FUNC_END,
936: 4, self,
937: func, spec,
938: 0);
939:
940: simple_lock(&thread_call_lock); active_call_num--;
941: }
942:
943: if ((call_thread_num - active_call_num) <= call_thread_min) {
944:
945: assert_wait(&pending_call_num, FALSE);
946:
947: simple_unlock(&thread_call_lock);
948:
949: thread_block_with_continuation(_call_thread_continue);
950: /* NOTREACHED */
951: }
952:
953: call_thread_num--;
954:
955: simple_unlock(&thread_call_lock);
956:
957: (void) spl0();
958:
959: (void) thread_terminate(self); thread_halt_self();
960: }
961:
962: static
963: void
964: _call_thread(void)
965: {
966: stack_privilege(current_thread());
967:
968: _call_thread_continue();
969: /* NOTREACHED */
970: }
971:
972: /*
973: * Routine: _call_activate_thread [private]
974: *
975: * Purpose: Executed by the callout activate thread.
976: *
977: * Preconditions: None.
978: *
979: * Postconditions: Never terminates.
980: */
981:
982: static
983: void
984: _call_activate_thread_continue(void)
985: {
986: thread_t self = current_thread();
987:
988: (void) splsched();
989:
990: simple_lock(&thread_call_lock);
991:
992: if (call_thread_num < (active_call_num + pending_call_num)) {
993:
994: call_thread_num++; simple_unlock(&thread_call_lock);
995:
996: (void) kernel_thread(self->task, _call_thread, (void *)0);
997:
998: thread_block_with_continuation(_call_activate_thread_continue);
999: /* NOTREACHED */
1000: }
1001:
1002: assert_wait(&call_thread_num, FALSE);
1003:
1004: simple_unlock(&thread_call_lock);
1005:
1006: thread_block_with_continuation(_call_activate_thread_continue);
1007: /* NOTREACHED */
1008: }
1009:
1010: static
1011: void
1012: _call_activate_thread(void)
1013: {
1014: stack_privilege(current_thread());
1015:
1016: _call_activate_thread_continue();
1017: /* NOTREACHED */
1018: }
1019:
1020: static
1021: void
1022: _delayed_call_interrupt(
1023: tvalspec_t timestamp
1024: )
1025: {
1026: _thread_call_t call;
1027: queue_head_t intransit_call_queue;
1028: int s;
1029:
1030: queue_init(&intransit_call_queue);
1031:
1032: s = splsched();
1033:
1034: simple_lock(&thread_call_lock);
1035:
1036: call = TC(queue_first(&delayed_call_queue));
1037:
1038: while (!queue_end(&delayed_call_queue, qe(call))) {
1039: if (CMP_TVALSPEC(&call->deadline, ×tamp) <= 0) {
1040: _delayed_call_dequeue(call);
1041:
1042: enqueue_tail(&intransit_call_queue, qe(call));
1043: }
1044: else
1045: break;
1046:
1047: call = TC(queue_first(&delayed_call_queue));
1048: }
1049:
1050: if (!queue_end(&delayed_call_queue, qe(call)))
1051: _set_delayed_call_timer(call);
1052:
1053: while (call = TC(dequeue_head(&intransit_call_queue))) {
1054: _pending_call_enqueue(call);
1055:
1056: _call_thread_wake();
1057:
1058: simple_lock(&thread_call_lock);
1059: }
1060:
1061: simple_unlock(&thread_call_lock);
1062:
1063: splx(s);
1064: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.