![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to act.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / kern|
Return to act.c CVS log | Up to [GnuMach] / OSKit-Mach / kern |
1.1 root 1: /*
2: * Copyright (c) 1993,1994 The University of Utah and
3: * the Computer Systems Laboratory (CSL). All rights reserved.
4: *
5: * Permission to use, copy, modify and distribute this software and its
6: * documentation is hereby granted, provided that both the copyright
7: * notice and this permission notice appear in all copies of the
8: * software, derivative works or modified versions, and any portions
9: * thereof, and that both notices appear in supporting documentation.
10: *
11: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
12: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
13: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
14: *
15: * CSL requests users of this software to return to [email protected] any
16: * improvements that they make and grant CSL redistribution rights.
17: *
18: * Author: Bryan Ford, University of Utah CSL
19: */
20: /*
21: * File: act.c
22: *
23: * Activation management routines
24: *
25: */
26:
27: #ifdef MIGRATING_THREADS
28:
29: #include <mach_ipc_compat.h> /* XXX */
30: #include <mach/kern_return.h>
31: #include <mach/alert.h>
32: #include <kern/mach_param.h> /* XXX INCALL_... */
33: #include <kern/zalloc.h>
34: #include <kern/thread.h>
35: #include <kern/task.h>
36: #include <kern/act.h>
37: #include <kern/current.h>
38: #include "ipc_target.h"
39:
40: static void special_handler(ReturnHandler *rh, struct Act *act);
41:
42: #ifdef ACT_STATIC_KLUDGE
43: #undef ACT_STATIC_KLUDGE
44: #define ACT_STATIC_KLUDGE 300
45: #endif
46:
47: #ifndef ACT_STATIC_KLUDGE
48: static zone_t act_zone;
49: #else
50: static Act *act_freelist;
51: static Act free_acts[ACT_STATIC_KLUDGE];
52: #endif
53:
54: /* This is a rather special activation
55: which resides at the top and bottom of every thread.
56: When the last "real" activation on a thread is destroyed,
57: the null_act on the bottom gets invoked, destroying the thread.
58: At the top, the null_act acts as an "invalid" cached activation,
59: which will always fail the cached-activation test on RPC paths.
60:
61: As you might expect, most of its members have no particular value.
62: alerts is zero. */
63: Act null_act;
64:
65: void
66: global_act_init()
67: {
68: #ifndef ACT_STATIC_KLUDGE
69: act_zone = zinit(
70: sizeof(struct Act),
71: ACT_MAX * sizeof(struct Act), /* XXX */
72: ACT_CHUNK * sizeof(struct Act),
73: 0, "activations");
74: #else
75: int i;
76:
77: printf("activations: [%x-%x]\n", &free_acts[0], &free_acts[ACT_STATIC_KLUDGE]);
78: act_freelist = &free_acts[0];
79: free_acts[0].ipt_next = 0;
80: for (i = 1; i < ACT_STATIC_KLUDGE; i++) {
81: free_acts[i].ipt_next = act_freelist;
82: act_freelist = &free_acts[i];
83: }
84: /* XXX simple_lock_init(&act_freelist->lock); */
85: #endif
86:
87: #if 0
88: simple_lock_init(&null_act.lock);
89: refcount_init(&null_act.ref_count, 1);
90: #endif
91:
92: act_machine_init();
93: }
94:
95: /* Create a new activation in a specific task.
96: Locking: Task */
97: kern_return_t act_create(task_t task, vm_offset_t user_stack,
98: vm_offset_t user_rbuf, vm_size_t user_rbuf_size,
99: struct Act **new_act)
100: {
101: Act *act;
102: int rc;
103:
104: #ifndef ACT_STATIC_KLUDGE
105: act = (Act*)zalloc(act_zone);
106: if (act == 0)
107: return(KERN_RESOURCE_SHORTAGE);
108: #else
109: /* XXX ipt_lock(act_freelist); */
110: act = act_freelist;
111: if (act == 0) panic("out of activations");
112: act_freelist = act->ipt_next;
113: /* XXX ipt_unlock(act_freelist); */
114: act->ipt_next = 0;
115: #endif
116: bzero(act, sizeof(*act)); /*XXX shouldn't be needed */
117:
118: #ifdef DEBUG
119: act->lower = act->higher = 0;
120: #endif
121:
122: /* Start with one reference for being active, another for the caller */
123: simple_lock_init(&act->lock);
124: refcount_init(&act->ref_count, 2);
125:
126: /* Latch onto the task. */
127: act->task = task;
128: task_reference(task);
129:
130: /* Other simple setup */
131: act->ipt = 0;
132: act->thread = 0;
133: act->suspend_count = 0;
134: act->active = 1;
135: act->handlers = 0;
136:
137: /* The special_handler will always be last on the returnhandlers list. */
138: act->special_handler.next = 0;
139: act->special_handler.handler = special_handler;
140:
141: ipc_act_init(task, act);
142: act_machine_create(task, act, user_stack, user_rbuf, user_rbuf_size);
143:
144: task_lock(task);
145:
146: /* Chain the act onto the task's list */
147: act->task_links.next = task->acts.next;
148: act->task_links.prev = &task->acts;
149: task->acts.next->prev = &act->task_links;
150: task->acts.next = &act->task_links;
151: task->act_count++;
152:
153: task_unlock(task);
154:
155: *new_act = act;
156: return KERN_SUCCESS;
157: }
158:
159: /* This is called when an act's ref_count drops to zero.
160: This can only happen when thread is zero (not in use),
161: ipt is zero (not attached to any ipt),
162: and active is false (terminated). */
163: static void act_free(Act *inc)
164: {
165: act_machine_destroy(inc);
166: ipc_act_destroy(inc);
167:
168: /* Drop the task reference. */
169: task_deallocate(inc->task);
170:
171: /* Put the act back on the act zone */
172: #ifndef ACT_STATIC_KLUDGE
173: zfree(act_zone, (vm_offset_t)inc);
174: #else
175: /* XXX ipt_lock(act_freelist); */
176: inc->ipt_next = act_freelist;
177: act_freelist = inc;
178: /* XXX ipt_unlock(act_freelist); */
179: #endif
180: }
181:
182: void act_deallocate(Act *inc)
183: {
184: refcount_drop(&inc->ref_count, act_free(inc));
185: }
186:
187: /* Attach an act to the top of a thread ("push the stack").
188: The thread must be either the current one or a brand-new one.
189: Assumes the act is active but not in use.
190: Assumes that if it is attached to an ipt (i.e. the ipt pointer is nonzero),
191: the act has already been taken off the ipt's list.
192:
193: Already locked: cur_thread, act */
194: void act_attach(Act *act, thread_t thread, unsigned init_alert_mask)
195: {
196: Act *lower;
197:
198: act->thread = thread;
199:
200: /* The thread holds a reference to the activation while using it. */
201: refcount_take(&act->ref_count);
202:
203: /* XXX detach any cached activations from above the target */
204:
205: /* Chain the act onto the thread's act stack. */
206: lower = thread->top_act;
207: act->lower = lower;
208: lower->higher = act;
209: thread->top_act = act;
210:
211: act->alert_mask = init_alert_mask;
212: act->alerts = lower->alerts & init_alert_mask;
213: }
214:
215: /* Remove the current act from the top of the current thread ("pop the stack").
216: Return it to the ipt it lives on, if any.
217: Locking: Thread > Act(not on ipt) > ipc_target */
218: void act_detach(Act *cur_act)
219: {
220: thread_t cur_thread = cur_act->thread;
221:
222: thread_lock(cur_thread);
223: act_lock(cur_act);
224:
225: /* Unlink the act from the thread's act stack */
226: cur_thread->top_act = cur_act->lower;
227: cur_act->thread = 0;
228: #ifdef DEBUG
229: cur_act->lower = cur_act->higher = 0;
230: #endif
231:
232: thread_unlock(cur_thread);
233:
234: /* Return it to the ipt's list */
235: if (cur_act->ipt)
236: {
237: ipt_lock(cur_act->ipt);
238: cur_act->ipt_next = cur_act->ipt->ipt_acts;
239: cur_act->ipt->ipt_acts = cur_act;
240: ipt_unlock(cur_act->ipt);
241: #if 0
242: printf(" return to ipt %x\n", cur_act->ipt);
243: #endif
244: }
245:
246: act_unlock(cur_act);
247:
248: /* Drop the act reference taken for being in use. */
249: refcount_drop(&cur_act->ref_count, act_free(cur_act));
250: }
251:
252:
253:
254: /*** Activation control support routines ***/
255:
256: /* This is called by system-dependent code
257: when it detects that act->handlers is non-null
258: while returning into user mode.
259: Activations linked onto an ipt always have null act->handlers,
260: so RPC entry paths need not check it.
261:
262: Locking: Act */
263: void act_execute_returnhandlers()
264: {
265: Act *act = current_act();
266:
267: #if 0
268: printf("execute_returnhandlers\n");
269: #endif
270: while (1) {
271: ReturnHandler *rh;
272:
273: /* Grab the next returnhandler */
274: act_lock(act);
275: rh = act->handlers;
276: if (!rh) {
277: act_unlock(act);
278: return;
279: }
280: act->handlers = rh->next;
281: act_unlock(act);
282:
283: /* Execute it */
284: (*rh->handler)(rh, act);
285: }
286: }
287:
288: /* Try to nudge an act into executing its returnhandler chain.
289: Ensures that the activation will execute its returnhandlers
290: before it next executes any of its user-level code.
291: Also ensures that it is safe to break the thread's activation chain
292: immediately above this activation,
293: by rolling out of any outstanding two-way-optimized RPC.
294:
295: The target activation is not necessarily active
296: or even in use by a thread.
297: If it isn't, this routine does nothing.
298:
299: Already locked: Act */
300: static void act_nudge(struct Act *act)
301: {
302: /* If it's suspended, wake it up. */
303: thread_wakeup(&act->suspend_count);
304:
305: /* Do a machine-dependent low-level nudge.
306: If we're on a multiprocessor,
307: this may mean sending an interprocessor interrupt.
308: In any case, it means rolling out of two-way-optimized RPC paths. */
309: act_machine_nudge(act);
310: }
311:
312: /* Install the special returnhandler that handles suspension and termination,
313: if it hasn't been installed already.
314:
315: Already locked: Act */
316: static void install_special_handler(struct Act *act)
317: {
318: ReturnHandler **rh;
319:
320: /* The work handler must always be the last ReturnHandler on the list,
321: because it can do tricky things like detach the act. */
322: for (rh = &act->handlers; *rh; rh = &(*rh)->next);
323: if (rh != &act->special_handler.next) {
324: *rh = &act->special_handler;
325: }
326:
327: /* Nudge the target activation,
328: to ensure that it will see the returnhandler we're adding. */
329: act_nudge(act);
330: }
331:
332: /* Locking: Act */
333: static void special_handler(ReturnHandler *rh, struct Act *cur_act)
334: {
335: retry:
336:
337: act_lock(cur_act);
338:
339: /* If someone has killed this invocation,
340: invoke the return path with a terminated exception. */
341: if (!cur_act->active) {
342: act_unlock(cur_act);
343: act_machine_return(KERN_TERMINATED);
344: /* XXX should just set the activation's reentry_routine
345: and then return from special_handler().
346: The magic reentry_routine should just pop its own activation
347: and chain to the reentry_routine of the _lower_ activation.
348: If that lower activation is the null_act,
349: the thread will then be terminated. */
350: }
351:
352: /* If we're suspended, go to sleep and wait for someone to wake us up. */
353: if (cur_act->suspend_count) {
354: act_unlock(cur_act);
355: /* XXX mp unsafe */
356: thread_wait((int)&cur_act->suspend_count, FALSE);
357:
358: act_lock(cur_act);
359:
360: /* If we're still (or again) suspended,
361: go to sleep again after executing any new returnhandlers that may have appeared. */
362: if (cur_act->suspend_count)
363: install_special_handler(cur_act);
364: }
365:
366: act_unlock(cur_act);
367: }
368:
369: #if 0 /************************ OLD SEMI-OBSOLETE CODE *********************/
370: static __dead void act_throughcall_return(Act *act)
371: {
372: /* Done - destroy the act and return */
373: act_detach(act);
374: act_terminate(act);
375: act_deallocate(act);
376:
377: /* XXX */
378: thread_terminate_self();
379: }
380:
381: __dead void act_throughcall(task_t task, void (*infunc)())
382: {
383: thread_t thread = current_thread();
384: Act *act;
385: ReturnHandler rh;
386: int rc;
387:
388: rc = act_create(task, 0, 0, 0, &act);
389: if (rc) return rc;
390:
391: act->return_routine = act_throughcall_return;
392:
393: thread_lock(thread);
394: act_lock(act);
395:
396: act_attach(thread, act, 0);
397:
398: rh.handler = infunc;
399: rh.next = act->handlers;
400: act->handlers = &rh;
401:
402: act_unlock(act);
403: thread_unlock(thread);
404:
405: /* Call through the act into the returnhandler list */
406: act_machine_throughcall(act);
407: }
408:
409:
410: /* Grab an act from the specified pool, to pass to act_upcall.
411: Returns with the act locked, since it's in an inconsistent state
412: (not on its ipt but not on a thread either).
413: Returns null if no acts are available on the ipt.
414:
415: Locking: ipc_target > Act(on ipt) */
416: Act *act_grab(struct ipc_target *ipt)
417: {
418: Act *act;
419:
420: ipt_lock(ipt);
421:
422: retry:
423:
424: /* Pull an act off the ipt's list. */
425: act = ipt->acts;
426: if (!act)
427: goto none_avail;
428: ipt->acts = act->ipt_next;
429:
430: act_lock(act);
431:
432: /* If it's been terminated, drop it and get another one. */
433: if (!act->active) {
434: #if 0
435: printf("dropping terminated act %08x\n", act);
436: #endif
437: /* XXX ipt_deallocate(ipt); */
438: act->ipt = 0;
439: act_unlock(act);
440: act_deallocate(act);
441: goto retry;
442: }
443:
444: none_avail:
445: ipt_unlock(ipt);
446:
447: return act;
448: }
449:
450: /* Try to make an upcall with an act on the specified ipt.
451: If the ipt is empty, returns KERN_RESOURCE_SHORTAGE. XXX???
452:
453: Locking: ipc_target > Act > Thread */
454: kern_return_t act_upcall(struct Act *act, unsigned init_alert_mask,
455: vm_offset_t user_entrypoint, vm_offset_t user_data)
456: {
457: thread_t cur_thread = current_thread();
458: int rc;
459:
460: /* XXX locking */
461:
462: act_attach(cur_thread, act, init_alert_mask);
463:
464: /* Make the upcall into the destination task */
465: rc = act_machine_upcall(act, user_entrypoint, user_data);
466:
467: /* Done - detach the act and return */
468: act_detach(act);
469:
470: return rc;
471: }
472: #endif /************************ END OF OLD SEMI-OBSOLETE CODE *********************/
473:
474:
475:
476:
477: /*** Act service routines ***/
478:
479: /* Lock this act and its current thread.
480: We can only find the thread from the act
481: and the thread must be locked before the act,
482: requiring a little icky juggling.
483:
484: If the thread is not currently on any thread,
485: returns with only the act locked.
486:
487: Note that this routine is not called on any performance-critical path.
488: It is only for explicit act operations
489: which don't happen often.
490:
491: Locking: Thread > Act */
492: static thread_t act_lock_thread(Act *act)
493: {
494: thread_t thread;
495:
496: retry:
497:
498: /* Find the thread */
499: act_lock(act);
500: thread = act->thread;
501: if (thread == 0)
502: {
503: act_unlock(act);
504: return 0;
505: }
506: thread_reference(thread);
507: act_unlock(act);
508:
509: /* Lock the thread and re-lock the act,
510: and make sure the thread didn't change. */
511: thread_lock(thread);
512: act_lock(act);
513: if (act->thread != thread)
514: {
515: act_unlock(act);
516: thread_unlock(thread);
517: thread_deallocate(thread);
518: goto retry;
519: }
520:
521: thread_deallocate(thread);
522:
523: return thread;
524: }
525:
526: /* Already locked: act->task
527: Locking: Task > Act */
528: kern_return_t act_terminate_task_locked(struct Act *act)
529: {
530: act_lock(act);
531:
532: if (act->active)
533: {
534: /* Unlink the act from the task's act list,
535: so it doesn't appear in calls to task_acts and such.
536: The act still keeps its ref on the task, however,
537: until it loses all its own references and is freed. */
538: act->task_links.next->prev = act->task_links.prev;
539: act->task_links.prev->next = act->task_links.next;
540: act->task->act_count--;
541:
542: /* Remove it from any ipc_target. XXX is this right? */
543: act_set_target(act, 0);
544:
545: /* This will allow no more control operations on this act. */
546: act->active = 0;
547:
548: /* When the special_handler gets executed,
549: it will see the terminated condition and exit immediately. */
550: install_special_handler(act);
551:
552: /* Drop the act reference taken for being active.
553: (There is still at least one reference left: the one we were passed.) */
554: act_deallocate(act);
555: }
556:
557: act_unlock(act);
558:
559: return KERN_SUCCESS;
560: }
561:
562: /* Locking: Task > Act */
563: kern_return_t act_terminate(struct Act *act)
564: {
565: task_t task = act->task;
566: kern_return_t rc;
567:
568: /* act->task never changes,
569: so we can read it before locking the act. */
570: task_lock(act->task);
571:
572: rc = act_terminate_task_locked(act);
573:
574: task_unlock(act->task);
575:
576: return rc;
577: }
578:
579: /* If this Act is on a Thread and is not the topmost,
580: yank it and everything below it off of the thread's stack
581: and put it all on a new thread forked from the original one.
582: May fail due to resource shortage, but can always be retried.
583:
584: Locking: Thread > Act */
585: kern_return_t act_yank(Act *act)
586: {
587: thread_t thread = act_lock_thread(act);
588:
589: #if 0
590: printf("act_yank inc %08x thread %08x\n", act, thread);
591: #endif
592: if (thread)
593: {
594: if (thread->top_act != act)
595: {
596: printf("detaching act %08x from thread %08x\n", act, thread);
597:
598: /* Nudge the activation into a clean point for detachment. */
599: act_nudge(act);
600:
601: /* Now detach the activation
602: and give the orphan its own flow of control. */
603: /*XXX*/
604: }
605:
606: thread_unlock(thread);
607: }
608: act_unlock(act);
609:
610: /* Ask the thread to return as quickly as possible,
611: because its results are now useless. */
612: act_abort(act);
613:
614: return KERN_SUCCESS;
615: }
616:
617: /* Assign an activation to a specific ipc_target.
618: Fails if the activation is already assigned to another pool.
619: If ipt == 0, we remove the from its ipt.
620:
621: Locking: Act(not on ipt) > ipc_target > Act(on ipt) */
622: kern_return_t act_set_target(Act *act, struct ipc_target *ipt)
623: {
624: act_lock(act);
625:
626: if (ipt == 0)
627: {
628: Act **lact;
629:
630: ipt = act->ipt;
631: if (ipt == 0)
632: return;
633:
634: /* XXX This is a violation of the locking order. */
635: ipt_lock(ipt);
636: for (lact = &ipt->ipt_acts; *lact; lact = &((*lact)->ipt_next))
637: if (act == *lact)
638: {
639: *lact = act->ipt_next;
640: break;
641: }
642: ipt_unlock(ipt);
643:
644: act->ipt = 0;
645: /* XXX ipt_deallocate(ipt); */
646: act_deallocate(act);
647: return;
648: }
649: if (act->ipt != ipt)
650: {
651: if (act->ipt != 0)
652: {
653: act_unlock(act);
654: return KERN_FAILURE; /*XXX*/
655: }
656: act->ipt = ipt;
657: ipt->ipt_type |= IPT_TYPE_MIGRATE_RPC;
658:
659: /* They get references to each other. */
660: act_reference(act);
661: ipt_reference(ipt);
662:
663: /* If it is available,
664: add it to the ipt's available-activation list. */
665: if ((act->thread == 0) && (act->suspend_count == 0))
666: {
667: ipt_lock(ipt);
668: act->ipt_next = ipt->ipt_acts;
669: act->ipt->ipt_acts = act;
670: ipt_unlock(ipt);
671: }
672: }
673: act_unlock(act);
674:
675: return KERN_SUCCESS;
676: }
677:
678: /* Register an alert from this activation.
679: Each set bit is propagated upward from (but not including) this activation,
680: until the top of the chain is reached or the bit is masked.
681:
682: Locking: Thread > Act */
683: kern_return_t act_alert(struct Act *act, unsigned alerts)
684: {
685: thread_t thread = act_lock_thread(act);
686:
687: #if 0
688: printf("act_alert %08x: %08x\n", act, alerts);
689: #endif
690: if (thread)
691: {
692: struct Act *act_up = act;
693: while ((alerts) && (act_up != thread->top_act))
694: {
695: act_up = act_up->higher;
696: alerts &= act_up->alert_mask;
697: act_up->alerts |= alerts;
698: }
699:
700: /* XXX If we reach the top, and it is blocked in glue code, do something. */
701:
702: thread_unlock(thread);
703: }
704: act_unlock(act);
705:
706: return KERN_SUCCESS;
707: }
708:
709: /* Locking: Thread > Act */
710: kern_return_t act_abort(struct Act *act)
711: {
712: return act_alert(act, ALERT_ABORT_STRONG);
713: }
714:
715: /* Locking: Thread > Act */
716: kern_return_t act_abort_safely(struct Act *act)
717: {
718: return act_alert(act, ALERT_ABORT_SAFE);
719: }
720:
721: /* Locking: Thread > Act */
722: kern_return_t act_alert_mask(struct Act *act, unsigned alert_mask)
723: {
724: panic("act_alert_mask\n");
725: return KERN_SUCCESS;
726: }
727:
728: /* Locking: Thread > Act */
729: kern_return_t act_suspend(struct Act *act)
730: {
731: thread_t thread = act_lock_thread(act);
732: kern_return_t rc = KERN_SUCCESS;
733:
734: #if 0
735: printf("act_suspend %08x\n", act);
736: #endif
737: if (act->active)
738: {
739: if (act->suspend_count++ == 0)
740: {
741: /* XXX remove from ipt */
742: install_special_handler(act);
743: act_nudge(act);
744: }
745: }
746: else
747: rc = KERN_TERMINATED;
748:
749: if (thread)
750: thread_unlock(thread);
751: act_unlock(act);
752:
753: return rc;
754: }
755:
756: /* Locking: Act */
757: kern_return_t act_resume(struct Act *act)
758: {
759: #if 0
760: printf("act_resume %08x from %d\n", act, act->suspend_count);
761: #endif
762:
763: act_lock(act);
764: if (!act->active)
765: {
766: act_unlock(act);
767: return KERN_TERMINATED;
768: }
769:
770: if (act->suspend_count > 0) {
771: if (--act->suspend_count == 0) {
772: thread_wakeup(&act->suspend_count);
773: /* XXX return to ipt */
774: }
775: }
776:
777: act_unlock(act);
778:
779: return KERN_SUCCESS;
780: }
781:
782: typedef struct GetSetState {
783: struct ReturnHandler rh;
784: int flavor;
785: void *state;
786: int *pcount;
787: int result;
788: } GetSetState;
789:
790: /* Locking: Thread */
791: kern_return_t get_set_state(struct Act *act, int flavor, void *state, int *pcount,
792: void (*handler)(ReturnHandler *rh, struct Act *act))
793: {
794: GetSetState gss;
795:
796: /* Initialize a small parameter structure */
797: gss.rh.handler = handler;
798: gss.flavor = flavor;
799: gss.state = state;
800: gss.pcount = pcount;
801:
802: /* Add it to the act's return handler list */
803: act_lock(act);
804: gss.rh.next = act->handlers;
805: act->handlers = &gss.rh;
806:
807: act_nudge(act);
808:
809: act_unlock(act);
810: /* XXX mp unsafe */
811: thread_wait((int)&gss, 0); /* XXX could be interruptible */
812:
813: return gss.result;
814: }
815:
816: static void get_state_handler(ReturnHandler *rh, struct Act *act)
817: {
818: GetSetState *gss = (GetSetState*)rh;
819:
820: gss->result = act_machine_get_state(act, gss->flavor, gss->state, gss->pcount);
821: thread_wakeup((int)gss);
822: }
823:
824: /* Locking: Thread */
825: kern_return_t act_get_state(struct Act *act, int flavor, natural_t *state, natural_t *pcount)
826: {
827: return get_set_state(act, flavor, state, pcount, get_state_handler);
828: }
829:
830: static void set_state_handler(ReturnHandler *rh, struct Act *act)
831: {
832: GetSetState *gss = (GetSetState*)rh;
833:
834: gss->result = act_machine_set_state(act, gss->flavor, gss->state, *gss->pcount);
835: thread_wakeup((int)gss);
836: }
837:
838: /* Locking: Thread */
839: kern_return_t act_set_state(struct Act *act, int flavor, natural_t *state, natural_t count)
840: {
841: return get_set_state(act, flavor, state, &count, set_state_handler);
842: }
843:
844:
845:
846: /*** backward compatibility hacks ***/
847:
848: #include <mach/thread_info.h>
849: #include <mach/thread_special_ports.h>
850: #include <ipc/ipc_port.h>
851:
852: kern_return_t act_thread_info(Act *act, int flavor,
853: thread_info_t thread_info_out, unsigned *thread_info_count)
854: {
855: return thread_info(act->thread, flavor, thread_info_out, thread_info_count);
856: }
857:
858: kern_return_t
859: act_thread_assign(Act *act, processor_set_t new_pset)
860: {
861: return thread_assign(act->thread, new_pset);
862: }
863:
864: kern_return_t
865: act_thread_assign_default(Act *act)
866: {
867: return thread_assign_default(act->thread);
868: }
869:
870: kern_return_t
871: act_thread_get_assignment(Act *act, processor_set_t *pset)
872: {
873: return thread_get_assignment(act->thread, pset);
874: }
875:
876: kern_return_t
877: act_thread_priority(Act *act, int priority, boolean_t set_max)
878: {
879: return thread_priority(act->thread, priority, set_max);
880: }
881:
882: kern_return_t
883: act_thread_max_priority(Act *act, processor_set_t *pset, int max_priority)
884: {
885: return thread_max_priority(act->thread, pset, max_priority);
886: }
887:
888: kern_return_t
889: act_thread_policy(Act *act, int policy, int data)
890: {
891: return thread_policy(act->thread, policy, data);
892: }
893:
894: kern_return_t
895: act_thread_wire(struct host *host, Act *act, boolean_t wired)
896: {
897: return thread_wire(host, act->thread, wired);
898: }
899:
900: kern_return_t
901: act_thread_depress_abort(Act *act)
902: {
903: return thread_depress_abort(act->thread);
904: }
905:
906: /*
907: * Routine: act_get_special_port [kernel call]
908: * Purpose:
909: * Clones a send right for one of the thread's
910: * special ports.
911: * Conditions:
912: * Nothing locked.
913: * Returns:
914: * KERN_SUCCESS Extracted a send right.
915: * KERN_INVALID_ARGUMENT The thread is null.
916: * KERN_FAILURE The thread is dead.
917: * KERN_INVALID_ARGUMENT Invalid special port.
918: */
919:
920: kern_return_t
921: act_get_special_port(Act *act, int which, ipc_port_t *portp)
922: {
923: ipc_port_t *whichp;
924: ipc_port_t port;
925:
926: #if 0
927: printf("act_get_special_port\n");
928: #endif
929: if (act == 0)
930: return KERN_INVALID_ARGUMENT;
931:
932: switch (which) {
933: #if MACH_IPC_COMPAT
934: case THREAD_REPLY_PORT:
935: whichp = &act->reply_port;
936: break;
937: #endif /* MACH_IPC_COMPAT */
938:
939: case THREAD_KERNEL_PORT:
940: whichp = &act->self_port;
941: break;
942:
943: case THREAD_EXCEPTION_PORT:
944: whichp = &act->exception_port;
945: break;
946:
947: default:
948: return KERN_INVALID_ARGUMENT;
949: }
950:
951: thread_lock(act->thread);
952:
953: if (act->self_port == IP_NULL) {
954: thread_unlock(act->thread);
955: return KERN_FAILURE;
956: }
957:
958: port = ipc_port_copy_send(*whichp);
959: thread_unlock(act->thread);
960:
961: *portp = port;
962: return KERN_SUCCESS;
963: }
964:
965: /*
966: * Routine: act_set_special_port [kernel call]
967: * Purpose:
968: * Changes one of the thread's special ports,
969: * setting it to the supplied send right.
970: * Conditions:
971: * Nothing locked. If successful, consumes
972: * the supplied send right.
973: * Returns:
974: * KERN_SUCCESS Changed the special port.
975: * KERN_INVALID_ARGUMENT The thread is null.
976: * KERN_FAILURE The thread is dead.
977: * KERN_INVALID_ARGUMENT Invalid special port.
978: */
979:
980: kern_return_t
981: act_set_special_port(Act *act, int which, ipc_port_t port)
982: {
983: ipc_port_t *whichp;
984: ipc_port_t old;
985:
986: #if 0
987: printf("act_set_special_port\n");
988: #endif
989: if (act == 0)
990: return KERN_INVALID_ARGUMENT;
991:
992: switch (which) {
993: #if MACH_IPC_COMPAT
994: case THREAD_REPLY_PORT:
995: whichp = &act->reply_port;
996: break;
997: #endif /* MACH_IPC_COMPAT */
998:
999: case THREAD_KERNEL_PORT:
1000: whichp = &act->self_port;
1001: break;
1002:
1003: case THREAD_EXCEPTION_PORT:
1004: whichp = &act->exception_port;
1005: break;
1006:
1007: default:
1008: return KERN_INVALID_ARGUMENT;
1009: }
1010:
1011: thread_lock(act->thread);
1012: if (act->self_port == IP_NULL) {
1013: thread_unlock(act->thread);
1014: return KERN_FAILURE;
1015: }
1016:
1017: old = *whichp;
1018: *whichp = port;
1019: thread_unlock(act->thread);
1020:
1021: if (IP_VALID(old))
1022: ipc_port_release_send(old);
1023: return KERN_SUCCESS;
1024: }
1025:
1026: /*
1027: * XXX lame, non-blocking ways to get/set state.
1028: * Return thread's machine-dependent state.
1029: */
1030: kern_return_t
1031: act_get_state_immediate(act, flavor, old_state, old_state_count)
1032: register Act *act;
1033: int flavor;
1034: void *old_state; /* pointer to OUT array */
1035: unsigned int *old_state_count; /*IN/OUT*/
1036: {
1037: kern_return_t ret;
1038:
1039: act_lock(act);
1040: /* not the top activation, return current state */
1041: if (act->thread && act->thread->top_act != act) {
1042: ret = act_machine_get_state(act, flavor,
1043: old_state, old_state_count);
1044: act_unlock(act);
1045: return ret;
1046: }
1047: act_unlock(act);
1048:
1049: /* not sure this makes sense */
1050: return act_get_state(act, flavor, old_state, old_state_count);
1051: }
1052:
1053: /*
1054: * Change thread's machine-dependent state.
1055: */
1056: kern_return_t
1057: act_set_state_immediate(act, flavor, new_state, new_state_count)
1058: register Act *act;
1059: int flavor;
1060: void *new_state;
1061: unsigned int new_state_count;
1062: {
1063: kern_return_t ret;
1064:
1065: act_lock(act);
1066: /* not the top activation, set it now */
1067: if (act->thread && act->thread->top_act != act) {
1068: ret = act_machine_set_state(act, flavor,
1069: new_state, new_state_count);
1070: act_unlock(act);
1071: return ret;
1072: }
1073: act_unlock(act);
1074:
1075: /* not sure this makes sense */
1076: return act_set_state(act, flavor, new_state, new_state_count);
1077: }
1078:
1079: void act_count()
1080: {
1081: int i;
1082: Act *act;
1083: static int amin = ACT_STATIC_KLUDGE;
1084:
1085: i = 0;
1086: for (act = act_freelist; act; act = act->ipt_next)
1087: i++;
1088: if (i < amin)
1089: amin = i;
1090: printf("%d of %d activations in use, %d max\n",
1091: ACT_STATIC_KLUDGE-i, ACT_STATIC_KLUDGE, ACT_STATIC_KLUDGE-amin);
1092: }
1093:
1094: dump_act(act)
1095: Act *act;
1096: {
1097: act_count();
1098: kact_count();
1099: while (act) {
1100: printf("%08.8x: thread=%x, task=%x, hi=%x, lo=%x, ref=%x\n",
1101: act, act->thread, act->task,
1102: act->higher, act->lower, act->ref_count);
1103: printf("\talerts=%x, mask=%x, susp=%x, active=%x\n",
1104: act->alerts, act->alert_mask,
1105: act->suspend_count, act->active);
1106: machine_dump_act(&act->mact);
1107: if (act == act->lower)
1108: break;
1109: act = act->lower;
1110: }
1111: }
1112:
1113: #ifdef ACTWATCH
1114: Act *
1115: get_next_act(sp)
1116: int sp;
1117: {
1118: static int i;
1119: Act *act;
1120:
1121: while (1) {
1122: if (i == ACT_STATIC_KLUDGE) {
1123: i = 0;
1124: return 0;
1125: }
1126: act = &free_acts[i];
1127: i++;
1128: if (act->mact.space == sp)
1129: return act;
1130: }
1131: }
1132: #endif
1133:
1134: #endif /* MIGRATING_THREADS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.