![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to thread.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / kern|
Return to thread.c CVS log | Up to [GnuMach] / Gnu-Mach / kern |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1994-1987 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: kern/thread.c
28: * Author: Avadis Tevanian, Jr., Michael Wayne Young, David Golub
29: * Date: 1986
30: *
31: * Thread management primitives implementation.
32: */
33:
34: #include <cpus.h>
35: #include <hw_footprint.h>
36: #include <mach_host.h>
37: #include <mach_fixpri.h>
38: #include <mach_pcsample.h>
39: #include <simple_clock.h>
40: #include <mach_debug.h>
41: #include <net_atm.h>
42:
43: #include <mach/std_types.h>
44: #include <mach/policy.h>
45: #include <mach/thread_info.h>
46: #include <mach/thread_special_ports.h>
47: #include <mach/thread_status.h>
48: #include <mach/time_value.h>
49: #include "vm_param.h"
50: #include <kern/ast.h>
51: #include <kern/counters.h>
52: #include <kern/ipc_tt.h>
53: #include <kern/mach_param.h>
54: #include <kern/processor.h>
55: #include <kern/queue.h>
56: #include <kern/sched.h>
57: #include <kern/sched_prim.h>
58: #include <kern/thread.h>
59: #include <kern/thread_swap.h>
60: #include <kern/host.h>
61: #include <kern/zalloc.h>
62: #include <vm/vm_kern.h>
63: #include <ipc/ipc_kmsg.h>
64: #include <ipc/ipc_port.h>
65: #include <ipc/mach_msg.h>
66: #include <machine/machspl.h> /* for splsched */
67: #include <machine/thread.h> /* for MACHINE_STACK */
68:
69: #if NET_ATM
70: #include <chips/nw_mk.h>
71: #endif
72:
73: thread_t active_threads[NCPUS];
74: vm_offset_t active_stacks[NCPUS];
75:
76: struct zone *thread_zone;
77:
78: queue_head_t reaper_queue;
79: decl_simple_lock_data(, reaper_lock)
80:
81: extern int tick;
82:
83: extern void pcb_module_init(void);
84:
85: /* private */
86: struct thread thread_template;
87:
88: #if MACH_DEBUG
89: void stack_init(vm_offset_t stack); /* forward */
90: void stack_finalize(vm_offset_t stack); /* forward */
91:
92: #define STACK_MARKER 0xdeadbeefU
93: boolean_t stack_check_usage = FALSE;
94: decl_simple_lock_data(, stack_usage_lock)
95: vm_size_t stack_max_usage = 0;
96: #endif /* MACH_DEBUG */
97:
98: /*
99: * Machine-dependent code must define:
100: * pcb_init
101: * pcb_terminate
102: * pcb_collect
103: *
104: * The thread->pcb field is reserved for machine-dependent code.
105: */
106:
107: #ifdef MACHINE_STACK
108: /*
109: * Machine-dependent code must define:
110: * stack_alloc_try
111: * stack_alloc
112: * stack_free
113: * stack_handoff
114: * stack_collect
115: * and if MACH_DEBUG:
116: * stack_statistics
117: */
118: #else /* MACHINE_STACK */
119: /*
120: * We allocate stacks from generic kernel VM.
121: * Machine-dependent code must define:
122: * stack_attach
123: * stack_detach
124: * stack_handoff
125: *
126: * The stack_free_list can only be accessed at splsched,
127: * because stack_alloc_try/thread_invoke operate at splsched.
128: */
129:
130: decl_simple_lock_data(, stack_lock_data)/* splsched only */
131: #define stack_lock() simple_lock(&stack_lock_data)
132: #define stack_unlock() simple_unlock(&stack_lock_data)
133:
134: vm_offset_t stack_free_list; /* splsched only */
135: unsigned int stack_free_count = 0; /* splsched only */
136: unsigned int stack_free_limit = 1; /* patchable */
137:
138: unsigned int stack_alloc_hits = 0; /* debugging */
139: unsigned int stack_alloc_misses = 0; /* debugging */
140: unsigned int stack_alloc_max = 0; /* debugging */
141:
142: /*
143: * The next field is at the base of the stack,
144: * so the low end is left unsullied.
145: */
146:
147: #define stack_next(stack) (*((vm_offset_t *)((stack) + KERNEL_STACK_SIZE) - 1))
148:
149: /*
150: * stack_alloc_try:
151: *
152: * Non-blocking attempt to allocate a kernel stack.
153: * Called at splsched with the thread locked.
154: */
155:
156: boolean_t stack_alloc_try(
157: thread_t thread,
158: void (*resume)(thread_t))
159: {
160: register vm_offset_t stack;
161:
162: stack_lock();
163: stack = stack_free_list;
164: if (stack != 0) {
165: stack_free_list = stack_next(stack);
166: stack_free_count--;
167: } else {
168: stack = thread->stack_privilege;
169: }
170: stack_unlock();
171:
172: if (stack != 0) {
173: stack_attach(thread, stack, resume);
174: stack_alloc_hits++;
175: return TRUE;
176: } else {
177: stack_alloc_misses++;
178: return FALSE;
179: }
180: }
181:
182: /*
183: * stack_alloc:
184: *
185: * Allocate a kernel stack for a thread.
186: * May block.
187: */
188:
189: void stack_alloc(
190: thread_t thread,
191: void (*resume)(thread_t))
192: {
193: vm_offset_t stack;
194: spl_t s;
195:
196: /*
197: * We first try the free list. It is probably empty,
198: * or stack_alloc_try would have succeeded, but possibly
199: * a stack was freed before the swapin thread got to us.
200: */
201:
202: s = splsched();
203: stack_lock();
204: stack = stack_free_list;
205: if (stack != 0) {
206: stack_free_list = stack_next(stack);
207: stack_free_count--;
208: }
209: stack_unlock();
210: (void) splx(s);
211:
212: if (stack == 0) {
213: /*
214: * Kernel stacks should be naturally aligned,
215: * so that it is easy to find the starting/ending
216: * addresses of a stack given an address in the middle.
217: */
218:
219: if (kmem_alloc_aligned(kernel_map, &stack, KERNEL_STACK_SIZE)
220: != KERN_SUCCESS)
221: panic("stack_alloc");
222:
223: #if MACH_DEBUG
224: stack_init(stack);
225: #endif /* MACH_DEBUG */
226: }
227:
228: stack_attach(thread, stack, resume);
229: }
230:
231: /*
232: * stack_free:
233: *
234: * Free a thread's kernel stack.
235: * Called at splsched with the thread locked.
236: */
237:
238: void stack_free(
239: thread_t thread)
240: {
241: register vm_offset_t stack;
242:
243: stack = stack_detach(thread);
244:
245: if (stack != thread->stack_privilege) {
246: stack_lock();
247: stack_next(stack) = stack_free_list;
248: stack_free_list = stack;
249: if (++stack_free_count > stack_alloc_max)
250: stack_alloc_max = stack_free_count;
251: stack_unlock();
252: }
253: }
254:
255: /*
256: * stack_collect:
257: *
258: * Free excess kernel stacks.
259: * May block.
260: */
261:
262: void stack_collect(void)
263: {
264: register vm_offset_t stack;
265: spl_t s;
266:
267: s = splsched();
268: stack_lock();
269: while (stack_free_count > stack_free_limit) {
270: stack = stack_free_list;
271: stack_free_list = stack_next(stack);
272: stack_free_count--;
273: stack_unlock();
274: (void) splx(s);
275:
276: #if MACH_DEBUG
277: stack_finalize(stack);
278: #endif /* MACH_DEBUG */
279: kmem_free(kernel_map, stack, KERNEL_STACK_SIZE);
280:
281: s = splsched();
282: stack_lock();
283: }
284: stack_unlock();
285: (void) splx(s);
286: }
287: #endif /* MACHINE_STACK */
288:
289: /*
290: * stack_privilege:
291: *
292: * stack_alloc_try on this thread must always succeed.
293: */
294:
295: void stack_privilege(
296: register thread_t thread)
297: {
298: /*
299: * This implementation only works for the current thread.
300: */
301:
302: if (thread != current_thread())
303: panic("stack_privilege");
304:
305: if (thread->stack_privilege == 0)
306: thread->stack_privilege = current_stack();
307: }
308:
309: void thread_init(void)
310: {
311: thread_zone = zinit(
312: sizeof(struct thread),
313: THREAD_MAX * sizeof(struct thread),
314: THREAD_CHUNK * sizeof(struct thread),
315: 0, "threads");
316:
317: /*
318: * Fill in a template thread for fast initialization.
319: * [Fields that must be (or are typically) reset at
320: * time of creation are so noted.]
321: */
322:
323: /* thread_template.links (none) */
324: thread_template.runq = RUN_QUEUE_NULL;
325:
326: /* thread_template.task (later) */
327: /* thread_template.thread_list (later) */
328: /* thread_template.pset_threads (later) */
329:
330: /* thread_template.lock (later) */
331: /* one ref for being alive; one for the guy who creates the thread */
332: thread_template.ref_count = 2;
333:
334: thread_template.pcb = (pcb_t) 0; /* (reset) */
335: thread_template.kernel_stack = (vm_offset_t) 0;
336: thread_template.stack_privilege = (vm_offset_t) 0;
337:
338: thread_template.wait_event = 0;
339: /* thread_template.suspend_count (later) */
340: thread_template.wait_result = KERN_SUCCESS;
341: thread_template.wake_active = FALSE;
342: thread_template.state = TH_SUSP | TH_SWAPPED;
343: thread_template.swap_func = thread_bootstrap_return;
344:
345: /* thread_template.priority (later) */
346: thread_template.max_priority = BASEPRI_USER;
347: /* thread_template.sched_pri (later - compute_priority) */
348: #if MACH_FIXPRI
349: thread_template.sched_data = 0;
350: thread_template.policy = POLICY_TIMESHARE;
351: #endif /* MACH_FIXPRI */
352: thread_template.depress_priority = -1;
353: thread_template.cpu_usage = 0;
354: thread_template.sched_usage = 0;
355: /* thread_template.sched_stamp (later) */
356:
357: thread_template.recover = (vm_offset_t) 0;
358: thread_template.vm_privilege = FALSE;
359:
360: thread_template.user_stop_count = 1;
361:
362: /* thread_template.<IPC structures> (later) */
363:
364: timer_init(&(thread_template.user_timer));
365: timer_init(&(thread_template.system_timer));
366: thread_template.user_timer_save.low = 0;
367: thread_template.user_timer_save.high = 0;
368: thread_template.system_timer_save.low = 0;
369: thread_template.system_timer_save.high = 0;
370: thread_template.cpu_delta = 0;
371: thread_template.sched_delta = 0;
372:
373: thread_template.active = FALSE; /* reset */
374: thread_template.ast = AST_ZILCH;
375:
376: /* thread_template.processor_set (later) */
377: thread_template.bound_processor = PROCESSOR_NULL;
378: #if MACH_HOST
379: thread_template.may_assign = TRUE;
380: thread_template.assign_active = FALSE;
381: #endif /* MACH_HOST */
382:
383: #if NCPUS > 1
384: /* thread_template.last_processor (later) */
385: #endif /* NCPUS > 1 */
386:
387: /*
388: * Initialize other data structures used in
389: * this module.
390: */
391:
392: queue_init(&reaper_queue);
393: simple_lock_init(&reaper_lock);
394:
395: #ifndef MACHINE_STACK
396: simple_lock_init(&stack_lock_data);
397: #endif /* MACHINE_STACK */
398:
399: #if MACH_DEBUG
400: simple_lock_init(&stack_usage_lock);
401: #endif /* MACH_DEBUG */
402:
403: /*
404: * Initialize any machine-dependent
405: * per-thread structures necessary.
406: */
407:
408: pcb_module_init();
409: }
410:
411: kern_return_t thread_create(
412: register task_t parent_task,
413: thread_t *child_thread) /* OUT */
414: {
415: register thread_t new_thread;
416: register processor_set_t pset;
417:
418: if (parent_task == TASK_NULL)
419: return KERN_INVALID_ARGUMENT;
420:
421: /*
422: * Allocate a thread and initialize static fields
423: */
424:
425: new_thread = (thread_t) zalloc(thread_zone);
426:
427: if (new_thread == THREAD_NULL)
428: return KERN_RESOURCE_SHORTAGE;
429:
430: *new_thread = thread_template;
431:
432: /*
433: * Initialize runtime-dependent fields
434: */
435:
436: new_thread->task = parent_task;
437: simple_lock_init(&new_thread->lock);
438: new_thread->sched_stamp = sched_tick;
439: thread_timeout_setup(new_thread);
440:
441: /*
442: * Create a pcb. The kernel stack is created later,
443: * when the thread is swapped-in.
444: */
445: pcb_init(new_thread);
446:
447: ipc_thread_init(new_thread);
448:
449: #if NET_ATM
450: new_thread->nw_ep_waited = 0;
451: #endif
452:
453: /*
454: * Find the processor set for the parent task.
455: */
456: task_lock(parent_task);
457: pset = parent_task->processor_set;
458: pset_reference(pset);
459: task_unlock(parent_task);
460:
461: /*
462: * Lock both the processor set and the task,
463: * so that the thread can be added to both
464: * simultaneously. Processor set must be
465: * locked first.
466: */
467:
468: Restart:
469: pset_lock(pset);
470: task_lock(parent_task);
471:
472: /*
473: * If the task has changed processor sets,
474: * catch up (involves lots of lock juggling).
475: */
476: {
477: processor_set_t cur_pset;
478:
479: cur_pset = parent_task->processor_set;
480: if (!cur_pset->active)
481: cur_pset = &default_pset;
482:
483: if (cur_pset != pset) {
484: pset_reference(cur_pset);
485: task_unlock(parent_task);
486: pset_unlock(pset);
487: pset_deallocate(pset);
488: pset = cur_pset;
489: goto Restart;
490: }
491: }
492:
493: /*
494: * Set the thread`s priority from the pset and task.
495: */
496:
497: new_thread->priority = parent_task->priority;
498: if (pset->max_priority > new_thread->max_priority)
499: new_thread->max_priority = pset->max_priority;
500: if (new_thread->max_priority > new_thread->priority)
501: new_thread->priority = new_thread->max_priority;
502: /*
503: * Don't need to lock thread here because it can't
504: * possibly execute and no one else knows about it.
505: */
506: compute_priority(new_thread, TRUE);
507:
508: /*
509: * Thread is suspended if the task is. Add 1 to
510: * suspend count since thread is created in suspended
511: * state.
512: */
513: new_thread->suspend_count = parent_task->suspend_count + 1;
514:
515: /*
516: * Add the thread to the processor set.
517: * If the pset is empty, suspend the thread again.
518: */
519:
520: pset_add_thread(pset, new_thread);
521: if (pset->empty)
522: new_thread->suspend_count++;
523:
524: #if HW_FOOTPRINT
525: /*
526: * Need to set last_processor, idle processor would be best, but
527: * that requires extra locking nonsense. Go for tail of
528: * processors queue to avoid master.
529: */
530: if (!pset->empty) {
531: new_thread->last_processor =
532: (processor_t)queue_first(&pset->processors);
533: }
534: else {
535: /*
536: * Thread created in empty processor set. Pick
537: * master processor as an acceptable legal value.
538: */
539: new_thread->last_processor = master_processor;
540: }
541: #else /* HW_FOOTPRINT */
542: /*
543: * Don't need to initialize because the context switch
544: * code will set it before it can be used.
545: */
546: #endif /* HW_FOOTPRINT */
547:
548: #if MACH_PCSAMPLE
549: new_thread->pc_sample.buffer = 0;
550: new_thread->pc_sample.seqno = 0;
551: new_thread->pc_sample.sampletypes = 0;
552: #endif /* MACH_PCSAMPLE */
553:
554: new_thread->pc_sample.buffer = 0;
555: /*
556: * Add the thread to the task`s list of threads.
557: * The new thread holds another reference to the task.
558: */
559:
560: parent_task->ref_count++;
561:
562: parent_task->thread_count++;
563: queue_enter(&parent_task->thread_list, new_thread, thread_t,
564: thread_list);
565:
566: /*
567: * Finally, mark the thread active.
568: */
569:
570: new_thread->active = TRUE;
571:
572: if (!parent_task->active) {
573: task_unlock(parent_task);
574: pset_unlock(pset);
575: (void) thread_terminate(new_thread);
576: /* release ref we would have given our caller */
577: thread_deallocate(new_thread);
578: return KERN_FAILURE;
579: }
580: task_unlock(parent_task);
581: pset_unlock(pset);
582:
583: ipc_thread_enable(new_thread);
584:
585: *child_thread = new_thread;
586: return KERN_SUCCESS;
587: }
588:
589: unsigned int thread_deallocate_stack = 0;
590:
591: void thread_deallocate(
592: register thread_t thread)
593: {
594: spl_t s;
595: register task_t task;
596: register processor_set_t pset;
597:
598: time_value_t user_time, system_time;
599:
600: if (thread == THREAD_NULL)
601: return;
602:
603: /*
604: * First, check for new count > 0 (the common case).
605: * Only the thread needs to be locked.
606: */
607: s = splsched();
608: thread_lock(thread);
609: if (--thread->ref_count > 0) {
610: thread_unlock(thread);
611: (void) splx(s);
612: return;
613: }
614:
615: /*
616: * Count is zero. However, the task's and processor set's
617: * thread lists have implicit references to
618: * the thread, and may make new ones. Their locks also
619: * dominate the thread lock. To check for this, we
620: * temporarily restore the one thread reference, unlock
621: * the thread, and then lock the other structures in
622: * the proper order.
623: */
624: thread->ref_count = 1;
625: thread_unlock(thread);
626: (void) splx(s);
627:
628: pset = thread->processor_set;
629: pset_lock(pset);
630:
631: #if MACH_HOST
632: /*
633: * The thread might have moved.
634: */
635: while (pset != thread->processor_set) {
636: pset_unlock(pset);
637: pset = thread->processor_set;
638: pset_lock(pset);
639: }
640: #endif /* MACH_HOST */
641:
642: task = thread->task;
643: task_lock(task);
644:
645: s = splsched();
646: thread_lock(thread);
647:
648: if (--thread->ref_count > 0) {
649: /*
650: * Task or processor_set made extra reference.
651: */
652: thread_unlock(thread);
653: (void) splx(s);
654: task_unlock(task);
655: pset_unlock(pset);
656: return;
657: }
658:
659: /*
660: * Thread has no references - we can remove it.
661: */
662:
663: /*
664: * Remove pending timeouts.
665: */
666: reset_timeout_check(&thread->timer);
667:
668: reset_timeout_check(&thread->depress_timer);
669: thread->depress_priority = -1;
670:
671: /*
672: * Accumulate times for dead threads in task.
673: */
674: thread_read_times(thread, &user_time, &system_time);
675: time_value_add(&task->total_user_time, &user_time);
676: time_value_add(&task->total_system_time, &system_time);
677:
678: /*
679: * Remove thread from task list and processor_set threads list.
680: */
681: task->thread_count--;
682: queue_remove(&task->thread_list, thread, thread_t, thread_list);
683:
684: pset_remove_thread(pset, thread);
685:
686: thread_unlock(thread); /* no more references - safe */
687: (void) splx(s);
688: task_unlock(task);
689: pset_unlock(pset);
690: pset_deallocate(pset);
691:
692: /*
693: * A couple of quick sanity checks
694: */
695:
696: if (thread == current_thread()) {
697: panic("thread deallocating itself");
698: }
699: if ((thread->state & ~(TH_RUN | TH_HALTED | TH_SWAPPED)) != TH_SUSP)
700: panic("unstopped thread destroyed!");
701:
702: /*
703: * Deallocate the task reference, since we know the thread
704: * is not running.
705: */
706: task_deallocate(thread->task); /* may block */
707:
708: /*
709: * Clean up any machine-dependent resources.
710: */
711: if ((thread->state & TH_SWAPPED) == 0) {
712: spl_t _s_ = splsched();
713: stack_free(thread);
714: (void) splx(s);
715: thread_deallocate_stack++;
716: }
717: /*
718: * Rattle the event count machinery (gag)
719: */
720: evc_notify_abort(thread);
721:
722: pcb_terminate(thread);
723: zfree(thread_zone, (vm_offset_t) thread);
724: }
725:
726: void thread_reference(
727: register thread_t thread)
728: {
729: spl_t s;
730:
731: if (thread == THREAD_NULL)
732: return;
733:
734: s = splsched();
735: thread_lock(thread);
736: thread->ref_count++;
737: thread_unlock(thread);
738: (void) splx(s);
739: }
740:
741: /*
742: * thread_terminate:
743: *
744: * Permanently stop execution of the specified thread.
745: *
746: * A thread to be terminated must be allowed to clean up any state
747: * that it has before it exits. The thread is broken out of any
748: * wait condition that it is in, and signalled to exit. It then
749: * cleans up its state and calls thread_halt_self on its way out of
750: * the kernel. The caller waits for the thread to halt, terminates
751: * its IPC state, and then deallocates it.
752: *
753: * If the caller is the current thread, it must still exit the kernel
754: * to clean up any state (thread and port references, messages, etc).
755: * When it exits the kernel, it then terminates its IPC state and
756: * queues itself for the reaper thread, which will wait for the thread
757: * to stop and then deallocate it. (A thread cannot deallocate itself,
758: * since it needs a kernel stack to execute.)
759: */
760: kern_return_t thread_terminate(
761: register thread_t thread)
762: {
763: register thread_t cur_thread = current_thread();
764: register task_t cur_task;
765: spl_t s;
766:
767: if (thread == THREAD_NULL)
768: return KERN_INVALID_ARGUMENT;
769:
770: /*
771: * Break IPC control over the thread.
772: */
773: ipc_thread_disable(thread);
774:
775: if (thread == cur_thread) {
776:
777: /*
778: * Current thread will queue itself for reaper when
779: * exiting kernel.
780: */
781: s = splsched();
782: thread_lock(thread);
783: if (thread->active) {
784: thread->active = FALSE;
785: thread_ast_set(thread, AST_TERMINATE);
786: }
787: thread_unlock(thread);
788: ast_on(cpu_number(), AST_TERMINATE);
789: splx(s);
790: return KERN_SUCCESS;
791: }
792:
793: /*
794: * Lock both threads and the current task
795: * to check termination races and prevent deadlocks.
796: */
797: cur_task = current_task();
798: task_lock(cur_task);
799: s = splsched();
800: if ((vm_offset_t)thread < (vm_offset_t)cur_thread) {
801: thread_lock(thread);
802: thread_lock(cur_thread);
803: }
804: else {
805: thread_lock(cur_thread);
806: thread_lock(thread);
807: }
808:
809: /*
810: * If the current thread is being terminated, help out.
811: */
812: if ((!cur_task->active) || (!cur_thread->active)) {
813: thread_unlock(cur_thread);
814: thread_unlock(thread);
815: (void) splx(s);
816: task_unlock(cur_task);
817: thread_terminate(cur_thread);
818: return KERN_FAILURE;
819: }
820:
821: thread_unlock(cur_thread);
822: task_unlock(cur_task);
823:
824: /*
825: * Terminate victim thread.
826: */
827: if (!thread->active) {
828: /*
829: * Someone else got there first.
830: */
831: thread_unlock(thread);
832: (void) splx(s);
833: return KERN_FAILURE;
834: }
835:
836: thread->active = FALSE;
837:
838: thread_unlock(thread);
839: (void) splx(s);
840:
841: #if MACH_HOST
842: /*
843: * Reassign thread to default pset if needed.
844: */
845: thread_freeze(thread);
846: if (thread->processor_set != &default_pset) {
847: thread_doassign(thread, &default_pset, FALSE);
848: }
849: #endif /* MACH_HOST */
850:
851: /*
852: * Halt the victim at the clean point.
853: */
854: (void) thread_halt(thread, TRUE);
855: #if MACH_HOST
856: thread_unfreeze(thread);
857: #endif /* MACH_HOST */
858: /*
859: * Shut down the victims IPC and deallocate its
860: * reference to itself.
861: */
862: ipc_thread_terminate(thread);
863: #if NET_ATM
864: mk_waited_collect(thread);
865: #endif
866: thread_deallocate(thread);
867: return KERN_SUCCESS;
868: }
869:
870: /*
871: * thread_force_terminate:
872: *
873: * Version of thread_terminate called by task_terminate. thread is
874: * not the current thread. task_terminate is the dominant operation,
875: * so we can force this thread to stop.
876: */
877: void
878: thread_force_terminate(
879: register thread_t thread)
880: {
881: boolean_t deallocate_here = FALSE;
882: spl_t s;
883:
884: ipc_thread_disable(thread);
885:
886: #if MACH_HOST
887: /*
888: * Reassign thread to default pset if needed.
889: */
890: thread_freeze(thread);
891: if (thread->processor_set != &default_pset)
892: thread_doassign(thread, &default_pset, FALSE);
893: #endif /* MACH_HOST */
894:
895: s = splsched();
896: thread_lock(thread);
897: deallocate_here = thread->active;
898: thread->active = FALSE;
899: thread_unlock(thread);
900: (void) splx(s);
901:
902: (void) thread_halt(thread, TRUE);
903: ipc_thread_terminate(thread);
904: #if NET_ATM
905: mk_waited_collect(thread);
906: #endif
907:
908: #if MACH_HOST
909: thread_unfreeze(thread);
910: #endif /* MACH_HOST */
911:
912: if (deallocate_here)
913: thread_deallocate(thread);
914: }
915:
916:
917: /*
918: * Halt a thread at a clean point, leaving it suspended.
919: *
920: * must_halt indicates whether thread must halt.
921: *
922: */
923: kern_return_t thread_halt(
924: register thread_t thread,
925: boolean_t must_halt)
926: {
927: register thread_t cur_thread = current_thread();
928: register kern_return_t ret;
929: spl_t s;
930:
931: if (thread == cur_thread)
932: panic("thread_halt: trying to halt current thread.");
933: /*
934: * If must_halt is FALSE, then a check must be made for
935: * a cycle of halt operations.
936: */
937: if (!must_halt) {
938: /*
939: * Grab both thread locks.
940: */
941: s = splsched();
942: if ((vm_offset_t)thread < (vm_offset_t)cur_thread) {
943: thread_lock(thread);
944: thread_lock(cur_thread);
945: }
946: else {
947: thread_lock(cur_thread);
948: thread_lock(thread);
949: }
950:
951: /*
952: * If target thread is already halted, grab a hold
953: * on it and return.
954: */
955: if (thread->state & TH_HALTED) {
956: thread->suspend_count++;
957: thread_unlock(cur_thread);
958: thread_unlock(thread);
959: (void) splx(s);
960: return KERN_SUCCESS;
961: }
962:
963: /*
964: * If someone is trying to halt us, we have a potential
965: * halt cycle. Break the cycle by interrupting anyone
966: * who is trying to halt us, and causing this operation
967: * to fail; retry logic will only retry operations
968: * that cannot deadlock. (If must_halt is TRUE, this
969: * operation can never cause a deadlock.)
970: */
971: if (cur_thread->ast & AST_HALT) {
972: thread_wakeup_with_result((event_t)&cur_thread->wake_active,
973: THREAD_INTERRUPTED);
974: thread_unlock(thread);
975: thread_unlock(cur_thread);
976: (void) splx(s);
977: return KERN_FAILURE;
978: }
979:
980: thread_unlock(cur_thread);
981:
982: }
983: else {
984: /*
985: * Lock thread and check whether it is already halted.
986: */
987: s = splsched();
988: thread_lock(thread);
989: if (thread->state & TH_HALTED) {
990: thread->suspend_count++;
991: thread_unlock(thread);
992: (void) splx(s);
993: return KERN_SUCCESS;
994: }
995: }
996:
997: /*
998: * Suspend thread - inline version of thread_hold() because
999: * thread is already locked.
1000: */
1001: thread->suspend_count++;
1002: thread->state |= TH_SUSP;
1003:
1004: /*
1005: * If someone else is halting it, wait for that to complete.
1006: * Fail if wait interrupted and must_halt is false.
1007: */
1008: while ((thread->ast & AST_HALT) && (!(thread->state & TH_HALTED))) {
1009: thread->wake_active = TRUE;
1010: thread_sleep((event_t) &thread->wake_active,
1011: simple_lock_addr(thread->lock), TRUE);
1012:
1013: if (thread->state & TH_HALTED) {
1014: (void) splx(s);
1015: return KERN_SUCCESS;
1016: }
1017: if ((current_thread()->wait_result != THREAD_AWAKENED)
1018: && !(must_halt)) {
1019: (void) splx(s);
1020: thread_release(thread);
1021: return KERN_FAILURE;
1022: }
1023: thread_lock(thread);
1024: }
1025:
1026: /*
1027: * Otherwise, have to do it ourselves.
1028: */
1029:
1030: thread_ast_set(thread, AST_HALT);
1031:
1032: while (TRUE) {
1033: /*
1034: * Wait for thread to stop.
1035: */
1036: thread_unlock(thread);
1037: (void) splx(s);
1038:
1039: ret = thread_dowait(thread, must_halt);
1040:
1041: /*
1042: * If the dowait failed, so do we. Drop AST_HALT, and
1043: * wake up anyone else who might be waiting for it.
1044: */
1045: if (ret != KERN_SUCCESS) {
1046: s = splsched();
1047: thread_lock(thread);
1048: thread_ast_clear(thread, AST_HALT);
1049: thread_wakeup_with_result((event_t)&thread->wake_active,
1050: THREAD_INTERRUPTED);
1051: thread_unlock(thread);
1052: (void) splx(s);
1053:
1054: thread_release(thread);
1055: return ret;
1056: }
1057:
1058: /*
1059: * Clear any interruptible wait.
1060: */
1061: clear_wait(thread, THREAD_INTERRUPTED, TRUE);
1062:
1063: /*
1064: * If the thread's at a clean point, we're done.
1065: * Don't need a lock because it really is stopped.
1066: */
1067: if (thread->state & TH_HALTED) {
1068: return KERN_SUCCESS;
1069: }
1070:
1071: /*
1072: * If the thread is at a nice continuation,
1073: * or a continuation with a cleanup routine,
1074: * call the cleanup routine.
1075: */
1076: if ((((thread->swap_func == mach_msg_continue) ||
1077: (thread->swap_func == mach_msg_receive_continue)) &&
1078: mach_msg_interrupt(thread)) ||
1079: (thread->swap_func == thread_exception_return) ||
1080: (thread->swap_func == thread_bootstrap_return)) {
1081: s = splsched();
1082: thread_lock(thread);
1083: thread->state |= TH_HALTED;
1084: thread_ast_clear(thread, AST_HALT);
1085: thread_unlock(thread);
1086: splx(s);
1087:
1088: return KERN_SUCCESS;
1089: }
1090:
1091: /*
1092: * Force the thread to stop at a clean
1093: * point, and arrange to wait for it.
1094: *
1095: * Set it running, so it can notice. Override
1096: * the suspend count. We know that the thread
1097: * is suspended and not waiting.
1098: *
1099: * Since the thread may hit an interruptible wait
1100: * before it reaches a clean point, we must force it
1101: * to wake us up when it does so. This involves some
1102: * trickery:
1103: * We mark the thread SUSPENDED so that thread_block
1104: * will suspend it and wake us up.
1105: * We mark the thread RUNNING so that it will run.
1106: * We mark the thread UN-INTERRUPTIBLE (!) so that
1107: * some other thread trying to halt or suspend it won't
1108: * take it off the run queue before it runs. Since
1109: * dispatching a thread (the tail of thread_invoke) marks
1110: * the thread interruptible, it will stop at the next
1111: * context switch or interruptible wait.
1112: */
1113:
1114: s = splsched();
1115: thread_lock(thread);
1116: if ((thread->state & TH_SCHED_STATE) != TH_SUSP)
1117: panic("thread_halt");
1118: thread->state |= TH_RUN | TH_UNINT;
1119: thread_setrun(thread, FALSE);
1120:
1121: /*
1122: * Continue loop and wait for thread to stop.
1123: */
1124: }
1125: }
1126:
1127: void walking_zombie(void)
1128: {
1129: panic("the zombie walks!");
1130: }
1131:
1132: /*
1133: * Thread calls this routine on exit from the kernel when it
1134: * notices a halt request.
1135: */
1136: void thread_halt_self(void)
1137: {
1138: register thread_t thread = current_thread();
1139: spl_t s;
1140:
1141: if (thread->ast & AST_TERMINATE) {
1142: /*
1143: * Thread is terminating itself. Shut
1144: * down IPC, then queue it up for the
1145: * reaper thread.
1146: */
1147: ipc_thread_terminate(thread);
1148: #if NET_ATM
1149: mk_waited_collect(thread);
1150: #endif
1151:
1152: thread_hold(thread);
1153:
1154: s = splsched();
1155: simple_lock(&reaper_lock);
1156: enqueue_tail(&reaper_queue, (queue_entry_t) thread);
1157: simple_unlock(&reaper_lock);
1158:
1159: thread_lock(thread);
1160: thread->state |= TH_HALTED;
1161: thread_unlock(thread);
1162: (void) splx(s);
1163:
1164: thread_wakeup((event_t)&reaper_queue);
1165: counter(c_thread_halt_self_block++);
1166: thread_block(walking_zombie);
1167: /*NOTREACHED*/
1168: } else {
1169: /*
1170: * Thread was asked to halt - show that it
1171: * has done so.
1172: */
1173: s = splsched();
1174: thread_lock(thread);
1175: thread->state |= TH_HALTED;
1176: thread_ast_clear(thread, AST_HALT);
1177: thread_unlock(thread);
1178: splx(s);
1179: counter(c_thread_halt_self_block++);
1180: thread_block(thread_exception_return);
1181: /*
1182: * thread_release resets TH_HALTED.
1183: */
1184: }
1185: }
1186:
1187: /*
1188: * thread_hold:
1189: *
1190: * Suspend execution of the specified thread.
1191: * This is a recursive-style suspension of the thread, a count of
1192: * suspends is maintained.
1193: */
1194: void thread_hold(
1195: register thread_t thread)
1196: {
1197: spl_t s;
1198:
1199: s = splsched();
1200: thread_lock(thread);
1201: thread->suspend_count++;
1202: thread->state |= TH_SUSP;
1203: thread_unlock(thread);
1204: (void) splx(s);
1205: }
1206:
1207: /*
1208: * thread_dowait:
1209: *
1210: * Wait for a thread to actually enter stopped state.
1211: *
1212: * must_halt argument indicates if this may fail on interruption.
1213: * This is FALSE only if called from thread_abort via thread_halt.
1214: */
1215: kern_return_t
1216: thread_dowait(
1217: register thread_t thread,
1218: boolean_t must_halt)
1219: {
1220: register boolean_t need_wakeup;
1221: register kern_return_t ret = KERN_SUCCESS;
1222: spl_t s;
1223:
1224: if (thread == current_thread())
1225: panic("thread_dowait");
1226:
1227: /*
1228: * If a thread is not interruptible, it may not be suspended
1229: * until it becomes interruptible. In this case, we wait for
1230: * the thread to stop itself, and indicate that we are waiting
1231: * for it to stop so that it can wake us up when it does stop.
1232: *
1233: * If the thread is interruptible, we may be able to suspend
1234: * it immediately. There are several cases:
1235: *
1236: * 1) The thread is already stopped (trivial)
1237: * 2) The thread is runnable (marked RUN and on a run queue).
1238: * We pull it off the run queue and mark it stopped.
1239: * 3) The thread is running. We wait for it to stop.
1240: */
1241:
1242: need_wakeup = FALSE;
1243: s = splsched();
1244: thread_lock(thread);
1245:
1246: for (;;) {
1247: switch (thread->state & TH_SCHED_STATE) {
1248: case TH_SUSP:
1249: case TH_WAIT | TH_SUSP:
1250: /*
1251: * Thread is already suspended, or sleeping in an
1252: * interruptible wait. We win!
1253: */
1254: break;
1255:
1256: case TH_RUN | TH_SUSP:
1257: /*
1258: * The thread is interruptible. If we can pull
1259: * it off a runq, stop it here.
1260: */
1261: if (rem_runq(thread) != RUN_QUEUE_NULL) {
1262: thread->state &= ~TH_RUN;
1263: need_wakeup = thread->wake_active;
1264: thread->wake_active = FALSE;
1265: break;
1266: }
1267: #if NCPUS > 1
1268: /*
1269: * The thread must be running, so make its
1270: * processor execute ast_check(). This
1271: * should cause the thread to take an ast and
1272: * context switch to suspend for us.
1273: */
1274: cause_ast_check(thread->last_processor);
1275: #endif /* NCPUS > 1 */
1276:
1277: /*
1278: * Fall through to wait for thread to stop.
1279: */
1280:
1281: case TH_RUN | TH_SUSP | TH_UNINT:
1282: case TH_RUN | TH_WAIT | TH_SUSP:
1283: case TH_RUN | TH_WAIT | TH_SUSP | TH_UNINT:
1284: case TH_WAIT | TH_SUSP | TH_UNINT:
1285: /*
1286: * Wait for the thread to stop, or sleep interruptibly
1287: * (thread_block will stop it in the latter case).
1288: * Check for failure if interrupted.
1289: */
1290: thread->wake_active = TRUE;
1291: thread_sleep((event_t) &thread->wake_active,
1292: simple_lock_addr(thread->lock), TRUE);
1293: thread_lock(thread);
1294: if ((current_thread()->wait_result != THREAD_AWAKENED) &&
1295: !must_halt) {
1296: ret = KERN_FAILURE;
1297: break;
1298: }
1299:
1300: /*
1301: * Repeat loop to check thread`s state.
1302: */
1303: continue;
1304: }
1305: /*
1306: * Thread is stopped at this point.
1307: */
1308: break;
1309: }
1310:
1311: thread_unlock(thread);
1312: (void) splx(s);
1313:
1314: if (need_wakeup)
1315: thread_wakeup((event_t) &thread->wake_active);
1316:
1317: return ret;
1318: }
1319:
1320: void thread_release(
1321: register thread_t thread)
1322: {
1323: spl_t s;
1324:
1325: s = splsched();
1326: thread_lock(thread);
1327: if (--thread->suspend_count == 0) {
1328: thread->state &= ~(TH_SUSP | TH_HALTED);
1329: if ((thread->state & (TH_WAIT | TH_RUN)) == 0) {
1330: /* was only suspended */
1331: thread->state |= TH_RUN;
1332: thread_setrun(thread, TRUE);
1333: }
1334: }
1335: thread_unlock(thread);
1336: (void) splx(s);
1337: }
1338:
1339: kern_return_t thread_suspend(
1340: register thread_t thread)
1341: {
1342: register boolean_t hold;
1343: spl_t spl;
1344:
1345: if (thread == THREAD_NULL)
1346: return KERN_INVALID_ARGUMENT;
1347:
1348: hold = FALSE;
1349: spl = splsched();
1350: thread_lock(thread);
1351: if (thread->user_stop_count++ == 0) {
1352: hold = TRUE;
1353: thread->suspend_count++;
1354: thread->state |= TH_SUSP;
1355: }
1356: thread_unlock(thread);
1357: (void) splx(spl);
1358:
1359: /*
1360: * Now wait for the thread if necessary.
1361: */
1362: if (hold) {
1363: if (thread == current_thread()) {
1364: /*
1365: * We want to call thread_block on our way out,
1366: * to stop running.
1367: */
1368: spl = splsched();
1369: ast_on(cpu_number(), AST_BLOCK);
1370: (void) splx(spl);
1371: } else
1372: (void) thread_dowait(thread, TRUE);
1373: }
1374: return KERN_SUCCESS;
1375: }
1376:
1377:
1378: kern_return_t thread_resume(
1379: register thread_t thread)
1380: {
1381: register kern_return_t ret;
1382: spl_t s;
1383:
1384: if (thread == THREAD_NULL)
1385: return KERN_INVALID_ARGUMENT;
1386:
1387: ret = KERN_SUCCESS;
1388:
1389: s = splsched();
1390: thread_lock(thread);
1391: if (thread->user_stop_count > 0) {
1392: if (--thread->user_stop_count == 0) {
1393: if (--thread->suspend_count == 0) {
1394: thread->state &= ~(TH_SUSP | TH_HALTED);
1395: if ((thread->state & (TH_WAIT | TH_RUN)) == 0) {
1396: /* was only suspended */
1397: thread->state |= TH_RUN;
1398: thread_setrun(thread, TRUE);
1399: }
1400: }
1401: }
1402: }
1403: else {
1404: ret = KERN_FAILURE;
1405: }
1406:
1407: thread_unlock(thread);
1408: (void) splx(s);
1409:
1410: return ret;
1411: }
1412:
1413: /*
1414: * Return thread's machine-dependent state.
1415: */
1416: kern_return_t thread_get_state(
1417: register thread_t thread,
1418: int flavor,
1419: thread_state_t old_state, /* pointer to OUT array */
1420: natural_t *old_state_count) /*IN/OUT*/
1421: {
1422: kern_return_t ret;
1423:
1424: if (thread == THREAD_NULL || thread == current_thread()) {
1425: return KERN_INVALID_ARGUMENT;
1426: }
1427:
1428: thread_hold(thread);
1429: (void) thread_dowait(thread, TRUE);
1430:
1431: ret = thread_getstatus(thread, flavor, old_state, old_state_count);
1432:
1433: thread_release(thread);
1434: return ret;
1435: }
1436:
1437: /*
1438: * Change thread's machine-dependent state.
1439: */
1440: kern_return_t thread_set_state(
1441: register thread_t thread,
1442: int flavor,
1443: thread_state_t new_state,
1444: natural_t new_state_count)
1445: {
1446: kern_return_t ret;
1447:
1448: if (thread == THREAD_NULL || thread == current_thread()) {
1449: return KERN_INVALID_ARGUMENT;
1450: }
1451:
1452: thread_hold(thread);
1453: (void) thread_dowait(thread, TRUE);
1454:
1455: ret = thread_setstatus(thread, flavor, new_state, new_state_count);
1456:
1457: thread_release(thread);
1458: return ret;
1459: }
1460:
1461: kern_return_t thread_info(
1462: register thread_t thread,
1463: int flavor,
1464: thread_info_t thread_info_out, /* pointer to OUT array */
1465: natural_t *thread_info_count) /*IN/OUT*/
1466: {
1467: int state, flags;
1468: spl_t s;
1469:
1470: if (thread == THREAD_NULL)
1471: return KERN_INVALID_ARGUMENT;
1472:
1473: if (flavor == THREAD_BASIC_INFO) {
1474: register thread_basic_info_t basic_info;
1475:
1476: if (*thread_info_count < THREAD_BASIC_INFO_COUNT) {
1477: return KERN_INVALID_ARGUMENT;
1478: }
1479:
1480: basic_info = (thread_basic_info_t) thread_info_out;
1481:
1482: s = splsched();
1483: thread_lock(thread);
1484:
1485: /*
1486: * Update lazy-evaluated scheduler info because someone wants it.
1487: */
1488: if ((thread->state & TH_RUN) == 0 &&
1489: thread->sched_stamp != sched_tick)
1490: update_priority(thread);
1491:
1492: /* fill in info */
1493:
1494: thread_read_times(thread,
1495: &basic_info->user_time,
1496: &basic_info->system_time);
1497: basic_info->base_priority = thread->priority;
1498: basic_info->cur_priority = thread->sched_pri;
1499:
1500: /*
1501: * To calculate cpu_usage, first correct for timer rate,
1502: * then for 5/8 ageing. The correction factor [3/5] is
1503: * (1/(5/8) - 1).
1504: */
1505: basic_info->cpu_usage = thread->cpu_usage /
1506: (TIMER_RATE/TH_USAGE_SCALE);
1507: basic_info->cpu_usage = (basic_info->cpu_usage * 3) / 5;
1508: #if SIMPLE_CLOCK
1509: /*
1510: * Clock drift compensation.
1511: */
1512: basic_info->cpu_usage =
1513: (basic_info->cpu_usage * 1000000)/sched_usec;
1514: #endif /* SIMPLE_CLOCK */
1515:
1516: if (thread->state & TH_SWAPPED)
1517: flags = TH_FLAGS_SWAPPED;
1518: else if (thread->state & TH_IDLE)
1519: flags = TH_FLAGS_IDLE;
1520: else
1521: flags = 0;
1522:
1523: if (thread->state & TH_HALTED)
1524: state = TH_STATE_HALTED;
1525: else
1526: if (thread->state & TH_RUN)
1527: state = TH_STATE_RUNNING;
1528: else
1529: if (thread->state & TH_UNINT)
1530: state = TH_STATE_UNINTERRUPTIBLE;
1531: else
1532: if (thread->state & TH_SUSP)
1533: state = TH_STATE_STOPPED;
1534: else
1535: if (thread->state & TH_WAIT)
1536: state = TH_STATE_WAITING;
1537: else
1538: state = 0; /* ? */
1539:
1540: basic_info->run_state = state;
1541: basic_info->flags = flags;
1542: basic_info->suspend_count = thread->user_stop_count;
1543: if (state == TH_STATE_RUNNING)
1544: basic_info->sleep_time = 0;
1545: else
1546: basic_info->sleep_time = sched_tick - thread->sched_stamp;
1547:
1548: thread_unlock(thread);
1549: splx(s);
1550:
1551: *thread_info_count = THREAD_BASIC_INFO_COUNT;
1552: return KERN_SUCCESS;
1553: }
1554: else if (flavor == THREAD_SCHED_INFO) {
1555: register thread_sched_info_t sched_info;
1556:
1557: if (*thread_info_count < THREAD_SCHED_INFO_COUNT) {
1558: return KERN_INVALID_ARGUMENT;
1559: }
1560:
1561: sched_info = (thread_sched_info_t) thread_info_out;
1562:
1563: s = splsched();
1564: thread_lock(thread);
1565:
1566: #if MACH_FIXPRI
1567: sched_info->policy = thread->policy;
1568: if (thread->policy == POLICY_FIXEDPRI) {
1569: sched_info->data = (thread->sched_data * tick)/1000;
1570: }
1571: else {
1572: sched_info->data = 0;
1573: }
1574: #else /* MACH_FIXPRI */
1575: sched_info->policy = POLICY_TIMESHARE;
1576: sched_info->data = 0;
1577: #endif /* MACH_FIXPRI */
1578:
1579: sched_info->base_priority = thread->priority;
1580: sched_info->max_priority = thread->max_priority;
1581: sched_info->cur_priority = thread->sched_pri;
1582:
1583: sched_info->depressed = (thread->depress_priority >= 0);
1584: sched_info->depress_priority = thread->depress_priority;
1585:
1586: thread_unlock(thread);
1587: splx(s);
1588:
1589: *thread_info_count = THREAD_SCHED_INFO_COUNT;
1590: return KERN_SUCCESS;
1591: }
1592:
1593: return KERN_INVALID_ARGUMENT;
1594: }
1595:
1596: kern_return_t thread_abort(
1597: register thread_t thread)
1598: {
1599: if (thread == THREAD_NULL || thread == current_thread()) {
1600: return KERN_INVALID_ARGUMENT;
1601: }
1602:
1603: /*
1604: *
1605: * clear it of an event wait
1606: */
1607: evc_notify_abort(thread);
1608:
1609: /*
1610: * Try to force the thread to a clean point
1611: * If the halt operation fails return KERN_ABORTED.
1612: * ipc code will convert this to an ipc interrupted error code.
1613: */
1614: if (thread_halt(thread, FALSE) != KERN_SUCCESS)
1615: return KERN_ABORTED;
1616:
1617: /*
1618: * If the thread was in an exception, abort that too.
1619: */
1620: mach_msg_abort_rpc(thread);
1621:
1622: /*
1623: * Then set it going again.
1624: */
1625: thread_release(thread);
1626:
1627: /*
1628: * Also abort any depression.
1629: */
1630: if (thread->depress_priority != -1)
1631: thread_depress_abort(thread);
1632:
1633: return KERN_SUCCESS;
1634: }
1635:
1636: /*
1637: * thread_start:
1638: *
1639: * Start a thread at the specified routine.
1640: * The thread must be in a swapped state.
1641: */
1642:
1643: void
1644: thread_start(
1645: thread_t thread,
1646: continuation_t start)
1647: {
1648: thread->swap_func = start;
1649: }
1650:
1651: /*
1652: * kernel_thread:
1653: *
1654: * Start up a kernel thread in the specified task.
1655: */
1656:
1657: thread_t kernel_thread(
1658: task_t task,
1659: continuation_t start,
1660: void * arg)
1661: {
1662: thread_t thread;
1663:
1664: (void) thread_create(task, &thread);
1665: /* release "extra" ref that thread_create gave us */
1666: thread_deallocate(thread);
1667: thread_start(thread, start);
1668: thread->ith_other = arg;
1669:
1670: /*
1671: * We ensure that the kernel thread starts with a stack.
1672: * The swapin mechanism might not be operational yet.
1673: */
1674: thread_doswapin(thread);
1675: thread->max_priority = BASEPRI_SYSTEM;
1676: thread->priority = BASEPRI_SYSTEM;
1677: thread->sched_pri = BASEPRI_SYSTEM;
1678: (void) thread_resume(thread);
1679: return thread;
1680: }
1681:
1682: /*
1683: * reaper_thread:
1684: *
1685: * This kernel thread runs forever looking for threads to destroy
1686: * (when they request that they be destroyed, of course).
1687: */
1688: void reaper_thread_continue(void)
1689: {
1690: for (;;) {
1691: register thread_t thread;
1692: spl_t s;
1693:
1694: s = splsched();
1695: simple_lock(&reaper_lock);
1696:
1697: while ((thread = (thread_t) dequeue_head(&reaper_queue))
1698: != THREAD_NULL) {
1699: simple_unlock(&reaper_lock);
1700: (void) splx(s);
1701:
1702: (void) thread_dowait(thread, TRUE); /* may block */
1703: thread_deallocate(thread); /* may block */
1704:
1705: s = splsched();
1706: simple_lock(&reaper_lock);
1707: }
1708:
1709: assert_wait((event_t) &reaper_queue, FALSE);
1710: simple_unlock(&reaper_lock);
1711: (void) splx(s);
1712: counter(c_reaper_thread_block++);
1713: thread_block(reaper_thread_continue);
1714: }
1715: }
1716:
1717: void reaper_thread(void)
1718: {
1719: reaper_thread_continue();
1720: /*NOTREACHED*/
1721: }
1722:
1723: #if MACH_HOST
1724: /*
1725: * thread_assign:
1726: *
1727: * Change processor set assignment.
1728: * Caller must hold an extra reference to the thread (if this is
1729: * called directly from the ipc interface, this is an operation
1730: * in progress reference). Caller must hold no locks -- this may block.
1731: */
1732:
1733: kern_return_t
1734: thread_assign(
1735: thread_t thread,
1736: processor_set_t new_pset)
1737: {
1738: if (thread == THREAD_NULL || new_pset == PROCESSOR_SET_NULL) {
1739: return KERN_INVALID_ARGUMENT;
1740: }
1741:
1742: thread_freeze(thread);
1743: thread_doassign(thread, new_pset, TRUE);
1744:
1745: return KERN_SUCCESS;
1746: }
1747:
1748: /*
1749: * thread_freeze:
1750: *
1751: * Freeze thread's assignment. Prelude to assigning thread.
1752: * Only one freeze may be held per thread.
1753: */
1754: void
1755: thread_freeze(
1756: thread_t thread)
1757: {
1758: spl_t s;
1759: /*
1760: * Freeze the assignment, deferring to a prior freeze.
1761: */
1762: s = splsched();
1763: thread_lock(thread);
1764: while (thread->may_assign == FALSE) {
1765: thread->assign_active = TRUE;
1766: thread_sleep((event_t) &thread->assign_active,
1767: simple_lock_addr(thread->lock), FALSE);
1768: thread_lock(thread);
1769: }
1770: thread->may_assign = FALSE;
1771: thread_unlock(thread);
1772: (void) splx(s);
1773:
1774: }
1775:
1776: /*
1777: * thread_unfreeze: release freeze on thread's assignment.
1778: */
1779: void
1780: thread_unfreeze(
1781: thread_t thread)
1782: {
1783: spl_t s;
1784:
1785: s = splsched();
1786: thread_lock(thread);
1787: thread->may_assign = TRUE;
1788: if (thread->assign_active) {
1789: thread->assign_active = FALSE;
1790: thread_wakeup((event_t)&thread->assign_active);
1791: }
1792: thread_unlock(thread);
1793: splx(s);
1794: }
1795:
1796: /*
1797: * thread_doassign:
1798: *
1799: * Actually do thread assignment. thread_will_assign must have been
1800: * called on the thread. release_freeze argument indicates whether
1801: * to release freeze on thread.
1802: */
1803:
1804: void
1805: thread_doassign(
1806: register thread_t thread,
1807: register processor_set_t new_pset,
1808: boolean_t release_freeze)
1809: {
1810: register processor_set_t pset;
1811: register boolean_t old_empty, new_empty;
1812: boolean_t recompute_pri = FALSE;
1813: spl_t s;
1814:
1815: /*
1816: * Check for silly no-op.
1817: */
1818: pset = thread->processor_set;
1819: if (pset == new_pset) {
1820: if (release_freeze)
1821: thread_unfreeze(thread);
1822: return;
1823: }
1824: /*
1825: * Suspend the thread and stop it if it's not the current thread.
1826: */
1827: thread_hold(thread);
1828: if (thread != current_thread())
1829: (void) thread_dowait(thread, TRUE);
1830:
1831: /*
1832: * Lock both psets now, use ordering to avoid deadlocks.
1833: */
1834: Restart:
1835: if ((vm_offset_t)pset < (vm_offset_t)new_pset) {
1836: pset_lock(pset);
1837: pset_lock(new_pset);
1838: }
1839: else {
1840: pset_lock(new_pset);
1841: pset_lock(pset);
1842: }
1843:
1844: /*
1845: * Check if new_pset is ok to assign to. If not, reassign
1846: * to default_pset.
1847: */
1848: if (!new_pset->active) {
1849: pset_unlock(pset);
1850: pset_unlock(new_pset);
1851: new_pset = &default_pset;
1852: goto Restart;
1853: }
1854:
1855: pset_reference(new_pset);
1856:
1857: /*
1858: * Grab the thread lock and move the thread.
1859: * Then drop the lock on the old pset and the thread's
1860: * reference to it.
1861: */
1862: s = splsched();
1863: thread_lock(thread);
1864:
1865: thread_change_psets(thread, pset, new_pset);
1866:
1867: old_empty = pset->empty;
1868: new_empty = new_pset->empty;
1869:
1870: pset_unlock(pset);
1871:
1872: /*
1873: * Reset policy and priorities if needed.
1874: */
1875: #if MACH_FIXPRI
1876: if (thread->policy & new_pset->policies == 0) {
1877: thread->policy = POLICY_TIMESHARE;
1878: recompute_pri = TRUE;
1879: }
1880: #endif /* MACH_FIXPRI */
1881:
1882: if (thread->max_priority < new_pset->max_priority) {
1883: thread->max_priority = new_pset->max_priority;
1884: if (thread->priority < thread->max_priority) {
1885: thread->priority = thread->max_priority;
1886: recompute_pri = TRUE;
1887: }
1888: else {
1889: if ((thread->depress_priority >= 0) &&
1890: (thread->depress_priority < thread->max_priority)) {
1891: thread->depress_priority = thread->max_priority;
1892: }
1893: }
1894: }
1895:
1896: pset_unlock(new_pset);
1897:
1898: if (recompute_pri)
1899: compute_priority(thread, TRUE);
1900:
1901: if (release_freeze) {
1902: thread->may_assign = TRUE;
1903: if (thread->assign_active) {
1904: thread->assign_active = FALSE;
1905: thread_wakeup((event_t)&thread->assign_active);
1906: }
1907: }
1908:
1909: thread_unlock(thread);
1910: splx(s);
1911:
1912: pset_deallocate(pset);
1913:
1914: /*
1915: * Figure out hold status of thread. Threads assigned to empty
1916: * psets must be held. Therefore:
1917: * If old pset was empty release its hold.
1918: * Release our hold from above unless new pset is empty.
1919: */
1920:
1921: if (old_empty)
1922: thread_release(thread);
1923: if (!new_empty)
1924: thread_release(thread);
1925:
1926: /*
1927: * If current_thread is assigned, context switch to force
1928: * assignment to happen. This also causes hold to take
1929: * effect if the new pset is empty.
1930: */
1931: if (thread == current_thread()) {
1932: s = splsched();
1933: ast_on(cpu_number(), AST_BLOCK);
1934: (void) splx(s);
1935: }
1936: }
1937: #else /* MACH_HOST */
1938: kern_return_t
1939: thread_assign(
1940: thread_t thread,
1941: processor_set_t new_pset)
1942: {
1943: return KERN_FAILURE;
1944: }
1945: #endif /* MACH_HOST */
1946:
1947: /*
1948: * thread_assign_default:
1949: *
1950: * Special version of thread_assign for assigning threads to default
1951: * processor set.
1952: */
1953: kern_return_t
1954: thread_assign_default(
1955: thread_t thread)
1956: {
1957: return thread_assign(thread, &default_pset);
1958: }
1959:
1960: /*
1961: * thread_get_assignment
1962: *
1963: * Return current assignment for this thread.
1964: */
1965: kern_return_t thread_get_assignment(
1966: thread_t thread,
1967: processor_set_t *pset)
1968: {
1969: *pset = thread->processor_set;
1970: pset_reference(*pset);
1971: return KERN_SUCCESS;
1972: }
1973:
1974: /*
1975: * thread_priority:
1976: *
1977: * Set priority (and possibly max priority) for thread.
1978: */
1979: kern_return_t
1980: thread_priority(
1981: thread_t thread,
1982: int priority,
1983: boolean_t set_max)
1984: {
1985: spl_t s;
1986: kern_return_t ret = KERN_SUCCESS;
1987:
1988: if ((thread == THREAD_NULL) || invalid_pri(priority))
1989: return KERN_INVALID_ARGUMENT;
1990:
1991: s = splsched();
1992: thread_lock(thread);
1993:
1994: /*
1995: * Check for violation of max priority
1996: */
1997: if (priority < thread->max_priority) {
1998: ret = KERN_FAILURE;
1999: }
2000: else {
2001: /*
2002: * Set priorities. If a depression is in progress,
2003: * change the priority to restore.
2004: */
2005: if (thread->depress_priority >= 0) {
2006: thread->depress_priority = priority;
2007: }
2008: else {
2009: thread->priority = priority;
2010: compute_priority(thread, TRUE);
2011: }
2012:
2013: if (set_max)
2014: thread->max_priority = priority;
2015: }
2016: thread_unlock(thread);
2017: (void) splx(s);
2018:
2019: return ret;
2020: }
2021:
2022: /*
2023: * thread_set_own_priority:
2024: *
2025: * Internal use only; sets the priority of the calling thread.
2026: * Will adjust max_priority if necessary.
2027: */
2028: void
2029: thread_set_own_priority(
2030: int priority)
2031: {
2032: spl_t s;
2033: thread_t thread = current_thread();
2034:
2035: s = splsched();
2036: thread_lock(thread);
2037:
2038: if (priority < thread->max_priority)
2039: thread->max_priority = priority;
2040: thread->priority = priority;
2041: compute_priority(thread, TRUE);
2042:
2043: thread_unlock(thread);
2044: (void) splx(s);
2045: }
2046:
2047: /*
2048: * thread_max_priority:
2049: *
2050: * Reset the max priority for a thread.
2051: */
2052: kern_return_t
2053: thread_max_priority(
2054: thread_t thread,
2055: processor_set_t pset,
2056: int max_priority)
2057: {
2058: spl_t s;
2059: kern_return_t ret = KERN_SUCCESS;
2060:
2061: if ((thread == THREAD_NULL) || (pset == PROCESSOR_SET_NULL) ||
2062: invalid_pri(max_priority))
2063: return KERN_INVALID_ARGUMENT;
2064:
2065: s = splsched();
2066: thread_lock(thread);
2067:
2068: #if MACH_HOST
2069: /*
2070: * Check for wrong processor set.
2071: */
2072: if (pset != thread->processor_set) {
2073: ret = KERN_FAILURE;
2074: }
2075: else {
2076: #endif /* MACH_HOST */
2077: thread->max_priority = max_priority;
2078:
2079: /*
2080: * Reset priority if it violates new max priority
2081: */
2082: if (max_priority > thread->priority) {
2083: thread->priority = max_priority;
2084:
2085: compute_priority(thread, TRUE);
2086: }
2087: else {
2088: if (thread->depress_priority >= 0 &&
2089: max_priority > thread->depress_priority)
2090: thread->depress_priority = max_priority;
2091: }
2092: #if MACH_HOST
2093: }
2094: #endif /* MACH_HOST */
2095:
2096: thread_unlock(thread);
2097: (void) splx(s);
2098:
2099: return ret;
2100: }
2101:
2102: /*
2103: * thread_policy:
2104: *
2105: * Set scheduling policy for thread.
2106: */
2107: kern_return_t
2108: thread_policy(
2109: thread_t thread,
2110: int policy,
2111: int data)
2112: {
2113: #if MACH_FIXPRI
2114: register kern_return_t ret = KERN_SUCCESS;
2115: register int temp;
2116: spl_t s;
2117: #endif /* MACH_FIXPRI */
2118:
2119: if ((thread == THREAD_NULL) || invalid_policy(policy))
2120: return KERN_INVALID_ARGUMENT;
2121:
2122: #if MACH_FIXPRI
2123: s = splsched();
2124: thread_lock(thread);
2125:
2126: /*
2127: * Check if changing policy.
2128: */
2129: if (policy == thread->policy) {
2130: /*
2131: * Just changing data. This is meaningless for
2132: * timesharing, quantum for fixed priority (but
2133: * has no effect until current quantum runs out).
2134: */
2135: if (policy == POLICY_FIXEDPRI) {
2136: temp = data * 1000;
2137: if (temp % tick)
2138: temp += tick;
2139: thread->sched_data = temp/tick;
2140: }
2141: }
2142: else {
2143: /*
2144: * Changing policy. Check if new policy is allowed.
2145: */
2146: if ((thread->processor_set->policies & policy) == 0) {
2147: ret = KERN_FAILURE;
2148: }
2149: else {
2150: /*
2151: * Changing policy. Save data and calculate new
2152: * priority.
2153: */
2154: thread->policy = policy;
2155: if (policy == POLICY_FIXEDPRI) {
2156: temp = data * 1000;
2157: if (temp % tick)
2158: temp += tick;
2159: thread->sched_data = temp/tick;
2160: }
2161: compute_priority(thread, TRUE);
2162: }
2163: }
2164: thread_unlock(thread);
2165: (void) splx(s);
2166:
2167: return ret;
2168: #else /* MACH_FIXPRI */
2169: if (policy == POLICY_TIMESHARE)
2170: return KERN_SUCCESS;
2171: else
2172: return KERN_FAILURE;
2173: #endif /* MACH_FIXPRI */
2174: }
2175:
2176: /*
2177: * thread_wire:
2178: *
2179: * Specify that the target thread must always be able
2180: * to run and to allocate memory.
2181: */
2182: kern_return_t
2183: thread_wire(
2184: host_t host,
2185: thread_t thread,
2186: boolean_t wired)
2187: {
2188: spl_t s;
2189:
2190: if (host == HOST_NULL)
2191: return KERN_INVALID_ARGUMENT;
2192:
2193: if (thread == THREAD_NULL)
2194: return KERN_INVALID_ARGUMENT;
2195:
2196: /*
2197: * This implementation only works for the current thread.
2198: * See stack_privilege.
2199: */
2200: if (thread != current_thread())
2201: return KERN_INVALID_ARGUMENT;
2202:
2203: s = splsched();
2204: thread_lock(thread);
2205:
2206: if (wired) {
2207: thread->vm_privilege = TRUE;
2208: stack_privilege(thread);
2209: }
2210: else {
2211: thread->vm_privilege = FALSE;
2212: /*XXX stack_unprivilege(thread); */
2213: thread->stack_privilege = 0;
2214: }
2215:
2216: thread_unlock(thread);
2217: splx(s);
2218:
2219: return KERN_SUCCESS;
2220: }
2221:
2222: /*
2223: * thread_collect_scan:
2224: *
2225: * Attempt to free resources owned by threads.
2226: * pcb_collect doesn't do anything yet.
2227: */
2228:
2229: void thread_collect_scan(void)
2230: {
2231: #if 0
2232: register thread_t thread, prev_thread;
2233: processor_set_t pset, prev_pset;
2234:
2235: prev_thread = THREAD_NULL;
2236: prev_pset = PROCESSOR_SET_NULL;
2237:
2238: simple_lock(&all_psets_lock);
2239: queue_iterate(&all_psets, pset, processor_set_t, all_psets) {
2240: pset_lock(pset);
2241: queue_iterate(&pset->threads, thread, thread_t, pset_threads) {
2242: spl_t s = splsched();
2243: thread_lock(thread);
2244:
2245: /*
2246: * Only collect threads which are
2247: * not runnable and are swapped.
2248: */
2249:
2250: if ((thread->state & (TH_RUN|TH_SWAPPED))
2251: == TH_SWAPPED) {
2252: thread->ref_count++;
2253: thread_unlock(thread);
2254: (void) splx(s);
2255: pset->ref_count++;
2256: pset_unlock(pset);
2257: simple_unlock(&all_psets_lock);
2258:
2259: pcb_collect(thread);
2260:
2261: if (prev_thread != THREAD_NULL)
2262: thread_deallocate(prev_thread);
2263: prev_thread = thread;
2264:
2265: if (prev_pset != PROCESSOR_SET_NULL)
2266: pset_deallocate(prev_pset);
2267: prev_pset = pset;
2268:
2269: simple_lock(&all_psets_lock);
2270: pset_lock(pset);
2271: } else {
2272: thread_unlock(thread);
2273: (void) splx(s);
2274: }
2275: }
2276: pset_unlock(pset);
2277: }
2278: simple_unlock(&all_psets_lock);
2279:
2280: if (prev_thread != THREAD_NULL)
2281: thread_deallocate(prev_thread);
2282: if (prev_pset != PROCESSOR_SET_NULL)
2283: pset_deallocate(prev_pset);
2284: #endif /* 0 */
2285: }
2286:
2287: boolean_t thread_collect_allowed = TRUE;
2288: unsigned thread_collect_last_tick = 0;
2289: unsigned thread_collect_max_rate = 0; /* in ticks */
2290:
2291: /*
2292: * consider_thread_collect:
2293: *
2294: * Called by the pageout daemon when the system needs more free pages.
2295: */
2296:
2297: void consider_thread_collect(void)
2298: {
2299: /*
2300: * By default, don't attempt thread collection more frequently
2301: * than once a second.
2302: */
2303:
2304: if (thread_collect_max_rate == 0)
2305: thread_collect_max_rate = hz;
2306:
2307: if (thread_collect_allowed &&
2308: (sched_tick >
2309: (thread_collect_last_tick + thread_collect_max_rate))) {
2310: thread_collect_last_tick = sched_tick;
2311: thread_collect_scan();
2312: }
2313: }
2314:
2315: #if MACH_DEBUG
2316:
2317: vm_size_t stack_usage(
2318: register vm_offset_t stack)
2319: {
2320: int i;
2321:
2322: for (i = 0; i < KERNEL_STACK_SIZE/sizeof(unsigned int); i++)
2323: if (((unsigned int *)stack)[i] != STACK_MARKER)
2324: break;
2325:
2326: return KERNEL_STACK_SIZE - i * sizeof(unsigned int);
2327: }
2328:
2329: /*
2330: * Machine-dependent code should call stack_init
2331: * before doing its own initialization of the stack.
2332: */
2333:
2334: void stack_init(
2335: register vm_offset_t stack)
2336: {
2337: if (stack_check_usage) {
2338: int i;
2339:
2340: for (i = 0; i < KERNEL_STACK_SIZE/sizeof(unsigned int); i++)
2341: ((unsigned int *)stack)[i] = STACK_MARKER;
2342: }
2343: }
2344:
2345: /*
2346: * Machine-dependent code should call stack_finalize
2347: * before releasing the stack memory.
2348: */
2349:
2350: void stack_finalize(
2351: register vm_offset_t stack)
2352: {
2353: if (stack_check_usage) {
2354: vm_size_t used = stack_usage(stack);
2355:
2356: simple_lock(&stack_usage_lock);
2357: if (used > stack_max_usage)
2358: stack_max_usage = used;
2359: simple_unlock(&stack_usage_lock);
2360: }
2361: }
2362:
2363: #ifndef MACHINE_STACK
2364: /*
2365: * stack_statistics:
2366: *
2367: * Return statistics on cached kernel stacks.
2368: * *maxusagep must be initialized by the caller.
2369: */
2370:
2371: void stack_statistics(
2372: natural_t *totalp,
2373: vm_size_t *maxusagep)
2374: {
2375: spl_t s;
2376:
2377: s = splsched();
2378: stack_lock();
2379: if (stack_check_usage) {
2380: vm_offset_t stack;
2381:
2382: /*
2383: * This is pretty expensive to do at splsched,
2384: * but it only happens when someone makes
2385: * a debugging call, so it should be OK.
2386: */
2387:
2388: for (stack = stack_free_list; stack != 0;
2389: stack = stack_next(stack)) {
2390: vm_size_t usage = stack_usage(stack);
2391:
2392: if (usage > *maxusagep)
2393: *maxusagep = usage;
2394: }
2395: }
2396:
2397: *totalp = stack_free_count;
2398: stack_unlock();
2399: (void) splx(s);
2400: }
2401: #endif /* MACHINE_STACK */
2402:
2403: kern_return_t host_stack_usage(
2404: host_t host,
2405: vm_size_t *reservedp,
2406: unsigned int *totalp,
2407: vm_size_t *spacep,
2408: vm_size_t *residentp,
2409: vm_size_t *maxusagep,
2410: vm_offset_t *maxstackp)
2411: {
2412: unsigned int total;
2413: vm_size_t maxusage;
2414:
2415: if (host == HOST_NULL)
2416: return KERN_INVALID_HOST;
2417:
2418: simple_lock(&stack_usage_lock);
2419: maxusage = stack_max_usage;
2420: simple_unlock(&stack_usage_lock);
2421:
2422: stack_statistics(&total, &maxusage);
2423:
2424: *reservedp = 0;
2425: *totalp = total;
2426: *spacep = *residentp = total * round_page(KERNEL_STACK_SIZE);
2427: *maxusagep = maxusage;
2428: *maxstackp = 0;
2429: return KERN_SUCCESS;
2430: }
2431:
2432: kern_return_t processor_set_stack_usage(
2433: processor_set_t pset,
2434: unsigned int *totalp,
2435: vm_size_t *spacep,
2436: vm_size_t *residentp,
2437: vm_size_t *maxusagep,
2438: vm_offset_t *maxstackp)
2439: {
2440: unsigned int total;
2441: vm_size_t maxusage;
2442: vm_offset_t maxstack;
2443:
2444: register thread_t *threads;
2445: register thread_t tmp_thread;
2446:
2447: unsigned int actual; /* this many things */
2448: unsigned int i;
2449:
2450: vm_size_t size, size_needed;
2451: vm_offset_t addr;
2452:
2453: if (pset == PROCESSOR_SET_NULL)
2454: return KERN_INVALID_ARGUMENT;
2455:
2456: size = 0; addr = 0;
2457:
2458: for (;;) {
2459: pset_lock(pset);
2460: if (!pset->active) {
2461: pset_unlock(pset);
2462: return KERN_INVALID_ARGUMENT;
2463: }
2464:
2465: actual = pset->thread_count;
2466:
2467: /* do we have the memory we need? */
2468:
2469: size_needed = actual * sizeof(thread_t);
2470: if (size_needed <= size)
2471: break;
2472:
2473: /* unlock the pset and allocate more memory */
2474: pset_unlock(pset);
2475:
2476: if (size != 0)
2477: kfree(addr, size);
2478:
2479: assert(size_needed > 0);
2480: size = size_needed;
2481:
2482: addr = kalloc(size);
2483: if (addr == 0)
2484: return KERN_RESOURCE_SHORTAGE;
2485: }
2486:
2487: /* OK, have memory and the processor_set is locked & active */
2488:
2489: threads = (thread_t *) addr;
2490: for (i = 0, tmp_thread = (thread_t) queue_first(&pset->threads);
2491: i < actual;
2492: i++,
2493: tmp_thread = (thread_t) queue_next(&tmp_thread->pset_threads)) {
2494: thread_reference(tmp_thread);
2495: threads[i] = tmp_thread;
2496: }
2497: assert(queue_end(&pset->threads, (queue_entry_t) tmp_thread));
2498:
2499: /* can unlock processor set now that we have the thread refs */
2500: pset_unlock(pset);
2501:
2502: /* calculate maxusage and free thread references */
2503:
2504: total = 0;
2505: maxusage = 0;
2506: maxstack = 0;
2507: for (i = 0; i < actual; i++) {
2508: thread_t thread = threads[i];
2509: vm_offset_t stack = 0;
2510:
2511: /*
2512: * thread->kernel_stack is only accurate if the
2513: * thread isn't swapped and is not executing.
2514: *
2515: * Of course, we don't have the appropriate locks
2516: * for these shenanigans.
2517: */
2518:
2519: if ((thread->state & TH_SWAPPED) == 0) {
2520: int cpu;
2521:
2522: stack = thread->kernel_stack;
2523:
2524: for (cpu = 0; cpu < NCPUS; cpu++)
2525: if (active_threads[cpu] == thread) {
2526: stack = active_stacks[cpu];
2527: break;
2528: }
2529: }
2530:
2531: if (stack != 0) {
2532: total++;
2533:
2534: if (stack_check_usage) {
2535: vm_size_t usage = stack_usage(stack);
2536:
2537: if (usage > maxusage) {
2538: maxusage = usage;
2539: maxstack = (vm_offset_t) thread;
2540: }
2541: }
2542: }
2543:
2544: thread_deallocate(thread);
2545: }
2546:
2547: if (size != 0)
2548: kfree(addr, size);
2549:
2550: *totalp = total;
2551: *residentp = *spacep = total * round_page(KERNEL_STACK_SIZE);
2552: *maxusagep = maxusage;
2553: *maxstackp = maxstack;
2554: return KERN_SUCCESS;
2555: }
2556:
2557: /*
2558: * Useful in the debugger:
2559: */
2560: void
2561: thread_stats(void)
2562: {
2563: register thread_t thread;
2564: int total = 0, rpcreply = 0;
2565:
2566: queue_iterate(&default_pset.threads, thread, thread_t, pset_threads) {
2567: total++;
2568: if (thread->ith_rpc_reply != IP_NULL)
2569: rpcreply++;
2570: }
2571:
2572: printf("%d total threads.\n", total);
2573: printf("%d using rpc_reply.\n", rpcreply);
2574: }
2575: #endif /* MACH_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.