![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ppc|
Return to pcb.c CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
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_COPYRIGHT@
24: */
25: /*
26: * Copyright (c) 1990,1991,1992 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 is hereby
30: * granted provided that (1) source code retains these copyright, permission,
31: * and disclaimer notices, and (2) redistributions including binaries
32: * reproduce the notices in supporting documentation, and (3) all advertising
33: * materials mentioning features or use of this software display the following
34: * acknowledgement: ``This product includes software developed by the Center
35: * for Software Science at the University of Utah.''
36: *
37: * THE UNIVERSITY OF UTAH AND CSS ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
38: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSS DISCLAIM ANY LIABILITY OF
39: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
40: *
41: * CSS requests users of this software to return to [email protected] any
42: * improvements that they make and grant CSS redistribution rights.
43: *
44: * Utah $Hdr: pcb.c 1.23 92/06/27$
45: */
46:
47: #include <cpus.h>
48: #include <debug.h>
49:
50: #include <types.h>
51: #include <kern/task.h>
52: #include <kern/thread.h>
53: #include <kern/thread_act.h>
54: #include <kern/thread_swap.h>
55: #include <mach/thread_status.h>
56: #include <vm/vm_kern.h>
57: #include <kern/mach_param.h>
58:
59: #include <kern/misc_protos.h>
60: #include <ppc/misc_protos.h>
61: #include <ppc/fpu_protos.h>
62: #include <ppc/exception.h>
63: #include <ppc/proc_reg.h>
64: #include <kern/spl.h>
65: #include <ppc/pmap.h>
66: #include <ppc/trap.h>
67: #include <ppc/mappings.h>
68: #include <ppc/savearea.h>
69: #include <ppc/Firmware.h>
70: #include <ppc/asm.h>
71: #include <ppc/thread_act.h>
72:
73: #include <sys/kdebug.h>
74:
75: extern int real_ncpus; /* Number of actual CPUs */
76: extern struct Saveanchor saveanchor; /* Aliged savearea anchor */
77:
78: /*
79: * These constants are dumb. They should not be in asm.h!
80: */
81:
82: #define KF_SIZE (FM_SIZE+ARG_SIZE+FM_REDZONE)
83:
84: #if DEBUG
85: int fpu_trap_count = 0;
86: int fpu_switch_count = 0;
87: int vec_trap_count = 0;
88: int vec_switch_count = 0;
89: #endif
90:
91: extern struct thread_shuttle *Switch_context(
92: struct thread_shuttle *old,
93: void (*cont)(void),
94: struct thread_shuttle *new);
95:
96:
97: #if MACH_LDEBUG || MACH_KDB
98: void log_thread_action (char *, long, long, long);
99: #endif
100:
101:
102: /*
103: * consider_machine_collect: try to collect machine-dependent pages
104: */
105: void
106: consider_machine_collect()
107: {
108: /*
109: * none currently available
110: */
111: return;
112: }
113:
114: /*
115: * stack_attach: Attach a kernel stack to a thread.
116: */
117: void
118: machine_kernel_stack_init(
119: struct thread_shuttle *thread,
120: void (*continuation)(void))
121: {
122: vm_offset_t stack;
123: unsigned int *kss;
124: struct savearea *sv;
125:
126: assert(thread->top_act->mact.pcb);
127: assert(thread->kernel_stack);
128: stack = thread->kernel_stack;
129:
130: #if MACH_ASSERT
131: if (watchacts & WA_PCB)
132: printf("machine_kernel_stack_init(thr=%x,stk=%x,cont=%x)\n", thread,stack,continuation);
133: #endif /* MACH_ASSERT */
134:
135: kss = (unsigned int *)STACK_IKS(stack);
136: sv=(savearea *)(thread->top_act->mact.pcb); /* This for the sake of C */
137:
138: sv->save_lr = (unsigned int) continuation; /* Set up the execution address */
139: sv->save_srr0 = (unsigned int) continuation; /* Here too */
140: sv->save_srr1 = MSR_SUPERVISOR_INT_ON; /* Set the normal running MSR */
141: sv->save_r1 = (vm_offset_t) ((int)kss - KF_SIZE); /* Point to the top frame on the stack */
142:
143: *((int *)sv->save_r1) = 0; /* Zero the frame backpointer */
144: thread->top_act->mact.ksp = 0; /* Show that the kernel stack is in use already */
145:
146: }
147:
148: /*
149: * switch_context: Switch from one thread to another, needed for
150: * switching of space
151: *
152: */
153: struct thread_shuttle*
154: switch_context(
155: struct thread_shuttle *old,
156: void (*continuation)(void),
157: struct thread_shuttle *new)
158: {
159: register thread_act_t old_act = old->top_act, new_act = new->top_act;
160: register struct thread_shuttle* retval;
161: pmap_t new_pmap;
162: #if MACH_LDEBUG || MACH_KDB
163: log_thread_action("switch",
164: (long)old,
165: (long)new,
166: (long)__builtin_return_address(0));
167: #endif
168: assert(old_act->kernel_loaded ||
169: active_stacks[cpu_number()] == old_act->thread->kernel_stack);
170: assert (get_preemption_level() == 1);
171: check_simple_locks();
172:
173: /* Our context might wake up on another processor, so we must
174: * not keep hot state in our FPU, it must go back to the pcb
175: * so that it can be found by the other if needed
176: */
177: if(real_ncpus > 1) { /* This is potentially slow, so only do when actually SMP */
178: fpu_save(); /* Save floating point if used */
179: vec_save(); /* Save vector if used */
180: }
181:
182: #if DEBUG
183: if (watchacts & WA_PCB) {
184: printf("switch_context(0x%08x, 0x%x, 0x%08x)\n",
185: old,continuation,new);
186: }
187: #endif /* DEBUG */
188:
189: /*
190: * We do not have to worry about the PMAP module, so switch.
191: *
192: * We must not use top_act->map since this may not be the actual
193: * task map, but the map being used for a klcopyin/out.
194: */
195:
196: new_pmap = new_act->task->map->pmap;
197: if (old_act->task->map->pmap != new_pmap) {
198: pmap_switch(new_pmap);
199: }
200:
201: /* Sanity check - is the stack pointer inside the stack that
202: * we're about to switch to? Is the execution address within
203: * the kernel's VM space??
204: */
205: #if 0
206: printf("************* stack=%08X; R1=%08X; LR=%08X; old=%08X; cont=%08X; new=%08X\n",
207: new->kernel_stack, new_act->mact.pcb->ss.r1,
208: new_act->mact.pcb->ss.lr, old, continuation, new); /* (TEST/DEBUG) */
209: assert((new->kernel_stack < new_act->mact.pcb->ss.r1) &&
210: ((unsigned int)STACK_IKS(new->kernel_stack) >
211: new_act->mact.pcb->ss.r1));
212: assert(new_act->mact.pcb->ss.lr < VM_MAX_KERNEL_ADDRESS);
213: #endif
214:
215:
216: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_SCHED) | DBG_FUNC_NONE,
217: (int)old, (int)new, old->sched_pri, new->sched_pri, 0);
218:
219:
220: retval = Switch_context(old, continuation, new);
221: assert(retval != (struct thread_shuttle*)NULL);
222:
223: /* We've returned from having switched context, so we should be
224: * back in the original context.
225: */
226:
227: return retval;
228: }
229:
230: /*
231: * Alter the thread's state so that a following thread_exception_return
232: * will make the thread return 'retval' from a syscall.
233: */
234: void
235: thread_set_syscall_return(
236: struct thread_shuttle *thread,
237: kern_return_t retval)
238: {
239: struct ppc_saved_state *ssp = &thread->top_act->mact.pcb->ss;
240:
241: #if MACH_ASSERT
242: if (watchacts & WA_PCB)
243: printf("thread_set_syscall_return(thr=%x,retval=%d)\n", thread,retval);
244: #endif /* MACH_ASSERT */
245:
246: ssp->r3 = retval;
247: }
248:
249: /*
250: * Initialize the machine-dependent state for a new thread.
251: */
252: kern_return_t
253: thread_machine_create(
254: struct thread_shuttle *thread,
255: thread_act_t thr_act,
256: void (*start_pos)(void))
257: {
258:
259: savearea *sv; /* Pointer to newly allocated savearea */
260: unsigned int *CIsTooLimited, i;
261:
262:
263: #if MACH_ASSERT
264: if (watchacts & WA_PCB)
265: printf("thread_machine_create(thr=%x,thr_act=%x,st=%x)\n", thread, thr_act, start_pos);
266: #endif /* MACH_ASSERT */
267:
268: hw_atomic_add(&saveanchor.saveneed, 4); /* Account for the number of saveareas we think we "need"
269: for this activation */
270: assert(thr_act->mact.pcb == (pcb_t)0); /* Make sure there was no previous savearea */
271:
272: sv = save_alloc(); /* Go get us a savearea */
273:
274: bzero((char *) sv, sizeof(struct pcb)); /* Clear out the whole shebang */
275:
276: sv->save_act = thr_act; /* Set who owns it */
277: /* XXX: TO BE REMOVED WA for AltiVec compiler bug */
278: sv->save_vrsave = 0xffffffff;
279: thr_act->mact.pcb = (pcb_t)sv; /* Point to the save area */
280:
281: thread->kernel_stack = (int)stack_alloc(thread,start_pos); /* Allocate our kernel stack */
282: assert(thread->kernel_stack); /* Make sure we got it */
283:
284: #if MACH_ASSERT
285: if (watchacts & WA_PCB)
286: printf("pcb_init(%x) pcb=%x\n", thr_act, sv);
287: #endif /* MACH_ASSERT */
288: /*
289: * User threads will pull their context from the pcb when first
290: * returning to user mode, so fill in all the necessary values.
291: * Kernel threads are initialized from the save state structure
292: * at the base of the kernel stack (see stack_attach()).
293: */
294:
295: sv->save_srr1 = MSR_EXPORT_MASK_SET; /* Set the default user MSR */
296:
297: CIsTooLimited = (unsigned int *)(&sv->save_sr0); /* Make a pointer 'cause C can't cast on the left */
298: for(i=0; i<16; i++) { /* Initialize all SRs */
299: CIsTooLimited[i] = SEG_REG_PROT | (i << 20) | thr_act->task->map->pmap->space; /* Set the SR value */
300: }
301: sv->save_sr_copyin = SEG_REG_PROT | (SR_COPYIN_NUM<<20) | thr_act->task->map->pmap->space; /* Default the copyin */
302:
303: return(KERN_SUCCESS);
304: }
305:
306: /*
307: * Machine-dependent cleanup prior to destroying a thread
308: */
309: void
310: thread_machine_destroy( thread_t thread )
311: {
312: spl_t s;
313:
314: assert(thread->kernel_stack);
315: s = splsched();
316: stack_free(thread);
317: splx(s);
318: }
319:
320: /*
321: * flush out any lazily evaluated HW state in the
322: * owning thread's context, before termination.
323: */
324: void
325: thread_machine_flush( thread_act_t cur_act )
326: {
327: }
328:
329: /*
330: * Number of times we needed to swap an activation back in before
331: * switching to it.
332: */
333: int switch_act_swapins = 0;
334:
335: /*
336: * machine_switch_act
337: *
338: * Machine-dependent details of activation switching. Called with
339: * RPC locks held and preemption disabled.
340: */
341: void
342: machine_switch_act(
343: thread_t thread,
344: thread_act_t old,
345: thread_act_t new,
346: int cpu)
347: {
348: pmap_t new_pmap;
349:
350: /* Our context might wake up on another processor, so we must
351: * not keep hot state in our FPU, it must go back to the pcb
352: * so that it can be found by the other if needed
353: */
354: if(real_ncpus > 1) { /* This is potentially slow, so only do when actually SMP */
355: fpu_save(); /* Save floating point if used */
356: vec_save(); /* Save vector if used */
357: }
358:
359: active_stacks[cpu] = thread->kernel_stack;
360:
361: ast_context(new, cpu);
362:
363: /* Activations might have different pmaps
364: * (process->kernel->server, for example).
365: * Change space if needed
366: */
367: new_pmap = new->task->map->pmap;
368: if (old->task->map->pmap != new_pmap) {
369: pmap_switch(new_pmap);
370: }
371: }
372:
373: void
374: pcb_user_to_kernel(thread_act_t act)
375: {
376:
377: return; /* Not needed, I hope... */
378: }
379:
380:
381: /*
382: * act_machine_sv_free
383: * release saveareas associated with an act. if flag is true, release
384: * user level savearea(s) too, else don't
385: *
386: * this code cannot block so we call the proper save area free routine
387: */
388: void
389: act_machine_sv_free(thread_act_t act)
390: {
391: register pcb_t pcb,userpcb,npcb;
392: register savearea *svp;
393: register int i;
394:
395: /*
396: * This next bit insures that any live facility context for this thread is discarded on every processor
397: * that may have it. We go through all per-processor blocks and zero the facility owner if
398: * it is the thread being destroyed. This needs to be done via a compare-and-swap because
399: * some other processor could change the owner while we are clearing it. It turns out that
400: * this is the only place where we need the interlock, normal use of the owner field is cpu-local
401: * and doesn't need the interlock. Because we are called during termintation, and a thread
402: * terminates itself, the context on other processors has been saved (because we save it as
403: * part of the context switch), even if it is still considered live. Since the dead thread is
404: * not running elsewhere, and the context is saved, any other processor looking at the owner
405: * field will not attempt to save context again, meaning that it doesn't matter if the owner
406: * changes out from under it.
407: */
408:
409: /*
410: * free VMX and FPU saveareas. do not free user save areas.
411: * user VMX and FPU saveareas, if any, i'm told are last in
412: * the chain so we just stop if we find them
413: * we identify user VMX and FPU saveareas when we find a pcb
414: * with a save level of 0. we identify user regular save
415: * areas when we find one with MSR_PR set
416: */
417:
418: pcb = act->mact.VMX_pcb; /* Get the top vector savearea */
419: while(pcb) { /* Any VMX saved state? */
420: svp = (savearea *)pcb; /* save lots of casting later */
421: if (svp->save_level_vec == 0) break; /* done when hit user if any */
422: pcb = (pcb_t)svp->save_prev_vector; /* Get one underneath our's */
423: svp->save_flags &= ~SAVvmxvalid; /* Clear the VMX flag */
424: if(!(svp->save_flags & SAVinuse)) { /* Anyone left with this one? */
425:
426: save_ret(svp); /* release it */
427: }
428: }
429: act->mact.VMX_pcb = pcb;
430: if (act->mact.VMX_lvl != 0) {
431: for(i=0; i < real_ncpus; i++) { /* Cycle through processors */
432: (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].VMX_thread); /* Clear if ours */
433: }
434: }
435:
436: pcb = act->mact.FPU_pcb; /* Get the top floating point savearea */
437: while(pcb) { /* Any floating point saved state? */
438: svp = (savearea *)pcb;
439: if (svp->save_level_fp == 0) break; /* done when hit user if any */
440: pcb = (pcb_t)svp->save_prev_float; /* Get one underneath our's */
441: svp->save_flags &= ~SAVfpuvalid; /* Clear the floating point flag */
442: if(!(svp->save_flags & SAVinuse)) { /* Anyone left with this one? */
443: save_ret(svp); /* Nope, release it */
444: }
445: }
446: act->mact.FPU_pcb = pcb;
447: if (act->mact.FPU_lvl != 0) {
448: for(i=0; i < real_ncpus; i++) { /* Cycle through processors */
449: (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].FPU_thread); /* Clear if ours */
450: }
451: }
452:
453: /*
454: * free all regular saveareas except a user savearea, if any
455: */
456:
457: pcb = act->mact.pcb;
458: userpcb = (pcb_t)0;
459: while(pcb) {
460: svp = (savearea *)pcb;
461: if ((svp->save_srr1 & MASK(MSR_PR))) {
462: assert(userpcb == (pcb_t)0);
463: userpcb = pcb;
464: svp = (savearea *)userpcb;
465: npcb = (pcb_t)svp->save_prev;
466: svp->save_prev = (struct savearea *)0;
467: } else {
468: svp->save_flags = 0;
469: npcb = (pcb_t)svp->save_prev;
470: save_ret(svp);
471: }
472: pcb = npcb;
473: }
474: act->mact.pcb = userpcb;
475:
476: }
477:
478: /*
479: * act_machine_destroy: Shutdown any state associated with a thread pcb.
480: */
481: void
482: act_machine_destroy(thread_act_t act)
483: {
484: register pcb_t pcb, opcb;
485: int i;
486:
487: #if MACH_ASSERT
488: if (watchacts & WA_PCB)
489: printf("act_machine_destroy(0x%x)\n", act);
490: #endif /* MACH_ASSERT */
491:
492: if(act->mact.bbDescAddr) { /* Check if the Blue box assist is active */
493: (void) vm_map_unwire(act->map, /* Unwire the descriptor in user's address space */
494: (vm_offset_t)act->mact.bbUserDA,
495: (vm_offset_t)act->mact.bbUserDA + PAGE_SIZE,
496: FALSE);
497:
498: kmem_free(kernel_map, (vm_offset_t)act->mact.bbDescAddr, PAGE_SIZE); /* Release the page */
499:
500: act->mact.bbDescAddr = 0; /* Clear kernel pointer to it */
501: act->mact.bbUserDA = 0; /* Clear user pointer to it */
502: act->mact.bbTableStart = 0; /* Clear start of table address */
503:
504: }
505:
506: /*
507: * This next bit insures that any live facility context for this thread is discarded on every processor
508: * that may have it. We go through all per-processor blocks and zero the facility owner if
509: * it is the thread being destroyed. This needs to be done via a compare-and-swap because
510: * some other processor could change the owner while we are clearing it. It turns out that
511: * this is the only place where we need the interlock, normal use of the owner field is cpu-local
512: * and doesn't need the interlock. Because we are called during termintation, and a thread
513: * terminates itself, the context on other processors has been saved (because we save it as
514: * part of the context switch), even if it is still considered live. Since the dead thread is
515: * not running elsewhere, and the context is saved, any other processor looking at the owner
516: * field will not attempt to save context again, meaning that it doesn't matter if the owner
517: * changes out from under it.
518: */
519:
520: for(i=0; i < real_ncpus; i++) { /* Cycle through processors */
521: (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].FPU_thread); /* Clear if ours */
522: (void)hw_compare_and_store((unsigned int)act, 0, &per_proc_info[i].VMX_thread); /* Clear if ours */
523: }
524:
525: pcb = act->mact.VMX_pcb; /* Get the top vector savearea */
526: while(pcb) { /* Any VMX saved state? */
527: opcb = pcb; /* Save current savearea address */
528: pcb = (pcb_t)(((savearea *)pcb)->save_prev_vector); /* Get one underneath our's */
529: ((savearea *)opcb)->save_flags &= ~SAVvmxvalid; /* Clear the VMX flag */
530:
531: if(!(((savearea *)opcb)->save_flags & SAVinuse)) { /* Anyone left with this one? */
532: save_release((savearea *)opcb); /* Nope, release it */
533: }
534: }
535: act->mact.VMX_pcb = (pcb_t)0; /* Clear pointer */
536:
537: pcb = act->mact.FPU_pcb; /* Get the top floating point savearea */
538: while(pcb) { /* Any floating point saved state? */
539: opcb = pcb; /* Save current savearea address */
540: pcb = (pcb_t)(((savearea *)pcb)->save_prev_float); /* Get one underneath our's */
541: ((savearea *)opcb)->save_flags &= ~SAVfpuvalid; /* Clear the floating point flag */
542:
543: if(!(((savearea *)opcb)->save_flags & SAVinuse)) { /* Anyone left with this one? */
544: save_release((savearea *)opcb); /* Nope, release it */
545: }
546: }
547: act->mact.FPU_pcb = (pcb_t)0; /* Clear pointer */
548:
549: pcb = act->mact.pcb; /* Get the top normal savearea */
550: act->mact.pcb = (pcb_t)0; /* Clear pointer */
551:
552: while(pcb) { /* Any normal saved state left? */
553: opcb = pcb; /* Keep track of what we're working on */
554: pcb = (pcb_t)(((savearea *)pcb)->save_prev); /* Get one underneath our's */
555:
556: ((savearea *)opcb)->save_flags = 0; /* Clear all flags since we release this in any case */
557: save_release((savearea *)opcb); /* Release this one */
558: }
559:
560: hw_atomic_sub(&saveanchor.saveneed, 4); /* Unaccount for the number of saveareas we think we "need"
561: for this activation */
562: }
563:
564: kern_return_t
565: act_machine_create(task_t task, thread_act_t thr_act)
566: {
567: /*
568: * Clear & Init the pcb (sets up user-mode s regs)
569: * We don't use this anymore.
570: */
571:
572: register pcb_t pcb;
573: register int i;
574: unsigned int *CIsTooLimited;
575: pmap_t pmap;
576:
577: return KERN_SUCCESS;
578: }
579:
580: void act_machine_init()
581: {
582: #if MACH_ASSERT
583: if (watchacts & WA_PCB)
584: printf("act_machine_init()\n");
585: #endif /* MACH_ASSERT */
586:
587: /* Good to verify these once */
588: assert( THREAD_MACHINE_STATE_MAX <= THREAD_STATE_MAX );
589:
590: assert( THREAD_STATE_MAX >= PPC_THREAD_STATE_COUNT );
591: assert( THREAD_STATE_MAX >= PPC_EXCEPTION_STATE_COUNT );
592: assert( THREAD_STATE_MAX >= PPC_FLOAT_STATE_COUNT );
593: assert( THREAD_STATE_MAX >= sizeof(struct ppc_saved_state)/sizeof(int));
594:
595: /*
596: * If we start using kernel activations,
597: * would normally create kernel_thread_pool here,
598: * populating it from the act_zone
599: */
600: }
601:
602: void
603: act_machine_return(int code)
604: {
605: thread_act_t thr_act = current_act();
606: thread_act_t cur_act;
607: thread_t cur_thread = current_thread();
608: struct ipc_port *iplock;
609:
610: #if MACH_ASSERT
611: if (watchacts & WA_EXIT)
612: printf("act_machine_return(0x%x) cur_act=%x(%d) thr=%x(%d)\n",
613: code, thr_act, thr_act->ref_count,
614: thr_act->thread, thr_act->thread
615: ? thr_act->thread->ref_count : 0);
616: #endif /* MACH_ASSERT */
617:
618:
619: /*
620: * This code is called with nothing locked.
621: * It also returns with nothing locked, if it returns.
622: *
623: * This routine terminates the current thread activation.
624: * If this is the only activation associated with its
625: * thread shuttle, then the entire thread (shuttle plus
626: * activation) is terminated.
627: */
628: assert( code == KERN_TERMINATED );
629: assert( thr_act );
630:
631: act_lock_thread(thr_act);
632:
633: #ifdef CALLOUT_RPC_MODEL
634: /*
635: * JMM - This needs to get cleaned up to work under the much simpler
636: * return (instead of callout model).
637: */
638: if (thr_act->thread->top_act != thr_act) {
639: /*
640: * this is not the top activation;
641: * if possible, we should clone the shuttle so that
642: * both the root RPC-chain and the soon-to-be-orphaned
643: * RPC-chain have shuttles
644: *
645: * JMM - Cloning is a horrible idea! Instead we should alert
646: * the pieces upstream to return the shuttle. We will use
647: * alerts for this.
648: */
649: act_unlock_thread(thr_act);
650: panic("act_machine_return: ORPHAN CASE NOT YET IMPLEMENTED");
651: }
652:
653: if (thr_act->lower != THR_ACT_NULL) {
654: /* terminate the entire thread (shuttle plus activation) */
655: /* terminate only this activation, send an appropriate */
656: /* return code back to the activation that invoked us. */
657: iplock = thr_act->pool_port; /* remember for unlock call */
658: thr_act->lower->alerts |= SERVER_TERMINATED;
659: install_special_handler(thr_act->lower);
660:
661: /* Return to previous act with error code */
662:
663: act_locked_act_reference(thr_act); /* keep it around */
664: act_switch_swapcheck(cur_thread, (ipc_port_t)0);
665:
666: (void) switch_act(THR_ACT_NULL);
667: /* assert(thr_act->ref_count == 0); */ /* XXX */
668: cur_act = cur_thread->top_act;
669: MACH_RPC_RET(cur_act) = KERN_RPC_SERVER_TERMINATED;
670: machine_kernel_stack_init(cur_thread,
671: (void (*)(void)) mach_rpc_return_error);
672: /*
673: * The following unlocks must be done separately since fields
674: * used by `act_unlock_thread()' have been cleared, meaning
675: * that it would not release all of the appropriate locks.
676: */
677: rpc_unlock(cur_thread);
678: if (iplock) ip_unlock(iplock); /* must be done separately */
679: act_unlock(thr_act);
680: act_deallocate(thr_act); /* free it */
681: Load_context(cur_thread);
682: /*NOTREACHED*/
683:
684: panic("act_machine_return: TALKING ZOMBIE! (2)");
685: }
686:
687: #endif /* CALLOUT_RPC_MODEL */
688:
689: /* This is the only activation attached to the shuttle... */
690:
691: assert(thr_act->thread->top_act == thr_act);
692: act_unlock_thread(thr_act);
693: thread_terminate_self();
694:
695: /*NOTREACHED*/
696: panic("act_machine_return: TALKING ZOMBIE! (1)");
697: }
698:
699: void
700: thread_machine_set_current(struct thread_shuttle *thread)
701: {
702: register int my_cpu = cpu_number();
703:
704: cpu_data[my_cpu].active_thread = thread;
705:
706: active_kloaded[my_cpu] = thread->top_act->kernel_loaded ? thread->top_act : THR_ACT_NULL;
707: }
708:
709: void
710: thread_machine_init(void)
711: {
712: #ifdef MACHINE_STACK
713: #if KERNEL_STACK_SIZE > PPC_PGBYTES
714: panic("KERNEL_STACK_SIZE can't be greater than PPC_PGBYTES\n");
715: #endif
716: #endif
717: }
718:
719: #if MACH_ASSERT
720: void
721: dump_pcb(pcb_t pcb)
722: {
723: printf("pcb @ %8.8x:\n", pcb);
724: #if DEBUG
725: regDump(&pcb->ss);
726: #endif /* DEBUG */
727: }
728:
729: void
730: dump_thread(thread_t th)
731: {
732: printf(" thread @ 0x%x:\n", th);
733: }
734:
735: int
736: dump_act(thread_act_t thr_act)
737: {
738: if (!thr_act)
739: return(0);
740:
741: printf("thr_act(0x%x)(%d): thread=%x(%d) task=%x(%d)\n",
742: thr_act, thr_act->ref_count,
743: thr_act->thread, thr_act->thread ? thr_act->thread->ref_count:0,
744: thr_act->task, thr_act->task ? thr_act->task->ref_count : 0);
745:
746: printf("\talerts=%x mask=%x susp=%x active=%x hi=%x lo=%x\n",
747: thr_act->alerts, thr_act->alert_mask,
748: thr_act->suspend_count, thr_act->active,
749: thr_act->higher, thr_act->lower);
750:
751: return((int)thr_act);
752: }
753:
754: #endif
755:
756: unsigned int
757: get_useraddr()
758: {
759:
760: thread_act_t thr_act = current_act();
761:
762: return(thr_act->mact.pcb->ss.srr0);
763: }
764:
765: /*
766: * detach and return a kernel stack from a thread
767: */
768:
769: vm_offset_t
770: stack_detach(thread_t thread)
771: {
772: vm_offset_t stack;
773:
774: #ifdef KDEBUG
775: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_DETACH),
776: thread, thread->priority,
777: thread->sched_pri, 0,
778: 0);
779: #endif
780: stack = thread->kernel_stack;
781: thread->kernel_stack = 0;
782: return(stack);
783: }
784:
785: /*
786: * attach a kernel stack to a thread and initialize it
787: *
788: * attaches a stack to a thread. if there is no save
789: * area we allocate one. the top save area is then
790: * loaded with the pc (continuation address), the initial
791: * stack pointer, and a std kernel MSR. if the top
792: * save area is the user save area bad things will
793: * happen
794: *
795: */
796:
797: void
798: stack_attach(struct thread_shuttle *thread,
799: vm_offset_t stack,
800: void (*continuation)(void))
801: {
802: thread_act_t thr_act;
803: unsigned int *kss;
804: struct savearea *sv;
805:
806: #ifdef KDEBUG
807: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_ATTACH),
808: thread, thread->priority,
809: thread->sched_pri, continuation,
810: 0);
811: #endif
812:
813: assert(stack);
814: kss = (unsigned int *)STACK_IKS(stack);
815: thread->kernel_stack = stack;
816:
817: /* during initialization we sometimes do not have an
818: activation. in that case do not do anything */
819: if ((thr_act = thread->top_act) != 0) {
820: sv = save_get(); /* cannot block */
821: // bzero((char *) sv, sizeof(struct pcb));
822: sv->save_act = thr_act;
823: sv->save_prev = (struct savearea *)thr_act->mact.pcb;
824: thr_act->mact.pcb = (pcb_t)sv;
825:
826: sv->save_srr0 = (unsigned int) continuation;
827: /* sv->save_r3 = ARG ? */
828: sv->save_r1 = (vm_offset_t)((int)kss - KF_SIZE);
829: sv->save_srr1 = MSR_SUPERVISOR_INT_ON;
830: *((int *)sv->save_r1) = 0;
831: thr_act->mact.ksp = 0;
832: }
833:
834: return;
835: }
836:
837: /*
838: * move a stack from old to new thread
839: */
840:
841: void
842: stack_handoff(thread_t old,
843: thread_t new)
844: {
845:
846: vm_offset_t stack;
847: pmap_t new_pmap;
848:
849: assert(new->top_act);
850: assert(old->top_act);
851:
852: stack = stack_detach(old);
853: new->kernel_stack = stack;
854:
855: #if NCPUS > 1
856: if (real_ncpus > 1) {
857: fpu_save();
858: vec_save();
859: }
860: #endif
861:
862: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_STACK_HANDOFF) | DBG_FUNC_NONE,
863: (int)old, (int)new, old->sched_pri, new->sched_pri, 0);
864:
865: new_pmap = new->top_act->task->map->pmap;
866: if (old->top_act->task->map->pmap != new_pmap) {
867: pmap_switch(new_pmap);
868: }
869:
870: thread_machine_set_current(new);
871: active_stacks[cpu_number()] = new->kernel_stack;
872: per_proc_info[cpu_number()].Uassist = new->top_act->mact.cthread_self;
873: return;
874: }
875:
876: /*
877: * clean and initialize the current kernel stack and go to
878: * the given continuation routine
879: */
880:
881: void
882: call_continuation(void (*continuation)(void) )
883: {
884:
885: unsigned int *kss;
886: vm_offset_t tsp;
887:
888: assert(current_thread()->kernel_stack);
889: kss = (unsigned int *)STACK_IKS(current_thread()->kernel_stack);
890: assert(continuation);
891:
892: tsp = (vm_offset_t)((int)kss - KF_SIZE);
893: assert(tsp);
894: *((int *)tsp) = 0;
895:
896: Call_continuation(continuation, tsp);
897:
898: return;
899: }
900:
901: void
902: thread_swapin_mach_alloc(thread_t thread)
903: {
904: struct savearea *sv;
905:
906: assert(thread->top_act->mact.pcb == 0);
907:
908: sv = save_alloc();
909: assert(sv);
910: // bzero((char *) sv, sizeof(struct pcb));
911: sv->save_act = thread->top_act;
912: thread->top_act->mact.pcb = (pcb_t)sv;
913:
914: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.