![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to thread_act.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to thread_act.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_FREE_COPYRIGHT@
24: */
25: /*
26: * Copyright (c) 1993 The University of Utah and
27: * the Center for Software Science (CSS). All rights reserved.
28: *
29: * Permission to use, copy, modify and distribute this software and its
30: * documentation is hereby granted, provided that both the copyright
31: * notice and this permission notice appear in all copies of the
32: * software, derivative works or modified versions, and any portions
33: * thereof, and that both notices appear in supporting documentation.
34: *
35: * THE UNIVERSITY OF UTAH AND CSS ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
36: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSS DISCLAIM ANY LIABILITY OF
37: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
38: *
39: * CSS requests users of this software to return to [email protected] any
40: * improvements that they make and grant CSS redistribution rights.
41: *
42: * Author: Bryan Ford, University of Utah CSS
43: *
44: * Thread_Activation management routines
45: */
46:
47: #include <cpus.h>
48: #include <task_swapper.h>
49: #include <mach/kern_return.h>
50: #include <mach/alert.h>
51: #include <kern/etap_macros.h>
52: #include <kern/mach_param.h>
53: #include <kern/zalloc.h>
54: #include <kern/thread.h>
55: #include <kern/thread_swap.h>
56: #include <kern/task.h>
57: #include <kern/task_swap.h>
58: #include <kern/thread_act.h>
59: #include <kern/thread_pool.h>
60: #include <kern/sched_prim.h>
61: #include <kern/misc_protos.h>
62: #include <kern/assert.h>
63: #include <kern/exception.h>
64: #include <kern/ipc_mig.h>
65: #include <kern/ipc_tt.h>
66: #include <kern/profile.h>
67: #include <kern/machine.h>
68: #include <kern/spl.h>
69: #include <kern/syscall_subr.h>
70: #include <kern/sync_lock.h>
71: #include <kern/sf.h>
72: #include <kern/mk_sp.h> /*** ??? fix so this can be removed ***/
73: #include <mach_prof.h>
74: #include <mach/rpc.h>
75:
76: /*
77: * Debugging printf control
78: */
79: #if MACH_ASSERT
80: unsigned int watchacts = 0 /* WA_ALL */
81: ; /* Do-it-yourself & patchable */
82: #endif
83:
84: /*
85: * Track the number of times we need to swapin a thread to deallocate it.
86: */
87: int act_free_swapin = 0;
88: extern boolean_t thread_swap_unwire_stack;
89:
90: #if THREAD_SWAP_UNWIRE_USER_STACK
91: extern boolean_t thread_swap_unwire_user_stack;
92: #else /* THREAD_SWAP_UNWIRE_USER_STACK */
93: #define thread_swap_unwire_user_stack FALSE
94: #endif /* THREAD_SWAP_UNWIRE_USER_STACK */
95:
96: /*
97: * Forward declarations for functions local to this file.
98: */
99: kern_return_t act_abort( thread_act_t, int);
100: void special_handler(ReturnHandler *, thread_act_t);
101: void nudge(thread_act_t);
102: kern_return_t act_set_state_locked(thread_act_t, int,
103: thread_state_t,
104: mach_msg_type_number_t);
105: kern_return_t act_get_state_locked(thread_act_t, int,
106: thread_state_t,
107: mach_msg_type_number_t *);
108: void act_set_apc(thread_act_t);
109: void act_clr_apc(thread_act_t);
110: void act_user_to_kernel(thread_act_t);
111: void act_ulock_release_all(thread_act_t thr_act);
112:
113: kern_return_t terminate_empty_act(thread_act_t);
114: void install_special_handler_locked(thread_act_t);
115:
116: static zone_t thr_act_zone;
117:
118: /*
119: * Thread interfaces accessed via a thread_activation:
120: */
121:
122: /*
123: * Terminate a thread. Called with nothing locked.
124: * Returns same way.
125: */
126: kern_return_t
127: thread_terminate(
128: register thread_act_t thr_act)
129: {
130: thread_t thread;
131: task_t task;
132: struct ipc_port *iplock;
133: kern_return_t ret = KERN_INVALID_ARGUMENT;
134: #if NCPUS > 1
135: boolean_t held;
136: #endif /* NCPUS > 1 */
137:
138: if (thr_act == THR_ACT_NULL)
139: return(ret);
140:
141: if (((thr_act->task == kernel_task) || (thr_act->kernel_loaded == TRUE))
142: && (current_act() != thr_act)) {
143: return(KERN_FAILURE);
144: }
145:
146: #if THREAD_SWAPPER
147: thread_swap_disable(thr_act);
148: #endif /* THREAD_SWAPPER */
149:
150: /*
151: * Lock task containing target thread before (really)
152: * getting thread locks.
153: */
154: act_lock(thr_act);
155: task = thr_act->task;
156: act_unlock(thr_act);
157: task_lock(task);
158:
159: thread = act_lock_thread(thr_act);
160: if (!thr_act->active) {
161: act_unlock_thread(thr_act);
162: task_unlock(task);
163: return(KERN_TERMINATED);
164: }
165:
166: /*
167: * Break IPC control over the thread.
168: */
169: ipc_thr_act_disable_act_locked(thr_act);
170:
171: #if NCPUS > 1
172: /*
173: * Make sure this thread enters the kernel
174: */
175: if (thread != THREAD_NULL && thread != current_thread()) {
176: thread_hold(thr_act);
177: act_unlock_thread(thr_act);
178: #if 1 /* Grenoble */
179: if (!thread_stop_wait(thread)) {
180: ret = KERN_ABORTED;
181: (void)act_lock_thread(thr_act);
182: thread_release(thr_act);
183: act_unlock_thread(thr_act);
184: task_unlock(task);
185: return (ret);
186: }
187: #else
188: thread_stop_wait(thread);
189: #endif
190: held = TRUE;
191: (void)act_lock_thread(thr_act);
192: } else {
193: held = FALSE;
194: }
195: #endif /* NCPUS > 1 */
196:
197: #if 0 /* Grenoble */
198: /*
199: * Lock task containing target.
200: * Use mutex_try to respect lock ordering.
201: */
202:
203: task = thr_act->task;
204: if (!mutex_try(&task->lock)) {
205: act_unlock_thread(thr_act);
206: task_lock(task);
207: thread = act_lock_thread(thr_act);
208: }
209:
210:
211: if (!thr_act->active) {
212: act_unlock_thread(thr_act);
213: task_unlock(task);
214: ret = KERN_TERMINATED;
215: goto out;
216: }
217:
218: /*
219: * Break IPC control over the thread.
220: */
221: ipc_thr_act_disable_act_locked(thr_act);
222:
223: #endif
224: /*
225: * Check for terminating an empty thread_act -- detach it from
226: * its task, then deallocate its remaining refs here.
227: */
228: if (thr_act->thread == THREAD_NULL) {
229: iplock = thr_act->pool_port; /* remember for unlock call */
230: ret = terminate_empty_act( thr_act );
231:
232: /*
233: * Release locks individually. (`act_unlock_thread()'
234: * will not work since `pool_port' field has changed.)
235: */
236: ip_unlock(iplock);
237: act_unlock(thr_act);
238: }
239: else {
240: assert(thr_act->active);
241: act_disable_task_locked(thr_act);
242: ret = act_abort(thr_act,FALSE);
243: act_unlock_thread(thr_act);
244: }
245:
246: task_unlock(task);
247:
248: if (((thr_act->task == kernel_task) || (thr_act->kernel_loaded == TRUE))
249: && (current_act() == thr_act)) {
250: ast_taken(FALSE, AST_APC, 0);
251: panic("thread_terminate(): returning from ast_taken() for %x kernel activation\n", thr_act);
252: }
253:
254: #if 0 /* Grenoble */
255: out:
256: #endif
257:
258: #if NCPUS > 1
259: if (held) {
260: thread_unstop(thread);
261: (void)act_lock_thread(thr_act);
262: thread_release(thr_act);
263: act_unlock_thread(thr_act);
264: }
265: #endif /* NCPUS > 1 */
266: return(ret);
267: }
268:
269: /*
270: * Called with empty thread activation and its pool port locked.
271: * Activation is currently "active."
272: * Task containing activation is also locked.
273: * Returns the same way.
274: */
275: kern_return_t
276: terminate_empty_act( thread_act_t thr_act ) {
277: /*
278: * remove the activation from the pool port
279: * (this prevents it from being used)
280: */
281: if (thr_act->pool_port) {
282: act_locked_act_set_thread_pool(thr_act, IP_NULL);
283: }
284:
285: /*
286: * disassociate the thread from the task
287: */
288: assert(thr_act->active);
289: act_disable_task_locked( thr_act );
290:
291: return KERN_SUCCESS;
292: }
293:
294: /*
295: * thread_hold:
296: *
297: * Suspend execution of the specified thread.
298: * This is a recursive-style suspension of the thread, a count of
299: * suspends is maintained.
300: *
301: * Called with thr_act locked "appropriately" for synchrony with
302: * RPC (see act_lock_thread()). Returns same way.
303: */
304: void
305: thread_hold(
306: register thread_act_t thr_act)
307: {
308: if (thr_act->suspend_count++ == 0) {
309: install_special_handler(thr_act);
310: nudge(thr_act);
311: }
312: }
313:
314: /*
315: * Decrement internal suspension count for thr_act, setting thread
316: * runnable when count falls to zero.
317: *
318: * Called with thr_act locked "appropriately" for synchrony
319: * with RPC (see act_lock_thread()).
320: */
321: void
322: thread_release(
323: register thread_act_t thr_act)
324: {
325: if( thr_act->suspend_count &&
326: (--thr_act->suspend_count == 0) )
327: nudge( thr_act );
328: }
329:
330: kern_return_t
331: thread_suspend(
332: register thread_act_t thr_act)
333: {
334: thread_t thread;
335:
336: if (thr_act == THR_ACT_NULL) {
337: return(KERN_INVALID_ARGUMENT);
338: }
339: thread = act_lock_thread(thr_act);
340: if (!thr_act->active) {
341: act_unlock_thread(thr_act);
342: return(KERN_TERMINATED);
343: }
344: if (thr_act->user_stop_count++ == 0 &&
345: thr_act->suspend_count++ == 0 ) {
346: install_special_handler(thr_act);
347: if (thread &&
348: thr_act == thread->top_act && thread != current_thread()) {
349: nudge(thr_act);
350: act_unlock_thread(thr_act);
351: (void)thread_wait(thread);
352: }
353: else {
354: /*
355: * No need to wait for target thread
356: */
357: act_unlock_thread(thr_act);
358: }
359: }
360: else {
361: /*
362: * Thread is already suspended
363: */
364: act_unlock_thread(thr_act);
365: }
366: return(KERN_SUCCESS);
367: }
368:
369: kern_return_t
370: thread_resume(
371: register thread_act_t thr_act)
372: {
373: register kern_return_t ret;
374: spl_t s;
375: thread_t thread;
376:
377: if (thr_act == THR_ACT_NULL)
378: return(KERN_INVALID_ARGUMENT);
379: thread = act_lock_thread(thr_act);
380: ret = KERN_SUCCESS;
381:
382: if (thr_act->active) {
383: if (thr_act->user_stop_count > 0) {
384: if( --thr_act->user_stop_count == 0 ) {
385: --thr_act->suspend_count;
386: nudge( thr_act );
387: }
388: }
389: else
390: ret = KERN_FAILURE;
391: }
392: else
393: ret = KERN_TERMINATED;
394: act_unlock_thread( thr_act );
395: return ret;
396: }
397:
398: /*
399: * This routine walks toward the head of an RPC chain starting at
400: * a specified thread activation. An alert bit is set and a special
401: * handler is installed for each thread it encounters.
402: *
403: * The target thread act and thread shuttle are already locked.
404: */
405: kern_return_t
406: post_alert(
407: register thread_act_t thr_act,
408: unsigned alert_bits )
409: {
410: thread_act_t next;
411: thread_t thread;
412:
413: /*
414: * Chase the chain, setting alert bits and installing
415: * special handlers for each thread act.
416: */
417: /*** Not yet SMP safe ***/
418: /*** Worse, where's the activation locking as the chain is walked? ***/
419: for (next = thr_act; next != THR_ACT_NULL; next = next->higher) {
420: next->alerts |= alert_bits;
421: install_special_handler_locked(next);
422: }
423:
424: return(KERN_SUCCESS);
425: }
426:
427: /*
428: * thread_depress_abort:
429: *
430: * Prematurely abort priority depression if there is one.
431: */
432: kern_return_t
433: thread_depress_abort(
434: register thread_act_t thr_act)
435: {
436: register thread_t thread;
437: kern_return_t result;
438: sched_policy_t *policy;
439: spl_t s;
440:
441: if (thr_act == THR_ACT_NULL)
442: return (KERN_INVALID_ARGUMENT);
443:
444: thread = act_lock_thread(thr_act);
445: /* if activation is terminating, this operation is not meaningful */
446: if (!thr_act->active) {
447: act_unlock_thread(thr_act);
448:
449: return (KERN_TERMINATED);
450: }
451:
452: if (thread == THREAD_NULL) {
453: act_unlock_thread(thr_act);
454:
455: return (KERN_INVALID_ARGUMENT);
456: }
457:
458: s = splsched();
459: thread_lock(thread);
460: policy = &sched_policy[thread->policy];
461: thread_unlock(thread);
462: splx(s);
463:
464: result = policy->sp_ops.sp_thread_depress_abort(policy, thread);
465:
466: act_unlock_thread(thr_act);
467:
468: return (result);
469: }
470:
471:
472: /*
473: * Already locked: all RPC-related locks for thr_act (see
474: * act_lock_thread()).
475: */
476: kern_return_t
477: act_abort( thread_act_t thr_act, int chain_break )
478: {
479: spl_t spl;
480: thread_t thread;
481: struct ipc_port *iplock = thr_act->pool_port;
482: thread_act_t orphan;
483: kern_return_t kr;
484: etap_data_t probe_data;
485:
486: /*
487: * mark the activation for abort,
488: * update the suspend count,
489: * always install the special handler
490: */
491: install_special_handler(thr_act);
492:
493: ETAP_DATA_LOAD(probe_data[0], thr_act);
494: ETAP_DATA_LOAD(probe_data[1], thr_act->thread);
495: ETAP_PROBE_DATA(ETAP_P_ACT_ABORT,
496: 0,
497: current_thread(),
498: &probe_data,
499: ETAP_DATA_ENTRY*2);
500:
501: spl = splsched();
502: thread_lock( thr_act->thread );
503:
504: /*
505: * If the target thread activation is not the head...
506: */
507: if ( thr_act->thread->top_act != thr_act ) {
508: #ifdef AGRESSIVE_ABORT
509: /* release state buffer for target's outstanding invocation */
510: if (unwind_invoke_state(thr_act) != KERN_SUCCESS) {
511: panic("unwind_invoke_state failure");
512: }
513:
514: /* release state buffer for target's incoming invocation */
515: if (thr_act->lower != THR_ACT_NULL) {
516: if (unwind_invoke_state(thr_act->lower)
517: != KERN_SUCCESS) {
518: panic("unwind_invoke_state failure");
519: }
520: }
521:
522: /* unlink target thread activation from shuttle chain */
523: if ( thr_act->lower == THR_ACT_NULL ) {
524: /*
525: * This is the root thread activation of the chain.
526: * Unlink the root thread act from the bottom of
527: * the chain.
528: */
529: thr_act->higher->lower = THR_ACT_NULL;
530: } else {
531: /*
532: * This thread act is in the middle of the chain.
533: * Unlink the thread act from the middle of the chain.
534: */
535: thr_act->higher->lower = thr_act->lower;
536: thr_act->lower->higher = thr_act->higher;
537:
538: /* set the terminated bit for RPC return processing */
539: thr_act->lower->alerts |= SERVER_TERMINATED;
540: }
541:
542: orphan = thr_act->higher;
543:
544: /* remove the activation from its thread pool */
545: /* (note: this is okay for "rooted threads," too) */
546: act_locked_act_set_thread_pool(thr_act, IP_NULL);
547:
548: /* (just to be thorough) release the IP lock */
549: if (iplock != IP_NULL) ip_unlock(iplock);
550:
551: /* release one more reference for a rooted thread */
552: if (iplock == IP_NULL) act_locked_act_deallocate(thr_act);
553:
554: /* Presumably, the only reference to this activation is
555: * now held by the caller of this routine. */
556: assert(thr_act->ref_count == 1);
557: #else /*AGRESSIVE_ABORT*/
558: /* If there is a lower activation in the RPC chain... */
559: if (thr_act->lower != THR_ACT_NULL) {
560: /* ...indicate the server activation was terminated */
561: thr_act->lower->alerts |= SERVER_TERMINATED;
562: }
563: /* Mark (and process) any orphaned activations */
564: orphan = thr_act->higher;
565: #endif /*AGRESSIVE_ABORT*/
566:
567: /* indicate client of orphaned chain has been terminated */
568: orphan->alerts |= CLIENT_TERMINATED;
569:
570: /*
571: * Set up posting of alert to headward portion of
572: * the RPC chain.
573: */
574: /*** fix me -- orphan act is not locked ***/
575: post_alert(orphan, ORPHANED);
576:
577: /*
578: * Get attention of head of RPC chain.
579: */
580: thread_unlock(thr_act->thread);
581: nudge(thr_act->thread->top_act);
582: splx(spl);
583: return (KERN_SUCCESS);
584: }
585:
586: /*
587: * If the target thread is the end of the chain, the thread
588: * has to be marked for abort and rip it out of any wait.
589: */
590: if (thr_act->thread->top_act == thr_act) {
591: thr_act->thread->state |= TH_ABORT;
592: thread_unlock(thr_act->thread);
593: install_special_handler(thr_act);
594: nudge( thr_act );
595:
596: /*
597: * if it's waiting, clear it.
598: */
599: if( thr_act->thread->state & TH_WAIT ){
600: clear_wait(thr_act->thread, THREAD_INTERRUPTED, TRUE);
601: splx(spl);
602: return KERN_SUCCESS;
603: }
604: }
605: else {
606: thread_unlock(thr_act->thread);
607: }
608: splx(spl);
609: return KERN_SUCCESS;
610: }
611:
612: kern_return_t
613: thread_abort(
614: register thread_act_t thr_act)
615: {
616: int ret;
617: thread_t thread;
618:
619: if (thr_act == THR_ACT_NULL || thr_act == current_act())
620: return (KERN_INVALID_ARGUMENT);
621: /*
622: * Lock the target thread and the current thread now,
623: * in case thread_halt() ends up being called below.
624: */
625: thread = act_lock_thread(thr_act);
626: if (!thr_act->active) {
627: act_unlock_thread(thr_act);
628: return(KERN_TERMINATED);
629: }
630:
631: if( thread == THREAD_NULL ) {
632: act_unlock_thread(thr_act);
633: return KERN_NO_THREAD;
634: }
635:
636: ret = act_abort( thr_act, FALSE );
637: act_unlock_thread( thr_act );
638: return ret;
639: }
640:
641: kern_return_t
642: thread_abort_safely(
643: register thread_act_t thr_act)
644: {
645: boolean_t r;
646: thread_t cur_thr = current_thread();
647: thread_t thread, othread;
648: thread_act_t cur_thr_act = current_act();
649: spl_t spl;
650:
651: if (thr_act == THR_ACT_NULL || thr_act == current_act())
652: return(KERN_INVALID_ARGUMENT);
653:
654: othread = act_lock_thread(thr_act);
655: if (othread == THREAD_NULL) {
656: act_unlock_thread(thr_act);
657: return(KERN_INVALID_ARGUMENT);
658: }
659: if (!thr_act->active) {
660: act_unlock_thread(thr_act);
661: return(KERN_TERMINATED);
662: }
663: if (othread->top_act != thr_act) {
664: act_unlock_thread(thr_act);
665: return(KERN_FAILURE);
666: }
667:
668: /*
669: * This is the head of the chain. Stop it and check to see if
670: * it's in a condition which can be interrupted and restarted and,
671: * if so, clear the wait.
672: */
673: thread_hold(thr_act);
674: act_unlock_thread(thr_act);
675: r = thread_stop_wait(othread);
676: if ((thread = act_lock_thread(thr_act)) != othread || !r) {
677: thread_release(thr_act);
678: act_unlock_thread(thr_act);
679: if (r) {
680: thread_unstop(othread);
681: return (KERN_FAILURE);
682: }
683: else
684: return(KERN_ABORTED);
685: }
686:
687: assert(thread == thr_act->thread);
688:
689: spl = splsched();
690: thread_lock(thread);
691:
692: if( (thread->state&(TH_RUN|TH_UNINT|TH_WAIT)) == TH_WAIT ){
693: if ( thread->at_safe_point ) {
694: /*
695: * It's an interruptible wait, clear it, then
696: * let the thread go and return successfully.
697: */
698: thread_unlock(thread);
699: splx(spl);
700: clear_wait(thread, THREAD_INTERRUPTED, TRUE);
701: thread_unstop(thread);
702: thread_release(thr_act);
703: act_unlock_thread(thr_act);
704: return KERN_SUCCESS;
705: }
706: }
707: /*
708: * if not stopped at a safepoint, just let it go and return failure.
709: */
710: thread_unlock(thread);
711: splx(spl);
712: thread_unstop(thread);
713: thread_release(thr_act);
714: act_unlock_thread(thr_act);
715: return KERN_FAILURE;
716: }
717:
718: /*** backward compatibility hacks ***/
719: #include <mach/thread_info.h>
720: #include <mach/thread_special_ports.h>
721: #include <ipc/ipc_port.h>
722: #include <mach/thread_act_server.h>
723:
724: kern_return_t
725: thread_info(
726: thread_act_t thr_act,
727: thread_flavor_t flavor,
728: thread_info_t thread_info_out,
729: mach_msg_type_number_t *thread_info_count)
730: {
731: register thread_t thread;
732: kern_return_t result;
733:
734: if (thr_act == THR_ACT_NULL)
735: return (KERN_INVALID_ARGUMENT);
736:
737: thread = act_lock_thread(thr_act);
738: if (!thr_act->active) {
739: act_unlock_thread(thr_act);
740:
741: return (KERN_TERMINATED);
742: }
743:
744: if (thread == THREAD_NULL) {
745: act_unlock_thread(thr_act);
746:
747: return (KERN_NO_THREAD);
748: }
749:
750: result = thread_info_shuttle(thr_act, flavor,
751: thread_info_out, thread_info_count);
752:
753: act_unlock_thread(thr_act);
754:
755: return (result);
756: }
757:
758: /*
759: * Routine: thread_get_special_port [kernel call]
760: * Purpose:
761: * Clones a send right for one of the thread's
762: * special ports.
763: * Conditions:
764: * Nothing locked.
765: * Returns:
766: * KERN_SUCCESS Extracted a send right.
767: * KERN_INVALID_ARGUMENT The thread is null.
768: * KERN_FAILURE The thread is dead.
769: * KERN_INVALID_ARGUMENT Invalid special port.
770: */
771:
772: kern_return_t
773: thread_get_special_port(
774: thread_act_t thr_act,
775: int which,
776: ipc_port_t *portp)
777: {
778: ipc_port_t *whichp;
779: ipc_port_t port;
780: thread_t thread;
781:
782: #if MACH_ASSERT
783: if (watchacts & WA_PORT)
784: printf("thread_get_special_port(thr_act=%x, which=%x port@%x=%x\n",
785: thr_act, which, portp, (portp ? *portp : 0));
786: #endif /* MACH_ASSERT */
787:
788: if (!thr_act)
789: return KERN_INVALID_ARGUMENT;
790: thread = act_lock_thread(thr_act);
791: switch (which) {
792: case THREAD_KERNEL_PORT:
793: whichp = &thr_act->ith_sself;
794: break;
795:
796: default:
797: act_unlock_thread(thr_act);
798: return KERN_INVALID_ARGUMENT;
799: }
800:
801: if (!thr_act->active) {
802: act_unlock_thread(thr_act);
803: return KERN_FAILURE;
804: }
805:
806: port = ipc_port_copy_send(*whichp);
807: act_unlock_thread(thr_act);
808:
809: *portp = port;
810: return KERN_SUCCESS;
811: }
812:
813: /*
814: * Routine: thread_set_special_port [kernel call]
815: * Purpose:
816: * Changes one of the thread's special ports,
817: * setting it to the supplied send right.
818: * Conditions:
819: * Nothing locked. If successful, consumes
820: * the supplied send right.
821: * Returns:
822: * KERN_SUCCESS Changed the special port.
823: * KERN_INVALID_ARGUMENT The thread is null.
824: * KERN_FAILURE The thread is dead.
825: * KERN_INVALID_ARGUMENT Invalid special port.
826: */
827:
828: kern_return_t
829: thread_set_special_port(
830: thread_act_t thr_act,
831: int which,
832: ipc_port_t port)
833: {
834: ipc_port_t *whichp;
835: ipc_port_t old;
836: thread_t thread;
837:
838: #if MACH_ASSERT
839: if (watchacts & WA_PORT)
840: printf("thread_set_special_port(thr_act=%x,which=%x,port=%x\n",
841: thr_act, which, port);
842: #endif /* MACH_ASSERT */
843:
844: if (thr_act == 0)
845: return KERN_INVALID_ARGUMENT;
846:
847: thread = act_lock_thread(thr_act);
848: switch (which) {
849: case THREAD_KERNEL_PORT:
850: whichp = &thr_act->ith_self;
851: break;
852:
853: default:
854: act_unlock_thread(thr_act);
855: return KERN_INVALID_ARGUMENT;
856: }
857:
858: if (!thr_act->active) {
859: act_unlock_thread(thr_act);
860: return KERN_FAILURE;
861: }
862:
863: old = *whichp;
864: *whichp = port;
865: act_unlock_thread(thr_act);
866:
867: if (IP_VALID(old))
868: ipc_port_release_send(old);
869: return KERN_SUCCESS;
870: }
871:
872: /*
873: * thread state should always be accessible by locking the thread
874: * and copying it. The activation messes things up so for right
875: * now if it's not the top of the chain, use a special handler to
876: * get the information when the shuttle returns to the activation.
877: */
878: kern_return_t
879: thread_get_state(
880: register thread_act_t thr_act,
881: int flavor,
882: thread_state_t state, /* pointer to OUT array */
883: mach_msg_type_number_t *state_count) /*IN/OUT*/
884: {
885: kern_return_t ret;
886: thread_t thread, nthread;
887:
888: #if 0 /* Grenoble - why?? */
889: if (thr_act == THR_ACT_NULL || thr_act == current_act())
890: #else
891: if (thr_act == THR_ACT_NULL)
892: #endif
893: return (KERN_INVALID_ARGUMENT);
894:
895: thread = act_lock_thread(thr_act);
896: if (!thr_act->active) {
897: act_unlock_thread(thr_act);
898: return(KERN_TERMINATED);
899: }
900:
901: thread_hold(thr_act);
902: while (1) {
903: if (!thread || thr_act != thread->top_act)
904: break;
905: act_unlock_thread(thr_act);
906: (void)thread_stop_wait(thread);
907: nthread = act_lock_thread(thr_act);
908: if (nthread == thread)
909: break;
910: thread_unstop(thread);
911: thread = nthread;
912: }
913: ret = act_machine_get_state(thr_act, flavor,
914: state, state_count);
915: if (thread && thr_act == thread->top_act)
916: thread_unstop(thread);
917: thread_release(thr_act);
918: act_unlock_thread(thr_act);
919:
920: return(ret);
921: }
922:
923: /*
924: * Change thread's machine-dependent state. Called with nothing
925: * locked. Returns same way.
926: */
927: kern_return_t
928: thread_set_state(
929: register thread_act_t thr_act,
930: int flavor,
931: thread_state_t state,
932: mach_msg_type_number_t state_count)
933: {
934: kern_return_t ret;
935: thread_t thread, nthread;
936:
937: #if 0 /* Grenoble - why?? */
938: if (thr_act == THR_ACT_NULL || thr_act == current_act())
939: #else
940: if (thr_act == THR_ACT_NULL)
941: #endif
942: return (KERN_INVALID_ARGUMENT);
943: /*
944: * We have no kernel activations, so Utah's MO fails for signals etc.
945: *
946: * If we're blocked in the kernel, use non-blocking method, else
947: * pass locked thr_act+thread in to "normal" act_[gs]et_state().
948: */
949:
950: thread = act_lock_thread(thr_act);
951: if (!thr_act->active) {
952: act_unlock_thread(thr_act);
953: return(KERN_TERMINATED);
954: }
955:
956: thread_hold(thr_act);
957: while (1) {
958: if (!thread || thr_act != thread->top_act)
959: break;
960: act_unlock_thread(thr_act);
961: (void)thread_stop_wait(thread);
962: nthread = act_lock_thread(thr_act);
963: if (nthread == thread)
964: break;
965: thread_unstop(thread);
966: thread = nthread;
967: }
968: ret = act_machine_set_state(thr_act, flavor,
969: state, state_count);
970: if (thread && thr_act == thread->top_act)
971: thread_unstop(thread);
972: thread_release(thr_act);
973: act_unlock_thread(thr_act);
974:
975: return(ret);
976: }
977:
978: /*
979: * Kernel-internal "thread" interfaces used outside this file:
980: */
981:
982: kern_return_t
983: thread_dup(
984: thread_act_t source_thr_act,
985: thread_act_t target_thr_act)
986: {
987: kern_return_t ret;
988: thread_t thread, nthread;
989:
990: if (target_thr_act == THR_ACT_NULL || target_thr_act == current_act())
991: return (KERN_INVALID_ARGUMENT);
992:
993: thread = act_lock_thread(target_thr_act);
994: if (!target_thr_act->active) {
995: act_unlock_thread(target_thr_act);
996: return(KERN_TERMINATED);
997: }
998:
999: thread_hold(target_thr_act);
1000: while (1) {
1001: if (!thread || target_thr_act != thread->top_act)
1002: break;
1003: act_unlock_thread(target_thr_act);
1004: (void)thread_stop_wait(thread);
1005: nthread = act_lock_thread(target_thr_act);
1006: if (nthread == thread)
1007: break;
1008: thread_unstop(thread);
1009: thread = nthread;
1010: }
1011: ret = act_thread_dup(source_thr_act, target_thr_act);
1012: if (thread && target_thr_act == thread->top_act)
1013: thread_unstop(thread);
1014: thread_release(target_thr_act);
1015: act_unlock_thread(target_thr_act);
1016:
1017: return(ret);
1018: }
1019:
1020:
1021: /*
1022: * thread_setstatus:
1023: *
1024: * Set the status of the specified thread.
1025: * Called with (and returns with) no locks held.
1026: */
1027: kern_return_t
1028: thread_setstatus(
1029: thread_act_t thr_act,
1030: int flavor,
1031: thread_state_t tstate,
1032: mach_msg_type_number_t count)
1033: {
1034: kern_return_t kr;
1035: thread_t thread;
1036:
1037: thread = act_lock_thread(thr_act);
1038: assert(thread);
1039: assert(thread->top_act == thr_act);
1040: kr = act_machine_set_state(thr_act, flavor, tstate, count);
1041: act_unlock_thread(thr_act);
1042: return(kr);
1043: }
1044:
1045: /*
1046: * thread_getstatus:
1047: *
1048: * Get the status of the specified thread.
1049: */
1050: kern_return_t
1051: thread_getstatus(
1052: thread_act_t thr_act,
1053: int flavor,
1054: thread_state_t tstate,
1055: mach_msg_type_number_t *count)
1056: {
1057: kern_return_t kr;
1058: thread_t thread;
1059:
1060: thread = act_lock_thread(thr_act);
1061: assert(thread);
1062: assert(thread->top_act == thr_act);
1063: kr = act_machine_get_state(thr_act, flavor, tstate, count);
1064: act_unlock_thread(thr_act);
1065: return(kr);
1066: }
1067:
1068: /*
1069: * Kernel-internal thread_activation interfaces used outside this file:
1070: */
1071:
1072: /*
1073: * act_init() - Initialize activation handling code
1074: */
1075: void
1076: act_init()
1077: {
1078: thr_act_zone = zinit(
1079: sizeof(struct thread_activation),
1080: ACT_MAX * sizeof(struct thread_activation), /* XXX */
1081: ACT_CHUNK * sizeof(struct thread_activation),
1082: "activations");
1083: act_machine_init();
1084: }
1085:
1086:
1087: /*
1088: * act_create - Create a new activation in a specific task.
1089: */
1090: kern_return_t
1091: act_create(task_t task,
1092: thread_act_params_t params,
1093: thread_act_t *new_act)
1094: {
1095: thread_act_t thr_act;
1096: int rc;
1097: vm_map_t map;
1098:
1099: thr_act = (thread_act_t)zalloc(thr_act_zone);
1100: if (thr_act == 0)
1101: return(KERN_RESOURCE_SHORTAGE);
1102:
1103: #if MACH_ASSERT
1104: if (watchacts & WA_ACT_LNK)
1105: printf("act_create(task=%x,stk=%x,thr_act@%x=%x)\n",
1106: task, params ? params->stack : 0, new_act, thr_act);
1107: #endif /* MACH_ASSERT */
1108:
1109: /* Start by zeroing everything; then init non-zero items only */
1110: bzero((char *)thr_act, sizeof(*thr_act));
1111:
1112: /* Start with one reference for being active, another for the caller */
1113: act_lock_init(thr_act);
1114: thr_act->ref_count = 2;
1115:
1116: /* Latch onto the task. */
1117: thr_act->task = task;
1118: task_reference(task);
1119: thr_act->active = 1;
1120:
1121: /* Initialize sigbufp for High-Watermark buffer allocation */
1122: thr_act->r_sigbufp = (routine_descriptor_t) &thr_act->r_sigbuf;
1123: thr_act->r_sigbuf_size = sizeof(thr_act->r_sigbuf);
1124:
1125: /* Initialize thread stack */
1126: if (params)
1127: {
1128: thr_act->user_stack = params->stack;
1129: thr_act->user_stack_size = params->stack_size;
1130: thr_act->user_entry = params->entry_func;
1131: }
1132: else
1133: {
1134: thr_act->user_stack = 0;
1135: thr_act->user_stack_size = 0;
1136: thr_act->user_entry = 0;
1137: }
1138:
1139: #if THREAD_SWAPPER
1140: thr_act->swap_state = TH_SW_IN;
1141: #if MACH_ASSERT
1142: thr_act->kernel_stack_swapped_in = TRUE;
1143: #if THREAD_SWAP_UNWIRE_USER_STACK
1144: thr_act->user_stack_swapped_in = TRUE;
1145: #endif /* THREAD_SWAP_UNWIRE_USER_STACK */
1146: #endif /* MACH_ASSERT */
1147: #endif /* THREAD_SWAPPER */
1148:
1149: /* special_handler will always be last on the returnhandlers list. */
1150: thr_act->special_handler.next = 0;
1151: thr_act->special_handler.handler = special_handler;
1152:
1153: #if MACH_PROF
1154: thr_act->act_profiled = FALSE;
1155: thr_act->act_profiled_own = FALSE;
1156: thr_act->profil_buffer = NULLPROFDATA;
1157: #endif
1158:
1159: /* Initialize the held_ulocks queue as empty */
1160: queue_init(&thr_act->held_ulocks);
1161:
1162: /* Inherit the profiling status of the parent task */
1163: act_prof_init(thr_act, task);
1164:
1165: ipc_thr_act_init(task, thr_act);
1166: act_machine_create(task, thr_act);
1167:
1168: /*
1169: * If thr_act created in kernel-loaded task, alter its saved
1170: * state to so indicate
1171: */
1172: if (task->kernel_loaded) {
1173: act_user_to_kernel(thr_act);
1174: /*
1175: * If a user_stack was given, assume this is not a "base"
1176: * activation -- assert that it's fully kernel-loaded
1177: * already.
1178: */
1179: if (thr_act->user_stack != 0) {
1180: thr_act->kernel_loading = FALSE;
1181: thr_act->kernel_loaded = TRUE;
1182: }
1183: }
1184:
1185: task_lock(task);
1186:
1187: /* Chain the thr_act onto the task's list */
1188: mutex_lock(&task->act_list_lock);
1189: queue_enter(&task->thr_acts, thr_act, thread_act_t, thr_acts);
1190: task->thr_act_count++;
1191: /* no need to check for transition from 0 -> 1 here */
1192: task->res_act_count++;
1193: mutex_unlock(&task->act_list_lock);
1194:
1195: task_unlock(task);
1196:
1197: /* Cache the task's map and take a reference to it */
1198: thr_act->map = task->map;
1199:
1200: /* Inline vm_map_reference cause we don't want to increment res_count */
1201: map = task->map;
1202: mutex_lock(&map->s_lock);
1203: #if TASK_SWAPPER
1204: assert(map->res_count > 0);
1205: assert(map->ref_count >= map->res_count);
1206: #endif /* TASK_SWAPPER */
1207: map->ref_count++;
1208: mutex_unlock(&map->s_lock);
1209:
1210: *new_act = thr_act;
1211: return KERN_SUCCESS;
1212: }
1213:
1214: /*
1215: * act_free - called when an thr_act's ref_count drops to zero.
1216: *
1217: * This can only happen when thread is zero (not in use),
1218: * thread_pool is zero (not attached to any thread_pool),
1219: * and active is false (terminated). Called with act locked,
1220: * so that its shuttle pointer can be zeroed atomically.
1221: */
1222: #if MACH_ASSERT
1223: int dangerous_bzero = 1; /* paranoia & safety */
1224: #endif
1225:
1226: void
1227: act_free(thread_act_t thr_act)
1228: {
1229: thread_t thr;
1230: vm_map_t map;
1231: unsigned int ref;
1232:
1233: #if MACH_ASSERT
1234: if (watchacts & WA_EXIT)
1235: printf("act_free(%x(%d)) thr=%x tsk=%x(%d) pport=%x%sactive\n",
1236: thr_act, thr_act->ref_count, thr_act->thread,
1237: thr_act->task,
1238: thr_act->task ? thr_act->task->ref_count : 0,
1239: thr_act->pool_port,
1240: thr_act->active ? " " : " !");
1241: #endif /* MACH_ASSERT */
1242:
1243: /* Drop final ref to shuttle (not really ours, but we're
1244: * allowed to handle it). */
1245: if (thr = thr_act->thread) {
1246: thr_act->thread = 0;
1247: act_unlock(thr_act);
1248: thread_deallocate(thr);
1249: }
1250: else
1251: act_unlock(thr_act);
1252:
1253: #if THREAD_SWAPPER
1254: thread_swap_disable(thr_act);
1255: assert(thr_act->kernel_stack_swapped_in);
1256: #endif /* THREAD_SWAPPER */
1257:
1258: assert(!thr_act->active);
1259: assert(!thr_act->pool_port);
1260:
1261: act_machine_destroy(thr_act);
1262: ipc_thr_act_disable(thr_act);
1263: ipc_thr_act_terminate(thr_act);
1264:
1265: act_prof_deallocate(thr_act);
1266:
1267: /*
1268: * Drop the cached map reference.
1269: * Inline version of vm_map_deallocate() because we
1270: * don't want to decrement the map's residence count here.
1271: */
1272: map = thr_act->map;
1273: mutex_lock(&map->s_lock);
1274: #if TASK_SWAPPER
1275: assert(map->res_count >= 0);
1276: assert(map->ref_count > map->res_count);
1277: #endif /* TASK_SWAPPER */
1278: ref = --map->ref_count;
1279: mutex_unlock(&map->s_lock);
1280:
1281: /*
1282: * The task must still have a reference on the map. Also, if
1283: * the reference count drops to two (one remaining act and the
1284: * task itself), then someone may be waiting in task_halt_wait.
1285: * Wake them up, if needed.
1286: */
1287: if (ref == 0)
1288: panic("thread_deallocate: released last reference on map");
1289: else if (ref == 2)
1290: thread_wakeup(&map->ref_count);
1291:
1292: /* Drop the task reference. */
1293: task_deallocate(thr_act->task);
1294:
1295: #if MACH_ASSERT
1296: if (dangerous_bzero) /* dangerous if we're still using it! */
1297: bzero((char *)thr_act, sizeof(*thr_act));
1298: #endif /* MACH_ASSERT */
1299: /* Put the thr_act back on the thr_act zone */
1300: zfree(thr_act_zone, (vm_offset_t)thr_act);
1301: }
1302:
1303:
1304: /*
1305: * act_attach - Attach an thr_act to the top of a thread ("push the stack").
1306: *
1307: * The thread_shuttle must be either the current one or a brand-new one.
1308: * Assumes the thr_act is active but not in use, also, that if it is
1309: * attached to an thread_pool (i.e. the thread_pool pointer is nonzero),
1310: * the thr_act has already been taken off the thread_pool's list.
1311: *
1312: * Already locked: thr_act plus "appropriate" thread-related locks
1313: * (see act_lock_thread()).
1314: */
1315: void
1316: act_attach(
1317: thread_act_t thr_act,
1318: thread_t thread,
1319: unsigned init_alert_mask)
1320: {
1321: thread_act_t lower;
1322:
1323: #if MACH_ASSERT
1324: assert(thread == current_thread() || thread->top_act == THR_ACT_NULL);
1325: if (watchacts & WA_ACT_LNK)
1326: printf("act_attach(thr_act %x(%d) thread %x(%d) mask %d)\n",
1327: thr_act, thr_act->ref_count, thread, thread->ref_count,
1328: init_alert_mask);
1329: #endif /* MACH_ASSERT */
1330:
1331: /*
1332: * Chain the thr_act onto the thread's thr_act stack.
1333: * Set mask and auto-propagate alerts from below.
1334: */
1335: thr_act->thread = thread;
1336: thr_act->higher = THR_ACT_NULL; /*safety*/
1337: thr_act->alerts = 0;
1338: thr_act->alert_mask = init_alert_mask;
1339: lower = thr_act->lower = thread->top_act;
1340:
1341: if (lower != THR_ACT_NULL) {
1342: lower->higher = thr_act;
1343: thr_act->alerts = (lower->alerts & init_alert_mask);
1344: }
1345:
1346: thread->top_act = thr_act;
1347: }
1348:
1349: /*
1350: * act_detach
1351: *
1352: * Remove the current thr_act from the top of the current thread, i.e.
1353: * "pop the stack". Assumes already locked: thr_act plus "appropriate"
1354: * thread-related locks (see act_lock_thread).
1355: */
1356: void
1357: act_detach(
1358: thread_act_t cur_act)
1359: {
1360: thread_t cur_thread = cur_act->thread;
1361:
1362: #if MACH_ASSERT
1363: if (watchacts & (WA_EXIT|WA_ACT_LNK))
1364: printf("act_detach: thr_act %x(%d), thrd %x(%d) task=%x(%d)\n",
1365: cur_act, cur_act->ref_count,
1366: cur_thread, cur_thread->ref_count,
1367: cur_act->task,
1368: cur_act->task ? cur_act->task->ref_count : 0);
1369: #endif /* MACH_ASSERT */
1370:
1371: /* Unlink the thr_act from the thread's thr_act stack */
1372: cur_thread->top_act = cur_act->lower;
1373: cur_act->thread = 0;
1374:
1375: thread_pool_put_act(cur_act);
1376:
1377: #if MACH_ASSERT
1378: cur_act->lower = cur_act->higher = THR_ACT_NULL;
1379: if (cur_thread->top_act)
1380: cur_thread->top_act->higher = THR_ACT_NULL;
1381: #endif /* MACH_ASSERT */
1382:
1383: return;
1384: }
1385:
1386:
1387: /*
1388: * Synchronize a thread operation with RPC. Called with nothing
1389: * locked. Returns with thr_act locked, plus one of four
1390: * combinations of other locks held:
1391: * none - for new activation not yet associated with thread_pool
1392: * or shuttle
1393: * rpc_lock(thr_act->thread) only - for base activation (one
1394: * without pool_port)
1395: * ip_lock(thr_act->pool_port) only - for empty activation (one
1396: * with no associated shuttle)
1397: * both locks - for "active" activation (has shuttle, lives
1398: * on thread_pool)
1399: * If thr_act has an associated shuttle, this function returns
1400: * its address. Otherwise it returns zero.
1401: */
1402: thread_t
1403: act_lock_thread(
1404: thread_act_t thr_act)
1405: {
1406: ipc_port_t pport;
1407:
1408: /*
1409: * Allow the shuttle cloning code (q.v., when it
1410: * exists :-}) to obtain ip_lock()'s while holding
1411: * an rpc_lock().
1412: */
1413: while (1) {
1414: act_lock(thr_act);
1415: pport = thr_act->pool_port;
1416: if (!pport || ip_lock_try(pport)) {
1417: if (!thr_act->thread)
1418: break;
1419: if (rpc_lock_try(thr_act->thread))
1420: break;
1421: if (pport)
1422: ip_unlock(pport);
1423: }
1424: act_unlock(thr_act);
1425: mutex_pause();
1426: }
1427: return (thr_act->thread);
1428: }
1429:
1430: /*
1431: * Unsynchronize with RPC (i.e., undo an act_lock_thread() call).
1432: * Called with thr_act locked, plus thread locks held that are
1433: * "correct" for thr_act's state. Returns with nothing locked.
1434: */
1435: void
1436: act_unlock_thread(thread_act_t thr_act)
1437: {
1438: if (thr_act->thread)
1439: rpc_unlock(thr_act->thread);
1440: if (thr_act->pool_port)
1441: ip_unlock(thr_act->pool_port);
1442: act_unlock(thr_act);
1443: }
1444:
1445: /*
1446: * Synchronize with RPC given a pointer to a shuttle (instead of an
1447: * activation). Called with nothing locked; returns with all
1448: * "appropriate" thread-related locks held (see act_lock_thread()).
1449: */
1450: thread_act_t
1451: thread_lock_act(
1452: thread_t thread)
1453: {
1454: thread_act_t thr_act;
1455:
1456: while (1) {
1457: rpc_lock(thread);
1458: thr_act = thread->top_act;
1459: if (!thr_act)
1460: break;
1461: if (!act_lock_try(thr_act)) {
1462: rpc_unlock(thread);
1463: mutex_pause();
1464: continue;
1465: }
1466: if (thr_act->pool_port &&
1467: !ip_lock_try(thr_act->pool_port)) {
1468: rpc_unlock(thread);
1469: act_unlock(thr_act);
1470: mutex_pause();
1471: continue;
1472: }
1473: break;
1474: }
1475: return (thr_act);
1476: }
1477:
1478: /*
1479: * Unsynchronize with RPC starting from a pointer to a shuttle.
1480: * Called with RPC-related locks held that are appropriate to
1481: * shuttle's state; any activation is also locked.
1482: */
1483: void
1484: thread_unlock_act(
1485: thread_t thread)
1486: {
1487: thread_act_t thr_act;
1488:
1489: if (thr_act = thread->top_act) {
1490: if (thr_act->pool_port)
1491: ip_unlock(thr_act->pool_port);
1492: act_unlock(thr_act);
1493: }
1494: rpc_unlock(thread);
1495: }
1496:
1497: /*
1498: * switch_act
1499: *
1500: * If a new activation is given, switch to it. If not,
1501: * switch to the lower activation (pop). Returns the old
1502: * activation. This is for RPC support.
1503: */
1504: thread_act_t
1505: switch_act(
1506: thread_act_t act)
1507: {
1508: thread_t thread;
1509: thread_act_t old, new;
1510: unsigned cpu;
1511: spl_t spl;
1512:
1513:
1514: disable_preemption();
1515:
1516: cpu = cpu_number();
1517: thread = current_thread();
1518:
1519: /*
1520: * Find the old and new activation for switch.
1521: */
1522: old = thread->top_act;
1523:
1524: if (act) {
1525: new = act;
1526: new->thread = thread;
1527: }
1528: else {
1529: new = old->lower;
1530: }
1531:
1532: assert(new != THR_ACT_NULL);
1533: #if THREAD_SWAPPER
1534: assert(new->swap_state != TH_SW_OUT &&
1535: new->swap_state != TH_SW_COMING_IN);
1536: #endif /* THREAD_SWAPPER */
1537:
1538: assert(cpu_data[cpu].active_thread == thread);
1539: active_kloaded[cpu] = (new->kernel_loaded) ? new : 0;
1540:
1541: /* This is where all the work happens */
1542: machine_switch_act(thread, old, new, cpu);
1543:
1544: /*
1545: * Push or pop an activation on the chain.
1546: */
1547: if (act) {
1548: act_attach(new, thread, 0);
1549: }
1550: else {
1551: act_detach(old);
1552: }
1553:
1554: enable_preemption();
1555:
1556: return(old);
1557: }
1558:
1559: /*
1560: * install_special_handler
1561: * Install the special returnhandler that handles suspension and
1562: * termination, if it hasn't been installed already.
1563: *
1564: * Already locked: RPC-related locks for thr_act, but not
1565: * scheduling lock (thread_lock()) of the associated thread.
1566: */
1567: void
1568: install_special_handler(
1569: thread_act_t thr_act)
1570: {
1571: spl_t spl;
1572: thread_t thread = thr_act->thread;
1573:
1574: #if MACH_ASSERT
1575: if (watchacts & WA_ACT_HDLR)
1576: printf("act_%x: install_special_hdlr(%x)\n",current_act(),thr_act);
1577: #endif /* MACH_ASSERT */
1578:
1579: spl = splsched();
1580: if (thread)
1581: thread_lock(thread);
1582: install_special_handler_locked(thr_act);
1583: act_set_apc(thr_act);
1584: if (thread)
1585: thread_unlock(thread);
1586: splx(spl);
1587: }
1588:
1589: /*
1590: * install_special_handler_locked
1591: * Do the work of installing the special_handler.
1592: *
1593: * Already locked: RPC-related locks for thr_act, plus the
1594: * scheduling lock (thread_lock()) of the associated thread.
1595: */
1596: void
1597: install_special_handler_locked(
1598: thread_act_t thr_act)
1599: {
1600: ReturnHandler **rh;
1601: thread_t thread = thr_act->thread;
1602:
1603: /* The work handler must always be the last ReturnHandler on the list,
1604: because it can do tricky things like detach the thr_act. */
1605: for (rh = &thr_act->handlers; *rh; rh = &(*rh)->next)
1606: /* */ ;
1607: if (rh != &thr_act->special_handler.next) {
1608: *rh = &thr_act->special_handler;
1609: }
1610: if (thread && thr_act == thread->top_act) {
1611: /*
1612: * Temporarily undepress, so target has
1613: * a chance to do locking required to
1614: * block itself in special_handler().
1615: */
1616: /*** ??? fix me ***/
1617: assert(thread->sp_info != SP_INFO_NULL);
1618: if (((thread->policy == POLICY_TIMESHARE) ||
1619: (thread->policy == POLICY_RR) ||
1620: (thread->policy == POLICY_FIFO)) &&
1621: ((mk_sp_info_t)thread->sp_info)->depress_priority >= 0) {
1622: ((mk_sp_info_t)thread->sp_info)->priority = ((mk_sp_info_t)thread->sp_info)->depress_priority;
1623: /* Use special value -2 to indicate need
1624: * to redepress priority in special_handler
1625: * as thread blocks
1626: */
1627: ((mk_sp_info_t)thread->sp_info)->depress_priority = -2;
1628: compute_priority(thread, FALSE);
1629: }
1630: }
1631: act_set_apc(thr_act);
1632: }
1633:
1634: /*
1635: * JMM -
1636: * These two routines will be enhanced over time to call the general handler registration
1637: * mechanism used by special handlers and alerts. They are hack in for now to avoid
1638: * having to export the gory details of ASTs to the BSD code right now.
1639: */
1640: extern thread_apc_handler_t bsd_ast;
1641:
1642: kern_return_t
1643: thread_apc_set(
1644: thread_act_t thr_act,
1645: thread_apc_handler_t apc)
1646: {
1647: assert(apc == bsd_ast);
1648: thread_ast_set(thr_act, AST_BSD);
1649: if (thr_act == current_act())
1650: ast_propagate(thr_act->ast);
1651: return KERN_SUCCESS;
1652: }
1653:
1654: kern_return_t
1655: thread_apc_clear(
1656: thread_act_t thr_act,
1657: thread_apc_handler_t apc)
1658: {
1659: assert(apc == bsd_ast);
1660: thread_ast_clear(thr_act, AST_BSD);
1661: if (thr_act == current_act())
1662: ast_off(AST_BSD);
1663: return KERN_SUCCESS;
1664: }
1665:
1666: /*
1667: * act_set_thread_pool - Assign an activation to a specific thread_pool.
1668: * Fails if the activation is already assigned to another pool.
1669: * If thread_pool == 0, we remove the thr_act from its thread_pool.
1670: *
1671: * Called the port containing thread_pool already locked.
1672: * Returns the same way.
1673: */
1674: kern_return_t act_set_thread_pool(
1675: thread_act_t thr_act,
1676: ipc_port_t pool_port)
1677: {
1678: thread_pool_t thread_pool;
1679:
1680: #if MACH_ASSERT
1681: if (watchacts & WA_ACT_LNK)
1682: printf("act_set_thread_pool: %x(%d) -> %x\n",
1683: thr_act, thr_act->ref_count, thread_pool);
1684: #endif /* MACH_ASSERT */
1685:
1686: if (pool_port == 0) {
1687: thread_act_t *lact;
1688:
1689: if (thr_act->pool_port == 0)
1690: return KERN_SUCCESS;
1691: thread_pool = &thr_act->pool_port->ip_thread_pool;
1692:
1693: for (lact = &thread_pool->thr_acts; *lact;
1694: lact = &((*lact)->thread_pool_next)) {
1695: if (thr_act == *lact) {
1696: *lact = thr_act->thread_pool_next;
1697: break;
1698: }
1699: }
1700: act_lock(thr_act);
1701: thr_act->pool_port = 0;
1702: thr_act->thread_pool_next = 0;
1703: act_unlock(thr_act);
1704: act_deallocate(thr_act);
1705: return KERN_SUCCESS;
1706: }
1707: if (thr_act->pool_port != pool_port) {
1708: thread_pool = &pool_port->ip_thread_pool;
1709: if (thr_act->pool_port != 0) {
1710: #if MACH_ASSERT
1711: if (watchacts & WA_ACT_LNK)
1712: printf("act_set_thread_pool found %x!\n",
1713: thr_act->pool_port);
1714: #endif /* MACH_ASSERT */
1715: return(KERN_FAILURE);
1716: }
1717: act_lock(thr_act);
1718: thr_act->pool_port = pool_port;
1719:
1720: /* The pool gets a ref to the activation -- have
1721: * to inline operation because thr_act is already
1722: * locked.
1723: */
1724: act_locked_act_reference(thr_act);
1725:
1726: /* If it is available,
1727: * add it to the thread_pool's available-activation list.
1728: */
1729: if ((thr_act->thread == 0) && (thr_act->suspend_count == 0)) {
1730: thr_act->thread_pool_next = thread_pool->thr_acts;
1731: pool_port->ip_thread_pool.thr_acts = thr_act;
1732: if (thread_pool->waiting)
1733: thread_pool_wakeup(thread_pool);
1734: }
1735: act_unlock(thr_act);
1736: }
1737:
1738: return KERN_SUCCESS;
1739: }
1740:
1741: /*
1742: * act_locked_act_set_thread_pool- Assign activation to a specific thread_pool.
1743: * Fails if the activation is already assigned to another pool.
1744: * If thread_pool == 0, we remove the thr_act from its thread_pool.
1745: *
1746: * Called the port containing thread_pool already locked.
1747: * Also called with the thread activation locked.
1748: * Returns the same way.
1749: *
1750: * This routine is the same as `act_set_thread_pool()' except that it does
1751: * not call `act_deallocate(),' which unconditionally tries to obtain the
1752: * thread activation lock.
1753: */
1754: kern_return_t act_locked_act_set_thread_pool(
1755: thread_act_t thr_act,
1756: ipc_port_t pool_port)
1757: {
1758: thread_pool_t thread_pool;
1759:
1760: #if MACH_ASSERT
1761: if (watchacts & WA_ACT_LNK)
1762: printf("act_set_thread_pool: %x(%d) -> %x\n",
1763: thr_act, thr_act->ref_count, thread_pool);
1764: #endif /* MACH_ASSERT */
1765:
1766: if (pool_port == 0) {
1767: thread_act_t *lact;
1768:
1769: if (thr_act->pool_port == 0)
1770: return KERN_SUCCESS;
1771: thread_pool = &thr_act->pool_port->ip_thread_pool;
1772:
1773: for (lact = &thread_pool->thr_acts; *lact;
1774: lact = &((*lact)->thread_pool_next)) {
1775: if (thr_act == *lact) {
1776: *lact = thr_act->thread_pool_next;
1777: break;
1778: }
1779: }
1780:
1781: thr_act->pool_port = 0;
1782: thr_act->thread_pool_next = 0;
1783: act_locked_act_deallocate(thr_act);
1784: return KERN_SUCCESS;
1785: }
1786: if (thr_act->pool_port != pool_port) {
1787: thread_pool = &pool_port->ip_thread_pool;
1788: if (thr_act->pool_port != 0) {
1789: #if MACH_ASSERT
1790: if (watchacts & WA_ACT_LNK)
1791: printf("act_set_thread_pool found %x!\n",
1792: thr_act->pool_port);
1793: #endif /* MACH_ASSERT */
1794: return(KERN_FAILURE);
1795: }
1796: thr_act->pool_port = pool_port;
1797:
1798: /* The pool gets a ref to the activation -- have
1799: * to inline operation because thr_act is already
1800: * locked.
1801: */
1802: act_locked_act_reference(thr_act);
1803:
1804: /* If it is available,
1805: * add it to the thread_pool's available-activation list.
1806: */
1807: if ((thr_act->thread == 0) && (thr_act->suspend_count == 0)) {
1808: thr_act->thread_pool_next = thread_pool->thr_acts;
1809: pool_port->ip_thread_pool.thr_acts = thr_act;
1810: if (thread_pool->waiting)
1811: thread_pool_wakeup(thread_pool);
1812: }
1813: }
1814:
1815: return KERN_SUCCESS;
1816: }
1817:
1818: /*
1819: * Activation control support routines internal to this file:
1820: */
1821:
1822: /*
1823: * act_execute_returnhandlers() - does just what the name says
1824: *
1825: * This is called by system-dependent code when it detects that
1826: * thr_act->handlers is non-null while returning into user mode.
1827: * Activations linked onto an thread_pool always have null thr_act->handlers,
1828: * so RPC entry paths need not check it.
1829: */
1830: void act_execute_returnhandlers(
1831: void)
1832: {
1833: spl_t s;
1834: thread_t thread;
1835: thread_act_t thr_act = current_act();
1836:
1837: #if MACH_ASSERT
1838: if (watchacts & WA_ACT_HDLR)
1839: printf("execute_rtn_hdlrs: thr_act=%x\n", thr_act);
1840: #endif /* MACH_ASSERT */
1841:
1842: s = splsched();
1843: act_clr_apc(thr_act);
1844: spllo();
1845: while (1) {
1846: ReturnHandler *rh;
1847:
1848: /* Grab the next returnhandler */
1849: thread = act_lock_thread(thr_act);
1850: (void)splsched();
1851: thread_lock(thread);
1852: rh = thr_act->handlers;
1853: if (!rh) {
1854: thread_unlock(thread);
1855: splx(s);
1856: act_unlock_thread(thr_act);
1857: return;
1858: }
1859: thr_act->handlers = rh->next;
1860: thread_unlock(thread);
1861: spllo();
1862: act_unlock_thread(thr_act);
1863:
1864: #if MACH_ASSERT
1865: if (watchacts & WA_ACT_HDLR)
1866: printf( (rh == &thr_act->special_handler) ?
1867: "\tspecial_handler\n" : "\thandler=%x\n",
1868: rh->handler);
1869: #endif /* MACH_ASSERT */
1870:
1871: /* Execute it */
1872: (*rh->handler)(rh, thr_act);
1873: }
1874: }
1875:
1876: /*
1877: * special_handler - handles suspension, termination. Called
1878: * with nothing locked. Returns (if it returns) the same way.
1879: */
1880: void
1881: special_handler(
1882: ReturnHandler *rh,
1883: thread_act_t cur_act)
1884: {
1885: spl_t s;
1886: thread_t lthread;
1887: thread_t thread = act_lock_thread(cur_act);
1888: unsigned alert_bits;
1889: exception_data_type_t
1890: codes[EXCEPTION_CODE_MAX];
1891: kern_return_t kr;
1892: kern_return_t exc_kr;
1893:
1894: assert(thread != THREAD_NULL);
1895: #if MACH_ASSERT
1896: if (watchacts & WA_ACT_HDLR)
1897: printf("\t\tspecial_handler(thr_act=%x(%d))\n", cur_act,
1898: (cur_act ? cur_act->ref_count : 0));
1899: #endif /* MACH_ASSERT */
1900:
1901: s = splsched();
1902:
1903: thread_lock(thread);
1904: thread->state &= ~TH_ABORT; /* clear any aborts */
1905: thread_unlock(thread);
1906:
1907: /*
1908: * If someone has killed this invocation,
1909: * invoke the return path with a terminated exception.
1910: */
1911: if (!cur_act->active) {
1912: splx(s);
1913: act_unlock_thread(cur_act);
1914: act_machine_return(KERN_TERMINATED);
1915: }
1916:
1917: splx(s);
1918:
1919: /* strip server terminated bit */
1920: alert_bits = cur_act->alerts & (~SERVER_TERMINATED);
1921:
1922: /* clear server terminated bit */
1923: cur_act->alerts &= ~SERVER_TERMINATED;
1924:
1925: if ( alert_bits ) {
1926: /*
1927: * currently necessary to coordinate with the exception
1928: * code -fdr
1929: */
1930: act_unlock_thread(cur_act);
1931:
1932: /* upcall exception/alert port */
1933: codes[0] = alert_bits;
1934:
1935: /*
1936: * Exception makes a lot of assumptions. If there is no
1937: * exception handler or the exception reply is broken, the
1938: * thread will be terminated and exception will not return. If
1939: * we decide we don't like that behavior, we need to check
1940: * for the existence of an exception port before we call
1941: * exception.
1942: */
1943: exc_kr = alert_exception( EXC_RPC_ALERT, codes, 1 );
1944:
1945: /* clear the orphaned and time constraint indications */
1946: cur_act->alerts &= ~(ORPHANED | TIME_CONSTRAINT_UNSATISFIED);
1947:
1948: /* if this orphaned activation should be terminated... */
1949: if (exc_kr == KERN_RPC_TERMINATE_ORPHAN) {
1950: /*
1951: * ... terminate the activation
1952: *
1953: * This is done in two steps. First, the activation is
1954: * disabled (prepared for termination); second, the
1955: * `special_handler()' is executed again -- this time
1956: * to terminate the activation.
1957: * (`act_disable_task_locked()' arranges for the
1958: * additional execution of the `special_handler().')
1959: */
1960:
1961: #if THREAD_SWAPPER
1962: thread_swap_disable(cur_act);
1963: #endif /* THREAD_SWAPPER */
1964:
1965: /* acquire appropriate locks */
1966: task_lock(cur_act->task);
1967: act_lock_thread(cur_act);
1968:
1969: /* detach the activation from its task */
1970: kr = act_disable_task_locked(cur_act);
1971: assert( kr == KERN_SUCCESS );
1972:
1973: /* release locks */
1974: task_unlock(cur_act->task);
1975: }
1976: else {
1977: /* acquire activation lock again (released below) */
1978: act_lock_thread(cur_act);
1979: s = splsched();
1980: thread_lock(thread);
1981: /*** ??? fix me ***/
1982: assert(thread->sp_info != SP_INFO_NULL);
1983: if (((thread->policy == POLICY_TIMESHARE) ||
1984: (thread->policy == POLICY_RR) ||
1985: (thread->policy == POLICY_FIFO)) &&
1986: ((mk_sp_info_t)thread->sp_info)->depress_priority == -2) {
1987: /* We were temporarily undepressed by
1988: * install_special_handler; restore priority
1989: * depression.
1990: */
1991: ((mk_sp_info_t)thread->sp_info)->depress_priority = ((mk_sp_info_t)thread->sp_info)->priority;
1992: ((mk_sp_info_t)thread->sp_info)->priority = DEPRESSPRI;
1993: thread->sched_pri = DEPRESSPRI;
1994: }
1995: thread_unlock(thread);
1996: splx(s);
1997: }
1998: }
1999:
2000: /*
2001: * If we're suspended, go to sleep and wait for someone to wake us up.
2002: */
2003: if (cur_act->suspend_count) {
2004: if( cur_act->handlers == NULL ) {
2005: assert_wait((event_t)&cur_act->suspend_count,
2006: THREAD_ABORTSAFE);
2007: act_unlock_thread(cur_act);
2008: thread_block((void (*)(void))0);
2009: act_lock_thread(cur_act);
2010: }
2011:
2012: /*
2013: * If we're still (or again) suspended, go to sleep again
2014: * after executing any new handlers that may have appeared.
2015: */
2016: if (cur_act->suspend_count)
2017: install_special_handler(cur_act);
2018: else {
2019: s = splsched();
2020: thread_lock(thread);
2021: /*** ??? fix me ***/
2022: assert(thread->sp_info != SP_INFO_NULL);
2023: if (((thread->policy == POLICY_TIMESHARE) ||
2024: (thread->policy == POLICY_RR) ||
2025: (thread->policy == POLICY_FIFO)) &&
2026: ((mk_sp_info_t)thread->sp_info)->depress_priority == -2) {
2027: /* We were temporarily undepressed by
2028: * install_special_handler; restore priority
2029: * depression.
2030: */
2031: ((mk_sp_info_t)thread->sp_info)->depress_priority = ((mk_sp_info_t)thread->sp_info)->priority;
2032: ((mk_sp_info_t)thread->sp_info)->priority = DEPRESSPRI;
2033: thread->sched_pri = DEPRESSPRI;
2034: }
2035: thread_unlock(thread);
2036: splx(s);
2037: }
2038: }
2039:
2040: act_unlock_thread(cur_act);
2041: }
2042:
2043: /*
2044: * Try to nudge a thr_act into executing its returnhandler chain.
2045: * Ensures that the activation will execute its returnhandlers
2046: * before it next executes any of its user-level code.
2047: *
2048: * Called with thr_act's act_lock() and "appropriate" thread-related
2049: * locks held. (See act_lock_thread().) Returns same way.
2050: */
2051: void
2052: nudge(thread_act_t thr_act)
2053: {
2054: #if MACH_ASSERT
2055: if (watchacts & WA_ACT_HDLR)
2056: printf("\tact_%x: nudge(%x)\n", current_act(), thr_act);
2057: #endif /* MACH_ASSERT */
2058:
2059: /*
2060: * Don't need to do anything at all if this thr_act isn't the topmost.
2061: */
2062: if (thr_act->thread && thr_act->thread->top_act == thr_act) {
2063: /*
2064: * If it's suspended, wake it up.
2065: * This should nudge it even on another CPU.
2066: */
2067: thread_wakeup((event_t)&thr_act->suspend_count);
2068: }
2069: }
2070:
2071: /*
2072: * Update activation that belongs to a task created via kernel_task_create().
2073: */
2074: void
2075: act_user_to_kernel(
2076: thread_act_t thr_act)
2077: {
2078: pcb_user_to_kernel(thr_act);
2079: thr_act->kernel_loading = TRUE;
2080: }
2081:
2082: /*
2083: * Already locked: thr_act->task, RPC-related locks for thr_act
2084: *
2085: * Detach an activation from its task, and prepare it to terminate
2086: * itself.
2087: */
2088: kern_return_t
2089: act_disable_task_locked(
2090: thread_act_t thr_act)
2091: {
2092: thread_t thread = thr_act->thread;
2093: task_t task = thr_act->task;
2094:
2095: #if MACH_ASSERT
2096: if (watchacts & WA_EXIT) {
2097: printf("act_%x: act_disable_tl(thr_act=%x(%d))%sactive task=%x(%d)",
2098: current_act(), thr_act, thr_act->ref_count,
2099: (thr_act->active ? " " : " !"),
2100: thr_act->task, thr_act->task? thr_act->task->ref_count : 0);
2101: if (thr_act->pool_port)
2102: printf(", pool_port %x", thr_act->pool_port);
2103: printf("\n");
2104: (void) dump_act(thr_act);
2105: }
2106: #endif /* MACH_ASSERT */
2107: if (thr_act->thr_acts.next) {
2108: /* Unlink the thr_act from the task's thr_act list,
2109: * so it doesn't appear in calls to task_threads and such.
2110: * The thr_act still keeps its ref on the task, however.
2111: */
2112: #ifdef NOTEVER
2113: mutex_lock(&task->act_list_lock);
2114: #if 1
2115: queue_remove(&task->thr_acts, thr_act, thread_act_t, thr_acts);
2116: #else
2117: thr_act->thr_acts.next->prev = thr_act->thr_acts.prev;
2118: thr_act->thr_acts.prev->next = thr_act->thr_acts.next;
2119: #endif /* 1 */
2120: thr_act->thr_acts.next = 0;
2121: task->thr_act_count--;
2122: #if THREAD_SWAPPER
2123: /*
2124: * Thread is supposed to be unswappable by now...
2125: */
2126: assert(thr_act->swap_state == TH_SW_UNSWAPPABLE ||
2127: !(thread_swap_unwire_stack ||
2128: thread_swap_unwire_user_stack));
2129: #endif /* THREAD_SWAPPER */
2130: task->res_act_count--;
2131: mutex_unlock(&task->act_list_lock);
2132: #endif /* NOTEVER */
2133:
2134: /* This will allow no more control ops on this thr_act. */
2135: thr_act->active = 0;
2136:
2137: /* Clean-up any ulocks that are still owned by the thread
2138: * activation (acquired but not released or handed-off).
2139: */
2140: act_ulock_release_all(thr_act);
2141:
2142: /* If not an empty activation, install special handler */
2143: if (thr_act->thread != THREAD_NULL) {
2144:
2145: /* When the special_handler gets executed,
2146: * it will see the terminated condition and exit
2147: * immediately.
2148: */
2149: install_special_handler(thr_act);
2150: }
2151:
2152: /* If the target happens to be suspended,
2153: * give it a nudge so it can exit.
2154: */
2155: if (thr_act->suspend_count)
2156: nudge(thr_act);
2157: /* Drop the thr_act reference taken for being active.
2158: * (There is still at least one reference left:
2159: * the one we were passed.)
2160: * Inline the deallocate because thr_act is locked.
2161: */
2162: act_locked_act_deallocate(thr_act);
2163: }
2164:
2165: return(KERN_SUCCESS);
2166: }
2167:
2168: /*
2169: * act_alert - Register an alert from this activation.
2170: *
2171: * Each set bit is propagated upward from (but not including) this activation,
2172: * until the top of the chain is reached or the bit is masked.
2173: */
2174: kern_return_t
2175: act_alert(thread_act_t thr_act, unsigned alerts)
2176: {
2177: thread_t thread = act_lock_thread(thr_act);
2178:
2179: #if MACH_ASSERT
2180: if (watchacts & WA_ACT_LNK)
2181: printf("act_alert %x: %x\n", thr_act, alerts);
2182: #endif /* MACH_ASSERT */
2183:
2184: if (thread) {
2185: thread_act_t act_up = thr_act;
2186: while ((alerts) && (act_up != thread->top_act)) {
2187: act_up = act_up->higher;
2188: alerts &= act_up->alert_mask;
2189: act_up->alerts |= alerts;
2190: }
2191: /*
2192: * XXXX If we reach the top, and it is blocked in glue
2193: * code, do something to kick it. XXXX
2194: */
2195: }
2196: act_unlock_thread(thr_act);
2197:
2198: return KERN_SUCCESS;
2199: }
2200:
2201: kern_return_t act_alert_mask(thread_act_t thr_act, unsigned alert_mask)
2202: {
2203: panic("act_alert_mask NOT YET IMPLEMENTED\n");
2204: return KERN_SUCCESS;
2205: }
2206:
2207: typedef struct GetSetState {
2208: struct ReturnHandler rh;
2209: int flavor;
2210: void *state;
2211: int *pcount;
2212: int result;
2213: } GetSetState;
2214:
2215: /* Local Forward decls */
2216: kern_return_t get_set_state(
2217: thread_act_t thr_act, int flavor,
2218: thread_state_t state, int *pcount,
2219: void (*handler)(ReturnHandler *rh, thread_act_t thr_act));
2220: void get_state_handler(ReturnHandler *rh, thread_act_t thr_act);
2221: void set_state_handler(ReturnHandler *rh, thread_act_t thr_act);
2222:
2223: /*
2224: * get_set_state(thr_act ...)
2225: *
2226: * General code to install g/set_state handler.
2227: * Called with thr_act's act_lock() and "appropriate"
2228: * thread-related locks held. (See act_lock_thread().)
2229: */
2230: kern_return_t
2231: get_set_state(thread_act_t thr_act, int flavor, thread_state_t state, int *pcount,
2232: void (*handler)(ReturnHandler *rh, thread_act_t thr_act))
2233: {
2234: GetSetState gss;
2235: spl_t s;
2236:
2237: /* Initialize a small parameter structure */
2238: gss.rh.handler = handler;
2239: gss.flavor = flavor;
2240: gss.state = state;
2241: gss.pcount = pcount;
2242: gss.result = KERN_ABORTED; /* iff wait below is interrupted */
2243:
2244: /* Add it to the thr_act's return handler list */
2245: gss.rh.next = thr_act->handlers;
2246: thr_act->handlers = &gss.rh;
2247:
2248: s = splsched();
2249: act_set_apc(thr_act);
2250: splx(s);
2251:
2252: #if MACH_ASSERT
2253: if (watchacts & WA_ACT_HDLR) {
2254: printf("act_%x: get_set_state(thr_act=%x flv=%x state=%x ptr@%x=%x)",
2255: current_act(), thr_act, flavor, state,
2256: pcount, (pcount ? *pcount : 0));
2257: printf((handler == get_state_handler ? "get_state_hdlr\n" :
2258: (handler == set_state_handler ? "set_state_hdlr\n" :
2259: "hndler=%x\n")), handler);
2260: }
2261: #endif /* MACH_ASSERT */
2262:
2263: assert(thr_act->thread); /* Callers must ensure these */
2264: assert(thr_act != current_act());
2265: for (;;) {
2266: nudge(thr_act);
2267: /*
2268: * Wait must be interruptible to avoid deadlock (e.g.) with
2269: * task_suspend() when caller and target of get_set_state()
2270: * are in same task.
2271: */
2272: assert_wait((event_t)&gss, THREAD_ABORTSAFE);
2273: act_unlock_thread(thr_act);
2274: thread_block((void (*)(void))0);
2275: if (gss.result != KERN_ABORTED)
2276: break;
2277: if (current_act()->handlers)
2278: act_execute_returnhandlers();
2279: act_lock_thread(thr_act);
2280: }
2281:
2282: #if MACH_ASSERT
2283: if (watchacts & WA_ACT_HDLR)
2284: printf("act_%x: get_set_state returns %x\n",
2285: current_act(), gss.result);
2286: #endif /* MACH_ASSERT */
2287:
2288: return gss.result;
2289: }
2290:
2291: void
2292: set_state_handler(ReturnHandler *rh, thread_act_t thr_act)
2293: {
2294: GetSetState *gss = (GetSetState*)rh;
2295:
2296: #if MACH_ASSERT
2297: if (watchacts & WA_ACT_HDLR)
2298: printf("act_%x: set_state_handler(rh=%x,thr_act=%x)\n",
2299: current_act(), rh, thr_act);
2300: #endif /* MACH_ASSERT */
2301:
2302: gss->result = act_machine_set_state(thr_act, gss->flavor,
2303: gss->state, *gss->pcount);
2304: thread_wakeup((event_t)gss);
2305: }
2306:
2307: void
2308: get_state_handler(ReturnHandler *rh, thread_act_t thr_act)
2309: {
2310: GetSetState *gss = (GetSetState*)rh;
2311:
2312: #if MACH_ASSERT
2313: if (watchacts & WA_ACT_HDLR)
2314: printf("act_%x: get_state_handler(rh=%x,thr_act=%x)\n",
2315: current_act(), rh, thr_act);
2316: #endif /* MACH_ASSERT */
2317:
2318: gss->result = act_machine_get_state(thr_act, gss->flavor,
2319: gss->state,
2320: (mach_msg_type_number_t *) gss->pcount);
2321: thread_wakeup((event_t)gss);
2322: }
2323:
2324: kern_return_t
2325: act_get_state_locked(thread_act_t thr_act, int flavor, thread_state_t state,
2326: mach_msg_type_number_t *pcount)
2327: {
2328: #if MACH_ASSERT
2329: if (watchacts & WA_ACT_HDLR)
2330: printf("act_%x: act_get_state_L(thr_act=%x,flav=%x,st=%x,pcnt@%x=%x)\n",
2331: current_act(), thr_act, flavor, state, pcount,
2332: (pcount? *pcount : 0));
2333: #endif /* MACH_ASSERT */
2334:
2335: return(get_set_state(thr_act, flavor, state, (int*)pcount, get_state_handler));
2336: }
2337:
2338: kern_return_t
2339: act_set_state_locked(thread_act_t thr_act, int flavor, thread_state_t state,
2340: mach_msg_type_number_t count)
2341: {
2342: #if MACH_ASSERT
2343: if (watchacts & WA_ACT_HDLR)
2344: printf("act_%x: act_set_state_L(thr_act=%x,flav=%x,st=%x,pcnt@%x=%x)\n",
2345: current_act(), thr_act, flavor, state, count, count);
2346: #endif /* MACH_ASSERT */
2347:
2348: return(get_set_state(thr_act, flavor, state, (int*)&count, set_state_handler));
2349: }
2350:
2351: kern_return_t
2352: act_set_state(thread_act_t thr_act, int flavor, thread_state_t state,
2353: mach_msg_type_number_t count)
2354: {
2355: if (thr_act == THR_ACT_NULL || thr_act == current_act())
2356: return(KERN_INVALID_ARGUMENT);
2357:
2358: if (act_lock_thread(thr_act) == THREAD_NULL) {
2359: act_unlock(thr_act);
2360: return(KERN_INVALID_ARGUMENT);
2361: }
2362: return(act_set_state_locked(thr_act, flavor, state, count));
2363:
2364: }
2365:
2366: kern_return_t
2367: act_get_state(thread_act_t thr_act, int flavor, thread_state_t state,
2368: mach_msg_type_number_t *pcount)
2369: {
2370: if (thr_act == THR_ACT_NULL || thr_act == current_act())
2371: return(KERN_INVALID_ARGUMENT);
2372:
2373: if (act_lock_thread(thr_act) == THREAD_NULL) {
2374: act_unlock(thr_act);
2375: return(KERN_INVALID_ARGUMENT);
2376: }
2377: return(act_get_state_locked(thr_act, flavor, state, pcount));
2378: }
2379:
2380: /*
2381: * These two should be called at splsched()
2382: * Set/clear indicator to run APC (layered on ASTs)
2383: */
2384: void
2385: act_set_apc(thread_act_t thr_act)
2386: {
2387: thread_ast_set(thr_act, AST_APC);
2388: if (thr_act == current_act()) {
2389: mp_disable_preemption();
2390: ast_propagate(thr_act->ast);
2391: mp_enable_preemption();
2392: }
2393: }
2394:
2395: void
2396: act_clr_apc(thread_act_t thr_act)
2397: {
2398: thread_ast_clear(thr_act, AST_APC);
2399: }
2400:
2401: void
2402: act_ulock_release_all(thread_act_t thr_act)
2403: {
2404: ulock_t ulock;
2405:
2406: while (!queue_empty(&thr_act->held_ulocks)) {
2407: ulock = (ulock_t) queue_first(&thr_act->held_ulocks);
2408: (void) lock_make_unstable(ulock, thr_act);
2409: (void) lock_release_internal(ulock, thr_act);
2410: }
2411: }
2412:
2413: /*
2414: * Provide routines (for export to other components) of things that
2415: * are implemented as macros insternally.
2416: */
2417: #undef current_act
2418: thread_act_t
2419: current_act(void)
2420: {
2421: return(current_act_fast());
2422: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.